Flv解复用代码解析

最新推荐文章于 2023-01-06 10:31:03 发布
最新推荐文章于 2023-01-06 10:31:03 发布
阅读量3w 收藏 12
点赞数 16
分类专栏： 流媒体协议 文章标签： 音视频 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41910694/article/details/115224754
版权

Flv解复用代码解析

目录

  1. 总体流程
    1. main函数
    2. 处理函数process
    3. 解析函数
  2. 解析Flv header和Flv Tag
    1. 解析Flv header
    2. 解析Flv Tag
    3. 解析MetaData Tag
  3. dump H264、AAC和FLV

GitHub源码地址：flv-parser
Flv格式分析：Flv格式分析

1. 总体流程

  1. flv-parser项目能够解析flv格式文件，分离出H264和AAC数据，最后组装回flv格式文件并输出。

1. main函数

  1. 流程：
    1. 读取输⼊⽂件（flv类型的视频⽂件）
    2. 调⽤Process进⾏处理
    3. 退出
int main(int argc, char *argv[]) { //argv[1]是开始的第一个输入参数
    cout << "this is FLV parser test program!\ninput: flv, output:flv\n";

    if (argc != 3) {
        cout << "FlvParser.exe [input flv] [output flv]" << endl;
        return 0;
    }

    fstream fin; //fstream包含读写操作，对打开的文件可进行读写操作
    fin.open(argv[1], ios_base::in | ios_base::binary); //以二进制文件格式进行输入
    if (!fin)
        return 0;

    process(fin, argv[2]); //argv[2]，输出flv文件

    fin.close();

    return 1;
}

2. 处理函数process

  1. 流程：
    1. 读取Flv⽂件
    2. 开始解析
    3. 打印解析信息
    4. 把解析之后的数据输出到另外⼀个⽂件中
void process(fstream &fin, const char *filename) {
    CFlvParser parser;

    int nBufSize = 2 * 1024 * 1024;
    int nFlvPos = 0;
    unsigned char *pBuf, *pBak; //用于存储读取的文本数据，不会有负数，所以使用unsigned
    pBuf = new unsigned char[nBufSize]; //从堆中创建2M内存
    pBak = new unsigned char[nBufSize];

    while (1) {
        int nReadNum = 0; //总读取size
        int nUsedLen = 0; //已使用的size
        fin.read((char *) pBuf + nFlvPos, nBufSize - nFlvPos); //读取2M数据
        nReadNum = fin.gcount(); //获取读取的size
        if (nReadNum == 0) //读取为0，说明文件已经读取完
            break;
        nFlvPos += nReadNum; //移动偏移量

        parser.parse(pBuf, nFlvPos, nUsedLen);
        if (nFlvPos != nUsedLen) {
            memcpy(pBak, pBuf + nUsedLen, nFlvPos - nUsedLen); //将未使用的size复制到pBak
            memcpy(pBuf, pBak, nFlvPos - nUsedLen); //从pBak复制回pBuf
        }
        nFlvPos -= nUsedLen;
    }
    parser.PrintInfo(); //打印解析信息
    parser.DumpH264("parser.264"); //dump h264文件
    parser.DumpAAC("parser.aac"); //dump aac文件

    //dump into flv
    parser.DumpFlv(filename); //输出flv格式文件

    delete[]pBak; //释放内存，使用delete[]
    delete[]pBuf;
}

3. 解析函数

  1. 流程：
    1. 解析flv的头部
    2. 解析flv的Tag
int CFlvParser::parse(unsigned char *pBuf, int nBufSize, int &nUsedLen) {
    int nOffset = 0;

    if (m_pFlvHeader == 0) {
        CheckBuffer(9); //flv header头为9字节
        m_pFlvHeader = create_flvHeader(pBuf + nOffset); //创建FLV header
        nOffset += m_pFlvHeader->m_headSize;
    }

    while (1) {
        CheckBuffer(15); // previousTagSize(4字节) + tag header(11字节)
        int nPrevSize = show_u32(pBuf + nOffset);
        nOffset += 4;

        Tag *pTag = create_tag(pBuf + nOffset, nBufSize - nOffset); //获取一个flv tag
        if (pTag == NULL) {
            nOffset -= 4; //如果tag为null，复原offset
            break;
        }
        nOffset += (11 + pTag->m_header.m_dataSize); //tag header + tag datasize

        m_tag.push_back(pTag);
    }

    nUsedLen = nOffset; //记录使用的size
    return 0;
}

2. 解析Flv header和Flv Tag

1. 解析Flv header

  1. flv header数据结构：
    typedef struct FlvHeader_s {
        int m_version;
        int m_haveVideo, m_haveAudio;
        int m_headSize;

        unsigned char *m_flvHeader;
    } FlvHeader;
  1. 解析Flv header
CFlvParser::FlvHeader *CFlvParser::create_flvHeader(unsigned char *pBuf) {
    FlvHeader *pHeader = new FlvHeader;
    pHeader->m_version = pBuf[3];
    pHeader->m_haveAudio = (pBuf[4] >> 2) & 0x01;    //是否有音频，音频标识在第5bit，比如 0000 0101，右移两位就是0000 01，& 0x01就可以得到值了
    pHeader->m_haveVideo = (pBuf[4] >> 0) & 0x01;    //是否有视频
    pHeader->m_headSize = show_u32(pBuf + 5);   //头部长度，从第6字节开始，所以需要移动5字节，flv header头为9字节

    pHeader->m_flvHeader = new unsigned char[pHeader->m_headSize];
    memcpy(pHeader->m_flvHeader, pBuf, pHeader->m_headSize);

    return pHeader;
}

