FFmpeg  4.3.9
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 "libavutil/avstring.h"
23 #include "libavutil/bprint.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/thread.h"
26 
27 #include "avio_internal.h"
28 #include "avformat.h"
29 #include "id3v2.h"
30 #include "internal.h"
31 
32 
33 /**
34  * @file
35  * Format register and lookup
36  */
37 
38 int av_match_ext(const char *filename, const char *extensions)
39 {
40  const char *ext;
41 
42  if (!filename)
43  return 0;
44 
45  ext = strrchr(filename, '.');
46  if (ext)
47  return av_match_name(ext + 1, extensions);
48  return 0;
49 }
50 
51 int ff_match_url_ext(const char *url, const char *extensions)
52 {
53  const char *ext;
54  URLComponents uc;
55  int ret;
56  char scratchpad[128];
57 
58  if (!url)
59  return 0;
60 
61  ret = ff_url_decompose(&uc, url, NULL);
62  if (ret < 0 || !URL_COMPONENT_HAVE(uc, scheme))
63  return ret;
64  for (ext = uc.query; *ext != '.' && ext > uc.path; ext--)
65  ;
66 
67  if (*ext != '.')
68  return 0;
69  if (uc.query - ext > sizeof(scratchpad))
70  return AVERROR(ENOMEM); //not enough memory in our scratchpad
71  av_strlcpy(scratchpad, ext + 1, FFMIN(sizeof(scratchpad), uc.query - ext));
72 
73  return av_match_name(scratchpad, extensions);
74 }
75 
76 ff_const59 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
77  const char *mime_type)
78 {
79  const AVOutputFormat *fmt = NULL;
80  AVOutputFormat *fmt_found = NULL;
81  void *i = 0;
82  int score_max, score;
83 
84  /* specific test for image sequences */
85 #if CONFIG_IMAGE2_MUXER
86  if (!short_name && filename &&
87  av_filename_number_test(filename) &&
89  return av_guess_format("image2", NULL, NULL);
90  }
91 #endif
92  /* Find the proper file type. */
93  score_max = 0;
94  while ((fmt = av_muxer_iterate(&i))) {
95  score = 0;
96  if (fmt->name && short_name && av_match_name(short_name, fmt->name))
97  score += 100;
98  if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
99  score += 10;
100  if (filename && fmt->extensions &&
101  av_match_ext(filename, fmt->extensions)) {
102  score += 5;
103  }
104  if (score > score_max) {
105  score_max = score;
106  fmt_found = (AVOutputFormat*)fmt;
107  }
108  }
109  return fmt_found;
110 }
111 
112 enum AVCodecID av_guess_codec(ff_const59 AVOutputFormat *fmt, const char *short_name,
113  const char *filename, const char *mime_type,
114  enum AVMediaType type)
115 {
116  if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) {
117  ff_const59 AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
118  if (fmt2)
119  fmt = fmt2;
120  }
121 
122  if (type == AVMEDIA_TYPE_VIDEO) {
124 
125 #if CONFIG_IMAGE2_MUXER
126  if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {
127  codec_id = ff_guess_image2_codec(filename);
128  }
129 #endif
130  if (codec_id == AV_CODEC_ID_NONE)
131  codec_id = fmt->video_codec;
132  return codec_id;
133  } else if (type == AVMEDIA_TYPE_AUDIO)
134  return fmt->audio_codec;
135  else if (type == AVMEDIA_TYPE_SUBTITLE)
136  return fmt->subtitle_codec;
137  else if (type == AVMEDIA_TYPE_DATA)
138  return fmt->data_codec;
139  else
140  return AV_CODEC_ID_NONE;
141 }
142 
144 {
145  const AVInputFormat *fmt = NULL;
146  void *i = 0;
147  while ((fmt = av_demuxer_iterate(&i)))
148  if (av_match_name(short_name, fmt->name))
149  return (AVInputFormat*)fmt;
150  return NULL;
151 }
152 
154  int *score_ret)
155 {
156  AVProbeData lpd = *pd;
157  const AVInputFormat *fmt1 = NULL;
159  int score, score_max = 0;
160  void *i = 0;
161  const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
162  enum nodat {
163  NO_ID3,
164  ID3_ALMOST_GREATER_PROBE,
165  ID3_GREATER_PROBE,
166  ID3_GREATER_MAX_PROBE,
167  } nodat = NO_ID3;
168 
169  if (!lpd.buf)
170  lpd.buf = (unsigned char *) zerobuffer;
171 
172  if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
173  int id3len = ff_id3v2_tag_len(lpd.buf);
174  if (lpd.buf_size > id3len + 16) {
175  if (lpd.buf_size < 2LL*id3len + 16)
176  nodat = ID3_ALMOST_GREATER_PROBE;
177  lpd.buf += id3len;
178  lpd.buf_size -= id3len;
179  } else if (id3len >= PROBE_BUF_MAX) {
180  nodat = ID3_GREATER_MAX_PROBE;
181  } else
182  nodat = ID3_GREATER_PROBE;
183  }
184 
185  while ((fmt1 = av_demuxer_iterate(&i))) {
186  if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
187  continue;
188  score = 0;
189  if (fmt1->read_probe) {
190  score = fmt1->read_probe(&lpd);
191  if (score)
192  av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
193  if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
194  switch (nodat) {
195  case NO_ID3:
196  score = FFMAX(score, 1);
197  break;
198  case ID3_GREATER_PROBE:
199  case ID3_ALMOST_GREATER_PROBE:
200  score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
201  break;
202  case ID3_GREATER_MAX_PROBE:
203  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
204  break;
205  }
206  }
207  } else if (fmt1->extensions) {
208  if (av_match_ext(lpd.filename, fmt1->extensions))
209  score = AVPROBE_SCORE_EXTENSION;
210  }
211  if (av_match_name(lpd.mime_type, fmt1->mime_type)) {
212  if (AVPROBE_SCORE_MIME > score) {
213  av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME);
214  score = AVPROBE_SCORE_MIME;
215  }
216  }
217  if (score > score_max) {
218  score_max = score;
219  fmt = (AVInputFormat*)fmt1;
220  } else if (score == score_max)
221  fmt = NULL;
222  }
223  if (nodat == ID3_GREATER_PROBE)
224  score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
225  *score_ret = score_max;
226 
227  return fmt;
228 }
229 
231 {
232  int score_ret;
233  ff_const59 AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
234  if (score_ret > *score_max) {
235  *score_max = score_ret;
236  return fmt;
237  } else
238  return NULL;
239 }
240 
242 {
243  int score = 0;
244  return av_probe_input_format2(pd, is_opened, &score);
245 }
246 
248  const char *filename, void *logctx,
249  unsigned int offset, unsigned int max_probe_size)
250 {
251  AVProbeData pd = { filename ? filename : "" };
252  uint8_t *buf = NULL;
253  int ret = 0, probe_size, buf_offset = 0;
254  int score = 0;
255  int ret2;
256  int eof = 0;
257 
258  if (!max_probe_size)
259  max_probe_size = PROBE_BUF_MAX;
260  else if (max_probe_size < PROBE_BUF_MIN) {
261  av_log(logctx, AV_LOG_ERROR,
262  "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
263  return AVERROR(EINVAL);
264  }
265 
266  if (offset >= max_probe_size)
267  return AVERROR(EINVAL);
268 
269  if (pb->av_class) {
270  uint8_t *mime_type_opt = NULL;
271  char *semi;
272  av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
273  pd.mime_type = (const char *)mime_type_opt;
274  semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
275  if (semi) {
276  *semi = '\0';
277  }
278  }
279 
280  for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt && !eof;
281  probe_size = FFMIN(probe_size << 1,
282  FFMAX(max_probe_size, probe_size + 1))) {
283  score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
284 
285  /* Read probe data. */
286  if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
287  goto fail;
288  if ((ret = avio_read(pb, buf + buf_offset,
289  probe_size - buf_offset)) < 0) {
290  /* Fail if error was not end of file, otherwise, lower score. */
291  if (ret != AVERROR_EOF)
292  goto fail;
293 
294  score = 0;
295  ret = 0; /* error was end of file, nothing read */
296  eof = 1;
297  }
298  buf_offset += ret;
299  if (buf_offset < offset)
300  continue;
301  pd.buf_size = buf_offset - offset;
302  pd.buf = &buf[offset];
303 
304  memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
305 
306  /* Guess file format. */
307  *fmt = av_probe_input_format2(&pd, 1, &score);
308  if (*fmt) {
309  /* This can only be true in the last iteration. */
310  if (score <= AVPROBE_SCORE_RETRY) {
311  av_log(logctx, AV_LOG_WARNING,
312  "Format %s detected only with low score of %d, "
313  "misdetection possible!\n", (*fmt)->name, score);
314  } else
315  av_log(logctx, AV_LOG_DEBUG,
316  "Format %s probed with size=%d and score=%d\n",
317  (*fmt)->name, probe_size, score);
318 #if 0
319  FILE *f = fopen("probestat.tmp", "ab");
320  fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
321  fclose(f);
322 #endif
323  }
324  }
325 
326  if (!*fmt)
327  ret = AVERROR_INVALIDDATA;
328 
329 fail:
330  /* Rewind. Reuse probe buffer to avoid seeking. */
331  ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
332  if (ret >= 0)
333  ret = ret2;
334 
335  av_freep(&pd.mime_type);
336  return ret < 0 ? ret : score;
337 }
338 
340  const char *filename, void *logctx,
341  unsigned int offset, unsigned int max_probe_size)
342 {
343  int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
344  return ret < 0 ? ret : 0;
345 }
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: avformat.h:708
#define NULL
Definition: coverity.c:32
int ff_url_decompose(URLComponents *uc, const char *url, const char *end)
Parse an URL to find the components.
Definition: url.c:89
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define URL_COMPONENT_HAVE(uc, component)
Definition: url.h:376
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
const char * filename
Definition: avformat.h:442
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:1072
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:455
int av_probe_input_buffer(AVIOContext *pb, ff_const59 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:339
#define PROBE_BUF_MAX
Definition: internal.h:34
uint8_t
Opaque data information usually continuous.
Definition: avutil.h:203
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:664
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
#define f(width, name)
Definition: cbs_vp9.c:255
#define AVPROBE_SCORE_MIME
score for file mime type
Definition: avformat.h:452
const AVClass * av_class
A class for private options.
Definition: avio.h:174
#define AVERROR_EOF
End of file.
Definition: error.h:55
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:38
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:516
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:544
ff_const59 AVInputFormat * av_probe_input_format(ff_const59 AVProbeData *pd, int is_opened)
Guess the file format.
Definition: format.c:241
ff_const59 AVInputFormat * av_probe_input_format2(ff_const59 AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:230
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:143
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:350
static const uint8_t offset[127][2]
Definition: vf_spp.c:93
#define FFMAX(a, b)
Definition: common.h:94
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:123
const char * mime_type
mime_type, when known.
Definition: avformat.h:445
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
#define FFMIN(a, b)
Definition: common.h:96
const char * query
including initial &#39;?&#39; if present
Definition: url.h:361
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:558
enum AVCodecID av_guess_codec(ff_const59 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:112
const char * name
Definition: avformat.h:500
ff_const59 AVInputFormat * av_probe_input_format3(ff_const59 AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:153
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:448
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:533
#define PROBE_BUF_MIN
size of probe buffer, for guessing file type from file contents
Definition: internal.h:33
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:161
int av_probe_input_buffer2(AVIOContext *pb, ff_const59 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:247
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:324
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:51
ff_const59 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:76
cl_device_type type
AVMediaType
Definition: avutil.h:199
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
const char * mime_type
Comma-separated list of mime types.
Definition: avformat.h:682
const char * path
Definition: url.h:360
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:671
Main libavformat public API header.
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
Definition: id3v2.c:143
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:104
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:779
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
Definition: id3v2.c:156
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
const char * extensions
comma-separated filename extensions
Definition: avformat.h:508
const char * mime_type
Definition: avformat.h:507