virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

* introducing new public interface in imgconvert.c

Browse Source 
+ avcodec_get_pix_fmt
         converts textual representation of pixel format into
	 the actual id. Complements avcodec_get_pix_fmt_name.
       + avpicture_layout
         serializes given picture into a flat array.
	 Complements avpicture_fill.

   * adding a new option -pix_fmt to the ffmpeg, in order to control
     pixel format for the codecs that do support it, like rawvideo,
     for example.

   * reducing complexity of the rawvideo codec by splitting it in two
     and making it more reliable via hooking up to the avpicture_layout.
     Plus adding new FourCC as described here: http://www.fourcc.org

   * A tiny fix for avienc.c that makes avih and video strf consistent
     regarding codec FourCC.

Originally committed as revision 1842 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Roman Shaposhnik 2003-05-07 19:01:45 +00:00
parent 4e80eb21af
commit 631670888d
7 changed files with 140 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ffmpeg.c
View File

@ -89,6 +89,7 @@ static AVImageFormat *image_format;
static int frame_width = 160;
static int frame_height = 128;
static float frame_aspect_ratio = 0;
static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
static int frame_topBand = 0;
static int frame_bottomBand = 0;
static int frame_leftBand = 0;
@ -1706,6 +1707,11 @@ static void opt_frame_size(const char *arg)
}
}
static void opt_frame_pix_fmt(const char *arg)
{
frame_pix_fmt = avcodec_get_pix_fmt(arg);
}
static void opt_frame_aspect_ratio(const char *arg)
{
int x = 0, y = 0;
@ -2032,6 +2038,7 @@ static void opt_input_file(const char *filename)
ap->width = frame_width;
ap->height = frame_height;
ap->image_format = image_format;
ap->pix_fmt = frame_pix_fmt;
/* open the input file with generic libav function */
err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
@ -2061,6 +2068,7 @@ static void opt_input_file(const char *filename)
frame_height = enc->height;
frame_width = enc->width;
frame_aspect_ratio = enc->aspect_ratio;
frame_pix_fmt = enc->pix_fmt;
rfps = ic->streams[i]->r_frame_rate;
rfps_base = ic->streams[i]->r_frame_rate_base;
enc->workaround_bugs = workaround_bugs;
@ -2218,6 +2226,7 @@ static void opt_output_file(const char *filename)
video_enc->width = frame_width;
video_enc->height = frame_height;
video_enc->aspect_ratio = frame_aspect_ratio;
video_enc->pix_fmt = frame_pix_fmt;
if (!intra_only)
video_enc->gop_size = gop_size;
@ -2722,6 +2731,7 @@ const OptionDef options[] = {
{ "re", OPT_BOOL|OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate" },
{ "s", HAS_ARG, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
{ "aspect", HAS_ARG, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
{ "pix_fmt", HAS_ARG | OPT_EXPERT, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
{ "croptop", HAS_ARG, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
{ "cropbottom", HAS_ARG, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
{ "cropleft", HAS_ARG, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },

3
libavcodec/allcodecs.c
View File

@ -65,7 +65,8 @@ void avcodec_register_all(void)
register_avcodec(&mjpeg_encoder);
register_avcodec(&huffyuv_encoder);
#endif /* CONFIG_ENCODERS */
register_avcodec(&rawvideo_codec);
register_avcodec(&rawvideo_encoder);
register_avcodec(&rawvideo_decoder);
/* decoders */
#ifdef CONFIG_DECODERS

6
libavcodec/avcodec.h
View File

@ -1244,7 +1244,8 @@ PCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
#undef PCM_CODEC
/* dummy raw video codec */
extern AVCodec rawvideo_codec;
extern AVCodec rawvideo_encoder;
extern AVCodec rawvideo_decoder;
/* the following codecs use external GPL libs */
extern AVCodec ac3_decoder;
@ -1281,9 +1282,12 @@ void img_resample_close(ImgReSampleContext *s);
int avpicture_fill(AVPicture *picture, uint8_t *ptr,
int pix_fmt, int width, int height);
int avpicture_layout(AVPicture* src, int pix_fmt, int width, int height,
unsigned char *dest, int dest_size);
int avpicture_get_size(int pix_fmt, int width, int height);
void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift);
const char *avcodec_get_pix_fmt_name(int pix_fmt);
enum PixelFormat avcodec_get_pix_fmt(const char* name);
#define FF_LOSS_RESOLUTION 0x0001 /* loss due to resolution change */
#define FF_LOSS_DEPTH 0x0002 /* loss due to color depth change */

51
libavcodec/imgconvert.c
View File

@ -224,6 +224,16 @@ const char *avcodec_get_pix_fmt_name(int pix_fmt)
return pix_fmt_info[pix_fmt].name;
}
enum PixelFormat avcodec_get_pix_fmt(const char* name)
{
int i;
for (i=0; i < PIX_FMT_NB; i++)
if (!strcmp(pix_fmt_info[i].name, name))
break;
return i;
}
/* Picture field are filled with 'ptr' addresses. Also return size */
int avpicture_fill(AVPicture *picture, uint8_t *ptr,
int pix_fmt, int width, int height)
@ -303,6 +313,47 @@ int avpicture_fill(AVPicture *picture, uint8_t *ptr,
}
}
int avpicture_layout(AVPicture* src, int pix_fmt, int width, int height,
unsigned char *dest, int dest_size)
{
PixFmtInfo* pf = &pix_fmt_info[pix_fmt];
int i, j, w, h, data_planes;
unsigned char* s;
int size = avpicture_get_size(pix_fmt, width, height);
if (size > dest_size)
return -1;
if (pf->pixel_type == FF_PIXEL_PACKED) {
if (pix_fmt == PIX_FMT_YUV422 || pix_fmt == PIX_FMT_RGB565 ||
pix_fmt == PIX_FMT_RGB555)
w = width * 2;
else
w = width * (pf->depth * pf->nb_channels / 8);
data_planes = 1;
h = height;
} else {
data_planes = pf->nb_channels;
w = width;
h = height;
}
for (i=0; i<data_planes; i++) {
if (i == 1) {
w = width >> pf->x_chroma_shift;
h = height >> pf->y_chroma_shift;
}
s = src->data[i];
for(j=0; j<h; j++) {
memcpy(dest, s, w);
dest += w;
s += src->linesize[i];
}
}
return size;
}
int avpicture_get_size(int pix_fmt, int width, int height)
{
AVPicture dummy_pict;

171
libavcodec/raw.c
View File

@ -24,6 +24,12 @@
#include "avcodec.h"
typedef struct RawVideoContext {
unsigned char * buffer; /* block of memory for holding one frame */
unsigned char * p; /* current position in buffer */
int length; /* number of bytes in buffer */
AVFrame pic; ///< AVCodecContext.coded_frame
} RawVideoContext;
typedef struct PixleFormatTag {
int pix_fmt;
@ -31,8 +37,19 @@ typedef struct PixleFormatTag {
} PixelFormatTag;
const PixelFormatTag pixelFormatTags[] = {
{ PIX_FMT_YUV422, MKTAG('Y', '4', '2', '2') },
{ PIX_FMT_YUV420P, MKTAG('I', '4', '2', '0') },
{ PIX_FMT_YUV420P, MKTAG('I', '4', '2', '0') }, /* Planar formats */
{ PIX_FMT_YUV420P, MKTAG('I', 'Y', 'U', 'V') },
{ PIX_FMT_YUV410P, MKTAG('Y', 'U', 'V', '9') },
{ PIX_FMT_YUV411P, MKTAG('Y', '4', '1', 'B') },
{ PIX_FMT_YUV422P, MKTAG('Y', '4', '2', 'B') },
{ PIX_FMT_GRAY8, MKTAG('Y', '8', '0', '0') },
{ PIX_FMT_GRAY8, MKTAG(' ', ' ', 'Y', '8') },
{ PIX_FMT_YUV422, MKTAG('Y', '4', '2', '2') }, /* Packed formats */
{ PIX_FMT_YUV422, MKTAG('U', 'Y', 'V', 'Y') },
{ PIX_FMT_GRAY8, MKTAG('G', 'R', 'E', 'Y') },
{ -1, 0 },
};
@ -47,35 +64,37 @@ static int findPixelFormat(unsigned int fourcc)
return PIX_FMT_YUV420P;
}
static unsigned int findFourCC(int fmt)
{
const PixelFormatTag * tags = pixelFormatTags;
while (tags->pix_fmt >= 0) {
if (tags->pix_fmt == fmt)
return tags->fourcc;
tags++;
}
return 0;
}
typedef struct RawVideoContext {
unsigned char * buffer; /* block of memory for holding one frame */
unsigned char * p; /* current position in buffer */
int length; /* number of bytes in buffer */
AVFrame pic; ///< AVCodecContext.coded_frame
} RawVideoContext;
/* RAW Decoder Implementation */
static int raw_init(AVCodecContext *avctx)
static int raw_init_decoder(AVCodecContext *avctx)
{
RawVideoContext *context = avctx->priv_data;
if (avctx->codec_tag) {
avctx->pix_fmt = findPixelFormat(avctx->codec_tag);
}
context->length = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height);
context->buffer = av_malloc(context->length);
context->p = context->buffer;
context->pic.pict_type= FF_I_TYPE;
context->pic.key_frame= 1;
if (avctx->codec_tag)
avctx->pix_fmt = findPixelFormat(avctx->codec_tag);
context->length = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height);
context->buffer = av_malloc(context->length);
context->p = context->buffer;
context->pic.pict_type = FF_I_TYPE;
context->pic.key_frame = 1;
avctx->coded_frame= &context->pic;
if (! context->buffer) {
if (!context->buffer)
return -1;
}
return 0;
}
@ -110,102 +129,48 @@ static int raw_decode(AVCodecContext *avctx,
return bytesNeeded;
}
static int raw_close(AVCodecContext *avctx)
static int raw_close_decoder(AVCodecContext *avctx)
{
RawVideoContext *context = avctx->priv_data;
av_freep(&context->buffer);
return 0;
}
av_freep(& context->buffer);
/* RAW Encoder Implementation */
static int raw_init_encoder(AVCodecContext *avctx)
{
avctx->coded_frame = (AVPicture*)avctx->priv_data;
avctx->coded_frame->pict_type = FF_I_TYPE;
avctx->coded_frame->key_frame = 1;
avctx->codec_tag = findFourCC(avctx->pix_fmt);
return 0;
}
static int raw_encode(AVCodecContext *avctx,
unsigned char *frame, int buf_size, void *data)
{
AVPicture * picture = data;
unsigned char *src;
unsigned char *dest = frame;
int i, j;
int w = avctx->width;
int h = avctx->height;
int size = avpicture_get_size(avctx->pix_fmt, w, h);
if (size > buf_size) {
return -1;
}
switch(avctx->pix_fmt) {
case PIX_FMT_YUV420P:
for(i=0;i<3;i++) {
if (i == 1) {
w >>= 1;
h >>= 1;
}
src = picture->data[i];
for(j=0;j<h;j++) {
memcpy(dest, src, w);
dest += w;
src += picture->linesize[i];
}
}
break;
case PIX_FMT_YUV422P:
for(i=0;i<3;i++) {
if (i == 1) {
w >>= 1;
}
src = picture->data[i];
for(j=0;j<h;j++) {
memcpy(dest, src, w);
dest += w;
src += picture->linesize[i];
}
}
break;
case PIX_FMT_YUV444P:
for(i=0;i<3;i++) {
src = picture->data[i];
for(j=0;j<h;j++) {
memcpy(dest, src, w);
dest += w;
src += picture->linesize[i];
}
}
break;
case PIX_FMT_YUV422:
src = picture->data[0];
for(j=0;j<h;j++) {
memcpy(dest, src, w * 2);
dest += w * 2;
src += picture->linesize[0];
}
break;
case PIX_FMT_RGB24:
case PIX_FMT_BGR24:
src = picture->data[0];
for(j=0;j<h;j++) {
memcpy(dest, src, w * 3);
dest += w * 3;
src += picture->linesize[0];
}
break;
default:
return -1;
}
return size;
return avpicture_layout((AVPicture *)data, avctx->pix_fmt, avctx->width,
avctx->height, frame, buf_size);
}
AVCodec rawvideo_encoder = {
"rawvideo",
CODEC_TYPE_VIDEO,
CODEC_ID_RAWVIDEO,
sizeof(AVFrame),
raw_init_encoder,
raw_encode,
};
AVCodec rawvideo_codec = {
AVCodec rawvideo_decoder = {
"rawvideo",
CODEC_TYPE_VIDEO,
CODEC_ID_RAWVIDEO,
sizeof(RawVideoContext),
raw_init,
raw_encode,
raw_close,
raw_init_decoder,
NULL,
raw_close_decoder,
raw_decode,
};

2
libavformat/avienc.c
View File

@ -211,7 +211,7 @@ void put_bmp_header(ByteIOContext *pb, AVCodecContext *enc, const CodecTag *tags
put_le16(pb, enc->bits_per_sample ? enc->bits_per_sample : 24); /* depth */
/* compression type */
put_le32(pb, for_asf ? codec_get_asf_tag(tags, enc->codec_id) : codec_get_tag(tags, enc->codec_id));
put_le32(pb, for_asf ? codec_get_asf_tag(tags, enc->codec_id) : enc->codec_tag);
put_le32(pb, enc->width * enc->height * 3);
put_le32(pb, 0);
put_le32(pb, 0);

17
libavformat/raw.c
View File

@ -65,6 +65,7 @@ static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->codec.frame_rate_base = ap->frame_rate_base;
st->codec.width = ap->width;
st->codec.height = ap->height;
st->codec.pix_fmt = ap->pix_fmt;
break;
default:
return -1;
@ -455,21 +456,9 @@ static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
width = st->codec.width;
height = st->codec.height;
switch(st->codec.pix_fmt) {
case PIX_FMT_YUV420P:
packet_size = (width * height * 3) / 2;
break;
case PIX_FMT_YUV422:
packet_size = (width * height * 2);
break;
case PIX_FMT_BGR24:
case PIX_FMT_RGB24:
packet_size = (width * height * 3);
break;
default:
packet_size = avpicture_get_size(st->codec.pix_fmt, width, height);
if (packet_size < 0)
av_abort();
break;
}
if (av_new_packet(pkt, packet_size) < 0)
return -EIO;