2. 解析Flv Tag

  1. 先解析Tag header，再根据tag type匹配对应类型。
  2. 格式参考：Flv格式分析
CFlvParser::Tag *CFlvParser::create_tag(unsigned char *pBuf, int nLeftLen) {
    TagHeader header;   //开始解析标签头部
    header.m_type = show_u8(pBuf + 0);          //类型
    header.m_dataSize = show_u24(pBuf + 1);     //标签body的长度
    header.m_timeStamp = show_u24(pBuf + 4);    //时间戳 低24bit
    header.m_TSEx = show_u8(pBuf + 7);          //时间戳的扩展字段, 高8bit
    header.m_StreamID = show_u24(pBuf + 8);     //流id
    header.m_TotalTS =
            (unsigned int) ((header.m_TSEx << 24)) + header.m_timeStamp; //转换成uint32_t类型，nTSEx为高位，往左移动24位，然后加上nTimeStamp
    cout << "total TS : " << header.m_TotalTS << endl;
    //cout << "nLeftLen : " << nLeftLen << " , m_dataSize : " << pTag->header.m_dataSize << endl;
    if ((header.m_dataSize + 11) > nLeftLen) { //如果tag header + tag datasize长度大于nLeftLen
        return NULL;
    }

    Tag *pTag;
    switch (header.m_type) { //根据tag type匹配对应类型，格式参考blog：https://blog.csdn.net/weixin_41910694/article/details/109564752
        case 0x09:
            pTag = new CVideoTag(&header, pBuf, nLeftLen, this); //解析视频tag
            break;
        case 0x08:
            pTag = new CAudioTag(&header, pBuf, nLeftLen, this); //解析音频tag
            break;
        case 0x12:
            pTag = new CMetaDataTag(&header, pBuf, nLeftLen, this); //解析metadata tag
            break;
        default:
            pTag = new Tag();
            pTag->init(&header, pBuf, nLeftLen);
    }

    return pTag;
}
  1. 其中Tag的数据结构为：
    class Tag {
    public:
        Tag() : m_tagHeader(NULL), m_tagData(NULL), m_media(NULL), m_mediaLen(0) {}

        void init(TagHeader *pHeader, unsigned char *pBuf, int nLeftLen);

        TagHeader m_header;
        unsigned char *m_tagHeader; //记录tag header原始数据
        unsigned char *m_tagData; //记录tag data原始数据
        unsigned char *m_media;
        int m_mediaLen;
    };
  1. Tag Header数据结构为：
    struct TagHeader {
        int m_type;
        int m_dataSize;
        int m_timeStamp;
        int m_TSEx;
        int m_StreamID;

        unsigned int m_TotalTS;

        TagHeader() : m_type(0), m_dataSize(0), m_timeStamp(0), m_TSEx(0), m_StreamID(0), m_TotalTS(0) {}

        ~TagHeader() {}
    };
1. 解析Video Tag
  1. 当Tag header的type值为8时表示Video Tag，Video Tag数据结构为：
    class CVideoTag : public Tag {
    public:
        CVideoTag(TagHeader *pHeader, unsigned char *pBuf, int nLeftLen, CFlvParser *pParser);

        int m_frameType;
        int m_codecID;

        int parse_H264_tag(CFlvParser *pParser);

        int parse_H264_configuration(CFlvParser *pParser, unsigned char *pTagData);

        int parse_nalu(CFlvParser *pParser, unsigned char *pTagData);
    };
  1. Video Tag第1字节是4bit的帧类型和4bit的视频编码类型，如果视频编码类型为AVC则说明是h264的类型。
CFlvParser::CVideoTag::CVideoTag(TagHeader *pHeader, unsigned char *pBuf, int nLeftLen, CFlvParser *pParser) {
    init(pHeader, pBuf, nLeftLen); //存储tag header和tag data原始数据

    unsigned char *pd = m_tagData;
    m_frameType = (pd[0] & 0xf0) >> 4; //帧类型
    m_codecID = pd[0] & 0x0f;          //视频编码类型，值为7表示AVC
    if (m_header.m_type == 0x09 && m_codecID == 7) { //如果type=9并且codeId为7，那么表示h264
        parse_H264_tag(pParser); //解析h264 tag data
    }
}
  1. 第2字节表示AVCPacketType。
    1. 值为0表示AVC sequence header，解析方式
    2. 1表示AVC NALU。
  2. 按照不同的AVCPacketType进行解析。
