FLV格式解封装（demuxer）-----FlvParser源码阅读

最新推荐文章于 2024-07-09 11:27:31 发布
最新推荐文章于 2024-07-09 11:27:31 发布
阅读量858 收藏 1
点赞数
分类专栏： 音视频 ffmpeg 文章标签： 音视频 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41643938/article/details/124537035
版权
本文详细介绍了FLV文件的封装和解封装过程，通过一个简单的FLV解析器实例，展示了如何读取FLV文件、解析其头部信息、处理各个Tag（包括音频、视频和script标签）。解析器将标签数据输出到新的文件中，并提供了对H264和AAC数据的特殊处理。解析流程包括读取文件、解析头部、逐个处理Tag以及输出解析后的数据。
摘要由CSDN通过智能技术生成

总体流程

了解了FLV的封装原理，我们通过⼀个简单的FLV解析器的例⼦来看看FLV到底是怎么样封装/ 解封装的 该FLV的地址：功能强大的 FLV 文件分析和解析器

这个程序能够做什么：
（1）不能直接商⽤，因为每个tag解析后都存放到内存；
（2）audio parse
（3）video parse
（4）script parse

main函数

流程：
1、读取输⼊⽂件（flv类型的视频⽂件）
2、调⽤Process进⾏处理
3、退出

int main(int argc, char *argv[])
{
    cout << "Hi, this is FLV parser test program!\n";

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

    fstream fin;
    fin.open(argv[1], ios_base::in | ios_base::binary);
    if (!fin)
        return 0;

    Process(fin, argv[2]);

    fin.close();

    return 1;
}

处理函数Process

流程：

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

    int nBufSize = 2*1024 * 1024;
    int nFlvPos = 0;
    uint8_t *pBuf, *pBak;
    pBuf = new uint8_t[nBufSize];
    pBak = new uint8_t[nBufSize];

    while (1)
    {
        int nReadNum = 0;
        int nUsedLen = 0;
        fin.read((char *)pBuf + nFlvPos, nBufSize - nFlvPos);
        nReadNum = fin.gcount();
        if (nReadNum == 0)
            break;
        nFlvPos += nReadNum;

        parser.Parse(pBuf, nFlvPos, nUsedLen);
        if (nFlvPos != nUsedLen)
        {
            memcpy(pBak, pBuf + nUsedLen, nFlvPos - nUsedLen);
            memcpy(pBuf, pBak, nFlvPos - nUsedLen);
        }
        nFlvPos -= nUsedLen;
    }
    parser.PrintInfo();
    parser.DumpH264("parser.264");
    parser.DumpAAC("parser.aac");

    //dump into flv
    parser.DumpFlv(filename);

    delete []pBak;
    delete []pBuf;
}

解析函数

流程：

  1. 解析flv的头部
  2. 解析flv的Tag
int CFlvParser::Parse(uint8_t *pBuf, int nBufSize, int &nUsedLen)
{
    int nOffset = 0;

    if (_pFlvHeader == 0)
    {
        CheckBuffer(9);
        _pFlvHeader = CreateFlvHeader(pBuf+nOffset);
        nOffset += _pFlvHeader->nHeadSize;
    }

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

        Tag *pTag = CreateTag(pBuf + nOffset, nBufSize-nOffset);
        if (pTag == NULL)
        {
            nOffset -= 4;
            break;
        }
        nOffset += (11 + pTag->_header.nDataSize);

        _vpTag.push_back(pTag);
    }

    nUsedLen = nOffset;
    return 0;
}

FLV相关的数据结构

CFlvParser表示FLV解析器

FLV由FLV头部和FLV体构成，其中FLV体是由⼀系列的FLV tag构成的

class CFlvParser
{
public:
    CFlvParser();
    virtual ~CFlvParser();

    int Parse(uint8_t *pBuf, int nBufSize, int &nUsedLen);
    int PrintInfo();
    int DumpH264(const std::string &path);
    int DumpAAC(const std::string &path);
    int DumpFlv(const std::string &path);

private:
    // FLV头
    typedef struct FlvHeader_s
    {
        int nVersion; // 版本
        int bHaveVideo; // 是否包含视频
        int bHaveAudio; // 是否包含音频
        int nHeadSize;  // FLV头部长度
        /*
        ** 指向存放FLV头部的buffer
        ** 上面的三个成员指明了FLV头部的信息，是从FLV的头部中“翻译”得到的，
        ** 真实的FLV头部是一个二进制比特串，放在一个buffer中，由pFlvHeader成员指明
        */
        uint8_t *pFlvHeader;
    } FlvHeader;

