minor doc fix
[ffmpeg.git] / libavcodec / parser.c
1 /*
2  * Audio and Video frame extraction
3  * Copyright (c) 2003 Fabrice Bellard.
4  * Copyright (c) 2003 Michael Niedermayer.
5  *
6  * This file is part of FFmpeg.
7  *
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.
12  *
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.
17  *
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
21  */
22 #include "avcodec.h"
23 #include "mpegvideo.h"
24 #include "mpegaudio.h"
25 #include "parser.h"
26
27 AVCodecParser *av_first_parser = NULL;
28
29 void av_register_codec_parser(AVCodecParser *parser)
30 {
31     parser->next = av_first_parser;
32     av_first_parser = parser;
33 }
34
35 AVCodecParserContext *av_parser_init(int codec_id)
36 {
37     AVCodecParserContext *s;
38     AVCodecParser *parser;
39     int ret;
40
41     if(codec_id == CODEC_ID_NONE)
42         return NULL;
43
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)
50             goto found;
51     }
52     return NULL;
53  found:
54     s = av_mallocz(sizeof(AVCodecParserContext));
55     if (!s)
56         return NULL;
57     s->parser = parser;
58     s->priv_data = av_mallocz(parser->priv_data_size);
59     if (!s->priv_data) {
60         av_free(s);
61         return NULL;
62     }
63     if (parser->parser_init) {
64         ret = parser->parser_init(s);
65         if (ret != 0) {
66             av_free(s->priv_data);
67             av_free(s);
68             return NULL;
69         }
70     }
71     s->fetch_timestamp=1;
72     return s;
73 }
74
75 /**
76  *
77  * @param buf           input
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
84  *
85  * Example:
86  * @code
87  *   while(in_len){
88  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
89  *                                       in_data, in_len,
90  *                                       pts, dts);
91  *       in_data += len;
92  *       in_len  -= len;
93  *
94  *       if(size)
95  *          decode_frame(data, size);
96  *   }
97  * @endcode
98  */
99 int av_parser_parse(AVCodecParserContext *s,
100                     AVCodecContext *avctx,
101                     uint8_t **poutbuf, int *poutbuf_size,
102                     const uint8_t *buf, int buf_size,
103                     int64_t pts, int64_t dts)
104 {
105     int index, i, k;
106     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
107
108     if (buf_size == 0) {
109         /* padding is always necessary even if EOF, so we add it here */
110         memset(dummy_buf, 0, sizeof(dummy_buf));
111         buf = dummy_buf;
112     } else {
113         /* add a new packet descriptor */
114         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
115         s->cur_frame_start_index = k;
116         s->cur_frame_offset[k] = s->cur_offset;
117         s->cur_frame_pts[k] = pts;
118         s->cur_frame_dts[k] = dts;
119
120         /* fill first PTS/DTS */
121         if (s->fetch_timestamp){
122             s->fetch_timestamp=0;
123             s->last_pts = pts;
124             s->last_dts = dts;
125             s->cur_frame_pts[k] =
126             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
127         }
128     }
129
130     /* WARNING: the returned index can be negative */
131     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
132 //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);
133     /* update the file pointer */
134     if (*poutbuf_size) {
135         /* fill the data for the current frame */
136         s->frame_offset = s->last_frame_offset;
137         s->pts = s->last_pts;
138         s->dts = s->last_dts;
139
140         /* offset of the next frame */
141         s->last_frame_offset = s->cur_offset + index;
142         /* find the packet in which the new frame starts. It
143            is tricky because of MPEG video start codes
144            which can begin in one packet and finish in
145            another packet. In the worst case, an MPEG
146            video start code could be in 4 different
147            packets. */
148         k = s->cur_frame_start_index;
149         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
150             if (s->last_frame_offset >= s->cur_frame_offset[k])
151                 break;
152             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
153         }
154
155         s->last_pts = s->cur_frame_pts[k];
156         s->last_dts = s->cur_frame_dts[k];
157
158         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
159            so the next pts/dts is in the next chunk */
160         if(index == buf_size){
161             s->fetch_timestamp=1;
162         }
163     }
164     if (index < 0)
165         index = 0;
166     s->cur_offset += index;
167     return index;
168 }
169
170 /**
171  *
172  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
173  * @deprecated use AVBitstreamFilter
174  */
175 int av_parser_change(AVCodecParserContext *s,
176                      AVCodecContext *avctx,
177                      uint8_t **poutbuf, int *poutbuf_size,
178                      const uint8_t *buf, int buf_size, int keyframe){
179
180     if(s && s->parser->split){
181         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
182             int i= s->parser->split(avctx, buf, buf_size);
183             buf += i;
184             buf_size -= i;
185         }
186     }
187
188     /* cast to avoid warning about discarding qualifiers */
189     *poutbuf= (uint8_t *) buf;
190     *poutbuf_size= buf_size;
191     if(avctx->extradata){
192         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
193             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
194             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
195             int size= buf_size + avctx->extradata_size;
196             *poutbuf_size= size;
197             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
198
199             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
200             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
201             return 1;
202         }
203     }
204
205     return 0;
206 }
207
208 void av_parser_close(AVCodecParserContext *s)
209 {
210     if (s->parser->parser_close)
211         s->parser->parser_close(s);
212     av_free(s->priv_data);
213     av_free(s);
214 }
215
216 /*****************************************************/
217
218 /**
219  * combines the (truncated) bitstream to a complete frame
220  * @returns -1 if no complete frame could be created
221  */
222 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
223 {
224 #if 0
225     if(pc->overread){
226         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
227         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
228     }
229 #endif
230
231     /* copy overreaded bytes from last frame into buffer */
232     for(; pc->overread>0; pc->overread--){
233         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
234     }
235
236     /* flush remaining if EOF */
237     if(!*buf_size && next == END_NOT_FOUND){
238         next= 0;
239     }
240
241     pc->last_index= pc->index;
242
243     /* copy into buffer end return */
244     if(next == END_NOT_FOUND){
245         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
246
247         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
248         pc->index += *buf_size;
249         return -1;
250     }
251
252     *buf_size=
253     pc->overread_index= pc->index + next;
254
255     /* append to buffer */
256     if(pc->index){
257         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
258
259         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
260         pc->index = 0;
261         *buf= pc->buffer;
262     }
263
264     /* store overread bytes */
265     for(;next < 0; next++){
266         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
267         pc->overread++;
268     }
269
270 #if 0
271     if(pc->overread){
272         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
273         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
274     }
275 #endif
276
277     return 0;
278 }
279
280 void ff_parse_close(AVCodecParserContext *s)
281 {
282     ParseContext *pc = s->priv_data;
283
284     av_free(pc->buffer);
285 }
286
287 void ff_parse1_close(AVCodecParserContext *s)
288 {
289     ParseContext1 *pc1 = s->priv_data;
290
291     av_free(pc1->pc.buffer);
292     av_free(pc1->enc);
293 }
294
295 /*************************/
296
297 #ifdef CONFIG_MPEG4VIDEO_PARSER
298 /* used by parser */
299 /* XXX: make it use less memory */
300 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
301                                   AVCodecContext *avctx,
302                                   const uint8_t *buf, int buf_size)
303 {
304     ParseContext1 *pc = s1->priv_data;
305     MpegEncContext *s = pc->enc;
306     GetBitContext gb1, *gb = &gb1;
307     int ret;
308
309     s->avctx = avctx;
310     s->current_picture_ptr = &s->current_picture;
311
312     if (avctx->extradata_size && pc->first_picture){
313         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
314         ret = ff_mpeg4_decode_picture_header(s, gb);
315     }
316
317     init_get_bits(gb, buf, 8 * buf_size);
318     ret = ff_mpeg4_decode_picture_header(s, gb);
319     if (s->width) {
320         avcodec_set_dimensions(avctx, s->width, s->height);
321     }
322     s1->pict_type= s->pict_type;
323     pc->first_picture = 0;
324     return ret;
325 }
326
327 static int mpeg4video_parse_init(AVCodecParserContext *s)
328 {
329     ParseContext1 *pc = s->priv_data;
330
331     pc->enc = av_mallocz(sizeof(MpegEncContext));
332     if (!pc->enc)
333         return -1;
334     pc->first_picture = 1;
335     return 0;
336 }
337
338 static int mpeg4video_parse(AVCodecParserContext *s,
339                            AVCodecContext *avctx,
340                            uint8_t **poutbuf, int *poutbuf_size,
341                            const uint8_t *buf, int buf_size)
342 {
343     ParseContext *pc = s->priv_data;
344     int next;
345
346     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
347         next= buf_size;
348     }else{
349         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
350
351         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
352             *poutbuf = NULL;
353             *poutbuf_size = 0;
354             return buf_size;
355         }
356     }
357     av_mpeg4_decode_header(s, avctx, buf, buf_size);
358
359     *poutbuf = (uint8_t *)buf;
360     *poutbuf_size = buf_size;
361     return next;
362 }
363 #endif
364
365 int ff_mpeg4video_split(AVCodecContext *avctx,
366                            const uint8_t *buf, int buf_size)
367 {
368     int i;
369     uint32_t state= -1;
370
371     for(i=0; i<buf_size; i++){
372         state= (state<<8) | buf[i];
373         if(state == 0x1B3 || state == 0x1B6)
374             return i-3;
375     }
376     return 0;
377 }
378
379 /*************************/
380
381 #ifdef CONFIG_MPEGAUDIO_PARSER
382 typedef struct MpegAudioParseContext {
383     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
384     uint8_t *inbuf_ptr;
385     int frame_size;
386     int free_format_frame_size;
387     int free_format_next_header;
388     uint32_t header;
389     int header_count;
390 } MpegAudioParseContext;
391
392 #define MPA_HEADER_SIZE 4
393
394 /* header + layer + bitrate + freq + lsf/mpeg25 */
395 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
396 #define SAME_HEADER_MASK \
397    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
398
399 static int mpegaudio_parse_init(AVCodecParserContext *s1)
400 {
401     MpegAudioParseContext *s = s1->priv_data;
402     s->inbuf_ptr = s->inbuf;
403     return 0;
404 }
405
406 static int mpegaudio_parse(AVCodecParserContext *s1,
407                            AVCodecContext *avctx,
408                            uint8_t **poutbuf, int *poutbuf_size,
409                            const uint8_t *buf, int buf_size)
410 {
411     MpegAudioParseContext *s = s1->priv_data;
412     int len, ret, sr;
413     uint32_t header;
414     const uint8_t *buf_ptr;
415
416     *poutbuf = NULL;
417     *poutbuf_size = 0;
418     buf_ptr = buf;
419     while (buf_size > 0) {
420         len = s->inbuf_ptr - s->inbuf;
421         if (s->frame_size == 0) {
422             /* special case for next header for first frame in free
423                format case (XXX: find a simpler method) */
424             if (s->free_format_next_header != 0) {
425                 s->inbuf[0] = s->free_format_next_header >> 24;
426                 s->inbuf[1] = s->free_format_next_header >> 16;
427                 s->inbuf[2] = s->free_format_next_header >> 8;
428                 s->inbuf[3] = s->free_format_next_header;
429                 s->inbuf_ptr = s->inbuf + 4;
430                 s->free_format_next_header = 0;
431                 goto got_header;
432             }
433             /* no header seen : find one. We need at least MPA_HEADER_SIZE
434                bytes to parse it */
435             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
436             if (len > 0) {
437                 memcpy(s->inbuf_ptr, buf_ptr, len);
438                 buf_ptr += len;
439                 buf_size -= len;
440                 s->inbuf_ptr += len;
441             }
442             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
443             got_header:
444                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
445                     (s->inbuf[2] << 8) | s->inbuf[3];
446
447                 ret = mpa_decode_header(avctx, header, &sr);
448                 if (ret < 0) {
449                     s->header_count= -2;
450                     /* no sync found : move by one byte (inefficient, but simple!) */
451                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
452                     s->inbuf_ptr--;
453                     dprintf("skip %x\n", header);
454                     /* reset free format frame size to give a chance
455                        to get a new bitrate */
456                     s->free_format_frame_size = 0;
457                 } else {
458                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
459                         s->header_count= -3;
460                     s->header= header;
461                     s->header_count++;
462                     s->frame_size = ret;
463
464 #if 0
465                     /* free format: prepare to compute frame size */
466                     if (decode_header(s, header) == 1) {
467                         s->frame_size = -1;
468                     }
469 #endif
470                 }
471                 if(s->header_count > 1)
472                     avctx->sample_rate= sr;
473             }
474         } else
475 #if 0
476         if (s->frame_size == -1) {
477             /* free format : find next sync to compute frame size */
478             len = MPA_MAX_CODED_FRAME_SIZE - len;
479             if (len > buf_size)
480                 len = buf_size;
481             if (len == 0) {
482                 /* frame too long: resync */
483                 s->frame_size = 0;
484                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
485                 s->inbuf_ptr--;
486             } else {
487                 uint8_t *p, *pend;
488                 uint32_t header1;
489                 int padding;
490
491                 memcpy(s->inbuf_ptr, buf_ptr, len);
492                 /* check for header */
493                 p = s->inbuf_ptr - 3;
494                 pend = s->inbuf_ptr + len - 4;
495                 while (p <= pend) {
496                     header = (p[0] << 24) | (p[1] << 16) |
497                         (p[2] << 8) | p[3];
498                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
499                         (s->inbuf[2] << 8) | s->inbuf[3];
500                     /* check with high probability that we have a
501                        valid header */
502                     if ((header & SAME_HEADER_MASK) ==
503                         (header1 & SAME_HEADER_MASK)) {
504                         /* header found: update pointers */
505                         len = (p + 4) - s->inbuf_ptr;
506                         buf_ptr += len;
507                         buf_size -= len;
508                         s->inbuf_ptr = p;
509                         /* compute frame size */
510                         s->free_format_next_header = header;
511                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
512                         padding = (header1 >> 9) & 1;
513                         if (s->layer == 1)
514                             s->free_format_frame_size -= padding * 4;
515                         else
516                             s->free_format_frame_size -= padding;
517                         dprintf("free frame size=%d padding=%d\n",
518                                 s->free_format_frame_size, padding);
519                         decode_header(s, header1);
520                         goto next_data;
521                     }
522                     p++;
523                 }
524                 /* not found: simply increase pointers */
525                 buf_ptr += len;
526                 s->inbuf_ptr += len;
527                 buf_size -= len;
528             }
529         } else
530 #endif
531         if (len < s->frame_size) {
532             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
533                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
534             len = FFMIN(s->frame_size - len, buf_size);
535             memcpy(s->inbuf_ptr, buf_ptr, len);
536             buf_ptr += len;
537             s->inbuf_ptr += len;
538             buf_size -= len;
539         }
540
541         if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
542            && buf_size + buf_ptr - buf >= s->frame_size){
543             if(s->header_count > 0){
544                 *poutbuf = buf;
545                 *poutbuf_size = s->frame_size;
546             }
547             buf_ptr = buf + s->frame_size;
548             s->inbuf_ptr = s->inbuf;
549             s->frame_size = 0;
550             break;
551         }
552
553         //    next_data:
554         if (s->frame_size > 0 &&
555             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
556             if(s->header_count > 0){
557                 *poutbuf = s->inbuf;
558                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
559             }
560             s->inbuf_ptr = s->inbuf;
561             s->frame_size = 0;
562             break;
563         }
564     }
565     return buf_ptr - buf;
566 }
567 #endif /* CONFIG_MPEGAUDIO_PARSER */
568
569 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
570 /* also used for ADTS AAC */
571 typedef struct AC3ParseContext {
572     uint8_t *inbuf_ptr;
573     int frame_size;
574     int header_size;
575     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
576                 int *bit_rate, int *samples);
577     uint8_t inbuf[8192]; /* input buffer */
578 } AC3ParseContext;
579
580 #define AC3_HEADER_SIZE 7
581 #define AAC_HEADER_SIZE 7
582
583 #ifdef CONFIG_AC3_PARSER
584 static const int ac3_sample_rates[4] = {
585     48000, 44100, 32000, 0
586 };
587
588 static const int ac3_frame_sizes[64][3] = {
589     { 64,   69,   96   },
590     { 64,   70,   96   },
591     { 80,   87,   120  },
592     { 80,   88,   120  },
593     { 96,   104,  144  },
594     { 96,   105,  144  },
595     { 112,  121,  168  },
596     { 112,  122,  168  },
597     { 128,  139,  192  },
598     { 128,  140,  192  },
599     { 160,  174,  240  },
600     { 160,  175,  240  },
601     { 192,  208,  288  },
602     { 192,  209,  288  },
603     { 224,  243,  336  },
604     { 224,  244,  336  },
605     { 256,  278,  384  },
606     { 256,  279,  384  },
607     { 320,  348,  480  },
608     { 320,  349,  480  },
609     { 384,  417,  576  },
610     { 384,  418,  576  },
611     { 448,  487,  672  },
612     { 448,  488,  672  },
613     { 512,  557,  768  },
614     { 512,  558,  768  },
615     { 640,  696,  960  },
616     { 640,  697,  960  },
617     { 768,  835,  1152 },
618     { 768,  836,  1152 },
619     { 896,  975,  1344 },
620     { 896,  976,  1344 },
621     { 1024, 1114, 1536 },
622     { 1024, 1115, 1536 },
623     { 1152, 1253, 1728 },
624     { 1152, 1254, 1728 },
625     { 1280, 1393, 1920 },
626     { 1280, 1394, 1920 },
627 };
628
629 static const int ac3_bitrates[64] = {
630     32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
631     128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
632     384, 448, 448, 512, 512, 576, 576, 640, 640,
633 };
634
635 static const int ac3_channels[8] = {
636     2, 1, 2, 3, 3, 4, 4, 5
637 };
638 #endif /* CONFIG_AC3_PARSER */
639
640 #ifdef CONFIG_AAC_PARSER
641 static const int aac_sample_rates[16] = {
642     96000, 88200, 64000, 48000, 44100, 32000,
643     24000, 22050, 16000, 12000, 11025, 8000, 7350
644 };
645
646 static const int aac_channels[8] = {
647     0, 1, 2, 3, 4, 5, 6, 8
648 };
649 #endif
650
651 #ifdef CONFIG_AC3_PARSER
652 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
653                     int *bit_rate, int *samples)
654 {
655     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
656     GetBitContext bits;
657
658     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
659
660     if(get_bits(&bits, 16) != 0x0b77)
661         return 0;
662
663     skip_bits(&bits, 16);       /* crc */
664     fscod = get_bits(&bits, 2);
665     frmsizecod = get_bits(&bits, 6);
666
667     if(!ac3_sample_rates[fscod])
668         return 0;
669
670     bsid = get_bits(&bits, 5);
671     if(bsid > 8)
672         return 0;
673     skip_bits(&bits, 3);        /* bsmod */
674     acmod = get_bits(&bits, 3);
675     if(acmod & 1 && acmod != 1)
676         skip_bits(&bits, 2);    /* cmixlev */
677     if(acmod & 4)
678         skip_bits(&bits, 2);    /* surmixlev */
679     if(acmod & 2)
680         skip_bits(&bits, 2);    /* dsurmod */
681     lfeon = get_bits1(&bits);
682
683     *sample_rate = ac3_sample_rates[fscod];
684     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
685     *channels = ac3_channels[acmod] + lfeon;
686     *samples = 6 * 256;
687
688     return ac3_frame_sizes[frmsizecod][fscod] * 2;
689 }
690 #endif /* CONFIG_AC3_PARSER */
691
692 #ifdef CONFIG_AAC_PARSER
693 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
694                     int *bit_rate, int *samples)
695 {
696     GetBitContext bits;
697     int size, rdb, ch, sr;
698
699     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
700
701     if(get_bits(&bits, 12) != 0xfff)
702         return 0;
703
704     skip_bits1(&bits);          /* id */
705     skip_bits(&bits, 2);        /* layer */
706     skip_bits1(&bits);          /* protection_absent */
707     skip_bits(&bits, 2);        /* profile_objecttype */
708     sr = get_bits(&bits, 4);    /* sample_frequency_index */
709     if(!aac_sample_rates[sr])
710         return 0;
711     skip_bits1(&bits);          /* private_bit */
712     ch = get_bits(&bits, 3);    /* channel_configuration */
713     if(!aac_channels[ch])
714         return 0;
715     skip_bits1(&bits);          /* original/copy */
716     skip_bits1(&bits);          /* home */
717
718     /* adts_variable_header */
719     skip_bits1(&bits);          /* copyright_identification_bit */
720     skip_bits1(&bits);          /* copyright_identification_start */
721     size = get_bits(&bits, 13); /* aac_frame_length */
722     skip_bits(&bits, 11);       /* adts_buffer_fullness */
723     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
724
725     *channels = aac_channels[ch];
726     *sample_rate = aac_sample_rates[sr];
727     *samples = (rdb + 1) * 1024;
728     *bit_rate = size * 8 * *sample_rate / *samples;
729
730     return size;
731 }
732 #endif /* CONFIG_AAC_PARSER */
733
734 #ifdef CONFIG_AC3_PARSER
735 static int ac3_parse_init(AVCodecParserContext *s1)
736 {
737     AC3ParseContext *s = s1->priv_data;
738     s->inbuf_ptr = s->inbuf;
739     s->header_size = AC3_HEADER_SIZE;
740     s->sync = ac3_sync;
741     return 0;
742 }
743 #endif
744
745 #ifdef CONFIG_AAC_PARSER
746 static int aac_parse_init(AVCodecParserContext *s1)
747 {
748     AC3ParseContext *s = s1->priv_data;
749     s->inbuf_ptr = s->inbuf;
750     s->header_size = AAC_HEADER_SIZE;
751     s->sync = aac_sync;
752     return 0;
753 }
754 #endif
755
756 /* also used for ADTS AAC */
757 static int ac3_parse(AVCodecParserContext *s1,
758                      AVCodecContext *avctx,
759                      uint8_t **poutbuf, int *poutbuf_size,
760                      const uint8_t *buf, int buf_size)
761 {
762     AC3ParseContext *s = s1->priv_data;
763     const uint8_t *buf_ptr;
764     int len, sample_rate, bit_rate, channels, samples;
765
766     *poutbuf = NULL;
767     *poutbuf_size = 0;
768
769     buf_ptr = buf;
770     while (buf_size > 0) {
771         len = s->inbuf_ptr - s->inbuf;
772         if (s->frame_size == 0) {
773             /* no header seen : find one. We need at least s->header_size
774                bytes to parse it */
775             len = FFMIN(s->header_size - len, buf_size);
776
777             memcpy(s->inbuf_ptr, buf_ptr, len);
778             buf_ptr += len;
779             s->inbuf_ptr += len;
780             buf_size -= len;
781             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
782                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
783                               &samples);
784                 if (len == 0) {
785                     /* no sync found : move by one byte (inefficient, but simple!) */
786                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
787                     s->inbuf_ptr--;
788                 } else {
789                     s->frame_size = len;
790                     /* update codec info */
791                     avctx->sample_rate = sample_rate;
792                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
793                     if(avctx->codec_id == CODEC_ID_AC3){
794                         if(avctx->channels!=1 && avctx->channels!=2){
795                             avctx->channels = channels;
796                         }
797                     } else {
798                         avctx->channels = channels;
799                     }
800                     avctx->bit_rate = bit_rate;
801                     avctx->frame_size = samples;
802                 }
803             }
804         } else {
805             len = FFMIN(s->frame_size - len, buf_size);
806
807             memcpy(s->inbuf_ptr, buf_ptr, len);
808             buf_ptr += len;
809             s->inbuf_ptr += len;
810             buf_size -= len;
811
812             if(s->inbuf_ptr - s->inbuf == s->frame_size){
813                 *poutbuf = s->inbuf;
814                 *poutbuf_size = s->frame_size;
815                 s->inbuf_ptr = s->inbuf;
816                 s->frame_size = 0;
817                 break;
818             }
819         }
820     }
821     return buf_ptr - buf;
822 }
823 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
824
825 #ifdef CONFIG_MPEG4VIDEO_PARSER
826 AVCodecParser mpeg4video_parser = {
827     { CODEC_ID_MPEG4 },
828     sizeof(ParseContext1),
829     mpeg4video_parse_init,
830     mpeg4video_parse,
831     ff_parse1_close,
832     ff_mpeg4video_split,
833 };
834 #endif
835 #ifdef CONFIG_MPEGAUDIO_PARSER
836 AVCodecParser mpegaudio_parser = {
837     { CODEC_ID_MP2, CODEC_ID_MP3 },
838     sizeof(MpegAudioParseContext),
839     mpegaudio_parse_init,
840     mpegaudio_parse,
841     NULL,
842 };
843 #endif
844 #ifdef CONFIG_AC3_PARSER
845 AVCodecParser ac3_parser = {
846     { CODEC_ID_AC3 },
847     sizeof(AC3ParseContext),
848     ac3_parse_init,
849     ac3_parse,
850     NULL,
851 };
852 #endif
853 #ifdef CONFIG_AAC_PARSER
854 AVCodecParser aac_parser = {
855     { CODEC_ID_AAC },
856     sizeof(AC3ParseContext),
857     aac_parse_init,
858     ac3_parse,
859     NULL,
860 };
861 #endif