Originally committed as revision 6914 to svn://svn.ffmpeg.org/ffmpeg/trunktags/v0.5
@@ -3312,6 +3312,169 @@ AVCodec mpeg_xvmc_decoder = { | |||
#endif | |||
#ifdef CONFIG_MPEGVIDEO_PARSER | |||
static void mpegvideo_extract_headers(AVCodecParserContext *s, | |||
AVCodecContext *avctx, | |||
const uint8_t *buf, int buf_size) | |||
{ | |||
ParseContext1 *pc = s->priv_data; | |||
const uint8_t *buf_end; | |||
uint32_t start_code; | |||
int frame_rate_index, ext_type, bytes_left; | |||
int frame_rate_ext_n, frame_rate_ext_d; | |||
int picture_structure, top_field_first, repeat_first_field, progressive_frame; | |||
int horiz_size_ext, vert_size_ext, bit_rate_ext; | |||
//FIXME replace the crap with get_bits() | |||
s->repeat_pict = 0; | |||
buf_end = buf + buf_size; | |||
while (buf < buf_end) { | |||
start_code= -1; | |||
buf= ff_find_start_code(buf, buf_end, &start_code); | |||
bytes_left = buf_end - buf; | |||
switch(start_code) { | |||
case PICTURE_START_CODE: | |||
if (bytes_left >= 2) { | |||
s->pict_type = (buf[1] >> 3) & 7; | |||
} | |||
break; | |||
case SEQ_START_CODE: | |||
if (bytes_left >= 7) { | |||
pc->width = (buf[0] << 4) | (buf[1] >> 4); | |||
pc->height = ((buf[1] & 0x0f) << 8) | buf[2]; | |||
avcodec_set_dimensions(avctx, pc->width, pc->height); | |||
frame_rate_index = buf[3] & 0xf; | |||
pc->frame_rate.den = avctx->time_base.den = ff_frame_rate_tab[frame_rate_index].num; | |||
pc->frame_rate.num = avctx->time_base.num = ff_frame_rate_tab[frame_rate_index].den; | |||
avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400; | |||
avctx->codec_id = CODEC_ID_MPEG1VIDEO; | |||
avctx->sub_id = 1; | |||
} | |||
break; | |||
case EXT_START_CODE: | |||
if (bytes_left >= 1) { | |||
ext_type = (buf[0] >> 4); | |||
switch(ext_type) { | |||
case 0x1: /* sequence extension */ | |||
if (bytes_left >= 6) { | |||
horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7); | |||
vert_size_ext = (buf[2] >> 5) & 3; | |||
bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1); | |||
frame_rate_ext_n = (buf[5] >> 5) & 3; | |||
frame_rate_ext_d = (buf[5] & 0x1f); | |||
pc->progressive_sequence = buf[1] & (1 << 3); | |||
avctx->has_b_frames= !(buf[5] >> 7); | |||
pc->width |=(horiz_size_ext << 12); | |||
pc->height |=( vert_size_ext << 12); | |||
avctx->bit_rate += (bit_rate_ext << 18) * 400; | |||
avcodec_set_dimensions(avctx, pc->width, pc->height); | |||
avctx->time_base.den = pc->frame_rate.den * (frame_rate_ext_n + 1); | |||
avctx->time_base.num = pc->frame_rate.num * (frame_rate_ext_d + 1); | |||
avctx->codec_id = CODEC_ID_MPEG2VIDEO; | |||
avctx->sub_id = 2; /* forces MPEG2 */ | |||
} | |||
break; | |||
case 0x8: /* picture coding extension */ | |||
if (bytes_left >= 5) { | |||
picture_structure = buf[2]&3; | |||
top_field_first = buf[3] & (1 << 7); | |||
repeat_first_field = buf[3] & (1 << 1); | |||
progressive_frame = buf[4] & (1 << 7); | |||
/* check if we must repeat the frame */ | |||
if (repeat_first_field) { | |||
if (pc->progressive_sequence) { | |||
if (top_field_first) | |||
s->repeat_pict = 4; | |||
else | |||
s->repeat_pict = 2; | |||
} else if (progressive_frame) { | |||
s->repeat_pict = 1; | |||
} | |||
} | |||
/* the packet only represents half a frame | |||
XXX,FIXME maybe find a different solution */ | |||
if(picture_structure != 3) | |||
s->repeat_pict = -1; | |||
} | |||
break; | |||
} | |||
} | |||
break; | |||
case -1: | |||
goto the_end; | |||
default: | |||
/* we stop parsing when we encounter a slice. It ensures | |||
that this function takes a negligible amount of time */ | |||
if (start_code >= SLICE_MIN_START_CODE && | |||
start_code <= SLICE_MAX_START_CODE) | |||
goto the_end; | |||
break; | |||
} | |||
} | |||
the_end: ; | |||
} | |||
static int mpegvideo_parse(AVCodecParserContext *s, | |||
AVCodecContext *avctx, | |||
uint8_t **poutbuf, int *poutbuf_size, | |||
const uint8_t *buf, int buf_size) | |||
{ | |||
ParseContext1 *pc1 = s->priv_data; | |||
ParseContext *pc= &pc1->pc; | |||
int next; | |||
if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){ | |||
next= buf_size; | |||
}else{ | |||
next= ff_mpeg1_find_frame_end(pc, buf, buf_size); | |||
if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |||
*poutbuf = NULL; | |||
*poutbuf_size = 0; | |||
return buf_size; | |||
} | |||
} | |||
/* we have a full frame : we just parse the first few MPEG headers | |||
to have the full timing information. The time take by this | |||
function should be negligible for uncorrupted streams */ | |||
mpegvideo_extract_headers(s, avctx, buf, buf_size); | |||
#if 0 | |||
printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n", | |||
s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict); | |||
#endif | |||
*poutbuf = (uint8_t *)buf; | |||
*poutbuf_size = buf_size; | |||
return next; | |||
} | |||
static int mpegvideo_split(AVCodecContext *avctx, | |||
const uint8_t *buf, int buf_size) | |||
{ | |||
int i; | |||
uint32_t state= -1; | |||
for(i=0; i<buf_size; i++){ | |||
state= (state<<8) | buf[i]; | |||
if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100) | |||
return i-3; | |||
} | |||
return 0; | |||
} | |||
AVCodecParser mpegvideo_parser = { | |||
{ CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO }, | |||
sizeof(ParseContext1), | |||
NULL, | |||
mpegvideo_parse, | |||
ff_parse1_close, | |||
mpegvideo_split, | |||
}; | |||
#endif /* !CONFIG_MPEGVIDEO_PARSER */ | |||
/* this is ugly i know, but the alternative is too make | |||
hundreds of vars global and prefix them with ff_mpeg1_ | |||
which is far uglier. */ | |||
@@ -31,6 +31,7 @@ | |||
#include "dsputil.h" | |||
#include "bitstream.h" | |||
#include "ratecontrol.h" | |||
#include "parser.h" | |||
#define FRAME_SKIPPED 100 ///< return value for header parsers if frame is not coded | |||
@@ -142,17 +143,6 @@ typedef struct Picture{ | |||
int b_frame_score; /* */ | |||
} Picture; | |||
typedef struct ParseContext{ | |||
uint8_t *buffer; | |||
int index; | |||
int last_index; | |||
unsigned int buffer_size; | |||
uint32_t state; ///< contains the last few bytes in MSB order | |||
int frame_start_found; | |||
int overread; ///< the number of bytes which where irreversibly read from the next frame | |||
int overread_index; ///< the index into ParseContext.buffer of the overreaded bytes | |||
} ParseContext; | |||
struct MpegEncContext; | |||
/** | |||
@@ -717,9 +707,6 @@ void ff_init_scantable(uint8_t *, ScanTable *st, const uint8_t *src_scantable); | |||
void ff_draw_horiz_band(MpegEncContext *s, int y, int h); | |||
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, | |||
int src_x, int src_y, int w, int h); | |||
#define END_NOT_FOUND -100 | |||
int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size); | |||
void ff_parse_close(AVCodecParserContext *s); | |||
void ff_mpeg_flush(AVCodecContext *avctx); | |||
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict); | |||
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix); | |||
@@ -789,7 +776,6 @@ void mpeg1_encode_mb(MpegEncContext *s, | |||
void ff_mpeg1_encode_init(MpegEncContext *s); | |||
void ff_mpeg1_encode_slice_header(MpegEncContext *s); | |||
void ff_mpeg1_clean_buffers(MpegEncContext *s); | |||
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size); | |||
/** RLTable. */ | |||
@@ -896,7 +882,6 @@ void ff_mpeg4_init_direct_mv(MpegEncContext *s); | |||
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my); | |||
int ff_h263_round_chroma(int x); | |||
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code); | |||
int ff_mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size); | |||
/* rv10.c */ | |||
@@ -936,8 +921,5 @@ void mjpeg_picture_header(MpegEncContext *s); | |||
void mjpeg_picture_trailer(MpegEncContext *s); | |||
void ff_mjpeg_stuffing(PutBitContext * pbc); | |||
/* cavs.c */ | |||
int ff_cavs_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size); | |||
#endif /* AVCODEC_MPEGVIDEO_H */ | |||
@@ -22,6 +22,7 @@ | |||
#include "avcodec.h" | |||
#include "mpegvideo.h" | |||
#include "mpegaudio.h" | |||
#include "parser.h" | |||
AVCodecParser *av_first_parser = NULL; | |||
@@ -213,27 +214,6 @@ void av_parser_close(AVCodecParserContext *s) | |||
/*****************************************************/ | |||
//#define END_NOT_FOUND (-100) | |||
#define PICTURE_START_CODE 0x00000100 | |||
#define SEQ_START_CODE 0x000001b3 | |||
#define EXT_START_CODE 0x000001b5 | |||
#define SLICE_MIN_START_CODE 0x00000101 | |||
#define SLICE_MAX_START_CODE 0x000001af | |||
typedef struct ParseContext1{ | |||
ParseContext pc; | |||
/* XXX/FIXME PC1 vs. PC */ | |||
/* MPEG2 specific */ | |||
AVRational frame_rate; | |||
int progressive_sequence; | |||
int width, height; | |||
/* XXX: suppress that, needed by MPEG4 */ | |||
MpegEncContext *enc; | |||
int first_picture; | |||
} ParseContext1; | |||
/** | |||
* combines the (truncated) bitstream to a complete frame | |||
* @returns -1 if no complete frame could be created | |||
@@ -296,164 +276,6 @@ int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size) | |||
return 0; | |||
} | |||
#ifdef CONFIG_MPEGVIDEO_PARSER | |||
extern const AVRational ff_frame_rate_tab[]; | |||
//FIXME move into mpeg12.c | |||
static void mpegvideo_extract_headers(AVCodecParserContext *s, | |||
AVCodecContext *avctx, | |||
const uint8_t *buf, int buf_size) | |||
{ | |||
ParseContext1 *pc = s->priv_data; | |||
const uint8_t *buf_end; | |||
uint32_t start_code; | |||
int frame_rate_index, ext_type, bytes_left; | |||
int frame_rate_ext_n, frame_rate_ext_d; | |||
int picture_structure, top_field_first, repeat_first_field, progressive_frame; | |||
int horiz_size_ext, vert_size_ext, bit_rate_ext; | |||
//FIXME replace the crap with get_bits() | |||
s->repeat_pict = 0; | |||
buf_end = buf + buf_size; | |||
while (buf < buf_end) { | |||
start_code= -1; | |||
buf= ff_find_start_code(buf, buf_end, &start_code); | |||
bytes_left = buf_end - buf; | |||
switch(start_code) { | |||
case PICTURE_START_CODE: | |||
if (bytes_left >= 2) { | |||
s->pict_type = (buf[1] >> 3) & 7; | |||
} | |||
break; | |||
case SEQ_START_CODE: | |||
if (bytes_left >= 7) { | |||
pc->width = (buf[0] << 4) | (buf[1] >> 4); | |||
pc->height = ((buf[1] & 0x0f) << 8) | buf[2]; | |||
avcodec_set_dimensions(avctx, pc->width, pc->height); | |||
frame_rate_index = buf[3] & 0xf; | |||
pc->frame_rate.den = avctx->time_base.den = ff_frame_rate_tab[frame_rate_index].num; | |||
pc->frame_rate.num = avctx->time_base.num = ff_frame_rate_tab[frame_rate_index].den; | |||
avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400; | |||
avctx->codec_id = CODEC_ID_MPEG1VIDEO; | |||
avctx->sub_id = 1; | |||
} | |||
break; | |||
case EXT_START_CODE: | |||
if (bytes_left >= 1) { | |||
ext_type = (buf[0] >> 4); | |||
switch(ext_type) { | |||
case 0x1: /* sequence extension */ | |||
if (bytes_left >= 6) { | |||
horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7); | |||
vert_size_ext = (buf[2] >> 5) & 3; | |||
bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1); | |||
frame_rate_ext_n = (buf[5] >> 5) & 3; | |||
frame_rate_ext_d = (buf[5] & 0x1f); | |||
pc->progressive_sequence = buf[1] & (1 << 3); | |||
avctx->has_b_frames= !(buf[5] >> 7); | |||
pc->width |=(horiz_size_ext << 12); | |||
pc->height |=( vert_size_ext << 12); | |||
avctx->bit_rate += (bit_rate_ext << 18) * 400; | |||
avcodec_set_dimensions(avctx, pc->width, pc->height); | |||
avctx->time_base.den = pc->frame_rate.den * (frame_rate_ext_n + 1); | |||
avctx->time_base.num = pc->frame_rate.num * (frame_rate_ext_d + 1); | |||
avctx->codec_id = CODEC_ID_MPEG2VIDEO; | |||
avctx->sub_id = 2; /* forces MPEG2 */ | |||
} | |||
break; | |||
case 0x8: /* picture coding extension */ | |||
if (bytes_left >= 5) { | |||
picture_structure = buf[2]&3; | |||
top_field_first = buf[3] & (1 << 7); | |||
repeat_first_field = buf[3] & (1 << 1); | |||
progressive_frame = buf[4] & (1 << 7); | |||
/* check if we must repeat the frame */ | |||
if (repeat_first_field) { | |||
if (pc->progressive_sequence) { | |||
if (top_field_first) | |||
s->repeat_pict = 4; | |||
else | |||
s->repeat_pict = 2; | |||
} else if (progressive_frame) { | |||
s->repeat_pict = 1; | |||
} | |||
} | |||
/* the packet only represents half a frame | |||
XXX,FIXME maybe find a different solution */ | |||
if(picture_structure != 3) | |||
s->repeat_pict = -1; | |||
} | |||
break; | |||
} | |||
} | |||
break; | |||
case -1: | |||
goto the_end; | |||
default: | |||
/* we stop parsing when we encounter a slice. It ensures | |||
that this function takes a negligible amount of time */ | |||
if (start_code >= SLICE_MIN_START_CODE && | |||
start_code <= SLICE_MAX_START_CODE) | |||
goto the_end; | |||
break; | |||
} | |||
} | |||
the_end: ; | |||
} | |||
static int mpegvideo_parse(AVCodecParserContext *s, | |||
AVCodecContext *avctx, | |||
uint8_t **poutbuf, int *poutbuf_size, | |||
const uint8_t *buf, int buf_size) | |||
{ | |||
ParseContext1 *pc1 = s->priv_data; | |||
ParseContext *pc= &pc1->pc; | |||
int next; | |||
if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){ | |||
next= buf_size; | |||
}else{ | |||
next= ff_mpeg1_find_frame_end(pc, buf, buf_size); | |||
if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |||
*poutbuf = NULL; | |||
*poutbuf_size = 0; | |||
return buf_size; | |||
} | |||
} | |||
/* we have a full frame : we just parse the first few MPEG headers | |||
to have the full timing information. The time take by this | |||
function should be negligible for uncorrupted streams */ | |||
mpegvideo_extract_headers(s, avctx, buf, buf_size); | |||
#if 0 | |||
printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n", | |||
s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict); | |||
#endif | |||
*poutbuf = (uint8_t *)buf; | |||
*poutbuf_size = buf_size; | |||
return next; | |||
} | |||
static int mpegvideo_split(AVCodecContext *avctx, | |||
const uint8_t *buf, int buf_size) | |||
{ | |||
int i; | |||
uint32_t state= -1; | |||
for(i=0; i<buf_size; i++){ | |||
state= (state<<8) | buf[i]; | |||
if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100) | |||
return i-3; | |||
} | |||
return 0; | |||
} | |||
#endif /* CONFIG_MPEGVIDEO_PARSER */ | |||
void ff_parse_close(AVCodecParserContext *s) | |||
{ | |||
ParseContext *pc = s->priv_data; | |||
@@ -461,7 +283,7 @@ void ff_parse_close(AVCodecParserContext *s) | |||
av_free(pc->buffer); | |||
} | |||
static void parse1_close(AVCodecParserContext *s) | |||
void ff_parse1_close(AVCodecParserContext *s) | |||
{ | |||
ParseContext1 *pc1 = s->priv_data; | |||
@@ -1025,23 +847,13 @@ static int ac3_parse(AVCodecParserContext *s1, | |||
} | |||
#endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */ | |||
#ifdef CONFIG_MPEGVIDEO_PARSER | |||
AVCodecParser mpegvideo_parser = { | |||
{ CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO }, | |||
sizeof(ParseContext1), | |||
NULL, | |||
mpegvideo_parse, | |||
parse1_close, | |||
mpegvideo_split, | |||
}; | |||
#endif | |||
#ifdef CONFIG_MPEG4VIDEO_PARSER | |||
AVCodecParser mpeg4video_parser = { | |||
{ CODEC_ID_MPEG4 }, | |||
sizeof(ParseContext1), | |||
mpeg4video_parse_init, | |||
mpeg4video_parse, | |||
parse1_close, | |||
ff_parse1_close, | |||
mpeg4video_split, | |||
}; | |||
#endif | |||
@@ -1051,7 +863,7 @@ AVCodecParser cavsvideo_parser = { | |||
sizeof(ParseContext1), | |||
NULL, | |||
cavsvideo_parse, | |||
parse1_close, | |||
ff_parse1_close, | |||
mpeg4video_split, | |||
}; | |||
#endif | |||
@@ -0,0 +1,64 @@ | |||
/* | |||
* AVCodecParser prototypes and definitions | |||
* Copyright (c) 2003 Fabrice Bellard. | |||
* Copyright (c) 2003 Michael Niedermayer. | |||
* | |||
* This file is part of FFmpeg. | |||
* | |||
* FFmpeg is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 2.1 of the License, or (at your option) any later version. | |||
* | |||
* FFmpeg is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with FFmpeg; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |||
*/ | |||
#ifndef FFMPEG_PARSER_H | |||
#define FFMPEG_PARSER_H | |||
typedef struct ParseContext{ | |||
uint8_t *buffer; | |||
int index; | |||
int last_index; | |||
unsigned int buffer_size; | |||
uint32_t state; ///< contains the last few bytes in MSB order | |||
int frame_start_found; | |||
int overread; ///< the number of bytes which where irreversibly read from the next frame | |||
int overread_index; ///< the index into ParseContext.buffer of the overreaded bytes | |||
} ParseContext; | |||
struct MpegEncContext; | |||
typedef struct ParseContext1{ | |||
ParseContext pc; | |||
/* XXX/FIXME PC1 vs. PC */ | |||
/* MPEG2 specific */ | |||
AVRational frame_rate; | |||
int progressive_sequence; | |||
int width, height; | |||
/* XXX: suppress that, needed by MPEG4 */ | |||
struct MpegEncContext *enc; | |||
int first_picture; | |||
} ParseContext1; | |||
#define END_NOT_FOUND (-100) | |||
int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size); | |||
void ff_parse_close(AVCodecParserContext *s); | |||
void ff_parse1_close(AVCodecParserContext *s); | |||
/* h263dec.c */ | |||
int ff_mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size); | |||
/* cavs.c */ | |||
int ff_cavs_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size); | |||
#endif /* !FFMPEG_PARSER_H */ |