    // Tag头部
    struct TagHeader
    {
        int nType;      // 类型
        int nDataSize;  // 标签body的大小
        int nTimeStamp; // 时间戳
        int nTSEx;      // 时间戳的扩展字节
        int nStreamID;  // 流的ID，总是0

        uint32_t nTotalTS;  // 完整的时间戳nTimeStamp和nTSEx拼装

        TagHeader() : nType(0), nDataSize(0), nTimeStamp(0), nTSEx(0), nStreamID(0), nTotalTS(0) {}
        ~TagHeader() {}
    };

    class Tag
    {
    public:
        Tag() : _pTagHeader(NULL), _pTagData(NULL), _pMedia(NULL), _nMediaLen(0) {}
        void Init(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen);

        TagHeader _header;
        uint8_t *_pTagHeader;   // 指向标签头部
        uint8_t *_pTagData;     // 指向标签body，原始的tag data数据
        uint8_t *_pMedia;       // 指向标签的元数据，改造后的数据
        int _nMediaLen;         // 数据长度
    };

    class CVideoTag : public Tag
    {
    public:
        /**
         * @brief CVideoTag
         * @param pHeader
         * @param pBuf 整个tag的起始地址
         * @param nLeftLen
         * @param pParser
         */
        CVideoTag(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen, CFlvParser *pParser);

        int _nFrameType;    // 帧类型
        int _nCodecID;      // 视频编解码类型
        int ParseH264Tag(CFlvParser *pParser);
        int ParseH264Configuration(CFlvParser *pParser, uint8_t *pTagData);
        int ParseNalu(CFlvParser *pParser, uint8_t *pTagData);
    };

FlvHeader表示FLV的头部

  // FLV头
    typedef struct FlvHeader_s
    {
        int nVersion; // 版本
        int bHaveVideo; // 是否包含视频
        int bHaveAudio; // 是否包含音频
        int nHeadSize;  // FLV头部长度
        /*
        ** 指向存放FLV头部的buffer
        ** 上面的三个成员指明了FLV头部的信息，是从FLV的头部中“翻译”得到的，
        ** 真实的FLV头部是一个二进制比特串，放在一个buffer中，由pFlvHeader成员指明
        */
        uint8_t *pFlvHeader;
    } FlvHeader;

标签

标签包括标签头部和标签体，根据类型的不同，标签体可以分成三种：

  1. script类型的标签
  2. ⾳频标签
  3. 视频标签
标签头部
    // Tag头部
    struct TagHeader
    {
        int nType;      // 类型
        int nDataSize;  // 标签body的大小
        int nTimeStamp; // 时间戳
        int nTSEx;      // 时间戳的扩展字节
        int nStreamID;  // 流的ID，总是0

        uint32_t nTotalTS;  // 完整的时间戳nTimeStamp和nTSEx拼装

        TagHeader() : nType(0), nDataSize(0), nTimeStamp(0), nTSEx(0), nStreamID(0), nTotalTS(0) {}
        ~TagHeader() {}
    };
标签数据
    class Tag
    {
    public:
        Tag() : _pTagHeader(NULL), _pTagData(NULL), _pMedia(NULL), _nMediaLen(0) {}
        void Init(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen);

        TagHeader _header;
        uint8_t *_pTagHeader;   // 指向标签头部
        uint8_t *_pTagData;     // 指向标签body，原始的tag data数据
        uint8_t *_pMedia;       // 指向标签的元数据，改造后的数据
        int _nMediaLen;         // 数据长度
    };
script类型的标签
    class CMetaDataTag : public Tag
    {
    public:
        CMetaDataTag(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen, CFlvParser *pParser);

        double hexStr2double(const unsigned char* hex, const unsigned int length);
        int parseMeta(CFlvParser *pParser);
        void printMeta();

        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;
    };
⾳频标签
    class CAudioTag : public Tag
    {
    public:
        CAudioTag(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen, CFlvParser *pParser);

        int _nSoundFormat;  // 音频编码类型
        int _nSoundRate;    // 采样率
        int _nSoundSize;    // 精度
        int _nSoundType;    // 类型

        // aac
        static int _aacProfile;     // 对应AAC profile
        static int _sampleRateIndex;    // 采样率索引
        static int _channelConfig;      // 通道设置

