FFmpeg: libavformat/format.c Source File

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/bprint.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/thread.h"
28 
29 #include "avio_internal.h"
30 #include "avformat.h"
31 #include "id3v2.h"
32 #include "internal.h"
33 
34 
35 /**
36  * @file
37  * Format register and lookup
38  */
39 
40  int av_match_ext(const char *filename, const char *extensions)
41 {
42  const char *ext;
43 
44  if (!filename)
45  return 0;
46 
47  ext = strrchr(filename, '.');
48  if (ext)
49  return av_match_name(ext + 1, extensions);
50  return 0;
51 }
52 
53  const AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
54  const char *mime_type)
55 {
56  const AVOutputFormat *fmt = NULL;
57  const AVOutputFormat *fmt_found = NULL;
58  void *i = 0;
59  int score_max, score;
60 
61  /* specific test for image sequences */
62 #if CONFIG_IMAGE2_MUXER
63  if (!short_name && filename &&
64  av_filename_number_test(filename) &&
65  ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
66  return av_guess_format("image2", NULL, NULL);
67  }
68 #endif
69  /* Find the proper file type. */
70  score_max = 0;
71  while ((fmt = av_muxer_iterate(&i))) {
72  score = 0;
73  if (fmt->name && short_name && av_match_name(short_name, fmt->name))
74  score += 100;
75  if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
76  score += 10;
77  if (filename && fmt->extensions &&
78  av_match_ext(filename, fmt->extensions)) {
79  score += 5;
80  }
81  if (score > score_max) {
82  score_max = score;
83  fmt_found = fmt;
84  }
85  }
86  return fmt_found;
87 }
88 
89  enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
90  const char *filename, const char *mime_type,
91  enum AVMediaType type)
92 {
93  if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) {
94  const AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
95  if (fmt2)
96  fmt = fmt2;
97  }
98 
99  if (type == AVMEDIA_TYPE_VIDEO) {
100  enum AVCodecID codec_id = AV_CODEC_ID_NONE;
101 
102 #if CONFIG_IMAGE2_MUXER || CONFIG_IMAGE2PIPE_MUXER
103  if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) {
104  codec_id = ff_guess_image2_codec(filename);
105  }
106 #endif
107  if (codec_id == AV_CODEC_ID_NONE)
108  codec_id = fmt->video_codec;
109  return codec_id;
110  } else if (type == AVMEDIA_TYPE_AUDIO)
111  return fmt->audio_codec;
112  else if (type == AVMEDIA_TYPE_SUBTITLE)
113  return fmt->subtitle_codec;
114  else if (type == AVMEDIA_TYPE_DATA)
115  return fmt->data_codec;
116  else
117  return AV_CODEC_ID_NONE;
118 }
119 
120  const AVInputFormat *av_find_input_format(const char *short_name)
121 {
122  const AVInputFormat *fmt = NULL;
123  void *i = 0;
124  while ((fmt = av_demuxer_iterate(&i)))
125  if (av_match_name(short_name, fmt->name))
126  return fmt;
127  return NULL;
128 }
129 
130  const AVInputFormat *av_probe_input_format3(const AVProbeData *pd,
131  int is_opened, int *score_ret)
132 {
133  AVProbeData lpd = *pd;
134  const AVInputFormat *fmt1 = NULL;
135  const AVInputFormat *fmt = NULL;
136  int score, score_max = 0;
137  void *i = 0;
138  const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
139  enum nodat {
140  NO_ID3,
141  ID3_ALMOST_GREATER_PROBE,
142  ID3_GREATER_PROBE,
143  ID3_GREATER_MAX_PROBE,
144  } nodat = NO_ID3;
145 
146  if (!lpd.buf)
147  lpd.buf = (unsigned char *) zerobuffer;
148 
149  if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
150  int id3len = ff_id3v2_tag_len(lpd.buf);
151  if (lpd.buf_size > id3len + 16) {
152  if (lpd.buf_size < 2LL*id3len + 16)
153  nodat = ID3_ALMOST_GREATER_PROBE;
154  lpd.buf += id3len;
155  lpd.buf_size -= id3len;
156  } else if (id3len >= PROBE_BUF_MAX) {
157  nodat = ID3_GREATER_MAX_PROBE;
158  } else
159  nodat = ID3_GREATER_PROBE;
160  }
161 
162  while ((fmt1 = av_demuxer_iterate(&i))) {
163  if (fmt1->flags & AVFMT_EXPERIMENTAL)
164  continue;
165  if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
166  continue;
167  score = 0;
168  if (fmt1->read_probe) {
169  score = fmt1->read_probe(&lpd);
170  if (score)
171  av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
172  if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
173  switch (nodat) {
174  case NO_ID3:
175  score = FFMAX(score, 1);
176  break;
177  case ID3_GREATER_PROBE:
178  case ID3_ALMOST_GREATER_PROBE:
179  score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
180  break;
181  case ID3_GREATER_MAX_PROBE:
182  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
183  break;
184  }
185  }
186  } else if (fmt1->extensions) {
187  if (av_match_ext(lpd.filename, fmt1->extensions))
188  score = AVPROBE_SCORE_EXTENSION;
189  }
190  if (av_match_name(lpd.mime_type, fmt1->mime_type)) {
191  if (AVPROBE_SCORE_MIME > score) {
192  av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME);
193  score = AVPROBE_SCORE_MIME;
194  }
195  }
196  if (score > score_max) {
197  score_max = score;
198  fmt = fmt1;
199  } else if (score == score_max)
200  fmt = NULL;
201  }
202  if (nodat == ID3_GREATER_PROBE)
203  score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
204  *score_ret = score_max;
205 
206  return fmt;
207 }
208 
209  const AVInputFormat *av_probe_input_format2(const AVProbeData *pd,
210  int is_opened, int *score_max)
211 {
212  int score_ret;
213  const AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
214  if (score_ret > *score_max) {
215  *score_max = score_ret;
216  return fmt;
217  } else
218  return NULL;
219 }
220 
221  const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened)
222 {
223  int score = 0;
224  return av_probe_input_format2(pd, is_opened, &score);
225 }
226 
227  int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt,
228  const char *filename, void *logctx,
229  unsigned int offset, unsigned int max_probe_size)
230 {
231  AVProbeData pd = { filename ? filename : "" };
232  uint8_t *buf = NULL;
233  int ret = 0, probe_size, buf_offset = 0;
234  int score = 0;
235  int ret2;
236 
237  if (!max_probe_size)
238  max_probe_size = PROBE_BUF_MAX;
239  else if (max_probe_size < PROBE_BUF_MIN) {
240  av_log(logctx, AV_LOG_ERROR,
241  "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
242  return AVERROR(EINVAL);
243  }
244 
245  if (offset >= max_probe_size)
246  return AVERROR(EINVAL);
247 
248  if (pb->av_class) {
249  uint8_t *mime_type_opt = NULL;
250  char *semi;
251  av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
252  pd.mime_type = (const char *)mime_type_opt;
253  semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
254  if (semi) {
255  *semi = '0円';
256  }
257  }
258 
259  for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
260  probe_size = FFMIN(probe_size << 1,
261  FFMAX(max_probe_size, probe_size + 1))) {
262  score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
263 
264  /* Read probe data. */
265  if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
266  goto fail;
267  if ((ret = avio_read(pb, buf + buf_offset,
268  probe_size - buf_offset)) < 0) {
269  /* Fail if error was not end of file, otherwise, lower score. */
270  if (ret != AVERROR_EOF)
271  goto fail;
272 
273  score = 0;
274  ret = 0; /* error was end of file, nothing read */
275  }
276  buf_offset += ret;
277  if (buf_offset < offset)
278  continue;
279  pd.buf_size = buf_offset - offset;
280  pd.buf = &buf[offset];
281 
282  memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
283 
284  /* Guess file format. */
285  *fmt = av_probe_input_format2(&pd, 1, &score);
286  if (*fmt) {
287  /* This can only be true in the last iteration. */
288  if (score <= AVPROBE_SCORE_RETRY) {
289  av_log(logctx, AV_LOG_WARNING,
290  "Format %s detected only with low score of %d, "
291  "misdetection possible!\n", (*fmt)->name, score);
292  } else
293  av_log(logctx, AV_LOG_DEBUG,
294  "Format %s probed with size=%d and score=%d\n",
295  (*fmt)->name, probe_size, score);
296 #if 0
297  FILE *f = fopen("probestat.tmp", "ab");
298  fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
299  fclose(f);
300 #endif
301  }
302  }
303 
304  if (!*fmt)
305  ret = AVERROR_INVALIDDATA;
306 
307 fail:
308  /* Rewind. Reuse probe buffer to avoid seeking. */
309  ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
310  if (ret >= 0)
311  ret = ret2;
312 
313  av_freep(&pd.mime_type);
314  return ret < 0 ? ret : score;
315 }
316 
317  int av_probe_input_buffer(AVIOContext *pb, const AVInputFormat **fmt,
318  const char *filename, void *logctx,
319  unsigned int offset, unsigned int max_probe_size)
320 {
321  int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
322  return ret < 0 ? ret : 0;
323 }
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: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:227
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:113
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:456
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
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:125
fail
#define fail()
Definition: checkasm.h:131
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:467
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:130
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:656
AVProbeData::mime_type
const char * mime_type
mime_type, when known.
Definition: avformat.h:457
AVInputFormat::extensions
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:682
AVOutputFormat::data_codec
enum AVCodecID data_codec
default data codec
Definition: avformat.h:617
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVProbeData::filename
const char * filename
Definition: avformat.h:454
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:40
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:693
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:371
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
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:209
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:221
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:722
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:453
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:463
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
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:186
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:470
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:572
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:563
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:317
AVOutputFormat::mime_type
const char * mime_type
Definition: avformat.h:517
PROBE_BUF_MAX
#define PROBE_BUF_MAX
Definition: internal.h:36
bprint.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
avio_internal.h
AVPROBE_SCORE_MIME
#define AVPROBE_SCORE_MIME
score for file mime type
Definition: avformat.h:464
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVPROBE_SCORE_RETRY
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:460
AVFMT_EXPERIMENTAL
#define AVFMT_EXPERIMENTAL
The muxer/demuxer is experimental and should be used with caution.
Definition: avformat.h:478
ff_id3v2_tag_len
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
Definition: id3v2.c:157
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:89
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:553
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:675
PROBE_BUF_MIN
#define PROBE_BUF_MIN
size of probe buffer, for guessing file type from file contents
Definition: internal.h:35
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:356
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: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:120
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:53
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:1180
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:837
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_id3v2_match
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
Definition: id3v2.c:144
AVIOContext::av_class
const AVClass * av_class
A class for private options.
Definition: avio.h:175
Generated on Wed Aug 24 2022 21:42:14 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /