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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
parser.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：25k
源码类别：

Audio

开发平台：

Visual C++

parser.c：源码内容
  1. /*  * Audio and Video frame extraction  * Copyright (c) 2003 Fabrice Bellard.  * Copyright (c) 2003 Michael Niedermayer.  *  * This library is free software; you can redistribute it and/or  * modify it under the terms of the GNU Lesser General Public  * License as published by the Free Software Foundation; either  * version 2 of the License, or (at your option) any later version.  *  * This library is distributed in the hope that it will be useful,  * but WITHOUT ANY WARRANTY; without even the implied warranty of  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU  * Lesser General Public License for more details.  *  * You should have received a copy of the GNU Lesser General Public  * License along with this library; if not, write to the Free Software  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  */ #include "avcodec.h" #include "mpegvideo.h" //#include "mpegaudio.h"
  2. AVCodecParser *av_first_parser = NULL;
  3. void av_register_codec_parser(AVCodecParser *parser)
  4. {
  5.     parser->next = av_first_parser;
  6.     av_first_parser = parser;
  7. }
  8. AVCodecParserContext *av_parser_init(int codec_id)
  9. {
  10.     AVCodecParserContext *s;
  11.     AVCodecParser *parser;
  12.     int ret;
  13.     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
  14.         if (parser->codec_ids[0] == codec_id ||
  15.             parser->codec_ids[1] == codec_id ||
  16.             parser->codec_ids[2] == codec_id)
  17.             goto found;
  18.     }
  19.     return NULL;
  20.  found:
  21.     s = av_mallocz(sizeof(AVCodecParserContext));
  22.     if (!s)
  23.         return NULL;
  24.     s->parser = parser;
  25.     s->priv_data = av_mallocz(parser->priv_data_size);
  26.     if (!s->priv_data) {
  27.         av_free(s);
  28.         return NULL;
  29.     }
  30.     if (parser->parser_init) {
  31.         ret = parser->parser_init(s);
  32.         if (ret != 0) {
  33.             av_free(s->priv_data);
  34.             av_free(s);
  35.             return NULL;
  36.         }
  37.     }
  38.     s->fetch_timestamp=1;
  39.     return s;
  40. }
  41. /* NOTE: buf_size == 0 is used to signal EOF so that the last frame
  42.    can be returned if necessary */
  43. int av_parser_parse(AVCodecParserContext *s, 
  44.                     AVCodecContext *avctx,
  45.                     uint8_t **poutbuf, int *poutbuf_size, 
  46.                     const uint8_t *buf, int buf_size,
  47.                     int64_t pts, int64_t dts)
  48. {
  49.     int index, i, k;
  50.     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
  51.     
  52.     if (buf_size == 0) {
  53.         /* padding is always necessary even if EOF, so we add it here */
  54.         memset(dummy_buf, 0, sizeof(dummy_buf));
  55.         buf = dummy_buf;
  56.     } else {
  57.         /* add a new packet descriptor */
  58.         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
  59.         s->cur_frame_start_index = k;
  60.         s->cur_frame_offset[k] = s->cur_offset;
  61.         s->cur_frame_pts[k] = pts;
  62.         s->cur_frame_dts[k] = dts;
  63.         /* fill first PTS/DTS */
  64.         if (s->fetch_timestamp){
  65.             s->fetch_timestamp=0;
  66.             s->last_pts = pts;
  67.             s->last_dts = dts;
  68.             s->cur_frame_pts[k] =
  69.             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
  70.         }
  71.     }
  72.     /* WARNING: the returned index can be negative */
  73.     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
  74. //av_log(NULL, AV_LOG_DEBUG, "parser: in:%lld, %lld, out:%lld, %lld, in:%d out:%d id:%dn", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
  75.     /* update the file pointer */
  76.     if (*poutbuf_size) {
  77.         /* fill the data for the current frame */
  78.         s->frame_offset = s->last_frame_offset;
  79.         s->pts = s->last_pts;
  80.         s->dts = s->last_dts;
  81.         
  82.         /* offset of the next frame */
  83.         s->last_frame_offset = s->cur_offset + index;
  84.         /* find the packet in which the new frame starts. It
  85.            is tricky because of MPEG video start codes
  86.            which can begin in one packet and finish in
  87.            another packet. In the worst case, an MPEG
  88.            video start code could be in 4 different
  89.            packets. */
  90.         k = s->cur_frame_start_index;
  91.         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
  92.             if (s->last_frame_offset >= s->cur_frame_offset[k])
  93.                 break;
  94.             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
  95.         }
  96.         s->last_pts = s->cur_frame_pts[k];
  97.         s->last_dts = s->cur_frame_dts[k];
  98.         
  99.         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
  100.            so the next pts/dts is in the next chunk */
  101.         if(index == buf_size){
  102.             s->fetch_timestamp=1;
  103.         }
  104.     }
  105.     if (index < 0)
  106.         index = 0;
  107.     s->cur_offset += index;
  108.     return index;
  109. }
  110. void av_parser_close(AVCodecParserContext *s)
  111. {
  112.     if (s->parser->parser_close)
  113.         s->parser->parser_close(s);
  114.     av_free(s->priv_data);
  115.     av_free(s);
  116. }
  117. /*****************************************************/
  118. //#define END_NOT_FOUND (-100)
  119. #define PICTURE_START_CODE 0x00000100
  120. #define SEQ_START_CODE 0x000001b3
  121. #define EXT_START_CODE 0x000001b5
  122. #define SLICE_MIN_START_CODE 0x00000101
  123. #define SLICE_MAX_START_CODE 0x000001af
  124. typedef struct ParseContext1{
  125.     ParseContext pc;
  126. /* XXX/FIXME PC1 vs. PC */
  127.     /* MPEG2 specific */
  128.     int frame_rate;
  129.     int progressive_sequence;
  130.     int width, height;
  131.     /* XXX: suppress that, needed by MPEG4 */
  132.     MpegEncContext *enc;
  133.     int first_picture;
  134. } ParseContext1;
  135. /**
  136.  * combines the (truncated) bitstream to a complete frame
  137.  * @returns -1 if no complete frame could be created
  138.  */
  139. int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
  140. {
  141. #if 0
  142.     if(pc->overread){
  143.         printf("overread %d, state:%X next:%d index:%d o_index:%dn", pc->overread, pc->state, next, pc->index, pc->overread_index);
  144.         printf("%X %X %X %Xn", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
  145.     }
  146. #endif
  147.     /* copy overreaded bytes from last frame into buffer */
  148.     for(; pc->overread>0; pc->overread--){
  149.         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
  150.     }
  151.     
  152.     pc->last_index= pc->index;
  153.     /* copy into buffer end return */
  154.     if(next == END_NOT_FOUND){
  155.         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
  156.         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
  157.         pc->index += *buf_size;
  158.         return -1;
  159.     }
  160.     *buf_size=
  161.     pc->overread_index= pc->index + next;
  162.     
  163.     /* append to buffer */
  164.     if(pc->index){
  165.         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
  166.         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
  167.         pc->index = 0;
  168.         *buf= pc->buffer;
  169.     }
  170.     /* store overread bytes */
  171.     for(;next < 0; next++){
  172.         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
  173.         pc->overread++;
  174.     }
  175. #if 0
  176.     if(pc->overread){
  177.         printf("overread %d, state:%X next:%d index:%d o_index:%dn", pc->overread, pc->state, next, pc->index, pc->overread_index);
  178.         printf("%X %X %X %Xn", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
  179.     }
  180. #endif
  181.     return 0;
  182. }
  183. static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
  184. {
  185.     const uint8_t *buf_ptr;
  186.     unsigned int state=0xFFFFFFFF, v;
  187.     int val;
  188.     buf_ptr = *pbuf_ptr;
  189.     while (buf_ptr < buf_end) {
  190.         v = *buf_ptr++;
  191.         if (state == 0x000001) {
  192.             state = ((state << 8) | v) & 0xffffff;
  193.             val = state;
  194.             goto found;
  195.         }
  196.         state = ((state << 8) | v) & 0xffffff;
  197.     }
  198.     val = -1;
  199.  found:
  200.     *pbuf_ptr = buf_ptr;
  201.     return val;
  202. }
  203. /* XXX: merge with libavcodec ? */
  204. #define MPEG1_FRAME_RATE_BASE 1001
  205. static const int frame_rate_tab[16] = {
  206.         0,        
  207.     24000,
  208.     24024,
  209.     25025,
  210.     30000,
  211.     30030,
  212.     50050,
  213.     60000,
  214.     60060,
  215.   // Xing's 15fps: (9)
  216.     15015,
  217.   // libmpeg3's "Unofficial economy rates": (10-13)
  218.      5005,
  219.     10010,
  220.     12012,
  221.     15015,
  222.   // random, just to avoid segfault !never encode these
  223.     25025,
  224.     25025,
  225. };
  226. static void mpegvideo_extract_headers(AVCodecParserContext *s, 
  227.                                       AVCodecContext *avctx,
  228.                                       const uint8_t *buf, int buf_size)
  229. {
  230.     ParseContext1 *pc = s->priv_data;
  231.     const uint8_t *buf_end;
  232.     int32_t start_code;
  233.     int frame_rate_index, ext_type, bytes_left;
  234.     int frame_rate_ext_n, frame_rate_ext_d;
  235.     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
  236.     int horiz_size_ext, vert_size_ext;
  237.     s->repeat_pict = 0;
  238.     buf_end = buf + buf_size;
  239.     while (buf < buf_end) {
  240.         start_code = find_start_code(&buf, buf_end);
  241.         bytes_left = buf_end - buf;
  242.         switch(start_code) {
  243.         case PICTURE_START_CODE:
  244.             if (bytes_left >= 2) {
  245.                 s->pict_type = (buf[1] >> 3) & 7;
  246.             }
  247.             break;
  248.         case SEQ_START_CODE:
  249.             if (bytes_left >= 4) {
  250.                 pc->width = avctx->width = (buf[0] << 4) | (buf[1] >> 4);
  251.                 pc->height = avctx->height = ((buf[1] & 0x0f) << 8) | buf[2];
  252.                 frame_rate_index = buf[3] & 0xf;
  253.                 pc->frame_rate = avctx->frame_rate = frame_rate_tab[frame_rate_index];
  254.                 avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE;
  255.                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
  256.                 avctx->sub_id = 1;
  257.             }
  258.             break;
  259.         case EXT_START_CODE:
  260.             if (bytes_left >= 1) {
  261.                 ext_type = (buf[0] >> 4);
  262.                 switch(ext_type) {
  263.                 case 0x1: /* sequence extension */
  264.                     if (bytes_left >= 6) {
  265.                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
  266.                         vert_size_ext = (buf[2] >> 5) & 3;
  267.                         frame_rate_ext_n = (buf[5] >> 5) & 3;
  268.                         frame_rate_ext_d = (buf[5] & 0x1f);
  269.                         pc->progressive_sequence = buf[1] & (1 << 3);
  270.                         avctx->width = pc->width | (horiz_size_ext << 12);
  271.                         avctx->height = pc->height | (vert_size_ext << 12);
  272.                         avctx->frame_rate = pc->frame_rate * (frame_rate_ext_n + 1);
  273.                         avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
  274.                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
  275.                         avctx->sub_id = 2; /* forces MPEG2 */
  276.                     }
  277.                     break;
  278.                 case 0x8: /* picture coding extension */
  279.                     if (bytes_left >= 5) {
  280.                         picture_structure = buf[2]&3;
  281.                         top_field_first = buf[3] & (1 << 7);
  282.                         repeat_first_field = buf[3] & (1 << 1);
  283.                         progressive_frame = buf[4] & (1 << 7);
  284.                     
  285.                         /* check if we must repeat the frame */
  286.                         if (repeat_first_field) {
  287.                             if (pc->progressive_sequence) {
  288.                                 if (top_field_first)
  289.                                     s->repeat_pict = 4;
  290.                                 else
  291.                                     s->repeat_pict = 2;
  292.                             } else if (progressive_frame) {
  293.                                 s->repeat_pict = 1;
  294.                             }
  295.                         }
  296.                         
  297.                         /* the packet only represents half a frame 
  298.                            XXX,FIXME maybe find a different solution */
  299.                         if(picture_structure != 3)
  300.                             s->repeat_pict = -1;
  301.                     }
  302.                     break;
  303.                 }
  304.             }
  305.             break;
  306.         case -1:
  307.             goto the_end;
  308.         default:
  309.             /* we stop parsing when we encounter a slice. It ensures
  310.                that this function takes a negligible amount of time */
  311.             if (start_code >= SLICE_MIN_START_CODE && 
  312.                 start_code <= SLICE_MAX_START_CODE)
  313.                 goto the_end;
  314.             break;
  315.         }
  316.     }
  317.  the_end: ;
  318. }
  319. static int mpegvideo_parse(AVCodecParserContext *s,
  320.                            AVCodecContext *avctx,
  321.                            uint8_t **poutbuf, int *poutbuf_size, 
  322.                            const uint8_t *buf, int buf_size)
  323. {
  324.     ParseContext1 *pc1 = s->priv_data;
  325.     ParseContext *pc= &pc1->pc;
  326.     int next;
  327.     
  328.     next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
  329.     
  330.     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
  331.         *poutbuf = NULL;
  332.         *poutbuf_size = 0;
  333.         return buf_size;
  334.     }
  335.     /* we have a full frame : we just parse the first few MPEG headers
  336.        to have the full timing information. The time take by this
  337.        function should be negligible for uncorrupted streams */
  338.     mpegvideo_extract_headers(s, avctx, buf, buf_size);
  339. #if 0
  340.     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%dn", 
  341.            s->pict_type, (double)avctx->frame_rate / avctx->frame_rate_base, s->repeat_pict);
  342. #endif
  343.     *poutbuf = (uint8_t *)buf;
  344.     *poutbuf_size = buf_size;
  345.     return next;
  346. }
  347. void ff_parse_close(AVCodecParserContext *s)
  348. {
  349.     ParseContext *pc = s->priv_data;
  350.     av_free(pc->buffer);
  351. }
  352. static void parse1_close(AVCodecParserContext *s)
  353. {
  354.     ParseContext1 *pc1 = s->priv_data;
  355.     av_free(pc1->pc.buffer);
  356.     av_free(pc1->enc);
  357. }
  358. /*************************/
  359. /* used by parser */
  360. /* XXX: make it use less memory */
  361. static int av_mpeg4_decode_header(AVCodecParserContext *s1, 
  362.                                   AVCodecContext *avctx,
  363.                                   const uint8_t *buf, int buf_size)
  364. {
  365.     ParseContext1 *pc = s1->priv_data;
  366.     MpegEncContext *s = pc->enc;
  367.     GetBitContext gb1, *gb = &gb1;
  368.     int ret;
  369.     s->avctx = avctx;
  370.     s->current_picture_ptr = &s->current_picture;
  371.     if (avctx->extradata_size && pc->first_picture){
  372.         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
  373.         ret = ff_mpeg4_decode_picture_header(s, gb);
  374.     }
  375.     init_get_bits(gb, buf, 8 * buf_size);
  376.     ret = ff_mpeg4_decode_picture_header(s, gb);
  377.     if (s->width) {
  378.         avctx->width = s->width;
  379.         avctx->height = s->height;
  380.     }
  381.     pc->first_picture = 0;
  382.     return ret;
  383. }
  384. static int mpeg4video_parse_init(AVCodecParserContext *s)
  385. {
  386.     ParseContext1 *pc = s->priv_data;
  387.     pc->enc = av_mallocz(sizeof(MpegEncContext));
  388.     if (!pc->enc)
  389.         return -1;
  390.     pc->first_picture = 1;
  391.     return 0;
  392. }
  393. static int mpeg4video_parse(AVCodecParserContext *s,
  394.                            AVCodecContext *avctx,
  395.                            uint8_t **poutbuf, int *poutbuf_size, 
  396.                            const uint8_t *buf, int buf_size)
  397. {
  398.     ParseContext *pc = s->priv_data;
  399.     int next;
  400.     
  401.     next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
  402.     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
  403.         *poutbuf = NULL;
  404.         *poutbuf_size = 0;
  405.         return buf_size;
  406.     }
  407.     av_mpeg4_decode_header(s, avctx, buf, buf_size);
  408.     *poutbuf = (uint8_t *)buf;
  409.     *poutbuf_size = buf_size;
  410.     return next;
  411. }
  412. ///*************************/
  413. //typedef struct MpegAudioParseContext {
  414. //    uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
  415. //    uint8_t *inbuf_ptr;
  416. //    int frame_size;
  417. //    int free_format_frame_size;
  418. //    int free_format_next_header;
  419. //} MpegAudioParseContext;
  420. //#define MPA_HEADER_SIZE 4
  421. ///* header + layer + bitrate + freq + lsf/mpeg25 */
  422. //#define SAME_HEADER_MASK 
  423. //   (0xffe00000 | (3 << 17) | (0xf << 12) | (3 << 10) | (3 << 19))
  424. //static int mpegaudio_parse_init(AVCodecParserContext *s1)
  425. //{
  426. //    MpegAudioParseContext *s = s1->priv_data;
  427. //    s->inbuf_ptr = s->inbuf;
  428. //    return 0;
  429. //}
  430. //static int mpegaudio_parse(AVCodecParserContext *s1,
  431. //                           AVCodecContext *avctx,
  432. //                           uint8_t **poutbuf, int *poutbuf_size, 
  433. //                           const uint8_t *buf, int buf_size)
  434. //{
  435. //    MpegAudioParseContext *s = s1->priv_data;
  436. //    int len, ret;
  437. //    uint32_t header;
  438. //    const uint8_t *buf_ptr;
  439. //    *poutbuf = NULL;
  440. //    *poutbuf_size = 0;
  441. //    buf_ptr = buf;
  442. //    while (buf_size > 0) {
  443. // len = s->inbuf_ptr - s->inbuf;
  444. // if (s->frame_size == 0) {
  445. //            /* special case for next header for first frame in free
  446. //               format case (XXX: find a simpler method) */
  447. //            if (s->free_format_next_header != 0) {
  448. //                s->inbuf[0] = s->free_format_next_header >> 24;
  449. //                s->inbuf[1] = s->free_format_next_header >> 16;
  450. //                s->inbuf[2] = s->free_format_next_header >> 8;
  451. //                s->inbuf[3] = s->free_format_next_header;
  452. //                s->inbuf_ptr = s->inbuf + 4;
  453. //                s->free_format_next_header = 0;
  454. //                goto got_header;
  455. //            }
  456. //     /* no header seen : find one. We need at least MPA_HEADER_SIZE
  457. //               bytes to parse it */
  458. //     len = MPA_HEADER_SIZE - len;
  459. //     if (len > buf_size)
  460. // len = buf_size;
  461. //     if (len > 0) {
  462. // memcpy(s->inbuf_ptr, buf_ptr, len);
  463. // buf_ptr += len;
  464. // buf_size -= len;
  465. // s->inbuf_ptr += len;
  466. //     }
  467. //     if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
  468. //            got_header:
  469. // header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
  470. //     (s->inbuf[2] << 8) | s->inbuf[3];
  471. //                ret = mpa_decode_header(avctx, header);
  472. //                if (ret < 0) {
  473. //     /* no sync found : move by one byte (inefficient, but simple!) */
  474. //     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
  475. //     s->inbuf_ptr--;
  476. //                    dprintf("skip %xn", header);
  477. //                    /* reset free format frame size to give a chance
  478. //                       to get a new bitrate */
  479. //                    s->free_format_frame_size = 0;
  480. // } else {
  481. //                    s->frame_size = ret;
  482. //#if 0
  483. //                    /* free format: prepare to compute frame size */
  484. //     if (decode_header(s, header) == 1) {
  485. // s->frame_size = -1;
  486. //                    }
  487. //#endif
  488. // }
  489. //     }
  490. //        } else 
  491. //#if 0
  492. //        if (s->frame_size == -1) {
  493. //            /* free format : find next sync to compute frame size */
  494. //     len = MPA_MAX_CODED_FRAME_SIZE - len;
  495. //     if (len > buf_size)
  496. // len = buf_size;
  497. //            if (len == 0) {
  498. // /* frame too long: resync */
  499. //                s->frame_size = 0;
  500. // memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
  501. // s->inbuf_ptr--;
  502. //            } else {
  503. //                uint8_t *p, *pend;
  504. //                uint32_t header1;
  505. //                int padding;
  506. //                memcpy(s->inbuf_ptr, buf_ptr, len);
  507. //                /* check for header */
  508. //                p = s->inbuf_ptr - 3;
  509. //                pend = s->inbuf_ptr + len - 4;
  510. //                while (p <= pend) {
  511. //                    header = (p[0] << 24) | (p[1] << 16) |
  512. //                        (p[2] << 8) | p[3];
  513. //                    header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
  514. //                        (s->inbuf[2] << 8) | s->inbuf[3];
  515. //                    /* check with high probability that we have a
  516. //                       valid header */
  517. //                    if ((header & SAME_HEADER_MASK) ==
  518. //                        (header1 & SAME_HEADER_MASK)) {
  519. //                        /* header found: update pointers */
  520. //                        len = (p + 4) - s->inbuf_ptr;
  521. //                        buf_ptr += len;
  522. //                        buf_size -= len;
  523. //                        s->inbuf_ptr = p;
  524. //                        /* compute frame size */
  525. //                        s->free_format_next_header = header;
  526. //                        s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
  527. //                        padding = (header1 >> 9) & 1;
  528. //                        if (s->layer == 1)
  529. //                            s->free_format_frame_size -= padding * 4;
  530. //                        else
  531. //                            s->free_format_frame_size -= padding;
  532. //                        dprintf("free frame size=%d padding=%dn", 
  533. //                                s->free_format_frame_size, padding);
  534. //                        decode_header(s, header1);
  535. //                        goto next_data;
  536. //                    }
  537. //                    p++;
  538. //                }
  539. //                /* not found: simply increase pointers */
  540. //                buf_ptr += len;
  541. //                s->inbuf_ptr += len;
  542. //                buf_size -= len;
  543. //            }
  544. // } else 
  545. //#endif
  546. //        if (len < s->frame_size) {
  547. //            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
  548. //                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
  549. //     len = s->frame_size - len;
  550. //     if (len > buf_size)
  551. // len = buf_size;
  552. //     memcpy(s->inbuf_ptr, buf_ptr, len);
  553. //     buf_ptr += len;
  554. //     s->inbuf_ptr += len;
  555. //     buf_size -= len;
  556. // }
  557. //        //    next_data:
  558. //        if (s->frame_size > 0 && 
  559. //            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
  560. //            *poutbuf = s->inbuf;
  561. //            *poutbuf_size = s->inbuf_ptr - s->inbuf;
  562. //     s->inbuf_ptr = s->inbuf;
  563. //     s->frame_size = 0;
  564. //     break;
  565. // }
  566. //    }
  567. //    return buf_ptr - buf;
  568. //}
  569. //#ifdef CONFIG_AC3
  570. //extern int a52_syncinfo (const uint8_t * buf, int * flags,
  571. //                         int * sample_rate, int * bit_rate);
  572. //typedef struct AC3ParseContext {
  573. //    uint8_t inbuf[4096]; /* input buffer */
  574. //    uint8_t *inbuf_ptr;
  575. //    int frame_size;
  576. //    int flags;
  577. //} AC3ParseContext;
  578. //#define AC3_HEADER_SIZE 7
  579. //#define A52_LFE 16
  580. //static int ac3_parse_init(AVCodecParserContext *s1)
  581. //{
  582. //    AC3ParseContext *s = s1->priv_data;
  583. //    s->inbuf_ptr = s->inbuf;
  584. //    return 0;
  585. //}
  586. //static int ac3_parse(AVCodecParserContext *s1,
  587. //                     AVCodecContext *avctx,
  588. //                     uint8_t **poutbuf, int *poutbuf_size, 
  589. //                     const uint8_t *buf, int buf_size)
  590. //{
  591. //    AC3ParseContext *s = s1->priv_data;
  592. //    const uint8_t *buf_ptr;
  593. //    int len, sample_rate, bit_rate;
  594. //    static const int ac3_channels[8] = {
  595. // 2, 1, 2, 3, 3, 4, 4, 5
  596. //    };
  597. //    *poutbuf = NULL;
  598. //    *poutbuf_size = 0;
  599. //    buf_ptr = buf;
  600. //    while (buf_size > 0) {
  601. //        len = s->inbuf_ptr - s->inbuf;
  602. //        if (s->frame_size == 0) {
  603. //            /* no header seen : find one. We need at least 7 bytes to parse it */
  604. //            len = AC3_HEADER_SIZE - len;
  605. //            if (len > buf_size)
  606. //                len = buf_size;
  607. //            memcpy(s->inbuf_ptr, buf_ptr, len);
  608. //            buf_ptr += len;
  609. //            s->inbuf_ptr += len;
  610. //            buf_size -= len;
  611. //            if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
  612. //                len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
  613. //                if (len == 0) {
  614. //                    /* no sync found : move by one byte (inefficient, but simple!) */
  615. //                    memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
  616. //                    s->inbuf_ptr--;
  617. //                } else {
  618. //     s->frame_size = len;
  619. //                    /* update codec info */
  620. //                    avctx->sample_rate = sample_rate;
  621. //                    /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
  622. //                    if(avctx->channels!=1 && avctx->channels!=2){
  623. //                        avctx->channels = ac3_channels[s->flags & 7];
  624. //                        if (s->flags & A52_LFE)
  625. //                            avctx->channels++;
  626. //                    }
  627. //     avctx->bit_rate = bit_rate;
  628. //                    avctx->frame_size = 6 * 256;
  629. //                }
  630. //            }
  631. //        } else if (len < s->frame_size) {
  632. //            len = s->frame_size - len;
  633. //            if (len > buf_size)
  634. //                len = buf_size;
  635. //            memcpy(s->inbuf_ptr, buf_ptr, len);
  636. //            buf_ptr += len;
  637. //            s->inbuf_ptr += len;
  638. //            buf_size -= len;
  639. //        } else {
  640. //            *poutbuf = s->inbuf;
  641. //            *poutbuf_size = s->frame_size;
  642. //            s->inbuf_ptr = s->inbuf;
  643. //            s->frame_size = 0;
  644. //            break;
  645. //        }
  646. //    }
  647. //    return buf_ptr - buf;
  648. //}
  649. //#endif
  650. //AVCodecParser mpegvideo_parser = {
  651. //    { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
  652. //    sizeof(ParseContext1),
  653. //    NULL,
  654. //    mpegvideo_parse,
  655. //    parse1_close,
  656. //};
  657. //AVCodecParser mpeg4video_parser = {
  658. //    { CODEC_ID_MPEG4 },
  659. //    sizeof(ParseContext1),
  660. //    mpeg4video_parse_init,
  661. //    mpeg4video_parse,
  662. //    parse1_close,
  663. //};
  664. //AVCodecParser mpegaudio_parser = {
  665. //    { CODEC_ID_MP2, CODEC_ID_MP3 },
  666. //    sizeof(MpegAudioParseContext),
  667. //    mpegaudio_parse_init,
  668. //    mpegaudio_parse,
  669. //    NULL,
  670. //};
  671. //#ifdef CONFIG_AC3
  672. //AVCodecParser ac3_parser = {
  673. //    { CODEC_ID_AC3 },
  674. //    sizeof(AC3ParseContext),
  675. //    ac3_parse_init,
  676. //    ac3_parse,
  677. //    NULL,
  678. //};
  679. //#endif