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