Remove all stray tabs and trailing whitespace, this time for good.
[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 static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
276 {
277     const uint8_t *buf_ptr;
278     unsigned int state=0xFFFFFFFF, v;
279     int val;
280
281     buf_ptr = *pbuf_ptr;
282     while (buf_ptr < buf_end) {
283         v = *buf_ptr++;
284         if (state == 0x000001) {
285             state = ((state << 8) | v) & 0xffffff;
286             val = state;
287             goto found;
288         }
289         state = ((state << 8) | v) & 0xffffff;
290     }
291     val = -1;
292  found:
293     *pbuf_ptr = buf_ptr;
294     return val;
295 }
296
297 /* XXX: merge with libavcodec ? */
298 #define MPEG1_FRAME_RATE_BASE 1001
299
300 static const int frame_rate_tab[16] = {
301         0,
302     24000,
303     24024,
304     25025,
305     30000,
306     30030,
307     50050,
308     60000,
309     60060,
310   // Xing's 15fps: (9)
311     15015,
312   // libmpeg3's "Unofficial economy rates": (10-13)
313      5005,
314     10010,
315     12012,
316     15015,
317   // random, just to avoid segfault !never encode these
318     25025,
319     25025,
320 };
321
322 //FIXME move into mpeg12.c
323 static void mpegvideo_extract_headers(AVCodecParserContext *s,
324                                       AVCodecContext *avctx,
325                                       const uint8_t *buf, int buf_size)
326 {
327     ParseContext1 *pc = s->priv_data;
328     const uint8_t *buf_end;
329     int32_t start_code;
330     int frame_rate_index, ext_type, bytes_left;
331     int frame_rate_ext_n, frame_rate_ext_d;
332     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
333     int horiz_size_ext, vert_size_ext, bit_rate_ext;
334 //FIXME replace the crap with get_bits()
335     s->repeat_pict = 0;
336     buf_end = buf + buf_size;
337     while (buf < buf_end) {
338         start_code = find_start_code(&buf, buf_end);
339         bytes_left = buf_end - buf;
340         switch(start_code) {
341         case PICTURE_START_CODE:
342             if (bytes_left >= 2) {
343                 s->pict_type = (buf[1] >> 3) & 7;
344             }
345             break;
346         case SEQ_START_CODE:
347             if (bytes_left >= 7) {
348                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
349                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
350                 avcodec_set_dimensions(avctx, pc->width, pc->height);
351                 frame_rate_index = buf[3] & 0xf;
352                 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
353                 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
354                 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
355                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
356                 avctx->sub_id = 1;
357             }
358             break;
359         case EXT_START_CODE:
360             if (bytes_left >= 1) {
361                 ext_type = (buf[0] >> 4);
362                 switch(ext_type) {
363                 case 0x1: /* sequence extension */
364                     if (bytes_left >= 6) {
365                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
366                         vert_size_ext = (buf[2] >> 5) & 3;
367                         bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
368                         frame_rate_ext_n = (buf[5] >> 5) & 3;
369                         frame_rate_ext_d = (buf[5] & 0x1f);
370                         pc->progressive_sequence = buf[1] & (1 << 3);
371                         avctx->has_b_frames= !(buf[5] >> 7);
372
373                         pc->width  |=(horiz_size_ext << 12);
374                         pc->height |=( vert_size_ext << 12);
375                         avctx->bit_rate += (bit_rate_ext << 18) * 400;
376                         avcodec_set_dimensions(avctx, pc->width, pc->height);
377                         avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
378                         avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
379                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
380                         avctx->sub_id = 2; /* forces MPEG2 */
381                     }
382                     break;
383                 case 0x8: /* picture coding extension */
384                     if (bytes_left >= 5) {
385                         picture_structure = buf[2]&3;
386                         top_field_first = buf[3] & (1 << 7);
387                         repeat_first_field = buf[3] & (1 << 1);
388                         progressive_frame = buf[4] & (1 << 7);
389
390                         /* check if we must repeat the frame */
391                         if (repeat_first_field) {
392                             if (pc->progressive_sequence) {
393                                 if (top_field_first)
394                                     s->repeat_pict = 4;
395                                 else
396                                     s->repeat_pict = 2;
397                             } else if (progressive_frame) {
398                                 s->repeat_pict = 1;
399                             }
400                         }
401
402                         /* the packet only represents half a frame
403                            XXX,FIXME maybe find a different solution */
404                         if(picture_structure != 3)
405                             s->repeat_pict = -1;
406                     }
407                     break;
408                 }
409             }
410             break;
411         case -1:
412             goto the_end;
413         default:
414             /* we stop parsing when we encounter a slice. It ensures
415                that this function takes a negligible amount of time */
416             if (start_code >= SLICE_MIN_START_CODE &&
417                 start_code <= SLICE_MAX_START_CODE)
418                 goto the_end;
419             break;
420         }
421     }
422  the_end: ;
423 }
424
425 static int mpegvideo_parse(AVCodecParserContext *s,
426                            AVCodecContext *avctx,
427                            uint8_t **poutbuf, int *poutbuf_size,
428                            const uint8_t *buf, int buf_size)
429 {
430     ParseContext1 *pc1 = s->priv_data;
431     ParseContext *pc= &pc1->pc;
432     int next;
433
434     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
435         next= buf_size;
436     }else{
437         next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
438
439         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
440             *poutbuf = NULL;
441             *poutbuf_size = 0;
442             return buf_size;
443         }
444
445     }
446     /* we have a full frame : we just parse the first few MPEG headers
447        to have the full timing information. The time take by this
448        function should be negligible for uncorrupted streams */
449     mpegvideo_extract_headers(s, avctx, buf, buf_size);
450 #if 0
451     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
452            s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
453 #endif
454
455     *poutbuf = (uint8_t *)buf;
456     *poutbuf_size = buf_size;
457     return next;
458 }
459
460 static int mpegvideo_split(AVCodecContext *avctx,
461                            const uint8_t *buf, int buf_size)
462 {
463     int i;
464     uint32_t state= -1;
465
466     for(i=0; i<buf_size; i++){
467         state= (state<<8) | buf[i];
468         if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
469             return i-3;
470     }
471     return 0;
472 }
473
474 void ff_parse_close(AVCodecParserContext *s)
475 {
476     ParseContext *pc = s->priv_data;
477
478     av_free(pc->buffer);
479 }
480
481 static void parse1_close(AVCodecParserContext *s)
482 {
483     ParseContext1 *pc1 = s->priv_data;
484
485     av_free(pc1->pc.buffer);
486     av_free(pc1->enc);
487 }
488
489 /*************************/
490
491 /* used by parser */
492 /* XXX: make it use less memory */
493 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
494                                   AVCodecContext *avctx,
495                                   const uint8_t *buf, int buf_size)
496 {
497     ParseContext1 *pc = s1->priv_data;
498     MpegEncContext *s = pc->enc;
499     GetBitContext gb1, *gb = &gb1;
500     int ret;
501
502     s->avctx = avctx;
503     s->current_picture_ptr = &s->current_picture;
504
505     if (avctx->extradata_size && pc->first_picture){
506         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
507         ret = ff_mpeg4_decode_picture_header(s, gb);
508     }
509
510     init_get_bits(gb, buf, 8 * buf_size);
511     ret = ff_mpeg4_decode_picture_header(s, gb);
512     if (s->width) {
513         avcodec_set_dimensions(avctx, s->width, s->height);
514     }
515     s1->pict_type= s->pict_type;
516     pc->first_picture = 0;
517     return ret;
518 }
519
520 static int mpeg4video_parse_init(AVCodecParserContext *s)
521 {
522     ParseContext1 *pc = s->priv_data;
523
524     pc->enc = av_mallocz(sizeof(MpegEncContext));
525     if (!pc->enc)
526         return -1;
527     pc->first_picture = 1;
528     return 0;
529 }
530
531 static int mpeg4video_parse(AVCodecParserContext *s,
532                            AVCodecContext *avctx,
533                            uint8_t **poutbuf, int *poutbuf_size,
534                            const uint8_t *buf, int buf_size)
535 {
536     ParseContext *pc = s->priv_data;
537     int next;
538
539     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
540         next= buf_size;
541     }else{
542         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
543
544         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
545             *poutbuf = NULL;
546             *poutbuf_size = 0;
547             return buf_size;
548         }
549     }
550     av_mpeg4_decode_header(s, avctx, buf, buf_size);
551
552     *poutbuf = (uint8_t *)buf;
553     *poutbuf_size = buf_size;
554     return next;
555 }
556
557 static int mpeg4video_split(AVCodecContext *avctx,
558                            const uint8_t *buf, int buf_size)
559 {
560     int i;
561     uint32_t state= -1;
562
563     for(i=0; i<buf_size; i++){
564         state= (state<<8) | buf[i];
565         if(state == 0x1B3 || state == 0x1B6)
566             return i-3;
567     }
568     return 0;
569 }
570
571 /*************************/
572
573 typedef struct MpegAudioParseContext {
574     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
575     uint8_t *inbuf_ptr;
576     int frame_size;
577     int free_format_frame_size;
578     int free_format_next_header;
579     uint32_t header;
580     int header_count;
581 } MpegAudioParseContext;
582
583 #define MPA_HEADER_SIZE 4
584
585 /* header + layer + bitrate + freq + lsf/mpeg25 */
586 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
587 #define SAME_HEADER_MASK \
588    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
589
590 static int mpegaudio_parse_init(AVCodecParserContext *s1)
591 {
592     MpegAudioParseContext *s = s1->priv_data;
593     s->inbuf_ptr = s->inbuf;
594     return 0;
595 }
596
597 static int mpegaudio_parse(AVCodecParserContext *s1,
598                            AVCodecContext *avctx,
599                            uint8_t **poutbuf, int *poutbuf_size,
600                            const uint8_t *buf, int buf_size)
601 {
602     MpegAudioParseContext *s = s1->priv_data;
603     int len, ret, sr;
604     uint32_t header;
605     const uint8_t *buf_ptr;
606
607     *poutbuf = NULL;
608     *poutbuf_size = 0;
609     buf_ptr = buf;
610     while (buf_size > 0) {
611         len = s->inbuf_ptr - s->inbuf;
612         if (s->frame_size == 0) {
613             /* special case for next header for first frame in free
614                format case (XXX: find a simpler method) */
615             if (s->free_format_next_header != 0) {
616                 s->inbuf[0] = s->free_format_next_header >> 24;
617                 s->inbuf[1] = s->free_format_next_header >> 16;
618                 s->inbuf[2] = s->free_format_next_header >> 8;
619                 s->inbuf[3] = s->free_format_next_header;
620                 s->inbuf_ptr = s->inbuf + 4;
621                 s->free_format_next_header = 0;
622                 goto got_header;
623             }
624             /* no header seen : find one. We need at least MPA_HEADER_SIZE
625                bytes to parse it */
626             len = MPA_HEADER_SIZE - len;
627             if (len > buf_size)
628                 len = buf_size;
629             if (len > 0) {
630                 memcpy(s->inbuf_ptr, buf_ptr, len);
631                 buf_ptr += len;
632                 buf_size -= len;
633                 s->inbuf_ptr += len;
634             }
635             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
636             got_header:
637                 sr= avctx->sample_rate;
638                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
639                     (s->inbuf[2] << 8) | s->inbuf[3];
640
641                 ret = mpa_decode_header(avctx, header);
642                 if (ret < 0) {
643                     s->header_count= -2;
644                     /* no sync found : move by one byte (inefficient, but simple!) */
645                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
646                     s->inbuf_ptr--;
647                     dprintf("skip %x\n", header);
648                     /* reset free format frame size to give a chance
649                        to get a new bitrate */
650                     s->free_format_frame_size = 0;
651                 } else {
652                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
653                         s->header_count= -3;
654                     s->header= header;
655                     s->header_count++;
656                     s->frame_size = ret;
657
658 #if 0
659                     /* free format: prepare to compute frame size */
660                     if (decode_header(s, header) == 1) {
661                         s->frame_size = -1;
662                     }
663 #endif
664                 }
665                 if(s->header_count <= 0)
666                     avctx->sample_rate= sr; //FIXME ugly
667             }
668         } else
669 #if 0
670         if (s->frame_size == -1) {
671             /* free format : find next sync to compute frame size */
672             len = MPA_MAX_CODED_FRAME_SIZE - len;
673             if (len > buf_size)
674                 len = buf_size;
675             if (len == 0) {
676                 /* frame too long: resync */
677                 s->frame_size = 0;
678                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
679                 s->inbuf_ptr--;
680             } else {
681                 uint8_t *p, *pend;
682                 uint32_t header1;
683                 int padding;
684
685                 memcpy(s->inbuf_ptr, buf_ptr, len);
686                 /* check for header */
687                 p = s->inbuf_ptr - 3;
688                 pend = s->inbuf_ptr + len - 4;
689                 while (p <= pend) {
690                     header = (p[0] << 24) | (p[1] << 16) |
691                         (p[2] << 8) | p[3];
692                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
693                         (s->inbuf[2] << 8) | s->inbuf[3];
694                     /* check with high probability that we have a
695                        valid header */
696                     if ((header & SAME_HEADER_MASK) ==
697                         (header1 & SAME_HEADER_MASK)) {
698                         /* header found: update pointers */
699                         len = (p + 4) - s->inbuf_ptr;
700                         buf_ptr += len;
701                         buf_size -= len;
702                         s->inbuf_ptr = p;
703                         /* compute frame size */
704                         s->free_format_next_header = header;
705                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
706                         padding = (header1 >> 9) & 1;
707                         if (s->layer == 1)
708                             s->free_format_frame_size -= padding * 4;
709                         else
710                             s->free_format_frame_size -= padding;
711                         dprintf("free frame size=%d padding=%d\n",
712                                 s->free_format_frame_size, padding);
713                         decode_header(s, header1);
714                         goto next_data;
715                     }
716                     p++;
717                 }
718                 /* not found: simply increase pointers */
719                 buf_ptr += len;
720                 s->inbuf_ptr += len;
721                 buf_size -= len;
722             }
723         } else
724 #endif
725         if (len < s->frame_size) {
726             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
727                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
728             len = s->frame_size - len;
729             if (len > buf_size)
730                 len = buf_size;
731             memcpy(s->inbuf_ptr, buf_ptr, len);
732             buf_ptr += len;
733             s->inbuf_ptr += len;
734             buf_size -= len;
735         }
736         //    next_data:
737         if (s->frame_size > 0 &&
738             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
739             if(s->header_count > 0){
740                 *poutbuf = s->inbuf;
741                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
742             }
743             s->inbuf_ptr = s->inbuf;
744             s->frame_size = 0;
745             break;
746         }
747     }
748     return buf_ptr - buf;
749 }
750
751 typedef struct AC3ParseContext {
752     uint8_t inbuf[4096]; /* input buffer */
753     uint8_t *inbuf_ptr;
754     int frame_size;
755 } AC3ParseContext;
756
757 #define AC3_HEADER_SIZE 7
758
759 static const int ac3_sample_rates[4] = {
760     48000, 44100, 32000, 0
761 };
762
763 static const int ac3_frame_sizes[64][3] = {
764     { 64,   69,   96   },
765     { 64,   70,   96   },
766     { 80,   87,   120  },
767     { 80,   88,   120  },
768     { 96,   104,  144  },
769     { 96,   105,  144  },
770     { 112,  121,  168  },
771     { 112,  122,  168  },
772     { 128,  139,  192  },
773     { 128,  140,  192  },
774     { 160,  174,  240  },
775     { 160,  175,  240  },
776     { 192,  208,  288  },
777     { 192,  209,  288  },
778     { 224,  243,  336  },
779     { 224,  244,  336  },
780     { 256,  278,  384  },
781     { 256,  279,  384  },
782     { 320,  348,  480  },
783     { 320,  349,  480  },
784     { 384,  417,  576  },
785     { 384,  418,  576  },
786     { 448,  487,  672  },
787     { 448,  488,  672  },
788     { 512,  557,  768  },
789     { 512,  558,  768  },
790     { 640,  696,  960  },
791     { 640,  697,  960  },
792     { 768,  835,  1152 },
793     { 768,  836,  1152 },
794     { 896,  975,  1344 },
795     { 896,  976,  1344 },
796     { 1024, 1114, 1536 },
797     { 1024, 1115, 1536 },
798     { 1152, 1253, 1728 },
799     { 1152, 1254, 1728 },
800     { 1280, 1393, 1920 },
801     { 1280, 1394, 1920 },
802 };
803
804 static const int ac3_bitrates[64] = {
805     32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
806     128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
807     384, 448, 448, 512, 512, 576, 576, 640, 640,
808 };
809
810 static const int ac3_channels[8] = {
811     2, 1, 2, 3, 3, 4, 4, 5
812 };
813
814 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
815                     int *bit_rate)
816 {
817     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
818     GetBitContext bits;
819
820     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
821
822     if(get_bits(&bits, 16) != 0x0b77)
823         return 0;
824
825     get_bits(&bits, 16);    /* crc */
826     fscod = get_bits(&bits, 2);
827     frmsizecod = get_bits(&bits, 6);
828
829     if(!ac3_sample_rates[fscod])
830         return 0;
831
832     bsid = get_bits(&bits, 5);
833     if(bsid > 8)
834         return 0;
835     get_bits(&bits, 3);     /* bsmod */
836     acmod = get_bits(&bits, 3);
837     if(acmod & 1 && acmod != 1)
838         get_bits(&bits, 2); /* cmixlev */
839     if(acmod & 4)
840         get_bits(&bits, 2); /* surmixlev */
841     if(acmod & 2)
842         get_bits(&bits, 2); /* dsurmod */
843     lfeon = get_bits(&bits, 1);
844
845     *sample_rate = ac3_sample_rates[fscod];
846     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
847     *channels = ac3_channels[acmod] + lfeon;
848
849     return ac3_frame_sizes[frmsizecod][fscod] * 2;
850 }
851
852 static int ac3_parse_init(AVCodecParserContext *s1)
853 {
854     AC3ParseContext *s = s1->priv_data;
855     s->inbuf_ptr = s->inbuf;
856     return 0;
857 }
858
859 static int ac3_parse(AVCodecParserContext *s1,
860                      AVCodecContext *avctx,
861                      uint8_t **poutbuf, int *poutbuf_size,
862                      const uint8_t *buf, int buf_size)
863 {
864     AC3ParseContext *s = s1->priv_data;
865     const uint8_t *buf_ptr;
866     int len, sample_rate, bit_rate, channels;
867
868     *poutbuf = NULL;
869     *poutbuf_size = 0;
870
871     buf_ptr = buf;
872     while (buf_size > 0) {
873         len = s->inbuf_ptr - s->inbuf;
874         if (s->frame_size == 0) {
875             /* no header seen : find one. We need at least 7 bytes to parse it */
876             len = AC3_HEADER_SIZE - len;
877             if (len > buf_size)
878                 len = buf_size;
879             memcpy(s->inbuf_ptr, buf_ptr, len);
880             buf_ptr += len;
881             s->inbuf_ptr += len;
882             buf_size -= len;
883             if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
884                 len = ac3_sync(s->inbuf, &channels, &sample_rate, &bit_rate);
885                 if (len == 0) {
886                     /* no sync found : move by one byte (inefficient, but simple!) */
887                     memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
888                     s->inbuf_ptr--;
889                 } else {
890                     s->frame_size = len;
891                     /* update codec info */
892                     avctx->sample_rate = sample_rate;
893                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
894                     if(avctx->channels!=1 && avctx->channels!=2){
895                         avctx->channels = channels;
896                     }
897                     avctx->bit_rate = bit_rate;
898                     avctx->frame_size = 6 * 256;
899                 }
900             }
901         } else if (len < s->frame_size) {
902             len = s->frame_size - len;
903             if (len > buf_size)
904                 len = buf_size;
905
906             memcpy(s->inbuf_ptr, buf_ptr, len);
907             buf_ptr += len;
908             s->inbuf_ptr += len;
909             buf_size -= len;
910         } else {
911             *poutbuf = s->inbuf;
912             *poutbuf_size = s->frame_size;
913             s->inbuf_ptr = s->inbuf;
914             s->frame_size = 0;
915             break;
916         }
917     }
918     return buf_ptr - buf;
919 }
920
921 AVCodecParser mpegvideo_parser = {
922     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
923     sizeof(ParseContext1),
924     NULL,
925     mpegvideo_parse,
926     parse1_close,
927     mpegvideo_split,
928 };
929
930 AVCodecParser mpeg4video_parser = {
931     { CODEC_ID_MPEG4 },
932     sizeof(ParseContext1),
933     mpeg4video_parse_init,
934     mpeg4video_parse,
935     parse1_close,
936     mpeg4video_split,
937 };
938
939 AVCodecParser mpegaudio_parser = {
940     { CODEC_ID_MP2, CODEC_ID_MP3 },
941     sizeof(MpegAudioParseContext),
942     mpegaudio_parse_init,
943     mpegaudio_parse,
944     NULL,
945 };
946
947 AVCodecParser ac3_parser = {
948     { CODEC_ID_AC3 },
949     sizeof(AC3ParseContext),
950     ac3_parse_init,
951     ac3_parse,
952     NULL,
953 };