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
Split 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_FFWAVESYNTH_DECODER) += ffwavesynth.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_ENCODER) += flashsvenc.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);
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
}

1
libavcodec/h264.c
Unescape View File

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

103
libavformat/img2.c
Unescape View File

@ -29,61 +29,62 @@ typedef struct {
} IdStrMap;
static const IdStrMap img_tags[] = {
{ AV_CODEC_ID_MJPEG , "jpeg"},
{ AV_CODEC_ID_MJPEG , "jpg"},
{ AV_CODEC_ID_MJPEG , "jps"},
{ AV_CODEC_ID_LJPEG , "ljpg"},
{ AV_CODEC_ID_JPEGLS , "jls"},
{ AV_CODEC_ID_PNG , "png"},
{ AV_CODEC_ID_PNG , "pns"},
{ AV_CODEC_ID_PNG , "mng"},
{ AV_CODEC_ID_PPM , "ppm"},
{ AV_CODEC_ID_PPM , "pnm"},
{ AV_CODEC_ID_PGM , "pgm"},
{ AV_CODEC_ID_PGMYUV , "pgmyuv"},
{ AV_CODEC_ID_PBM , "pbm"},
{ AV_CODEC_ID_PAM , "pam"},
{ AV_CODEC_ID_MPEG1VIDEO, "mpg1-img"},
{ AV_CODEC_ID_MPEG2VIDEO, "mpg2-img"},
{ AV_CODEC_ID_MPEG4 , "mpg4-img"},
{ AV_CODEC_ID_FFV1 , "ffv1-img"},
{ AV_CODEC_ID_RAWVIDEO , "y"},
{ AV_CODEC_ID_RAWVIDEO , "raw"},
{ AV_CODEC_ID_BMP , "bmp"},
{ AV_CODEC_ID_GIF , "gif"},
{ AV_CODEC_ID_TARGA , "tga"},
{ AV_CODEC_ID_TIFF , "tiff"},
{ AV_CODEC_ID_TIFF , "tif"},
{ AV_CODEC_ID_SGI , "sgi"},
{ AV_CODEC_ID_PTX , "ptx"},
{ AV_CODEC_ID_PCX , "pcx"},
{ AV_CODEC_ID_BRENDER_PIX, "pix"},
{ AV_CODEC_ID_SUNRAST , "sun"},
{ AV_CODEC_ID_SUNRAST , "ras"},
{ AV_CODEC_ID_SUNRAST , "rs"},
{ AV_CODEC_ID_SUNRAST , "im1"},
{ AV_CODEC_ID_SUNRAST , "im8"},
{ AV_CODEC_ID_SUNRAST , "im24"},
{ AV_CODEC_ID_SUNRAST , "im32"},
{ AV_CODEC_ID_SUNRAST , "sunras"},
{ AV_CODEC_ID_JPEG2000 , "j2c"},
{ AV_CODEC_ID_JPEG2000 , "j2k"},
{ AV_CODEC_ID_JPEG2000 , "jp2"},
{ AV_CODEC_ID_JPEG2000 , "jpc"},
{ AV_CODEC_ID_DPX , "dpx"},
{ AV_CODEC_ID_EXR , "exr"},
{ AV_CODEC_ID_PICTOR , "pic"},
{ AV_CODEC_ID_V210X , "yuv10"},
{ AV_CODEC_ID_XBM , "xbm"},
{ AV_CODEC_ID_XFACE , "xface"},
{ AV_CODEC_ID_XWD , "xwd"},
{ AV_CODEC_ID_NONE , NULL}
{ AV_CODEC_ID_MJPEG, "jpeg" },
{ AV_CODEC_ID_MJPEG, "jpg" },
{ AV_CODEC_ID_MJPEG, "jps" },
{ AV_CODEC_ID_LJPEG, "ljpg" },
{ AV_CODEC_ID_JPEGLS, "jls" },
{ AV_CODEC_ID_PNG, "png" },
{ AV_CODEC_ID_PNG, "pns" },
{ AV_CODEC_ID_PNG, "mng" },
{ AV_CODEC_ID_PPM, "ppm" },
{ AV_CODEC_ID_PPM, "pnm" },
{ AV_CODEC_ID_PGM, "pgm" },
{ AV_CODEC_ID_PGMYUV, "pgmyuv" },
{ AV_CODEC_ID_PBM, "pbm" },
{ AV_CODEC_ID_PAM, "pam" },
{ AV_CODEC_ID_MPEG1VIDEO, "mpg1-img" },
{ AV_CODEC_ID_MPEG2VIDEO, "mpg2-img" },
{ AV_CODEC_ID_MPEG4, "mpg4-img" },
{ AV_CODEC_ID_FFV1, "ffv1-img" },
{ AV_CODEC_ID_RAWVIDEO, "y" },
{ AV_CODEC_ID_RAWVIDEO, "raw" },
{ AV_CODEC_ID_BMP, "bmp" },
{ AV_CODEC_ID_GIF, "gif" },
{ AV_CODEC_ID_TARGA, "tga" },
{ AV_CODEC_ID_TIFF, "tiff" },
{ AV_CODEC_ID_TIFF, "tif" },
{ AV_CODEC_ID_SGI, "sgi" },
{ AV_CODEC_ID_PTX, "ptx" },
{ AV_CODEC_ID_PCX, "pcx" },
{ AV_CODEC_ID_BRENDER_PIX, "pix" },
{ AV_CODEC_ID_SUNRAST, "sun" },
{ AV_CODEC_ID_SUNRAST, "ras" },
{ AV_CODEC_ID_SUNRAST, "rs" },
{ AV_CODEC_ID_SUNRAST, "im1" },
{ AV_CODEC_ID_SUNRAST, "im8" },
{ AV_CODEC_ID_SUNRAST, "im24" },
{ AV_CODEC_ID_SUNRAST, "im32" },
{ AV_CODEC_ID_SUNRAST, "sunras" },
{ AV_CODEC_ID_JPEG2000, "j2c" },
{ AV_CODEC_ID_JPEG2000, "j2k" },
{ AV_CODEC_ID_JPEG2000, "jp2" },
{ AV_CODEC_ID_JPEG2000, "jpc" },
{ AV_CODEC_ID_DPX, "dpx" },
{ AV_CODEC_ID_EXR, "exr" },
{ AV_CODEC_ID_PICTOR, "pic" },
{ AV_CODEC_ID_V210X, "yuv10" },
{ AV_CODEC_ID_XBM, "xbm" },
{ AV_CODEC_ID_XFACE, "xface" },
{ AV_CODEC_ID_XWD, "xwd" },
{ AV_CODEC_ID_NONE, NULL }
};
static enum AVCodecID av_str2id(const IdStrMap *tags, const char *str)
{
str= strrchr(str, '.');
if(!str) return AV_CODEC_ID_NONE;
str = strrchr(str, '.');
if (!str)
return AV_CODEC_ID_NONE;
str++;
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;
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) {
*width_ptr = sizes[i][0];
*width_ptr = sizes[i][0];
*height_ptr = sizes[i][1];
return 0;
}
}
return -1;
}
@ -128,9 +129,9 @@ static int find_image_range(int *pfirst_index, int *plast_index,
/* find the first image */
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 =
*plast_index = 1;
*plast_index = 1;
if (avio_check(buf, AVIO_FLAG_READ) > 0)
return 0;
return -1;
@ -143,9 +144,9 @@ static int find_image_range(int *pfirst_index, int *plast_index,
/* find the last image */
last_index = first_index;
for(;;) {
for (;;) {
range = 0;
for(;;) {
for (;;) {
if (!range)
range1 = 1;
else
@ -166,14 +167,14 @@ static int find_image_range(int *pfirst_index, int *plast_index,
last_index += range;
}
*pfirst_index = first_index;
*plast_index = last_index;
*plast_index = last_index;
return 0;
fail:
fail:
return -1;
}
static int read_probe(AVProbeData *p)
static int img_read_probe(AVProbeData *p)
{
if (p->filename && ff_guess_image2_codec(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"))
return 5;
else
return AVPROBE_SCORE_MAX/2;
return AVPROBE_SCORE_MAX / 2;
}
return 0;
}
static int read_header(AVFormatContext *s1)
static int img_read_header(AVFormatContext *s1)
{
VideoDemuxData *s = s1->priv_data;
int first_index, last_index, ret = 0;
@ -204,28 +205,33 @@ static int read_header(AVFormatContext *s1)
return AVERROR(ENOMEM);
}
if (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);
if (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);
}
if (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);
if (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;
}
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;
}
av_strlcpy(s->path, s1->filename, sizeof(s->path));
s->img_number = 0;
s->img_count = 0;
s->img_count = 0;
/* find format */
if (s1->iformat->flags & AVFMT_NOFILE)
s->is_pipe = 0;
else{
s->is_pipe = 1;
else {
s->is_pipe = 1;
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);
return AVERROR(EINVAL);
}
s->img_first = first_index;
s->img_last = last_index;
s->img_first = first_index;
s->img_last = last_index;
s->img_number = first_index;
/* compute duration */
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_id = s1->video_codec_id;
}else if(s1->audio_codec_id){
st->codec->codec_id = s1->video_codec_id;
} else if (s1->audio_codec_id) {
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s1->audio_codec_id;
}else{
const char *str= strrchr(s->path, '.');
s->split_planes = str && !av_strcasecmp(str + 1, "y");
st->codec->codec_id = s1->audio_codec_id;
} else {
const char *str = strrchr(s->path, '.');
s->split_planes = str && !av_strcasecmp(str + 1, "y");
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)
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;
return 0;
}
static int read_packet(AVFormatContext *s1, AVPacket *pkt)
static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
{
VideoDemuxData *s = s1->priv_data;
char filename_bytes[1024];
char *filename = filename_bytes;
int i;
int size[3]={0}, ret[3]={0};
AVIOContext *f[3] = {NULL};
AVCodecContext *codec= s1->streams[0]->codec;
int size[3] = { 0 }, ret[3] = { 0 };
AVIOContext *f[3] = { NULL };
AVCodecContext *codec = s1->streams[0]->codec;
if (!s->is_pipe) {
/* loop over input */
@ -349,25 +356,27 @@ static int read_packet(AVFormatContext *s1, AVPacket *pkt)
#endif
} else {
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);
}
for(i=0; i<3; i++){
for (i = 0; i < 3; i++) {
if (avio_open2(&f[i], filename, AVIO_FLAG_READ,
&s1->interrupt_callback, NULL) < 0) {
if(i>=1)
if (i >= 1)
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);
}
size[i]= avio_size(f[i]);
size[i] = avio_size(f[i]);
if(!s->split_planes)
if (!s->split_planes)
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]);
} else {
f[0] = s1->pb;
@ -376,27 +385,27 @@ static int read_packet(AVFormatContext *s1, AVPacket *pkt)
if (s->frame_size > 0) {
size[0] = s->frame_size;
} else {
size[0]= 4096;
size[0] = 4096;
}
}
if (av_new_packet(pkt, size[0] + size[1] + size[2]) < 0)
return AVERROR(ENOMEM);
pkt->stream_index = 0;
pkt->flags |= AV_PKT_FLAG_KEY;
pkt->flags |= AV_PKT_FLAG_KEY;
pkt->size= 0;
for(i=0; i<3; i++){
if(f[i]){
ret[i]= avio_read(f[i], pkt->data + pkt->size, size[i]);
pkt->size = 0;
for (i = 0; i < 3; i++) {
if (f[i]) {
ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
if (!s->is_pipe)
avio_close(f[i]);
if(ret[i]>0)
if (ret[i] > 0)
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);
return AVERROR(EIO); /* signal EOF */
} 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;
#if HAVE_GLOB
@ -420,19 +429,19 @@ static int read_close(struct AVFormatContext* s1)
#define OFFSET(x) offsetof(VideoDemuxData, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
{ "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 },
{ "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 },
{ "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", "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" },
{ "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", "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" },
{ "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 },
{ "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_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 },
{ "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, 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 },
{ NULL },
};
@ -447,10 +456,10 @@ AVInputFormat ff_image2_demuxer = {
.name = "image2",
.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
.priv_data_size = sizeof(VideoDemuxData),
.read_probe = read_probe,
.read_header = read_header,
.read_packet = read_packet,
.read_close = read_close,
.read_probe = img_read_probe,
.read_header = img_read_header,
.read_packet = img_read_packet,
.read_close = img_read_close,
.flags = AVFMT_NOFILE,
.priv_class = &img2_class,
};
@ -466,8 +475,8 @@ AVInputFormat ff_image2pipe_demuxer = {
.name = "image2pipe",
.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
.priv_data_size = sizeof(VideoDemuxData),
.read_header = read_header,
.read_packet = read_packet,
.read_header = img_read_header,
.read_packet = img_read_packet,
.priv_class = &img2pipe_class,
};
#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;
AVIOContext *pb[4];
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);
int i;
if (!img->is_pipe) {
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,
"Could not get frame filename number %d from pattern '%s'\n",
img->img_number, img->path);
return AVERROR(EINVAL);
}
for(i=0; i<4; i++){
for (i = 0; i < 4; i++) {
if (avio_open2(&pb[i], filename, AVIO_FLAG_WRITE,
&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);
}
if(!img->split_planes || i+1 >= desc->nb_components)
if (!img->split_planes || i+1 >= desc->nb_components)
break;
filename[ strlen(filename) - 1 ]= ((int[]){'U','V','A','x'})[i];
filename[strlen(filename) - 1] = ((int[]){'U','V','A','x'})[i];
}
} else {
pb[0] = s->pb;
}
if(img->split_planes){
if (img->split_planes) {
int ysize = codec->width * codec->height;
int usize = ((-codec->width)>>desc->log2_chroma_w) * ((-codec->height)>>desc->log2_chroma_h);
if (desc->comp[0].depth_minus1 >= 8) {
ysize *= 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[2], pkt->data + ysize + usize, usize);
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_close(pb[3]);
}
}else{
} else {
avio_write(pb[0], pkt->data, pkt->size);
}
avio_flush(pb[0]);
@ -128,8 +128,8 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
#define OFFSET(x) offsetof(VideoMuxData, x)
#define ENC AV_OPT_FLAG_ENCODING_PARAM
static const AVOption muxoptions[] = {
{ "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 },
{ "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 },
{ NULL },
};

Write Preview
Loading…
Cancel
Save