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
|
|
|
|
*/
|
|
|
|
|
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"
|
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"
|
2016-03-06 21:28:22 +00:00
|
|
|
#include "libavcodec/mjpeg.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;
|
|
|
|
}
|
|
|
|
|
2012-11-29 03:56:40 +00:00
|
|
|
static int img_read_probe(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;
|
2012-02-21 21:07:56 +00:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_FULL;
|
|
|
|
}
|
|
|
|
|
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);
|
2013-05-24 13:50:36 +00:00
|
|
|
else
|
2013-05-25 13:33:44 +00:00
|
|
|
avpriv_set_pts_info(st, 64, s->framerate.den, s->framerate.num);
|
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);
|
|
|
|
} 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;
|
|
|
|
}
|
|
|
|
|
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 };
|
2014-03-28 16:24:48 +00:00
|
|
|
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;
|
2014-06-21 19:43:19 +00:00
|
|
|
} else if (!s1->streams[0]->parser) {
|
|
|
|
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]);
|
|
|
|
|
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) {
|
2015-10-23 09:11:31 +00:00
|
|
|
av_packet_unref(pkt);
|
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;
|
|
|
|
s1->img_number = st->index_entries[index].pos;
|
|
|
|
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
|
2014-09-11 13:10:15 +00:00
|
|
|
const AVOption ff_img_options[] = {
|
2016-06-09 03:00:52 +00:00
|
|
|
{ "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC },
|
2015-11-21 21:05:07 +00:00
|
|
|
{ "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC },
|
2012-08-06 12:54:06 +00:00
|
|
|
|
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" },
|
2012-08-06 12:54:06 +00:00
|
|
|
|
2012-11-30 13:49:13 +00:00
|
|
|
{ "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
|
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-04-05 15:07:52 +00:00
|
|
|
{ "video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC },
|
2012-11-30 13:49:13 +00:00
|
|
|
{ "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 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" },
|
2012-02-21 21:07:56 +00:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
#if CONFIG_IMAGE2_DEMUXER
|
|
|
|
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,
|
|
|
|
};
|
|
|
|
AVInputFormat ff_image2_demuxer = {
|
|
|
|
.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
|
|
|
|
#if CONFIG_IMAGE2PIPE_DEMUXER
|
|
|
|
static const AVClass img2pipe_class = {
|
|
|
|
.class_name = "image2pipe 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,
|
|
|
|
};
|
|
|
|
AVInputFormat ff_image2pipe_demuxer = {
|
|
|
|
.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,
|
2012-02-21 21:07:56 +00:00
|
|
|
.priv_class = &img2pipe_class,
|
|
|
|
};
|
|
|
|
#endif
|
2014-06-21 19:43:19 +00:00
|
|
|
|
|
|
|
static int bmp_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-06-29 14:13:26 +00:00
|
|
|
static int dds_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-06-21 19:43:19 +00:00
|
|
|
static int dpx_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int exr_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RL32(b) == 20000630)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-04 00:10:26 +00:00
|
|
|
static int j2k_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB64(b) == 0x0000000c6a502020 ||
|
|
|
|
AV_RB32(b) == 0xff4fff51)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-25 21:02:06 +00:00
|
|
|
static int jpeg_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
2016-03-06 21:28:22 +00:00
|
|
|
int i, state = SOI;
|
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:
|
|
|
|
case APP1:
|
|
|
|
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)
|
2017-01-27 07:31:07 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION / 2;
|
2014-09-25 21:02:06 +00:00
|
|
|
return AVPROBE_SCORE_EXTENSION / 8;
|
|
|
|
}
|
|
|
|
|
2014-08-08 19:19:29 +00:00
|
|
|
static int jpegls_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB32(b) == 0xffd8fff7)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-29 14:49:52 +00:00
|
|
|
static int pcx_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-05-06 23:10:45 +00:00
|
|
|
static int qdraw_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-06-21 19:43:19 +00:00
|
|
|
static int pictor_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RL16(b) == 0x1234)
|
|
|
|
return AVPROBE_SCORE_EXTENSION / 4;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int png_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB64(b) == 0x89504e470d0a1a0a)
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-24 20:26:56 +00:00
|
|
|
static int psd_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2014-06-21 19:43:19 +00:00
|
|
|
static int sgi_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sunrast_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB32(b) == 0x59a66a95)
|
|
|
|
return AVPROBE_SCORE_EXTENSION + 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-16 11:45:14 +00:00
|
|
|
static int svg_probe(AVProbeData *p)
|
|
|
|
{
|
2017-10-02 09:38:34 +00:00
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
const uint8_t *end = p->buf + p->buf_size;
|
2018-03-10 00:40:36 +00:00
|
|
|
|
2017-10-02 09:38:34 +00:00
|
|
|
if (memcmp(p->buf, "<?xml", 5))
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-06-21 19:43:19 +00:00
|
|
|
static int tiff_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-08-08 14:14:18 +00:00
|
|
|
static int webp_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pbm_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 1) || pnm_magic_check(p, 4) ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pgmx_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 2) || pnm_magic_check(p, 5) ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pgm_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
int ret = pgmx_probe(p);
|
|
|
|
return ret && !av_match_ext(p->filename, "pgmyuv") ? ret : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pgmyuv_probe(AVProbeData *p) // custom FFmpeg format recognized by file extension
|
|
|
|
{
|
|
|
|
int ret = pgmx_probe(p);
|
|
|
|
return ret && av_match_ext(p->filename, "pgmyuv") ? ret : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ppm_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 3) || pnm_magic_check(p, 6) ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pam_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
return pnm_magic_check(p, 7) ? pnm_probe(p) : 0;
|
|
|
|
}
|
|
|
|
|
2017-03-11 21:01:23 +00:00
|
|
|
static int xpm_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
const uint8_t *b = p->buf;
|
|
|
|
|
|
|
|
if (AV_RB64(b) == 0x2f2a2058504d202a && *(b+8) == '/')
|
|
|
|
return AVPROBE_SCORE_MAX - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-05-25 18:06:34 +00:00
|
|
|
static int xwd_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-06-21 19:43:19 +00:00
|
|
|
#define IMAGEAUTO_DEMUXER(imgname, codecid)\
|
|
|
|
static const AVClass imgname ## _class = {\
|
|
|
|
.class_name = AV_STRINGIFY(imgname) " demuxer",\
|
|
|
|
.item_name = av_default_item_name,\
|
2014-09-11 13:10:15 +00:00
|
|
|
.option = ff_img_options,\
|
2014-06-21 19:43:19 +00:00
|
|
|
.version = LIBAVUTIL_VERSION_INT,\
|
|
|
|
};\
|
|
|
|
AVInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\
|
|
|
|
.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,\
|
|
|
|
.priv_class = & imgname ## _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,\
|
|
|
|
};
|
|
|
|
|
|
|
|
IMAGEAUTO_DEMUXER(bmp, AV_CODEC_ID_BMP)
|
2015-06-29 14:13:26 +00:00
|
|
|
IMAGEAUTO_DEMUXER(dds, AV_CODEC_ID_DDS)
|
2014-06-21 19:43:19 +00:00
|
|
|
IMAGEAUTO_DEMUXER(dpx, AV_CODEC_ID_DPX)
|
|
|
|
IMAGEAUTO_DEMUXER(exr, AV_CODEC_ID_EXR)
|
2014-07-04 00:10:26 +00:00
|
|
|
IMAGEAUTO_DEMUXER(j2k, AV_CODEC_ID_JPEG2000)
|
2014-09-25 21:02:06 +00:00
|
|
|
IMAGEAUTO_DEMUXER(jpeg, AV_CODEC_ID_MJPEG)
|
2014-08-08 19:19:29 +00:00
|
|
|
IMAGEAUTO_DEMUXER(jpegls, AV_CODEC_ID_JPEGLS)
|
2016-06-08 13:16:34 +00:00
|
|
|
IMAGEAUTO_DEMUXER(pam, AV_CODEC_ID_PAM)
|
|
|
|
IMAGEAUTO_DEMUXER(pbm, AV_CODEC_ID_PBM)
|
2016-02-29 14:49:52 +00:00
|
|
|
IMAGEAUTO_DEMUXER(pcx, AV_CODEC_ID_PCX)
|
2016-06-08 13:16:34 +00:00
|
|
|
IMAGEAUTO_DEMUXER(pgm, AV_CODEC_ID_PGM)
|
|
|
|
IMAGEAUTO_DEMUXER(pgmyuv, AV_CODEC_ID_PGMYUV)
|
2014-06-21 19:43:19 +00:00
|
|
|
IMAGEAUTO_DEMUXER(pictor, AV_CODEC_ID_PICTOR)
|
|
|
|
IMAGEAUTO_DEMUXER(png, AV_CODEC_ID_PNG)
|
2016-06-08 13:16:34 +00:00
|
|
|
IMAGEAUTO_DEMUXER(ppm, AV_CODEC_ID_PPM)
|
2016-11-24 20:26:56 +00:00
|
|
|
IMAGEAUTO_DEMUXER(psd, AV_CODEC_ID_PSD)
|
2015-05-06 23:10:45 +00:00
|
|
|
IMAGEAUTO_DEMUXER(qdraw, AV_CODEC_ID_QDRAW)
|
2014-06-21 19:43:19 +00:00
|
|
|
IMAGEAUTO_DEMUXER(sgi, AV_CODEC_ID_SGI)
|
|
|
|
IMAGEAUTO_DEMUXER(sunrast, AV_CODEC_ID_SUNRAST)
|
2017-05-16 11:45:14 +00:00
|
|
|
IMAGEAUTO_DEMUXER(svg, AV_CODEC_ID_SVG)
|
2014-06-21 19:43:19 +00:00
|
|
|
IMAGEAUTO_DEMUXER(tiff, AV_CODEC_ID_TIFF)
|
2014-08-08 14:14:18 +00:00
|
|
|
IMAGEAUTO_DEMUXER(webp, AV_CODEC_ID_WEBP)
|
2017-03-11 21:01:23 +00:00
|
|
|
IMAGEAUTO_DEMUXER(xpm, AV_CODEC_ID_XPM)
|
2018-05-25 18:06:34 +00:00
|
|
|
IMAGEAUTO_DEMUXER(xwd, AV_CODEC_ID_XWD)
|