        int ParseAACTag(CFlvParser *pParser);
        int ParseAudioSpecificConfig(CFlvParser *pParser, uint8_t *pTagData);
        int ParseRawAAC(CFlvParser *pParser, uint8_t *pTagData);
    };
视频标签
    class CVideoTag : public Tag
    {
    public:
        /**
         * @brief CVideoTag
         * @param pHeader
         * @param pBuf 整个tag的起始地址
         * @param nLeftLen
         * @param pParser
         */
        CVideoTag(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen, CFlvParser *pParser);

        int _nFrameType;    // 帧类型
        int _nCodecID;      // 视频编解码类型
        int ParseH264Tag(CFlvParser *pParser);
        int ParseH264Configuration(CFlvParser *pParser, uint8_t *pTagData);
        int ParseNalu(CFlvParser *pParser, uint8_t *pTagData);
    };

解析FLV头部

入口函数

int CFlvParser::Parse(uint8_t *pBuf, int nBufSize, int &nUsedLen)
{
    int nOffset = 0;

    if (_pFlvHeader == 0)
    {
        CheckBuffer(9);
        _pFlvHeader = CreateFlvHeader(pBuf+nOffset);
        nOffset += _pFlvHeader->nHeadSize;
    }

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

        Tag *pTag = CreateTag(pBuf + nOffset, nBufSize-nOffset);
        if (pTag == NULL)
        {
            nOffset -= 4;
            break;
        }
        nOffset += (11 + pTag->_header.nDataSize);

        _vpTag.push_back(pTag);
    }

    nUsedLen = nOffset;
    return 0;
}

FLV头部解析函数

CFlvParser::FlvHeader *CFlvParser::CreateFlvHeader(uint8_t *pBuf)
{
    FlvHeader *pHeader = new FlvHeader;
    pHeader->nVersion = pBuf[3];        // 版本号
    pHeader->bHaveAudio = (pBuf[4] >> 2) & 0x01;    // 是否有音频
    pHeader->bHaveVideo = (pBuf[4] >> 0) & 0x01;    // 是否有视频
    pHeader->nHeadSize = ShowU32(pBuf + 5);         // 头部长度

    pHeader->pFlvHeader = new uint8_t[pHeader->nHeadSize];
    memcpy(pHeader->pFlvHeader, pBuf, pHeader->nHeadSize);

    return pHeader;
}

解析标签头部

标签的解析过程

  1. CFlvParser::Parse调⽤CreateTag解析标签
  2. CFlvParser::CreateTag⾸先解析标签头部
  3. 根据标签头部的类型字段，判断标签的类型
  4. 如果是视频标签，那么解析视频标签
  5. 如果是⾳频标签，那么解析⾳频标签
  6. 如果是其他的标签，那么调⽤Tag::Init进⾏解析

解析标签头部的函数


CFlvParser::Tag *CFlvParser::CreateTag(uint8_t *pBuf, int nLeftLen)
{
    // 开始解析标签头部
    TagHeader header;
    header.nType = ShowU8(pBuf+0);  // 类型
    header.nDataSize = ShowU24(pBuf + 1);   // 标签body的长度
    header.nTimeStamp = ShowU24(pBuf + 4);  // 时间戳 低24bit
    header.nTSEx = ShowU8(pBuf + 7);        // 时间戳的扩展字段, 高8bit
    header.nStreamID = ShowU24(pBuf + 8);   // 流的id
    header.nTotalTS = (uint32_t)((header.nTSEx << 24)) + header.nTimeStamp;
    // 标签头部解析结束

//    cout << "total TS : " << header.nTotalTS << endl;
//    cout << "nLeftLen : " << nLeftLen << " , nDataSize : " << header.nDataSize << endl;
    if ((header.nDataSize + 11) > nLeftLen)
    {
        return NULL;
    }

    Tag *pTag;
    switch (header.nType) {
    case 0x09:  // 视频类型的Tag
        pTag = new CVideoTag(&header, pBuf, nLeftLen, this);
        break;
    case 0x08:  // 音频类型的Tag
        pTag = new CAudioTag(&header, pBuf, nLeftLen, this);
        break;
    case 0x12:  // script Tag
        pTag = new CMetaDataTag(&header, pBuf, nLeftLen, this);
        break;
    default:    // script类型的Tag
        pTag = new Tag();
        pTag->Init(&header, pBuf, nLeftLen);
    }

    return pTag;
}

