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;
147 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
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){
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);
163 *poutbuf_size= buf_size;
164 if(avctx->extradata){
165 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
166 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
167 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
168 int size= buf_size + avctx->extradata_size;
170 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
172 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
173 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
181 void av_parser_close(AVCodecParserContext *s)
183 if (s->parser->parser_close)
184 s->parser->parser_close(s);
185 av_free(s->priv_data);
189 /*****************************************************/
191 //#define END_NOT_FOUND (-100)
193 #define PICTURE_START_CODE 0x00000100
194 #define SEQ_START_CODE 0x000001b3
195 #define EXT_START_CODE 0x000001b5
196 #define SLICE_MIN_START_CODE 0x00000101
197 #define SLICE_MAX_START_CODE 0x000001af
199 typedef struct ParseContext1{
201 /* XXX/FIXME PC1 vs. PC */
204 int progressive_sequence;
207 /* XXX: suppress that, needed by MPEG4 */
213 * combines the (truncated) bitstream to a complete frame
214 * @returns -1 if no complete frame could be created
216 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
220 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
221 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
225 /* copy overreaded bytes from last frame into buffer */
226 for(; pc->overread>0; pc->overread--){
227 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
230 /* flush remaining if EOF */
231 if(!*buf_size && next == END_NOT_FOUND){
235 pc->last_index= pc->index;
237 /* copy into buffer end return */
238 if(next == END_NOT_FOUND){
239 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
241 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
242 pc->index += *buf_size;
247 pc->overread_index= pc->index + next;
249 /* append to buffer */
251 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
253 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
258 /* store overread bytes */
259 for(;next < 0; next++){
260 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
266 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
267 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
274 static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
276 const uint8_t *buf_ptr;
277 unsigned int state=0xFFFFFFFF, v;
281 while (buf_ptr < buf_end) {
283 if (state == 0x000001) {
284 state = ((state << 8) | v) & 0xffffff;
288 state = ((state << 8) | v) & 0xffffff;
296 /* XXX: merge with libavcodec ? */
297 #define MPEG1_FRAME_RATE_BASE 1001
299 static const int frame_rate_tab[16] = {
311 // libmpeg3's "Unofficial economy rates": (10-13)
316 // random, just to avoid segfault !never encode these
321 //FIXME move into mpeg12.c
322 static void mpegvideo_extract_headers(AVCodecParserContext *s,
323 AVCodecContext *avctx,
324 const uint8_t *buf, int buf_size)
326 ParseContext1 *pc = s->priv_data;
327 const uint8_t *buf_end;
329 int frame_rate_index, ext_type, bytes_left;
330 int frame_rate_ext_n, frame_rate_ext_d;
331 int picture_structure, top_field_first, repeat_first_field, progressive_frame;
332 int horiz_size_ext, vert_size_ext, bit_rate_ext;
333 //FIXME replace the crap with get_bits()
335 buf_end = buf + buf_size;
336 while (buf < buf_end) {
337 start_code = find_start_code(&buf, buf_end);
338 bytes_left = buf_end - buf;
340 case PICTURE_START_CODE:
341 if (bytes_left >= 2) {
342 s->pict_type = (buf[1] >> 3) & 7;
346 if (bytes_left >= 7) {
347 pc->width = (buf[0] << 4) | (buf[1] >> 4);
348 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
349 avcodec_set_dimensions(avctx, pc->width, pc->height);
350 frame_rate_index = buf[3] & 0xf;
351 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
352 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
353 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
354 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
359 if (bytes_left >= 1) {
360 ext_type = (buf[0] >> 4);
362 case 0x1: /* sequence extension */
363 if (bytes_left >= 6) {
364 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
365 vert_size_ext = (buf[2] >> 5) & 3;
366 bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
367 frame_rate_ext_n = (buf[5] >> 5) & 3;
368 frame_rate_ext_d = (buf[5] & 0x1f);
369 pc->progressive_sequence = buf[1] & (1 << 3);
370 avctx->has_b_frames= !(buf[5] >> 7);
372 pc->width |=(horiz_size_ext << 12);
373 pc->height |=( vert_size_ext << 12);
374 avctx->bit_rate += (bit_rate_ext << 18) * 400;
375 avcodec_set_dimensions(avctx, pc->width, pc->height);
376 avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
377 avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
378 avctx->codec_id = CODEC_ID_MPEG2VIDEO;
379 avctx->sub_id = 2; /* forces MPEG2 */
382 case 0x8: /* picture coding extension */
383 if (bytes_left >= 5) {
384 picture_structure = buf[2]&3;
385 top_field_first = buf[3] & (1 << 7);
386 repeat_first_field = buf[3] & (1 << 1);
387 progressive_frame = buf[4] & (1 << 7);
389 /* check if we must repeat the frame */
390 if (repeat_first_field) {
391 if (pc->progressive_sequence) {
396 } else if (progressive_frame) {
401 /* the packet only represents half a frame
402 XXX,FIXME maybe find a different solution */
403 if(picture_structure != 3)
413 /* we stop parsing when we encounter a slice. It ensures
414 that this function takes a negligible amount of time */
415 if (start_code >= SLICE_MIN_START_CODE &&
416 start_code <= SLICE_MAX_START_CODE)
424 static int mpegvideo_parse(AVCodecParserContext *s,
425 AVCodecContext *avctx,
426 uint8_t **poutbuf, int *poutbuf_size,
427 const uint8_t *buf, int buf_size)
429 ParseContext1 *pc1 = s->priv_data;
430 ParseContext *pc= &pc1->pc;
433 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
436 next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
438 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
445 /* we have a full frame : we just parse the first few MPEG headers
446 to have the full timing information. The time take by this
447 function should be negligible for uncorrupted streams */
448 mpegvideo_extract_headers(s, avctx, buf, buf_size);
450 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
451 s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
454 *poutbuf = (uint8_t *)buf;
455 *poutbuf_size = buf_size;
459 static int mpegvideo_split(AVCodecContext *avctx,
460 const uint8_t *buf, int buf_size)
465 for(i=0; i<buf_size; i++){
466 state= (state<<8) | buf[i];
467 if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
473 void ff_parse_close(AVCodecParserContext *s)
475 ParseContext *pc = s->priv_data;
480 static void parse1_close(AVCodecParserContext *s)
482 ParseContext1 *pc1 = s->priv_data;
484 av_free(pc1->pc.buffer);
488 /*************************/
491 /* XXX: make it use less memory */
492 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
493 AVCodecContext *avctx,
494 const uint8_t *buf, int buf_size)
496 ParseContext1 *pc = s1->priv_data;
497 MpegEncContext *s = pc->enc;
498 GetBitContext gb1, *gb = &gb1;
502 s->current_picture_ptr = &s->current_picture;
504 if (avctx->extradata_size && pc->first_picture){
505 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
506 ret = ff_mpeg4_decode_picture_header(s, gb);
509 init_get_bits(gb, buf, 8 * buf_size);
510 ret = ff_mpeg4_decode_picture_header(s, gb);
512 avcodec_set_dimensions(avctx, s->width, s->height);
514 s1->pict_type= s->pict_type;
515 pc->first_picture = 0;
519 static int mpeg4video_parse_init(AVCodecParserContext *s)
521 ParseContext1 *pc = s->priv_data;
523 pc->enc = av_mallocz(sizeof(MpegEncContext));
526 pc->first_picture = 1;
530 static int mpeg4video_parse(AVCodecParserContext *s,
531 AVCodecContext *avctx,
532 uint8_t **poutbuf, int *poutbuf_size,
533 const uint8_t *buf, int buf_size)
535 ParseContext *pc = s->priv_data;
538 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
541 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
543 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
549 av_mpeg4_decode_header(s, avctx, buf, buf_size);
551 *poutbuf = (uint8_t *)buf;
552 *poutbuf_size = buf_size;
556 static int mpeg4video_split(AVCodecContext *avctx,
557 const uint8_t *buf, int buf_size)
562 for(i=0; i<buf_size; i++){
563 state= (state<<8) | buf[i];
564 if(state == 0x1B3 || state == 0x1B6)
570 /*************************/
572 typedef struct MpegAudioParseContext {
573 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
576 int free_format_frame_size;
577 int free_format_next_header;
580 } MpegAudioParseContext;
582 #define MPA_HEADER_SIZE 4
584 /* header + layer + bitrate + freq + lsf/mpeg25 */
585 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
586 #define SAME_HEADER_MASK \
587 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
589 static int mpegaudio_parse_init(AVCodecParserContext *s1)
591 MpegAudioParseContext *s = s1->priv_data;
592 s->inbuf_ptr = s->inbuf;
596 static int mpegaudio_parse(AVCodecParserContext *s1,
597 AVCodecContext *avctx,
598 uint8_t **poutbuf, int *poutbuf_size,
599 const uint8_t *buf, int buf_size)
601 MpegAudioParseContext *s = s1->priv_data;
604 const uint8_t *buf_ptr;
609 while (buf_size > 0) {
610 len = s->inbuf_ptr - s->inbuf;
611 if (s->frame_size == 0) {
612 /* special case for next header for first frame in free
613 format case (XXX: find a simpler method) */
614 if (s->free_format_next_header != 0) {
615 s->inbuf[0] = s->free_format_next_header >> 24;
616 s->inbuf[1] = s->free_format_next_header >> 16;
617 s->inbuf[2] = s->free_format_next_header >> 8;
618 s->inbuf[3] = s->free_format_next_header;
619 s->inbuf_ptr = s->inbuf + 4;
620 s->free_format_next_header = 0;
623 /* no header seen : find one. We need at least MPA_HEADER_SIZE
625 len = MPA_HEADER_SIZE - len;
629 memcpy(s->inbuf_ptr, buf_ptr, len);
634 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
636 sr= avctx->sample_rate;
637 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
638 (s->inbuf[2] << 8) | s->inbuf[3];
640 ret = mpa_decode_header(avctx, header);
643 /* no sync found : move by one byte (inefficient, but simple!) */
644 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
646 dprintf("skip %x\n", header);
647 /* reset free format frame size to give a chance
648 to get a new bitrate */
649 s->free_format_frame_size = 0;
651 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
658 /* free format: prepare to compute frame size */
659 if (decode_header(s, header) == 1) {
664 if(s->header_count <= 0)
665 avctx->sample_rate= sr; //FIXME ugly
669 if (s->frame_size == -1) {
670 /* free format : find next sync to compute frame size */
671 len = MPA_MAX_CODED_FRAME_SIZE - len;
675 /* frame too long: resync */
677 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
684 memcpy(s->inbuf_ptr, buf_ptr, len);
685 /* check for header */
686 p = s->inbuf_ptr - 3;
687 pend = s->inbuf_ptr + len - 4;
689 header = (p[0] << 24) | (p[1] << 16) |
691 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
692 (s->inbuf[2] << 8) | s->inbuf[3];
693 /* check with high probability that we have a
695 if ((header & SAME_HEADER_MASK) ==
696 (header1 & SAME_HEADER_MASK)) {
697 /* header found: update pointers */
698 len = (p + 4) - s->inbuf_ptr;
702 /* compute frame size */
703 s->free_format_next_header = header;
704 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
705 padding = (header1 >> 9) & 1;
707 s->free_format_frame_size -= padding * 4;
709 s->free_format_frame_size -= padding;
710 dprintf("free frame size=%d padding=%d\n",
711 s->free_format_frame_size, padding);
712 decode_header(s, header1);
717 /* not found: simply increase pointers */
724 if (len < s->frame_size) {
725 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
726 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
727 len = s->frame_size - len;
730 memcpy(s->inbuf_ptr, buf_ptr, len);
736 if (s->frame_size > 0 &&
737 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
738 if(s->header_count > 0){
740 *poutbuf_size = s->inbuf_ptr - s->inbuf;
742 s->inbuf_ptr = s->inbuf;
747 return buf_ptr - buf;
752 extern int ff_a52_syncinfo (AVCodecContext * avctx, const uint8_t * buf,
753 int * flags, int * sample_rate, int * bit_rate);
755 extern int a52_syncinfo (const uint8_t * buf, int * flags,
756 int * sample_rate, int * bit_rate);
759 typedef struct AC3ParseContext {
760 uint8_t inbuf[4096]; /* input buffer */
766 #define AC3_HEADER_SIZE 7
769 static int ac3_parse_init(AVCodecParserContext *s1)
771 AC3ParseContext *s = s1->priv_data;
772 s->inbuf_ptr = s->inbuf;
776 static int ac3_parse(AVCodecParserContext *s1,
777 AVCodecContext *avctx,
778 uint8_t **poutbuf, int *poutbuf_size,
779 const uint8_t *buf, int buf_size)
781 AC3ParseContext *s = s1->priv_data;
782 const uint8_t *buf_ptr;
783 int len, sample_rate, bit_rate;
784 static const int ac3_channels[8] = {
785 2, 1, 2, 3, 3, 4, 4, 5
792 while (buf_size > 0) {
793 len = s->inbuf_ptr - s->inbuf;
794 if (s->frame_size == 0) {
795 /* no header seen : find one. We need at least 7 bytes to parse it */
796 len = AC3_HEADER_SIZE - len;
799 memcpy(s->inbuf_ptr, buf_ptr, len);
803 if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
805 len = ff_a52_syncinfo(avctx, s->inbuf, &s->flags, &sample_rate, &bit_rate);
807 len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
810 /* no sync found : move by one byte (inefficient, but simple!) */
811 memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
815 /* update codec info */
816 avctx->sample_rate = sample_rate;
817 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
818 if(avctx->channels!=1 && avctx->channels!=2){
819 avctx->channels = ac3_channels[s->flags & 7];
820 if (s->flags & A52_LFE)
823 avctx->bit_rate = bit_rate;
824 avctx->frame_size = 6 * 256;
827 } else if (len < s->frame_size) {
828 len = s->frame_size - len;
832 memcpy(s->inbuf_ptr, buf_ptr, len);
838 *poutbuf_size = s->frame_size;
839 s->inbuf_ptr = s->inbuf;
844 return buf_ptr - buf;
848 AVCodecParser mpegvideo_parser = {
849 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
850 sizeof(ParseContext1),
857 AVCodecParser mpeg4video_parser = {
859 sizeof(ParseContext1),
860 mpeg4video_parse_init,
866 AVCodecParser mpegaudio_parser = {
867 { CODEC_ID_MP2, CODEC_ID_MP3 },
868 sizeof(MpegAudioParseContext),
869 mpegaudio_parse_init,
875 AVCodecParser ac3_parser = {
877 sizeof(AC3ParseContext),