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 "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 ff_const59 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
52  const char *mime_type)
53 {
54  const AVOutputFormat *fmt = NULL;
55  AVOutputFormat *fmt_found = NULL;
56  void *i = 0;
57  int score_max, score;
58 
59  /* specific test for image sequences */
60 #if CONFIG_IMAGE2_MUXER
61  if (!short_name && filename &&
62  av_filename_number_test(filename) &&
64  return av_guess_format("image2", NULL, NULL);
65  }
66 #endif
67  /* Find the proper file type. */
68  score_max = 0;
69  while ((fmt = av_muxer_iterate(&i))) {
70  score = 0;
71  if (fmt->name && short_name && av_match_name(short_name, fmt->name))
72  score += 100;
73  if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
74  score += 10;
75  if (filename && fmt->extensions &&
76  av_match_ext(filename, fmt->extensions)) {
77  score += 5;
78  }
79  if (score > score_max) {
80  score_max = score;
81  fmt_found = (AVOutputFormat*)fmt;
82  }
83  }
84  return fmt_found;
85 }
86 
87 enum AVCodecID av_guess_codec(ff_const59 AVOutputFormat *fmt, const char *short_name,
88  const char *filename, const char *mime_type,
89  enum AVMediaType type)
90 {
91  if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) {
93  if (fmt2)
94  fmt = fmt2;
95  }
96 
97  if (type == AVMEDIA_TYPE_VIDEO) {
99 
100 #if CONFIG_IMAGE2_MUXER
101  if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {
102  codec_id = ff_guess_image2_codec(filename);
103  }
104 #endif
105  if (codec_id == AV_CODEC_ID_NONE)
106  codec_id = fmt->video_codec;
107  return codec_id;
108  } else if (type == AVMEDIA_TYPE_AUDIO)
109  return fmt->audio_codec;
110  else if (type == AVMEDIA_TYPE_SUBTITLE)
111  return fmt->subtitle_codec;
112  else if (type == AVMEDIA_TYPE_DATA)
113  return fmt->data_codec;
114  else
115  return AV_CODEC_ID_NONE;
116 }
117 
119 {
120  const AVInputFormat *fmt = NULL;
121  void *i = 0;
122  while ((fmt = av_demuxer_iterate(&i)))
123  if (av_match_name(short_name, fmt->name))
124  return (AVInputFormat*)fmt;
125  return NULL;
126 }
127 
129  int *score_ret)
130 {
131  AVProbeData lpd = *pd;
132  const AVInputFormat *fmt1 = NULL;
134  int score, score_max = 0;
135  void *i = 0;
136  const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
137  enum nodat {
138  NO_ID3,
139  ID3_ALMOST_GREATER_PROBE,
140  ID3_GREATER_PROBE,
141  ID3_GREATER_MAX_PROBE,
142  } nodat = NO_ID3;
143 
144  if (!lpd.buf)
145  lpd.buf = (unsigned char *) zerobuffer;
146 
147  if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
148  int id3len = ff_id3v2_tag_len(lpd.buf);
149  if (lpd.buf_size > id3len + 16) {
150  if (lpd.buf_size < 2LL*id3len + 16)
151  nodat = ID3_ALMOST_GREATER_PROBE;
152  lpd.buf += id3len;
153  lpd.buf_size -= id3len;
154  } else if (id3len >= PROBE_BUF_MAX) {
155  nodat = ID3_GREATER_MAX_PROBE;
156  } else
157  nodat = ID3_GREATER_PROBE;
158  }
159 
160  while ((fmt1 = av_demuxer_iterate(&i))) {
161  if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
162  continue;
163  score = 0;
164  if (fmt1->read_probe) {
165  score = fmt1->read_probe(&lpd);
166  if (score)
167  av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
168  if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
169  switch (nodat) {
170  case NO_ID3:
171  score = FFMAX(score, 1);
172  break;
173  case ID3_GREATER_PROBE:
174  case ID3_ALMOST_GREATER_PROBE:
175  score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
176  break;
177  case ID3_GREATER_MAX_PROBE:
178  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
179  break;
180  }
181  }
182  } else if (fmt1->extensions) {
183  if (av_match_ext(lpd.filename, fmt1->extensions))
184  score = AVPROBE_SCORE_EXTENSION;
185  }
186  if (av_match_name(lpd.mime_type, fmt1->mime_type)) {
187  if (AVPROBE_SCORE_MIME > score) {
188  av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME);
189  score = AVPROBE_SCORE_MIME;
190  }
191  }
192  if (score > score_max) {
193  score_max = score;
194  fmt = (AVInputFormat*)fmt1;
195  } else if (score == score_max)
196  fmt = NULL;
197  }
198  if (nodat == ID3_GREATER_PROBE)
199  score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
200  *score_ret = score_max;
201 
202  return fmt;
203 }
204 
206 {
207  int score_ret;
208  ff_const59 AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
209  if (score_ret > *score_max) {
210  *score_max = score_ret;
211  return fmt;
212  } else
213  return NULL;
214 }
215 
217 {
218  int score = 0;
219  return av_probe_input_format2(pd, is_opened, &score);
220 }
221 
223  const char *filename, void *logctx,
224  unsigned int offset, unsigned int max_probe_size)
225 {
226  AVProbeData pd = { filename ? filename : "" };
227  uint8_t *buf = NULL;
228  int ret = 0, probe_size, buf_offset = 0;
229  int score = 0;
230  int ret2;
231 
232  if (!max_probe_size)
233  max_probe_size = PROBE_BUF_MAX;
234  else if (max_probe_size < PROBE_BUF_MIN) {
235  av_log(logctx, AV_LOG_ERROR,
236  "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
237  return AVERROR(EINVAL);
238  }
239 
240  if (offset >= max_probe_size)
241  return AVERROR(EINVAL);
242 
243  if (pb->av_class) {
244  uint8_t *mime_type_opt = NULL;
245  char *semi;
246  av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
247  pd.mime_type = (const char *)mime_type_opt;
248  semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
249  if (semi) {
250  *semi = '\0';
251  }
252  }
253 
254  for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
255  probe_size = FFMIN(probe_size << 1,
256  FFMAX(max_probe_size, probe_size + 1))) {
257  score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
258 
259  /* Read probe data. */
260  if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
261  goto fail;
262  if ((ret = avio_read(pb, buf + buf_offset,
263  probe_size - buf_offset)) < 0) {
264  /* Fail if error was not end of file, otherwise, lower score. */
265  if (ret != AVERROR_EOF)
266  goto fail;
267 
268  score = 0;
269  ret = 0; /* error was end of file, nothing read */
270  }
271  buf_offset += ret;
272  if (buf_offset < offset)
273  continue;
274  pd.buf_size = buf_offset - offset;
275  pd.buf = &buf[offset];
276 
277  memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
278 
279  /* Guess file format. */
280  *fmt = av_probe_input_format2(&pd, 1, &score);
281  if (*fmt) {
282  /* This can only be true in the last iteration. */
283  if (score <= AVPROBE_SCORE_RETRY) {
284  av_log(logctx, AV_LOG_WARNING,
285  "Format %s detected only with low score of %d, "
286  "misdetection possible!\n", (*fmt)->name, score);
287  } else
288  av_log(logctx, AV_LOG_DEBUG,
289  "Format %s probed with size=%d and score=%d\n",
290  (*fmt)->name, probe_size, score);
291 #if 0
292  FILE *f = fopen("probestat.tmp", "ab");
293  fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
294  fclose(f);
295 #endif
296  }
297  }
298 
299  if (!*fmt)
300  ret = AVERROR_INVALIDDATA;
301 
302 fail:
303  /* Rewind. Reuse probe buffer to avoid seeking. */
304  ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
305  if (ret >= 0)
306  ret = ret2;
307 
308  av_freep(&pd.mime_type);
309  return ret < 0 ? ret : score;
310 }
311 
313  const char *filename, void *logctx,
314  unsigned int offset, unsigned int max_probe_size)
315 {
316  int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
317  return ret < 0 ? ret : 0;
318 }
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: avformat.h:712
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
const char * fmt
Definition: avisynth_c.h:861
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
const char * filename
Definition: avformat.h:447
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:1144
enum AVCodecID codec_id
Definition: qsv.c:77
#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:460
GLint GLenum type
Definition: opengl_enc.c:104
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:312
#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:668
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
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
#define f(width, name)
Definition: cbs_vp9.c:255
#define AVPROBE_SCORE_MIME
score for file mime type
Definition: avformat.h:457
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:650
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:507
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:549
ff_const59 AVInputFormat * av_probe_input_format(ff_const59 AVProbeData *pd, int is_opened)
Guess the file format.
Definition: format.c:216
ff_const59 AVInputFormat * av_probe_input_format2(ff_const59 AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:205
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#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:118
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:348
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:122
const char * mime_type
mime_type, when known.
Definition: avformat.h:450
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:449
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
#define FFMIN(a, b)
Definition: common.h:96
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:557
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:87
const char * name
Definition: avformat.h:505
ff_const59 AVInputFormat * av_probe_input_format3(ff_const59 AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:128
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:453
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:524
#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:163
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:222
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:327
void * buf
Definition: avisynth_c.h:766
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:51
AVMediaType
Definition: avutil.h:199
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:456
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
const char * mime_type
Comma-separated list of mime types.
Definition: avformat.h:686
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:675
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:463
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:103
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:761
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:654
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
const char * extensions
comma-separated filename extensions
Definition: avformat.h:513
const char * mime_type
Definition: avformat.h:512