视频标签

    class CVideoTag : public Tag
    {
    public:
        /**
         * @brief CVideoTag
         * @param pHeader
         * @param pBuf 整个tag的起始地址
         * @param nLeftLen
         * @param pParser
         */
        CVideoTag(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen, CFlvParser *pParser);

        int _nFrameType;    // 帧类型
        int _nCodecID;      // 视频编解码类型
        int ParseH264Tag(CFlvParser *pParser);
        int ParseH264Configuration(CFlvParser *pParser, uint8_t *pTagData);
        int ParseNalu(CFlvParser *pParser, uint8_t *pTagData);
    };

创建视频标签

流程如下：

  1. 初始化
  2. 解析帧类型
  3. 解析视频编码类型
  4. 解析视频标签
CFlvParser::CVideoTag::CVideoTag(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen, CFlvParser *pParser)
{
    // 初始化
    Init(pHeader, pBuf, nLeftLen);

    uint8_t *pd = _pTagData;
    _nFrameType = (pd[0] & 0xf0) >> 4;  // 帧类型
    _nCodecID = pd[0] & 0x0f;           // 视频编码类型
    // 开始解析
    if (_header.nType == 0x09 && _nCodecID == 7)
    {
        ParseH264Tag(pParser);
    }
}

解析视频标签

流程如下：

  1. 解析数据包类型
  2. 如果数据包是配置信息，那么就解析配置信息
  3. 如果数据包是视频数据，那么就解析视频数据
int CFlvParser::CVideoTag::ParseH264Tag(CFlvParser *pParser)
{
    uint8_t *pd = _pTagData;
    /*
    ** 数据包的类型
    ** 视频数据被压缩之后被打包成数据包在网上传输
    ** 有两种类型的数据包：视频信息包（sps、pps等）和视频数据包（视频的压缩数据）
    */
    int nAVCPacketType = pd[1];
    int nCompositionTime = CFlvParser::ShowU24(pd + 2);

    // 如果是视频配置信息
    if (nAVCPacketType == 0)    // AVC sequence header
    {
        ParseH264Configuration(pParser, pd);
    }
    // 如果是视频数据
    else if (nAVCPacketType == 1) // AVC NALU
    {
        ParseNalu(pParser, pd);
    }
    else
    {

    }
    return 1;
}

解析视频配置信息

流程如下：

  1. 解析配置信息的⻓度
  2. 解析sps、pps的⻓度
  3. 保存元数据，元数据即sps、pps等
int CFlvParser::CVideoTag::ParseH264Configuration(CFlvParser *pParser, uint8_t *pTagData)
{
    uint8_t *pd = pTagData;
    // 跨过 Tag Data的VIDEODATA(1字节) AVCVIDEOPACKET(AVCPacketType(1字节) 和CompositionTime(3字节) 4字节)
    // 总共跨过5个字节

    // NalUnit长度表示占用的字节
    pParser->_nNalUnitLength = (pd[9] & 0x03) + 1;  // lengthSizeMinusOne 9 = 5 + 4

    int sps_size, pps_size;
    // sps（序列参数集）的长度
    sps_size = CFlvParser::ShowU16(pd + 11);        // sequenceParameterSetLength 11 = 5 + 6
    // pps（图像参数集）的长度
    pps_size = CFlvParser::ShowU16(pd + 11 + (2 + sps_size) + 1);   // pictureParameterSetLength

    // 元数据的长度
    _nMediaLen = 4 + sps_size + 4 + pps_size;   // 添加start code
    _pMedia = new uint8_t[_nMediaLen];
    // 保存元数据
    memcpy(_pMedia, &nH264StartCode, 4);
    memcpy(_pMedia + 4, pd + 11 + 2, sps_size);
    memcpy(_pMedia + 4 + sps_size, &nH264StartCode, 4);
    memcpy(_pMedia + 4 + sps_size + 4, pd + 11 + 2 + sps_size + 2 + 1, pps_size);

    return 1;
}

解析视频数据

流程如下：

  1. 如果⼀个Tag还没解析完成，那么执⾏下⾯步骤
  2. 计算NALU的⻓度
  3. 获取NALU的起始码
  4. 保存NALU的数据
  5. 调⽤⾃定义的处理函数对NALU数据进⾏处理
