blob: 38ca2a3465affc59f7b6391774d8fd8dee013180
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/atomic.h" |
23 | #include "libavutil/avstring.h" |
24 | #include "libavutil/bprint.h" |
25 | #include "libavutil/opt.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 | /** head of registered input format linked list */ |
38 | static AVInputFormat *first_iformat = NULL; |
39 | /** head of registered output format linked list */ |
40 | static AVOutputFormat *first_oformat = NULL; |
41 | |
42 | static AVInputFormat **last_iformat = &first_iformat; |
43 | static AVOutputFormat **last_oformat = &first_oformat; |
44 | |
45 | AVInputFormat *av_iformat_next(const AVInputFormat *f) |
46 | { |
47 | if (f) |
48 | return f->next; |
49 | else |
50 | return first_iformat; |
51 | } |
52 | |
53 | AVOutputFormat *av_oformat_next(const AVOutputFormat *f) |
54 | { |
55 | if (f) |
56 | return f->next; |
57 | else |
58 | return first_oformat; |
59 | } |
60 | |
61 | void av_register_input_format(AVInputFormat *format) |
62 | { |
63 | AVInputFormat **p = last_iformat; |
64 | |
65 | // Note, format could be added after the first 2 checks but that implies that *p is no longer NULL |
66 | while(p != &format->next && !format->next && avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format)) |
67 | p = &(*p)->next; |
68 | |
69 | if (!format->next) |
70 | last_iformat = &format->next; |
71 | } |
72 | |
73 | void av_register_output_format(AVOutputFormat *format) |
74 | { |
75 | AVOutputFormat **p = last_oformat; |
76 | |
77 | // Note, format could be added after the first 2 checks but that implies that *p is no longer NULL |
78 | while(p != &format->next && !format->next && avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format)) |
79 | p = &(*p)->next; |
80 | |
81 | if (!format->next) |
82 | last_oformat = &format->next; |
83 | } |
84 | |
85 | int av_match_ext(const char *filename, const char *extensions) |
86 | { |
87 | const char *ext; |
88 | |
89 | if (!filename) |
90 | return 0; |
91 | |
92 | ext = strrchr(filename, '.'); |
93 | if (ext) |
94 | return av_match_name(ext + 1, extensions); |
95 | return 0; |
96 | } |
97 | |
98 | AVOutputFormat *av_guess_format(const char *short_name, const char *filename, |
99 | const char *mime_type) |
100 | { |
101 | AVOutputFormat *fmt = NULL, *fmt_found; |
102 | int score_max, score; |
103 | |
104 | /* specific test for image sequences */ |
105 | #if CONFIG_IMAGE2_MUXER |
106 | if (!short_name && filename && |
107 | av_filename_number_test(filename) && |
108 | ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) { |
109 | return av_guess_format("image2", NULL, NULL); |
110 | } |
111 | #endif |
112 | /* Find the proper file type. */ |
113 | fmt_found = NULL; |
114 | score_max = 0; |
115 | while ((fmt = av_oformat_next(fmt))) { |
116 | score = 0; |
117 | if (fmt->name && short_name && av_match_name(short_name, fmt->name)) |
118 | score += 100; |
119 | if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type)) |
120 | score += 10; |
121 | if (filename && fmt->extensions && |
122 | av_match_ext(filename, fmt->extensions)) { |
123 | score += 5; |
124 | } |
125 | if (score > score_max) { |
126 | score_max = score; |
127 | fmt_found = fmt; |
128 | } |
129 | } |
130 | return fmt_found; |
131 | } |
132 | |
133 | enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, |
134 | const char *filename, const char *mime_type, |
135 | enum AVMediaType type) |
136 | { |
137 | if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) { |
138 | AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL); |
139 | if (fmt2) |
140 | fmt = fmt2; |
141 | } |
142 | |
143 | if (type == AVMEDIA_TYPE_VIDEO) { |
144 | enum AVCodecID codec_id = AV_CODEC_ID_NONE; |
145 | |
146 | #if CONFIG_IMAGE2_MUXER |
147 | if (!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")) { |
148 | codec_id = ff_guess_image2_codec(filename); |
149 | } |
150 | #endif |
151 | if (codec_id == AV_CODEC_ID_NONE) |
152 | codec_id = fmt->video_codec; |
153 | return codec_id; |
154 | } else if (type == AVMEDIA_TYPE_AUDIO) |
155 | return fmt->audio_codec; |
156 | else if (type == AVMEDIA_TYPE_SUBTITLE) |
157 | return fmt->subtitle_codec; |
158 | else if (type == AVMEDIA_TYPE_DATA) |
159 | return fmt->data_codec; |
160 | else |
161 | return AV_CODEC_ID_NONE; |
162 | } |
163 | |
164 | AVInputFormat *av_find_input_format(const char *short_name) |
165 | { |
166 | AVInputFormat *fmt = NULL; |
167 | while ((fmt = av_iformat_next(fmt))) |
168 | if (av_match_name(short_name, fmt->name)) |
169 | return fmt; |
170 | return NULL; |
171 | } |
172 | |
173 | AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, |
174 | int *score_ret) |
175 | { |
176 | AVProbeData lpd = *pd; |
177 | AVInputFormat *fmt1 = NULL, *fmt; |
178 | int score, score_max = 0; |
179 | const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE]; |
180 | enum nodat { |
181 | NO_ID3, |
182 | ID3_ALMOST_GREATER_PROBE, |
183 | ID3_GREATER_PROBE, |
184 | ID3_GREATER_MAX_PROBE, |
185 | } nodat = NO_ID3; |
186 | |
187 | if (!lpd.buf) |
188 | lpd.buf = (unsigned char *) zerobuffer; |
189 | |
190 | if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) { |
191 | int id3len = ff_id3v2_tag_len(lpd.buf); |
192 | if (lpd.buf_size > id3len + 16) { |
193 | if (lpd.buf_size < 2LL*id3len + 16) |
194 | nodat = ID3_ALMOST_GREATER_PROBE; |
195 | lpd.buf += id3len; |
196 | lpd.buf_size -= id3len; |
197 | } else if (id3len >= PROBE_BUF_MAX) { |
198 | nodat = ID3_GREATER_MAX_PROBE; |
199 | } else |
200 | nodat = ID3_GREATER_PROBE; |
201 | } |
202 | |
203 | fmt = NULL; |
204 | while ((fmt1 = av_iformat_next(fmt1))) { |
205 | if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2")) |
206 | continue; |
207 | score = 0; |
208 | if (fmt1->read_probe) { |
209 | score = fmt1->read_probe(&lpd); |
210 | if (score) |
211 | av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size); |
212 | if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) { |
213 | switch (nodat) { |
214 | case NO_ID3: |
215 | score = FFMAX(score, 1); |
216 | break; |
217 | case ID3_GREATER_PROBE: |
218 | case ID3_ALMOST_GREATER_PROBE: |
219 | score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1); |
220 | break; |
221 | case ID3_GREATER_MAX_PROBE: |
222 | score = FFMAX(score, AVPROBE_SCORE_EXTENSION); |
223 | break; |
224 | } |
225 | } |
226 | } else if (fmt1->extensions) { |
227 | if (av_match_ext(lpd.filename, fmt1->extensions)) |
228 | score = AVPROBE_SCORE_EXTENSION; |
229 | } |
230 | if (av_match_name(lpd.mime_type, fmt1->mime_type)) { |
231 | if (AVPROBE_SCORE_MIME > score) { |
232 | av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME); |
233 | score = AVPROBE_SCORE_MIME; |
234 | } |
235 | } |
236 | if (score > score_max) { |
237 | score_max = score; |
238 | fmt = fmt1; |
239 | } else if (score == score_max) |
240 | fmt = NULL; |
241 | } |
242 | if (nodat == ID3_GREATER_PROBE) |
243 | score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max); |
244 | *score_ret = score_max; |
245 | |
246 | return fmt; |
247 | } |
248 | |
249 | AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max) |
250 | { |
251 | int score_ret; |
252 | AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret); |
253 | if (score_ret > *score_max) { |
254 | *score_max = score_ret; |
255 | return fmt; |
256 | } else |
257 | return NULL; |
258 | } |
259 | |
260 | AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened) |
261 | { |
262 | int score = 0; |
263 | return av_probe_input_format2(pd, is_opened, &score); |
264 | } |
265 | |
266 | int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt, |
267 | const char *filename, void *logctx, |
268 | unsigned int offset, unsigned int max_probe_size) |
269 | { |
270 | AVProbeData pd = { filename ? filename : "" }; |
271 | uint8_t *buf = NULL; |
272 | int ret = 0, probe_size, buf_offset = 0; |
273 | int score = 0; |
274 | int ret2; |
275 | |
276 | if (!max_probe_size) |
277 | max_probe_size = PROBE_BUF_MAX; |
278 | else if (max_probe_size < PROBE_BUF_MIN) { |
279 | av_log(logctx, AV_LOG_ERROR, |
280 | "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN); |
281 | return AVERROR(EINVAL); |
282 | } |
283 | |
284 | if (offset >= max_probe_size) |
285 | return AVERROR(EINVAL); |
286 | |
287 | if (pb->av_class) { |
288 | uint8_t *mime_type_opt = NULL; |
289 | char *semi; |
290 | av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt); |
291 | pd.mime_type = (const char *)mime_type_opt; |
292 | semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL; |
293 | if (semi) { |
294 | *semi = '\0'; |
295 | } |
296 | } |
297 | #if 0 |
298 | if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) { |
299 | if (!av_strcasecmp(mime_type, "audio/aacp")) { |
300 | *fmt = av_find_input_format("aac"); |
301 | } |
302 | av_freep(&mime_type); |
303 | } |
304 | #endif |
305 | |
306 | for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt; |
307 | probe_size = FFMIN(probe_size << 1, |
308 | FFMAX(max_probe_size, probe_size + 1))) { |
309 | score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0; |
310 | |
311 | /* Read probe data. */ |
312 | if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0) |
313 | goto fail; |
314 | if ((ret = avio_read(pb, buf + buf_offset, |
315 | probe_size - buf_offset)) < 0) { |
316 | /* Fail if error was not end of file, otherwise, lower score. */ |
317 | if (ret != AVERROR_EOF) |
318 | goto fail; |
319 | |
320 | score = 0; |
321 | ret = 0; /* error was end of file, nothing read */ |
322 | } |
323 | buf_offset += ret; |
324 | if (buf_offset < offset) |
325 | continue; |
326 | pd.buf_size = buf_offset - offset; |
327 | pd.buf = &buf[offset]; |
328 | |
329 | memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE); |
330 | |
331 | /* Guess file format. */ |
332 | *fmt = av_probe_input_format2(&pd, 1, &score); |
333 | if (*fmt) { |
334 | /* This can only be true in the last iteration. */ |
335 | if (score <= AVPROBE_SCORE_RETRY) { |
336 | av_log(logctx, AV_LOG_WARNING, |
337 | "Format %s detected only with low score of %d, " |
338 | "misdetection possible!\n", (*fmt)->name, score); |
339 | } else |
340 | av_log(logctx, AV_LOG_DEBUG, |
341 | "Format %s probed with size=%d and score=%d\n", |
342 | (*fmt)->name, probe_size, score); |
343 | #if 0 |
344 | FILE *f = fopen("probestat.tmp", "ab"); |
345 | fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename); |
346 | fclose(f); |
347 | #endif |
348 | } |
349 | } |
350 | |
351 | if (!*fmt) |
352 | ret = AVERROR_INVALIDDATA; |
353 | |
354 | fail: |
355 | /* Rewind. Reuse probe buffer to avoid seeking. */ |
356 | ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset); |
357 | if (ret >= 0) |
358 | ret = ret2; |
359 | |
360 | av_freep(&pd.mime_type); |
361 | return ret < 0 ? ret : score; |
362 | } |
363 | |
364 | int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt, |
365 | const char *filename, void *logctx, |
366 | unsigned int offset, unsigned int max_probe_size) |
367 | { |
368 | int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size); |
369 | return ret < 0 ? ret : 0; |
370 | } |
371 |