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  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(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 (AVInputFormat*)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 (!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 = 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  int is_opened, int *score_max)
207 {
208  int score_ret;
209  const AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
210  if (score_ret > *score_max) {
211  *score_max = score_ret;
212  return fmt;
213  } else
214  return NULL;
215 }
216 
217 const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened)
218 {
219  int score = 0;
220  return av_probe_input_format2(pd, is_opened, &score);
221 }
222 
224  const char *filename, void *logctx,
225  unsigned int offset, unsigned int max_probe_size)
226 {
227  AVProbeData pd = { filename ? filename : "" };
228  uint8_t *buf = NULL;
229  int ret = 0, probe_size, buf_offset = 0;
230  int score = 0;
231  int ret2;
232 
233  if (!max_probe_size)
234  max_probe_size = PROBE_BUF_MAX;
235  else if (max_probe_size < PROBE_BUF_MIN) {
236  av_log(logctx, AV_LOG_ERROR,
237  "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
238  return AVERROR(EINVAL);
239  }
240 
241  if (offset >= max_probe_size)
242  return AVERROR(EINVAL);
243 
244  if (pb->av_class) {
245  uint8_t *mime_type_opt = NULL;
246  char *semi;
247  av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
248  pd.mime_type = (const char *)mime_type_opt;
249  semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
250  if (semi) {
251  *semi = '\0';
252  }
253  }
254 
255  for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
256  probe_size = FFMIN(probe_size << 1,
257  FFMAX(max_probe_size, probe_size + 1))) {
258  score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
259 
260  /* Read probe data. */
261  if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
262  goto fail;
263  if ((ret = avio_read(pb, buf + buf_offset,
264  probe_size - buf_offset)) < 0) {
265  /* Fail if error was not end of file, otherwise, lower score. */
266  if (ret != AVERROR_EOF)
267  goto fail;
268 
269  score = 0;
270  ret = 0; /* error was end of file, nothing read */
271  }
272  buf_offset += ret;
273  if (buf_offset < offset)
274  continue;
275  pd.buf_size = buf_offset - offset;
276  pd.buf = &buf[offset];
277 
278  memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
279 
280  /* Guess file format. */
281  *fmt = av_probe_input_format2(&pd, 1, &score);
282  if (*fmt) {
283  /* This can only be true in the last iteration. */
284  if (score <= AVPROBE_SCORE_RETRY) {
285  av_log(logctx, AV_LOG_WARNING,
286  "Format %s detected only with low score of %d, "
287  "misdetection possible!\n", (*fmt)->name, score);
288  } else
289  av_log(logctx, AV_LOG_DEBUG,
290  "Format %s probed with size=%d and score=%d\n",
291  (*fmt)->name, probe_size, score);
292 #if 0
293  FILE *f = fopen("probestat.tmp", "ab");
294  fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
295  fclose(f);
296 #endif
297  }
298  }
299 
300  if (!*fmt)
302 
303 fail:
304  /* Rewind. Reuse probe buffer to avoid seeking. */
305  ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
306  if (ret >= 0)
307  ret = ret2;
308 
309  av_freep(&pd.mime_type);
310  return ret < 0 ? ret : score;
311 }
312 
314  const char *filename, void *logctx,
315  unsigned int offset, unsigned int max_probe_size)
316 {
317  int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
318  return ret < 0 ? ret : 0;
319 }
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:187
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
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:223
thread.h
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
id3v2.h
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
AVOutputFormat::subtitle_codec
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:503
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:298
fail
#define fail()
Definition: checkasm.h:134
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_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:207
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
AVInputFormat
Definition: avformat.h:616
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:642
AVOutputFormat::data_codec
enum AVCodecID data_codec
default data codec
Definition: avformat.h:581
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:621
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
AVOutputFormat::audio_codec
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:501
AVInputFormat::mime_type
const char * mime_type
Comma-separated list of mime types.
Definition: avformat.h:653
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
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:205
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:217
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:677
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
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:167
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:554
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
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:313
AVOutputFormat::mime_type
const char * mime_type
Definition: avformat.h:498
PROBE_BUF_MAX
#define PROBE_BUF_MAX
Definition: internal.h:34
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
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_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:537
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:635
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:616
AVOutputFormat::video_codec
enum AVCodecID video_codec
default video codec
Definition: avformat.h:502
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:1077
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
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