int CFlvParser::CVideoTag::ParseNalu(CFlvParser *pParser, uint8_t *pTagData)
{
    uint8_t *pd = pTagData;
    int nOffset = 0;

    _pMedia = new uint8_t[_header.nDataSize+10];
    _nMediaLen = 0;
    // 跨过 Tag Data的VIDEODATA(1字节) AVCVIDEOPACKET(AVCPacketType和CompositionTime 4字节)
    nOffset = 5; // 总共跨过5个字节 132 - 5 = 127 = _nNalUnitLength(4字节)  + NALU(123字节)
    //                                           startcode(4字节)  + NALU(123字节) = 127
    while (1)
    {
        // 如果解析完了一个Tag，那么就跳出循环
        if (nOffset >= _header.nDataSize)
            break;
        // 计算NALU（视频数据被包装成NALU在网上传输）的长度,
        // 一个tag可能包含多个nalu, 所以每个nalu前面有NalUnitLength字节表示每个nalu的长度
        int nNaluLen;
        switch (pParser->_nNalUnitLength)
        {
        case 4:
            nNaluLen = CFlvParser::ShowU32(pd + nOffset);
            break;
        case 3:
            nNaluLen = CFlvParser::ShowU24(pd + nOffset);
            break;
        case 2:
            nNaluLen = CFlvParser::ShowU16(pd + nOffset);
            break;
        default:
            nNaluLen = CFlvParser::ShowU8(pd + nOffset);
        }
        // 获取NALU的起始码
        memcpy(_pMedia + _nMediaLen, &nH264StartCode, 4);
        // 复制NALU的数据
        memcpy(_pMedia + _nMediaLen + 4, pd + nOffset + pParser->_nNalUnitLength, nNaluLen);
        // 解析NALU
//        pParser->_vjj->Process(_pMedia+_nMediaLen, 4+nNaluLen, _header.nTotalTS);
        _nMediaLen += (4 + nNaluLen);
        nOffset += (pParser->_nNalUnitLength + nNaluLen);
    }

    return 1;
}

自定义的视频处理

把视频的NALU解析出来之后，可以根据⾃⼰的需要往视频中添加内容

// 用户可以根据自己的需要，对该函数进行修改或者扩展
// 下面这个函数的功能大致就是往视频中写入SEI信息
int CVideojj::Process(uint8_t *pNalu, int nNaluLen, int nTimeStamp)
{
    // 如果起始码后面的两个字节是0x05或者0x06，那么表示IDR图像或者SEI信息
	if (pNalu[4] != 0x06 || pNalu[5] != 0x05)
		return 0;
    uint8_t *p = pNalu + 4 + 2;
	while (*p++ == 0xff);
	const char *szVideojjUUID = "VideojjLeonUUID";
	char *pp = (char *)p;
	for (int i = 0; i < strlen(szVideojjUUID); i++)
	{
		if (pp[i] != szVideojjUUID[i])
			return 0;
	}
	
	VjjSEI sei;
	sei.nTimeStamp = nTimeStamp;
	sei.nLen = nNaluLen - (pp - (char *)pNalu) - 16 - 1;
	sei.szUD = new char[sei.nLen];
	memcpy(sei.szUD, pp + 16, sei.nLen);
	_vVjjSEI.push_back(sei);

	return 1;
}

音频标签

入口函数CreateTag

创建音频标签

流程如下：

  1. 初始化
  2. 解析⾳频编码类型
  3. 解析采样率
  4. 解析精度和类型
  5. 解析⾳频标签
CFlvParser::CAudioTag::CAudioTag(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen, CFlvParser *pParser)
{
    Init(pHeader, pBuf, nLeftLen);

    uint8_t *pd = _pTagData;
    _nSoundFormat = (pd[0] & 0xf0) >> 4;    // 音频格式
    _nSoundRate = (pd[0] & 0x0c) >> 2;      // 采样率
    _nSoundSize = (pd[0] & 0x02) >> 1;      // 采样精度
    _nSoundType = (pd[0] & 0x01);           // 是否立体声
    if (_nSoundFormat == 10)                // AAC
    {
        ParseAACTag(pParser);
    }
}

解析音频标签

流程如下：

  1. 获取数据包的类型
  2. 判断数据包的类型
  3. 如果数据包是⾳频配置信息，那么解析有⾳频配置信息
  4. 如果是原始⾳频数据，那么对原始⾳频数据进⾏处理
