CAVS decoder by (Stefan Gehrer stefan.gehrer gmx.de)
[libav.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 cavsvideo_parse(AVCodecParserContext *s,
537 AVCodecContext *avctx,
538 uint8_t **poutbuf, int *poutbuf_size,
539 const uint8_t *buf, int buf_size)
540 {
541 ParseContext *pc = s->priv_data;
542 int next;
543
544 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
545 next= buf_size;
546 }else{
547 next= ff_cavs_find_frame_end(pc, buf, buf_size);
548
549 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
550 *poutbuf = NULL;
551 *poutbuf_size = 0;
552 return buf_size;
553 }
554 }
555 *poutbuf = (uint8_t *)buf;
556 *poutbuf_size = buf_size;
557 return next;
558 }
559
560 static int mpeg4video_split(AVCodecContext *avctx,
561 const uint8_t *buf, int buf_size)
562 {
563 int i;
564 uint32_t state= -1;
565
566 for(i=0; i<buf_size; i++){
567 state= (state<<8) | buf[i];
568 if(state == 0x1B3 || state == 0x1B6)
569 return i-3;
570 }
571 return 0;
572 }
573
574 /*************************/
575
576 typedef struct MpegAudioParseContext {
577 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
578 uint8_t *inbuf_ptr;
579 int frame_size;
580 int free_format_frame_size;
581 int free_format_next_header;
582 uint32_t header;
583 int header_count;
584 } MpegAudioParseContext;
585
586 #define MPA_HEADER_SIZE 4
587
588 /* header + layer + bitrate + freq + lsf/mpeg25 */
589 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
590 #define SAME_HEADER_MASK \
591 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
592
593 static int mpegaudio_parse_init(AVCodecParserContext *s1)
594 {
595 MpegAudioParseContext *s = s1->priv_data;
596 s->inbuf_ptr = s->inbuf;
597 return 0;
598 }
599
600 static int mpegaudio_parse(AVCodecParserContext *s1,
601 AVCodecContext *avctx,
602 uint8_t **poutbuf, int *poutbuf_size,
603 const uint8_t *buf, int buf_size)
604 {
605 MpegAudioParseContext *s = s1->priv_data;
606 int len, ret, sr;
607 uint32_t header;
608 const uint8_t *buf_ptr;
609
610 *poutbuf = NULL;
611 *poutbuf_size = 0;
612 buf_ptr = buf;
613 while (buf_size > 0) {
614 len = s->inbuf_ptr - s->inbuf;
615 if (s->frame_size == 0) {
616 /* special case for next header for first frame in free
617 format case (XXX: find a simpler method) */
618 if (s->free_format_next_header != 0) {
619 s->inbuf[0] = s->free_format_next_header >> 24;
620 s->inbuf[1] = s->free_format_next_header >> 16;
621 s->inbuf[2] = s->free_format_next_header >> 8;
622 s->inbuf[3] = s->free_format_next_header;
623 s->inbuf_ptr = s->inbuf + 4;
624 s->free_format_next_header = 0;
625 goto got_header;
626 }
627 /* no header seen : find one. We need at least MPA_HEADER_SIZE
628 bytes to parse it */
629 len = MPA_HEADER_SIZE - len;
630 if (len > buf_size)
631 len = buf_size;
632 if (len > 0) {
633 memcpy(s->inbuf_ptr, buf_ptr, len);
634 buf_ptr += len;
635 buf_size -= len;
636 s->inbuf_ptr += len;
637 }
638 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
639 got_header:
640 sr= avctx->sample_rate;
641 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
642 (s->inbuf[2] << 8) | s->inbuf[3];
643
644 ret = mpa_decode_header(avctx, header);
645 if (ret < 0) {
646 s->header_count= -2;
647 /* no sync found : move by one byte (inefficient, but simple!) */
648 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
649 s->inbuf_ptr--;
650 dprintf("skip %x\n", header);
651 /* reset free format frame size to give a chance
652 to get a new bitrate */
653 s->free_format_frame_size = 0;
654 } else {
655 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
656 s->header_count= -3;
657 s->header= header;
658 s->header_count++;
659 s->frame_size = ret;
660
661 #if 0
662 /* free format: prepare to compute frame size */
663 if (decode_header(s, header) == 1) {
664 s->frame_size = -1;
665 }
666 #endif
667 }
668 if(s->header_count <= 0)
669 avctx->sample_rate= sr; //FIXME ugly
670 }
671 } else
672 #if 0
673 if (s->frame_size == -1) {
674 /* free format : find next sync to compute frame size */
675 len = MPA_MAX_CODED_FRAME_SIZE - len;
676 if (len > buf_size)
677 len = buf_size;
678 if (len == 0) {
679 /* frame too long: resync */
680 s->frame_size = 0;
681 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
682 s->inbuf_ptr--;
683 } else {
684 uint8_t *p, *pend;
685 uint32_t header1;
686 int padding;
687
688 memcpy(s->inbuf_ptr, buf_ptr, len);
689 /* check for header */
690 p = s->inbuf_ptr - 3;
691 pend = s->inbuf_ptr + len - 4;
692 while (p <= pend) {
693 header = (p[0] << 24) | (p[1] << 16) |
694 (p[2] << 8) | p[3];
695 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
696 (s->inbuf[2] << 8) | s->inbuf[3];
697 /* check with high probability that we have a
698 valid header */
699 if ((header & SAME_HEADER_MASK) ==
700 (header1 & SAME_HEADER_MASK)) {
701 /* header found: update pointers */
702 len = (p + 4) - s->inbuf_ptr;
703 buf_ptr += len;
704 buf_size -= len;
705 s->inbuf_ptr = p;
706 /* compute frame size */
707 s->free_format_next_header = header;
708 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
709 padding = (header1 >> 9) & 1;
710 if (s->layer == 1)
711 s->free_format_frame_size -= padding * 4;
712 else
713 s->free_format_frame_size -= padding;
714 dprintf("free frame size=%d padding=%d\n",
715 s->free_format_frame_size, padding);
716 decode_header(s, header1);
717 goto next_data;
718 }
719 p++;
720 }
721 /* not found: simply increase pointers */
722 buf_ptr += len;
723 s->inbuf_ptr += len;
724 buf_size -= len;
725 }
726 } else
727 #endif
728 if (len < s->frame_size) {
729 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
730 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
731 len = s->frame_size - len;
732 if (len > buf_size)
733 len = buf_size;
734 memcpy(s->inbuf_ptr, buf_ptr, len);
735 buf_ptr += len;
736 s->inbuf_ptr += len;
737 buf_size -= len;
738 }
739 // next_data:
740 if (s->frame_size > 0 &&
741 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
742 if(s->header_count > 0){
743 *poutbuf = s->inbuf;
744 *poutbuf_size = s->inbuf_ptr - s->inbuf;
745 }
746 s->inbuf_ptr = s->inbuf;
747 s->frame_size = 0;
748 break;
749 }
750 }
751 return buf_ptr - buf;
752 }
753
754 /* also used for ADTS AAC */
755 typedef struct AC3ParseContext {
756 uint8_t *inbuf_ptr;
757 int frame_size;
758 int header_size;
759 int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
760 int *bit_rate, int *samples);
761 uint8_t inbuf[8192]; /* input buffer */
762 } AC3ParseContext;
763
764 #define AC3_HEADER_SIZE 7
765 #define AAC_HEADER_SIZE 7
766
767 static const int ac3_sample_rates[4] = {
768 48000, 44100, 32000, 0
769 };
770
771 static const int ac3_frame_sizes[64][3] = {
772 { 64, 69, 96 },
773 { 64, 70, 96 },
774 { 80, 87, 120 },
775 { 80, 88, 120 },
776 { 96, 104, 144 },
777 { 96, 105, 144 },
778 { 112, 121, 168 },
779 { 112, 122, 168 },
780 { 128, 139, 192 },
781 { 128, 140, 192 },
782 { 160, 174, 240 },
783 { 160, 175, 240 },
784 { 192, 208, 288 },
785 { 192, 209, 288 },
786 { 224, 243, 336 },
787 { 224, 244, 336 },
788 { 256, 278, 384 },
789 { 256, 279, 384 },
790 { 320, 348, 480 },
791 { 320, 349, 480 },
792 { 384, 417, 576 },
793 { 384, 418, 576 },
794 { 448, 487, 672 },
795 { 448, 488, 672 },
796 { 512, 557, 768 },
797 { 512, 558, 768 },
798 { 640, 696, 960 },
799 { 640, 697, 960 },
800 { 768, 835, 1152 },
801 { 768, 836, 1152 },
802 { 896, 975, 1344 },
803 { 896, 976, 1344 },
804 { 1024, 1114, 1536 },
805 { 1024, 1115, 1536 },
806 { 1152, 1253, 1728 },
807 { 1152, 1254, 1728 },
808 { 1280, 1393, 1920 },
809 { 1280, 1394, 1920 },
810 };
811
812 static const int ac3_bitrates[64] = {
813 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
814 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
815 384, 448, 448, 512, 512, 576, 576, 640, 640,
816 };
817
818 static const int ac3_channels[8] = {
819 2, 1, 2, 3, 3, 4, 4, 5
820 };
821
822 static int aac_sample_rates[16] = {
823 96000, 88200, 64000, 48000, 44100, 32000,
824 24000, 22050, 16000, 12000, 11025, 8000, 7350
825 };
826
827 static int aac_channels[8] = {
828 0, 1, 2, 3, 4, 5, 6, 8
829 };
830
831 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
832 int *bit_rate, int *samples)
833 {
834 unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
835 GetBitContext bits;
836
837 init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
838
839 if(get_bits(&bits, 16) != 0x0b77)
840 return 0;
841
842 skip_bits(&bits, 16); /* crc */
843 fscod = get_bits(&bits, 2);
844 frmsizecod = get_bits(&bits, 6);
845
846 if(!ac3_sample_rates[fscod])
847 return 0;
848
849 bsid = get_bits(&bits, 5);
850 if(bsid > 8)
851 return 0;
852 skip_bits(&bits, 3); /* bsmod */
853 acmod = get_bits(&bits, 3);
854 if(acmod & 1 && acmod != 1)
855 skip_bits(&bits, 2); /* cmixlev */
856 if(acmod & 4)
857 skip_bits(&bits, 2); /* surmixlev */
858 if(acmod & 2)
859 skip_bits(&bits, 2); /* dsurmod */
860 lfeon = get_bits1(&bits);
861
862 *sample_rate = ac3_sample_rates[fscod];
863 *bit_rate = ac3_bitrates[frmsizecod] * 1000;
864 *channels = ac3_channels[acmod] + lfeon;
865 *samples = 6 * 256;
866
867 return ac3_frame_sizes[frmsizecod][fscod] * 2;
868 }
869
870 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
871 int *bit_rate, int *samples)
872 {
873 GetBitContext bits;
874 int size, rdb, ch, sr;
875
876 init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
877
878 if(get_bits(&bits, 12) != 0xfff)
879 return 0;
880
881 skip_bits1(&bits); /* id */
882 skip_bits(&bits, 2); /* layer */
883 skip_bits1(&bits); /* protection_absent */
884 skip_bits(&bits, 2); /* profile_objecttype */
885 sr = get_bits(&bits, 4); /* sample_frequency_index */
886 if(!aac_sample_rates[sr])
887 return 0;
888 skip_bits1(&bits); /* private_bit */
889 ch = get_bits(&bits, 3); /* channel_configuration */
890 if(!aac_channels[ch])
891 return 0;
892 skip_bits1(&bits); /* original/copy */
893 skip_bits1(&bits); /* home */
894
895 /* adts_variable_header */
896 skip_bits1(&bits); /* copyright_identification_bit */
897 skip_bits1(&bits); /* copyright_identification_start */
898 size = get_bits(&bits, 13); /* aac_frame_length */
899 skip_bits(&bits, 11); /* adts_buffer_fullness */
900 rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
901
902 *channels = aac_channels[ch];
903 *sample_rate = aac_sample_rates[sr];
904 *samples = (rdb + 1) * 1024;
905 *bit_rate = size * 8 * *sample_rate / *samples;
906
907 return size;
908 }
909
910 static int ac3_parse_init(AVCodecParserContext *s1)
911 {
912 AC3ParseContext *s = s1->priv_data;
913 s->inbuf_ptr = s->inbuf;
914 s->header_size = AC3_HEADER_SIZE;
915 s->sync = ac3_sync;
916 return 0;
917 }
918
919 static int aac_parse_init(AVCodecParserContext *s1)
920 {
921 AC3ParseContext *s = s1->priv_data;
922 s->inbuf_ptr = s->inbuf;
923 s->header_size = AAC_HEADER_SIZE;
924 s->sync = aac_sync;
925 return 0;
926 }
927
928 /* also used for ADTS AAC */
929 static int ac3_parse(AVCodecParserContext *s1,
930 AVCodecContext *avctx,
931 uint8_t **poutbuf, int *poutbuf_size,
932 const uint8_t *buf, int buf_size)
933 {
934 AC3ParseContext *s = s1->priv_data;
935 const uint8_t *buf_ptr;
936 int len, sample_rate, bit_rate, channels, samples;
937
938 *poutbuf = NULL;
939 *poutbuf_size = 0;
940
941 buf_ptr = buf;
942 while (buf_size > 0) {
943 len = s->inbuf_ptr - s->inbuf;
944 if (s->frame_size == 0) {
945 /* no header seen : find one. We need at least s->header_size
946 bytes to parse it */
947 len = FFMIN(s->header_size - len, buf_size);
948
949 memcpy(s->inbuf_ptr, buf_ptr, len);
950 buf_ptr += len;
951 s->inbuf_ptr += len;
952 buf_size -= len;
953 if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
954 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
955 &samples);
956 if (len == 0) {
957 /* no sync found : move by one byte (inefficient, but simple!) */
958 memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
959 s->inbuf_ptr--;
960 } else {
961 s->frame_size = len;
962 /* update codec info */
963 avctx->sample_rate = sample_rate;
964 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
965 if(avctx->codec_id == CODEC_ID_AC3){
966 if(avctx->channels!=1 && avctx->channels!=2){
967 avctx->channels = channels;
968 }
969 } else {
970 avctx->channels = channels;
971 }
972 avctx->bit_rate = bit_rate;
973 avctx->frame_size = samples;
974 }
975 }
976 } else {
977 len = FFMIN(s->frame_size - len, buf_size);
978
979 memcpy(s->inbuf_ptr, buf_ptr, len);
980 buf_ptr += len;
981 s->inbuf_ptr += len;
982 buf_size -= len;
983
984 if(s->inbuf_ptr - s->inbuf == s->frame_size){
985 *poutbuf = s->inbuf;
986 *poutbuf_size = s->frame_size;
987 s->inbuf_ptr = s->inbuf;
988 s->frame_size = 0;
989 break;
990 }
991 }
992 }
993 return buf_ptr - buf;
994 }
995
996 AVCodecParser mpegvideo_parser = {
997 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
998 sizeof(ParseContext1),
999 NULL,
1000 mpegvideo_parse,
1001 parse1_close,
1002 mpegvideo_split,
1003 };
1004
1005 AVCodecParser mpeg4video_parser = {
1006 { CODEC_ID_MPEG4 },
1007 sizeof(ParseContext1),
1008 mpeg4video_parse_init,
1009 mpeg4video_parse,
1010 parse1_close,
1011 mpeg4video_split,
1012 };
1013
1014 AVCodecParser cavsvideo_parser = {
1015 { CODEC_ID_CAVS },
1016 sizeof(ParseContext1),
1017 NULL,
1018 cavsvideo_parse,
1019 parse1_close,
1020 mpeg4video_split,
1021 };
1022
1023 AVCodecParser mpegaudio_parser = {
1024 { CODEC_ID_MP2, CODEC_ID_MP3 },
1025 sizeof(MpegAudioParseContext),
1026 mpegaudio_parse_init,
1027 mpegaudio_parse,
1028 NULL,
1029 };
1030
1031 AVCodecParser ac3_parser = {
1032 { CODEC_ID_AC3 },
1033 sizeof(AC3ParseContext),
1034 ac3_parse_init,
1035 ac3_parse,
1036 NULL,
1037 };
1038
1039 AVCodecParser aac_parser = {
1040 { CODEC_ID_AAC },
1041 sizeof(AC3ParseContext),
1042 aac_parse_init,
1043 ac3_parse,
1044 NULL,
1045 };