2012-02-21 21:07:56 +00:00
|
|
|
/*
|
|
|
|
* Image format
|
|
|
|
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
|
|
|
|
* Copyright (c) 2004 Michael Niedermayer
|
|
|
|
*
|
2012-02-23 01:33:21 +00:00
|
|
|
* This file is part of FFmpeg.
|
2012-02-21 21:07:56 +00:00
|
|
|
*
|
2012-02-23 01:33:21 +00:00
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2012-02-21 21:07:56 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
2012-02-23 01:33:21 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2012-02-21 21:07:56 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2012-02-23 01:33:21 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2012-02-21 21:07:56 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "libavutil/intreadwrite.h"
|
2013-10-19 17:39:28 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2012-02-21 21:07:56 +00:00
|
|
|
#include "libavutil/avstring.h"
|
2019-12-27 00:19:17 +00:00
|
|
|
#include "libavutil/dict.h"
|
2012-02-21 21:07:56 +00:00
|
|
|
#include "libavutil/log.h"
|
2012-02-23 01:33:21 +00:00
|
|
|
#include "libavutil/opt.h"
|
2012-11-06 00:25:59 +00:00
|
|
|
#include "libavutil/pixdesc.h"
|
2014-11-02 19:09:16 +00:00
|
|
|
#include "libavutil/time_internal.h"
|
2012-02-21 21:07:56 +00:00
|
|
|
#include "avformat.h"
|
|
|
|
#include "avio_internal.h"
|
|
|
|
#include "internal.h"
|
2015-09-06 15:07:20 +00:00
|
|
|
#include "img2.h"
|
2012-02-21 21:07:56 +00:00
|
|
|
|
2014-09-22 07:19:33 +00:00
|
|
|
typedef struct VideoMuxData {
|
2012-02-23 01:33:21 +00:00
|
|
|
const AVClass *class; /**< Class for private options. */
|
2012-02-21 21:07:56 +00:00
|
|
|
int img_number;
|
2012-02-23 01:33:21 +00:00
|
|
|
int split_planes; /**< use independent file for each Y, U, V plane */
|
2012-02-21 21:07:56 +00:00
|
|
|
char path[1024];
|
2015-10-27 20:21:17 +00:00
|
|
|
char tmp[4][1024];
|
|
|
|
char target[4][1024];
|
2013-04-04 20:57:58 +00:00
|
|
|
int update;
|
2013-07-18 22:17:11 +00:00
|
|
|
int use_strftime;
|
2017-11-13 02:52:01 +00:00
|
|
|
int frame_pts;
|
2013-10-19 17:39:28 +00:00
|
|
|
const char *muxer;
|
2015-10-27 18:45:59 +00:00
|
|
|
int use_rename;
|
2019-12-27 00:19:17 +00:00
|
|
|
AVDictionary *protocol_opts;
|
2012-02-21 21:07:56 +00:00
|
|
|
} VideoMuxData;
|
|
|
|
|
|
|
|
static int write_header(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
VideoMuxData *img = s->priv_data;
|
2012-11-06 00:13:12 +00:00
|
|
|
AVStream *st = s->streams[0];
|
2016-04-10 19:58:15 +00:00
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(st->codecpar->format);
|
2012-02-21 21:07:56 +00:00
|
|
|
|
2017-12-29 22:30:14 +00:00
|
|
|
av_strlcpy(img->path, s->url, sizeof(img->path));
|
2012-02-21 21:07:56 +00:00
|
|
|
|
2016-04-10 19:58:15 +00:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_GIF) {
|
2013-10-19 17:39:28 +00:00
|
|
|
img->muxer = "gif";
|
2017-08-29 17:20:33 +00:00
|
|
|
} else if (st->codecpar->codec_id == AV_CODEC_ID_FITS) {
|
|
|
|
img->muxer = "fits";
|
2016-04-10 19:58:15 +00:00
|
|
|
} else if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
|
2013-10-19 17:39:28 +00:00
|
|
|
const char *str = strrchr(img->path, '.');
|
2013-11-07 19:22:25 +00:00
|
|
|
img->split_planes = str
|
|
|
|
&& !av_strcasecmp(str + 1, "y")
|
|
|
|
&& s->nb_streams == 1
|
|
|
|
&& desc
|
|
|
|
&&(desc->flags & AV_PIX_FMT_FLAG_PLANAR)
|
|
|
|
&& desc->nb_components >= 3;
|
2013-10-19 17:39:28 +00:00
|
|
|
}
|
2015-10-27 18:45:59 +00:00
|
|
|
|
2012-02-21 21:07:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-12-26 18:57:04 +00:00
|
|
|
static int write_muxed_file(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
VideoMuxData *img = s->priv_data;
|
2019-12-26 22:33:26 +00:00
|
|
|
AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
|
2019-12-26 18:57:04 +00:00
|
|
|
AVStream *st;
|
2019-12-01 09:04:02 +00:00
|
|
|
AVPacket pkt2;
|
2019-12-26 18:57:04 +00:00
|
|
|
AVFormatContext *fmt = NULL;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* URL is not used directly as we are overriding the IO context later. */
|
|
|
|
ret = avformat_alloc_output_context2(&fmt, NULL, img->muxer, s->url);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
st = avformat_new_stream(fmt, NULL);
|
|
|
|
if (!st) {
|
2019-12-01 09:04:02 +00:00
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto out;
|
2019-12-26 18:57:04 +00:00
|
|
|
}
|
|
|
|
st->id = pkt->stream_index;
|
|
|
|
|
|
|
|
fmt->pb = pb;
|
2019-12-26 21:58:45 +00:00
|
|
|
|
2019-12-26 22:33:26 +00:00
|
|
|
ret = av_packet_ref(&pkt2, pkt);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
pkt2.stream_index = 0;
|
|
|
|
|
|
|
|
if ((ret = avcodec_parameters_copy(st->codecpar, par)) < 0 ||
|
2019-12-26 18:57:04 +00:00
|
|
|
(ret = avformat_write_header(fmt, NULL)) < 0 ||
|
|
|
|
(ret = av_interleaved_write_frame(fmt, &pkt2)) < 0 ||
|
2019-12-26 21:58:45 +00:00
|
|
|
(ret = av_write_trailer(fmt))) {}
|
|
|
|
|
2019-12-26 18:57:04 +00:00
|
|
|
av_packet_unref(&pkt2);
|
2019-12-01 09:04:02 +00:00
|
|
|
out:
|
2019-12-26 18:57:04 +00:00
|
|
|
avformat_free_context(fmt);
|
2019-12-26 21:58:45 +00:00
|
|
|
return ret;
|
2019-12-26 18:57:04 +00:00
|
|
|
}
|
|
|
|
|
2019-12-26 19:51:19 +00:00
|
|
|
static int write_packet_pipe(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
VideoMuxData *img = s->priv_data;
|
|
|
|
if (img->muxer) {
|
|
|
|
int ret = write_muxed_file(s, s->pb, pkt);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
avio_write(s->pb, pkt->data, pkt->size);
|
|
|
|
}
|
|
|
|
img->img_number++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-21 21:07:56 +00:00
|
|
|
static int write_packet(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
VideoMuxData *img = s->priv_data;
|
2019-12-26 20:08:22 +00:00
|
|
|
AVIOContext *pb[4] = {0};
|
2012-02-21 21:07:56 +00:00
|
|
|
char filename[1024];
|
2016-11-01 21:58:01 +00:00
|
|
|
AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
|
2016-04-10 19:58:15 +00:00
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(par->format);
|
2019-12-26 18:57:04 +00:00
|
|
|
int ret, i;
|
2015-10-27 20:21:17 +00:00
|
|
|
int nb_renames = 0;
|
2019-12-27 00:19:17 +00:00
|
|
|
AVDictionary *options = NULL;
|
2012-02-21 21:07:56 +00:00
|
|
|
|
2019-12-26 19:54:14 +00:00
|
|
|
if (img->update) {
|
|
|
|
av_strlcpy(filename, img->path, sizeof(filename));
|
|
|
|
} else if (img->use_strftime) {
|
|
|
|
time_t now0;
|
|
|
|
struct tm *tm, tmpbuf;
|
|
|
|
time(&now0);
|
|
|
|
tm = localtime_r(&now0, &tmpbuf);
|
|
|
|
if (!strftime(filename, sizeof(filename), img->path, tm)) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Could not get frame filename with strftime\n");
|
2012-02-23 01:33:21 +00:00
|
|
|
return AVERROR(EINVAL);
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
2019-12-26 19:54:14 +00:00
|
|
|
} else if (img->frame_pts) {
|
|
|
|
if (av_get_frame_filename2(filename, sizeof(filename), img->path, pkt->pts, AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Cannot write filename by pts of the frames.");
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
} else if (av_get_frame_filename2(filename, sizeof(filename), img->path,
|
|
|
|
img->img_number,
|
|
|
|
AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0 &&
|
|
|
|
img->img_number > 1) {
|
|
|
|
av_log(s, AV_LOG_ERROR,
|
|
|
|
"Could not get frame filename number %d from pattern '%s'. "
|
|
|
|
"Use '-frames:v 1' for a single image, or '-update' option, or use a pattern such as %%03d within the filename.\n",
|
|
|
|
img->img_number, img->path);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
for (i = 0; i < 4; i++) {
|
2019-12-27 00:19:17 +00:00
|
|
|
av_dict_copy(&options, img->protocol_opts, 0);
|
2019-12-26 19:54:14 +00:00
|
|
|
snprintf(img->tmp[i], sizeof(img->tmp[i]), "%s.tmp", filename);
|
|
|
|
av_strlcpy(img->target[i], filename, sizeof(img->target[i]));
|
2019-12-27 00:19:17 +00:00
|
|
|
if (s->io_open(s, &pb[i], img->use_rename ? img->tmp[i] : filename, AVIO_FLAG_WRITE, &options) < 0) {
|
2019-12-26 19:54:14 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Could not open file : %s\n", img->use_rename ? img->tmp[i] : filename);
|
2019-12-26 20:08:22 +00:00
|
|
|
ret = AVERROR(EIO);
|
|
|
|
goto fail;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
2019-12-27 00:19:17 +00:00
|
|
|
if (options) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Could not recognize some protocol options\n");
|
|
|
|
ret = AVERROR(EINVAL);
|
|
|
|
goto fail;
|
|
|
|
}
|
2019-12-26 19:54:14 +00:00
|
|
|
|
|
|
|
if (!img->split_planes || i+1 >= desc->nb_components)
|
|
|
|
break;
|
|
|
|
filename[strlen(filename) - 1] = "UVAx"[i];
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
2019-12-26 19:54:14 +00:00
|
|
|
if (img->use_rename)
|
|
|
|
nb_renames = i + 1;
|
2012-02-21 21:07:56 +00:00
|
|
|
|
2012-11-30 13:49:13 +00:00
|
|
|
if (img->split_planes) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
int ysize = par->width * par->height;
|
2016-04-10 19:58:15 +00:00
|
|
|
int usize = AV_CEIL_RSHIFT(par->width, desc->log2_chroma_w) * AV_CEIL_RSHIFT(par->height, desc->log2_chroma_h);
|
2015-09-08 15:10:48 +00:00
|
|
|
if (desc->comp[0].depth >= 9) {
|
2012-11-06 01:27:04 +00:00
|
|
|
ysize *= 2;
|
|
|
|
usize *= 2;
|
|
|
|
}
|
2012-11-30 13:49:13 +00:00
|
|
|
avio_write(pb[0], pkt->data , ysize);
|
2012-11-06 00:27:09 +00:00
|
|
|
avio_write(pb[1], pkt->data + ysize , usize);
|
|
|
|
avio_write(pb[2], pkt->data + ysize + usize, usize);
|
2016-01-16 16:53:43 +00:00
|
|
|
ff_format_io_close(s, &pb[1]);
|
|
|
|
ff_format_io_close(s, &pb[2]);
|
2012-11-06 00:42:26 +00:00
|
|
|
if (desc->nb_components > 3) {
|
|
|
|
avio_write(pb[3], pkt->data + ysize + 2*usize, ysize);
|
2016-02-10 14:40:32 +00:00
|
|
|
ff_format_io_close(s, &pb[3]);
|
2012-11-06 00:42:26 +00:00
|
|
|
}
|
2013-10-19 17:39:28 +00:00
|
|
|
} else if (img->muxer) {
|
2019-12-26 18:57:04 +00:00
|
|
|
ret = write_muxed_file(s, pb[0], pkt);
|
2013-10-19 17:39:28 +00:00
|
|
|
if (ret < 0)
|
2019-12-26 20:08:22 +00:00
|
|
|
goto fail;
|
2012-11-30 13:49:13 +00:00
|
|
|
} else {
|
2012-02-21 21:07:56 +00:00
|
|
|
avio_write(pb[0], pkt->data, pkt->size);
|
|
|
|
}
|
|
|
|
avio_flush(pb[0]);
|
2019-12-26 19:54:14 +00:00
|
|
|
ff_format_io_close(s, &pb[0]);
|
|
|
|
for (i = 0; i < nb_renames; i++) {
|
|
|
|
int ret = ff_rename(img->tmp[i], img->target[i], s);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
img->img_number++;
|
|
|
|
return 0;
|
2019-12-26 20:08:22 +00:00
|
|
|
|
|
|
|
fail:
|
2019-12-27 00:19:17 +00:00
|
|
|
av_dict_free(&options);
|
2019-12-26 20:08:22 +00:00
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(pb); i++)
|
|
|
|
if (pb[i])
|
|
|
|
ff_format_io_close(s, &pb[i]);
|
|
|
|
return ret;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
|
2015-09-06 15:07:20 +00:00
|
|
|
static int query_codec(enum AVCodecID id, int std_compliance)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; ff_img_tags[i].id != AV_CODEC_ID_NONE; i++)
|
|
|
|
if (ff_img_tags[i].id == id)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
// Anything really can be stored in img2
|
|
|
|
return std_compliance < FF_COMPLIANCE_NORMAL;
|
|
|
|
}
|
|
|
|
|
2012-02-23 01:33:21 +00:00
|
|
|
#define OFFSET(x) offsetof(VideoMuxData, x)
|
|
|
|
#define ENC AV_OPT_FLAG_ENCODING_PARAM
|
|
|
|
static const AVOption muxoptions[] = {
|
2015-11-21 21:05:07 +00:00
|
|
|
{ "update", "continuously overwrite one file", OFFSET(update), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
|
2013-08-22 08:09:11 +00:00
|
|
|
{ "start_number", "set first number in the sequence", OFFSET(img_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, INT_MAX, ENC },
|
2015-11-21 21:05:07 +00:00
|
|
|
{ "strftime", "use strftime for filename", OFFSET(use_strftime), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
|
2017-11-13 02:52:01 +00:00
|
|
|
{ "frame_pts", "use current frame pts for filename", OFFSET(frame_pts), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
|
2016-02-11 01:01:29 +00:00
|
|
|
{ "atomic_writing", "write files atomically (using temporary files and renames)", OFFSET(use_rename), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
|
2019-12-27 00:19:17 +00:00
|
|
|
{ "protocol_opts", "specify protocol options for the opened files", OFFSET(protocol_opts), AV_OPT_TYPE_DICT, {0}, 0, 0, ENC },
|
2012-02-23 01:33:21 +00:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
2012-02-21 21:07:56 +00:00
|
|
|
#if CONFIG_IMAGE2_MUXER
|
2012-02-23 01:33:21 +00:00
|
|
|
static const AVClass img2mux_class = {
|
|
|
|
.class_name = "image2 muxer",
|
|
|
|
.item_name = av_default_item_name,
|
|
|
|
.option = muxoptions,
|
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
|
|
};
|
2012-06-23 03:53:43 +00:00
|
|
|
|
2012-02-21 21:07:56 +00:00
|
|
|
AVOutputFormat ff_image2_muxer = {
|
|
|
|
.name = "image2",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
|
2012-02-23 01:33:21 +00:00
|
|
|
.extensions = "bmp,dpx,jls,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png,"
|
2013-04-29 11:11:32 +00:00
|
|
|
"ppm,sgi,tga,tif,tiff,jp2,j2c,j2k,xwd,sun,ras,rs,im1,im8,im24,"
|
2014-11-01 23:52:29 +00:00
|
|
|
"sunras,xbm,xface,pix,y",
|
2012-02-21 21:07:56 +00:00
|
|
|
.priv_data_size = sizeof(VideoMuxData),
|
2012-08-05 09:11:04 +00:00
|
|
|
.video_codec = AV_CODEC_ID_MJPEG,
|
2012-02-21 21:07:56 +00:00
|
|
|
.write_header = write_header,
|
|
|
|
.write_packet = write_packet,
|
2015-09-06 15:07:20 +00:00
|
|
|
.query_codec = query_codec,
|
2012-02-23 01:33:21 +00:00
|
|
|
.flags = AVFMT_NOTIMESTAMPS | AVFMT_NODIMENSIONS | AVFMT_NOFILE,
|
|
|
|
.priv_class = &img2mux_class,
|
2012-02-21 21:07:56 +00:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
#if CONFIG_IMAGE2PIPE_MUXER
|
|
|
|
AVOutputFormat ff_image2pipe_muxer = {
|
|
|
|
.name = "image2pipe",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
|
|
|
|
.priv_data_size = sizeof(VideoMuxData),
|
2012-08-05 09:11:04 +00:00
|
|
|
.video_codec = AV_CODEC_ID_MJPEG,
|
2012-02-21 21:07:56 +00:00
|
|
|
.write_header = write_header,
|
2019-12-26 19:51:19 +00:00
|
|
|
.write_packet = write_packet_pipe,
|
2015-09-06 15:07:20 +00:00
|
|
|
.query_codec = query_codec,
|
2012-02-21 21:07:56 +00:00
|
|
|
.flags = AVFMT_NOTIMESTAMPS | AVFMT_NODIMENSIONS
|
|
|
|
};
|
|
|
|
#endif
|