int CFlvParser::CAudioTag::ParseAACTag(CFlvParser *pParser)
{
    uint8_t *pd = _pTagData;

    // 数据包的类型：音频配置信息，音频数据
    int nAACPacketType = pd[1];

    // 如果是音频配置信息
    if (nAACPacketType == 0)    // AAC sequence header
    {
        // 解析配置信息
        ParseAudioSpecificConfig(pParser, pd); // 解析AudioSpecificConfig
    }
    // 如果是音频数据
    else if (nAACPacketType == 1)   // AAC RAW
    {
        // 解析音频数据
        ParseRawAAC(pParser, pd);
    }
    else
    {

    }

    return 1;
}

处理始音频配置

流程如下：

  1. 解析AAC的采样率
  2. 解析采样率索引
  3. 解析声道
int CFlvParser::CAudioTag::ParseAudioSpecificConfig(CFlvParser *pParser, uint8_t *pTagData)
{
    uint8_t *pd = _pTagData;

    _aacProfile = ((pd[2]&0xf8)>>3);    // 5bit AAC编码级别
    _sampleRateIndex = ((pd[2]&0x07)<<1) | (pd[3]>>7);  // 4bit 真正的采样率索引
    _channelConfig = (pd[3]>>3) & 0x0f;                 // 4bit 通道数量
    printf("----- AAC ------\n");
    printf("profile:%d\n", _aacProfile);
    printf("sample rate index:%d\n", _sampleRateIndex);
    printf("channel config:%d\n", _channelConfig);

    _pMedia = NULL;
    _nMediaLen = 0;

    return 1;
}

处理原始音频数据

主要的功能是为原始的⾳频数据添加元数据，可以根据⾃⼰的需要进行改写、

int CFlvParser::CAudioTag::ParseRawAAC(CFlvParser *pParser, uint8_t *pTagData)
{
    uint64_t bits = 0;  // 占用8字节
    // 数据长度 跳过tag data的第一个第二字节
    int dataSize = _header.nDataSize - 2;   // 减去两字节的 audio tag data信息部分

    // 制作元数据
    WriteU64(bits, 12, 0xFFF);
    WriteU64(bits, 1, 0);
    WriteU64(bits, 2, 0);
    WriteU64(bits, 1, 1);
    WriteU64(bits, 2, _aacProfile - 1);
    WriteU64(bits, 4, _sampleRateIndex);
    WriteU64(bits, 1, 0);
    WriteU64(bits, 3, _channelConfig);
    WriteU64(bits, 1, 0);
    WriteU64(bits, 1, 0);
    WriteU64(bits, 1, 0);
    WriteU64(bits, 1, 0);
    WriteU64(bits, 13, 7 + dataSize);
    WriteU64(bits, 11, 0x7FF);
    WriteU64(bits, 2, 0);
    // WriteU64执行为上述的操作，最高的8bit还没有被移位到，实际是使用7个字节
    _nMediaLen = 7 + dataSize;
    _pMedia = new uint8_t[_nMediaLen];
    uint8_t p64[8];
    p64[0] = (uint8_t)(bits >> 56); // 是bits的最高8bit，实际为0
    p64[1] = (uint8_t)(bits >> 48); // 才是ADTS起始头 0xfff的高8bit
    p64[2] = (uint8_t)(bits >> 40);
    p64[3] = (uint8_t)(bits >> 32);
    p64[4] = (uint8_t)(bits >> 24);
    p64[5] = (uint8_t)(bits >> 16);
    p64[6] = (uint8_t)(bits >> 8);
    p64[7] = (uint8_t)(bits);

    memcpy(_pMedia, p64+1, 7);  // ADTS header, p64+1是从ADTS起始头开始
    memcpy(_pMedia + 7, pTagData + 2, dataSize); // AAC body

    return 1;
}

其他标签

解析普通标签

/**
 * @brief 复制header + body
 * @param pHeader
 * @param pBuf
 * @param nLeftLen
 */
