从文件中读取yuv和h264数据

1.从文件中读取h264数据

参考ffmpeg avc.c写的从文件中一帧帧读取h.264数据的demo

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
 
char* filebuf_;
const char* pbuf_;
int filesize_;
unsigned char is_stop_;
 
const char* AVCFindStartCodeInternal(const char *p, const char *end)
{
    const char *a = p +  - ((ptrdiff_t)p & );
 
    for (end -= ; p < a && p < end; p++) {
        if (p[] ==  && p[] ==  && p[] == )
            return p;
    }
 
    for (end -= ; p < end; p += ) {
        unsigned int x = *(const unsigned int*)p;
        //      if ((x - 0x01000100) & (~x) & 0x80008000) // little endian
        //      if ((x - 0x00010001) & (~x) & 0x00800080) // big endian
        if ((x - 0x01010101) & (~x) & 0x80808080) { // generic
            if (p[] == ) {
                if (p[] ==  && p[] == )
                    return p;
                if (p[] ==  && p[] == )
                    return p + ;
            }
            if (p[] == ) {
                if (p[] ==  && p[] == )
                    return p + ;
                if (p[] ==  && p[] == )
                    return p + ;
            }
        }
    }
 
    for (end += ; p < end; p++) {
        if (p[] ==  && p[] ==  && p[] == )
            return p;
    }
 
    return end + ;
}
 
const char* AVCFindStartCode(const char *p, const char *end)
{
    const char *out = AVCFindStartCodeInternal(p, end);
    if (p<out && out<end && !out[-]) out--;
    return out;
}
 
H264FrameReader_Init(const char* filename)
{
    FILE* fp = fopen(filename, "rb");
    filebuf_ = ;
    filesize_ = ;
 
    if (fp)
    {
        int retval = ;
        fseek(fp, , SEEK_END);
        filesize_ = ftell(fp);
        fseek(fp, , SEEK_SET);
 
        filebuf_ = (char*)malloc(filesize_);
        retval = fread(filebuf_, , filesize_, fp);
 
        fclose(fp);
    }
    pbuf_ = filebuf_;
}
 
H264FrameReader_Free()
{
    free(filebuf_);
}
 
H264FrameReader_ReadFrame(char* outBuf, int* outBufSize)
{
    char* pbufout = ;
    const char *p = ;
    const char *end = ;
    const char *nal_start, *nal_end;
 
    char startcodebuf[] = { 0x00, 0x00, 0x00, 0x01 };
    if (pbuf_ >= filebuf_ + filesize_)
    {
        return ;
    }
 
    pbufout = outBuf;
    p = pbuf_;
    end = filebuf_ + filesize_;
 
    nal_start = AVCFindStartCode(p, end);
    while (nal_start < end)
    {
        unsigned int nal_size = ;
        unsigned char nal_type = ;
 
        while (!*(nal_start++));
 
        nal_end = AVCFindStartCode(nal_start, end);
 
        nal_size = nal_end - nal_start;
        nal_type = nal_start[] & 0x1f;
 
        memcpy(pbufout, startcodebuf, );
        pbufout += ;
        memcpy(pbufout, nal_start, nal_size);
        pbufout += nal_size;
 
        nal_start = nal_end;
        break;
    }
 
    *outBufSize = pbufout - outBuf;
    pbuf_ = nal_start;
 
    return ;
}
 
int main(int argc, char **argv)
{
    unsigned long max_size =  * ;
    int tmpbuf_len = ;
    int current_read_len = ;
    char* tmpbuf = (char*)malloc(max_size * );
 
    FILE *fp = fopen("out.h264", "wb+");
    if (!fp)
    {
        printf("open file error\n");
        return -;
    }
 
    H264FrameReader_Init("test.h264");
    printf("file size = %d\n", filesize_);
    while (current_read_len < filesize_)
    {
        if (H264FrameReader_ReadFrame(tmpbuf, &tmpbuf_len))
        {
            printf("tmpbuf_len = %d\n", tmpbuf_len);
            fwrite(tmpbuf, tmpbuf_len, , fp);
            current_read_len += tmpbuf_len;
        }
    }
    fclose(fp);
    H264FrameReader_Free();
 
    return ;
}

2.从文件中读取yuv数据

从planar yuv420 文件中读取每一帧数据，从nvenc demo中参考来的，原理如下

1.通过fseek和ftell计算出文件的大小

2.通过yuv的分辨率可以计算出每一帧yuv数据的大小

3.通过上面两步可以计算出文件中包含多少帧的yuv数据，然后通过每一帧数据在文件中的偏移，就可以读出该帧数据

int loadframe(uint8_t *yuvInput[], FILE *hInputYUVFile, uint32_t frmIdx, uint32_t width, uint32_t height)
{
    uint64_t fileOffset;
    uint32_t result;
    uint32_t dwInFrameSize = ;
    int anFrameSize[] = {};
 
    dwInFrameSize = width * height *  / ;
    anFrameSize[] = width * height;
    anFrameSize[] = anFrameSize[] = width * height / ;
 
    //当前帧在文件中的偏移量：当前index * 每一帧的大小
    fileOffset = (uint64_t)dwInFrameSize * frmIdx;
    //seek到偏移处
    result = _fseeki64(hInputYUVFile, fileOffset, SEEK_SET);
    if (result == -)
    {
        return -;
    }
    //把当前帧的Y、U、V数据分别读取到对应的数组中
    fread(yuvInput[], anFrameSize[], , hInputYUVFile);
    fread(yuvInput[], anFrameSize[], , hInputYUVFile);
    fread(yuvInput[], anFrameSize[], , hInputYUVFile);
 
    return ;
}
 
int main()
{
 
    infp = fopen("yb.yuv", "rb");
    if (!infp)
    {
        printf("open in file failed\n");
        return -;
    }
 
    uint8_t *yuv[];
    int lumaPlaneSize, chromaPlaneSize;
 
    lumaPlaneSize =  * ;
    chromaPlaneSize = lumaPlaneSize >> ;
 
    yuv[] = new uint8_t[lumaPlaneSize];
    yuv[] = new uint8_t[chromaPlaneSize];
    yuv[] = new uint8_t[chromaPlaneSize];
    memset(yuv[], , lumaPlaneSize);
    memset(yuv[], , chromaPlaneSize);
    memset(yuv[], , chromaPlaneSize);
 
    uint64_t file_size = ;
 
    _fseeki64(infp, , SEEK_END);
    file_size = _ftelli64(infp);
    _fseeki64(infp, , SEEK_SET);
    int totalFrames = file_size / (lumaPlaneSize + chromaPlaneSize + chromaPlaneSize);
 
    //遍历每一帧YUV数据
    for (int frm = ; frm < totalFrames; frm++)
    {
        loadframe(yuv, infp, frm, , );
        //处理yuv数据
        //....
    }
 
    return ;
}