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