int CFlvParser::CVideoTag::parse_H264_tag(CFlvParser *pParser) {
    unsigned char *pd = m_tagData; //pd[0]表示帧类型和编码ID
    //pd[1]表示AVCPacketType，值为0表示AVC sequence header，1表示AVC NALU
    int nAVCPacketType = pd[1];
    int nCompositionTime = CFlvParser::show_u24(pd + 2);

    if (nAVCPacketType == 0) { //AVCPacketType=0那么data数据为AVCDecoderConfigurationRecoder
        parse_H264_configuration(pParser, pd);
    } else if (nAVCPacketType == 1) { //AVCPacketType=1那么表示有一个或多个NALU
        parse_nalu(pParser, pd);
    } else {

    }
    return 1;
}
1. 解析AVCDecoderConfigurationRecoder
/**
AVCDecoderConfigurationRecord {
    uint32_t(8) configurationVersion = 1;  [0]
    uint32_t(8) AVCProfileIndication;       [1]
    uint32_t(8) profile_compatibility;      [2]
    uint32_t(8) AVCLevelIndication;         [3]
    bit(6) reserved = ‘111111’b;            [4]
    uint32_t(2) lengthSizeMinusOne;         [4] 计算方法是 1 + (lengthSizeMinusOne & 3)，实际计算结果一直是4
    bit(3) reserved = ‘111’b;                   [5]
    uint32_t(5) numOfSequenceParameterSets; [5] SPS 的个数，计算方法是 numOfSequenceParameterSets & 0x1F，实际计算结果一直为1
    for (i=0; i< numOfSequenceParameterSets; i++) {
        uint32_t(16) sequenceParameterSetLength ;   [6,7]
        bit(8*sequenceParameterSetLength) sequenceParameterSetNALUnit;
    }
    uint32_t(8) numOfPictureParameterSets;      PPS 的个数，一直为1
    for (i=0; i< numOfPictureParameterSets; i++) {
        uint32_t(16) pictureParameterSetLength;
        bit(8*pictureParameterSetLength) pictureParameterSetNALUnit;
    }
}
 */
int CFlvParser::CVideoTag::parse_H264_configuration(CFlvParser *pParser, unsigned char *pTagData) {
    unsigned char *pd = pTagData;
    // 跨过 Tag Data的VIDEODATA(1字节) AVCVIDEOPACKET(AVCPacketType(1字节) 和 CompositionTime(3字节) 5字节)
    pParser->m_nalUnitLength = (pd[9] & 0x03) + 1; //m_nalUnitLength = 1 + (lengthSizeMinusOne & 3)，表示NALU的长度

    int sps_size, pps_size;
    sps_size = CFlvParser::show_u16(pd + 11); //sequenceParameterSetLength
    pps_size = CFlvParser::show_u16(pd + 11 + (2 + sps_size) + 1); //pictureParameterSetLength

    m_mediaLen = 4 + sps_size + 4 + pps_size;
    m_media = new unsigned char[m_mediaLen];
    memcpy(m_media, &g_h264StartCode, 4);
    memcpy(m_media + 4, pd + 11 + 2, sps_size); //sequenceParameterSetNALUnit
    memcpy(m_media + 4 + sps_size, &g_h264StartCode, 4);
    memcpy(m_media + 4 + sps_size + 4, pd + 11 + 2 + sps_size + 2 + 1, pps_size); //pictureParameterSetNALUnit

    return 1;
}
  1. 其中m_nalUnitLength表示用几个字节来存储NALU的长度，因为一个tag可能包含多个nalu, 所以每个nalu前面有NalUnitLength字节表示每个nalu的长度
    a. 如果NALULengthSizeMinusOne是0，那么每个NALU使用一个字节的前缀来指定长度，那么每个NALU包的最大长度是255字节，
    b. 使用2个字节的前缀来指定长度，那么每个NALU包的最大长度是64K字节，但分辨率达到1280*720 的图像编码出的I帧，可能大于64K；
    c. 3字节是比较好的，但是因为一些原因（例如对齐）没有被广泛支持，因此4字节长度的前缀是目前使用最多的方式。
2. 解析NALU
int CFlvParser::CVideoTag::parse_nalu(CFlvParser *pParser, unsigned char *pTagData) {
    unsigned char *pd = pTagData;
    int nOffset = 0;

    m_media = new unsigned char[m_header.m_dataSize + 10];
    m_mediaLen = 0;

    nOffset = 5;
    while (1) {
        if (nOffset >= m_header.m_dataSize) //如果解析完了一个tag，跳出循环
            break;
        //一个tag可能包含多个nalu, 所以每个nalu前面有NalUnitLength字节表示每个nalu的长度
        int nNaluLen;  //nNaluLen表示时间nalu数据长度
        switch (pParser->m_nalUnitLength) {
            case 4:
                nNaluLen = CFlvParser::show_u32(pd + nOffset);
                break;
            case 3:
                nNaluLen = CFlvParser::show_u24(pd + nOffset);
                break;
            case 2:
                nNaluLen = CFlvParser::show_u16(pd + nOffset);
                break;
            default:
                nNaluLen = CFlvParser::show_u8(pd + nOffset);
        }
        memcpy(m_media + m_mediaLen, &g_h264StartCode, 4);
        memcpy(m_media + m_mediaLen + 4, pd + nOffset + pParser->m_nalUnitLength, nNaluLen);
        m_mediaLen += (4 + nNaluLen); //m_mediaLen = startcode + nNaluLen（实际数据长度）
        nOffset += (pParser->m_nalUnitLength + nNaluLen); //一个nalu整体长度 = NalUnitLength + NaluLen
    }

    return 1;
}
  1. 根据m_nalUnitLength获取NALU的长度，然后拷贝到m_media。
2. 解析Audio Tag
  1. 当Tag header的type值为8时表示Audio Tag，Audio Tag的数据结构为：
class CAudioTag : public Tag {
public:
    CAudioTag(TagHeader *pHeader, unsigned char *pBuf, int nLeftLen, CFlvParser *pParser);

    int m_soundFormat;
    int m_soundRate;
    int m_soundSize;
    int m_soundType;

    // aac
    static int m_aacProfile;
    static int m_sampleRateIndex;
    static int m_channelConfig;

    int parse_AAC_tag(CFlvParser *pParser);

