6b0b98f9483be84d58a99d2f717b50d60c9f9b00
[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 #ifdef CONFIG_MPEG4VIDEO_PARSER
302 /* used by parser */
303 /* XXX: make it use less memory */
304 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
305                                   AVCodecContext *avctx,
306                                   const uint8_t *buf, int buf_size)
307 {
308     ParseContext1 *pc = s1->priv_data;
309     MpegEncContext *s = pc->enc;
310     GetBitContext gb1, *gb = &gb1;
311     int ret;
312
313     s->avctx = avctx;
314     s->current_picture_ptr = &s->current_picture;
315
316     if (avctx->extradata_size && pc->first_picture){
317         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
318         ret = ff_mpeg4_decode_picture_header(s, gb);
319     }
320
321     init_get_bits(gb, buf, 8 * buf_size);
322     ret = ff_mpeg4_decode_picture_header(s, gb);
323     if (s->width) {
324         avcodec_set_dimensions(avctx, s->width, s->height);
325     }
326     s1->pict_type= s->pict_type;
327     pc->first_picture = 0;
328     return ret;
329 }
330
331 static int mpeg4video_parse_init(AVCodecParserContext *s)
332 {
333     ParseContext1 *pc = s->priv_data;
334
335     pc->enc = av_mallocz(sizeof(MpegEncContext));
336     if (!pc->enc)
337         return -1;
338     pc->first_picture = 1;
339     return 0;
340 }
341
342 static int mpeg4video_parse(AVCodecParserContext *s,
343                            AVCodecContext *avctx,
344                            uint8_t **poutbuf, int *poutbuf_size,
345                            const uint8_t *buf, int buf_size)
346 {
347     ParseContext *pc = s->priv_data;
348     int next;
349
350     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
351         next= buf_size;
352     }else{
353         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
354
355         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
356             *poutbuf = NULL;
357             *poutbuf_size = 0;
358             return buf_size;
359         }
360     }
361     av_mpeg4_decode_header(s, avctx, buf, buf_size);
362
363     *poutbuf = (uint8_t *)buf;
364     *poutbuf_size = buf_size;
365     return next;
366 }
367 #endif
368
369 int ff_mpeg4video_split(AVCodecContext *avctx,
370                            const uint8_t *buf, int buf_size)
371 {
372     int i;
373     uint32_t state= -1;
374
375     for(i=0; i<buf_size; i++){
376         state= (state<<8) | buf[i];
377         if(state == 0x1B3 || state == 0x1B6)
378             return i-3;
379     }
380     return 0;
381 }
382
383 /*************************/
384
385 #ifdef CONFIG_MPEGAUDIO_PARSER
386 typedef struct MpegAudioParseContext {
387     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
388     uint8_t *inbuf_ptr;
389     int frame_size;
390     int free_format_frame_size;
391     int free_format_next_header;
392     uint32_t header;
393     int header_count;
394 } MpegAudioParseContext;
395
396 #define MPA_HEADER_SIZE 4
397
398 /* header + layer + bitrate + freq + lsf/mpeg25 */
399 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
400 #define SAME_HEADER_MASK \
401    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
402
403 static int mpegaudio_parse_init(AVCodecParserContext *s1)
404 {
405     MpegAudioParseContext *s = s1->priv_data;
406     s->inbuf_ptr = s->inbuf;
407     return 0;
408 }
409
410 static int mpegaudio_parse(AVCodecParserContext *s1,
411                            AVCodecContext *avctx,
412                            uint8_t **poutbuf, int *poutbuf_size,
413                            const uint8_t *buf, int buf_size)
414 {
415     MpegAudioParseContext *s = s1->priv_data;
416     int len, ret, sr;
417     uint32_t header;
418     const uint8_t *buf_ptr;
419
420     *poutbuf = NULL;
421     *poutbuf_size = 0;
422     buf_ptr = buf;
423     while (buf_size > 0) {
424         len = s->inbuf_ptr - s->inbuf;
425         if (s->frame_size == 0) {
426             /* special case for next header for first frame in free
427                format case (XXX: find a simpler method) */
428             if (s->free_format_next_header != 0) {
429                 s->inbuf[0] = s->free_format_next_header >> 24;
430                 s->inbuf[1] = s->free_format_next_header >> 16;
431                 s->inbuf[2] = s->free_format_next_header >> 8;
432                 s->inbuf[3] = s->free_format_next_header;
433                 s->inbuf_ptr = s->inbuf + 4;
434                 s->free_format_next_header = 0;
435                 goto got_header;
436             }
437             /* no header seen : find one. We need at least MPA_HEADER_SIZE
438                bytes to parse it */
439             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
440             if (len > 0) {
441                 memcpy(s->inbuf_ptr, buf_ptr, len);
442                 buf_ptr += len;
443                 buf_size -= len;
444                 s->inbuf_ptr += len;
445             }
446             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
447             got_header:
448                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
449                     (s->inbuf[2] << 8) | s->inbuf[3];
450
451                 ret = mpa_decode_header(avctx, header, &sr);
452                 if (ret < 0) {
453                     s->header_count= -2;
454                     /* no sync found : move by one byte (inefficient, but simple!) */
455                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
456                     s->inbuf_ptr--;
457                     dprintf(avctx, "skip %x\n", header);
458                     /* reset free format frame size to give a chance
459                        to get a new bitrate */
460                     s->free_format_frame_size = 0;
461                 } else {
462                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
463                         s->header_count= -3;
464                     s->header= header;
465                     s->header_count++;
466                     s->frame_size = ret;
467
468 #if 0
469                     /* free format: prepare to compute frame size */
470                     if (decode_header(s, header) == 1) {
471                         s->frame_size = -1;
472                     }
473 #endif
474                 }
475                 if(s->header_count > 1)
476                     avctx->sample_rate= sr;
477             }
478         } else
479 #if 0
480         if (s->frame_size == -1) {
481             /* free format : find next sync to compute frame size */
482             len = MPA_MAX_CODED_FRAME_SIZE - len;
483             if (len > buf_size)
484                 len = buf_size;
485             if (len == 0) {
486                 /* frame too long: resync */
487                 s->frame_size = 0;
488                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
489                 s->inbuf_ptr--;
490             } else {
491                 uint8_t *p, *pend;
492                 uint32_t header1;
493                 int padding;
494
495                 memcpy(s->inbuf_ptr, buf_ptr, len);
496                 /* check for header */
497                 p = s->inbuf_ptr - 3;
498                 pend = s->inbuf_ptr + len - 4;
499                 while (p <= pend) {
500                     header = (p[0] << 24) | (p[1] << 16) |
501                         (p[2] << 8) | p[3];
502                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
503                         (s->inbuf[2] << 8) | s->inbuf[3];
504                     /* check with high probability that we have a
505                        valid header */
506                     if ((header & SAME_HEADER_MASK) ==
507                         (header1 & SAME_HEADER_MASK)) {
508                         /* header found: update pointers */
509                         len = (p + 4) - s->inbuf_ptr;
510                         buf_ptr += len;
511                         buf_size -= len;
512                         s->inbuf_ptr = p;
513                         /* compute frame size */
514                         s->free_format_next_header = header;
515                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
516                         padding = (header1 >> 9) & 1;
517                         if (s->layer == 1)
518                             s->free_format_frame_size -= padding * 4;
519                         else
520                             s->free_format_frame_size -= padding;
521                         dprintf(avctx, "free frame size=%d padding=%d\n",
522                                 s->free_format_frame_size, padding);
523                         decode_header(s, header1);
524                         goto next_data;
525                     }
526                     p++;
527                 }
528                 /* not found: simply increase pointers */
529                 buf_ptr += len;
530                 s->inbuf_ptr += len;
531                 buf_size -= len;
532             }
533         } else
534 #endif
535         if (len < s->frame_size) {
536             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
537                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
538             len = FFMIN(s->frame_size - len, buf_size);
539             memcpy(s->inbuf_ptr, buf_ptr, len);
540             buf_ptr += len;
541             s->inbuf_ptr += len;
542             buf_size -= len;
543         }
544
545         if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
546            && buf_size + buf_ptr - buf >= s->frame_size){
547             if(s->header_count > 0){
548                 *poutbuf = buf;
549                 *poutbuf_size = s->frame_size;
550             }
551             buf_ptr = buf + s->frame_size;
552             s->inbuf_ptr = s->inbuf;
553             s->frame_size = 0;
554             break;
555         }
556
557         //    next_data:
558         if (s->frame_size > 0 &&
559             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
560             if(s->header_count > 0){
561                 *poutbuf = s->inbuf;
562                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
563             }
564             s->inbuf_ptr = s->inbuf;
565             s->frame_size = 0;
566             break;
567         }
568     }
569     return buf_ptr - buf;
570 }
571 #endif /* CONFIG_MPEGAUDIO_PARSER */
572
573 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
574 /* also used for ADTS AAC */
575 typedef struct AC3ParseContext {
576     uint8_t *inbuf_ptr;
577     int frame_size;
578     int header_size;
579     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
580                 int *bit_rate, int *samples);
581     uint8_t inbuf[8192]; /* input buffer */
582 } AC3ParseContext;
583
584 #define AC3_HEADER_SIZE 7
585 #define AAC_HEADER_SIZE 7
586
587 #ifdef CONFIG_AC3_PARSER
588
589 static const uint8_t eac3_blocks[4] = {
590     1, 2, 3, 6
591 };
592
593 #endif /* CONFIG_AC3_PARSER */
594
595 #ifdef CONFIG_AAC_PARSER
596 static const int aac_sample_rates[16] = {
597     96000, 88200, 64000, 48000, 44100, 32000,
598     24000, 22050, 16000, 12000, 11025, 8000, 7350
599 };
600
601 static const int aac_channels[8] = {
602     0, 1, 2, 3, 4, 5, 6, 8
603 };
604 #endif
605
606 #ifdef CONFIG_AC3_PARSER
607 int ff_ac3_parse_header(const uint8_t buf[7], AC3HeaderInfo *hdr)
608 {
609     GetBitContext gbc;
610
611     memset(hdr, 0, sizeof(*hdr));
612
613     init_get_bits(&gbc, buf, 54);
614
615     hdr->sync_word = get_bits(&gbc, 16);
616     if(hdr->sync_word != 0x0B77)
617         return -1;
618
619     /* read ahead to bsid to make sure this is AC-3, not E-AC-3 */
620     hdr->bsid = show_bits_long(&gbc, 29) & 0x1F;
621     if(hdr->bsid > 10)
622         return -2;
623
624     hdr->crc1 = get_bits(&gbc, 16);
625     hdr->fscod = get_bits(&gbc, 2);
626     if(hdr->fscod == 3)
627         return -3;
628
629     hdr->frmsizecod = get_bits(&gbc, 6);
630     if(hdr->frmsizecod > 37)
631         return -4;
632
633     skip_bits(&gbc, 5); // skip bsid, already got it
634
635     hdr->bsmod = get_bits(&gbc, 3);
636     hdr->acmod = get_bits(&gbc, 3);
637     if((hdr->acmod & 1) && hdr->acmod != 1) {
638         hdr->cmixlev = get_bits(&gbc, 2);
639     }
640     if(hdr->acmod & 4) {
641         hdr->surmixlev = get_bits(&gbc, 2);
642     }
643     if(hdr->acmod == 2) {
644         hdr->dsurmod = get_bits(&gbc, 2);
645     }
646     hdr->lfeon = get_bits1(&gbc);
647
648     hdr->halfratecod = FFMAX(hdr->bsid, 8) - 8;
649     hdr->sample_rate = ff_ac3_freqs[hdr->fscod] >> hdr->halfratecod;
650     hdr->bit_rate = (ff_ac3_bitratetab[hdr->frmsizecod>>1] * 1000) >> hdr->halfratecod;
651     hdr->channels = ff_ac3_channels[hdr->acmod] + hdr->lfeon;
652     hdr->frame_size = ff_ac3_frame_sizes[hdr->frmsizecod][hdr->fscod] * 2;
653
654     return 0;
655 }
656
657 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
658                     int *bit_rate, int *samples)
659 {
660     int err;
661     unsigned int fscod, acmod, bsid, lfeon;
662     unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
663     GetBitContext bits;
664     AC3HeaderInfo hdr;
665
666     err = ff_ac3_parse_header(buf, &hdr);
667
668     if(err < 0 && err != -2)
669         return 0;
670
671     bsid = hdr.bsid;
672     if(bsid <= 10) {             /* Normal AC-3 */
673         *sample_rate = hdr.sample_rate;
674         *bit_rate = hdr.bit_rate;
675         *channels = hdr.channels;
676         *samples = AC3_FRAME_SIZE;
677         return hdr.frame_size;
678     } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
679         init_get_bits(&bits, &buf[2], (AC3_HEADER_SIZE-2) * 8);
680         strmtyp = get_bits(&bits, 2);
681         substreamid = get_bits(&bits, 3);
682
683         if (strmtyp != 0 || substreamid != 0)
684             return 0;   /* Currently don't support additional streams */
685
686         frmsiz = get_bits(&bits, 11) + 1;
687         fscod = get_bits(&bits, 2);
688         if (fscod == 3) {
689             fscod2 = get_bits(&bits, 2);
690             numblkscod = 3;
691
692             if(fscod2 == 3)
693                 return 0;
694
695             *sample_rate = ff_ac3_freqs[fscod2] / 2;
696         } else {
697             numblkscod = get_bits(&bits, 2);
698
699             *sample_rate = ff_ac3_freqs[fscod];
700         }
701
702         acmod = get_bits(&bits, 3);
703         lfeon = get_bits1(&bits);
704
705         *samples = eac3_blocks[numblkscod] * 256;
706         *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
707         *channels = ff_ac3_channels[acmod] + lfeon;
708
709         return frmsiz * 2;
710     }
711
712     /* Unsupported bitstream version */
713     return 0;
714 }
715 #endif /* CONFIG_AC3_PARSER */
716
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)
720 {
721     GetBitContext bits;
722     int size, rdb, ch, sr;
723
724     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
725
726     if(get_bits(&bits, 12) != 0xfff)
727         return 0;
728
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])
735         return 0;
736     skip_bits1(&bits);          /* private_bit */
737     ch = get_bits(&bits, 3);    /* channel_configuration */
738     if(!aac_channels[ch])
739         return 0;
740     skip_bits1(&bits);          /* original/copy */
741     skip_bits1(&bits);          /* home */
742
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 */
749
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;
754
755     return size;
756 }
757 #endif /* CONFIG_AAC_PARSER */
758
759 #ifdef CONFIG_AC3_PARSER
760 static int ac3_parse_init(AVCodecParserContext *s1)
761 {
762     AC3ParseContext *s = s1->priv_data;
763     s->inbuf_ptr = s->inbuf;
764     s->header_size = AC3_HEADER_SIZE;
765     s->sync = ac3_sync;
766     return 0;
767 }
768 #endif
769
770 #ifdef CONFIG_AAC_PARSER
771 static int aac_parse_init(AVCodecParserContext *s1)
772 {
773     AC3ParseContext *s = s1->priv_data;
774     s->inbuf_ptr = s->inbuf;
775     s->header_size = AAC_HEADER_SIZE;
776     s->sync = aac_sync;
777     return 0;
778 }
779 #endif
780
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)
786 {
787     AC3ParseContext *s = s1->priv_data;
788     const uint8_t *buf_ptr;
789     int len, sample_rate, bit_rate, channels, samples;
790
791     *poutbuf = NULL;
792     *poutbuf_size = 0;
793
794     buf_ptr = buf;
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
799                bytes to parse it */
800             len = FFMIN(s->header_size - len, buf_size);
801
802             memcpy(s->inbuf_ptr, buf_ptr, len);
803             buf_ptr += len;
804             s->inbuf_ptr += len;
805             buf_size -= len;
806             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
807                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
808                               &samples);
809                 if (len == 0) {
810                     /* no sync found : move by one byte (inefficient, but simple!) */
811                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
812                     s->inbuf_ptr--;
813                 } else {
814                     s->frame_size = len;
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;
821                         }
822                     } else {
823                         avctx->channels = channels;
824                     }
825                     avctx->bit_rate = bit_rate;
826                     avctx->frame_size = samples;
827                 }
828             }
829         } else {
830             len = FFMIN(s->frame_size - len, buf_size);
831
832             memcpy(s->inbuf_ptr, buf_ptr, len);
833             buf_ptr += len;
834             s->inbuf_ptr += len;
835             buf_size -= len;
836
837             if(s->inbuf_ptr - s->inbuf == s->frame_size){
838                 *poutbuf = s->inbuf;
839                 *poutbuf_size = s->frame_size;
840                 s->inbuf_ptr = s->inbuf;
841                 s->frame_size = 0;
842                 break;
843             }
844         }
845     }
846     return buf_ptr - buf;
847 }
848 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
849
850 #ifdef CONFIG_MPEG4VIDEO_PARSER
851 AVCodecParser mpeg4video_parser = {
852     { CODEC_ID_MPEG4 },
853     sizeof(ParseContext1),
854     mpeg4video_parse_init,
855     mpeg4video_parse,
856     ff_parse1_close,
857     ff_mpeg4video_split,
858 };
859 #endif
860 #ifdef CONFIG_MPEGAUDIO_PARSER
861 AVCodecParser mpegaudio_parser = {
862     { CODEC_ID_MP2, CODEC_ID_MP3 },
863     sizeof(MpegAudioParseContext),
864     mpegaudio_parse_init,
865     mpegaudio_parse,
866     NULL,
867 };
868 #endif
869 #ifdef CONFIG_AC3_PARSER
870 AVCodecParser ac3_parser = {
871     { CODEC_ID_AC3 },
872     sizeof(AC3ParseContext),
873     ac3_parse_init,
874     ac3_parse,
875     NULL,
876 };
877 #endif
878 #ifdef CONFIG_AAC_PARSER
879 AVCodecParser aac_parser = {
880     { CODEC_ID_AAC },
881     sizeof(AC3ParseContext),
882     aac_parse_init,
883     ac3_parse,
884     NULL,
885 };
886 #endif