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 "libavutil/intreadwrite.h"
24 #include "libavutil/avassert.h"
25 #include "libavutil/avstring.h"
26 #include "libavutil/log.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
30 #include "avformat.h"
31 #include "avio_internal.h"
32 #include "internal.h"
33 #include "img2.h"
34 
35 typedef struct VideoMuxData {
36  const AVClass *class; /**< Class for private options. */
38  int split_planes; /**< use independent file for each Y, U, V plane */
39  char path[1024];
40  char tmp[4][1024];
41  char target[4][1024];
42  int update;
44  int frame_pts;
45  const char *muxer;
47 } VideoMuxData;
48 
50 {
52  AVStream *st = s->streams[0];
54 
55  av_strlcpy(img->path, s->url, sizeof(img->path));
56 
57  if (st->codecpar->codec_id == AV_CODEC_ID_GIF) {
58  img->muxer = "gif";
59  } else if (st->codecpar->codec_id == AV_CODEC_ID_FITS) {
60  img->muxer = "fits";
61  } else if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
62  const char *str = strrchr(img->path, '.');
63  img->split_planes = str
64  && !av_strcasecmp(str + 1, "y")
65  && s->nb_streams == 1
66  && desc
67  &&(desc->flags & AV_PIX_FMT_FLAG_PLANAR)
68  && desc->nb_components >= 3;
69  }
70 
71  return 0;
72 }
73 
75 {
78  AVStream *st;
79  AVPacket pkt2 = {0};
81  int ret;
82 
83  /* URL is not used directly as we are overriding the IO context later. */
84  ret = avformat_alloc_output_context2(&fmt, NULL, img->muxer, s->url);
85  if (ret < 0)
86  return ret;
87  st = avformat_new_stream(fmt, NULL);
88  if (!st) {
90  return AVERROR(ENOMEM);
91  }
92  st->id = pkt->stream_index;
93 
94  fmt->pb = pb;
95 
96  ret = av_packet_ref(&pkt2, pkt);
97  if (ret < 0)
98  goto out;
99  pkt2.stream_index = 0;
100 
101  if ((ret = avcodec_parameters_copy(st->codecpar, par)) < 0 ||
102  (ret = avformat_write_header(fmt, NULL)) < 0 ||
103  (ret = av_interleaved_write_frame(fmt, &pkt2)) < 0 ||
104  (ret = av_write_trailer(fmt))) {}
105 
106 out:
107  av_packet_unref(&pkt2);
109  return ret;
110 }
111 
113 {
114  VideoMuxData *img = s->priv_data;
115  if (img->muxer) {
116  int ret = write_muxed_file(s, s->pb, pkt);
117  if (ret < 0)
118  return ret;
119  } else {
120  avio_write(s->pb, pkt->data, pkt->size);
121  }
122  img->img_number++;
123  return 0;
124 }
125 
127 {
128  VideoMuxData *img = s->priv_data;
129  AVIOContext *pb[4] = {0};
130  char filename[1024];
133  int ret, i;
134  int nb_renames = 0;
135 
136  if (img->update) {
137  av_strlcpy(filename, img->path, sizeof(filename));
138  } else if (img->use_strftime) {
139  time_t now0;
140  struct tm *tm, tmpbuf;
141  time(&now0);
142  tm = localtime_r(&now0, &tmpbuf);
143  if (!strftime(filename, sizeof(filename), img->path, tm)) {
144  av_log(s, AV_LOG_ERROR, "Could not get frame filename with strftime\n");
145  return AVERROR(EINVAL);
146  }
147  } else if (img->frame_pts) {
148  if (av_get_frame_filename2(filename, sizeof(filename), img->path, pkt->pts, AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
149  av_log(s, AV_LOG_ERROR, "Cannot write filename by pts of the frames.");
150  return AVERROR(EINVAL);
151  }
152  } else if (av_get_frame_filename2(filename, sizeof(filename), img->path,
153  img->img_number,
155  img->img_number > 1) {
156  av_log(s, AV_LOG_ERROR,
157  "Could not get frame filename number %d from pattern '%s'. "
158  "Use '-frames:v 1' for a single image, or '-update' option, or use a pattern such as %%03d within the filename.\n",
159  img->img_number, img->path);
160  return AVERROR(EINVAL);
161  }
162  for (i = 0; i < 4; i++) {
163  snprintf(img->tmp[i], sizeof(img->tmp[i]), "%s.tmp", filename);
164  av_strlcpy(img->target[i], filename, sizeof(img->target[i]));
165  if (s->io_open(s, &pb[i], img->use_rename ? img->tmp[i] : filename, AVIO_FLAG_WRITE, NULL) < 0) {
166  av_log(s, AV_LOG_ERROR, "Could not open file : %s\n", img->use_rename ? img->tmp[i] : filename);
167  ret = AVERROR(EIO);
168  goto fail;
169  }
170 
171  if (!img->split_planes || i+1 >= desc->nb_components)
172  break;
173  filename[strlen(filename) - 1] = "UVAx"[i];
174  }
175  if (img->use_rename)
176  nb_renames = i + 1;
177 
178  if (img->split_planes) {
179  int ysize = par->width * par->height;
180  int usize = AV_CEIL_RSHIFT(par->width, desc->log2_chroma_w) * AV_CEIL_RSHIFT(par->height, desc->log2_chroma_h);
181  if (desc->comp[0].depth >= 9) {
182  ysize *= 2;
183  usize *= 2;
184  }
185  avio_write(pb[0], pkt->data , ysize);
186  avio_write(pb[1], pkt->data + ysize , usize);
187  avio_write(pb[2], pkt->data + ysize + usize, usize);
188  ff_format_io_close(s, &pb[1]);
189  ff_format_io_close(s, &pb[2]);
190  if (desc->nb_components > 3) {
191  avio_write(pb[3], pkt->data + ysize + 2*usize, ysize);
192  ff_format_io_close(s, &pb[3]);
193  }
194  } else if (img->muxer) {
195  ret = write_muxed_file(s, pb[0], pkt);
196  if (ret < 0)
197  goto fail;
198  } else {
199  avio_write(pb[0], pkt->data, pkt->size);
200  }
201  avio_flush(pb[0]);
202  ff_format_io_close(s, &pb[0]);
203  for (i = 0; i < nb_renames; i++) {
204  int ret = ff_rename(img->tmp[i], img->target[i], s);
205  if (ret < 0)
206  return ret;
207  }
208 
209  img->img_number++;
210  return 0;
211 
212 fail:
213  for (i = 0; i < FF_ARRAY_ELEMS(pb); i++)
214  if (pb[i])
215  ff_format_io_close(s, &pb[i]);
216  return ret;
217 }
218 
219 static int query_codec(enum AVCodecID id, int std_compliance)
220 {
221  int i;
222  for (i = 0; ff_img_tags[i].id != AV_CODEC_ID_NONE; i++)
223  if (ff_img_tags[i].id == id)
224  return 1;
225 
226  // Anything really can be stored in img2
227  return std_compliance < FF_COMPLIANCE_NORMAL;
228 }
229 
230 #define OFFSET(x) offsetof(VideoMuxData, x)
231 #define ENC AV_OPT_FLAG_ENCODING_PARAM
232 static const AVOption muxoptions[] = {
233  { "update", "continuously overwrite one file", OFFSET(update), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
234  { "start_number", "set first number in the sequence", OFFSET(img_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, INT_MAX, ENC },
235  { "strftime", "use strftime for filename", OFFSET(use_strftime), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
236  { "frame_pts", "use current frame pts for filename", OFFSET(frame_pts), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
237  { "atomic_writing", "write files atomically (using temporary files and renames)", OFFSET(use_rename), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
238  { NULL },
239 };
240 
241 #if CONFIG_IMAGE2_MUXER
242 static const AVClass img2mux_class = {
243  .class_name = "image2 muxer",
244  .item_name = av_default_item_name,
245  .option = muxoptions,
246  .version = LIBAVUTIL_VERSION_INT,
247 };
248 
250  .name = "image2",
251  .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
252  .extensions = "bmp,dpx,jls,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png,"
253  "ppm,sgi,tga,tif,tiff,jp2,j2c,j2k,xwd,sun,ras,rs,im1,im8,im24,"
254  "sunras,xbm,xface,pix,y",
255  .priv_data_size = sizeof(VideoMuxData),
256  .video_codec = AV_CODEC_ID_MJPEG,
261  .priv_class = &img2mux_class,
262 };
263 #endif
264 #if CONFIG_IMAGE2PIPE_MUXER
266  .name = "image2pipe",
267  .long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
268  .priv_data_size = sizeof(VideoMuxData),
269  .video_codec = AV_CODEC_ID_MJPEG,
274 };
275 #endif
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1939
#define NULL
Definition: coverity.c:32
AVOutputFormat ff_image2_muxer
Bytestream IO Context.
Definition: avio.h:161
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1199
AVOption.
Definition: opt.h:246
int use_strftime
Definition: img2enc.c:43
const char * fmt
Definition: avisynth_c.h:861
enum AVCodecID id
Definition: img2.h:68
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
const char * desc
Definition: nvenc.c:68
#define OFFSET(x)
Definition: img2enc.c:230
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3981
int size
Definition: avcodec.h:1494
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
static AVPacket pkt
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3973
Format I/O context.
Definition: avformat.h:1357
#define img
static int query_codec(enum AVCodecID id, int std_compliance)
Definition: img2enc.c:219
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:72
int use_rename
Definition: img2enc.c:46
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
int width
Video only.
Definition: avcodec.h:4047
AVOptions.
int id
Format-specific stream ID.
Definition: avformat.h:887
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5682
char path[1024]
Definition: img2enc.c:39
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4501
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1425
static const AVOption muxoptions[]
Definition: img2enc.c:232
uint8_t * data
Definition: avcodec.h:1493
static int write_header(AVFormatContext *s)
Definition: img2enc.c:49
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
#define av_log(a,...)
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:608
static int write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: img2enc.c:126
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2043
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
char * url
input or output URL.
Definition: avformat.h:1453
int frame_pts
Definition: img2enc.c:44
simple assert() macros that are a bit more flexible than ISO C assert().
int avformat_alloc_output_context2(AVFormatContext **ctx, ff_const59 AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:148
#define AV_FRAME_FILENAME_FLAGS_MULTIPLE
Allow multiple d.
Definition: avformat.h:2911
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:83
#define fail()
Definition: checkasm.h:122
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1413
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
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:516
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
const char * name
Definition: avformat.h:505
#define s(width, name)
Definition: cbs_vp9.c:257
char tmp[4][1024]
Definition: img2enc.c:40
char target[4][1024]
Definition: img2enc.c:41
#define FF_ARRAY_ELEMS(a)
Stream structure.
Definition: avformat.h:880
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:467
int img_number
Definition: img2enc.c:37
AVIOContext * pb
I/O context.
Definition: avformat.h:1399
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
Return in &#39;buf&#39; the path with &#39;d&#39; replaced by a number.
Definition: utils.c:4714
static int ff_rename(const char *oldpath, const char *newpath, void *logctx)
Wrap errno on rename() error.
Definition: internal.h:589
Describe the class of an AVClass context structure.
Definition: log.h:67
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2647
const IdStrMap ff_img_tags[]
Definition: img2.c:27
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
#define ENC
Definition: img2enc.c:231
#define snprintf
Definition: snprintf.h:34
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4432
#define flags(name, subs,...)
Definition: cbs_av1.c:561
Main libavformat public API header.
int update
Definition: img2enc.c:42
int split_planes
use independent file for each Y, U, V plane
Definition: img2enc.c:38
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
#define localtime_r
Definition: time_internal.h:46
AVOutputFormat ff_image2pipe_muxer
void * priv_data
Format private data.
Definition: avformat.h:1385
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:471
static int write_muxed_file(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Definition: img2enc.c:74
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1261
FILE * out
Definition: movenc.c:54
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1027
int stream_index
Definition: avcodec.h:1495
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
const char * muxer
Definition: img2enc.c:45
This structure stores compressed data.
Definition: avcodec.h:1470
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1486
static int write_packet_pipe(AVFormatContext *s, AVPacket *pkt)
Definition: img2enc.c:112
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58