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)
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 }
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:200
AVOutputFormat::extensions
const char * extensions
comma-separated filename extensions
Definition: avformat.h:499
AVOutputFormat::name
const char * name
Definition: avformat.h:491
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
thread.h
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
id3v2.h
av_guess_codec
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
ff_guess_image2_codec
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:106
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
ff_const59
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning.
Definition: avformat.h:535
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:333
av_guess_format
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
fail
#define fail()
Definition: checkasm.h:133
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:455
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVInputFormat
Definition: avformat.h:640
AVProbeData::mime_type
const char * mime_type
mime_type, when known.
Definition: avformat.h:445
AVInputFormat::extensions
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:666
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVProbeData::filename
const char * filename
Definition: avformat.h:442
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:38
AVInputFormat::mime_type
const char * mime_type
Comma-separated list of mime types.
Definition: avformat.h:677
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
f
#define f(width, name)
Definition: cbs_vp9.c:255
internal.h
NULL
#define NULL
Definition: coverity.c:32
AVInputFormat::read_probe
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: avformat.h:705
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVMediaType
AVMediaType
Definition: avutil.h:199
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
av_probe_input_format
ff_const59 AVInputFormat * av_probe_input_format(ff_const59 AVProbeData *pd, int is_opened)
Guess the file format.
Definition: format.c:216
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:161
av_probe_input_buffer2
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
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:558
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
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
AVOutputFormat::mime_type
const char * mime_type
Definition: avformat.h:498
PROBE_BUF_MAX
#define PROBE_BUF_MAX
Definition: internal.h:34
av_find_input_format
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
bprint.h
i
int i
Definition: input.c:407
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
AVOutputFormat
Definition: avformat.h:490
avio_internal.h
AVPROBE_SCORE_MIME
#define AVPROBE_SCORE_MIME
score for file mime type
Definition: avformat.h:452
uint8_t
uint8_t
Definition: audio_convert.c:194
AVPROBE_SCORE_RETRY
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:448
ff_id3v2_tag_len
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
Definition: id3v2.c:156
ret
ret
Definition: filter_design.txt:187
avformat.h
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:541
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:659
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:353
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
av_probe_input_format2
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
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:1094
av_probe_input_buffer
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
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:779
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
avstring.h
av_probe_input_format3
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
ff_id3v2_match
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
Definition: id3v2.c:143
AVIOContext::av_class
const AVClass * av_class
A class for private options.
Definition: avio.h:174