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/mem.h"
26 #include "libavutil/opt.h"
27 
28 #include "avio_internal.h"
29 #include "avformat.h"
30 #include "demux.h"
31 #include "id3v2.h"
32 #include "internal.h"
33 #include "url.h"
34 
35 
36 /**
37  * @file
38  * Format register and lookup
39  */
40 
41 int av_match_ext(const char *filename, const char *extensions)
42 {
43  const char *ext;
44 
45  if (!filename)
46  return 0;
47 
48  ext = strrchr(filename, '.');
49  if (ext)
50  return av_match_name(ext + 1, extensions);
51  return 0;
52 }
53 
54 int ff_match_url_ext(const char *url, const char *extensions)
55 {
56  const char *ext;
57  URLComponents uc;
58  int ret;
59  char scratchpad[128];
60 
61  if (!url)
62  return 0;
63 
64  ret = ff_url_decompose(&uc, url, NULL);
65  if (ret < 0 || !URL_COMPONENT_HAVE(uc, scheme))
66  return ret;
67  for (ext = uc.query; *ext != '.' && ext > uc.path; ext--)
68  ;
69 
70  if (*ext != '.')
71  return 0;
72  if (uc.query - ext > sizeof(scratchpad))
73  return AVERROR(ENOMEM); //not enough memory in our scratchpad
74  av_strlcpy(scratchpad, ext + 1, uc.query - ext);
75 
76  return av_match_name(scratchpad, extensions);
77 }
78 
79 const AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
80  const char *mime_type)
81 {
82  const AVOutputFormat *fmt = NULL;
83  const AVOutputFormat *fmt_found = NULL;
84  void *i = 0;
85  int score_max, score;
86 
87  /* specific test for image sequences */
88 #if CONFIG_IMAGE2_MUXER
89  if (!short_name && filename &&
90  av_filename_number_test(filename) &&
92  return av_guess_format("image2", NULL, NULL);
93  }
94 #endif
95  /* Find the proper file type. */
96  score_max = 0;
97  while ((fmt = av_muxer_iterate(&i))) {
98  score = 0;
99  if (fmt->name && short_name && av_match_name(short_name, fmt->name))
100  score += 100;
101  if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
102  score += 10;
103  if (filename && fmt->extensions &&
104  av_match_ext(filename, fmt->extensions)) {
105  score += 5;
106  }
107  if (score > score_max) {
108  score_max = score;
109  fmt_found = fmt;
110  }
111  }
112  return fmt_found;
113 }
114 
115 enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
116  const char *filename, const char *mime_type,
117  enum AVMediaType type)
118 {
119  if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) {
120  const AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
121  if (fmt2)
122  fmt = fmt2;
123  }
124 
125  if (type == AVMEDIA_TYPE_VIDEO) {
127 
128 #if CONFIG_IMAGE2_MUXER || CONFIG_IMAGE2PIPE_MUXER
129  if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {
130  codec_id = ff_guess_image2_codec(filename);
131  }
132 #endif
133  if (codec_id == AV_CODEC_ID_NONE)
134  codec_id = fmt->video_codec;
135  return codec_id;
136  } else if (type == AVMEDIA_TYPE_AUDIO)
137  return fmt->audio_codec;
138  else if (type == AVMEDIA_TYPE_SUBTITLE)
139  return fmt->subtitle_codec;
140  else
141  return AV_CODEC_ID_NONE;
142 }
143 
144 const AVInputFormat *av_find_input_format(const char *short_name)
145 {
146  const AVInputFormat *fmt = NULL;
147  void *i = 0;
148  while ((fmt = av_demuxer_iterate(&i)))
149  if (av_match_name(short_name, fmt->name))
150  return fmt;
151  return NULL;
152 }
153 
155  int is_opened, int *score_ret)
156 {
157  AVProbeData lpd = *pd;
158  const AVInputFormat *fmt1 = NULL;
159  const AVInputFormat *fmt = NULL;
160  int score, score_max = 0;
161  void *i = 0;
162  const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
163  enum nodat {
164  NO_ID3,
165  ID3_ALMOST_GREATER_PROBE,
166  ID3_GREATER_PROBE,
167  ID3_GREATER_MAX_PROBE,
168  } nodat = NO_ID3;
169 
170  if (!lpd.buf)
171  lpd.buf = (unsigned char *) zerobuffer;
172 
173  if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
174  int id3len = ff_id3v2_tag_len(lpd.buf);
175  if (lpd.buf_size > id3len + 16) {
176  if (lpd.buf_size < 2LL*id3len + 16)
177  nodat = ID3_ALMOST_GREATER_PROBE;
178  lpd.buf += id3len;
179  lpd.buf_size -= id3len;
180  } else if (id3len >= PROBE_BUF_MAX) {
181  nodat = ID3_GREATER_MAX_PROBE;
182  } else
183  nodat = ID3_GREATER_PROBE;
184  }
185 
186  while ((fmt1 = av_demuxer_iterate(&i))) {
187  if (fmt1->flags & AVFMT_EXPERIMENTAL)
188  continue;
189  if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
190  continue;
191  score = 0;
192  if (ffifmt(fmt1)->read_probe) {
193  score = ffifmt(fmt1)->read_probe(&lpd);
194  if (score)
195  av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
196  if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
197  switch (nodat) {
198  case NO_ID3:
199  score = FFMAX(score, 1);
200  break;
201  case ID3_GREATER_PROBE:
202  case ID3_ALMOST_GREATER_PROBE:
203  score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
204  break;
205  case ID3_GREATER_MAX_PROBE:
206  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
207  break;
208  }
209  }
210  } else if (fmt1->extensions) {
211  if (av_match_ext(lpd.filename, fmt1->extensions))
212  score = AVPROBE_SCORE_EXTENSION;
213  }
214  if (av_match_name(lpd.mime_type, fmt1->mime_type)) {
215  if (AVPROBE_SCORE_MIME > score) {
216  av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME);
217  score = AVPROBE_SCORE_MIME;
218  }
219  }
220  if (score > score_max) {
221  score_max = score;
222  fmt = fmt1;
223  } else if (score == score_max)
224  fmt = NULL;
225  }
226  if (nodat == ID3_GREATER_PROBE)
227  score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
228  *score_ret = score_max;
229 
230  return fmt;
231 }
232 
234  int is_opened, int *score_max)
235 {
236  int score_ret;
237  const AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
238  if (score_ret > *score_max) {
239  *score_max = score_ret;
240  return fmt;
241  } else
242  return NULL;
243 }
244 
245 const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened)
246 {
247  int score = 0;
248  return av_probe_input_format2(pd, is_opened, &score);
249 }
250 
252  const char *filename, void *logctx,
253  unsigned int offset, unsigned int max_probe_size)
254 {
255  AVProbeData pd = { filename ? filename : "" };
256  uint8_t *buf = NULL;
257  int ret = 0, probe_size, buf_offset = 0;
258  int score = 0;
259  int ret2;
260  int eof = 0;
261 
262  if (!max_probe_size)
263  max_probe_size = PROBE_BUF_MAX;
264  else if (max_probe_size < PROBE_BUF_MIN) {
265  av_log(logctx, AV_LOG_ERROR,
266  "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
267  return AVERROR(EINVAL);
268  }
269 
270  if (offset >= max_probe_size)
271  return AVERROR(EINVAL);
272 
273  if (pb->av_class) {
274  uint8_t *mime_type_opt = NULL;
275  char *semi;
276  av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
277  pd.mime_type = (const char *)mime_type_opt;
278  semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
279  if (semi) {
280  *semi = '\0';
281  }
282  }
283 
284  for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt && !eof;
285  probe_size = FFMIN(probe_size << 1,
286  FFMAX(max_probe_size, probe_size + 1))) {
287  score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
288 
289  /* Read probe data. */
290  if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
291  goto fail;
292  if ((ret = avio_read(pb, buf + buf_offset,
293  probe_size - buf_offset)) < 0) {
294  /* Fail if error was not end of file, otherwise, lower score. */
295  if (ret != AVERROR_EOF)
296  goto fail;
297 
298  score = 0;
299  ret = 0; /* error was end of file, nothing read */
300  eof = 1;
301  }
302  buf_offset += ret;
303  if (buf_offset < offset)
304  continue;
305  pd.buf_size = buf_offset - offset;
306  pd.buf = &buf[offset];
307 
308  memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
309 
310  /* Guess file format. */
311  *fmt = av_probe_input_format2(&pd, 1, &score);
312  if (*fmt) {
313  /* This can only be true in the last iteration. */
314  if (score <= AVPROBE_SCORE_RETRY) {
315  av_log(logctx, AV_LOG_WARNING,
316  "Format %s detected only with low score of %d, "
317  "misdetection possible!\n", (*fmt)->name, score);
318  } else
319  av_log(logctx, AV_LOG_DEBUG,
320  "Format %s probed with size=%d and score=%d\n",
321  (*fmt)->name, probe_size, score);
322 #if 0
323  FILE *f = fopen("probestat.tmp", "ab");
324  fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
325  fclose(f);
326 #endif
327  }
328  }
329 
330  if (!*fmt)
332 
333 fail:
334  /* Rewind. Reuse probe buffer to avoid seeking. */
335  ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
336  if (ret >= 0)
337  ret = ret2;
338 
339  av_freep(&pd.mime_type);
340  return ret < 0 ? ret : score;
341 }
342 
344  const char *filename, void *logctx,
345  unsigned int offset, unsigned int max_probe_size)
346 {
347  int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
348  return ret < 0 ? ret : 0;
349 }
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:63
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:251
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:125
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:127
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:154
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:41
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:387
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:233
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:245
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:188
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:604
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:343
AVOutputFormat::mime_type
const char * mime_type
Definition: avformat.h:517
PROBE_BUF_MAX
#define PROBE_BUF_MAX
Definition: internal.h:34
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:256
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:54
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:158
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:115
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:583
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:133
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:612
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:144
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:79
mem.h
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:1148
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:1147
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:145
AVIOContext::av_class
const AVClass * av_class
A class for private options.
Definition: avio.h:173