FFmpeg
format.c
Go to the documentation of this file.
1 /*
2  * Format register and lookup
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "config_components.h"
23 
24 #include "libavutil/avstring.h"
25 #include "libavutil/bprint.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/thread.h"
28 
29 #include "avio_internal.h"
30 #include "avformat.h"
31 #include "demux.h"
32 #include "id3v2.h"
33 #include "internal.h"
34 #include "url.h"
35 
36 
37 /**
38  * @file
39  * Format register and lookup
40  */
41 
42 int av_match_ext(const char *filename, const char *extensions)
43 {
44  const char *ext;
45 
46  if (!filename)
47  return 0;
48 
49  ext = strrchr(filename, '.');
50  if (ext)
51  return av_match_name(ext + 1, extensions);
52  return 0;
53 }
54 
55 int ff_match_url_ext(const char *url, const char *extensions)
56 {
57  const char *ext;
58  URLComponents uc;
59  int ret;
60  char scratchpad[128];
61 
62  if (!url)
63  return 0;
64 
65  ret = ff_url_decompose(&uc, url, NULL);
66  if (ret < 0 || !URL_COMPONENT_HAVE(uc, scheme))
67  return ret;
68  for (ext = uc.query; *ext != '.' && ext > uc.path; ext--)
69  ;
70 
71  if (*ext != '.')
72  return 0;
73  if (uc.query - ext > sizeof(scratchpad))
74  return AVERROR(ENOMEM); //not enough memory in our scratchpad
75  av_strlcpy(scratchpad, ext + 1, uc.query - ext);
76 
77  return av_match_name(scratchpad, extensions);
78 }
79 
80 const AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
81  const char *mime_type)
82 {
83  const AVOutputFormat *fmt = NULL;
84  const AVOutputFormat *fmt_found = NULL;
85  void *i = 0;
86  int score_max, score;
87 
88  /* specific test for image sequences */
89 #if CONFIG_IMAGE2_MUXER
90  if (!short_name && filename &&
91  av_filename_number_test(filename) &&
93  return av_guess_format("image2", NULL, NULL);
94  }
95 #endif
96  /* Find the proper file type. */
97  score_max = 0;
98  while ((fmt = av_muxer_iterate(&i))) {
99  score = 0;
100  if (fmt->name && short_name && av_match_name(short_name, fmt->name))
101  score += 100;
102  if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
103  score += 10;
104  if (filename && fmt->extensions &&
105  av_match_ext(filename, fmt->extensions)) {
106  score += 5;
107  }
108  if (score > score_max) {
109  score_max = score;
110  fmt_found = fmt;
111  }
112  }
113  return fmt_found;
114 }
115 
116 enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
117  const char *filename, const char *mime_type,
118  enum AVMediaType type)
119 {
120  if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) {
121  const AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
122  if (fmt2)
123  fmt = fmt2;
124  }
125 
126  if (type == AVMEDIA_TYPE_VIDEO) {
128 
129 #if CONFIG_IMAGE2_MUXER || CONFIG_IMAGE2PIPE_MUXER
130  if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {
131  codec_id = ff_guess_image2_codec(filename);
132  }
133 #endif
134  if (codec_id == AV_CODEC_ID_NONE)
135  codec_id = fmt->video_codec;
136  return codec_id;
137  } else if (type == AVMEDIA_TYPE_AUDIO)
138  return fmt->audio_codec;
139  else if (type == AVMEDIA_TYPE_SUBTITLE)
140  return fmt->subtitle_codec;
141  else
142  return AV_CODEC_ID_NONE;
143 }
144 
145 const AVInputFormat *av_find_input_format(const char *short_name)
146 {
147  const AVInputFormat *fmt = NULL;
148  void *i = 0;
149  while ((fmt = av_demuxer_iterate(&i)))
150  if (av_match_name(short_name, fmt->name))
151  return fmt;
152  return NULL;
153 }
154 
156  int is_opened, int *score_ret)
157 {
158  AVProbeData lpd = *pd;
159  const AVInputFormat *fmt1 = NULL;
160  const AVInputFormat *fmt = NULL;
161  int score, score_max = 0;
162  void *i = 0;
163  const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
164  enum nodat {
165  NO_ID3,
166  ID3_ALMOST_GREATER_PROBE,
167  ID3_GREATER_PROBE,
168  ID3_GREATER_MAX_PROBE,
169  } nodat = NO_ID3;
170 
171  if (!lpd.buf)
172  lpd.buf = (unsigned char *) zerobuffer;
173 
174  if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
175  int id3len = ff_id3v2_tag_len(lpd.buf);
176  if (lpd.buf_size > id3len + 16) {
177  if (lpd.buf_size < 2LL*id3len + 16)
178  nodat = ID3_ALMOST_GREATER_PROBE;
179  lpd.buf += id3len;
180  lpd.buf_size -= id3len;
181  } else if (id3len >= PROBE_BUF_MAX) {
182  nodat = ID3_GREATER_MAX_PROBE;
183  } else
184  nodat = ID3_GREATER_PROBE;
185  }
186 
187  while ((fmt1 = av_demuxer_iterate(&i))) {
188  if (fmt1->flags & AVFMT_EXPERIMENTAL)
189  continue;
190  if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
191  continue;
192  score = 0;
193  if (ffifmt(fmt1)->read_probe) {
194  score = ffifmt(fmt1)->read_probe(&lpd);
195  if (score)
196  av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
197  if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
198  switch (nodat) {
199  case NO_ID3:
200  score = FFMAX(score, 1);
201  break;
202  case ID3_GREATER_PROBE:
203  case ID3_ALMOST_GREATER_PROBE:
204  score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
205  break;
206  case ID3_GREATER_MAX_PROBE:
207  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
208  break;
209  }
210  }
211  } else if (fmt1->extensions) {
212  if (av_match_ext(lpd.filename, fmt1->extensions))
213  score = AVPROBE_SCORE_EXTENSION;
214  }
215  if (av_match_name(lpd.mime_type, fmt1->mime_type)) {
216  if (AVPROBE_SCORE_MIME > score) {
217  av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME);
218  score = AVPROBE_SCORE_MIME;
219  }
220  }
221  if (score > score_max) {
222  score_max = score;
223  fmt = fmt1;
224  } else if (score == score_max)
225  fmt = NULL;
226  }
227  if (nodat == ID3_GREATER_PROBE)
228  score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
229  *score_ret = score_max;
230 
231  return fmt;
232 }
233 
235  int is_opened, int *score_max)
236 {
237  int score_ret;
238  const AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
239  if (score_ret > *score_max) {
240  *score_max = score_ret;
241  return fmt;
242  } else
243  return NULL;
244 }
245 
246 const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened)
247 {
248  int score = 0;
249  return av_probe_input_format2(pd, is_opened, &score);
250 }
251 
253  const char *filename, void *logctx,
254  unsigned int offset, unsigned int max_probe_size)
255 {
256  AVProbeData pd = { filename ? filename : "" };
257  uint8_t *buf = NULL;
258  int ret = 0, probe_size, buf_offset = 0;
259  int score = 0;
260  int ret2;
261  int eof = 0;
262 
263  if (!max_probe_size)
264  max_probe_size = PROBE_BUF_MAX;
265  else if (max_probe_size < PROBE_BUF_MIN) {
266  av_log(logctx, AV_LOG_ERROR,
267  "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
268  return AVERROR(EINVAL);
269  }
270 
271  if (offset >= max_probe_size)
272  return AVERROR(EINVAL);
273 
274  if (pb->av_class) {
275  uint8_t *mime_type_opt = NULL;
276  char *semi;
277  av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
278  pd.mime_type = (const char *)mime_type_opt;
279  semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
280  if (semi) {
281  *semi = '\0';
282  }
283  }
284 
285  for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt && !eof;
286  probe_size = FFMIN(probe_size << 1,
287  FFMAX(max_probe_size, probe_size + 1))) {
288  score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
289 
290  /* Read probe data. */
291  if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
292  goto fail;
293  if ((ret = avio_read(pb, buf + buf_offset,
294  probe_size - buf_offset)) < 0) {
295  /* Fail if error was not end of file, otherwise, lower score. */
296  if (ret != AVERROR_EOF)
297  goto fail;
298 
299  score = 0;
300  ret = 0; /* error was end of file, nothing read */
301  eof = 1;
302  }
303  buf_offset += ret;
304  if (buf_offset < offset)
305  continue;
306  pd.buf_size = buf_offset - offset;
307  pd.buf = &buf[offset];
308 
309  memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
310 
311  /* Guess file format. */
312  *fmt = av_probe_input_format2(&pd, 1, &score);
313  if (*fmt) {
314  /* This can only be true in the last iteration. */
315  if (score <= AVPROBE_SCORE_RETRY) {
316  av_log(logctx, AV_LOG_WARNING,
317  "Format %s detected only with low score of %d, "
318  "misdetection possible!\n", (*fmt)->name, score);
319  } else
320  av_log(logctx, AV_LOG_DEBUG,
321  "Format %s probed with size=%d and score=%d\n",
322  (*fmt)->name, probe_size, score);
323 #if 0
324  FILE *f = fopen("probestat.tmp", "ab");
325  fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
326  fclose(f);
327 #endif
328  }
329  }
330 
331  if (!*fmt)
333 
334 fail:
335  /* Rewind. Reuse probe buffer to avoid seeking. */
336  ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
337  if (ret >= 0)
338  ret = ret2;
339 
340  av_freep(&pd.mime_type);
341  return ret < 0 ? ret : score;
342 }
343 
345  const char *filename, void *logctx,
346  unsigned int offset, unsigned int max_probe_size)
347 {
348  int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
349  return ret < 0 ? ret : 0;
350 }
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:522
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FFInputFormat::read_probe
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: demux.h:57
AVOutputFormat::extensions
const char * extensions
comma-separated filename extensions
Definition: avformat.h:518
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
av_probe_input_buffer2
int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)
Probe a bytestream to determine the input format.
Definition: format.c:252
thread.h
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
URLComponents
Definition: url.h:359
id3v2.h
URLComponents::path
const char * path
Definition: url.h:366
ff_guess_image2_codec
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:115
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
URL_COMPONENT_HAVE
#define URL_COMPONENT_HAVE(uc, component)
Definition: url.h:382
AVOutputFormat::subtitle_codec
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:522
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:126
fail
#define fail()
Definition: checkasm.h:179
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AVPROBE_PADDING_SIZE
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:465
av_probe_input_format3
const AVInputFormat * av_probe_input_format3(const AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:155
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:548
AVProbeData::mime_type
const char * mime_type
mime_type, when known.
Definition: avformat.h:455
AVInputFormat::extensions
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:574
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVProbeData::filename
const char * filename
Definition: avformat.h:452
av_match_ext
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
Definition: format.c:42
AVOutputFormat::audio_codec
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:520
AVInputFormat::mime_type
const char * mime_type
Comma-separated list of mime types.
Definition: avformat.h:585
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:386
URLComponents::query
const char * query
including initial '?' if present
Definition: url.h:367
av_probe_input_format2
const AVInputFormat * av_probe_input_format2(const AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:234
internal.h
av_probe_input_format
const AVInputFormat * av_probe_input_format(const AVProbeData *pd, int is_opened)
Guess the file format.
Definition: format.c:246
NULL
#define NULL
Definition: coverity.c:32
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:461
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVMediaType
AVMediaType
Definition: avutil.h:199
ID3v2_DEFAULT_MAGIC
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:186
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:603
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_probe_input_buffer
int av_probe_input_buffer(AVIOContext *pb, const AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)
Like av_probe_input_buffer2() but returns 0 on success.
Definition: format.c:344
AVOutputFormat::mime_type
const char * mime_type
Definition: avformat.h:517
PROBE_BUF_MAX
#define PROBE_BUF_MAX
Definition: internal.h:34
bprint.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
avio_internal.h
AVPROBE_SCORE_MIME
#define AVPROBE_SCORE_MIME
score for file mime type
Definition: avformat.h:462
ff_match_url_ext
int ff_match_url_ext(const char *url, const char *extensions)
Return a positive value if the given url has one of the given extensions, negative AVERROR on error,...
Definition: format.c:55
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
url.h
AVPROBE_SCORE_RETRY
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:458
AVFMT_EXPERIMENTAL
#define AVFMT_EXPERIMENTAL
The muxer/demuxer is experimental and should be used with caution.
Definition: avformat.h:476
demux.h
ff_id3v2_tag_len
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
Definition: id3v2.c:157
ret
ret
Definition: filter_design.txt:187
avformat.h
av_guess_codec
enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AVMediaType type)
Guess the codec ID based upon muxer and filename.
Definition: format.c:116
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:582
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
ffifmt
static const FFInputFormat * ffifmt(const AVInputFormat *fmt)
Definition: demux.h:127
PROBE_BUF_MIN
#define PROBE_BUF_MIN
size of probe buffer, for guessing file type from file contents
Definition: internal.h:33
av_match_name
int av_match_name(const char *name, const char *names)
Match instances of a name in a comma-separated list of names.
Definition: avstring.c:345
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:611
AVOutputFormat::video_codec
enum AVCodecID video_codec
default video codec
Definition: avformat.h:521
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:145
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
av_guess_format
const AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:80
ffio_rewind_with_probe_data
int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **buf, int buf_size)
Rewind the AVIOContext using the specified buffer containing the first buf_size bytes of the file.
Definition: aviobuf.c:1147
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:1145
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
avstring.h
ff_url_decompose
int ff_url_decompose(URLComponents *uc, const char *url, const char *end)
Parse an URL to find the components.
Definition: url.c:91
ff_id3v2_match
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
Definition: id3v2.c:144
AVIOContext::av_class
const AVClass * av_class
A class for private options.
Definition: avio.h:173