Change license headers to say 'FFmpeg' instead of 'this program/this library'
[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
26 AVCodecParser *av_first_parser = NULL;
27
28 void av_register_codec_parser(AVCodecParser *parser)
29 {
30     parser->next = av_first_parser;
31     av_first_parser = parser;
32 }
33
34 AVCodecParserContext *av_parser_init(int codec_id)
35 {
36     AVCodecParserContext *s;
37     AVCodecParser *parser;
38     int ret;
39
40     if(codec_id == CODEC_ID_NONE)
41         return NULL;
42
43     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
44         if (parser->codec_ids[0] == codec_id ||
45             parser->codec_ids[1] == codec_id ||
46             parser->codec_ids[2] == codec_id ||
47             parser->codec_ids[3] == codec_id ||
48             parser->codec_ids[4] == codec_id)
49             goto found;
50     }
51     return NULL;
52  found:
53     s = av_mallocz(sizeof(AVCodecParserContext));
54     if (!s)
55         return NULL;
56     s->parser = parser;
57     s->priv_data = av_mallocz(parser->priv_data_size);
58     if (!s->priv_data) {
59         av_free(s);
60         return NULL;
61     }
62     if (parser->parser_init) {
63         ret = parser->parser_init(s);
64         if (ret != 0) {
65             av_free(s->priv_data);
66             av_free(s);
67             return NULL;
68         }
69     }
70     s->fetch_timestamp=1;
71     return s;
72 }
73
74 /* NOTE: buf_size == 0 is used to signal EOF so that the last frame
75    can be returned if necessary */
76 int av_parser_parse(AVCodecParserContext *s,
77                     AVCodecContext *avctx,
78                     uint8_t **poutbuf, int *poutbuf_size,
79                     const uint8_t *buf, int buf_size,
80                     int64_t pts, int64_t dts)
81 {
82     int index, i, k;
83     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
84
85     if (buf_size == 0) {
86         /* padding is always necessary even if EOF, so we add it here */
87         memset(dummy_buf, 0, sizeof(dummy_buf));
88         buf = dummy_buf;
89     } else {
90         /* add a new packet descriptor */
91         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
92         s->cur_frame_start_index = k;
93         s->cur_frame_offset[k] = s->cur_offset;
94         s->cur_frame_pts[k] = pts;
95         s->cur_frame_dts[k] = dts;
96
97         /* fill first PTS/DTS */
98         if (s->fetch_timestamp){
99             s->fetch_timestamp=0;
100             s->last_pts = pts;
101             s->last_dts = dts;
102             s->cur_frame_pts[k] =
103             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
104         }
105     }
106
107     /* WARNING: the returned index can be negative */
108     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
109 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%lld, %lld, out:%lld, %lld, in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
110     /* update the file pointer */
111     if (*poutbuf_size) {
112         /* fill the data for the current frame */
113         s->frame_offset = s->last_frame_offset;
114         s->pts = s->last_pts;
115         s->dts = s->last_dts;
116
117         /* offset of the next frame */
118         s->last_frame_offset = s->cur_offset + index;
119         /* find the packet in which the new frame starts. It
120            is tricky because of MPEG video start codes
121            which can begin in one packet and finish in
122            another packet. In the worst case, an MPEG
123            video start code could be in 4 different
124            packets. */
125         k = s->cur_frame_start_index;
126         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
127             if (s->last_frame_offset >= s->cur_frame_offset[k])
128                 break;
129             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
130         }
131
132         s->last_pts = s->cur_frame_pts[k];
133         s->last_dts = s->cur_frame_dts[k];
134
135         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
136            so the next pts/dts is in the next chunk */
137         if(index == buf_size){
138             s->fetch_timestamp=1;
139         }
140     }
141     if (index < 0)
142         index = 0;
143     s->cur_offset += index;
144     return index;
145 }
146
147 /**
148  *
149  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
150  * @deprecated use AVBitstreamFilter
151  */
152 int av_parser_change(AVCodecParserContext *s,
153                      AVCodecContext *avctx,
154                      uint8_t **poutbuf, int *poutbuf_size,
155                      const uint8_t *buf, int buf_size, int keyframe){
156
157     if(s && s->parser->split){
158         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
159             int i= s->parser->split(avctx, buf, buf_size);
160             buf += i;
161             buf_size -= i;
162         }
163     }
164
165     /* cast to avoid warning about discarding qualifiers */
166     *poutbuf= (uint8_t *) buf;
167     *poutbuf_size= buf_size;
168     if(avctx->extradata){
169         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
170             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
171             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
172             int size= buf_size + avctx->extradata_size;
173             *poutbuf_size= size;
174             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
175
176             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
177             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
178             return 1;
179         }
180     }
181
182     return 0;
183 }
184
185 void av_parser_close(AVCodecParserContext *s)
186 {
187     if (s->parser->parser_close)
188         s->parser->parser_close(s);
189     av_free(s->priv_data);
190     av_free(s);
191 }
192
193 /*****************************************************/
194
195 //#define END_NOT_FOUND (-100)
196
197 #define PICTURE_START_CODE      0x00000100
198 #define SEQ_START_CODE          0x000001b3
199 #define EXT_START_CODE          0x000001b5
200 #define SLICE_MIN_START_CODE    0x00000101
201 #define SLICE_MAX_START_CODE    0x000001af
202
203 typedef struct ParseContext1{
204     ParseContext pc;
205 /* XXX/FIXME PC1 vs. PC */
206     /* MPEG2 specific */
207     int frame_rate;
208     int progressive_sequence;
209     int width, height;
210
211     /* XXX: suppress that, needed by MPEG4 */
212     MpegEncContext *enc;
213     int first_picture;
214 } ParseContext1;
215
216 /**
217  * combines the (truncated) bitstream to a complete frame
218  * @returns -1 if no complete frame could be created
219  */
220 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
221 {
222 #if 0
223     if(pc->overread){
224         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
225         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
226     }
227 #endif
228
229     /* copy overreaded bytes from last frame into buffer */
230     for(; pc->overread>0; pc->overread--){
231         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
232     }
233
234     /* flush remaining if EOF */
235     if(!*buf_size && next == END_NOT_FOUND){
236         next= 0;
237     }
238
239     pc->last_index= pc->index;
240
241     /* copy into buffer end return */
242     if(next == END_NOT_FOUND){
243         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
244
245         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
246         pc->index += *buf_size;
247         return -1;
248     }
249
250     *buf_size=
251     pc->overread_index= pc->index + next;
252
253     /* append to buffer */
254     if(pc->index){
255         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
256
257         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
258         pc->index = 0;
259         *buf= pc->buffer;
260     }
261
262     /* store overread bytes */
263     for(;next < 0; next++){
264         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
265         pc->overread++;
266     }
267
268 #if 0
269     if(pc->overread){
270         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
271         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
272     }
273 #endif
274
275     return 0;
276 }
277
278 /* XXX: merge with libavcodec ? */
279 #define MPEG1_FRAME_RATE_BASE 1001
280
281 static const int frame_rate_tab[16] = {
282         0,
283     24000,
284     24024,
285     25025,
286     30000,
287     30030,
288     50050,
289     60000,
290     60060,
291   // Xing's 15fps: (9)
292     15015,
293   // libmpeg3's "Unofficial economy rates": (10-13)
294      5005,
295     10010,
296     12012,
297     15015,
298   // random, just to avoid segfault !never encode these
299     25025,
300     25025,
301 };
302
303 #ifdef CONFIG_MPEGVIDEO_PARSER
304 //FIXME move into mpeg12.c
305 static void mpegvideo_extract_headers(AVCodecParserContext *s,
306                                       AVCodecContext *avctx,
307                                       const uint8_t *buf, int buf_size)
308 {
309     ParseContext1 *pc = s->priv_data;
310     const uint8_t *buf_end;
311     uint32_t start_code;
312     int frame_rate_index, ext_type, bytes_left;
313     int frame_rate_ext_n, frame_rate_ext_d;
314     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
315     int horiz_size_ext, vert_size_ext, bit_rate_ext;
316 //FIXME replace the crap with get_bits()
317     s->repeat_pict = 0;
318     buf_end = buf + buf_size;
319     while (buf < buf_end) {
320         start_code= -1;
321         buf= ff_find_start_code(buf, buf_end, &start_code);
322         bytes_left = buf_end - buf;
323         switch(start_code) {
324         case PICTURE_START_CODE:
325             if (bytes_left >= 2) {
326                 s->pict_type = (buf[1] >> 3) & 7;
327             }
328             break;
329         case SEQ_START_CODE:
330             if (bytes_left >= 7) {
331                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
332                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
333                 avcodec_set_dimensions(avctx, pc->width, pc->height);
334                 frame_rate_index = buf[3] & 0xf;
335                 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
336                 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
337                 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
338                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
339                 avctx->sub_id = 1;
340             }
341             break;
342         case EXT_START_CODE:
343             if (bytes_left >= 1) {
344                 ext_type = (buf[0] >> 4);
345                 switch(ext_type) {
346                 case 0x1: /* sequence extension */
347                     if (bytes_left >= 6) {
348                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
349                         vert_size_ext = (buf[2] >> 5) & 3;
350                         bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
351                         frame_rate_ext_n = (buf[5] >> 5) & 3;
352                         frame_rate_ext_d = (buf[5] & 0x1f);
353                         pc->progressive_sequence = buf[1] & (1 << 3);
354                         avctx->has_b_frames= !(buf[5] >> 7);
355
356                         pc->width  |=(horiz_size_ext << 12);
357                         pc->height |=( vert_size_ext << 12);
358                         avctx->bit_rate += (bit_rate_ext << 18) * 400;
359                         avcodec_set_dimensions(avctx, pc->width, pc->height);
360                         avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
361                         avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
362                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
363                         avctx->sub_id = 2; /* forces MPEG2 */
364                     }
365                     break;
366                 case 0x8: /* picture coding extension */
367                     if (bytes_left >= 5) {
368                         picture_structure = buf[2]&3;
369                         top_field_first = buf[3] & (1 << 7);
370                         repeat_first_field = buf[3] & (1 << 1);
371                         progressive_frame = buf[4] & (1 << 7);
372
373                         /* check if we must repeat the frame */
374                         if (repeat_first_field) {
375                             if (pc->progressive_sequence) {
376                                 if (top_field_first)
377                                     s->repeat_pict = 4;
378                                 else
379                                     s->repeat_pict = 2;
380                             } else if (progressive_frame) {
381                                 s->repeat_pict = 1;
382                             }
383                         }
384
385                         /* the packet only represents half a frame
386                            XXX,FIXME maybe find a different solution */
387                         if(picture_structure != 3)
388                             s->repeat_pict = -1;
389                     }
390                     break;
391                 }
392             }
393             break;
394         case -1:
395             goto the_end;
396         default:
397             /* we stop parsing when we encounter a slice. It ensures
398                that this function takes a negligible amount of time */
399             if (start_code >= SLICE_MIN_START_CODE &&
400                 start_code <= SLICE_MAX_START_CODE)
401                 goto the_end;
402             break;
403         }
404     }
405  the_end: ;
406 }
407
408 static int mpegvideo_parse(AVCodecParserContext *s,
409                            AVCodecContext *avctx,
410                            uint8_t **poutbuf, int *poutbuf_size,
411                            const uint8_t *buf, int buf_size)
412 {
413     ParseContext1 *pc1 = s->priv_data;
414     ParseContext *pc= &pc1->pc;
415     int next;
416
417     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
418         next= buf_size;
419     }else{
420         next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
421
422         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
423             *poutbuf = NULL;
424             *poutbuf_size = 0;
425             return buf_size;
426         }
427
428     }
429     /* we have a full frame : we just parse the first few MPEG headers
430        to have the full timing information. The time take by this
431        function should be negligible for uncorrupted streams */
432     mpegvideo_extract_headers(s, avctx, buf, buf_size);
433 #if 0
434     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
435            s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
436 #endif
437
438     *poutbuf = (uint8_t *)buf;
439     *poutbuf_size = buf_size;
440     return next;
441 }
442
443 static int mpegvideo_split(AVCodecContext *avctx,
444                            const uint8_t *buf, int buf_size)
445 {
446     int i;
447     uint32_t state= -1;
448
449     for(i=0; i<buf_size; i++){
450         state= (state<<8) | buf[i];
451         if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
452             return i-3;
453     }
454     return 0;
455 }
456 #endif /* CONFIG_MPEGVIDEO_PARSER */
457
458 void ff_parse_close(AVCodecParserContext *s)
459 {
460     ParseContext *pc = s->priv_data;
461
462     av_free(pc->buffer);
463 }
464
465 static void parse1_close(AVCodecParserContext *s)
466 {
467     ParseContext1 *pc1 = s->priv_data;
468
469     av_free(pc1->pc.buffer);
470     av_free(pc1->enc);
471 }
472
473 /*************************/
474
475 #ifdef CONFIG_MPEG4VIDEO_PARSER
476 /* used by parser */
477 /* XXX: make it use less memory */
478 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
479                                   AVCodecContext *avctx,
480                                   const uint8_t *buf, int buf_size)
481 {
482     ParseContext1 *pc = s1->priv_data;
483     MpegEncContext *s = pc->enc;
484     GetBitContext gb1, *gb = &gb1;
485     int ret;
486
487     s->avctx = avctx;
488     s->current_picture_ptr = &s->current_picture;
489
490     if (avctx->extradata_size && pc->first_picture){
491         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
492         ret = ff_mpeg4_decode_picture_header(s, gb);
493     }
494
495     init_get_bits(gb, buf, 8 * buf_size);
496     ret = ff_mpeg4_decode_picture_header(s, gb);
497     if (s->width) {
498         avcodec_set_dimensions(avctx, s->width, s->height);
499     }
500     s1->pict_type= s->pict_type;
501     pc->first_picture = 0;
502     return ret;
503 }
504
505 static int mpeg4video_parse_init(AVCodecParserContext *s)
506 {
507     ParseContext1 *pc = s->priv_data;
508
509     pc->enc = av_mallocz(sizeof(MpegEncContext));
510     if (!pc->enc)
511         return -1;
512     pc->first_picture = 1;
513     return 0;
514 }
515
516 static int mpeg4video_parse(AVCodecParserContext *s,
517                            AVCodecContext *avctx,
518                            uint8_t **poutbuf, int *poutbuf_size,
519                            const uint8_t *buf, int buf_size)
520 {
521     ParseContext *pc = s->priv_data;
522     int next;
523
524     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
525         next= buf_size;
526     }else{
527         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
528
529         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
530             *poutbuf = NULL;
531             *poutbuf_size = 0;
532             return buf_size;
533         }
534     }
535     av_mpeg4_decode_header(s, avctx, buf, buf_size);
536
537     *poutbuf = (uint8_t *)buf;
538     *poutbuf_size = buf_size;
539     return next;
540 }
541 #endif
542
543 #ifdef CONFIG_CAVSVIDEO_PARSER
544 static int cavsvideo_parse(AVCodecParserContext *s,
545                            AVCodecContext *avctx,
546                            uint8_t **poutbuf, int *poutbuf_size,
547                            const uint8_t *buf, int buf_size)
548 {
549     ParseContext *pc = s->priv_data;
550     int next;
551
552     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
553         next= buf_size;
554     }else{
555         next= ff_cavs_find_frame_end(pc, buf, buf_size);
556
557         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
558             *poutbuf = NULL;
559             *poutbuf_size = 0;
560             return buf_size;
561         }
562     }
563     *poutbuf = (uint8_t *)buf;
564     *poutbuf_size = buf_size;
565     return next;
566 }
567 #endif /* CONFIG_CAVSVIDEO_PARSER */
568
569 static int mpeg4video_split(AVCodecContext *avctx,
570                            const uint8_t *buf, int buf_size)
571 {
572     int i;
573     uint32_t state= -1;
574
575     for(i=0; i<buf_size; i++){
576         state= (state<<8) | buf[i];
577         if(state == 0x1B3 || state == 0x1B6)
578             return i-3;
579     }
580     return 0;
581 }
582
583 /*************************/
584
585 #ifdef CONFIG_MPEGAUDIO_PARSER
586 typedef struct MpegAudioParseContext {
587     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
588     uint8_t *inbuf_ptr;
589     int frame_size;
590     int free_format_frame_size;
591     int free_format_next_header;
592     uint32_t header;
593     int header_count;
594 } MpegAudioParseContext;
595
596 #define MPA_HEADER_SIZE 4
597
598 /* header + layer + bitrate + freq + lsf/mpeg25 */
599 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
600 #define SAME_HEADER_MASK \
601    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
602
603 static int mpegaudio_parse_init(AVCodecParserContext *s1)
604 {
605     MpegAudioParseContext *s = s1->priv_data;
606     s->inbuf_ptr = s->inbuf;
607     return 0;
608 }
609
610 static int mpegaudio_parse(AVCodecParserContext *s1,
611                            AVCodecContext *avctx,
612                            uint8_t **poutbuf, int *poutbuf_size,
613                            const uint8_t *buf, int buf_size)
614 {
615     MpegAudioParseContext *s = s1->priv_data;
616     int len, ret, sr;
617     uint32_t header;
618     const uint8_t *buf_ptr;
619
620     *poutbuf = NULL;
621     *poutbuf_size = 0;
622     buf_ptr = buf;
623     while (buf_size > 0) {
624         len = s->inbuf_ptr - s->inbuf;
625         if (s->frame_size == 0) {
626             /* special case for next header for first frame in free
627                format case (XXX: find a simpler method) */
628             if (s->free_format_next_header != 0) {
629                 s->inbuf[0] = s->free_format_next_header >> 24;
630                 s->inbuf[1] = s->free_format_next_header >> 16;
631                 s->inbuf[2] = s->free_format_next_header >> 8;
632                 s->inbuf[3] = s->free_format_next_header;
633                 s->inbuf_ptr = s->inbuf + 4;
634                 s->free_format_next_header = 0;
635                 goto got_header;
636             }
637             /* no header seen : find one. We need at least MPA_HEADER_SIZE
638                bytes to parse it */
639             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
640             if (len > 0) {
641                 memcpy(s->inbuf_ptr, buf_ptr, len);
642                 buf_ptr += len;
643                 buf_size -= len;
644                 s->inbuf_ptr += len;
645             }
646             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
647             got_header:
648                 sr= avctx->sample_rate;
649                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
650                     (s->inbuf[2] << 8) | s->inbuf[3];
651
652                 ret = mpa_decode_header(avctx, header);
653                 if (ret < 0) {
654                     s->header_count= -2;
655                     /* no sync found : move by one byte (inefficient, but simple!) */
656                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
657                     s->inbuf_ptr--;
658                     dprintf("skip %x\n", header);
659                     /* reset free format frame size to give a chance
660                        to get a new bitrate */
661                     s->free_format_frame_size = 0;
662                 } else {
663                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
664                         s->header_count= -3;
665                     s->header= header;
666                     s->header_count++;
667                     s->frame_size = ret;
668
669 #if 0
670                     /* free format: prepare to compute frame size */
671                     if (decode_header(s, header) == 1) {
672                         s->frame_size = -1;
673                     }
674 #endif
675                 }
676                 if(s->header_count <= 0)
677                     avctx->sample_rate= sr; //FIXME ugly
678             }
679         } else
680 #if 0
681         if (s->frame_size == -1) {
682             /* free format : find next sync to compute frame size */
683             len = MPA_MAX_CODED_FRAME_SIZE - len;
684             if (len > buf_size)
685                 len = buf_size;
686             if (len == 0) {
687                 /* frame too long: resync */
688                 s->frame_size = 0;
689                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
690                 s->inbuf_ptr--;
691             } else {
692                 uint8_t *p, *pend;
693                 uint32_t header1;
694                 int padding;
695
696                 memcpy(s->inbuf_ptr, buf_ptr, len);
697                 /* check for header */
698                 p = s->inbuf_ptr - 3;
699                 pend = s->inbuf_ptr + len - 4;
700                 while (p <= pend) {
701                     header = (p[0] << 24) | (p[1] << 16) |
702                         (p[2] << 8) | p[3];
703                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
704                         (s->inbuf[2] << 8) | s->inbuf[3];
705                     /* check with high probability that we have a
706                        valid header */
707                     if ((header & SAME_HEADER_MASK) ==
708                         (header1 & SAME_HEADER_MASK)) {
709                         /* header found: update pointers */
710                         len = (p + 4) - s->inbuf_ptr;
711                         buf_ptr += len;
712                         buf_size -= len;
713                         s->inbuf_ptr = p;
714                         /* compute frame size */
715                         s->free_format_next_header = header;
716                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
717                         padding = (header1 >> 9) & 1;
718                         if (s->layer == 1)
719                             s->free_format_frame_size -= padding * 4;
720                         else
721                             s->free_format_frame_size -= padding;
722                         dprintf("free frame size=%d padding=%d\n",
723                                 s->free_format_frame_size, padding);
724                         decode_header(s, header1);
725                         goto next_data;
726                     }
727                     p++;
728                 }
729                 /* not found: simply increase pointers */
730                 buf_ptr += len;
731                 s->inbuf_ptr += len;
732                 buf_size -= len;
733             }
734         } else
735 #endif
736         if (len < s->frame_size) {
737             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
738                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
739             len = FFMIN(s->frame_size - len, buf_size);
740             memcpy(s->inbuf_ptr, buf_ptr, len);
741             buf_ptr += len;
742             s->inbuf_ptr += len;
743             buf_size -= len;
744         }
745
746         if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
747            && buf_size + buf_ptr - buf >= s->frame_size){
748             if(s->header_count > 0){
749                 *poutbuf = buf;
750                 *poutbuf_size = s->frame_size;
751             }
752             buf_ptr = buf + s->frame_size;
753             s->inbuf_ptr = s->inbuf;
754             s->frame_size = 0;
755             break;
756         }
757
758         //    next_data:
759         if (s->frame_size > 0 &&
760             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
761             if(s->header_count > 0){
762                 *poutbuf = s->inbuf;
763                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
764             }
765             s->inbuf_ptr = s->inbuf;
766             s->frame_size = 0;
767             break;
768         }
769     }
770     return buf_ptr - buf;
771 }
772 #endif /* CONFIG_MPEGAUDIO_PARSER */
773
774 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
775 /* also used for ADTS AAC */
776 typedef struct AC3ParseContext {
777     uint8_t *inbuf_ptr;
778     int frame_size;
779     int header_size;
780     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
781                 int *bit_rate, int *samples);
782     uint8_t inbuf[8192]; /* input buffer */
783 } AC3ParseContext;
784
785 #define AC3_HEADER_SIZE 7
786 #define AAC_HEADER_SIZE 7
787
788 #ifdef CONFIG_AC3_PARSER
789 static const int ac3_sample_rates[4] = {
790     48000, 44100, 32000, 0
791 };
792
793 static const int ac3_frame_sizes[64][3] = {
794     { 64,   69,   96   },
795     { 64,   70,   96   },
796     { 80,   87,   120  },
797     { 80,   88,   120  },
798     { 96,   104,  144  },
799     { 96,   105,  144  },
800     { 112,  121,  168  },
801     { 112,  122,  168  },
802     { 128,  139,  192  },
803     { 128,  140,  192  },
804     { 160,  174,  240  },
805     { 160,  175,  240  },
806     { 192,  208,  288  },
807     { 192,  209,  288  },
808     { 224,  243,  336  },
809     { 224,  244,  336  },
810     { 256,  278,  384  },
811     { 256,  279,  384  },
812     { 320,  348,  480  },
813     { 320,  349,  480  },
814     { 384,  417,  576  },
815     { 384,  418,  576  },
816     { 448,  487,  672  },
817     { 448,  488,  672  },
818     { 512,  557,  768  },
819     { 512,  558,  768  },
820     { 640,  696,  960  },
821     { 640,  697,  960  },
822     { 768,  835,  1152 },
823     { 768,  836,  1152 },
824     { 896,  975,  1344 },
825     { 896,  976,  1344 },
826     { 1024, 1114, 1536 },
827     { 1024, 1115, 1536 },
828     { 1152, 1253, 1728 },
829     { 1152, 1254, 1728 },
830     { 1280, 1393, 1920 },
831     { 1280, 1394, 1920 },
832 };
833
834 static const int ac3_bitrates[64] = {
835     32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
836     128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
837     384, 448, 448, 512, 512, 576, 576, 640, 640,
838 };
839
840 static const int ac3_channels[8] = {
841     2, 1, 2, 3, 3, 4, 4, 5
842 };
843 #endif /* CONFIG_AC3_PARSER */
844
845 #ifdef CONFIG_AAC_PARSER
846 static const int aac_sample_rates[16] = {
847     96000, 88200, 64000, 48000, 44100, 32000,
848     24000, 22050, 16000, 12000, 11025, 8000, 7350
849 };
850
851 static const int aac_channels[8] = {
852     0, 1, 2, 3, 4, 5, 6, 8
853 };
854 #endif
855
856 #ifdef CONFIG_AC3_PARSER
857 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
858                     int *bit_rate, int *samples)
859 {
860     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
861     GetBitContext bits;
862
863     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
864
865     if(get_bits(&bits, 16) != 0x0b77)
866         return 0;
867
868     skip_bits(&bits, 16);       /* crc */
869     fscod = get_bits(&bits, 2);
870     frmsizecod = get_bits(&bits, 6);
871
872     if(!ac3_sample_rates[fscod])
873         return 0;
874
875     bsid = get_bits(&bits, 5);
876     if(bsid > 8)
877         return 0;
878     skip_bits(&bits, 3);        /* bsmod */
879     acmod = get_bits(&bits, 3);
880     if(acmod & 1 && acmod != 1)
881         skip_bits(&bits, 2);    /* cmixlev */
882     if(acmod & 4)
883         skip_bits(&bits, 2);    /* surmixlev */
884     if(acmod & 2)
885         skip_bits(&bits, 2);    /* dsurmod */
886     lfeon = get_bits1(&bits);
887
888     *sample_rate = ac3_sample_rates[fscod];
889     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
890     *channels = ac3_channels[acmod] + lfeon;
891     *samples = 6 * 256;
892
893     return ac3_frame_sizes[frmsizecod][fscod] * 2;
894 }
895 #endif /* CONFIG_AC3_PARSER */
896
897 #ifdef CONFIG_AAC_PARSER
898 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
899                     int *bit_rate, int *samples)
900 {
901     GetBitContext bits;
902     int size, rdb, ch, sr;
903
904     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
905
906     if(get_bits(&bits, 12) != 0xfff)
907         return 0;
908
909     skip_bits1(&bits);          /* id */
910     skip_bits(&bits, 2);        /* layer */
911     skip_bits1(&bits);          /* protection_absent */
912     skip_bits(&bits, 2);        /* profile_objecttype */
913     sr = get_bits(&bits, 4);    /* sample_frequency_index */
914     if(!aac_sample_rates[sr])
915         return 0;
916     skip_bits1(&bits);          /* private_bit */
917     ch = get_bits(&bits, 3);    /* channel_configuration */
918     if(!aac_channels[ch])
919         return 0;
920     skip_bits1(&bits);          /* original/copy */
921     skip_bits1(&bits);          /* home */
922
923     /* adts_variable_header */
924     skip_bits1(&bits);          /* copyright_identification_bit */
925     skip_bits1(&bits);          /* copyright_identification_start */
926     size = get_bits(&bits, 13); /* aac_frame_length */
927     skip_bits(&bits, 11);       /* adts_buffer_fullness */
928     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
929
930     *channels = aac_channels[ch];
931     *sample_rate = aac_sample_rates[sr];
932     *samples = (rdb + 1) * 1024;
933     *bit_rate = size * 8 * *sample_rate / *samples;
934
935     return size;
936 }
937 #endif /* CONFIG_AAC_PARSER */
938
939 #ifdef CONFIG_AC3_PARSER
940 static int ac3_parse_init(AVCodecParserContext *s1)
941 {
942     AC3ParseContext *s = s1->priv_data;
943     s->inbuf_ptr = s->inbuf;
944     s->header_size = AC3_HEADER_SIZE;
945     s->sync = ac3_sync;
946     return 0;
947 }
948 #endif
949
950 #ifdef CONFIG_AAC_PARSER
951 static int aac_parse_init(AVCodecParserContext *s1)
952 {
953     AC3ParseContext *s = s1->priv_data;
954     s->inbuf_ptr = s->inbuf;
955     s->header_size = AAC_HEADER_SIZE;
956     s->sync = aac_sync;
957     return 0;
958 }
959 #endif
960
961 /* also used for ADTS AAC */
962 static int ac3_parse(AVCodecParserContext *s1,
963                      AVCodecContext *avctx,
964                      uint8_t **poutbuf, int *poutbuf_size,
965                      const uint8_t *buf, int buf_size)
966 {
967     AC3ParseContext *s = s1->priv_data;
968     const uint8_t *buf_ptr;
969     int len, sample_rate, bit_rate, channels, samples;
970
971     *poutbuf = NULL;
972     *poutbuf_size = 0;
973
974     buf_ptr = buf;
975     while (buf_size > 0) {
976         len = s->inbuf_ptr - s->inbuf;
977         if (s->frame_size == 0) {
978             /* no header seen : find one. We need at least s->header_size
979                bytes to parse it */
980             len = FFMIN(s->header_size - len, buf_size);
981
982             memcpy(s->inbuf_ptr, buf_ptr, len);
983             buf_ptr += len;
984             s->inbuf_ptr += len;
985             buf_size -= len;
986             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
987                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
988                               &samples);
989                 if (len == 0) {
990                     /* no sync found : move by one byte (inefficient, but simple!) */
991                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
992                     s->inbuf_ptr--;
993                 } else {
994                     s->frame_size = len;
995                     /* update codec info */
996                     avctx->sample_rate = sample_rate;
997                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
998                     if(avctx->codec_id == CODEC_ID_AC3){
999                         if(avctx->channels!=1 && avctx->channels!=2){
1000                             avctx->channels = channels;
1001                         }
1002                     } else {
1003                         avctx->channels = channels;
1004                     }
1005                     avctx->bit_rate = bit_rate;
1006                     avctx->frame_size = samples;
1007                 }
1008             }
1009         } else {
1010             len = FFMIN(s->frame_size - len, buf_size);
1011
1012             memcpy(s->inbuf_ptr, buf_ptr, len);
1013             buf_ptr += len;
1014             s->inbuf_ptr += len;
1015             buf_size -= len;
1016
1017             if(s->inbuf_ptr - s->inbuf == s->frame_size){
1018                 *poutbuf = s->inbuf;
1019                 *poutbuf_size = s->frame_size;
1020                 s->inbuf_ptr = s->inbuf;
1021                 s->frame_size = 0;
1022                 break;
1023             }
1024         }
1025     }
1026     return buf_ptr - buf;
1027 }
1028 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
1029
1030 #ifdef CONFIG_MPEGVIDEO_PARSER
1031 AVCodecParser mpegvideo_parser = {
1032     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
1033     sizeof(ParseContext1),
1034     NULL,
1035     mpegvideo_parse,
1036     parse1_close,
1037     mpegvideo_split,
1038 };
1039 #endif
1040 #ifdef CONFIG_MPEG4VIDEO_PARSER
1041 AVCodecParser mpeg4video_parser = {
1042     { CODEC_ID_MPEG4 },
1043     sizeof(ParseContext1),
1044     mpeg4video_parse_init,
1045     mpeg4video_parse,
1046     parse1_close,
1047     mpeg4video_split,
1048 };
1049 #endif
1050 #ifdef CONFIG_CAVSVIDEO_PARSER
1051 AVCodecParser cavsvideo_parser = {
1052     { CODEC_ID_CAVS },
1053     sizeof(ParseContext1),
1054     NULL,
1055     cavsvideo_parse,
1056     parse1_close,
1057     mpeg4video_split,
1058 };
1059 #endif
1060 #ifdef CONFIG_MPEGAUDIO_PARSER
1061 AVCodecParser mpegaudio_parser = {
1062     { CODEC_ID_MP2, CODEC_ID_MP3 },
1063     sizeof(MpegAudioParseContext),
1064     mpegaudio_parse_init,
1065     mpegaudio_parse,
1066     NULL,
1067 };
1068 #endif
1069 #ifdef CONFIG_AC3_PARSER
1070 AVCodecParser ac3_parser = {
1071     { CODEC_ID_AC3 },
1072     sizeof(AC3ParseContext),
1073     ac3_parse_init,
1074     ac3_parse,
1075     NULL,
1076 };
1077 #endif
1078 #ifdef CONFIG_AAC_PARSER
1079 AVCodecParser aac_parser = {
1080     { CODEC_ID_AAC },
1081     sizeof(AC3ParseContext),
1082     aac_parse_init,
1083     ac3_parse,
1084     NULL,
1085 };
1086 #endif