Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge commit '9d46eaec7a90bd8f5cd9e45398c6d17804182320'

Browse Source 
* commit '9d46eaec7a90bd8f5cd9e45398c6d17804182320':
  build: The FLAC encoder also depends on the flacdsp code
  img2: K&R formatting cosmetics
  h264: check context state before decoding slice data partitions
  flashsv: make sure data for zlib priming is available

Conflicts:
	libavcodec/Makefile
	libavformat/img2.c
	libavformat/img2dec.c
	libavformat/img2enc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/8/head
Michael Niedermayer 12 years ago
parent 8119d8b01f 9d46eaec7a
commit db29a7c7c2
6 changed files with 148 additions and 132 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      libavcodec/Makefile
  2. 5
      libavcodec/flashsv.c
  3. 1
      libavcodec/h264.c
  4. 103
      libavformat/img2.c
  5. 147
      libavformat/img2dec.c
  6. 22
      libavformat/img2enc.c

2
libavcodec/Makefile
Unescape View File

@ -193,7 +193,7 @@ OBJS-$(CONFIG_FFVHUFF_DECODER) += huffyuv.o
OBJS-$(CONFIG_FFVHUFF_ENCODER) += huffyuv.o OBJS-$(CONFIG_FFVHUFF_ENCODER) += huffyuv.o
OBJS-$(CONFIG_FFWAVESYNTH_DECODER) += ffwavesynth.o OBJS-$(CONFIG_FFWAVESYNTH_DECODER) += ffwavesynth.o
OBJS-$(CONFIG_FLAC_DECODER) += flacdec.o flacdata.o flac.o flacdsp.o OBJS-$(CONFIG_FLAC_DECODER) += flacdec.o flacdata.o flac.o flacdsp.o
OBJS-$(CONFIG_FLAC_ENCODER) += flacenc.o flacdata.o flac.o vorbis_data.o OBJS-$(CONFIG_FLAC_ENCODER) += flacenc.o flacdata.o flac.o flacdsp.o vorbis_data.o
OBJS-$(CONFIG_FLASHSV_DECODER) += flashsv.o OBJS-$(CONFIG_FLASHSV_DECODER) += flashsv.o
OBJS-$(CONFIG_FLASHSV_ENCODER) += flashsvenc.o OBJS-$(CONFIG_FLASHSV_ENCODER) += flashsvenc.o
OBJS-$(CONFIG_FLASHSV2_ENCODER) += flashsv2enc.o OBJS-$(CONFIG_FLASHSV2_ENCODER) += flashsv2enc.o

5
libavcodec/flashsv.c
Unescape View File

@ -403,6 +403,11 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
av_log_missing_feature(avctx, "zlibprime_curr", 1); av_log_missing_feature(avctx, "zlibprime_curr", 1);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
av_log(avctx, AV_LOG_ERROR, "no data available for zlib "
"priming\n");
return AVERROR_INVALIDDATA;
}
size--; // account for flags byte size--; // account for flags byte
} }

1
libavcodec/h264.c
Unescape View File

