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
|
|
|
|
*/
|
|
|
|
|
2022-02-23 12:56:49 +00:00
|
|
|
#include "config_components.h"
|
|
|
|
|
2015-10-03 12:41:00 +00:00
|
|
|
#define _DEFAULT_SOURCE
|
2013-05-25 13:34:27 +00:00
|
|
|
#define _BSD_SOURCE
|
2013-05-24 13:50:36 +00:00
|
|
|
#include <sys/stat.h>
|
2012-02-21 21:07:56 +00:00
|
|
|
#include "libavutil/avstring.h"
|
|
|
|
#include "libavutil/log.h"
|
|
|
|
#include "libavutil/opt.h"
|
|
|
|
#include "libavutil/pixdesc.h"
|
|
|
|
#include "libavutil/parseutils.h"
|
2014-06-21 19:43:19 +00:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2018-12-08 12:06:31 +00:00
|
|
|
#include "libavcodec/gif.h"
|
2012-02-21 21:07:56 +00:00
|
|
|
#include "avformat.h"
|
2014-07-04 01:42:30 +00:00
|
|
|
#include "avio_internal.h"
|
2012-02-21 21:07:56 +00:00
|
|
|
#include "internal.h"
|
2014-03-28 20:03:14 +00:00
|
|
|
#include "img2.h"
|
2022-04-17 13:22:36 +00:00
|
|
|
#include "jpegxl_probe.h"
|
2016-03-06 21:28:22 +00:00
|
|
|
#include "libavcodec/mjpeg.h"
|
2022-03-19 00:22:23 +00:00
|
|
|
#include "libavcodec/vbn.h"
|
2018-05-25 18:06:34 +00:00
|
|
|
#include "libavcodec/xwd.h"
|
2017-10-02 09:38:34 +00:00
|
|
|
#include "subtitles.h"
|
2012-02-27 09:27:17 +00:00
|
|
|
|
2014-03-28 20:03:14 +00:00
|
|
|
#if HAVE_GLOB
|
2012-02-27 09:27:17 +00:00
|
|
|
/* Locally define as 0 (bitwise-OR no-op) any missing glob options that
|
|
|
|
are non-posix glibc/bsd extensions. */
|
|
|
|
#ifndef GLOB_NOMAGIC
|
|
|
|
#define GLOB_NOMAGIC 0
|
|
|
|
#endif
|
|
|
|
#ifndef GLOB_BRACE
|
|
|
|
#define GLOB_BRACE 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif /* HAVE_GLOB */
|
2012-02-21 21:07:56 +00:00
|
|
|
|
|
|
|
static const int sizes[][2] = {
|
|
|
|
{ 640, 480 },
|
|
|
|
{ 720, 480 },
|
|
|
|
{ 720, 576 },
|
|
|
|
{ 352, 288 },
|
|
|
|
{ 352, 240 },
|
|
|
|
{ 160, 128 },
|
|
|
|
{ 512, 384 },
|
|
|
|
{ 640, 352 },
|
|
|
|
{ 640, 240 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static int infer_size(int *width_ptr, int *height_ptr, int size)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2012-11-29 03:56:40 +00:00
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(sizes); i++) {
|
2012-02-21 21:07:56 +00:00
|
|
|
if ((sizes[i][0] * sizes[i][1]) == size) {
|
2012-11-29 03:56:40 +00:00
|
|
|
*width_ptr = sizes[i][0];
|
2012-02-21 21:07:56 +00:00
|
|
|
*height_ptr = sizes[i][1];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2012-11-29 03:56:40 +00:00
|
|
|
|
2012-02-21 21:07:56 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-02-27 09:27:17 +00:00
|
|
|
static int is_glob(const char *path)
|
|
|
|
{
|
|
|
|
#if HAVE_GLOB
|
2012-03-11 14:24:51 +00:00
|
|
|
size_t span = 0;
|
|
|
|
const char *p = path;
|
|
|
|
|
|
|
|
while (p = strchr(p, '%')) {
|
|
|
|
if (*(++p) == '%') {
|
|
|
|
++p;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (span = strspn(p, "*?[]{}"))
|
|
|
|
break;
|
|
|
|
}
|
2012-02-27 09:27:17 +00:00
|
|
|
/* Did we hit a glob char or get to the end? */
|
2012-03-11 14:24:51 +00:00
|
|
|
return span != 0;
|
2012-02-27 09:27:17 +00:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-08-04 15:06:05 +00:00
|
|
|
/**
|
|
|
|
* Get index range of image files matched by path.
|
|
|
|
*
|
|
|
|
* @param pfirst_index pointer to index updated with the first number in the range
|
|
|
|
* @param plast_index pointer to index updated with the last number in the range
|
|
|
|
* @param path path which has to be matched by the image files in the range
|
|
|
|
* @param start_index minimum accepted value for the first index in the range
|
|
|
|
* @return -1 if no image file could be found
|
|
|
|
*/
|
2015-12-26 17:57:09 +00:00
|
|
|
static int find_image_range(AVIOContext *pb, int *pfirst_index, int *plast_index,
|
2012-08-05 08:04:02 +00:00
|
|
|
const char *path, int start_index, int start_index_range)
|
2012-02-21 21:07:56 +00:00
|
|
|
{
|
|
|
|
char buf[1024];
|
|
|
|
int range, last_index, range1, first_index;
|
|
|
|
|
|
|
|
/* find the first image */
|
2012-08-05 08:04:02 +00:00
|
|
|
for (first_index = start_index; first_index < start_index + start_index_range; first_index++) {
|
2012-11-29 03:56:40 +00:00
|
|
|
if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0) {
|
2012-02-21 21:07:56 +00:00
|
|
|
*pfirst_index =
|
2012-11-29 03:56:40 +00:00
|
|
|
*plast_index = 1;
|
2015-12-26 17:57:09 +00:00
|
|
|
if (pb || avio_check(buf, AVIO_FLAG_READ) > 0)
|
2012-02-21 21:07:56 +00:00
|
|
|
return 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (avio_check(buf, AVIO_FLAG_READ) > 0)
|
|
|
|
break;
|
|
|
|
}
|
2012-08-05 08:04:02 +00:00
|
|
|
if (first_index == start_index + start_index_range)
|
2012-02-21 21:07:56 +00:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* find the last image */
|
|
|
|
last_index = first_index;
|
2012-11-29 03:56:40 +00:00
|
|
|
for (;;) {
|
2012-02-21 21:07:56 +00:00
|
|
|
range = 0;
|
2012-11-29 03:56:40 +00:00
|
|
|
for (;;) {
|
2012-02-21 21:07:56 +00:00
|
|
|
if (!range)
|
|
|
|
range1 = 1;
|
|
|
|
else
|
|
|
|
range1 = 2 * range;
|
|
|
|
if (av_get_frame_filename(buf, sizeof(buf), path,
|
|
|
|
last_index + range1) < 0)
|
|
|
|
goto fail;
|
|
|
|
if (avio_check(buf, AVIO_FLAG_READ) <= 0)
|
|
|
|
break;
|
|
|
|
range = range1;
|
|
|
|
/* just in case... */
|
|
|
|
if (range >= (1 << 30))
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
/* we are sure than image last_index + range exists */
|
|
|
|
if (!range)
|
|
|
|
break;
|
|
|
|
last_index += range;
|
|
|
|
}
|
|
|
|
*pfirst_index = first_index;
|
2012-11-29 03:56:40 +00:00
|
|
|
*plast_index = last_index;
|
2012-02-21 21:07:56 +00:00
|
|
|
return 0;
|
2012-11-29 03:56:40 +00:00
|
|
|
|
|
|
|
fail:
|
2012-02-21 21:07:56 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int img_read_probe(const AVProbeData *p)
|
2012-02-21 21:07:56 +00:00
|
|
|
{
|
|
|
|
if (p->filename && ff_guess_image2_codec(p->filename)) {
|
|
|
|
if (av_filename_number_test(p->filename))
|
|
|
|
return AVPROBE_SCORE_MAX;
|
2012-02-27 09:27:17 +00:00
|
|
|
else if (is_glob(p->filename))
|
|
|
|
return AVPROBE_SCORE_MAX;
|
2014-10-05 01:42:32 +00:00
|
|
|
else if (p->filename[strcspn(p->filename, "*?{")]) // probably PT_GLOB
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 2; // score chosen to be a tad above the image pipes
|
2014-09-11 14:48:03 +00:00
|
|
|
else if (p->buf_size == 0)
|
|
|
|
return 0;
|
2012-11-30 08:58:57 +00:00
|
|
|
else if (av_match_ext(p->filename, "raw") || av_match_ext(p->filename, "gif"))
|
2012-10-10 19:40:03 +00:00
|
|
|
return 5;
|
2012-02-21 21:07:56 +00:00
|
|
|
else
|
2013-03-25 15:12:51 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-28 20:03:14 +00:00
|
|
|
int ff_img_read_header(AVFormatContext *s1)
|
2012-02-21 21:07:56 +00:00
|
|
|
{
|
|
|
|
VideoDemuxData *s = s1->priv_data;
|
2015-05-12 00:22:02 +00:00
|
|
|
int first_index = 1, last_index = 1;
|
2012-02-21 21:07:56 +00:00
|
|
|
AVStream *st;
|
2012-10-06 10:10:34 +00:00
|
|
|
enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;
|
2012-02-21 21:07:56 +00:00
|
|
|
|
|
|
|
s1->ctx_flags |= AVFMTCTX_NOHEADER;
|
|
|
|
|
|
|
|
st = avformat_new_stream(s1, NULL);
|
|
|
|
if (!st) {
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
|
|
|
|
2012-11-29 03:56:40 +00:00
|
|
|
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);
|
2012-02-21 21:07:56 +00:00
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
2017-12-29 22:30:14 +00:00
|
|
|
av_strlcpy(s->path, s1->url, sizeof(s->path));
|
2012-02-21 21:07:56 +00:00
|
|
|
s->img_number = 0;
|
2012-11-29 03:56:40 +00:00
|
|
|
s->img_count = 0;
|
2012-02-21 21:07:56 +00:00
|
|
|
|
|
|
|
/* find format */
|
|
|
|
if (s1->iformat->flags & AVFMT_NOFILE)
|
|
|
|
s->is_pipe = 0;
|
2012-11-29 03:56:40 +00:00
|
|
|
else {
|
|
|
|
s->is_pipe = 1;
|
2021-08-24 17:41:16 +00:00
|
|
|
ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
|
2013-05-25 13:34:27 +00:00
|
|
|
if (s->ts_from_file == 2) {
|
|
|
|
#if !HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
|
|
|
|
av_log(s1, AV_LOG_ERROR, "POSIX.1-2008 not supported, nanosecond file timestamps unavailable\n");
|
|
|
|
return AVERROR(ENOSYS);
|
|
|
|
#endif
|
|
|
|
avpriv_set_pts_info(st, 64, 1, 1000000000);
|
|
|
|
} else if (s->ts_from_file)
|
2013-05-25 13:33:44 +00:00
|
|
|
avpriv_set_pts_info(st, 64, 1, 1);
|
2020-10-07 11:02:39 +00:00
|
|
|
else {
|
2013-05-25 13:33:44 +00:00
|
|
|
avpriv_set_pts_info(st, 64, s->framerate.den, s->framerate.num);
|
2021-04-07 18:17:04 +00:00
|
|
|
st->avg_frame_rate = st->r_frame_rate = s->framerate;
|
2020-10-07 11:02:39 +00:00
|
|
|
}
|
2012-02-21 21:07:56 +00:00
|
|
|
|
2013-04-05 15:07:52 +00:00
|
|
|
if (s->width && s->height) {
|
2016-04-10 19:58:15 +00:00
|
|
|
st->codecpar->width = s->width;
|
|
|
|
st->codecpar->height = s->height;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!s->is_pipe) {
|
2016-01-20 10:21:44 +00:00
|
|
|
if (s->pattern_type == PT_DEFAULT) {
|
|
|
|
if (s1->pb) {
|
|
|
|
s->pattern_type = PT_NONE;
|
|
|
|
} else
|
|
|
|
s->pattern_type = PT_GLOB_SEQUENCE;
|
|
|
|
}
|
|
|
|
|
2012-08-06 12:54:06 +00:00
|
|
|
if (s->pattern_type == PT_GLOB_SEQUENCE) {
|
2012-02-27 09:27:17 +00:00
|
|
|
s->use_glob = is_glob(s->path);
|
|
|
|
if (s->use_glob) {
|
2015-01-20 21:03:18 +00:00
|
|
|
#if HAVE_GLOB
|
2012-03-11 14:24:51 +00:00
|
|
|
char *p = s->path, *q, *dup;
|
2012-02-27 09:27:17 +00:00
|
|
|
int gerr;
|
2015-01-20 21:03:18 +00:00
|
|
|
#endif
|
2012-03-11 14:24:51 +00:00
|
|
|
|
2012-08-06 12:54:06 +00:00
|
|
|
av_log(s1, AV_LOG_WARNING, "Pattern type 'glob_sequence' is deprecated: "
|
|
|
|
"use pattern_type 'glob' instead\n");
|
|
|
|
#if HAVE_GLOB
|
2012-03-11 14:24:51 +00:00
|
|
|
dup = q = av_strdup(p);
|
|
|
|
while (*q) {
|
|
|
|
/* Do we have room for the next char and a \ insertion? */
|
|
|
|
if ((p - s->path) >= (sizeof(s->path) - 2))
|
|
|
|
break;
|
|
|
|
if (*q == '%' && strspn(q + 1, "%*?[]{}"))
|
|
|
|
++q;
|
|
|
|
else if (strspn(q, "\\*?[]{}"))
|
|
|
|
*p++ = '\\';
|
|
|
|
*p++ = *q++;
|
|
|
|
}
|
|
|
|
*p = 0;
|
|
|
|
av_free(dup);
|
|
|
|
|
2012-03-29 22:35:01 +00:00
|
|
|
gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
|
2012-02-27 09:27:17 +00:00
|
|
|
if (gerr != 0) {
|
|
|
|
return AVERROR(ENOENT);
|
|
|
|
}
|
|
|
|
first_index = 0;
|
|
|
|
last_index = s->globstate.gl_pathc - 1;
|
|
|
|
#endif
|
2012-08-06 12:54:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((s->pattern_type == PT_GLOB_SEQUENCE && !s->use_glob) || s->pattern_type == PT_SEQUENCE) {
|
2015-12-26 17:57:09 +00:00
|
|
|
if (find_image_range(s1->pb, &first_index, &last_index, s->path,
|
2012-08-05 08:04:02 +00:00
|
|
|
s->start_number, s->start_number_range) < 0) {
|
2012-08-04 15:34:53 +00:00
|
|
|
av_log(s1, AV_LOG_ERROR,
|
2013-08-12 15:04:19 +00:00
|
|
|
"Could find no file with path '%s' and index in the range %d-%d\n",
|
2012-08-05 08:04:02 +00:00
|
|
|
s->path, s->start_number, s->start_number + s->start_number_range - 1);
|
2012-06-24 07:40:50 +00:00
|
|
|
return AVERROR(ENOENT);
|
2012-08-04 15:34:53 +00:00
|
|
|
}
|
2012-08-06 12:54:06 +00:00
|
|
|
} else if (s->pattern_type == PT_GLOB) {
|
|
|
|
#if HAVE_GLOB
|
|
|
|
int gerr;
|
|
|
|
gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
|
|
|
|
if (gerr != 0) {
|
|
|
|
return AVERROR(ENOENT);
|
|
|
|
}
|
|
|
|
first_index = 0;
|
|
|
|
last_index = s->globstate.gl_pathc - 1;
|
|
|
|
s->use_glob = 1;
|
|
|
|
#else
|
|
|
|
av_log(s1, AV_LOG_ERROR,
|
|
|
|
"Pattern type 'glob' was selected but globbing "
|
|
|
|
"is not supported by this libavformat build\n");
|
|
|
|
return AVERROR(ENOSYS);
|
|
|
|
#endif
|
2015-05-12 00:22:02 +00:00
|
|
|
} else if (s->pattern_type != PT_GLOB_SEQUENCE && s->pattern_type != PT_NONE) {
|
2012-08-06 12:54:06 +00:00
|
|
|
av_log(s1, AV_LOG_ERROR,
|
|
|
|
"Unknown value '%d' for pattern_type option\n", s->pattern_type);
|
|
|
|
return AVERROR(EINVAL);
|
2012-02-27 09:27:17 +00:00
|
|
|
}
|
2012-11-29 03:56:40 +00:00
|
|
|
s->img_first = first_index;
|
|
|
|
s->img_last = last_index;
|
2012-02-21 21:07:56 +00:00
|
|
|
s->img_number = first_index;
|
|
|
|
/* compute duration */
|
2013-05-25 10:05:32 +00:00
|
|
|
if (!s->ts_from_file) {
|
|
|
|
st->start_time = 0;
|
|
|
|
st->duration = last_index - first_index + 1;
|
|
|
|
}
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
|
2012-11-29 03:56:40 +00:00
|
|
|
if (s1->video_codec_id) {
|
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
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = s1->video_codec_id;
|
2012-11-29 03:56:40 +00:00
|
|
|
} else if (s1->audio_codec_id) {
|
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
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
st->codecpar->codec_id = s1->audio_codec_id;
|
2014-03-28 20:03:14 +00:00
|
|
|
} else if (s1->iformat->raw_codec_id) {
|
2016-04-10 19:58:15 +00:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = s1->iformat->raw_codec_id;
|
2012-11-29 03:56:40 +00:00
|
|
|
} else {
|
2012-11-30 13:49:13 +00:00
|
|
|
const char *str = strrchr(s->path, '.');
|
|
|
|
s->split_planes = str && !av_strcasecmp(str + 1, "y");
|
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
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
2014-06-21 19:43:19 +00:00
|
|
|
if (s1->pb) {
|
2014-07-04 02:54:32 +00:00
|
|
|
int probe_buffer_size = 2048;
|
2014-07-04 01:40:53 +00:00
|
|
|
uint8_t *probe_buffer = av_realloc(NULL, probe_buffer_size + AVPROBE_PADDING_SIZE);
|
2018-03-18 15:31:20 +00:00
|
|
|
const AVInputFormat *fmt = NULL;
|
|
|
|
void *fmt_iter = NULL;
|
2014-08-11 17:55:26 +00:00
|
|
|
AVProbeData pd = { 0 };
|
2014-07-04 01:40:53 +00:00
|
|
|
|
|
|
|
if (!probe_buffer)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
|
|
|
probe_buffer_size = avio_read(s1->pb, probe_buffer, probe_buffer_size);
|
|
|
|
if (probe_buffer_size < 0) {
|
|
|
|
av_free(probe_buffer);
|
|
|
|
return probe_buffer_size;
|
|
|
|
}
|
|
|
|
memset(probe_buffer + probe_buffer_size, 0, AVPROBE_PADDING_SIZE);
|
2014-06-21 19:43:19 +00:00
|
|
|
|
|
|
|
pd.buf = probe_buffer;
|
2014-07-04 01:43:02 +00:00
|
|
|
pd.buf_size = probe_buffer_size;
|
2017-12-29 22:30:14 +00:00
|
|
|
pd.filename = s1->url;
|
2014-06-21 19:43:19 +00:00
|
|
|
|
2018-03-18 15:31:20 +00:00
|
|
|
while ((fmt = av_demuxer_iterate(&fmt_iter))) {
|
2014-06-21 19:43:19 +00:00
|
|
|
if (fmt->read_header != ff_img_read_header ||
|
|
|
|
!fmt->read_probe ||
|
|
|
|
(fmt->flags & AVFMT_NOFILE) ||
|
|
|
|
!fmt->raw_codec_id)
|
|
|
|
continue;
|
|
|
|
if (fmt->read_probe(&pd) > 0) {
|
2016-04-10 19:58:15 +00:00
|
|
|
st->codecpar->codec_id = fmt->raw_codec_id;
|
2014-06-21 19:43:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-04-20 21:59:53 +00:00
|
|
|
if (s1->flags & AVFMT_FLAG_CUSTOM_IO) {
|
|
|
|
avio_seek(s1->pb, 0, SEEK_SET);
|
2019-06-12 19:20:04 +00:00
|
|
|
av_freep(&probe_buffer);
|
2015-04-20 21:59:53 +00:00
|
|
|
} else
|
|
|
|
ffio_rewind_with_probe_data(s1->pb, &probe_buffer, probe_buffer_size);
|
2014-06-21 19:43:19 +00:00
|
|
|
}
|
2016-04-10 19:58:15 +00:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
|
|
|
|
st->codecpar->codec_id = ff_guess_image2_codec(s->path);
|
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_LJPEG)
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_MJPEG;
|
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_ALIAS_PIX) // we cannot distingiush this from BRENDER_PIX
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_NONE;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
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
|
|
|
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
|
2012-11-29 03:56:40 +00:00
|
|
|
pix_fmt != AV_PIX_FMT_NONE)
|
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
|
|
|
st->codecpar->format = pix_fmt;
|
2012-02-21 21:07:56 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-01 16:57:02 +00:00
|
|
|
/**
|
|
|
|
* Add this frame's source path and basename to packet's sidedata
|
|
|
|
* as a dictionary, so it can be used by filters like 'drawtext'.
|
|
|
|
*/
|
|
|
|
static int add_filename_as_pkt_side_data(char *filename, AVPacket *pkt) {
|
|
|
|
AVDictionary *d = NULL;
|
|
|
|
char *packed_metadata = NULL;
|
2021-04-14 12:59:32 +00:00
|
|
|
size_t metadata_len;
|
2021-03-17 18:31:45 +00:00
|
|
|
int ret;
|
2020-01-01 16:57:02 +00:00
|
|
|
|
|
|
|
av_dict_set(&d, "lavf.image2dec.source_path", filename, 0);
|
|
|
|
av_dict_set(&d, "lavf.image2dec.source_basename", av_basename(filename), 0);
|
|
|
|
|
|
|
|
packed_metadata = av_packet_pack_dictionary(d, &metadata_len);
|
|
|
|
av_dict_free(&d);
|
|
|
|
if (!packed_metadata)
|
|
|
|
return AVERROR(ENOMEM);
|
2020-05-23 11:02:54 +00:00
|
|
|
ret = av_packet_add_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA,
|
|
|
|
packed_metadata, metadata_len);
|
|
|
|
if (ret < 0) {
|
2020-01-01 16:57:02 +00:00
|
|
|
av_freep(&packed_metadata);
|
2020-05-23 11:02:54 +00:00
|
|
|
return ret;
|
2020-01-01 16:57:02 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-28 20:03:14 +00:00
|
|
|
int ff_img_read_packet(AVFormatContext *s1, AVPacket *pkt)
|
2012-02-21 21:07:56 +00:00
|
|
|
{
|
|
|
|
VideoDemuxData *s = s1->priv_data;
|
2012-02-27 09:27:17 +00:00
|
|
|
char filename_bytes[1024];
|
|
|
|
char *filename = filename_bytes;
|
2014-10-20 13:11:15 +00:00
|
|
|
int i, res;
|
2012-11-29 03:56:40 +00:00
|
|
|
int size[3] = { 0 }, ret[3] = { 0 };
|
|
|
|
AVIOContext *f[3] = { NULL };
|
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
|
|
|
AVCodecParameters *par = s1->streams[0]->codecpar;
|
2012-02-21 21:07:56 +00:00
|
|
|
|
|
|
|
if (!s->is_pipe) {
|
|
|
|
/* loop over input */
|
|
|
|
if (s->loop && s->img_number > s->img_last) {
|
|
|
|
s->img_number = s->img_first;
|
|
|
|
}
|
|
|
|
if (s->img_number > s->img_last)
|
|
|
|
return AVERROR_EOF;
|
2015-05-12 00:22:02 +00:00
|
|
|
if (s->pattern_type == PT_NONE) {
|
|
|
|
av_strlcpy(filename_bytes, s->path, sizeof(filename_bytes));
|
|
|
|
} else if (s->use_glob) {
|
2012-02-27 09:27:17 +00:00
|
|
|
#if HAVE_GLOB
|
|
|
|
filename = s->globstate.gl_pathv[s->img_number];
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes),
|
2012-11-29 03:56:40 +00:00
|
|
|
s->path,
|
|
|
|
s->img_number) < 0 && s->img_number > 1)
|
2012-02-21 21:07:56 +00:00
|
|
|
return AVERROR(EIO);
|
2012-02-27 09:27:17 +00:00
|
|
|
}
|
2012-11-29 03:56:40 +00:00
|
|
|
for (i = 0; i < 3; i++) {
|
2015-12-26 18:38:13 +00:00
|
|
|
if (s1->pb &&
|
|
|
|
!strcmp(filename_bytes, s->path) &&
|
|
|
|
!s->loop &&
|
|
|
|
!s->split_planes) {
|
|
|
|
f[i] = s1->pb;
|
2016-02-10 14:40:32 +00:00
|
|
|
} else if (s1->io_open(s1, &f[i], filename, AVIO_FLAG_READ, NULL) < 0) {
|
2012-11-29 03:56:40 +00:00
|
|
|
if (i >= 1)
|
2012-02-21 21:07:56 +00:00
|
|
|
break;
|
2012-11-29 03:56:40 +00:00
|
|
|
av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",
|
|
|
|
filename);
|
2012-02-21 21:07:56 +00:00
|
|
|
return AVERROR(EIO);
|
|
|
|
}
|
2012-11-29 03:56:40 +00:00
|
|
|
size[i] = avio_size(f[i]);
|
2012-02-21 21:07:56 +00:00
|
|
|
|
2012-11-30 13:49:13 +00:00
|
|
|
if (!s->split_planes)
|
2012-02-21 21:07:56 +00:00
|
|
|
break;
|
2012-11-29 03:56:40 +00:00
|
|
|
filename[strlen(filename) - 1] = 'U' + i;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
|
2016-04-10 19:58:15 +00:00
|
|
|
if (par->codec_id == AV_CODEC_ID_NONE) {
|
2014-08-10 15:45:05 +00:00
|
|
|
AVProbeData pd = { 0 };
|
2019-03-20 17:52:38 +00:00
|
|
|
const AVInputFormat *ifmt;
|
2014-03-28 23:18:56 +00:00
|
|
|
uint8_t header[PROBE_BUF_MIN + AVPROBE_PADDING_SIZE];
|
2014-03-28 16:24:48 +00:00
|
|
|
int ret;
|
|
|
|
int score = 0;
|
|
|
|
|
2014-03-28 23:18:56 +00:00
|
|
|
ret = avio_read(f[0], header, PROBE_BUF_MIN);
|
2014-03-28 16:24:48 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2014-03-31 21:42:08 +00:00
|
|
|
memset(header + ret, 0, sizeof(header) - ret);
|
2014-03-28 16:24:48 +00:00
|
|
|
avio_skip(f[0], -ret);
|
|
|
|
pd.buf = header;
|
|
|
|
pd.buf_size = ret;
|
|
|
|
pd.filename = filename;
|
|
|
|
|
|
|
|
ifmt = av_probe_input_format3(&pd, 1, &score);
|
|
|
|
if (ifmt && ifmt->read_packet == ff_img_read_packet && ifmt->raw_codec_id)
|
2016-04-10 19:58:15 +00:00
|
|
|
par->codec_id = ifmt->raw_codec_id;
|
2014-03-28 16:24:48 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
if (par->codec_id == AV_CODEC_ID_RAWVIDEO && !par->width)
|
|
|
|
infer_size(&par->width, &par->height, size[0]);
|
2012-02-21 21:07:56 +00:00
|
|
|
} else {
|
|
|
|
f[0] = s1->pb;
|
2014-10-04 23:49:25 +00:00
|
|
|
if (avio_feof(f[0]) && s->loop && s->is_pipe)
|
|
|
|
avio_seek(f[0], 0, SEEK_SET);
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(f[0]))
|
2014-09-25 13:12:27 +00:00
|
|
|
return AVERROR_EOF;
|
2012-11-10 01:25:17 +00:00
|
|
|
if (s->frame_size > 0) {
|
|
|
|
size[0] = s->frame_size;
|
2021-08-24 17:41:16 +00:00
|
|
|
} else if (!ffstream(s1->streams[0])->parser) {
|
2014-06-21 19:43:19 +00:00
|
|
|
size[0] = avio_size(s1->pb);
|
2012-11-10 01:25:17 +00:00
|
|
|
} else {
|
2012-11-30 13:49:13 +00:00
|
|
|
size[0] = 4096;
|
2012-11-10 01:25:17 +00:00
|
|
|
}
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
|
2014-10-20 13:11:15 +00:00
|
|
|
res = av_new_packet(pkt, size[0] + size[1] + size[2]);
|
2015-09-29 13:25:07 +00:00
|
|
|
if (res < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-02-21 21:07:56 +00:00
|
|
|
pkt->stream_index = 0;
|
2012-11-29 03:56:40 +00:00
|
|
|
pkt->flags |= AV_PKT_FLAG_KEY;
|
2013-05-24 13:50:36 +00:00
|
|
|
if (s->ts_from_file) {
|
|
|
|
struct stat img_stat;
|
2015-09-29 13:25:07 +00:00
|
|
|
if (stat(filename, &img_stat)) {
|
|
|
|
res = AVERROR(EIO);
|
|
|
|
goto fail;
|
|
|
|
}
|
2013-05-24 13:50:36 +00:00
|
|
|
pkt->pts = (int64_t)img_stat.st_mtime;
|
2013-05-25 13:34:27 +00:00
|
|
|
#if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
|
|
|
|
if (s->ts_from_file == 2)
|
|
|
|
pkt->pts = 1000000000*pkt->pts + img_stat.st_mtim.tv_nsec;
|
|
|
|
#endif
|
2013-05-25 10:06:14 +00:00
|
|
|
av_add_index_entry(s1->streams[0], s->img_number, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
|
2013-05-24 13:50:36 +00:00
|
|
|
} else if (!s->is_pipe) {
|
2013-01-08 21:02:08 +00:00
|
|
|
pkt->pts = s->pts;
|
2013-05-24 13:50:36 +00:00
|
|
|
}
|
2012-02-21 21:07:56 +00:00
|
|
|
|
2014-09-25 15:06:33 +00:00
|
|
|
if (s->is_pipe)
|
|
|
|
pkt->pos = avio_tell(f[0]);
|
|
|
|
|
2020-01-01 16:57:02 +00:00
|
|
|
/*
|
|
|
|
* export_path_metadata must be explicitly enabled via
|
|
|
|
* command line options for path metadata to be exported
|
|
|
|
* as packet side_data.
|
|
|
|
*/
|
|
|
|
if (!s->is_pipe && s->export_path_metadata == 1) {
|
|
|
|
res = add_filename_as_pkt_side_data(filename, pkt);
|
|
|
|
if (res < 0)
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2012-11-29 03:56:40 +00:00
|
|
|
pkt->size = 0;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
if (f[i]) {
|
|
|
|
ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
|
2014-10-04 23:49:25 +00:00
|
|
|
if (s->loop && s->is_pipe && ret[i] == AVERROR_EOF) {
|
|
|
|
if (avio_seek(f[i], 0, SEEK_SET) >= 0) {
|
|
|
|
pkt->pos = 0;
|
|
|
|
ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
|
|
|
|
}
|
|
|
|
}
|
2015-12-26 18:38:13 +00:00
|
|
|
if (!s->is_pipe && f[i] != s1->pb)
|
2016-01-16 16:53:43 +00:00
|
|
|
ff_format_io_close(s1, &f[i]);
|
2012-11-29 03:56:40 +00:00
|
|
|
if (ret[i] > 0)
|
2012-02-21 21:07:56 +00:00
|
|
|
pkt->size += ret[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-29 03:56:40 +00:00
|
|
|
if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
|
2014-09-25 14:17:08 +00:00
|
|
|
if (ret[0] < 0) {
|
2015-09-29 13:25:07 +00:00
|
|
|
res = ret[0];
|
2014-09-25 14:17:08 +00:00
|
|
|
} else if (ret[1] < 0) {
|
2015-09-29 13:25:07 +00:00
|
|
|
res = ret[1];
|
|
|
|
} else if (ret[2] < 0) {
|
|
|
|
res = ret[2];
|
|
|
|
} else {
|
|
|
|
res = AVERROR_EOF;
|
|
|
|
}
|
|
|
|
goto fail;
|
2012-02-21 21:07:56 +00:00
|
|
|
} else {
|
|
|
|
s->img_count++;
|
|
|
|
s->img_number++;
|
2013-01-08 21:02:08 +00:00
|
|
|
s->pts++;
|
2012-02-21 21:07:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2015-09-29 13:25:07 +00:00
|
|
|
|
|
|
|
fail:
|
|
|
|
if (!s->is_pipe) {
|
|
|
|
for (i = 0; i < 3; i++) {
|
2015-12-26 18:38:13 +00:00
|
|
|
if (f[i] != s1->pb)
|
2016-02-10 14:40:32 +00:00
|
|
|
ff_format_io_close(s1, &f[i]);
|
2015-09-29 13:25:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return res;
|
2012-02-21 21:07:56 +00:00
|
|
|
}
|
|
|
|
|
2012-11-30 13:49:13 +00:00
|
|
|
static int img_read_close(struct AVFormatContext* s1)
|
2012-02-27 09:27:17 +00:00
|
|
|
{
|
|
|
|
#if HAVE_GLOB
|
2015-01-20 21:03:18 +00:00
|
|
|
VideoDemuxData *s = s1->priv_data;
|
2012-02-27 09:27:17 +00:00
|
|
|
if (s->use_glob) {
|
|
|
|
globfree(&s->globstate);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-01-08 11:43:07 +00:00
|
|
|
static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
|
|
|
|
{
|
|
|
|
VideoDemuxData *s1 = s->priv_data;
|
2013-05-25 10:06:14 +00:00
|
|
|
AVStream *st = s->streams[0];
|
|
|
|
|
|
|
|
if (s1->ts_from_file) {
|
|
|
|
int index = av_index_search_timestamp(st, timestamp, flags);
|
|
|
|
if(index < 0)
|
|
|
|
return -1;
|
2021-08-24 17:41:16 +00:00
|
|
|
s1->img_number = ffstream(st)->index_entries[index].pos;
|
2013-05-25 10:06:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2013-01-08 11:43:07 +00:00
|
|
|
|
2013-01-08 21:02:08 +00:00
|
|
|
if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first)
|
2013-01-08 11:43:07 +00:00
|
|
|
return -1;
|
2013-01-08 21:02:08 +00:00
|
|
|
s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first;
|
|
|
|
s1->pts = timestamp;
|
2013-01-08 11:43:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-21 21:07:56 +00:00
|
|
|
#define OFFSET(x) offsetof(VideoDemuxData, x)
|
|
|
|
#define DEC AV_OPT_FLAG_DECODING_PARAM
|
2019-02-10 16:56:01 +00:00
|
|
|
#define COMMON_OPTIONS \
|
|
|
|
{ "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC }, \
|
|
|
|
{ "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
|
|
|
|
{ "video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC }, \
|
2019-02-10 17:56:46 +00:00
|
|
|
{ "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
|
2019-02-10 16:56:01 +00:00
|
|
|
{ NULL },
|
|
|
|
|
|
|
|
#if CONFIG_IMAGE2_DEMUXER
|
2014-09-11 13:10:15 +00:00
|
|
|
const AVOption ff_img_options[] = {
|
2016-01-20 10:21:44 +00:00
|
|
|
{ "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_DEFAULT}, 0, INT_MAX, DEC, "pattern_type"},
|
2013-01-24 14:28:07 +00:00
|
|
|
{ "glob_sequence","select glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
|
|
|
|
{ "glob", "select glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB }, INT_MIN, INT_MAX, DEC, "pattern_type" },
|
|
|
|
{ "sequence", "select sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
|
2015-05-12 00:22:02 +00:00
|
|
|
{ "none", "disable pattern matching", 0, AV_OPT_TYPE_CONST, {.i64=PT_NONE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
|
2015-02-03 17:01:29 +00:00
|
|
|
{ "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, DEC },
|
2012-09-05 12:26:01 +00:00
|
|
|
{ "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 },
|
2013-05-25 13:34:27 +00:00
|
|
|
{ "ts_from_file", "set frame timestamp from file's one", OFFSET(ts_from_file), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, DEC, "ts_type" },
|
|
|
|
{ "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 2, DEC, "ts_type" },
|
2014-04-14 19:40:59 +00:00
|
|
|
{ "sec", "second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 2, DEC, "ts_type" },
|
|
|
|
{ "ns", "nano second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 2, DEC, "ts_type" },
|
2020-01-01 16:57:02 +00:00
|
|
|
{ "export_path_metadata", "enable metadata containing input path information", OFFSET(export_path_metadata), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
|
2019-02-10 16:56:01 +00:00
|
|
|
COMMON_OPTIONS
|
2012-02-21 21:07:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const AVClass img2_class = {
|
|
|
|
.class_name = "image2 demuxer",
|
|
|
|
.item_name = av_default_item_name,
|
2014-09-11 13:10:15 +00:00
|
|
|
.option = ff_img_options,
|
2012-02-21 21:07:56 +00:00
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
|
|
};
|
2021-04-19 17:45:24 +00:00
|
|
|
const AVInputFormat ff_image2_demuxer = {
|
2012-02-21 21:07:56 +00:00
|
|
|
.name = "image2",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
|
|
|
|
.priv_data_size = sizeof(VideoDemuxData),
|
2012-11-29 03:56:40 +00:00
|
|
|
.read_probe = img_read_probe,
|
2014-03-28 20:03:14 +00:00
|
|
|
.read_header = ff_img_read_header,
|
|
|
|
.read_packet = ff_img_read_packet,
|
2012-11-30 13:49:13 +00:00
|
|
|
.read_close = img_read_close,
|
2013-01-08 11:43:07 +00:00
|
|
|
.read_seek = img_read_seek,
|
2012-02-21 21:07:56 +00:00
|
|
|
.flags = AVFMT_NOFILE,
|
|
|
|
.priv_class = &img2_class,
|
|
|
|
};
|
|
|
|
#endif
|
2019-02-10 16:56:01 +00:00
|
|
|
|
2021-06-07 15:53:04 +00:00
|
|
|
static const AVOption img2pipe_options[] = {
|
2019-02-10 16:56:01 +00:00
|
|
|
{ "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
|
|
|
|
COMMON_OPTIONS
|
|
|
|
};
|
2021-07-08 19:31:19 +00:00
|
|
|
static const AVClass imagepipe_class = {
|
2021-06-07 14:13:33 +00:00
|
|
|
.class_name = "imagepipe demuxer",
|
2012-02-21 21:07:56 +00:00
|
|
|
.item_name = av_default_item_name,
|
2021-06-07 15:53:04 +00:00
|
|
|
.option = img2pipe_options,
|
2012-02-21 21:07:56 +00:00
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
|
|
};
|
2021-06-07 14:13:33 +00:00
|
|
|
|
|
|
|
#if CONFIG_IMAGE2PIPE_DEMUXER
|
2021-04-19 17:45:24 +00:00
|
|
|
const AVInputFormat ff_image2pipe_demuxer = {
|
2012-02-21 21:07:56 +00:00
|
|
|
.name = "image2pipe",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
|
|
|
|
.priv_data_size = sizeof(VideoDemuxData),
|
2014-03-28 20:03:14 +00:00
|
|
|
.read_header = ff_img_read_header,
|
|
|
|
.read_packet = ff_img_read_packet,
|
2021-07-08 19:31:19 +00:00
|
|
|
.priv_class = &imagepipe_class,
|
2012-02-21 21:07:56 +00:00
|
|
|
};
|
|
|
|
#endif
|
2014-06-21 19:43:19 +00:00
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int bmp_probe(const AVProbeData *p)
|
2014-06-21 19:43:19 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
2014-07-04 02:54:52 +00:00
|
|
|
int ihsize;
|
2014-06-21 19:43:19 +00:00
|
|
|
|
2014-07-04 02:54:52 +00:00
|
|
|
if (AV_RB16(b) != 0x424d)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ihsize = AV_RL32(b+14);
|
|
|
|
if (ihsize < 12 || ihsize > 255)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!AV_RN32(b + 6)) {
|
2014-10-03 11:54:06 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
2014-07-04 02:54:52 +00:00
|
|
|
}
|
2015-02-06 07:06:40 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION / 4;
|
2014-06-21 19:43:19 +00:00
|
|
|
}
|
|
|
|
|
2020-10-08 07:34:55 +00:00
|
|
|
static int cri_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if ( AV_RL32(b) == 1
|
|
|
|
&& AV_RL32(b + 4) == 4
|
|
|
|
&& AV_RN32(b + 8) == AV_RN32("DVCC"))
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int dds_probe(const AVProbeData *p)
|
2015-06-29 14:13:26 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if ( AV_RB64(b) == 0x444453207c000000
|
|
|
|
&& AV_RL32(b + 8)
|
|
|
|
&& AV_RL32(b + 12))
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int dpx_probe(const AVProbeData *p)
|
2014-06-21 19:43:19 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
2014-12-21 22:00:36 +00:00
|
|
|
int w, h;
|
|
|
|
int is_big = (AV_RN32(b) == AV_RN32("SDPX"));
|
2014-06-21 19:43:19 +00:00
|
|
|
|
2014-12-21 22:00:36 +00:00
|
|
|
if (p->buf_size < 0x304+8)
|
|
|
|
return 0;
|
|
|
|
w = is_big ? AV_RB32(p->buf + 0x304) : AV_RL32(p->buf + 0x304);
|
|
|
|
h = is_big ? AV_RB32(p->buf + 0x308) : AV_RL32(p->buf + 0x308);
|
|
|
|
if (w <= 0 || h <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (is_big || AV_RN32(b) == AV_RN32("XPDS"))
|
2014-06-21 19:43:19 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int exr_probe(const AVProbeData *p)
|
2014-06-21 19:43:19 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RL32(b) == 20000630)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int j2k_probe(const AVProbeData *p)
|
2014-07-04 00:10:26 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB64(b) == 0x0000000c6a502020 ||
|
|
|
|
AV_RB32(b) == 0xff4fff51)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int jpeg_probe(const AVProbeData *p)
|
2014-09-25 21:02:06 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
2021-11-25 19:36:46 +00:00
|
|
|
int i, state = SOI, got_header = 0;
|
2014-09-25 21:02:06 +00:00
|
|
|
|
|
|
|
if (AV_RB16(b) != 0xFFD8 ||
|
|
|
|
AV_RB32(b) == 0xFFD8FFF7)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
b += 2;
|
2015-09-12 17:00:02 +00:00
|
|
|
for (i = 0; i < p->buf_size - 3; i++) {
|
2014-09-25 21:02:06 +00:00
|
|
|
int c;
|
|
|
|
if (b[i] != 0xFF)
|
|
|
|
continue;
|
|
|
|
c = b[i + 1];
|
|
|
|
switch (c) {
|
2016-03-06 21:28:22 +00:00
|
|
|
case SOI:
|
2014-09-25 21:02:06 +00:00
|
|
|
return 0;
|
2016-03-06 21:28:22 +00:00
|
|
|
case SOF0:
|
|
|
|
case SOF1:
|
|
|
|
case SOF2:
|
|
|
|
case SOF3:
|
|
|
|
case SOF5:
|
|
|
|
case SOF6:
|
|
|
|
case SOF7:
|
2016-02-26 08:53:29 +00:00
|
|
|
i += AV_RB16(&b[i + 2]) + 1;
|
2016-03-06 21:28:22 +00:00
|
|
|
if (state != SOI)
|
2014-09-25 21:02:06 +00:00
|
|
|
return 0;
|
2016-03-06 21:28:22 +00:00
|
|
|
state = SOF0;
|
2014-09-25 21:02:06 +00:00
|
|
|
break;
|
2016-03-06 21:28:22 +00:00
|
|
|
case SOS:
|
2016-02-29 10:58:16 +00:00
|
|
|
i += AV_RB16(&b[i + 2]) + 1;
|
2016-03-06 21:28:22 +00:00
|
|
|
if (state != SOF0 && state != SOS)
|
2014-09-25 21:02:06 +00:00
|
|
|
return 0;
|
2016-03-06 21:28:22 +00:00
|
|
|
state = SOS;
|
2014-09-25 21:02:06 +00:00
|
|
|
break;
|
2016-03-06 21:28:22 +00:00
|
|
|
case EOI:
|
|
|
|
if (state != SOS)
|
2014-09-25 21:02:06 +00:00
|
|
|
return 0;
|
2016-03-06 21:28:22 +00:00
|
|
|
state = EOI;
|
2014-09-25 21:02:06 +00:00
|
|
|
break;
|
2016-09-03 11:38:16 +00:00
|
|
|
case DQT:
|
2016-03-06 21:28:22 +00:00
|
|
|
case APP0:
|
2021-11-25 19:36:46 +00:00
|
|
|
if (AV_RL32(&b[i + 4]) == MKTAG('J','F','I','F'))
|
|
|
|
got_header = 1;
|
2016-03-06 21:28:22 +00:00
|
|
|
case APP1:
|
2021-11-25 19:36:46 +00:00
|
|
|
if (AV_RL32(&b[i + 4]) == MKTAG('E','x','i','f'))
|
|
|
|
got_header = 1;
|
2016-03-06 21:28:22 +00:00
|
|
|
case APP2:
|
|
|
|
case APP3:
|
|
|
|
case APP4:
|
|
|
|
case APP5:
|
|
|
|
case APP6:
|
|
|
|
case APP7:
|
|
|
|
case APP8:
|
|
|
|
case APP9:
|
|
|
|
case APP10:
|
|
|
|
case APP11:
|
|
|
|
case APP12:
|
|
|
|
case APP13:
|
|
|
|
case APP14:
|
|
|
|
case APP15:
|
2016-03-22 10:13:24 +00:00
|
|
|
case COM:
|
2015-09-12 17:00:02 +00:00
|
|
|
i += AV_RB16(&b[i + 2]) + 1;
|
|
|
|
break;
|
2014-09-25 21:02:06 +00:00
|
|
|
default:
|
2016-03-06 21:28:22 +00:00
|
|
|
if ( (c > TEM && c < SOF0)
|
|
|
|
|| c == JPG)
|
2014-09-25 21:02:06 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-06 21:28:22 +00:00
|
|
|
if (state == EOI)
|
2014-09-25 21:02:06 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
2017-01-01 17:59:57 +00:00
|
|
|
if (state == SOS)
|
2021-11-25 19:36:46 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION / 2 + got_header;
|
2020-12-24 12:16:44 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION / 8 + 1;
|
2014-09-25 21:02:06 +00:00
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int jpegls_probe(const AVProbeData *p)
|
2014-08-08 19:19:29 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB32(b) == 0xffd8fff7)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-04-17 13:22:36 +00:00
|
|
|
static int jpegxl_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
/* ISOBMFF-based container */
|
|
|
|
/* 0x4a584c20 == "JXL " */
|
|
|
|
if (AV_RL64(b) == FF_JPEGXL_CONTAINER_SIGNATURE_LE)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
/* Raw codestreams all start with 0xff0a */
|
|
|
|
if (AV_RL16(b) != FF_JPEGXL_CODESTREAM_SIGNATURE_LE)
|
|
|
|
return 0;
|
|
|
|
#if CONFIG_IMAGE_JPEGXL_PIPE_DEMUXER
|
|
|
|
if (ff_jpegxl_verify_codestream_header(p->buf, p->buf_size) >= 0)
|
|
|
|
return AVPROBE_SCORE_MAX - 2;
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int pcx_probe(const AVProbeData *p)
|
2016-02-29 14:49:52 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if ( p->buf_size < 128
|
|
|
|
|| b[0] != 10
|
|
|
|
|| b[1] > 5
|
2016-07-15 08:26:27 +00:00
|
|
|
|| b[2] > 1
|
2016-02-29 14:49:52 +00:00
|
|
|
|| av_popcount(b[3]) != 1 || b[3] > 8
|
|
|
|
|| AV_RL16(&b[4]) > AV_RL16(&b[8])
|
|
|
|
|| AV_RL16(&b[6]) > AV_RL16(&b[10])
|
|
|
|
|| b[64])
|
|
|
|
return 0;
|
|
|
|
b += 73;
|
|
|
|
while (++b < p->buf + 128)
|
|
|
|
if (*b)
|
|
|
|
return AVPROBE_SCORE_EXTENSION / 4;
|
|
|
|
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int qdraw_probe(const AVProbeData *p)
|
2015-05-06 23:10:45 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
2015-06-29 14:25:11 +00:00
|
|
|
if ( p->buf_size >= 528
|
|
|
|
&& (AV_RB64(b + 520) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
|
|
|
|
&& AV_RB16(b + 520)
|
|
|
|
&& AV_RB16(b + 518))
|
|
|
|
return AVPROBE_SCORE_MAX * 3 / 4;
|
|
|
|
if ( (AV_RB64(b + 8) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
|
|
|
|
&& AV_RB16(b + 8)
|
|
|
|
&& AV_RB16(b + 6))
|
|
|
|
return AVPROBE_SCORE_EXTENSION / 4;
|
2015-05-06 23:10:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int pictor_probe(const AVProbeData *p)
|
2014-06-21 19:43:19 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RL16(b) == 0x1234)
|
|
|
|
return AVPROBE_SCORE_EXTENSION / 4;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int png_probe(const AVProbeData *p)
|
2014-06-21 19:43:19 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB64(b) == 0x89504e470d0a1a0a)
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int psd_probe(const AVProbeData *p)
|
2016-11-24 20:26:56 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
int ret = 0;
|
|
|
|
uint16_t color_mode;
|
|
|
|
|
|
|
|
if (AV_RL32(b) == MKTAG('8','B','P','S')) {
|
|
|
|
ret += 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((b[4] == 0) && (b[5] == 1)) {/* version 1 is PSD, version 2 is PSB */
|
|
|
|
ret += 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((AV_RL32(b+6) == 0) && (AV_RL16(b+10) == 0))/* reserved must be 0 */
|
|
|
|
ret += 1;
|
|
|
|
|
|
|
|
color_mode = AV_RB16(b+24);
|
|
|
|
if ((color_mode <= 9) && (color_mode != 5) && (color_mode != 6))
|
|
|
|
ret += 1;
|
|
|
|
|
2016-12-21 21:03:55 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION + ret;
|
2016-11-24 20:26:56 +00:00
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int sgi_probe(const AVProbeData *p)
|
2014-06-21 19:43:19 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB16(b) == 474 &&
|
|
|
|
(b[2] & ~1) == 0 &&
|
|
|
|
(b[3] & ~3) == 0 && b[3] &&
|
|
|
|
(AV_RB16(b + 4) & ~7) == 0 && AV_RB16(b + 4))
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int sunrast_probe(const AVProbeData *p)
|
2014-06-21 19:43:19 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB32(b) == 0x59a66a95)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int svg_probe(const AVProbeData *p)
|
2017-05-16 11:45:14 +00:00
|
|
|
{
|
2017-10-02 09:38:34 +00:00
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
const uint8_t *end = p->buf + p->buf_size;
|
2023-03-09 09:29:12 +00:00
|
|
|
while (b < end && av_isspace(*b))
|
|
|
|
b++;
|
|
|
|
if (b >= end - 5)
|
|
|
|
return 0;
|
|
|
|
if (!memcmp(b, "<svg", 4))
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
if (memcmp(p->buf, "<?xml", 5) && memcmp(b, "<!--", 4))
|
2017-10-02 09:38:34 +00:00
|
|
|
return 0;
|
|
|
|
while (b < end) {
|
2018-03-10 00:40:36 +00:00
|
|
|
int inc = ff_subtitles_next_line(b);
|
|
|
|
if (!inc)
|
|
|
|
break;
|
|
|
|
b += inc;
|
2017-10-02 09:38:34 +00:00
|
|
|
if (b >= end - 4)
|
|
|
|
return 0;
|
|
|
|
if (!memcmp(b, "<svg", 4))
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
}
|
2017-05-16 11:45:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int tiff_probe(const AVProbeData *p)
|
2014-06-21 19:43:19 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
2014-07-22 15:15:20 +00:00
|
|
|
if (AV_RB32(b) == 0x49492a00 ||
|
|
|
|
AV_RB32(b) == 0x4D4D002a)
|
2014-06-21 19:43:19 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int webp_probe(const AVProbeData *p)
|
2014-08-08 14:14:18 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB32(b) == 0x52494646 &&
|
|
|
|
AV_RB32(b + 8) == 0x57454250)
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-08 13:16:34 +00:00
|
|
|
static int pnm_magic_check(const AVProbeData *p, int magic)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
return b[0] == 'P' && b[1] == magic + '0';
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pnm_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
while (b[2] == '\r')
|
|
|
|
b++;
|
|
|
|
if (b[2] == '\n' && (b[3] == '#' || (b[3] >= '0' && b[3] <= '9')))
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 2;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int pbm_probe(const AVProbeData *p)
|
2016-06-08 13:16:34 +00:00
|
|
|
{
|
2022-07-01 08:06:15 +00:00
|
|
|
return pnm_magic_check(p, 1) || pnm_magic_check(p, 4) ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pfm_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 'F' - '0') ||
|
|
|
|
pnm_magic_check(p, 'f' - '0') ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int phm_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 'H' - '0') ||
|
|
|
|
pnm_magic_check(p, 'h' - '0') ? pnm_probe(p) : 0;
|
2016-06-08 13:16:34 +00:00
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static inline int pgmx_probe(const AVProbeData *p)
|
2016-06-08 13:16:34 +00:00
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 2) || pnm_magic_check(p, 5) ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int pgm_probe(const AVProbeData *p)
|
2016-06-08 13:16:34 +00:00
|
|
|
{
|
|
|
|
int ret = pgmx_probe(p);
|
|
|
|
return ret && !av_match_ext(p->filename, "pgmyuv") ? ret : 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int pgmyuv_probe(const AVProbeData *p) // custom FFmpeg format recognized by file extension
|
2016-06-08 13:16:34 +00:00
|
|
|
{
|
|
|
|
int ret = pgmx_probe(p);
|
|
|
|
return ret && av_match_ext(p->filename, "pgmyuv") ? ret : 0;
|
|
|
|
}
|
|
|
|
|
2020-07-02 19:19:39 +00:00
|
|
|
static int pgx_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
if (!memcmp(b, "PG ML ", 6))
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int ppm_probe(const AVProbeData *p)
|
2016-06-08 13:16:34 +00:00
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 3) || pnm_magic_check(p, 6) ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int pam_probe(const AVProbeData *p)
|
2016-06-08 13:16:34 +00:00
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 7) ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
2022-07-03 21:50:05 +00:00
|
|
|
static int hdr_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
if (!memcmp(p->buf, "#?RADIANCE\n", 11))
|
|
|
|
return AVPROBE_SCORE_MAX;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-02-03 12:52:00 +00:00
|
|
|
static int xbm_probe(const AVProbeData *p)
|
|
|
|
{
|
2021-02-05 21:33:32 +00:00
|
|
|
if (!memcmp(p->buf, "/* XBM X10 format */", 20))
|
|
|
|
return AVPROBE_SCORE_MAX;
|
|
|
|
|
2021-02-03 12:52:00 +00:00
|
|
|
if (!memcmp(p->buf, "#define", 7))
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int xpm_probe(const AVProbeData *p)
|
2017-03-11 21:01:23 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB64(b) == 0x2f2a2058504d202a && *(b+8) == '/')
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int xwd_probe(const AVProbeData *p)
|
2018-05-25 18:06:34 +00:00
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
unsigned width, bpp, bpad, lsize;
|
|
|
|
|
|
|
|
if ( p->buf_size < XWD_HEADER_SIZE
|
|
|
|
|| AV_RB32(b ) < XWD_HEADER_SIZE // header size
|
|
|
|
|| AV_RB32(b + 4) != XWD_VERSION // version
|
|
|
|
|| AV_RB32(b + 8) != XWD_Z_PIXMAP // format
|
|
|
|
|| AV_RB32(b + 12) > 32 || !AV_RB32(b + 12) // depth
|
|
|
|
|| AV_RB32(b + 16) == 0 // width
|
|
|
|
|| AV_RB32(b + 20) == 0 // height
|
|
|
|
|| AV_RB32(b + 28) > 1 // byteorder
|
|
|
|
|| AV_RB32(b + 32) & ~56 || av_popcount(AV_RB32(b + 32)) != 1 // bitmap unit
|
|
|
|
|| AV_RB32(b + 36) > 1 // bitorder
|
|
|
|
|| AV_RB32(b + 40) & ~56 || av_popcount(AV_RB32(b + 40)) != 1 // padding
|
|
|
|
|| AV_RB32(b + 44) > 32 || !AV_RB32(b + 44) // bpp
|
|
|
|
|| AV_RB32(b + 68) > 256) // colours
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
width = AV_RB32(b + 16);
|
|
|
|
bpad = AV_RB32(b + 40);
|
|
|
|
bpp = AV_RB32(b + 44);
|
|
|
|
lsize = AV_RB32(b + 48);
|
|
|
|
if (lsize < FFALIGN(width * bpp, bpad) >> 3)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return AVPROBE_SCORE_MAX / 2 + 1;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int gif_probe(const AVProbeData *p)
|
2018-12-08 12:06:31 +00:00
|
|
|
{
|
|
|
|
/* check magick */
|
|
|
|
if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* width or height contains zero? */
|
|
|
|
if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
}
|
|
|
|
|
2020-09-05 08:45:52 +00:00
|
|
|
static int photocd_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
if (!memcmp(p->buf, "PCD_OPA", 7))
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
|
|
|
|
if (p->buf_size < 0x807 || memcmp(p->buf + 0x800, "PCD_IPI", 7))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
}
|
|
|
|
|
2022-05-31 10:33:54 +00:00
|
|
|
static int qoi_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
if (memcmp(p->buf, "qoif", 4))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (AV_RB32(p->buf + 4) == 0 || AV_RB32(p->buf + 8) == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (p->buf[12] != 3 && p->buf[12] != 4)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (p->buf[13] > 1)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
}
|
|
|
|
|
2021-09-15 10:15:42 +00:00
|
|
|
static int gem_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
if ( AV_RB16(b ) >= 1 && AV_RB16(b ) <= 3 &&
|
|
|
|
AV_RB16(b + 2) >= 8 && AV_RB16(b + 2) <= 779 &&
|
2022-01-20 22:01:57 +00:00
|
|
|
(AV_RB16(b + 4) > 0 && AV_RB16(b + 4) <= 32) && /* planes */
|
|
|
|
(AV_RB16(b + 6) > 0 && AV_RB16(b + 6) <= 8) && /* pattern_size */
|
2021-09-15 10:15:42 +00:00
|
|
|
AV_RB16(b + 8) &&
|
|
|
|
AV_RB16(b + 10) &&
|
|
|
|
AV_RB16(b + 12) &&
|
|
|
|
AV_RB16(b + 14)) {
|
|
|
|
if (AV_RN32(b + 16) == AV_RN32("STTT") ||
|
|
|
|
AV_RN32(b + 16) == AV_RN32("TIMG") ||
|
|
|
|
AV_RN32(b + 16) == AV_RN32("XIMG"))
|
2022-01-23 04:46:34 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return AVPROBE_SCORE_EXTENSION / 4;
|
2021-09-15 10:15:42 +00:00
|
|
|
}
|
2022-01-23 04:46:34 +00:00
|
|
|
return 0;
|
2021-09-15 10:15:42 +00:00
|
|
|
}
|
|
|
|
|
2022-03-19 00:22:23 +00:00
|
|
|
static int vbn_probe(const AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
if (AV_RL32(b ) == VBN_MAGIC &&
|
|
|
|
AV_RL32(b + 4) == VBN_MAJOR &&
|
|
|
|
AV_RL32(b + 8) == VBN_MINOR)
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-01-06 17:37:12 +00:00
|
|
|
#define IMAGEAUTO_DEMUXER_0(imgname, codecid)
|
|
|
|
#define IMAGEAUTO_DEMUXER_1(imgname, codecid)\
|
2021-04-19 17:45:24 +00:00
|
|
|
const AVInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\
|
2014-06-21 19:43:19 +00:00
|
|
|
.name = AV_STRINGIFY(imgname) "_pipe",\
|
2014-07-22 01:32:03 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("piped " AV_STRINGIFY(imgname) " sequence"),\
|
2014-06-21 19:43:19 +00:00
|
|
|
.priv_data_size = sizeof(VideoDemuxData),\
|
|
|
|
.read_probe = imgname ## _probe,\
|
|
|
|
.read_header = ff_img_read_header,\
|
|
|
|
.read_packet = ff_img_read_packet,\
|
2021-07-08 19:31:19 +00:00
|
|
|
.priv_class = &imagepipe_class,\
|
2014-09-25 15:07:04 +00:00
|
|
|
.flags = AVFMT_GENERIC_INDEX, \
|
2014-06-21 19:43:19 +00:00
|
|
|
.raw_codec_id = codecid,\
|
|
|
|
};
|
|
|
|
|
2022-01-06 17:37:12 +00:00
|
|
|
#define IMAGEAUTO_DEMUXER_2(imgname, codecid, enabled) \
|
|
|
|
IMAGEAUTO_DEMUXER_ ## enabled(imgname, codecid)
|
|
|
|
#define IMAGEAUTO_DEMUXER_3(imgname, codecid, config) \
|
|
|
|
IMAGEAUTO_DEMUXER_2(imgname, codecid, config)
|
|
|
|
#define IMAGEAUTO_DEMUXER_EXT(imgname, codecid, uppercase_name) \
|
|
|
|
IMAGEAUTO_DEMUXER_3(imgname, AV_CODEC_ID_ ## codecid, \
|
|
|
|
CONFIG_IMAGE_ ## uppercase_name ## _PIPE_DEMUXER)
|
|
|
|
#define IMAGEAUTO_DEMUXER(imgname, codecid) \
|
|
|
|
IMAGEAUTO_DEMUXER_EXT(imgname, codecid, codecid)
|
|
|
|
|
|
|
|
IMAGEAUTO_DEMUXER(bmp, BMP)
|
|
|
|
IMAGEAUTO_DEMUXER(cri, CRI)
|
|
|
|
IMAGEAUTO_DEMUXER(dds, DDS)
|
|
|
|
IMAGEAUTO_DEMUXER(dpx, DPX)
|
|
|
|
IMAGEAUTO_DEMUXER(exr, EXR)
|
|
|
|
IMAGEAUTO_DEMUXER(gem, GEM)
|
|
|
|
IMAGEAUTO_DEMUXER(gif, GIF)
|
2022-07-16 20:40:44 +00:00
|
|
|
IMAGEAUTO_DEMUXER_EXT(hdr, RADIANCE_HDR, HDR)
|
2022-01-06 17:37:12 +00:00
|
|
|
IMAGEAUTO_DEMUXER_EXT(j2k, JPEG2000, J2K)
|
|
|
|
IMAGEAUTO_DEMUXER_EXT(jpeg, MJPEG, JPEG)
|
|
|
|
IMAGEAUTO_DEMUXER(jpegls, JPEGLS)
|
2022-04-17 13:22:36 +00:00
|
|
|
IMAGEAUTO_DEMUXER(jpegxl, JPEGXL)
|
2022-01-06 17:37:12 +00:00
|
|
|
IMAGEAUTO_DEMUXER(pam, PAM)
|
|
|
|
IMAGEAUTO_DEMUXER(pbm, PBM)
|
|
|
|
IMAGEAUTO_DEMUXER(pcx, PCX)
|
2022-07-01 08:06:15 +00:00
|
|
|
IMAGEAUTO_DEMUXER(pfm, PFM)
|
2022-01-06 17:37:12 +00:00
|
|
|
IMAGEAUTO_DEMUXER(pgm, PGM)
|
|
|
|
IMAGEAUTO_DEMUXER(pgmyuv, PGMYUV)
|
|
|
|
IMAGEAUTO_DEMUXER(pgx, PGX)
|
2022-07-01 08:06:15 +00:00
|
|
|
IMAGEAUTO_DEMUXER(phm, PHM)
|
2022-01-06 17:37:12 +00:00
|
|
|
IMAGEAUTO_DEMUXER(photocd, PHOTOCD)
|
|
|
|
IMAGEAUTO_DEMUXER(pictor, PICTOR)
|
|
|
|
IMAGEAUTO_DEMUXER(png, PNG)
|
|
|
|
IMAGEAUTO_DEMUXER(ppm, PPM)
|
|
|
|
IMAGEAUTO_DEMUXER(psd, PSD)
|
|
|
|
IMAGEAUTO_DEMUXER(qdraw, QDRAW)
|
2022-05-31 10:33:54 +00:00
|
|
|
IMAGEAUTO_DEMUXER(qoi, QOI)
|
2022-01-06 17:37:12 +00:00
|
|
|
IMAGEAUTO_DEMUXER(sgi, SGI)
|
|
|
|
IMAGEAUTO_DEMUXER(sunrast, SUNRAST)
|
|
|
|
IMAGEAUTO_DEMUXER(svg, SVG)
|
|
|
|
IMAGEAUTO_DEMUXER(tiff, TIFF)
|
2022-03-19 00:22:23 +00:00
|
|
|
IMAGEAUTO_DEMUXER(vbn, VBN)
|
2022-01-06 17:37:12 +00:00
|
|
|
IMAGEAUTO_DEMUXER(webp, WEBP)
|
|
|
|
IMAGEAUTO_DEMUXER(xbm, XBM)
|
|
|
|
IMAGEAUTO_DEMUXER(xpm, XPM)
|
|
|
|
IMAGEAUTO_DEMUXER(xwd, XWD)
|