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