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