    int parse_audio_specificConfig(CFlvParser *pParser, unsigned char *pTagData);

    int parse_rawAAC(CFlvParser *pParser, unsigned char *pTagData);
};
  1. Tag Data的第0字节包含：
    a. 4bit的音频格式
    b. 2bit的采样率
    c. 1bit的采样精度
    d. 1bit的判断是否为立体声
  2. 当音频格式值为10表示AAC，进行解析AAC Tag
CFlvParser::CAudioTag::CAudioTag(TagHeader *pHeader, unsigned char *pBuf, int nLeftLen, CFlvParser *pParser) {
    init(pHeader, pBuf, nLeftLen);

    unsigned char *pd = m_tagData;
    m_soundFormat = (pd[0] & 0xf0) >> 4; //音频格式
    m_soundRate = (pd[0] & 0x0c) >> 2;   //采样率
    m_soundSize = (pd[0] & 0x02) >> 1;   //采样精度
    m_soundType = (pd[0] & 0x01);        //是否立体声
    if (m_soundFormat == 10) // m_soundFormat=10时表示AAC
    {
        parse_AAC_tag(pParser); //解析AAC tag
    }
}
  1. Tag Data的第1字节表示AACPacketType，值为0表示AAC sequence header，值为1表示AAC raw data。
int CFlvParser::CAudioTag::parse_AAC_tag(CFlvParser *pParser) {
    unsigned char *pd = m_tagData;
    int nAACPacketType = pd[1]; //值为0表示AAC sequence header，值为1表示AAC raw

    if (nAACPacketType == 0) { //值为0表示AAC sequence header，数据是AudioSpecificConfig
        parse_audio_specificConfig(pParser, pd);
    } else if (nAACPacketType == 1) { //值为1表示AAC raw，数据是Raw AAC frame data
        parse_rawAAC(pParser, pd);
    } else {

    }

    return 1;
}
1. 解析AudioSpecificConfig
  1. 从第2字节开始，包含：
    a. 5bit的AAC编码级别
    b. 4bit的采样率索引
    c. 4bit的通道数量
int CFlvParser::CAudioTag::parse_audio_specificConfig(CFlvParser *pParser, unsigned char *pTagData) {
    unsigned char *pd = m_tagData;

    m_aacProfile = ((pd[2] & 0xf8) >> 3) - 1; //5bit，AAC编码级别，audioObjectType
    m_sampleRateIndex = ((pd[2] & 0x07) << 1) | (pd[3] >> 7); //4bit，真正的采样率索引，samplingFrequencyIndex
    m_channelConfig = (pd[3] >> 3) & 0x0f; //4bit，通道数量

    m_media = NULL;
    m_mediaLen = 0;

    return 1;
}
2. 解析AAC raw data
  1. AAC raw data需要制作ADTS header，可以参考博客：AAC音频基础知识及码流解析
int CFlvParser::CAudioTag::parse_rawAAC(CFlvParser *pParser, unsigned char *pTagData) {
    uint64_t bits = 0;
    int dataSize = m_header.m_dataSize - 2; // 减去两字节的 audio tag data信息部分

    //制作元数据，见ADTS头格式, https://blog.csdn.net/weixin_41910694/article/details/107735932
    write_u64(bits, 12, 0xFFF);
    write_u64(bits, 1, 0);
    write_u64(bits, 2, 0);
    write_u64(bits, 1, 1);
    write_u64(bits, 2, m_aacProfile);
    write_u64(bits, 4, m_sampleRateIndex);
    write_u64(bits, 1, 0);
    write_u64(bits, 3, m_channelConfig);
    write_u64(bits, 1, 0);
    write_u64(bits, 1, 0);
    write_u64(bits, 1, 0);
    write_u64(bits, 1, 0);
    write_u64(bits, 13, 7 + dataSize);
    write_u64(bits, 11, 0x7FF);
    write_u64(bits, 2, 0);

    m_mediaLen = 7 + dataSize;
    m_media = new unsigned char[m_mediaLen];
    unsigned char p64[8];
    p64[0] = (unsigned char) (bits >> 56);
    p64[1] = (unsigned char) (bits >> 48);
    p64[2] = (unsigned char) (bits >> 40);
    p64[3] = (unsigned char) (bits >> 32);
    p64[4] = (unsigned char) (bits >> 24);
    p64[5] = (unsigned char) (bits >> 16);
    p64[6] = (unsigned char) (bits >> 8);
    p64[7] = (unsigned char) (bits);

    memcpy(m_media, p64 + 1, 7);
    memcpy(m_media + 7, pTagData + 2, dataSize);

    return 1;
}
3. 解析MetaData Tag
  1. 当Tag header的type值为18时表示MetaData Tag，MetaData Tag的数据结构为：
class CMetaDataTag : public Tag {
public:
    CMetaDataTag(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen, CFlvParser *pParser);

    double hex_str2double(const unsigned char *hex, const unsigned int length);

    int parse_meta(CFlvParser *pParser);

    void print_meta();

    uint8_t m_amf1_type;
    uint32_t m_amf1_size;
    uint8_t m_amf2_type;
    unsigned char *m_meta;
    unsigned int m_length;

    double m_duration;
    double m_width;
    double m_height;
    double m_videodatarate;
    double m_framerate;
    double m_videocodecid;

    double m_audiodatarate;
    double m_audiosamplerate;
    double m_audiosamplesize;
    bool m_stereo;
    double m_audiocodecid;

