2 * Audio and Video frame extraction
3 * Copyright (c) 2003 Fabrice Bellard.
4 * Copyright (c) 2003 Michael Niedermayer.
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include "mpegvideo.h"
24 #include "mpegaudio.h"
27 AVCodecParser *av_first_parser = NULL;
29 void av_register_codec_parser(AVCodecParser *parser)
31 parser->next = av_first_parser;
32 av_first_parser = parser;
35 AVCodecParserContext *av_parser_init(int codec_id)
37 AVCodecParserContext *s;
38 AVCodecParser *parser;
41 if(codec_id == CODEC_ID_NONE)
44 for(parser = av_first_parser; parser != NULL; parser = parser->next) {
45 if (parser->codec_ids[0] == codec_id ||
46 parser->codec_ids[1] == codec_id ||
47 parser->codec_ids[2] == codec_id ||
48 parser->codec_ids[3] == codec_id ||
49 parser->codec_ids[4] == codec_id)
54 s = av_mallocz(sizeof(AVCodecParserContext));
58 s->priv_data = av_mallocz(parser->priv_data_size);
63 if (parser->parser_init) {
64 ret = parser->parser_init(s);
66 av_free(s->priv_data);
78 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output)
79 * @param pts input presentation timestamp
80 * @param dts input decoding timestamp
81 * @param poutbuf will contain a pointer to the first byte of the output frame
82 * @param poutbuf_size will contain the length of the output frame
83 * @return the number of bytes of the input bitstream used
88 * len = av_parser_parse(myparser, AVCodecContext, &data, &size,
94 * decode_frame(data, size);
98 int av_parser_parse(AVCodecParserContext *s,
99 AVCodecContext *avctx,
100 uint8_t **poutbuf, int *poutbuf_size,
101 const uint8_t *buf, int buf_size,
102 int64_t pts, int64_t dts)
105 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
108 /* padding is always necessary even if EOF, so we add it here */
109 memset(dummy_buf, 0, sizeof(dummy_buf));
112 /* add a new packet descriptor */
113 k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
114 s->cur_frame_start_index = k;
115 s->cur_frame_offset[k] = s->cur_offset;
116 s->cur_frame_pts[k] = pts;
117 s->cur_frame_dts[k] = dts;
119 /* fill first PTS/DTS */
120 if (s->fetch_timestamp){
121 s->fetch_timestamp=0;
124 s->cur_frame_pts[k] =
125 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
129 /* WARNING: the returned index can be negative */
130 index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
131 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%"PRId64", %"PRId64", out:%"PRId64", %"PRId64", in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
132 /* update the file pointer */
134 /* fill the data for the current frame */
135 s->frame_offset = s->last_frame_offset;
136 s->pts = s->last_pts;
137 s->dts = s->last_dts;
139 /* offset of the next frame */
140 s->last_frame_offset = s->cur_offset + index;
141 /* find the packet in which the new frame starts. It
142 is tricky because of MPEG video start codes
143 which can begin in one packet and finish in
144 another packet. In the worst case, an MPEG
145 video start code could be in 4 different
147 k = s->cur_frame_start_index;
148 for(i = 0; i < AV_PARSER_PTS_NB; i++) {
149 if (s->last_frame_offset >= s->cur_frame_offset[k])
151 k = (k - 1) & (AV_PARSER_PTS_NB - 1);
154 s->last_pts = s->cur_frame_pts[k];
155 s->last_dts = s->cur_frame_dts[k];
157 /* some parsers tell us the packet size even before seeing the first byte of the next packet,
158 so the next pts/dts is in the next chunk */
159 if(index == buf_size){
160 s->fetch_timestamp=1;
165 s->cur_offset += index;
171 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
172 * @deprecated use AVBitstreamFilter
174 int av_parser_change(AVCodecParserContext *s,
175 AVCodecContext *avctx,
176 uint8_t **poutbuf, int *poutbuf_size,
177 const uint8_t *buf, int buf_size, int keyframe){
179 if(s && s->parser->split){
180 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
181 int i= s->parser->split(avctx, buf, buf_size);
187 /* cast to avoid warning about discarding qualifiers */
188 *poutbuf= (uint8_t *) buf;
189 *poutbuf_size= buf_size;
190 if(avctx->extradata){
191 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
192 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
193 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
194 int size= buf_size + avctx->extradata_size;
196 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
198 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
199 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
207 void av_parser_close(AVCodecParserContext *s)
209 if (s->parser->parser_close)
210 s->parser->parser_close(s);
211 av_free(s->priv_data);
215 /*****************************************************/
218 * combines the (truncated) bitstream to a complete frame
219 * @returns -1 if no complete frame could be created
221 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
225 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
226 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
230 /* copy overreaded bytes from last frame into buffer */
231 for(; pc->overread>0; pc->overread--){
232 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
235 /* flush remaining if EOF */
236 if(!*buf_size && next == END_NOT_FOUND){
240 pc->last_index= pc->index;
242 /* copy into buffer end return */
243 if(next == END_NOT_FOUND){
244 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
246 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
247 pc->index += *buf_size;
252 pc->overread_index= pc->index + next;
254 /* append to buffer */
256 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
258 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
263 /* store overread bytes */
264 for(;next < 0; next++){
265 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
271 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
272 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
279 void ff_parse_close(AVCodecParserContext *s)
281 ParseContext *pc = s->priv_data;
286 void ff_parse1_close(AVCodecParserContext *s)
288 ParseContext1 *pc1 = s->priv_data;
290 av_free(pc1->pc.buffer);
294 /*************************/
296 #ifdef CONFIG_MPEG4VIDEO_PARSER
298 /* XXX: make it use less memory */
299 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
300 AVCodecContext *avctx,
301 const uint8_t *buf, int buf_size)
303 ParseContext1 *pc = s1->priv_data;
304 MpegEncContext *s = pc->enc;
305 GetBitContext gb1, *gb = &gb1;
309 s->current_picture_ptr = &s->current_picture;
311 if (avctx->extradata_size && pc->first_picture){
312 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
313 ret = ff_mpeg4_decode_picture_header(s, gb);
316 init_get_bits(gb, buf, 8 * buf_size);
317 ret = ff_mpeg4_decode_picture_header(s, gb);
319 avcodec_set_dimensions(avctx, s->width, s->height);
321 s1->pict_type= s->pict_type;
322 pc->first_picture = 0;
326 static int mpeg4video_parse_init(AVCodecParserContext *s)
328 ParseContext1 *pc = s->priv_data;
330 pc->enc = av_mallocz(sizeof(MpegEncContext));
333 pc->first_picture = 1;
337 static int mpeg4video_parse(AVCodecParserContext *s,
338 AVCodecContext *avctx,
339 uint8_t **poutbuf, int *poutbuf_size,
340 const uint8_t *buf, int buf_size)
342 ParseContext *pc = s->priv_data;
345 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
348 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
350 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
356 av_mpeg4_decode_header(s, avctx, buf, buf_size);
358 *poutbuf = (uint8_t *)buf;
359 *poutbuf_size = buf_size;
364 #ifdef CONFIG_CAVSVIDEO_PARSER
365 static int cavsvideo_parse(AVCodecParserContext *s,
366 AVCodecContext *avctx,
367 uint8_t **poutbuf, int *poutbuf_size,
368 const uint8_t *buf, int buf_size)
370 ParseContext *pc = s->priv_data;
373 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
376 next= ff_cavs_find_frame_end(pc, buf, buf_size);
378 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
384 *poutbuf = (uint8_t *)buf;
385 *poutbuf_size = buf_size;
388 #endif /* CONFIG_CAVSVIDEO_PARSER */
390 static int mpeg4video_split(AVCodecContext *avctx,
391 const uint8_t *buf, int buf_size)
396 for(i=0; i<buf_size; i++){
397 state= (state<<8) | buf[i];
398 if(state == 0x1B3 || state == 0x1B6)
404 /*************************/
406 #ifdef CONFIG_MPEGAUDIO_PARSER
407 typedef struct MpegAudioParseContext {
408 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
411 int free_format_frame_size;
412 int free_format_next_header;
415 } MpegAudioParseContext;
417 #define MPA_HEADER_SIZE 4
419 /* header + layer + bitrate + freq + lsf/mpeg25 */
420 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
421 #define SAME_HEADER_MASK \
422 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
424 static int mpegaudio_parse_init(AVCodecParserContext *s1)
426 MpegAudioParseContext *s = s1->priv_data;
427 s->inbuf_ptr = s->inbuf;
431 static int mpegaudio_parse(AVCodecParserContext *s1,
432 AVCodecContext *avctx,
433 uint8_t **poutbuf, int *poutbuf_size,
434 const uint8_t *buf, int buf_size)
436 MpegAudioParseContext *s = s1->priv_data;
439 const uint8_t *buf_ptr;
444 while (buf_size > 0) {
445 len = s->inbuf_ptr - s->inbuf;
446 if (s->frame_size == 0) {
447 /* special case for next header for first frame in free
448 format case (XXX: find a simpler method) */
449 if (s->free_format_next_header != 0) {
450 s->inbuf[0] = s->free_format_next_header >> 24;
451 s->inbuf[1] = s->free_format_next_header >> 16;
452 s->inbuf[2] = s->free_format_next_header >> 8;
453 s->inbuf[3] = s->free_format_next_header;
454 s->inbuf_ptr = s->inbuf + 4;
455 s->free_format_next_header = 0;
458 /* no header seen : find one. We need at least MPA_HEADER_SIZE
460 len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
462 memcpy(s->inbuf_ptr, buf_ptr, len);
467 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
469 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
470 (s->inbuf[2] << 8) | s->inbuf[3];
472 ret = mpa_decode_header(avctx, header, &sr);
475 /* no sync found : move by one byte (inefficient, but simple!) */
476 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
478 dprintf("skip %x\n", header);
479 /* reset free format frame size to give a chance
480 to get a new bitrate */
481 s->free_format_frame_size = 0;
483 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
490 /* free format: prepare to compute frame size */
491 if (decode_header(s, header) == 1) {
496 if(s->header_count > 1)
497 avctx->sample_rate= sr;
501 if (s->frame_size == -1) {
502 /* free format : find next sync to compute frame size */
503 len = MPA_MAX_CODED_FRAME_SIZE - len;
507 /* frame too long: resync */
509 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
516 memcpy(s->inbuf_ptr, buf_ptr, len);
517 /* check for header */
518 p = s->inbuf_ptr - 3;
519 pend = s->inbuf_ptr + len - 4;
521 header = (p[0] << 24) | (p[1] << 16) |
523 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
524 (s->inbuf[2] << 8) | s->inbuf[3];
525 /* check with high probability that we have a
527 if ((header & SAME_HEADER_MASK) ==
528 (header1 & SAME_HEADER_MASK)) {
529 /* header found: update pointers */
530 len = (p + 4) - s->inbuf_ptr;
534 /* compute frame size */
535 s->free_format_next_header = header;
536 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
537 padding = (header1 >> 9) & 1;
539 s->free_format_frame_size -= padding * 4;
541 s->free_format_frame_size -= padding;
542 dprintf("free frame size=%d padding=%d\n",
543 s->free_format_frame_size, padding);
544 decode_header(s, header1);
549 /* not found: simply increase pointers */
556 if (len < s->frame_size) {
557 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
558 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
559 len = FFMIN(s->frame_size - len, buf_size);
560 memcpy(s->inbuf_ptr, buf_ptr, len);
566 if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
567 && buf_size + buf_ptr - buf >= s->frame_size){
568 if(s->header_count > 0){
570 *poutbuf_size = s->frame_size;
572 buf_ptr = buf + s->frame_size;
573 s->inbuf_ptr = s->inbuf;
579 if (s->frame_size > 0 &&
580 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
581 if(s->header_count > 0){
583 *poutbuf_size = s->inbuf_ptr - s->inbuf;
585 s->inbuf_ptr = s->inbuf;
590 return buf_ptr - buf;
592 #endif /* CONFIG_MPEGAUDIO_PARSER */
594 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
595 /* also used for ADTS AAC */
596 typedef struct AC3ParseContext {
600 int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
601 int *bit_rate, int *samples);
602 uint8_t inbuf[8192]; /* input buffer */
605 #define AC3_HEADER_SIZE 7
606 #define AAC_HEADER_SIZE 7
608 #ifdef CONFIG_AC3_PARSER
609 static const int ac3_sample_rates[4] = {
610 48000, 44100, 32000, 0
613 static const int ac3_frame_sizes[64][3] = {
646 { 1024, 1114, 1536 },
647 { 1024, 1115, 1536 },
648 { 1152, 1253, 1728 },
649 { 1152, 1254, 1728 },
650 { 1280, 1393, 1920 },
651 { 1280, 1394, 1920 },
654 static const int ac3_bitrates[64] = {
655 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
656 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
657 384, 448, 448, 512, 512, 576, 576, 640, 640,
660 static const int ac3_channels[8] = {
661 2, 1, 2, 3, 3, 4, 4, 5
663 #endif /* CONFIG_AC3_PARSER */
665 #ifdef CONFIG_AAC_PARSER
666 static const int aac_sample_rates[16] = {
667 96000, 88200, 64000, 48000, 44100, 32000,
668 24000, 22050, 16000, 12000, 11025, 8000, 7350
671 static const int aac_channels[8] = {
672 0, 1, 2, 3, 4, 5, 6, 8
676 #ifdef CONFIG_AC3_PARSER
677 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
678 int *bit_rate, int *samples)
680 unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
683 init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
685 if(get_bits(&bits, 16) != 0x0b77)
688 skip_bits(&bits, 16); /* crc */
689 fscod = get_bits(&bits, 2);
690 frmsizecod = get_bits(&bits, 6);
692 if(!ac3_sample_rates[fscod])
695 bsid = get_bits(&bits, 5);
698 skip_bits(&bits, 3); /* bsmod */
699 acmod = get_bits(&bits, 3);
700 if(acmod & 1 && acmod != 1)
701 skip_bits(&bits, 2); /* cmixlev */
703 skip_bits(&bits, 2); /* surmixlev */
705 skip_bits(&bits, 2); /* dsurmod */
706 lfeon = get_bits1(&bits);
708 *sample_rate = ac3_sample_rates[fscod];
709 *bit_rate = ac3_bitrates[frmsizecod] * 1000;
710 *channels = ac3_channels[acmod] + lfeon;
713 return ac3_frame_sizes[frmsizecod][fscod] * 2;
715 #endif /* CONFIG_AC3_PARSER */
717 #ifdef CONFIG_AAC_PARSER
718 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
719 int *bit_rate, int *samples)
722 int size, rdb, ch, sr;
724 init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
726 if(get_bits(&bits, 12) != 0xfff)
729 skip_bits1(&bits); /* id */
730 skip_bits(&bits, 2); /* layer */
731 skip_bits1(&bits); /* protection_absent */
732 skip_bits(&bits, 2); /* profile_objecttype */
733 sr = get_bits(&bits, 4); /* sample_frequency_index */
734 if(!aac_sample_rates[sr])
736 skip_bits1(&bits); /* private_bit */
737 ch = get_bits(&bits, 3); /* channel_configuration */
738 if(!aac_channels[ch])
740 skip_bits1(&bits); /* original/copy */
741 skip_bits1(&bits); /* home */
743 /* adts_variable_header */
744 skip_bits1(&bits); /* copyright_identification_bit */
745 skip_bits1(&bits); /* copyright_identification_start */
746 size = get_bits(&bits, 13); /* aac_frame_length */
747 skip_bits(&bits, 11); /* adts_buffer_fullness */
748 rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
750 *channels = aac_channels[ch];
751 *sample_rate = aac_sample_rates[sr];
752 *samples = (rdb + 1) * 1024;
753 *bit_rate = size * 8 * *sample_rate / *samples;
757 #endif /* CONFIG_AAC_PARSER */
759 #ifdef CONFIG_AC3_PARSER
760 static int ac3_parse_init(AVCodecParserContext *s1)
762 AC3ParseContext *s = s1->priv_data;
763 s->inbuf_ptr = s->inbuf;
764 s->header_size = AC3_HEADER_SIZE;
770 #ifdef CONFIG_AAC_PARSER
771 static int aac_parse_init(AVCodecParserContext *s1)
773 AC3ParseContext *s = s1->priv_data;
774 s->inbuf_ptr = s->inbuf;
775 s->header_size = AAC_HEADER_SIZE;
781 /* also used for ADTS AAC */
782 static int ac3_parse(AVCodecParserContext *s1,
783 AVCodecContext *avctx,
784 uint8_t **poutbuf, int *poutbuf_size,
785 const uint8_t *buf, int buf_size)
787 AC3ParseContext *s = s1->priv_data;
788 const uint8_t *buf_ptr;
789 int len, sample_rate, bit_rate, channels, samples;
795 while (buf_size > 0) {
796 len = s->inbuf_ptr - s->inbuf;
797 if (s->frame_size == 0) {
798 /* no header seen : find one. We need at least s->header_size
800 len = FFMIN(s->header_size - len, buf_size);
802 memcpy(s->inbuf_ptr, buf_ptr, len);
806 if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
807 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
810 /* no sync found : move by one byte (inefficient, but simple!) */
811 memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
815 /* update codec info */
816 avctx->sample_rate = sample_rate;
817 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
818 if(avctx->codec_id == CODEC_ID_AC3){
819 if(avctx->channels!=1 && avctx->channels!=2){
820 avctx->channels = channels;
823 avctx->channels = channels;
825 avctx->bit_rate = bit_rate;
826 avctx->frame_size = samples;
830 len = FFMIN(s->frame_size - len, buf_size);
832 memcpy(s->inbuf_ptr, buf_ptr, len);
837 if(s->inbuf_ptr - s->inbuf == s->frame_size){
839 *poutbuf_size = s->frame_size;
840 s->inbuf_ptr = s->inbuf;
846 return buf_ptr - buf;
848 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
850 #ifdef CONFIG_MPEG4VIDEO_PARSER
851 AVCodecParser mpeg4video_parser = {
853 sizeof(ParseContext1),
854 mpeg4video_parse_init,
860 #ifdef CONFIG_CAVSVIDEO_PARSER
861 AVCodecParser cavsvideo_parser = {
863 sizeof(ParseContext1),
870 #ifdef CONFIG_MPEGAUDIO_PARSER
871 AVCodecParser mpegaudio_parser = {
872 { CODEC_ID_MP2, CODEC_ID_MP3 },
873 sizeof(MpegAudioParseContext),
874 mpegaudio_parse_init,
879 #ifdef CONFIG_AC3_PARSER
880 AVCodecParser ac3_parser = {
882 sizeof(AC3ParseContext),
888 #ifdef CONFIG_AAC_PARSER
889 AVCodecParser aac_parser = {
891 sizeof(AC3ParseContext),