@ -3989,6 +3989,7 @@ again:
if (hx->redundant_pic_count == 0 && if (hx->redundant_pic_count == 0 &&
hx->intra_gb_ptr && hx->intra_gb_ptr &&
hx->s.data_partitioning && hx->s.data_partitioning &&
s->current_picture_ptr &&
s->context_initialized && s->context_initialized &&
(avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc) && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc) &&
(avctx->skip_frame < AVDISCARD_BIDIR || (avctx->skip_frame < AVDISCARD_BIDIR ||

103
libavformat/img2.c
Unescape View File

@ -29,61 +29,62 @@ typedef struct {
} IdStrMap; } IdStrMap;
static const IdStrMap img_tags[] = { static const IdStrMap img_tags[] = {
{ AV_CODEC_ID_MJPEG , "jpeg"}, { AV_CODEC_ID_MJPEG, "jpeg" },
{ AV_CODEC_ID_MJPEG , "jpg"}, { AV_CODEC_ID_MJPEG, "jpg" },
{ AV_CODEC_ID_MJPEG , "jps"}, { AV_CODEC_ID_MJPEG, "jps" },
{ AV_CODEC_ID_LJPEG , "ljpg"}, { AV_CODEC_ID_LJPEG, "ljpg" },
{ AV_CODEC_ID_JPEGLS , "jls"}, { AV_CODEC_ID_JPEGLS, "jls" },
{ AV_CODEC_ID_PNG , "png"}, { AV_CODEC_ID_PNG, "png" },
{ AV_CODEC_ID_PNG , "pns"}, { AV_CODEC_ID_PNG, "pns" },
{ AV_CODEC_ID_PNG , "mng"}, { AV_CODEC_ID_PNG, "mng" },
{ AV_CODEC_ID_PPM , "ppm"}, { AV_CODEC_ID_PPM, "ppm" },
{ AV_CODEC_ID_PPM , "pnm"}, { AV_CODEC_ID_PPM, "pnm" },
{ AV_CODEC_ID_PGM , "pgm"}, { AV_CODEC_ID_PGM, "pgm" },
{ AV_CODEC_ID_PGMYUV , "pgmyuv"}, { AV_CODEC_ID_PGMYUV, "pgmyuv" },
{ AV_CODEC_ID_PBM , "pbm"}, { AV_CODEC_ID_PBM, "pbm" },
{ AV_CODEC_ID_PAM , "pam"}, { AV_CODEC_ID_PAM, "pam" },
{ AV_CODEC_ID_MPEG1VIDEO, "mpg1-img"}, { AV_CODEC_ID_MPEG1VIDEO, "mpg1-img" },
{ AV_CODEC_ID_MPEG2VIDEO, "mpg2-img"}, { AV_CODEC_ID_MPEG2VIDEO, "mpg2-img" },
{ AV_CODEC_ID_MPEG4 , "mpg4-img"}, { AV_CODEC_ID_MPEG4, "mpg4-img" },
{ AV_CODEC_ID_FFV1 , "ffv1-img"}, { AV_CODEC_ID_FFV1, "ffv1-img" },
{ AV_CODEC_ID_RAWVIDEO , "y"}, { AV_CODEC_ID_RAWVIDEO, "y" },
{ AV_CODEC_ID_RAWVIDEO , "raw"}, { AV_CODEC_ID_RAWVIDEO, "raw" },
{ AV_CODEC_ID_BMP , "bmp"}, { AV_CODEC_ID_BMP, "bmp" },
{ AV_CODEC_ID_GIF , "gif"}, { AV_CODEC_ID_GIF, "gif" },
{ AV_CODEC_ID_TARGA , "tga"}, { AV_CODEC_ID_TARGA, "tga" },
{ AV_CODEC_ID_TIFF , "tiff"}, { AV_CODEC_ID_TIFF, "tiff" },
{ AV_CODEC_ID_TIFF , "tif"}, { AV_CODEC_ID_TIFF, "tif" },
{ AV_CODEC_ID_SGI , "sgi"}, { AV_CODEC_ID_SGI, "sgi" },
{ AV_CODEC_ID_PTX , "ptx"}, { AV_CODEC_ID_PTX, "ptx" },
{ AV_CODEC_ID_PCX , "pcx"}, { AV_CODEC_ID_PCX, "pcx" },
{ AV_CODEC_ID_BRENDER_PIX, "pix"}, { AV_CODEC_ID_BRENDER_PIX, "pix" },
{ AV_CODEC_ID_SUNRAST , "sun"}, { AV_CODEC_ID_SUNRAST, "sun" },
{ AV_CODEC_ID_SUNRAST , "ras"}, { AV_CODEC_ID_SUNRAST, "ras" },
{ AV_CODEC_ID_SUNRAST , "rs"}, { AV_CODEC_ID_SUNRAST, "rs" },
{ AV_CODEC_ID_SUNRAST , "im1"}, { AV_CODEC_ID_SUNRAST, "im1" },
{ AV_CODEC_ID_SUNRAST , "im8"}, { AV_CODEC_ID_SUNRAST, "im8" },
{ AV_CODEC_ID_SUNRAST , "im24"}, { AV_CODEC_ID_SUNRAST, "im24" },
{ AV_CODEC_ID_SUNRAST , "im32"}, { AV_CODEC_ID_SUNRAST, "im32" },
{ AV_CODEC_ID_SUNRAST , "sunras"}, { AV_CODEC_ID_SUNRAST, "sunras" },
{ AV_CODEC_ID_JPEG2000 , "j2c"}, { AV_CODEC_ID_JPEG2000, "j2c" },
{ AV_CODEC_ID_JPEG2000 , "j2k"}, { AV_CODEC_ID_JPEG2000, "j2k" },
{ AV_CODEC_ID_JPEG2000 , "jp2"}, { AV_CODEC_ID_JPEG2000, "jp2" },
{ AV_CODEC_ID_JPEG2000 , "jpc"}, { AV_CODEC_ID_JPEG2000, "jpc" },
{ AV_CODEC_ID_DPX , "dpx"}, { AV_CODEC_ID_DPX, "dpx" },
{ AV_CODEC_ID_EXR , "exr"}, { AV_CODEC_ID_EXR, "exr" },
{ AV_CODEC_ID_PICTOR , "pic"}, { AV_CODEC_ID_PICTOR, "pic" },
{ AV_CODEC_ID_V210X , "yuv10"}, { AV_CODEC_ID_V210X, "yuv10" },
{ AV_CODEC_ID_XBM , "xbm"}, { AV_CODEC_ID_XBM, "xbm" },
{ AV_CODEC_ID_XFACE , "xface"}, { AV_CODEC_ID_XFACE, "xface" },
{ AV_CODEC_ID_XWD , "xwd"}, { AV_CODEC_ID_XWD, "xwd" },
{ AV_CODEC_ID_NONE , NULL} { AV_CODEC_ID_NONE, NULL }
}; };
static enum AVCodecID av_str2id(const IdStrMap *tags, const char *str) static enum AVCodecID av_str2id(const IdStrMap *tags, const char *str)
{ {
str= strrchr(str, '.'); str = strrchr(str, '.');
if(!str) return AV_CODEC_ID_NONE; if (!str)
return AV_CODEC_ID_NONE;
str++; str++;
while (tags->id) { while (tags->id) {

147
libavformat/img2dec.c
Unescape View File

@ -80,13 +80,14 @@ static int infer_size(int *width_ptr, int *height_ptr, int size)
{ {
int i; int i;
for(i=0;i<FF_ARRAY_ELEMS(sizes);i++) { for (i = 0; i < FF_ARRAY_ELEMS(sizes); i++) {
if ((sizes[i][0] * sizes[i][1]) == size) { if ((sizes[i][0] * sizes[i][1]) == size) {
*width_ptr = sizes[i][0]; *width_ptr = sizes[i][0];
*height_ptr = sizes[i][1]; *height_ptr = sizes[i][1];
return 0; return 0;
} }
} }
return -1; return -1;
} }
@ -128,9 +129,9 @@ static int find_image_range(int *pfirst_index, int *plast_index,
/* find the first image */ /* find the first image */
for (first_index = start_index; first_index < start_index + start_index_range; first_index++) { for (first_index = start_index; first_index < start_index + start_index_range; first_index++) {
if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0){ if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0) {
*pfirst_index = *pfirst_index =
*plast_index = 1; *plast_index = 1;
if (avio_check(buf, AVIO_FLAG_READ) > 0) if (avio_check(buf, AVIO_FLAG_READ) > 0)
return 0; return 0;
return -1; return -1;
@ -143,9 +144,9 @@ static int find_image_range(int *pfirst_index, int *plast_index,
/* find the last image */ /* find the last image */
last_index = first_index; last_index = first_index;
for(;;) { for (;;) {
range = 0; range = 0;
for(;;) { for (;;) {
if (!range) if (!range)
range1 = 1; range1 = 1;
else else
@ -166,14 +167,14 @@ static int find_image_range(int *pfirst_index, int *plast_index,
last_index += range; last_index += range;
} }
*pfirst_index = first_index; *pfirst_index = first_index;
*plast_index = last_index; *plast_index = last_index;
return 0; return 0;
fail:
fail:
return -1; return -1;
} }
static int img_read_probe(AVProbeData *p)
static int read_probe(AVProbeData *p)
{ {
if (p->filename && ff_guess_image2_codec(p->filename)) { if (p->filename && ff_guess_image2_codec(p->filename)) {
if (av_filename_number_test(p->filename)) if (av_filename_number_test(p->filename))
@ -183,12 +184,12 @@ static int read_probe(AVProbeData *p)
else if(av_match_ext(p->filename, "raw")) else if(av_match_ext(p->filename, "raw"))
return 5; return 5;
else else
return AVPROBE_SCORE_MAX/2; return AVPROBE_SCORE_MAX / 2;
} }
return 0; return 0;
} }
static int read_header(AVFormatContext *s1) static int img_read_header(AVFormatContext *s1)
{ {
VideoDemuxData *s = s1->priv_data; VideoDemuxData *s = s1->priv_data;
int first_index, last_index, ret = 0; int first_index, last_index, ret = 0;
@ -204,28 +205,33 @@ static int read_header(AVFormatContext *s1)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if (s->pixel_format && (pix_fmt = av_get_pix_fmt(s->pixel_format)) == AV_PIX_FMT_NONE) { if (s->pixel_format &&
av_log(s1, AV_LOG_ERROR, "No such pixel format: %s.\n", s->pixel_format); (pix_fmt = av_get_pix_fmt(s->pixel_format)) == AV_PIX_FMT_NONE) {
av_log(s1, AV_LOG_ERROR, "No such pixel format: %s.\n",
s->pixel_format);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (s->video_size && (ret = av_parse_video_size(&width, &height, s->video_size)) < 0) { if (s->video_size &&
av_log(s, AV_LOG_ERROR, "Could not parse video size: %s.\n", s->video_size); (ret = av_parse_video_size(&width, &height, s->video_size)) < 0) {
av_log(s, AV_LOG_ERROR,
"Could not parse video size: %s.\n", s->video_size);
return ret; return ret;
} }
if ((ret = av_parse_video_rate(&framerate, s->framerate)) < 0) { if ((ret = av_parse_video_rate(&framerate, s->framerate)) < 0) {
av_log(s, AV_LOG_ERROR, "Could not parse framerate: %s.\n", s->framerate); av_log(s, AV_LOG_ERROR,
"Could not parse framerate: %s.\n", s->framerate);
return ret; return ret;
} }
av_strlcpy(s->path, s1->filename, sizeof(s->path)); av_strlcpy(s->path, s1->filename, sizeof(s->path));
s->img_number = 0; s->img_number = 0;
s->img_count = 0; s->img_count = 0;
/* find format */ /* find format */
if (s1->iformat->flags & AVFMT_NOFILE) if (s1->iformat->flags & AVFMT_NOFILE)
s->is_pipe = 0; s->is_pipe = 0;
else{ else {
s->is_pipe = 1; s->is_pipe = 1;
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
} }
@ -298,43 +304,44 @@ static int read_header(AVFormatContext *s1)
"Unknown value '%d' for pattern_type option\n", s->pattern_type); "Unknown value '%d' for pattern_type option\n", s->pattern_type);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
s->img_first = first_index; s->img_first = first_index;
s->img_last = last_index; s->img_last = last_index;
s->img_number = first_index; s->img_number = first_index;
/* compute duration */ /* compute duration */
st->start_time = 0; st->start_time = 0;
st->duration = last_index - first_index + 1; st->duration = last_index - first_index + 1;
} }
if(s1->video_codec_id){ if (s1->video_codec_id) {
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = s1->video_codec_id; st->codec->codec_id = s1->video_codec_id;
}else if(s1->audio_codec_id){ } else if (s1->audio_codec_id) {
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s1->audio_codec_id; st->codec->codec_id = s1->audio_codec_id;
}else{ } else {
const char *str= strrchr(s->path, '.'); const char *str = strrchr(s->path, '.');
s->split_planes = str && !av_strcasecmp(str + 1, "y"); s->split_planes = str && !av_strcasecmp(str + 1, "y");
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = ff_guess_image2_codec(s->path); st->codec->codec_id = ff_guess_image2_codec(s->path);
if (st->codec->codec_id == AV_CODEC_ID_LJPEG) if (st->codec->codec_id == AV_CODEC_ID_LJPEG)
st->codec->codec_id = AV_CODEC_ID_MJPEG; st->codec->codec_id = AV_CODEC_ID_MJPEG;
} }
if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pix_fmt != AV_PIX_FMT_NONE) if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
pix_fmt != AV_PIX_FMT_NONE)
st->codec->pix_fmt = pix_fmt; st->codec->pix_fmt = pix_fmt;
return 0; return 0;
} }
static int read_packet(AVFormatContext *s1, AVPacket *pkt) static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
{ {
VideoDemuxData *s = s1->priv_data; VideoDemuxData *s = s1->priv_data;
char filename_bytes[1024]; char filename_bytes[1024];
char *filename = filename_bytes; char *filename = filename_bytes;
int i; int i;
int size[3]={0}, ret[3]={0}; int size[3] = { 0 }, ret[3] = { 0 };
AVIOContext *f[3] = {NULL}; AVIOContext *f[3] = { NULL };
AVCodecContext *codec= s1->streams[0]->codec; AVCodecContext *codec = s1->streams[0]->codec;
if (!s->is_pipe) { if (!s->is_pipe) {
/* loop over input */ /* loop over input */
@ -349,25 +356,27 @@ static int read_packet(AVFormatContext *s1, AVPacket *pkt)
#endif #endif
} else { } else {
if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes), if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes),
s->path, s->img_number)<0 && s->img_number > 1) s->path,
s->img_number) < 0 && s->img_number > 1)
return AVERROR(EIO); return AVERROR(EIO);
} }
for(i=0; i<3; i++){ for (i = 0; i < 3; i++) {
if (avio_open2(&f[i], filename, AVIO_FLAG_READ, if (avio_open2(&f[i], filename, AVIO_FLAG_READ,
&s1->interrupt_callback, NULL) < 0) { &s1->interrupt_callback, NULL) < 0) {
if(i>=1) if (i >= 1)
break; break;
av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",filename); av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",
filename);
return AVERROR(EIO); return AVERROR(EIO);
} }
size[i]= avio_size(f[i]); size[i] = avio_size(f[i]);
if(!s->split_planes) if (!s->split_planes)
break; break;
filename[ strlen(filename) - 1 ]= 'U' + i; filename[strlen(filename) - 1] = 'U' + i;
} }
if(codec->codec_id == AV_CODEC_ID_RAWVIDEO && !codec->width) if (codec->codec_id == AV_CODEC_ID_RAWVIDEO && !codec->width)
infer_size(&codec->width, &codec->height, size[0]); infer_size(&codec->width, &codec->height, size[0]);
} else { } else {
f[0] = s1->pb; f[0] = s1->pb;
@ -376,27 +385,27 @@ static int read_packet(AVFormatContext *s1, AVPacket *pkt)
if (s->frame_size > 0) { if (s->frame_size > 0) {
size[0] = s->frame_size; size[0] = s->frame_size;
} else { } else {
size[0]= 4096; size[0] = 4096;
} }
} }
if (av_new_packet(pkt, size[0] + size[1] + size[2]) < 0) if (av_new_packet(pkt, size[0] + size[1] + size[2]) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
pkt->stream_index = 0; pkt->stream_index = 0;
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
pkt->size= 0; pkt->size = 0;
for(i=0; i<3; i++){ for (i = 0; i < 3; i++) {
if(f[i]){ if (f[i]) {
ret[i]= avio_read(f[i], pkt->data + pkt->size, size[i]); ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
if (!s->is_pipe) if (!s->is_pipe)
avio_close(f[i]); avio_close(f[i]);
if(ret[i]>0) if (ret[i] > 0)
pkt->size += ret[i]; pkt->size += ret[i];
} }
} }
if (ret[0] <= 0 || ret[1]<0 || ret[2]<0) { if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
av_free_packet(pkt); av_free_packet(pkt);
return AVERROR(EIO); /* signal EOF */ return AVERROR(EIO); /* signal EOF */
} else { } else {
@ -406,7 +415,7 @@ static int read_packet(AVFormatContext *s1, AVPacket *pkt)
} }
} }
static int read_close(struct AVFormatContext* s1) static int img_read_close(struct AVFormatContext* s1)
{ {
VideoDemuxData *s = s1->priv_data; VideoDemuxData *s = s1->priv_data;
#if HAVE_GLOB #if HAVE_GLOB
@ -420,19 +429,19 @@ static int read_close(struct AVFormatContext* s1)
#define OFFSET(x) offsetof(VideoDemuxData, x) #define OFFSET(x) offsetof(VideoDemuxData, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM #define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = { static const AVOption options[] = {
{ "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC }, { "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC },
{ "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC }, { "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, DEC },
{ "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_GLOB_SEQUENCE}, 0, INT_MAX, DEC, "pattern_type"}, { "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_GLOB_SEQUENCE}, 0, INT_MAX, DEC, "pattern_type"},
{ "glob_sequence","glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" }, { "glob_sequence","glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
{ "glob", "glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB}, INT_MIN, INT_MAX, DEC, "pattern_type" }, { "glob", "glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB }, INT_MIN, INT_MAX, DEC, "pattern_type" },
{ "sequence", "glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" }, { "sequence", "glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
{ "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, { "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
{ "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC }, { "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
{ "start_number_range", "set range for looking at the first sequence number", OFFSET(start_number_range), AV_OPT_TYPE_INT, {.i64 = 5}, 1, INT_MAX, DEC }, { "start_number_range", "set range for looking at the first sequence number", OFFSET(start_number_range), AV_OPT_TYPE_INT, {.i64 = 5}, 1, INT_MAX, DEC },
{ "video_size", "set video size", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, { "video_size", "set video size", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
{ "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC }, { "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
{ NULL }, { NULL },
}; };
@ -447,10 +456,10 @@ AVInputFormat ff_image2_demuxer = {
.name = "image2", .name = "image2",
.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"), .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
.priv_data_size = sizeof(VideoDemuxData), .priv_data_size = sizeof(VideoDemuxData),
.read_probe = read_probe, .read_probe = img_read_probe,
.read_header = read_header, .read_header = img_read_header,
.read_packet = read_packet, .read_packet = img_read_packet,
.read_close = read_close, .read_close = img_read_close,
.flags = AVFMT_NOFILE, .flags = AVFMT_NOFILE,
.priv_class = &img2_class, .priv_class = &img2_class,
}; };
@ -466,8 +475,8 @@ AVInputFormat ff_image2pipe_demuxer = {
.name = "image2pipe", .name = "image2pipe",
.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"), .long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
.priv_data_size = sizeof(VideoDemuxData), .priv_data_size = sizeof(VideoDemuxData),
.read_header = read_header, .read_header = img_read_header,
.read_packet = read_packet, .read_packet = img_read_packet,
.priv_class = &img2pipe_class, .priv_class = &img2pipe_class,
}; };
#endif #endif

22
libavformat/img2enc.c
Unescape View File

@ -70,41 +70,41 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
VideoMuxData *img = s->priv_data; VideoMuxData *img = s->priv_data;
AVIOContext *pb[4]; AVIOContext *pb[4];
char filename[1024]; char filename[1024];
AVCodecContext *codec= s->streams[ pkt->stream_index ]->codec; AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(codec->pix_fmt); const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(codec->pix_fmt);
int i; int i;
if (!img->is_pipe) { if (!img->is_pipe) {
if (av_get_frame_filename(filename, sizeof(filename), if (av_get_frame_filename(filename, sizeof(filename),
img->path, img->img_number) < 0 && img->img_number>1 && !img->updatefirst) { img->path, img->img_number) < 0 && img->img_number > 1 && !img->updatefirst) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"Could not get frame filename number %d from pattern '%s'\n", "Could not get frame filename number %d from pattern '%s'\n",
img->img_number, img->path); img->img_number, img->path);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
for(i=0; i<4; i++){ for (i = 0; i < 4; i++) {
if (avio_open2(&pb[i], filename, AVIO_FLAG_WRITE, if (avio_open2(&pb[i], filename, AVIO_FLAG_WRITE,
&s->interrupt_callback, NULL) < 0) { &s->interrupt_callback, NULL) < 0) {
av_log(s, AV_LOG_ERROR, "Could not open file : %s\n",filename); av_log(s, AV_LOG_ERROR, "Could not open file : %s\n", filename);
return AVERROR(EIO); return AVERROR(EIO);
} }
if(!img->split_planes || i+1 >= desc->nb_components) if (!img->split_planes || i+1 >= desc->nb_components)
break; break;
filename[ strlen(filename) - 1 ]= ((int[]){'U','V','A','x'})[i]; filename[strlen(filename) - 1] = ((int[]){'U','V','A','x'})[i];
} }
} else { } else {
pb[0] = s->pb; pb[0] = s->pb;
} }
if(img->split_planes){ if (img->split_planes) {
int ysize = codec->width * codec->height; int ysize = codec->width * codec->height;
int usize = ((-codec->width)>>desc->log2_chroma_w) * ((-codec->height)>>desc->log2_chroma_h); int usize = ((-codec->width)>>desc->log2_chroma_w) * ((-codec->height)>>desc->log2_chroma_h);
if (desc->comp[0].depth_minus1 >= 8) { if (desc->comp[0].depth_minus1 >= 8) {
ysize *= 2; ysize *= 2;
usize *= 2; usize *= 2;
} }
avio_write(pb[0], pkt->data , ysize); avio_write(pb[0], pkt->data , ysize);
avio_write(pb[1], pkt->data + ysize , usize); avio_write(pb[1], pkt->data + ysize , usize);
avio_write(pb[2], pkt->data + ysize + usize, usize); avio_write(pb[2], pkt->data + ysize + usize, usize);
avio_close(pb[1]); avio_close(pb[1]);
@ -113,7 +113,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
avio_write(pb[3], pkt->data + ysize + 2*usize, ysize); avio_write(pb[3], pkt->data + ysize + 2*usize, ysize);
avio_close(pb[3]); avio_close(pb[3]);
} }
}else{ } else {
avio_write(pb[0], pkt->data, pkt->size); avio_write(pb[0], pkt->data, pkt->size);
} }
avio_flush(pb[0]); avio_flush(pb[0]);
@ -128,8 +128,8 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
#define OFFSET(x) offsetof(VideoMuxData, x) #define OFFSET(x) offsetof(VideoMuxData, x)
#define ENC AV_OPT_FLAG_ENCODING_PARAM #define ENC AV_OPT_FLAG_ENCODING_PARAM
static const AVOption muxoptions[] = { static const AVOption muxoptions[] = {
{ "updatefirst", "", OFFSET(updatefirst), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, ENC }, { "updatefirst", "", OFFSET(updatefirst), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, ENC },
{ "start_number", "first number in the sequence", OFFSET(img_number), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, ENC }, { "start_number", "first number in the sequence", OFFSET(img_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, ENC },
{ NULL }, { NULL },
}; };

Write Preview
Loading…
Cancel
Save