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 const AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
52  const char *mime_type)
53 {
54  const AVOutputFormat *fmt = NULL;
55  const 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 = fmt;
82  }
83  }
84  return fmt_found;
85 }
86 
87 enum AVCodecID av_guess_codec(const 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)) {
92  const AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
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 
118 const AVInputFormat *av_find_input_format(const char *short_name)
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 fmt;
125  return NULL;
126 }
127 
129  int is_opened, int *score_ret)
130 {
131  AVProbeData lpd = *pd;
132  const AVInputFormat *fmt1 = NULL;
133  const AVInputFormat *fmt = 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 (fmt1->flags & AVFMT_EXPERIMENTAL)
162  continue;
163  if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
164  continue;
165  score = 0;
166  if (fmt1->read_probe) {
167  score = fmt1->read_probe(&lpd);
168  if (score)
169  av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
170  if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
171  switch (nodat) {
172  case NO_ID3:
173  score = FFMAX(score, 1);
174  break;
175  case ID3_GREATER_PROBE:
176  case ID3_ALMOST_GREATER_PROBE:
177  score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
178  break;
179  case ID3_GREATER_MAX_PROBE:
180  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
181  break;
182  }
183  }
184  } else if (fmt1->extensions) {
185  if (av_match_ext(lpd.filename, fmt1->extensions))
186  score = AVPROBE_SCORE_EXTENSION;
187  }
188  if (av_match_name(lpd.mime_type, fmt1->mime_type)) {
189  if (AVPROBE_SCORE_MIME > score) {
190  av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME);
191  score = AVPROBE_SCORE_MIME;
192  }
193  }
194  if (score > score_max) {
195  score_max = score;
196  fmt = fmt1;
197  } else if (score == score_max)
198  fmt = NULL;
199  }
200  if (nodat == ID3_GREATER_PROBE)
201  score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
202  *score_ret = score_max;
203 
204  return fmt;
205 }
206 
208  int is_opened, int *score_max)
209 {
210  int score_ret;
211  const AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
212  if (score_ret > *score_max) {
213  *score_max = score_ret;
214  return fmt;
215  } else
216  return NULL;
217 }
218 
219 const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened)
220 {
221  int score = 0;
222  return av_probe_input_format2(pd, is_opened, &score);
223 }
224 
226  const char *filename, void *logctx,
227  unsigned int offset, unsigned int max_probe_size)
228 {
229  AVProbeData pd = { filename ? filename : "" };
230  uint8_t *buf = NULL;
231  int ret = 0, probe_size, buf_offset = 0;
232  int score = 0;
233  int ret2;
234 
235  if (!max_probe_size)
236  max_probe_size = PROBE_BUF_MAX;
237  else if (max_probe_size < PROBE_BUF_MIN) {
238  av_log(logctx, AV_LOG_ERROR,
239  "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
240  return AVERROR(EINVAL);
241  }
242 
243  if (offset >= max_probe_size)
244  return AVERROR(EINVAL);
245 
246  if (pb->av_class) {
247  uint8_t *mime_type_opt = NULL;
248  char *semi;
249  av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
250  pd.mime_type = (const char *)mime_type_opt;
251  semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
252  if (semi) {
253  *semi = '\0';
254  }
255  }
256 
257  for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
258  probe_size = FFMIN(probe_size << 1,
259  FFMAX(max_probe_size, probe_size + 1))) {
260  score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
261 
262  /* Read probe data. */
263  if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
264  goto fail;
265  if ((ret = avio_read(pb, buf + buf_offset,
266  probe_size - buf_offset)) < 0) {
267  /* Fail if error was not end of file, otherwise, lower score. */
268  if (ret != AVERROR_EOF)
269  goto fail;
270 
271  score = 0;
272  ret = 0; /* error was end of file, nothing read */
273  }
274  buf_offset += ret;
275  if (buf_offset < offset)
276  continue;
277  pd.buf_size = buf_offset - offset;
278  pd.buf = &buf[offset];
279 
280  memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
281 
282  /* Guess file format. */
283  *fmt = av_probe_input_format2(&pd, 1, &score);
284  if (*fmt) {
285  /* This can only be true in the last iteration. */
286  if (score <= AVPROBE_SCORE_RETRY) {
287  av_log(logctx, AV_LOG_WARNING,
288  "Format %s detected only with low score of %d, "
289  "misdetection possible!\n", (*fmt)->name, score);
290  } else
291  av_log(logctx, AV_LOG_DEBUG,
292  "Format %s probed with size=%d and score=%d\n",
293  (*fmt)->name, probe_size, score);
294 #if 0
295  FILE *f = fopen("probestat.tmp", "ab");
296  fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
297  fclose(f);
298 #endif
299  }
300  }
301 
302  if (!*fmt)
304 
305 fail:
306  /* Rewind. Reuse probe buffer to avoid seeking. */
307  ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
308  if (ret >= 0)
309  ret = ret2;
310 
311  av_freep(&pd.mime_type);
312  return ret < 0 ? ret : score;
313 }
314 
316  const char *filename, void *logctx,
317  unsigned int offset, unsigned int max_probe_size)
318 {
319  int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
320  return ret < 0 ? ret : 0;
321 }
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
AVOutputFormat::extensions
const char * extensions
comma-separated filename extensions
Definition: avformat.h:512
AVOutputFormat::name
const char * name
Definition: avformat.h:504
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:225
thread.h
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
id3v2.h
ff_guess_image2_codec
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:109
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:450
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVOutputFormat::subtitle_codec
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:516
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:220
fail
#define fail()
Definition: checkasm.h:127
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:461
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:128
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:650
AVProbeData::mime_type
const char * mime_type
mime_type, when known.
Definition: avformat.h:451
AVInputFormat::extensions
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:676
AVOutputFormat::data_codec
enum AVCodecID data_codec
default data codec
Definition: avformat.h:611
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:655
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:449
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVProbeData::filename
const char * filename
Definition: avformat.h:448
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
AVOutputFormat::audio_codec
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:514
AVInputFormat::mime_type
const char * mime_type
Comma-separated list of mime types.
Definition: avformat.h:687
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: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
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:207
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:219
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:716
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:447
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:457
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
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:185
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:464
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:564
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:559
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:315
AVOutputFormat::mime_type
const char * mime_type
Definition: avformat.h:511
PROBE_BUF_MAX
#define PROBE_BUF_MAX
Definition: internal.h:37
bprint.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVOutputFormat
Definition: avformat.h:503
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
avio_internal.h
AVPROBE_SCORE_MIME
#define AVPROBE_SCORE_MIME
score for file mime type
Definition: avformat.h:458
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVPROBE_SCORE_RETRY
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:454
AVFMT_EXPERIMENTAL
#define AVFMT_EXPERIMENTAL
The muxer/demuxer is experimental and should be used with caution.
Definition: avformat.h:472
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_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:87
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:545
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:669
PROBE_BUF_MIN
#define PROBE_BUF_MIN
size of probe buffer, for guessing file type from file contents
Definition: internal.h:36
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:641
AVOutputFormat::video_codec
enum AVCodecID video_codec
default video codec
Definition: avformat.h:515
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:118
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:51
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:1177
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:782
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:61
avstring.h
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