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