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