    string m_major_brand;
    string m_minor_version;
    string m_compatible_brands;
    string m_encoder;

    double m_filesize;
};
  1. MetaData由两个AFM包组成。
  2. 第⼀个AMF包：
    a. 第0字节表示AMF包类型，⼀般总是0x02，表示字符串。
    b. 第1-2字节为UI16类型值，标识字符串的⻓度，⼀般总是0x000A。
    c. 从第3字节开始为amf1的value，为"onMetaData"。
  3. 第⼆个AMF包：
    a. 第1个字节表示AMF包类型，⼀般总是0x08，表示数组。
    b. 第2-5个字节为UI32类型值，表示数组元素的个数。
    c. 后⾯即为各数组元素的封装，数组元素为元素名称和值组成的对。详细参考博客：FLV格式解析
CFlvParser::CMetaDataTag::CMetaDataTag(CFlvParser::TagHeader *pHeader, uint8_t *pBuf, int nLeftLen,
                                       CFlvParser *pParser) {

    init(pHeader, pBuf, nLeftLen);
    uint8_t *pd = pBuf;
    m_amf1_type = show_u8(pd + 0); //amf1包的type
    m_amf1_size = show_u16(pd + 1); //amf1包的value_size

    if (m_amf1_type != 2) {
        printf("no metadata\n");
        return;
    }

    //解析script
    if (strncmp((const char *) "onMetaData", (const char *) (pd + 3), 10) == 0) { //从第3字节开始为amf1的value
        parse_meta(pParser);
    }

}

int CFlvParser::CMetaDataTag::parse_meta(CFlvParser *pParser) {
    uint8_t *pd = m_tagData;
    int dataSize = m_header.m_dataSize;

    uint32_t arrayLen = 0;
    uint32_t offset = 13; // Type + Value_Size + Value = 13字节

    uint32_t nameLen = 0;
    double doubleValue = 0;
    string strValue = "";
    bool boolValue = false;
    uint32_t valueLen = 0;
    uint8_t u8Value = 0;

    if (pd[offset++] == 0x08) { // 0x08表示onMetaData
        arrayLen = show_u32(pd + offset); //ECMAArrayLength
        offset += 4; //跳过 [ECMAArrayLength]占用的字节
        printf("ArrayLen = %d\n", arrayLen);
    } else {
        printf("metadata format error!!!");
        return -1;
    }

    for (uint32_t i = 0; i < arrayLen; i++) {
        doubleValue = 0;
        boolValue = false;
        strValue = "";
        //读取字段长度
        nameLen = show_u16(pd + offset); //stringLength
        offset += 2;

        char name[nameLen + 1];
        memset(name, 0, sizeof(name));
        memcpy(name, &pd[offset], nameLen); //stringData
        name[nameLen + 1] = '\0';
        offset += nameLen; //跳过字段名占用的长度

        uint8_t amfType = pd[offset++]; //type
        switch (amfType) {
            case 0x0: //Number type, 就是double类型，占用8字节
                doubleValue = hex_str2double(&pd[offset], 8);
                offset += 8; //跳过8字节
                break;
            case 0x1: //boolean type，bool类型，占用1字节
                u8Value = show_u8(pd + offset);
                offset += 1;
                if (u8Value != 0x00) {
                    boolValue = true;
                } else {
                    boolValue = false;
                }
                break;
            case 0x2: //string type，占2字节
                valueLen = show_u16(pd + offset);
                offset += 2;
                strValue.append(pd + offset, pd + offset + valueLen); //todo
                strValue.append("");
                offset += valueLen;
                break;
            default:
                printf("un handle amfType:%d\n", amfType);
                break;
        }

        if (strncmp(name, "duration", 8) == 0) {
            m_duration = doubleValue;
        } else if (strncmp(name, "width", 5) == 0) {
            m_width = doubleValue;
        } else if (strncmp(name, "height", 6) == 0) {
            m_height = doubleValue;
        } else if (strncmp(name, "videodatarate", 13) == 0) {
            m_videodatarate = doubleValue;
        } else if (strncmp(name, "framerate", 9) == 0) {
            m_framerate = doubleValue;
        } else if (strncmp(name, "videocodecid", 12) == 0) {
            m_videocodecid = doubleValue;
        } else if (strncmp(name, "audiodatarate", 13) == 0) {
            m_audiodatarate = doubleValue;
        } else if (strncmp(name, "audiosamplerate", 15) == 0) {
            m_audiosamplerate = doubleValue;
        } else if (strncmp(name, "audiosamplesize", 15) == 0) {
            m_audiosamplesize = doubleValue;
        } else if (strncmp(name, "stereo", 6) == 0) {
            m_stereo = boolValue;
        } else if (strncmp(name, "audiocodecid", 12) == 0) {
            m_audiocodecid = doubleValue;
        } else if (strncmp(name, "major_brand", 11) == 0) {
            m_major_brand = strValue;
        } else if (strncmp(name, "minor_version", 13) == 0) {
            m_minor_version = strValue;
        } else if (strncmp(name, "compatible_brands", 17) == 0) {
            m_compatible_brands = strValue;
        } else if (strncmp(name, "encoder", 7) == 0) {
            m_encoder = strValue;
        } else if (strncmp(name, "filesize", 8) == 0) {
            m_filesize = doubleValue;
        }
    }

    print_meta();
    return 1;
}
  1. 打印MetaData
