make mpeg4video_split public as ff_mpeg4video_split
[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  *       decode_frame(data, size);
95  *   }
96  * @endcode
97  */
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)
103 {
104     int index, i, k;
105     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
106
107     if (buf_size == 0) {
108         /* padding is always necessary even if EOF, so we add it here */
109         memset(dummy_buf, 0, sizeof(dummy_buf));
110         buf = dummy_buf;
111     } else {
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;
118
119         /* fill first PTS/DTS */
120         if (s->fetch_timestamp){
121             s->fetch_timestamp=0;
122             s->last_pts = pts;
123             s->last_dts = dts;
124             s->cur_frame_pts[k] =
125             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
126         }
127     }
128
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 */
133     if (*poutbuf_size) {
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;
138
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
146            packets. */
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])
150                 break;
151             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
152         }
153
154         s->last_pts = s->cur_frame_pts[k];
155         s->last_dts = s->cur_frame_dts[k];
156
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;
161         }
162     }
163     if (index < 0)
164         index = 0;
165     s->cur_offset += index;
166     return index;
167 }
168
169 /**
170  *
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
173  */
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){
178
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);
182             buf += i;
183             buf_size -= i;
184         }
185     }
186
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;
195             *poutbuf_size= size;
196             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
197
198             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
199             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
200             return 1;
201         }
202     }
203
204     return 0;
205 }
206
207 void av_parser_close(AVCodecParserContext *s)
208 {
209     if (s->parser->parser_close)
210         s->parser->parser_close(s);
211     av_free(s->priv_data);
212     av_free(s);
213 }
214
215 /*****************************************************/
216
217 /**
218  * combines the (truncated) bitstream to a complete frame
219  * @returns -1 if no complete frame could be created
220  */
221 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
222 {
223 #if 0
224     if(pc->overread){
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]);
227     }
228 #endif
229
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++];
233     }
234
235     /* flush remaining if EOF */
236     if(!*buf_size && next == END_NOT_FOUND){
237         next= 0;
238     }
239
240     pc->last_index= pc->index;
241
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);
245
246         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
247         pc->index += *buf_size;
248         return -1;
249     }
250
251     *buf_size=
252     pc->overread_index= pc->index + next;
253
254     /* append to buffer */
255     if(pc->index){
256         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
257
258         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
259         pc->index = 0;
260         *buf= pc->buffer;
261     }
262
263     /* store overread bytes */
264     for(;next < 0; next++){
265         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
266         pc->overread++;
267     }
268
269 #if 0
270     if(pc->overread){
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]);
273     }
274 #endif
275
276     return 0;
277 }
278
279 void ff_parse_close(AVCodecParserContext *s)
280 {
281     ParseContext *pc = s->priv_data;
282
283     av_free(pc->buffer);
284 }
285
286 void ff_parse1_close(AVCodecParserContext *s)
287 {
288     ParseContext1 *pc1 = s->priv_data;
289
290     av_free(pc1->pc.buffer);
291     av_free(pc1->enc);
292 }
293
294 /*************************/
295
296 #ifdef CONFIG_MPEG4VIDEO_PARSER
297 /* used by 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)
302 {
303     ParseContext1 *pc = s1->priv_data;
304     MpegEncContext *s = pc->enc;
305     GetBitContext gb1, *gb = &gb1;
306     int ret;
307
308     s->avctx = avctx;
309     s->current_picture_ptr = &s->current_picture;
310
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);
314     }
315
316     init_get_bits(gb, buf, 8 * buf_size);
317     ret = ff_mpeg4_decode_picture_header(s, gb);
318     if (s->width) {
319         avcodec_set_dimensions(avctx, s->width, s->height);
320     }
321     s1->pict_type= s->pict_type;
322     pc->first_picture = 0;
323     return ret;
324 }
325
326 static int mpeg4video_parse_init(AVCodecParserContext *s)
327 {
328     ParseContext1 *pc = s->priv_data;
329
330     pc->enc = av_mallocz(sizeof(MpegEncContext));
331     if (!pc->enc)
332         return -1;
333     pc->first_picture = 1;
334     return 0;
335 }
336
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)
341 {
342     ParseContext *pc = s->priv_data;
343     int next;
344
345     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
346         next= buf_size;
347     }else{
348         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
349
350         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
351             *poutbuf = NULL;
352             *poutbuf_size = 0;
353             return buf_size;
354         }
355     }
356     av_mpeg4_decode_header(s, avctx, buf, buf_size);
357
358     *poutbuf = (uint8_t *)buf;
359     *poutbuf_size = buf_size;
360     return next;
361 }
362 #endif
363
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)
369 {
370     ParseContext *pc = s->priv_data;
371     int next;
372
373     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
374         next= buf_size;
375     }else{
376         next= ff_cavs_find_frame_end(pc, buf, buf_size);
377
378         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
379             *poutbuf = NULL;
380             *poutbuf_size = 0;
381             return buf_size;
382         }
383     }
384     *poutbuf = (uint8_t *)buf;
385     *poutbuf_size = buf_size;
386     return next;
387 }
388 #endif /* CONFIG_CAVSVIDEO_PARSER */
389
390 int ff_mpeg4video_split(AVCodecContext *avctx,
391                            const uint8_t *buf, int buf_size)
392 {
393     int i;
394     uint32_t state= -1;
395
396     for(i=0; i<buf_size; i++){
397         state= (state<<8) | buf[i];
398         if(state == 0x1B3 || state == 0x1B6)
399             return i-3;
400     }
401     return 0;
402 }
403
404 /*************************/
405
406 #ifdef CONFIG_MPEGAUDIO_PARSER
407 typedef struct MpegAudioParseContext {
408     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
409     uint8_t *inbuf_ptr;
410     int frame_size;
411     int free_format_frame_size;
412     int free_format_next_header;
413     uint32_t header;
414     int header_count;
415 } MpegAudioParseContext;
416
417 #define MPA_HEADER_SIZE 4
418
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))
423
424 static int mpegaudio_parse_init(AVCodecParserContext *s1)
425 {
426     MpegAudioParseContext *s = s1->priv_data;
427     s->inbuf_ptr = s->inbuf;
428     return 0;
429 }
430
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)
435 {
436     MpegAudioParseContext *s = s1->priv_data;
437     int len, ret, sr;
438     uint32_t header;
439     const uint8_t *buf_ptr;
440
441     *poutbuf = NULL;
442     *poutbuf_size = 0;
443     buf_ptr = buf;
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;
456                 goto got_header;
457             }
458             /* no header seen : find one. We need at least MPA_HEADER_SIZE
459                bytes to parse it */
460             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
461             if (len > 0) {
462                 memcpy(s->inbuf_ptr, buf_ptr, len);
463                 buf_ptr += len;
464                 buf_size -= len;
465                 s->inbuf_ptr += len;
466             }
467             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
468             got_header:
469                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
470                     (s->inbuf[2] << 8) | s->inbuf[3];
471
472                 ret = mpa_decode_header(avctx, header, &sr);
473                 if (ret < 0) {
474                     s->header_count= -2;
475                     /* no sync found : move by one byte (inefficient, but simple!) */
476                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
477                     s->inbuf_ptr--;
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;
482                 } else {
483                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
484                         s->header_count= -3;
485                     s->header= header;
486                     s->header_count++;
487                     s->frame_size = ret;
488
489 #if 0
490                     /* free format: prepare to compute frame size */
491                     if (decode_header(s, header) == 1) {
492                         s->frame_size = -1;
493                     }
494 #endif
495                 }
496                 if(s->header_count > 1)
497                     avctx->sample_rate= sr;
498             }
499         } else
500 #if 0
501         if (s->frame_size == -1) {
502             /* free format : find next sync to compute frame size */
503             len = MPA_MAX_CODED_FRAME_SIZE - len;
504             if (len > buf_size)
505                 len = buf_size;
506             if (len == 0) {
507                 /* frame too long: resync */
508                 s->frame_size = 0;
509                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
510                 s->inbuf_ptr--;
511             } else {
512                 uint8_t *p, *pend;
513                 uint32_t header1;
514                 int padding;
515
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;
520                 while (p <= pend) {
521                     header = (p[0] << 24) | (p[1] << 16) |
522                         (p[2] << 8) | p[3];
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
526                        valid header */
527                     if ((header & SAME_HEADER_MASK) ==
528                         (header1 & SAME_HEADER_MASK)) {
529                         /* header found: update pointers */
530                         len = (p + 4) - s->inbuf_ptr;
531                         buf_ptr += len;
532                         buf_size -= len;
533                         s->inbuf_ptr = p;
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;
538                         if (s->layer == 1)
539                             s->free_format_frame_size -= padding * 4;
540                         else
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);
545                         goto next_data;
546                     }
547                     p++;
548                 }
549                 /* not found: simply increase pointers */
550                 buf_ptr += len;
551                 s->inbuf_ptr += len;
552                 buf_size -= len;
553             }
554         } else
555 #endif
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);
561             buf_ptr += len;
562             s->inbuf_ptr += len;
563             buf_size -= len;
564         }
565
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){
569                 *poutbuf = buf;
570                 *poutbuf_size = s->frame_size;
571             }
572             buf_ptr = buf + s->frame_size;
573             s->inbuf_ptr = s->inbuf;
574             s->frame_size = 0;
575             break;
576         }
577
578         //    next_data:
579         if (s->frame_size > 0 &&
580             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
581             if(s->header_count > 0){
582                 *poutbuf = s->inbuf;
583                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
584             }
585             s->inbuf_ptr = s->inbuf;
586             s->frame_size = 0;
587             break;
588         }
589     }
590     return buf_ptr - buf;
591 }
592 #endif /* CONFIG_MPEGAUDIO_PARSER */
593
594 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
595 /* also used for ADTS AAC */
596 typedef struct AC3ParseContext {
597     uint8_t *inbuf_ptr;
598     int frame_size;
599     int header_size;
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 */
603 } AC3ParseContext;
604
605 #define AC3_HEADER_SIZE 7
606 #define AAC_HEADER_SIZE 7
607
608 #ifdef CONFIG_AC3_PARSER
609 static const int ac3_sample_rates[4] = {
610     48000, 44100, 32000, 0
611 };
612
613 static const int ac3_frame_sizes[64][3] = {
614     { 64,   69,   96   },
615     { 64,   70,   96   },
616     { 80,   87,   120  },
617     { 80,   88,   120  },
618     { 96,   104,  144  },
619     { 96,   105,  144  },
620     { 112,  121,  168  },
621     { 112,  122,  168  },
622     { 128,  139,  192  },
623     { 128,  140,  192  },
624     { 160,  174,  240  },
625     { 160,  175,  240  },
626     { 192,  208,  288  },
627     { 192,  209,  288  },
628     { 224,  243,  336  },
629     { 224,  244,  336  },
630     { 256,  278,  384  },
631     { 256,  279,  384  },
632     { 320,  348,  480  },
633     { 320,  349,  480  },
634     { 384,  417,  576  },
635     { 384,  418,  576  },
636     { 448,  487,  672  },
637     { 448,  488,  672  },
638     { 512,  557,  768  },
639     { 512,  558,  768  },
640     { 640,  696,  960  },
641     { 640,  697,  960  },
642     { 768,  835,  1152 },
643     { 768,  836,  1152 },
644     { 896,  975,  1344 },
645     { 896,  976,  1344 },
646     { 1024, 1114, 1536 },
647     { 1024, 1115, 1536 },
648     { 1152, 1253, 1728 },
649     { 1152, 1254, 1728 },
650     { 1280, 1393, 1920 },
651     { 1280, 1394, 1920 },
652 };
653
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,
658 };
659
660 static const int ac3_channels[8] = {
661     2, 1, 2, 3, 3, 4, 4, 5
662 };
663 #endif /* CONFIG_AC3_PARSER */
664
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
669 };
670
671 static const int aac_channels[8] = {
672     0, 1, 2, 3, 4, 5, 6, 8
673 };
674 #endif
675
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)
679 {
680     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
681     GetBitContext bits;
682
683     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
684
685     if(get_bits(&bits, 16) != 0x0b77)
686         return 0;
687
688     skip_bits(&bits, 16);       /* crc */
689     fscod = get_bits(&bits, 2);
690     frmsizecod = get_bits(&bits, 6);
691
692     if(!ac3_sample_rates[fscod])
693         return 0;
694
695     bsid = get_bits(&bits, 5);
696     if(bsid > 8)
697         return 0;
698     skip_bits(&bits, 3);        /* bsmod */
699     acmod = get_bits(&bits, 3);
700     if(acmod & 1 && acmod != 1)
701         skip_bits(&bits, 2);    /* cmixlev */
702     if(acmod & 4)
703         skip_bits(&bits, 2);    /* surmixlev */
704     if(acmod & 2)
705         skip_bits(&bits, 2);    /* dsurmod */
706     lfeon = get_bits1(&bits);
707
708     *sample_rate = ac3_sample_rates[fscod];
709     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
710     *channels = ac3_channels[acmod] + lfeon;
711     *samples = 6 * 256;
712
713     return ac3_frame_sizes[frmsizecod][fscod] * 2;
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_CAVSVIDEO_PARSER
861 AVCodecParser cavsvideo_parser = {
862     { CODEC_ID_CAVS },
863     sizeof(ParseContext1),
864     NULL,
865     cavsvideo_parse,
866     ff_parse1_close,
867     ff_mpeg4video_split,
868 };
869 #endif
870 #ifdef CONFIG_MPEGAUDIO_PARSER
871 AVCodecParser mpegaudio_parser = {
872     { CODEC_ID_MP2, CODEC_ID_MP3 },
873     sizeof(MpegAudioParseContext),
874     mpegaudio_parse_init,
875     mpegaudio_parse,
876     NULL,
877 };
878 #endif
879 #ifdef CONFIG_AC3_PARSER
880 AVCodecParser ac3_parser = {
881     { CODEC_ID_AC3 },
882     sizeof(AC3ParseContext),
883     ac3_parse_init,
884     ac3_parse,
885     NULL,
886 };
887 #endif
888 #ifdef CONFIG_AAC_PARSER
889 AVCodecParser aac_parser = {
890     { CODEC_ID_AAC },
891     sizeof(AC3ParseContext),
892     aac_parse_init,
893     ac3_parse,
894     NULL,
895 };
896 #endif