void CFlvParser::Tag::Init(TagHeader *pHeader, uint8_t *pBuf, int nLeftLen)
{
    memcpy(&_header, pHeader, sizeof(TagHeader));
    // 复制标签头部信息 header
    _pTagHeader = new uint8_t[11];
    memcpy(_pTagHeader, pBuf, 11);      // 头部
    // 复制标签 body
    _pTagData = new uint8_t[_header.nDataSize];
    memcpy(_pTagData, pBuf + 11, _header.nDataSize);
}
生椰_李点点
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
以FLV解复用为例详解开源库FFmpeg中解复用器的源码逻辑及处理流程
dvlinker的技术专栏
08-20 1万+
本文以FLV音视频解复用为例，详细讲解开源库FFmpeg中解复用器的源码逻辑及处理流程。
FlvParse flv文件结构解析器
05-29
小巧而又强大的flv文件格式解析器，非常适合学习flv文件格式以及进行flv研发的朋友使用。作者不详，可能是新浪BLOG上的“可下人间”
flv parser
04-15
查看flv文件的小工具,方便的观看flv封装格式，适合初学者
音视频解封装demo：将FLV文件解封装(demux)得到文件中的H264数据和AAC数据(纯手工，不依赖第三方开源库)
最新发布
weixin_44498318的博客
07-09 680
目前demo解封装功能正常，所得到的H.264文件与AAC文件均可正常播放。
FLVParser flv格式解析器
02-03
解析flv文件中各个Tag结构信息
flv 解封装
zhengfl的专栏
03-27 1275
#include #include #include #define DEBUG_INFO typedef struct FileHeader { unsigned char type[4]; // UI8 * 3 "FLV" unsigned char versions; // UI8 版本号 unsigned char stream_info;//UI8
VOB Demuxer-开源
05-09
【VOB Demuxer - 开源工具详解】 VOB Demuxer是一款开源工具，专为从DVD VOB文件中提取核心元素而设计。这个工具的主要功能是将VOB文件中的MPEG2视频流（M2V）和杜比数字音频流（AC3）分离出来，以便用户可以单独...
SSARomeo, the multilanguage ssa demuxer-开源
05-10
SSARomeo是一款开源的工具，专为处理多语言的 SSA（SubStation Alpha）字幕格式而设计。SSA 字幕格式广泛应用于动画、视频字幕制作，它提供了丰富的样式和时间轴控制功能，使得字幕可以更加生动、精确地与视频内容...
v4l2[1].pdf.tar.gz_V4L2-capture_v4l2
09-21
Muxer将多个数据流合并成一个单一的输出流，而Demuxer则将混合流分离回其原始组件。 6. **同步和异步I/O** V4L2 API支持同步I/O（read/write）和异步I/O（如中断驱动的I/O）。异步I/O通常更高效，因为它允许应用...
jswebm:Webm Demuxer（matroska）的javascript实现
05-02
Webm Demuxer Webm Demuxer（matroska）JavaScript实现。 查看dumux结果的演示更好的示例和重新设计的api即将推出。 现场演示： : API提案 韦伯 特性 顶层包装器和接口。 videoPackets ：多路videoPackets视频包...
flvparser.zip 解析flv的工具箱，包括各种标识和字段
08-31
flvparser.zip 解析flv的工具箱，包括各种标识和字段
flvParser.zip
05-12
学习flv视频格式后使用python写的一个界面化的flv文件解析工具，希望能对flv格式学习有所帮助
flv二进制数据解析工具(FlvParse)-已包含齐全的动态库
03-20
【该资源在win7——64位系统下验证通过。win10系统试试用win7兼容方式打开】 解析flv二进制数据的小工具，tag header tag data等都分析出来了的 这个工具的主要功能是查看FLV的文件结构，帮助我们理解FLV格式。另外，如果涉及到处理flv文件的开发，这个工具对于查看处理结果非常有帮助。因此我觉得有必要写一个使用说明，希望这个工具能够给大家提供帮助。 打开后的界面如下图所示。 先说一下界面布局：左上方是FLV文件的结构树，右边是FLV文件的字节流数据；左侧结构树下面依次是结构树的信息等级选择、高速模式选择、文件分析用时及进度条等；下方是分析文件的地址显示以及文件选择按钮。下面详细介绍一下相关部分。 结构树及信息等级 FLV结构树是这个工具最重要的显示信息，用户可以直观的查看当前FLV文件的结构。FLVParse默认FLV文件结构树的形式为：File Header + Metadata Tag(1个) + Video or Audio Tags(按顺序)。 结构树的信息详细程度是按等级划分的，之所以要分等级，是为了区分显示信息的详细程度，因为不同程度的分析对于分析所用的时间影响是比较大的（主要在UI界面上），越详细的信息等级占用分析时间越长。一共有6个等级，按从简单到详细介绍如下。 only section position info —— 只有每个section的位置信息，如下图所示。其中每个section后的方括号里是位置信息（十六进制表示），每个“Pre Tag Size”后面的数字表示size的大小（十进制表示），Video&Audio Tag按照在文件中的顺序依次排序标号； file header info, metadata info —— 只有File Header + Metadata Tag的详细信息，如下图所示。其中File Header的详细结构信息会在子树中列出，并在每项后面标示该项的值；Metadata Tag类似，包含Tag Header和Tag Data两个子树，并且对应子项的详细信息也都列出； file header info, metadata info, tag position info —— 包含File Header + Metadata Tag的详细信息，Video&Audio Tags的位置信息，以及Pre Tag Size信息，如下图所示； file header info, metadata info, tag section position info —— 比上个等级多出Video&Audio Tags的Tag Header和Tag Data的位置信息，如下图所示； file header info, metadata info, tag header info —— 比上个等级多出Tag Header的详细子项信息，如下图所示； file header info, metadata info, tag info —— 比上个等级多出Tag Data的详细子项信息，如下图所示。 FLV字节流数据显示 右侧显示了FLV文件的数据，可以让用户方便地查询对应位置上的字节。每一行都以一个十六进制的位置开始，该位置为相对于文件开头的位置。每一行有十六个字节，每个字节按高4位和第4位显示2个十六进制的字符，用户可以滑动滚动条查看任意位置的字节。 当用户选中左边结构树中的某项时，右边数据会自动选中对应的数据区域（绿色），根据不同项的类型，选中的区域大小也会自动对应。 高速模式 这个选项是为了解决分析比较大的FLV文件时，用户等待时间过长的问题。 普通模式时，分析过程为阻塞模式，即主线程分析完毕后刷新界面，用户才可以继续操作。 高速模式时，为非阻塞模式，主线程分析一小部分后立即返回刷新界面，响应用户操作；另外一个线程会继续分析剩余大部分文件，直到分析完毕自动结束线程。因此高速模式时，用户会看到结构树的滚动条一直在滑动，这是因为后台分析线程在不断向结构树里添加子项。需要注意的是，当后台分析线程还没有结束，如果用户打开新的文件进行分析，有可能出现错误的分析结果。这个目前没有进行测试，我想应该是这样的。 这里需要提一下，其实真正分析文件的时间并不会特别长，即使几百兆的文件，几十秒内应该没有问题，时间主要消耗在MFC的树型控件CTreeCtrl上。为了开发效率，FLVParse使用了MFC控件，但是CTreeCtrl在结构比较复杂，子项比较多的时候，效率会出现比较大的下降。当子项超过10000的时候，再进行添加的时间大大变长，几乎到了无法忍受的程度，好在还算稳定，没有出现崩溃等现象。粗略估计，每次分析文件，花在更新UI界面上的时间要占总耗时的90%以上，而且对于越大的
flv解析工具
05-10
flv解析工具 很好用 flv解析工具 很好用 flv解析工具 很好用 flv解析工具 很好用 flv解析工具 很好用 flv解析工具 很好用
Flv解析器 （SpecialFFLv）
07-11
Flv解析器
探索FlvParser：强大的FLV文件解析库
gitblog_00058的博客
04-03 482
探索FlvParser：强大的FLV文件解析库 项目地址:https://gitcode.com/imagora/FlvParser 项目简介 FlvParser 是一个开源的JavaScript库，专为解析Flash视频流（FLV）格式而设计。这个项目由Imagora开发并维护，旨在提供一种高效、灵活的方式来处理和理解FLV文件的内容，这对于视频处理、直播服务或者网络多媒体应用开发者来说是一项非...
FLV学习（五）FlvParser源码阅读（3）解析FLV头部
NB_vol_1的专栏
02-25 728
解析FLV头部 入口函数 int CFlvParser::Parse(unsigned char *pBuf, int nBufSize, int &nUsedLen) { int nOffset = 0; if (_pFlvHeader == 0) { CheckBuffer(9); // 解析FLV头部 _pFlvHeader = CreateF
FLV学习（七）FlvParser源码阅读（5）解析视频标签
NB_vol_1的专栏
02-25 1315
解析视频标签 入口函数CreateTag 流程如下： 1、解析标签头部 2、判断标签头部的类型 3、根据标签头部的类型，解析不同的标签 4、如果是视频类型的标签，那么就创建并解析视频标签 CFlvParser::Tag *CFlvParser::CreateTag(unsigned char *pBuf, int nLeftLen) { // 开始解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值