FFmpeg
img2enc.c
Go to the documentation of this file.
1 /*
2  * Image format
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  * Copyright (c) 2004 Michael Niedermayer
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <time.h>
24 
25 #include "config_components.h"
26 
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/log.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
34 #include "avformat.h"
35 #include "avio_internal.h"
36 #include "internal.h"
37 #include "img2.h"
38 #include "mux.h"
39 
40 typedef struct VideoMuxData {
41  const AVClass *class; /**< Class for private options. */
44  int split_planes; /**< use independent file for each Y, U, V plane */
45  char tmp[4][1024];
46  char target[4][1024];
47  int update;
49  int frame_pts;
50  const char *muxer;
53 } VideoMuxData;
54 
56 {
57  VideoMuxData *img = s->priv_data;
58  AVStream *st = s->streams[0];
60 
61  if (st->codecpar->codec_id == AV_CODEC_ID_GIF) {
62  img->muxer = "gif";
63  } else if (st->codecpar->codec_id == AV_CODEC_ID_FITS) {
64  img->muxer = "fits";
65  } else if (st->codecpar->codec_id == AV_CODEC_ID_AV1) {
66  img->muxer = "avif";
67  } else if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
68  const char *str = strrchr(s->url, '.');
69  img->split_planes = str
70  && !av_strcasecmp(str + 1, "y")
71  && s->nb_streams == 1
72  && desc
73  &&(desc->flags & AV_PIX_FMT_FLAG_PLANAR)
74  && desc->nb_components >= 3;
75  }
76  img->img_number = img->start_img_number;
77 
78  return 0;
79 }
80 
82 {
83  VideoMuxData *img = s->priv_data;
84  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
85  AVStream *st;
86  AVPacket *const pkt2 = ffformatcontext(s)->pkt;
87  AVFormatContext *fmt = NULL;
88  int ret;
89 
90  /* URL is not used directly as we are overriding the IO context later. */
91  ret = avformat_alloc_output_context2(&fmt, NULL, img->muxer, s->url);
92  if (ret < 0)
93  return ret;
94  st = avformat_new_stream(fmt, NULL);
95  if (!st) {
96  ret = AVERROR(ENOMEM);
97  goto out;
98  }
99  st->id = pkt->stream_index;
100 
101  fmt->pb = pb;
102 
103  ret = av_packet_ref(pkt2, pkt);
104  if (ret < 0)
105  goto out;
106  pkt2->stream_index = 0;
107 
108  if ((ret = avcodec_parameters_copy(st->codecpar, par)) < 0 ||
109  (ret = avformat_write_header(fmt, NULL)) < 0 ||
110  (ret = av_interleaved_write_frame(fmt, pkt2)) < 0 ||
111  (ret = av_write_trailer(fmt))) {}
112 
113  av_packet_unref(pkt2);
114 out:
116  return ret;
117 }
118 
120 {
121  VideoMuxData *img = s->priv_data;
122  if (img->muxer) {
123  int ret = write_muxed_file(s, s->pb, pkt);
124  if (ret < 0)
125  return ret;
126  } else {
127  avio_write(s->pb, pkt->data, pkt->size);
128  }
129  img->img_number++;
130  return 0;
131 }
132 
133 static int write_and_close(AVFormatContext *s, AVIOContext **pb, const unsigned char *buf, int size)
134 {
135  avio_write(*pb, buf, size);
136  avio_flush(*pb);
137  return ff_format_io_close(s, pb);
138 }
139 
141 {
142  VideoMuxData *img = s->priv_data;
143  AVIOContext *pb[4] = {0};
144  char filename[1024];
145  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
147  int ret, i;
148  int nb_renames = 0;
150 
151  if (img->update) {
152  av_strlcpy(filename, s->url, sizeof(filename));
153  } else if (img->use_strftime) {
154  time_t now0;
155  struct tm *tm, tmpbuf;
156  time(&now0);
157  tm = localtime_r(&now0, &tmpbuf);
158  if (!strftime(filename, sizeof(filename), s->url, tm)) {
159  av_log(s, AV_LOG_ERROR, "Could not get frame filename with strftime\n");
160  return AVERROR(EINVAL);
161  }
162  } else if (img->frame_pts) {
163  if (av_get_frame_filename2(filename, sizeof(filename), s->url, pkt->pts, AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
164  av_log(s, AV_LOG_ERROR, "Cannot write filename by pts of the frames.");
165  return AVERROR(EINVAL);
166  }
167  } else if (av_get_frame_filename2(filename, sizeof(filename), s->url,
168  img->img_number,
170  if (img->img_number == img->start_img_number) {
171  av_log(s, AV_LOG_WARNING, "The specified filename '%s' does not contain an image sequence pattern or a pattern is invalid.\n", s->url);
173  "Use a pattern such as %%03d for an image sequence or "
174  "use the -update option (with -frames:v 1 if needed) to write a single image.\n");
175  av_strlcpy(filename, s->url, sizeof(filename));
176  } else {
177  av_log(s, AV_LOG_ERROR, "Cannot write more than one file with the same name. Are you missing the -update option or a sequence pattern?\n");
178  return AVERROR(EINVAL);
179  }
180  }
181  for (i = 0; i < 4; i++) {
182  av_dict_copy(&options, img->protocol_opts, 0);
183  snprintf(img->tmp[i], sizeof(img->tmp[i]), "%s.tmp", filename);
184  av_strlcpy(img->target[i], filename, sizeof(img->target[i]));
185  if (s->io_open(s, &pb[i], img->use_rename ? img->tmp[i] : filename, AVIO_FLAG_WRITE, &options) < 0) {
186  av_log(s, AV_LOG_ERROR, "Could not open file : %s\n", img->use_rename ? img->tmp[i] : filename);
187  ret = AVERROR(EIO);
188  goto fail;
189  }
190  if (options) {
191  av_log(s, AV_LOG_ERROR, "Could not recognize some protocol options\n");
192  ret = AVERROR(EINVAL);
193  goto fail;
194  }
195 
196  if (!img->split_planes || i+1 >= desc->nb_components)
197  break;
198  filename[strlen(filename) - 1] = "UVAx"[i];
199  }
200  if (img->use_rename)
201  nb_renames = i + 1;
202 
203  if (img->split_planes) {
204  int ysize = par->width * par->height;
205  int usize = AV_CEIL_RSHIFT(par->width, desc->log2_chroma_w) * AV_CEIL_RSHIFT(par->height, desc->log2_chroma_h);
206  if (desc->comp[0].depth >= 9) {
207  ysize *= 2;
208  usize *= 2;
209  }
210  if ((ret = write_and_close(s, &pb[0], pkt->data , ysize)) < 0 ||
211  (ret = write_and_close(s, &pb[1], pkt->data + ysize , usize)) < 0 ||
212  (ret = write_and_close(s, &pb[2], pkt->data + ysize + usize, usize)) < 0)
213  goto fail;
214  if (desc->nb_components > 3)
215  ret = write_and_close(s, &pb[3], pkt->data + ysize + 2*usize, ysize);
216  } else if (img->muxer) {
217  if ((ret = write_muxed_file(s, pb[0], pkt)) < 0)
218  goto fail;
219  ret = ff_format_io_close(s, &pb[0]);
220  } else {
221  ret = write_and_close(s, &pb[0], pkt->data, pkt->size);
222  }
223  if (ret < 0)
224  goto fail;
225 
226  for (i = 0; i < nb_renames; i++) {
227  int ret = ff_rename(img->tmp[i], img->target[i], s);
228  if (ret < 0)
229  return ret;
230  }
231 
232  img->img_number++;
233  return 0;
234 
235 fail:
237  for (i = 0; i < FF_ARRAY_ELEMS(pb); i++)
238  if (pb[i])
239  ff_format_io_close(s, &pb[i]);
240  return ret;
241 }
242 
243 static int query_codec(enum AVCodecID id, int std_compliance)
244 {
245  int i;
246  for (i = 0; ff_img_tags[i].id != AV_CODEC_ID_NONE; i++)
247  if (ff_img_tags[i].id == id)
248  return 1;
249 
250  // Anything really can be stored in img2
251  return std_compliance < FF_COMPLIANCE_NORMAL;
252 }
253 
254 #define OFFSET(x) offsetof(VideoMuxData, x)
255 #define ENC AV_OPT_FLAG_ENCODING_PARAM
256 static const AVOption muxoptions[] = {
257  { "update", "continuously overwrite one file", OFFSET(update), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
258  { "start_number", "set first number in the sequence", OFFSET(start_img_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, INT_MAX, ENC },
259  { "strftime", "use strftime for filename", OFFSET(use_strftime), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
260  { "frame_pts", "use current frame pts for filename", OFFSET(frame_pts), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
261  { "atomic_writing", "write files atomically (using temporary files and renames)", OFFSET(use_rename), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
262  { "protocol_opts", "specify protocol options for the opened files", OFFSET(protocol_opts), AV_OPT_TYPE_DICT, {0}, 0, 0, ENC },
263  { NULL },
264 };
265 
266 #if CONFIG_IMAGE2_MUXER
267 static const AVClass img2mux_class = {
268  .class_name = "image2 muxer",
269  .item_name = av_default_item_name,
270  .option = muxoptions,
271  .version = LIBAVUTIL_VERSION_INT,
272 };
273 
275  .p.name = "image2",
276  .p.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
277  .p.extensions = "bmp,dpx,exr,jls,jpeg,jpg,jxl,ljpg,pam,pbm,pcx,pfm,pgm,pgmyuv,phm,"
278  "png,ppm,sgi,tga,tif,tiff,jp2,j2c,j2k,xwd,sun,ras,rs,im1,im8,"
279  "im24,sunras,vbn,xbm,xface,pix,y,avif,qoi,hdr,wbmp",
280  .priv_data_size = sizeof(VideoMuxData),
281  .p.video_codec = AV_CODEC_ID_MJPEG,
282  .write_header = write_header,
283  .write_packet = write_packet,
284  .query_codec = query_codec,
286  .p.priv_class = &img2mux_class,
287 };
288 #endif
289 #if CONFIG_IMAGE2PIPE_MUXER
291  .p.name = "image2pipe",
292  .p.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
293  .priv_data_size = sizeof(VideoMuxData),
294  .p.video_codec = AV_CODEC_ID_MJPEG,
295  .write_header = write_header,
296  .write_packet = write_packet_pipe,
297  .query_codec = query_codec,
299 };
300 #endif
ff_image2_muxer
const FFOutputFormat ff_image2_muxer
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
VideoMuxData::img_number
int img_number
Definition: img2enc.c:43
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
write_packet_pipe
static int write_packet_pipe(AVFormatContext *s, AVPacket *pkt)
Definition: img2enc.c:119
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:483
out
FILE * out
Definition: movenc.c:55
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
pixdesc.h
AVPacket::data
uint8_t * data
Definition: packet.h:520
av_get_frame_filename2
int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
Return in 'buf' the path with 'd' replaced by a number.
Definition: utils.c:283
AVOption
AVOption.
Definition: opt.h:357
VideoMuxData::muxer
const char * muxer
Definition: img2enc.c:50
write_and_close
static int write_and_close(AVFormatContext *s, AVIOContext **pb, const unsigned char *buf, int size)
Definition: img2enc.c:133
VideoMuxData::target
char target[4][1024]
Definition: img2enc.c:46
OFFSET
#define OFFSET(x)
Definition: img2enc.c:254
AVDictionary
Definition: dict.c:34
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
write_header
static int write_header(AVFormatContext *s)
Definition: img2enc.c:55
fail
#define fail()
Definition: checkasm.h:185
query_codec
static int query_codec(enum AVCodecID id, int std_compliance)
Definition: img2enc.c:243
update
static av_always_inline void update(SilenceDetectContext *s, AVFrame *insamples, int is_silence, int current_sample, int64_t nb_samples_notify, AVRational time_base)
Definition: af_silencedetect.c:78
ff_rename
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap ffurl_move() and log if error happens.
Definition: avio.c:861
write_packet
static int write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: img2enc.c:140
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
muxoptions
static const AVOption muxoptions[]
Definition: img2enc.c:256
ff_img_tags
const IdStrMap ff_img_tags[]
Definition: img2.c:104
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
avformat_write_header
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
Definition: mux.c:487
time_internal.h
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:223
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
VideoMuxData::use_strftime
int use_strftime
Definition: img2enc.c:48
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
VideoMuxData::update
int update
Definition: img2enc.c:47
NULL
#define NULL
Definition: coverity.c:32
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
IdStrMap::id
enum AVCodecID id
Definition: img2.h:68
AV_CODEC_ID_FITS
@ AV_CODEC_ID_FITS
Definition: codec_id.h:286
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:252
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1297
FFOutputFormat
Definition: mux.h:61
time.h
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: packet.c:435
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
options
const OptionDef options[]
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVPacket::size
int size
Definition: packet.h:521
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
localtime_r
#define localtime_r
Definition: time_internal.h:46
VideoMuxData::split_planes
int split_planes
use independent file for each Y, U, V plane
Definition: img2enc.c:44
size
int size
Definition: twinvq_data.h:10344
VideoMuxData::tmp
char tmp[4][1024]
Definition: img2enc.c:45
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: avformat.c:944
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: defs.h:60
img
#define img
Definition: vf_colormatrix.c:114
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
VideoMuxData::use_rename
int use_rename
Definition: img2enc.c:51
VideoMuxData::frame_pts
int frame_pts
Definition: img2enc.c:49
AV_FRAME_FILENAME_FLAGS_MULTIPLE
#define AV_FRAME_FILENAME_FLAGS_MULTIPLE
Allow multiple d.
Definition: avformat.h:2891
AV_CODEC_ID_GIF
@ AV_CODEC_ID_GIF
Definition: codec_id.h:149
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
av_write_trailer
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1295
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:513
avio_internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:135
img2.h
ENC
#define ENC
Definition: img2enc.c:255
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:755
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
avformat.h
dict.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:141
VideoMuxData
Definition: img2enc.c:40
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
write_muxed_file
static int write_muxed_file(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Definition: img2enc.c:81
ff_image2pipe_muxer
const FFOutputFormat ff_image2pipe_muxer
AVPacket::stream_index
int stream_index
Definition: packet.h:522
VideoMuxData::start_img_number
int start_img_number
Definition: img2enc.c:42
desc
const char * desc
Definition: libsvtav1.c:79
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:134
AVCodecParameters::format
int format
Definition: codec_par.h:92
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
av_interleaved_write_frame
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1280
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
avstring.h
avformat_alloc_output_context2
int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:94
snprintf
#define snprintf
Definition: snprintf.h:34
VideoMuxData::protocol_opts
AVDictionary * protocol_opts
Definition: img2enc.c:52
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:106
mux.h