void CFlvParser::CMetaDataTag::print_meta() {
    printf("\nduration: %0.2lfs, filesize: %.0lfbytes\n", m_duration, m_filesize);

    printf("width: %0.0lf, height: %0.0lf\n", m_width, m_height);
    printf("videodatarate: %0.2lfkbps, framerate: %0.0lffps\n", m_videodatarate, m_framerate);
    printf("videocodecid: %0.0lf\n", m_videocodecid);

    printf("audiodatarate: %0.2lfkbps, audiosamplerate: %0.0lfKhz\n",
           m_audiodatarate, m_audiosamplerate);
    printf("audiosamplesize: %0.0lfbit, stereo: %d\n", m_audiosamplesize, m_stereo);
    printf("audiocodecid: %0.0lf\n", m_audiocodecid);

    printf("major_brand: %s, minor_version: %s\n", m_major_brand.c_str(), m_minor_version.c_str());
    printf("compatible_brands: %s, encoder: %s\n\n", m_compatible_brands.c_str(), m_encoder.c_str());
}

3. dump H264、AAC和FLV

1. dump H264

int CFlvParser::dump_H264(const std::string &path) {
    fstream f;
    f.open(path.c_str(), ios_base::out | ios_base::binary); //以二进制文件输出

    vector<Tag *>::iterator it_tag;
    for (it_tag = m_tag.begin(); it_tag != m_tag.end(); it_tag++) {
        if ((*it_tag)->m_header.m_type != 0x09) //如果不是视频tag，continue
            continue;

        f.write((char *) (*it_tag)->m_media, (*it_tag)->m_mediaLen); //输出
    }
    f.close();

    return 1;
}

2. dump AAC

int CFlvParser::dump_AAC(const std::string &path) {
    fstream f;
    f.open(path.c_str(), ios_base::out | ios_base::binary); //以二进制方式输出

    vector<Tag *>::iterator it_tag;
    for (it_tag = m_tag.begin(); it_tag != m_tag.end(); it_tag++) {
        if ((*it_tag)->m_header.m_type != 0x08) //如果不是音频tag，continue
            continue;

        CAudioTag *pAudioTag = (CAudioTag *) (*it_tag);
        if (pAudioTag->m_soundFormat != 10) //如果不是AAC格式，continue
            continue;

        if (pAudioTag->m_mediaLen != 0)
            f.write((char *) (*it_tag)->m_media, (*it_tag)->m_mediaLen);
    }
    f.close();

    return 1;
}

3. dump FLV

