2 * Audio and Video frame extraction
3 * Copyright (c) 2003 Fabrice Bellard.
4 * Copyright (c) 2003 Michael Niedermayer.
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include "mpegvideo.h"
22 #include "mpegaudio.h"
24 AVCodecParser *av_first_parser = NULL;
26 void av_register_codec_parser(AVCodecParser *parser)
28 parser->next = av_first_parser;
29 av_first_parser = parser;
32 AVCodecParserContext *av_parser_init(int codec_id)
34 AVCodecParserContext *s;
35 AVCodecParser *parser;
38 if(codec_id == CODEC_ID_NONE)
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)
51 s = av_mallocz(sizeof(AVCodecParserContext));
55 s->priv_data = av_mallocz(parser->priv_data_size);
60 if (parser->parser_init) {
61 ret = parser->parser_init(s);
63 av_free(s->priv_data);
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)
81 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
84 /* padding is always necessary even if EOF, so we add it here */
85 memset(dummy_buf, 0, sizeof(dummy_buf));
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;
95 /* fill first PTS/DTS */
96 if (s->fetch_timestamp){
100 s->cur_frame_pts[k] =
101 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
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 */
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;
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
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])
127 k = (k - 1) & (AV_PARSER_PTS_NB - 1);
130 s->last_pts = s->cur_frame_pts[k];
131 s->last_dts = s->cur_frame_dts[k];
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;
141 s->cur_offset += index;
145 void av_parser_close(AVCodecParserContext *s)
147 if (s->parser->parser_close)
148 s->parser->parser_close(s);
149 av_free(s->priv_data);
153 /*****************************************************/
155 //#define END_NOT_FOUND (-100)
157 #define PICTURE_START_CODE 0x00000100
158 #define SEQ_START_CODE 0x000001b3
159 #define EXT_START_CODE 0x000001b5
160 #define SLICE_MIN_START_CODE 0x00000101
161 #define SLICE_MAX_START_CODE 0x000001af
163 typedef struct ParseContext1{
165 /* XXX/FIXME PC1 vs. PC */
168 int progressive_sequence;
171 /* XXX: suppress that, needed by MPEG4 */
177 * combines the (truncated) bitstream to a complete frame
178 * @returns -1 if no complete frame could be created
180 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
184 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
185 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
189 /* copy overreaded bytes from last frame into buffer */
190 for(; pc->overread>0; pc->overread--){
191 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
194 /* flush remaining if EOF */
195 if(!*buf_size && next == END_NOT_FOUND){
199 pc->last_index= pc->index;
201 /* copy into buffer end return */
202 if(next == END_NOT_FOUND){
203 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
205 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
206 pc->index += *buf_size;
211 pc->overread_index= pc->index + next;
213 /* append to buffer */
215 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
217 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
222 /* store overread bytes */
223 for(;next < 0; next++){
224 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
230 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
231 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
238 static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
240 const uint8_t *buf_ptr;
241 unsigned int state=0xFFFFFFFF, v;
245 while (buf_ptr < buf_end) {
247 if (state == 0x000001) {
248 state = ((state << 8) | v) & 0xffffff;
252 state = ((state << 8) | v) & 0xffffff;
260 /* XXX: merge with libavcodec ? */
261 #define MPEG1_FRAME_RATE_BASE 1001
263 static const int frame_rate_tab[16] = {
275 // libmpeg3's "Unofficial economy rates": (10-13)
280 // random, just to avoid segfault !never encode these
285 //FIXME move into mpeg12.c
286 static void mpegvideo_extract_headers(AVCodecParserContext *s,
287 AVCodecContext *avctx,
288 const uint8_t *buf, int buf_size)
290 ParseContext1 *pc = s->priv_data;
291 const uint8_t *buf_end;
293 int frame_rate_index, ext_type, bytes_left;
294 int frame_rate_ext_n, frame_rate_ext_d;
295 int picture_structure, top_field_first, repeat_first_field, progressive_frame;
296 int horiz_size_ext, vert_size_ext, bit_rate_ext;
299 buf_end = buf + buf_size;
300 while (buf < buf_end) {
301 start_code = find_start_code(&buf, buf_end);
302 bytes_left = buf_end - buf;
304 case PICTURE_START_CODE:
305 if (bytes_left >= 2) {
306 s->pict_type = (buf[1] >> 3) & 7;
310 if (bytes_left >= 7) {
311 pc->width = (buf[0] << 4) | (buf[1] >> 4);
312 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
313 avcodec_set_dimensions(avctx, pc->width, pc->height);
314 frame_rate_index = buf[3] & 0xf;
315 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
316 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
317 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
318 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
323 if (bytes_left >= 1) {
324 ext_type = (buf[0] >> 4);
326 case 0x1: /* sequence extension */
327 if (bytes_left >= 6) {
328 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
329 vert_size_ext = (buf[2] >> 5) & 3;
330 bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
331 frame_rate_ext_n = (buf[5] >> 5) & 3;
332 frame_rate_ext_d = (buf[5] & 0x1f);
333 pc->progressive_sequence = buf[1] & (1 << 3);
334 avctx->has_b_frames= !(buf[5] >> 7);
336 pc->width |=(horiz_size_ext << 12);
337 pc->height |=( vert_size_ext << 12);
338 avctx->bit_rate += (bit_rate_ext << 18) * 400;
339 avcodec_set_dimensions(avctx, pc->width, pc->height);
340 avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
341 avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
342 avctx->codec_id = CODEC_ID_MPEG2VIDEO;
343 avctx->sub_id = 2; /* forces MPEG2 */
346 case 0x8: /* picture coding extension */
347 if (bytes_left >= 5) {
348 picture_structure = buf[2]&3;
349 top_field_first = buf[3] & (1 << 7);
350 repeat_first_field = buf[3] & (1 << 1);
351 progressive_frame = buf[4] & (1 << 7);
353 /* check if we must repeat the frame */
354 if (repeat_first_field) {
355 if (pc->progressive_sequence) {
360 } else if (progressive_frame) {
365 /* the packet only represents half a frame
366 XXX,FIXME maybe find a different solution */
367 if(picture_structure != 3)
377 /* we stop parsing when we encounter a slice. It ensures
378 that this function takes a negligible amount of time */
379 if (start_code >= SLICE_MIN_START_CODE &&
380 start_code <= SLICE_MAX_START_CODE)
388 static int mpegvideo_parse(AVCodecParserContext *s,
389 AVCodecContext *avctx,
390 uint8_t **poutbuf, int *poutbuf_size,
391 const uint8_t *buf, int buf_size)
393 ParseContext1 *pc1 = s->priv_data;
394 ParseContext *pc= &pc1->pc;
397 next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
399 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
404 /* we have a full frame : we just parse the first few MPEG headers
405 to have the full timing information. The time take by this
406 function should be negligible for uncorrupted streams */
407 mpegvideo_extract_headers(s, avctx, buf, buf_size);
409 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
410 s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
413 *poutbuf = (uint8_t *)buf;
414 *poutbuf_size = buf_size;
418 void ff_parse_close(AVCodecParserContext *s)
420 ParseContext *pc = s->priv_data;
425 static void parse1_close(AVCodecParserContext *s)
427 ParseContext1 *pc1 = s->priv_data;
429 av_free(pc1->pc.buffer);
433 /*************************/
436 /* XXX: make it use less memory */
437 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
438 AVCodecContext *avctx,
439 const uint8_t *buf, int buf_size)
441 ParseContext1 *pc = s1->priv_data;
442 MpegEncContext *s = pc->enc;
443 GetBitContext gb1, *gb = &gb1;
447 s->current_picture_ptr = &s->current_picture;
449 if (avctx->extradata_size && pc->first_picture){
450 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
451 ret = ff_mpeg4_decode_picture_header(s, gb);
454 init_get_bits(gb, buf, 8 * buf_size);
455 ret = ff_mpeg4_decode_picture_header(s, gb);
457 avcodec_set_dimensions(avctx, s->width, s->height);
459 pc->first_picture = 0;
463 static int mpeg4video_parse_init(AVCodecParserContext *s)
465 ParseContext1 *pc = s->priv_data;
467 pc->enc = av_mallocz(sizeof(MpegEncContext));
470 pc->first_picture = 1;
474 static int mpeg4video_parse(AVCodecParserContext *s,
475 AVCodecContext *avctx,
476 uint8_t **poutbuf, int *poutbuf_size,
477 const uint8_t *buf, int buf_size)
479 ParseContext *pc = s->priv_data;
482 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
484 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
489 av_mpeg4_decode_header(s, avctx, buf, buf_size);
491 *poutbuf = (uint8_t *)buf;
492 *poutbuf_size = buf_size;
496 /*************************/
498 typedef struct MpegAudioParseContext {
499 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
502 int free_format_frame_size;
503 int free_format_next_header;
506 } MpegAudioParseContext;
508 #define MPA_HEADER_SIZE 4
510 /* header + layer + bitrate + freq + lsf/mpeg25 */
511 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
512 #define SAME_HEADER_MASK \
513 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
515 static int mpegaudio_parse_init(AVCodecParserContext *s1)
517 MpegAudioParseContext *s = s1->priv_data;
518 s->inbuf_ptr = s->inbuf;
522 static int mpegaudio_parse(AVCodecParserContext *s1,
523 AVCodecContext *avctx,
524 uint8_t **poutbuf, int *poutbuf_size,
525 const uint8_t *buf, int buf_size)
527 MpegAudioParseContext *s = s1->priv_data;
530 const uint8_t *buf_ptr;
535 while (buf_size > 0) {
536 len = s->inbuf_ptr - s->inbuf;
537 if (s->frame_size == 0) {
538 /* special case for next header for first frame in free
539 format case (XXX: find a simpler method) */
540 if (s->free_format_next_header != 0) {
541 s->inbuf[0] = s->free_format_next_header >> 24;
542 s->inbuf[1] = s->free_format_next_header >> 16;
543 s->inbuf[2] = s->free_format_next_header >> 8;
544 s->inbuf[3] = s->free_format_next_header;
545 s->inbuf_ptr = s->inbuf + 4;
546 s->free_format_next_header = 0;
549 /* no header seen : find one. We need at least MPA_HEADER_SIZE
551 len = MPA_HEADER_SIZE - len;
555 memcpy(s->inbuf_ptr, buf_ptr, len);
560 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
562 sr= avctx->sample_rate;
563 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
564 (s->inbuf[2] << 8) | s->inbuf[3];
566 ret = mpa_decode_header(avctx, header);
569 /* no sync found : move by one byte (inefficient, but simple!) */
570 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
572 dprintf("skip %x\n", header);
573 /* reset free format frame size to give a chance
574 to get a new bitrate */
575 s->free_format_frame_size = 0;
577 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
584 /* free format: prepare to compute frame size */
585 if (decode_header(s, header) == 1) {
590 if(s->header_count <= 0)
591 avctx->sample_rate= sr; //FIXME ugly
595 if (s->frame_size == -1) {
596 /* free format : find next sync to compute frame size */
597 len = MPA_MAX_CODED_FRAME_SIZE - len;
601 /* frame too long: resync */
603 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
610 memcpy(s->inbuf_ptr, buf_ptr, len);
611 /* check for header */
612 p = s->inbuf_ptr - 3;
613 pend = s->inbuf_ptr + len - 4;
615 header = (p[0] << 24) | (p[1] << 16) |
617 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
618 (s->inbuf[2] << 8) | s->inbuf[3];
619 /* check with high probability that we have a
621 if ((header & SAME_HEADER_MASK) ==
622 (header1 & SAME_HEADER_MASK)) {
623 /* header found: update pointers */
624 len = (p + 4) - s->inbuf_ptr;
628 /* compute frame size */
629 s->free_format_next_header = header;
630 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
631 padding = (header1 >> 9) & 1;
633 s->free_format_frame_size -= padding * 4;
635 s->free_format_frame_size -= padding;
636 dprintf("free frame size=%d padding=%d\n",
637 s->free_format_frame_size, padding);
638 decode_header(s, header1);
643 /* not found: simply increase pointers */
650 if (len < s->frame_size) {
651 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
652 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
653 len = s->frame_size - len;
656 memcpy(s->inbuf_ptr, buf_ptr, len);
662 if (s->frame_size > 0 &&
663 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
664 if(s->header_count > 0){
666 *poutbuf_size = s->inbuf_ptr - s->inbuf;
668 s->inbuf_ptr = s->inbuf;
673 return buf_ptr - buf;
677 extern int a52_syncinfo (const uint8_t * buf, int * flags,
678 int * sample_rate, int * bit_rate);
680 typedef struct AC3ParseContext {
681 uint8_t inbuf[4096]; /* input buffer */
687 #define AC3_HEADER_SIZE 7
690 static int ac3_parse_init(AVCodecParserContext *s1)
692 AC3ParseContext *s = s1->priv_data;
693 s->inbuf_ptr = s->inbuf;
697 static int ac3_parse(AVCodecParserContext *s1,
698 AVCodecContext *avctx,
699 uint8_t **poutbuf, int *poutbuf_size,
700 const uint8_t *buf, int buf_size)
702 AC3ParseContext *s = s1->priv_data;
703 const uint8_t *buf_ptr;
704 int len, sample_rate, bit_rate;
705 static const int ac3_channels[8] = {
706 2, 1, 2, 3, 3, 4, 4, 5
713 while (buf_size > 0) {
714 len = s->inbuf_ptr - s->inbuf;
715 if (s->frame_size == 0) {
716 /* no header seen : find one. We need at least 7 bytes to parse it */
717 len = AC3_HEADER_SIZE - len;
720 memcpy(s->inbuf_ptr, buf_ptr, len);
724 if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
725 len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
727 /* no sync found : move by one byte (inefficient, but simple!) */
728 memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
732 /* update codec info */
733 avctx->sample_rate = sample_rate;
734 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
735 if(avctx->channels!=1 && avctx->channels!=2){
736 avctx->channels = ac3_channels[s->flags & 7];
737 if (s->flags & A52_LFE)
740 avctx->bit_rate = bit_rate;
741 avctx->frame_size = 6 * 256;
744 } else if (len < s->frame_size) {
745 len = s->frame_size - len;
749 memcpy(s->inbuf_ptr, buf_ptr, len);
755 *poutbuf_size = s->frame_size;
756 s->inbuf_ptr = s->inbuf;
761 return buf_ptr - buf;
765 AVCodecParser mpegvideo_parser = {
766 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
767 sizeof(ParseContext1),
773 AVCodecParser mpeg4video_parser = {
775 sizeof(ParseContext1),
776 mpeg4video_parse_init,
781 AVCodecParser mpegaudio_parser = {
782 { CODEC_ID_MP2, CODEC_ID_MP3 },
783 sizeof(MpegAudioParseContext),
784 mpegaudio_parse_init,
790 AVCodecParser ac3_parser = {
792 sizeof(AC3ParseContext),