开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Ap4AdtsParser.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：9k
源码类别：

多媒体编程

开发平台：

Visual C++

Ap4AdtsParser.cpp：源码内容
  2. /*****************************************************************
  3. |
  4. |      File: Ap4AdtsParser.c
  5. |
  6. |      AP4 - ADTS Parser
  7. |
  8. |      (c) 2005 Gilles Boccon-Gibod
  9. |      Author: Gilles Boccon-Gibod (bok@bok.net)
  10. |
  11.  ****************************************************************/
  13. /*----------------------------------------------------------------------
  14. |       includes
  15. +---------------------------------------------------------------------*/
  16. #include "Ap4BitStream.h"
  17. #include "Ap4AdtsParser.h"
  19. /*----------------------------------------------------------------------
  20. |       constants
  21. +---------------------------------------------------------------------*/
  22. #define AP4_ADTS_HEADER_SIZE 7
  24. #define AP4_ADTS_SYNC_MASK     0xFFF6 /* 12 sync bits plus 2 layer bits */
  25. #define AP4_ADTS_SYNC_PATTERN  0xFFF0 /* 12 sync bits=1 layer=0         */
  27. const unsigned long  
  28. AP4_AdtsSamplingFrequencyTable[16] =
  29. {
  30.     96000,
  31.     88200,
  32.     64000,
  33.     48000,
  34.     44100,
  35.     32000,
  36.     24000,
  37.     22050,
  38.     16000,
  39.     12000,
  40.     11025,
  41.     8000,
  42.     7350,
  43.     0,      /* Reserved */
  44.     0,      /* Reserved */
  45.     0       /* Escape code */
  46. };
  48. /*----------------------------------------------------------------------+
  49. |        AP4_AdtsHeader::AP4_AdtsHeader
  50. +----------------------------------------------------------------------*/
  51. AP4_AdtsHeader::AP4_AdtsHeader(const AP4_UI08* bytes)
  52. {
  53.     // fixed part
  54.     m_Id                     = ( bytes[1] & 0x08) >> 3;
  55.     m_ProtectionAbsent       =   bytes[1] & 0x01;
  56.     m_ProfileObjectType      = ( bytes[2] & 0xC0) >> 6;
  57.     m_SamplingFrequencyIndex = ( bytes[2] & 0x3C) >> 2;
  58.     m_ChannelConfiguration   = ((bytes[2] & 0x01) << 2) | 
  59.                                ((bytes[3] & 0xC0) >> 6);
  60.     // variable part
  61.     m_FrameLength = ((unsigned int)(bytes[3] & 0x03) << 11) |
  62.                     ((unsigned int)(bytes[4]       ) <<  3) |
  63.                     ((unsigned int)(bytes[5] & 0xE0) >>  5);
  64.     m_RawDataBlocks =               bytes[6] & 0x03;
  65. }
  67. /*----------------------------------------------------------------------+
  68. |        AP4_AdtsHeader::MatchFixed
  69. |
  70. |    Check that two fixed headers are the same
  71. |
  72. +----------------------------------------------------------------------*/
  73. bool
  74. AP4_AdtsHeader::MatchFixed(unsigned char* a, unsigned char* b)
  75. {
  76.     if (a[0]         ==  b[0] &&
  77.         a[1]         ==  b[1] &&
  78.         a[2]         ==  b[2] &&
  79.        (a[3] & 0xF0) == (b[3] & 0xF0)) {
  80.         return true;
  81.     } else {
  82.         return false;
  83.     }
  84. }
  86. /*----------------------------------------------------------------------+
  87. |        AP4_AdtsHeader::Check
  88. +----------------------------------------------------------------------*/
  89. AP4_Result
  90. AP4_AdtsHeader::Check()
  91. {
  92.     // check that the sampling frequency index is valid
  93.     if (m_SamplingFrequencyIndex >= 0xD) {
  94.         return AP4_FAILURE;
  95.     }
  97.     /* MPEG2 does not use all profiles */
  98.     if (m_Id == 1 && m_ProfileObjectType == 3) {
  99.         return AP4_FAILURE;
  100.     }
  102.     return AP4_SUCCESS;
  103. }
  105. /*----------------------------------------------------------------------+
  106. |        AP4_AdtsParser::AP4_AdtsParser
  107. +----------------------------------------------------------------------*/
  108. AP4_AdtsParser::AP4_AdtsParser()
  109. {
  110. }
  112. /*----------------------------------------------------------------------+
  113. |        AP4_AdtsParser::~AP4_AdtsParser
  114. +----------------------------------------------------------------------*/
  115. AP4_AdtsParser::~AP4_AdtsParser()
  116. {
  117. }
  119. /*----------------------------------------------------------------------+
  120. |        AP4_AdtsParser::Reset
  121. +----------------------------------------------------------------------*/
  122. AP4_Result
  123. AP4_AdtsParser::Reset()
  124. {
  125.     m_FrameCount = 0;
  127.     return AP4_SUCCESS;
  128. }
  130. /*----------------------------------------------------------------------+
  131. |        AP4_AdtsParser::Feed
  132. +----------------------------------------------------------------------*/
  133. AP4_Result
  134. AP4_AdtsParser::Feed(const AP4_UI08* buffer, 
  135.                      AP4_Size*       buffer_size,
  136.                      AP4_Flags       flags)
  137. {
  138.     AP4_Size free_space;
  140.     /* update flags */
  141.     m_Bits.m_Flags = flags;
  143.     /* possible shortcut */
  144.     if (buffer == NULL ||
  145.         buffer_size == NULL || 
  146.         *buffer_size == 0) {
  147.         return AP4_SUCCESS;
  148.     }
  150.     /* see how much data we can write */
  151.     free_space = m_Bits.GetBytesFree();
  152.     if (*buffer_size > free_space) *buffer_size = free_space;
  154.     /* write the data */
  155.     return m_Bits.WriteBytes(buffer, *buffer_size); 
  156. }
  158. /*----------------------------------------------------------------------+
  159. |        AP4_AdtsParser::FindHeader
  160. +----------------------------------------------------------------------*/
  161. AP4_Result
  162. AP4_AdtsParser::FindHeader(AP4_UI08* header)
  163. {
  164.    int          available = m_Bits.GetBytesAvailable();
  165.    unsigned int sync = 0;
  166.    long         nbr_skipped_bytes = 0;
  168.    /* look for the sync pattern */
  169.    while (available-- >= AP4_ADTS_HEADER_SIZE) {
  170.       sync = (m_Bits.ReadByte() << 8) | m_Bits.PeekByte();
  172.       if ((sync & AP4_ADTS_SYNC_MASK) == AP4_ADTS_SYNC_PATTERN) {
  173.          /* found a sync pattern, read the rest of the header */
  174.          header[0] = (sync >> 8) & 0xFF;
  175.          m_Bits.ReadBytes(&header[1], AP4_ADTS_HEADER_SIZE-1);
  177.          return AP4_SUCCESS;
  178.       } else {
  179.          ++ nbr_skipped_bytes;
  180.       }
  181.    }
  183.    return AP4_ERROR_NOT_ENOUGH_DATA;
  184. }
  186. /*----------------------------------------------------------------------+
  187. |        AP4_AdtsParser::FindFrame
  188. +----------------------------------------------------------------------*/
  189. AP4_Result
  190. AP4_AdtsParser::FindFrame(AP4_AacFrame& frame)
  191. {
  192.     unsigned int   available;
  193.     unsigned char  raw_header[AP4_ADTS_HEADER_SIZE];
  194.     AP4_Result     result;
  196.     /* align to the start of the next byte */
  197.     m_Bits.ByteAlign();
  198.     
  199.     /* find a frame header */
  200.     result = FindHeader(raw_header);
  201.     if (AP4_FAILED(result)) return result;
  203.     /* parse the header */
  204.     AP4_AdtsHeader adts_header(raw_header);
  206.     /* check the header */
  207.     result = adts_header.Check();
  208.     if (AP4_FAILED(result)) goto fail;
  209.     
  210.     /* check that we have enough data to peek at the next header */
  211.     available = AP4_ADTS_HEADER_SIZE + m_Bits.GetBytesAvailable();
  212.     if (m_Bits.m_Flags & AP4_BITSTREAM_FLAG_EOS) {
  213.         /* we're at the end of the stream, we only need the entire frame */
  214.         if (available < adts_header.m_FrameLength) {
  215.             return AP4_ERROR_NOT_ENOUGH_DATA;
  216.         } 
  217.     } else {
  218.         /* peek at the header of the next frame */
  219.         unsigned char peek_raw_header[AP4_ADTS_HEADER_SIZE];
  221.         if (available < adts_header.m_FrameLength+AP4_ADTS_HEADER_SIZE) {
  222.             return AP4_ERROR_NOT_ENOUGH_DATA;
  223.         } 
  224.         m_Bits.SkipBytes(adts_header.m_FrameLength-AP4_ADTS_HEADER_SIZE);
  225.         m_Bits.PeekBytes(peek_raw_header, AP4_ADTS_HEADER_SIZE);
  226.         m_Bits.SkipBytes(-((int)adts_header.m_FrameLength-AP4_ADTS_HEADER_SIZE));
  228.         /* check the header */
  229.         AP4_AdtsHeader peek_adts_header(peek_raw_header);
  230.         result = peek_adts_header.Check();
  231.         if (AP4_FAILED(result)) goto fail;
  233.         /* check that the fixed part of this header is the same as the */
  234.         /* fixed part of the previous header                           */
  235.         if (!AP4_AdtsHeader::MatchFixed(peek_raw_header, raw_header)) {
  236.             goto fail;
  237.         }
  238.     }
  240.     /* fill in the frame info */
  241.     frame.m_Info.m_Standard = (adts_header.m_Id == 1 ? 
  242.                             AP4_AAC_STANDARD_MPEG2 :
  243.                             AP4_AAC_STANDARD_MPEG4);
  244.     switch (adts_header.m_ProfileObjectType) {
  245.         case 0:
  246.             frame.m_Info.m_Profile = AP4_AAC_PROFILE_MAIN;
  247.             break;
  249.         case 1:
  250.             frame.m_Info.m_Profile = AP4_AAC_PROFILE_LC;
  251.             break;
  253.         case 2: 
  254.             frame.m_Info.m_Profile = AP4_AAC_PROFILE_SSR;
  255.             break;
  257.         case 3:
  258.             frame.m_Info.m_Profile = AP4_AAC_PROFILE_LTP;
  259.     }
  260.     frame.m_Info.m_FrameLength = adts_header.m_FrameLength-AP4_ADTS_HEADER_SIZE;
  261.     frame.m_Info.m_ChannelConfiguration = adts_header.m_ChannelConfiguration;
  262.     frame.m_Info.m_SamplingFrequencyIndex = adts_header.m_SamplingFrequencyIndex;
  263.     frame.m_Info.m_SamplingFrequency = AP4_AdtsSamplingFrequencyTable[adts_header.m_SamplingFrequencyIndex];
  265.     /* skip crc if present */
  266.     if (adts_header.m_ProtectionAbsent == 0) {
  267.         m_Bits.SkipBits(16);
  268.     } 
  270.     /* set the frame source */
  271.     frame.m_Source = &m_Bits;
  273.     return AP4_SUCCESS;
  275. fail:
  276.     /* skip the header and return (only skip the first byte in  */
  277.     /* case this was a false header that hides one just after)  */
  278.     //m_Bits.SkipBytes(-(AP4_ADTS_HEADER_SIZE-1));
  279.     return AP4_ERROR_CORRUPTED_BITSTREAM;
  280. }
  282. /*----------------------------------------------------------------------+
  283. |        AP4_AdtsParser::GetBytesFree
  284. +----------------------------------------------------------------------*/
  285. AP4_Size
  286. AP4_AdtsParser::GetBytesFree()
  287. {
  288. return (m_Bits.GetBytesFree());
  289. }
  293. /*----------------------------------------------------------------------+
  294. |        AP4_AdtsParser::GetBytesAvailable
  295. +----------------------------------------------------------------------*/
  296. AP4_Size
  297. AP4_AdtsParser::GetBytesAvailable()
  298. {
  299. return (m_Bits.GetBytesAvailable());
  300. }