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