int CFlvParser::dump_Flv(const std::string &path) {
    fstream f;
    f.open(path.c_str(), ios_base::out | ios_base::binary);

    // 写Flv header
    f.write((char *) m_pFlvHeader->m_flvHeader, m_pFlvHeader->m_headSize);
    unsigned int nLastTagSize = 0;


    // 写 flv tag
    vector<Tag *>::iterator it_tag;
    for (it_tag = m_tag.begin(); it_tag < m_tag.end(); it_tag++) {
        unsigned int nn = write_u32(nLastTagSize); //第一个previousTagSize
        f.write((char *) &nn, 4);

        //检查重复的start code
        if ((*it_tag)->m_header.m_type == 0x09 && *((*it_tag)->m_tagData + 1) == 0x01) {
            bool duplicate = false;
            unsigned char *pStartCode = (*it_tag)->m_tagData + 5 + m_nalUnitLength;
            //printf("tagsize=%d\n",(*it_tag)->m_header.m_dataSize);
            unsigned nalu_len = 0;
            unsigned char *p_nalu_len = (unsigned char *) &nalu_len;
            switch (m_nalUnitLength) {
                case 4:
                    nalu_len = show_u32((*it_tag)->m_tagData + 5);
                    break;
                case 3:
                    nalu_len = show_u24((*it_tag)->m_tagData + 5);
                    break;
                case 2:
                    nalu_len = show_u16((*it_tag)->m_tagData + 5);
                    break;
                default:
                    nalu_len = show_u8((*it_tag)->m_tagData + 5);
                    break;
            }
            /*
            printf("nalu_len=%u\n",nalu_len);
            printf("%x,%x,%x,%x,%x,%x,%x,%x,%x\n",(*it_tag)->m_tagData[5],(*it_tag)->m_tagData[6],
                    (*it_tag)->m_tagData[7],(*it_tag)->m_tagData[8],(*it_tag)->m_tagData[9],
                    (*it_tag)->m_tagData[10],(*it_tag)->m_tagData[11],(*it_tag)->m_tagData[12],
                    (*it_tag)->m_tagData[13]);
            */

            unsigned char *pStartCodeRecord = pStartCode;
            int i;
            for (i = 0; i < (*it_tag)->m_header.m_dataSize - 5 - m_nalUnitLength - 4; ++i) {
                if (pStartCode[i] == 0x00 && pStartCode[i + 1] == 0x00 && pStartCode[i + 2] == 0x00 &&
                    pStartCode[i + 3] == 0x01) {
                    if (pStartCode[i + 4] == 0x67) {
                        //printf("duplicate sps found!\n");
                        i += 4;
                        continue;
                    } else if (pStartCode[i + 4] == 0x68) {
                        //printf("duplicate pps found!\n");
                        i += 4;
                        continue;
                    } else if (pStartCode[i + 4] == 0x06) {
                        //printf("duplicate sei found!\n");
                        i += 4;
                        continue;
                    } else {
                        i += 4;
                        //printf("offset=%d\n",i);
                        duplicate = true;
                        break;
                    }
                }
            }

            if (duplicate) {
                nalu_len -= i;
                (*it_tag)->m_header.m_dataSize -= i;
                unsigned char *p = (unsigned char *) &((*it_tag)->m_header.m_dataSize);
                (*it_tag)->m_tagHeader[1] = p[2];
                (*it_tag)->m_tagHeader[2] = p[1];
                (*it_tag)->m_tagHeader[3] = p[0];
                //printf("after,tagsize=%d\n",(int)show_u24((*it_tag)->m_tagHeader + 1));
                //printf("%x,%x,%x\n",(*it_tag)->m_tagHeader[1],(*it_tag)->m_tagHeader[2],(*it_tag)->m_tagHeader[3]);

                f.write((char *) (*it_tag)->m_tagHeader, 11);
                switch (m_nalUnitLength) {
                    case 4:
                        *((*it_tag)->m_tagData + 5) = p_nalu_len[3];
                        *((*it_tag)->m_tagData + 6) = p_nalu_len[2];
                        *((*it_tag)->m_tagData + 7) = p_nalu_len[1];
                        *((*it_tag)->m_tagData + 8) = p_nalu_len[0];
                        break;
                    case 3:
                        *((*it_tag)->m_tagData + 5) = p_nalu_len[2];
                        *((*it_tag)->m_tagData + 6) = p_nalu_len[1];
                        *((*it_tag)->m_tagData + 7) = p_nalu_len[0];
                        break;
                    case 2:
                        *((*it_tag)->m_tagData + 5) = p_nalu_len[1];
                        *((*it_tag)->m_tagData + 6) = p_nalu_len[0];
                        break;
                    default:
                        *((*it_tag)->m_tagData + 5) = p_nalu_len[0];
                        break;
                }
                //printf("after,nalu_len=%d\n",(int)show_u32((*it_tag)->m_tagData + 5));
                f.write((char *) (*it_tag)->m_tagData, pStartCode - (*it_tag)->m_tagData);
                /*
                printf("%x,%x,%x,%x,%x,%x,%x,%x,%x\n",(*it_tag)->m_tagData[0],(*it_tag)->m_tagData[1],(*it_tag)->m_tagData[2],
                        (*it_tag)->m_tagData[3],(*it_tag)->m_tagData[4],(*it_tag)->m_tagData[5],(*it_tag)->m_tagData[6],
                        (*it_tag)->m_tagData[7],(*it_tag)->m_tagData[8]);
                */
                f.write((char *) pStartCode + i, (*it_tag)->m_header.m_dataSize - (pStartCode - (*it_tag)->m_tagData));
                /*
                printf("write size:%d\n", (pStartCode - (*it_tag)->m_tagData) +
                        ((*it_tag)->m_header.m_dataSize - (pStartCode - (*it_tag)->m_tagData)));
                */
            } else {
                f.write((char *) (*it_tag)->m_tagHeader, 11);
                f.write((char *) (*it_tag)->m_tagData, (*it_tag)->m_header.m_dataSize);
            }
        } else {
            f.write((char *) (*it_tag)->m_tagHeader, 11);
            f.write((char *) (*it_tag)->m_tagData, (*it_tag)->m_header.m_dataSize);
        }

        nLastTagSize = 11 + (*it_tag)->m_header.m_dataSize;
    }
    unsigned int nn = write_u32(nLastTagSize);
    f.write((char *) &nn, 4);

    f.close();

    return 1;
}
Lumos`
关注
  • 16
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
h5px 转rem
敲门的小白
10-23 5万+
<script type="text/javascript"> // px转rem var rootResize = function() { var baseFontSize = 100; var baseWidth = 750; var minWidth = 320; ...
pythonUI自动化-02-unittest框架
m0_58250910的博客
10-30 3万+
ui
在线引用 jq bs fontawesme confirm
weixin_44692699的博客
07-01 3120
Bootstrap 在线引用 https://blog.csdn.net/qq_40147863/article/details/83117202 jQuery 所有版本在线引用 https://blog.csdn.net/qq_40147863/article/details/83116859
JQuery、AJAX与Javascript之间的父子关系
许德鹏
01-29 5549
JQuery、AJAX都是Javascript的一个框架，各有各自不同的功能，如果把Javascript比作父亲的话，JQuery和AJAX就是Javascript的亲生儿子。在Javascript中非常复杂的功能，让他们实现起来是极其的方便快捷。下面来总结一下他们各自的功能及特点和应用的场合。 JQuery是轻量级的js库，它兼容CSS3，还兼容各种浏览器 （IE 6.0+, FF1.
awesome PyQt5 的奇技淫巧
MusicMan
01-06 4112
来自PyQt5的奇技淫巧
flv mux源代码、标准和分离工具资料汇总
12-23
**FLV Mux（复用）** FLV Mux是将音频和视频数据流组合成一个单一的FLV文件的过程。这个过程涉及到将不同的数据包按照特定的时间顺序和结构放入FLV容器中。FLV文件的头部包含文件标识、文件头和流信息，接着是连续...
ffmpegTest.rar
09-30
FFmpeg中的libavformat库提供了这个功能，它包含了多种媒体容器格式（如MP4、TS、FLV等）的解析器，能够识别和解复用这些格式中的流。 在这个"ffmpegTest"项目中，开发者首先需要配置FFmpeg库，确保所有必要的...
FLASH将FLV文件还原为FLA文件 各种代码也可以还原
06-03
标题中的“FLASH将FLV文件还原为FLA文件 各种代码也可以还原”是指通过特定的工具或技术，能够将已经编译好的Flash影片（FLV格式）转换回其原始的源代码文件（FLA格式）。FLA文件是Adobe Flash Professional用于创建...
文件转换swf/flv
03-28
源码的分享对于开发者来说是极其有价值的，因为它允许他们理解转换过程的内部机制，自定义功能，或者在自己的项目中复用代码。 “工具”标签表明可能还介绍了一款或几款用于转换的软件或应用程序。这些工具可能是...
VC音视频编解码技术及实践——源代码
07-05
3. **源代码分析**：在提供的源代码中，开发者可以学习如何实现音频和视频的解码流程，包括解析容器格式（如MP4、FLV等）、解复用、解码核心算法，以及如何进行回放。这对于熟悉底层工作原理和调试代码具有极大的...
jq 工作中常用代码封装之----ajax封装路由
qq_17108919的博客
07-17 4386
路由封装 api = function (params) { return new Promise((resolve, reject) => { $.ajax({ url: params.url, //路由 data: params.data || '', // 传参 type: params.type ? params.type : 'post', // 发送方式，不传默认post success: function (res) {
FW:50个jQuery代码段帮你成为更出…
zxg519的专栏
01-15 1945
http://blog.jobbole.com/18513/
centos7 PXE自动化安装
AtTheAutumn的博客
12-13 1万+
地址池 next-server 192.168.128.128;#dhcp服务器 filename "pxelinux.0";#安装界面的提示界面为图形 graphical #安装界面的提示界面为文字 #text url --url="不管安不安装图形化界面都最好将内存设置到2GB及以上。（11）使用未安装操作系统的虚拟机进行验证。将镜像文件临时挂载到此目录。查看dhcp服务是否开启。//创建软件包存放目录。（8）启动tftp服务。查看httpd服务状态。查看tftp服务状态。
涂抹CANVAS，判断清除完毕执行操作
热门推荐
羽筠的博客
07-24 19万+
涂抹CANVAS，判断清除完毕执行操作 clearCanvas.js代码如下： function clearCanvas(imgSrc,Bl,callback){ var ctx = null; var mouseX = null; var mouseY = null; var _width = 0; var _height = 0; function touchStartEven
Ajax & Jquery
ByeBye(野蛮生长)
05-22 1万+
Ajax (Asynchronous Javascript And XML) （异步JavaScript和XML）， 是什么? 并不是新的技术，只是把原有的技术，整合到一起而已。 1.使用CSS和XHTML来表示。 2. 使用DOM模型来交互和动态显示。 3.使用XMLHttpRequest来和服务器进行异步通信。 4.使用javascript来绑定和调用。 有什么用? 网页如果想要刷新局部...
Java轻量级的插件框架PF4J的使用教程
IT- 研究者
07-10 6760
一、简介 PF4J是一个Java轻量级的插件框架，可以实现动态加载，执行，卸载外部插件(支持jar以及zip)，具体可以看官网：https://pf4j.org/。 本文例子基于Github地址：https://github.com/pf4j/pf4j <dependency> <groupId>org.pf4j</groupId> <artifactId>pf4j</artifactId> <version>3.0
FLV格式分析
努力努力再努力L
11-26 3315
FLV格式分析 目录 FVL概述 框架解析图 FLV Header FLV Body 1. FVL概述 FLV(Flash Video)是Adobe公司推出的⼀种流媒体格式，由于其封装后的⾳视频⽂件体积⼩、封装简单等特点，⾮常适合于互联⽹上使⽤。⽬前主流的视频⽹站基本都⽀持FLV。采⽤FLV格式封装的⽂件后缀为.flv。 FLV封装格式是由⼀个⽂件头(file header)和 ⽂件体(file Body)组成。 FLV body由⼀对对的(Previous Tag Size字段 + tag)组
php正则匹配sg-nc-wap_Pandas基础操作（上）
weixin_28977715的博客
12-29 11万+
文章目录一、Pandas文件读取1.pandas数据读取1、读取纯文本文件1.1 读取csv，使用默认的标题行、逗号分隔符1.2 读取txt文件，自己指定分隔符、列名2、读取excel文件3、读取sql文件二、pandas的数据结构DataFrame和SeriesDataFrame：二维数据，整个表格，多行多列1.Series1.1 仅有数据列表即可生产最简单的Series1.2 创建一个具有标签...
AW 中控制FLASH 部分函数的用法
penjie0418的专栏
02-23 798
1、位置控制与获取 　　SetSpriteProperty(@"FlashMovie", #viewH, parameter) ——控制动画的横坐标的数值，其中FlashMovie表示Flash动画的图标名称， #viewH表示控制方式，parameter表示具体数值，也可以是一个变量。 SetSpriteProperty(@"FlashMovie", #viewV,paramete
ffmpeg解复用命令
最新发布
09-02
FFmpeg的解复用命令通常使用分路器来解复用FLV文件和RTMP网络流。对于FLV文件，可以使用以下命令：ffmpeg -f flv -i myfile.flv ...。而对于实时网络流，可以使用以下命令：ffmpeg -f live_flv -i rtmp://<any.server>/anything/key ...。如果需要保持时间戳的连续性，可以使用live_flv选项而不是flv选项。同时，为了使FFmpeg能够自动识别格式，指令必须在脚本的第一行以原样出现，没有额外的空格或字节顺序标记。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [FFplay文档解读-9-解复用器](https://blog.csdn.net/irainsa/article/details/127787379)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值