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