Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * AVI demuxer | |
3 | * Copyright (c) 2001 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 <inttypes.h> | |
23 | ||
24 | #include "libavutil/avassert.h" | |
25 | #include "libavutil/avstring.h" | |
26 | #include "libavutil/bswap.h" | |
27 | #include "libavutil/opt.h" | |
28 | #include "libavutil/dict.h" | |
29 | #include "libavutil/internal.h" | |
30 | #include "libavutil/intreadwrite.h" | |
31 | #include "libavutil/mathematics.h" | |
32 | #include "avformat.h" | |
33 | #include "avi.h" | |
34 | #include "dv.h" | |
35 | #include "internal.h" | |
36 | #include "riff.h" | |
37 | #include "libavcodec/bytestream.h" | |
38 | #include "libavcodec/exif.h" | |
39 | ||
40 | typedef struct AVIStream { | |
41 | int64_t frame_offset; /* current frame (video) or byte (audio) counter | |
42 | * (used to compute the pts) */ | |
43 | int remaining; | |
44 | int packet_size; | |
45 | ||
46 | uint32_t scale; | |
47 | uint32_t rate; | |
48 | int sample_size; /* size of one sample (or packet) | |
49 | * (in the rate/scale sense) in bytes */ | |
50 | ||
51 | int64_t cum_len; /* temporary storage (used during seek) */ | |
52 | int prefix; /* normally 'd'<<8 + 'c' or 'w'<<8 + 'b' */ | |
53 | int prefix_count; | |
54 | uint32_t pal[256]; | |
55 | int has_pal; | |
56 | int dshow_block_align; /* block align variable used to emulate bugs in | |
57 | * the MS dshow demuxer */ | |
58 | ||
59 | AVFormatContext *sub_ctx; | |
60 | AVPacket sub_pkt; | |
61 | uint8_t *sub_buffer; | |
62 | ||
63 | int64_t seek_pos; | |
64 | } AVIStream; | |
65 | ||
66 | typedef struct { | |
67 | const AVClass *class; | |
68 | int64_t riff_end; | |
69 | int64_t movi_end; | |
70 | int64_t fsize; | |
71 | int64_t io_fsize; | |
72 | int64_t movi_list; | |
73 | int64_t last_pkt_pos; | |
74 | int index_loaded; | |
75 | int is_odml; | |
76 | int non_interleaved; | |
77 | int stream_index; | |
78 | DVDemuxContext *dv_demux; | |
79 | int odml_depth; | |
80 | int use_odml; | |
81 | #define MAX_ODML_DEPTH 1000 | |
82 | int64_t dts_max; | |
83 | } AVIContext; | |
84 | ||
85 | ||
86 | static const AVOption options[] = { | |
87 | { "use_odml", "use odml index", offsetof(AVIContext, use_odml), AV_OPT_TYPE_INT, {.i64 = 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM}, | |
88 | { NULL }, | |
89 | }; | |
90 | ||
91 | static const AVClass demuxer_class = { | |
92 | .class_name = "avi", | |
93 | .item_name = av_default_item_name, | |
94 | .option = options, | |
95 | .version = LIBAVUTIL_VERSION_INT, | |
96 | .category = AV_CLASS_CATEGORY_DEMUXER, | |
97 | }; | |
98 | ||
99 | ||
100 | static const char avi_headers[][8] = { | |
101 | { 'R', 'I', 'F', 'F', 'A', 'V', 'I', ' ' }, | |
102 | { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 'X' }, | |
103 | { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 0x19 }, | |
104 | { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f' }, | |
105 | { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' ' }, | |
106 | { 0 } | |
107 | }; | |
108 | ||
109 | static const AVMetadataConv avi_metadata_conv[] = { | |
110 | { "strn", "title" }, | |
111 | { 0 }, | |
112 | }; | |
113 | ||
114 | static int avi_load_index(AVFormatContext *s); | |
115 | static int guess_ni_flag(AVFormatContext *s); | |
116 | ||
117 | #define print_tag(str, tag, size) \ | |
118 | av_dlog(NULL, "pos:%"PRIX64" %s: tag=%c%c%c%c size=0x%x\n", \ | |
119 | avio_tell(pb), str, tag & 0xff, \ | |
120 | (tag >> 8) & 0xff, \ | |
121 | (tag >> 16) & 0xff, \ | |
122 | (tag >> 24) & 0xff, \ | |
123 | size) | |
124 | ||
125 | static inline int get_duration(AVIStream *ast, int len) | |
126 | { | |
127 | if (ast->sample_size) | |
128 | return len; | |
129 | else if (ast->dshow_block_align) | |
130 | return (len + ast->dshow_block_align - 1) / ast->dshow_block_align; | |
131 | else | |
132 | return 1; | |
133 | } | |
134 | ||
135 | static int get_riff(AVFormatContext *s, AVIOContext *pb) | |
136 | { | |
137 | AVIContext *avi = s->priv_data; | |
138 | char header[8]; | |
139 | int i; | |
140 | ||
141 | /* check RIFF header */ | |
142 | avio_read(pb, header, 4); | |
143 | avi->riff_end = avio_rl32(pb); /* RIFF chunk size */ | |
144 | avi->riff_end += avio_tell(pb); /* RIFF chunk end */ | |
145 | avio_read(pb, header + 4, 4); | |
146 | ||
147 | for (i = 0; avi_headers[i][0]; i++) | |
148 | if (!memcmp(header, avi_headers[i], 8)) | |
149 | break; | |
150 | if (!avi_headers[i][0]) | |
151 | return AVERROR_INVALIDDATA; | |
152 | ||
153 | if (header[7] == 0x19) | |
154 | av_log(s, AV_LOG_INFO, | |
155 | "This file has been generated by a totally broken muxer.\n"); | |
156 | ||
157 | return 0; | |
158 | } | |
159 | ||
160 | static int read_braindead_odml_indx(AVFormatContext *s, int frame_num) | |
161 | { | |
162 | AVIContext *avi = s->priv_data; | |
163 | AVIOContext *pb = s->pb; | |
164 | int longs_pre_entry = avio_rl16(pb); | |
165 | int index_sub_type = avio_r8(pb); | |
166 | int index_type = avio_r8(pb); | |
167 | int entries_in_use = avio_rl32(pb); | |
168 | int chunk_id = avio_rl32(pb); | |
169 | int64_t base = avio_rl64(pb); | |
170 | int stream_id = ((chunk_id & 0xFF) - '0') * 10 + | |
171 | ((chunk_id >> 8 & 0xFF) - '0'); | |
172 | AVStream *st; | |
173 | AVIStream *ast; | |
174 | int i; | |
175 | int64_t last_pos = -1; | |
176 | int64_t filesize = avi->fsize; | |
177 | ||
178 | av_dlog(s, | |
179 | "longs_pre_entry:%d index_type:%d entries_in_use:%d " | |
180 | "chunk_id:%X base:%16"PRIX64"\n", | |
181 | longs_pre_entry, | |
182 | index_type, | |
183 | entries_in_use, | |
184 | chunk_id, | |
185 | base); | |
186 | ||
187 | if (stream_id >= s->nb_streams || stream_id < 0) | |
188 | return AVERROR_INVALIDDATA; | |
189 | st = s->streams[stream_id]; | |
190 | ast = st->priv_data; | |
191 | ||
192 | if (index_sub_type) | |
193 | return AVERROR_INVALIDDATA; | |
194 | ||
195 | avio_rl32(pb); | |
196 | ||
197 | if (index_type && longs_pre_entry != 2) | |
198 | return AVERROR_INVALIDDATA; | |
199 | if (index_type > 1) | |
200 | return AVERROR_INVALIDDATA; | |
201 | ||
202 | if (filesize > 0 && base >= filesize) { | |
203 | av_log(s, AV_LOG_ERROR, "ODML index invalid\n"); | |
204 | if (base >> 32 == (base & 0xFFFFFFFF) && | |
205 | (base & 0xFFFFFFFF) < filesize && | |
206 | filesize <= 0xFFFFFFFF) | |
207 | base &= 0xFFFFFFFF; | |
208 | else | |
209 | return AVERROR_INVALIDDATA; | |
210 | } | |
211 | ||
212 | for (i = 0; i < entries_in_use; i++) { | |
213 | if (index_type) { | |
214 | int64_t pos = avio_rl32(pb) + base - 8; | |
215 | int len = avio_rl32(pb); | |
216 | int key = len >= 0; | |
217 | len &= 0x7FFFFFFF; | |
218 | ||
219 | #ifdef DEBUG_SEEK | |
220 | av_log(s, AV_LOG_ERROR, "pos:%"PRId64", len:%X\n", pos, len); | |
221 | #endif | |
222 | if (avio_feof(pb)) | |
223 | return AVERROR_INVALIDDATA; | |
224 | ||
225 | if (last_pos == pos || pos == base - 8) | |
226 | avi->non_interleaved = 1; | |
227 | if (last_pos != pos && len) | |
228 | av_add_index_entry(st, pos, ast->cum_len, len, 0, | |
229 | key ? AVINDEX_KEYFRAME : 0); | |
230 | ||
231 | ast->cum_len += get_duration(ast, len); | |
232 | last_pos = pos; | |
233 | } else { | |
234 | int64_t offset, pos; | |
235 | int duration; | |
236 | offset = avio_rl64(pb); | |
237 | avio_rl32(pb); /* size */ | |
238 | duration = avio_rl32(pb); | |
239 | ||
240 | if (avio_feof(pb)) | |
241 | return AVERROR_INVALIDDATA; | |
242 | ||
243 | pos = avio_tell(pb); | |
244 | ||
245 | if (avi->odml_depth > MAX_ODML_DEPTH) { | |
246 | av_log(s, AV_LOG_ERROR, "Too deeply nested ODML indexes\n"); | |
247 | return AVERROR_INVALIDDATA; | |
248 | } | |
249 | ||
250 | if (avio_seek(pb, offset + 8, SEEK_SET) < 0) | |
251 | return -1; | |
252 | avi->odml_depth++; | |
253 | read_braindead_odml_indx(s, frame_num); | |
254 | avi->odml_depth--; | |
255 | frame_num += duration; | |
256 | ||
257 | if (avio_seek(pb, pos, SEEK_SET) < 0) { | |
258 | av_log(s, AV_LOG_ERROR, "Failed to restore position after reading index\n"); | |
259 | return -1; | |
260 | } | |
261 | ||
262 | } | |
263 | } | |
264 | avi->index_loaded = 2; | |
265 | return 0; | |
266 | } | |
267 | ||
268 | static void clean_index(AVFormatContext *s) | |
269 | { | |
270 | int i; | |
271 | int64_t j; | |
272 | ||
273 | for (i = 0; i < s->nb_streams; i++) { | |
274 | AVStream *st = s->streams[i]; | |
275 | AVIStream *ast = st->priv_data; | |
276 | int n = st->nb_index_entries; | |
277 | int max = ast->sample_size; | |
278 | int64_t pos, size, ts; | |
279 | ||
280 | if (n != 1 || ast->sample_size == 0) | |
281 | continue; | |
282 | ||
283 | while (max < 1024) | |
284 | max += max; | |
285 | ||
286 | pos = st->index_entries[0].pos; | |
287 | size = st->index_entries[0].size; | |
288 | ts = st->index_entries[0].timestamp; | |
289 | ||
290 | for (j = 0; j < size; j += max) | |
291 | av_add_index_entry(st, pos + j, ts + j, FFMIN(max, size - j), 0, | |
292 | AVINDEX_KEYFRAME); | |
293 | } | |
294 | } | |
295 | ||
296 | static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag, | |
297 | uint32_t size) | |
298 | { | |
299 | AVIOContext *pb = s->pb; | |
300 | char key[5] = { 0 }; | |
301 | char *value; | |
302 | ||
303 | size += (size & 1); | |
304 | ||
305 | if (size == UINT_MAX) | |
306 | return AVERROR(EINVAL); | |
307 | value = av_malloc(size + 1); | |
308 | if (!value) | |
309 | return AVERROR(ENOMEM); | |
310 | avio_read(pb, value, size); | |
311 | value[size] = 0; | |
312 | ||
313 | AV_WL32(key, tag); | |
314 | ||
315 | return av_dict_set(st ? &st->metadata : &s->metadata, key, value, | |
316 | AV_DICT_DONT_STRDUP_VAL); | |
317 | } | |
318 | ||
319 | static const char months[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
320 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; | |
321 | ||
322 | static void avi_metadata_creation_time(AVDictionary **metadata, char *date) | |
323 | { | |
324 | char month[4], time[9], buffer[64]; | |
325 | int i, day, year; | |
326 | /* parse standard AVI date format (ie. "Mon Mar 10 15:04:43 2003") */ | |
327 | if (sscanf(date, "%*3s%*[ ]%3s%*[ ]%2d%*[ ]%8s%*[ ]%4d", | |
328 | month, &day, time, &year) == 4) { | |
329 | for (i = 0; i < 12; i++) | |
330 | if (!av_strcasecmp(month, months[i])) { | |
331 | snprintf(buffer, sizeof(buffer), "%.4d-%.2d-%.2d %s", | |
332 | year, i + 1, day, time); | |
333 | av_dict_set(metadata, "creation_time", buffer, 0); | |
334 | } | |
335 | } else if (date[4] == '/' && date[7] == '/') { | |
336 | date[4] = date[7] = '-'; | |
337 | av_dict_set(metadata, "creation_time", date, 0); | |
338 | } | |
339 | } | |
340 | ||
341 | static void avi_read_nikon(AVFormatContext *s, uint64_t end) | |
342 | { | |
343 | while (avio_tell(s->pb) < end) { | |
344 | uint32_t tag = avio_rl32(s->pb); | |
345 | uint32_t size = avio_rl32(s->pb); | |
346 | switch (tag) { | |
347 | case MKTAG('n', 'c', 't', 'g'): /* Nikon Tags */ | |
348 | { | |
349 | uint64_t tag_end = avio_tell(s->pb) + size; | |
350 | while (avio_tell(s->pb) < tag_end) { | |
351 | uint16_t tag = avio_rl16(s->pb); | |
352 | uint16_t size = avio_rl16(s->pb); | |
353 | const char *name = NULL; | |
354 | char buffer[64] = { 0 }; | |
355 | size = FFMIN(size, tag_end - avio_tell(s->pb)); | |
356 | size -= avio_read(s->pb, buffer, | |
357 | FFMIN(size, sizeof(buffer) - 1)); | |
358 | switch (tag) { | |
359 | case 0x03: | |
360 | name = "maker"; | |
361 | break; | |
362 | case 0x04: | |
363 | name = "model"; | |
364 | break; | |
365 | case 0x13: | |
366 | name = "creation_time"; | |
367 | if (buffer[4] == ':' && buffer[7] == ':') | |
368 | buffer[4] = buffer[7] = '-'; | |
369 | break; | |
370 | } | |
371 | if (name) | |
372 | av_dict_set(&s->metadata, name, buffer, 0); | |
373 | avio_skip(s->pb, size); | |
374 | } | |
375 | break; | |
376 | } | |
377 | default: | |
378 | avio_skip(s->pb, size); | |
379 | break; | |
380 | } | |
381 | } | |
382 | } | |
383 | ||
384 | static int avi_extract_stream_metadata(AVStream *st) | |
385 | { | |
386 | GetByteContext gb; | |
387 | uint8_t *data = st->codec->extradata; | |
388 | int data_size = st->codec->extradata_size; | |
389 | int tag, offset; | |
390 | ||
391 | if (!data || data_size < 8) { | |
392 | return AVERROR_INVALIDDATA; | |
393 | } | |
394 | ||
395 | bytestream2_init(&gb, data, data_size); | |
396 | ||
397 | tag = bytestream2_get_le32(&gb); | |
398 | ||
399 | switch (tag) { | |
400 | case MKTAG('A', 'V', 'I', 'F'): | |
401 | // skip 4 byte padding | |
402 | bytestream2_skip(&gb, 4); | |
403 | offset = bytestream2_tell(&gb); | |
404 | bytestream2_init(&gb, data + offset, data_size - offset); | |
405 | ||
406 | // decode EXIF tags from IFD, AVI is always little-endian | |
407 | return avpriv_exif_decode_ifd(st->codec, &gb, 1, 0, &st->metadata); | |
408 | break; | |
409 | case MKTAG('C', 'A', 'S', 'I'): | |
410 | avpriv_request_sample(st->codec, "RIFF stream data tag type CASI (%u)", tag); | |
411 | break; | |
412 | case MKTAG('Z', 'o', 'r', 'a'): | |
413 | avpriv_request_sample(st->codec, "RIFF stream data tag type Zora (%u)", tag); | |
414 | break; | |
415 | default: | |
416 | break; | |
417 | } | |
418 | ||
419 | return 0; | |
420 | } | |
421 | ||
422 | static int calculate_bitrate(AVFormatContext *s) | |
423 | { | |
424 | AVIContext *avi = s->priv_data; | |
425 | int i, j; | |
426 | int64_t lensum = 0; | |
427 | int64_t maxpos = 0; | |
428 | ||
429 | for (i = 0; i<s->nb_streams; i++) { | |
430 | int64_t len = 0; | |
431 | AVStream *st = s->streams[i]; | |
432 | ||
433 | if (!st->nb_index_entries) | |
434 | continue; | |
435 | ||
436 | for (j = 0; j < st->nb_index_entries; j++) | |
437 | len += st->index_entries[j].size; | |
438 | maxpos = FFMAX(maxpos, st->index_entries[j-1].pos); | |
439 | lensum += len; | |
440 | } | |
441 | if (maxpos < avi->io_fsize*9/10) // index does not cover the whole file | |
442 | return 0; | |
443 | if (lensum*9/10 > maxpos || lensum < maxpos*9/10) // frame sum and filesize mismatch | |
444 | return 0; | |
445 | ||
446 | for (i = 0; i<s->nb_streams; i++) { | |
447 | int64_t len = 0; | |
448 | AVStream *st = s->streams[i]; | |
449 | int64_t duration; | |
450 | ||
451 | for (j = 0; j < st->nb_index_entries; j++) | |
452 | len += st->index_entries[j].size; | |
453 | ||
454 | if (st->nb_index_entries < 2 || st->codec->bit_rate > 0) | |
455 | continue; | |
456 | duration = st->index_entries[j-1].timestamp - st->index_entries[0].timestamp; | |
457 | st->codec->bit_rate = av_rescale(8*len, st->time_base.den, duration * st->time_base.num); | |
458 | } | |
459 | return 1; | |
460 | } | |
461 | ||
462 | static int avi_read_header(AVFormatContext *s) | |
463 | { | |
464 | AVIContext *avi = s->priv_data; | |
465 | AVIOContext *pb = s->pb; | |
466 | unsigned int tag, tag1, handler; | |
467 | int codec_type, stream_index, frame_period; | |
468 | unsigned int size; | |
469 | int i; | |
470 | AVStream *st; | |
471 | AVIStream *ast = NULL; | |
472 | int avih_width = 0, avih_height = 0; | |
473 | int amv_file_format = 0; | |
474 | uint64_t list_end = 0; | |
475 | int ret; | |
476 | AVDictionaryEntry *dict_entry; | |
477 | ||
478 | avi->stream_index = -1; | |
479 | ||
480 | ret = get_riff(s, pb); | |
481 | if (ret < 0) | |
482 | return ret; | |
483 | ||
484 | av_log(avi, AV_LOG_DEBUG, "use odml:%d\n", avi->use_odml); | |
485 | ||
486 | avi->io_fsize = avi->fsize = avio_size(pb); | |
487 | if (avi->fsize <= 0 || avi->fsize < avi->riff_end) | |
488 | avi->fsize = avi->riff_end == 8 ? INT64_MAX : avi->riff_end; | |
489 | ||
490 | /* first list tag */ | |
491 | stream_index = -1; | |
492 | codec_type = -1; | |
493 | frame_period = 0; | |
494 | for (;;) { | |
495 | if (avio_feof(pb)) | |
496 | goto fail; | |
497 | tag = avio_rl32(pb); | |
498 | size = avio_rl32(pb); | |
499 | ||
500 | print_tag("tag", tag, size); | |
501 | ||
502 | switch (tag) { | |
503 | case MKTAG('L', 'I', 'S', 'T'): | |
504 | list_end = avio_tell(pb) + size; | |
505 | /* Ignored, except at start of video packets. */ | |
506 | tag1 = avio_rl32(pb); | |
507 | ||
508 | print_tag("list", tag1, 0); | |
509 | ||
510 | if (tag1 == MKTAG('m', 'o', 'v', 'i')) { | |
511 | avi->movi_list = avio_tell(pb) - 4; | |
512 | if (size) | |
513 | avi->movi_end = avi->movi_list + size + (size & 1); | |
514 | else | |
515 | avi->movi_end = avi->fsize; | |
516 | av_dlog(NULL, "movi end=%"PRIx64"\n", avi->movi_end); | |
517 | goto end_of_header; | |
518 | } else if (tag1 == MKTAG('I', 'N', 'F', 'O')) | |
519 | ff_read_riff_info(s, size - 4); | |
520 | else if (tag1 == MKTAG('n', 'c', 'd', 't')) | |
521 | avi_read_nikon(s, list_end); | |
522 | ||
523 | break; | |
524 | case MKTAG('I', 'D', 'I', 'T'): | |
525 | { | |
526 | unsigned char date[64] = { 0 }; | |
527 | size += (size & 1); | |
528 | size -= avio_read(pb, date, FFMIN(size, sizeof(date) - 1)); | |
529 | avio_skip(pb, size); | |
530 | avi_metadata_creation_time(&s->metadata, date); | |
531 | break; | |
532 | } | |
533 | case MKTAG('d', 'm', 'l', 'h'): | |
534 | avi->is_odml = 1; | |
535 | avio_skip(pb, size + (size & 1)); | |
536 | break; | |
537 | case MKTAG('a', 'm', 'v', 'h'): | |
538 | amv_file_format = 1; | |
539 | case MKTAG('a', 'v', 'i', 'h'): | |
540 | /* AVI header */ | |
541 | /* using frame_period is bad idea */ | |
542 | frame_period = avio_rl32(pb); | |
543 | avio_rl32(pb); /* max. bytes per second */ | |
544 | avio_rl32(pb); | |
545 | avi->non_interleaved |= avio_rl32(pb) & AVIF_MUSTUSEINDEX; | |
546 | ||
547 | avio_skip(pb, 2 * 4); | |
548 | avio_rl32(pb); | |
549 | avio_rl32(pb); | |
550 | avih_width = avio_rl32(pb); | |
551 | avih_height = avio_rl32(pb); | |
552 | ||
553 | avio_skip(pb, size - 10 * 4); | |
554 | break; | |
555 | case MKTAG('s', 't', 'r', 'h'): | |
556 | /* stream header */ | |
557 | ||
558 | tag1 = avio_rl32(pb); | |
559 | handler = avio_rl32(pb); /* codec tag */ | |
560 | ||
561 | if (tag1 == MKTAG('p', 'a', 'd', 's')) { | |
562 | avio_skip(pb, size - 8); | |
563 | break; | |
564 | } else { | |
565 | stream_index++; | |
566 | st = avformat_new_stream(s, NULL); | |
567 | if (!st) | |
568 | goto fail; | |
569 | ||
570 | st->id = stream_index; | |
571 | ast = av_mallocz(sizeof(AVIStream)); | |
572 | if (!ast) | |
573 | goto fail; | |
574 | st->priv_data = ast; | |
575 | } | |
576 | if (amv_file_format) | |
577 | tag1 = stream_index ? MKTAG('a', 'u', 'd', 's') | |
578 | : MKTAG('v', 'i', 'd', 's'); | |
579 | ||
580 | print_tag("strh", tag1, -1); | |
581 | ||
582 | if (tag1 == MKTAG('i', 'a', 'v', 's') || | |
583 | tag1 == MKTAG('i', 'v', 'a', 's')) { | |
584 | int64_t dv_dur; | |
585 | ||
586 | /* After some consideration -- I don't think we | |
587 | * have to support anything but DV in type1 AVIs. */ | |
588 | if (s->nb_streams != 1) | |
589 | goto fail; | |
590 | ||
591 | if (handler != MKTAG('d', 'v', 's', 'd') && | |
592 | handler != MKTAG('d', 'v', 'h', 'd') && | |
593 | handler != MKTAG('d', 'v', 's', 'l')) | |
594 | goto fail; | |
595 | ||
596 | ast = s->streams[0]->priv_data; | |
597 | av_freep(&s->streams[0]->codec->extradata); | |
598 | av_freep(&s->streams[0]->codec); | |
599 | if (s->streams[0]->info) | |
600 | av_freep(&s->streams[0]->info->duration_error); | |
601 | av_freep(&s->streams[0]->info); | |
602 | av_freep(&s->streams[0]); | |
603 | s->nb_streams = 0; | |
604 | if (CONFIG_DV_DEMUXER) { | |
605 | avi->dv_demux = avpriv_dv_init_demux(s); | |
606 | if (!avi->dv_demux) | |
607 | goto fail; | |
608 | } else | |
609 | goto fail; | |
610 | s->streams[0]->priv_data = ast; | |
611 | avio_skip(pb, 3 * 4); | |
612 | ast->scale = avio_rl32(pb); | |
613 | ast->rate = avio_rl32(pb); | |
614 | avio_skip(pb, 4); /* start time */ | |
615 | ||
616 | dv_dur = avio_rl32(pb); | |
617 | if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) { | |
618 | dv_dur *= AV_TIME_BASE; | |
619 | s->duration = av_rescale(dv_dur, ast->scale, ast->rate); | |
620 | } | |
621 | /* else, leave duration alone; timing estimation in utils.c | |
622 | * will make a guess based on bitrate. */ | |
623 | ||
624 | stream_index = s->nb_streams - 1; | |
625 | avio_skip(pb, size - 9 * 4); | |
626 | break; | |
627 | } | |
628 | ||
629 | av_assert0(stream_index < s->nb_streams); | |
630 | st->codec->stream_codec_tag = handler; | |
631 | ||
632 | avio_rl32(pb); /* flags */ | |
633 | avio_rl16(pb); /* priority */ | |
634 | avio_rl16(pb); /* language */ | |
635 | avio_rl32(pb); /* initial frame */ | |
636 | ast->scale = avio_rl32(pb); | |
637 | ast->rate = avio_rl32(pb); | |
638 | if (!(ast->scale && ast->rate)) { | |
639 | av_log(s, AV_LOG_WARNING, | |
640 | "scale/rate is %"PRIu32"/%"PRIu32" which is invalid. " | |
641 | "(This file has been generated by broken software.)\n", | |
642 | ast->scale, | |
643 | ast->rate); | |
644 | if (frame_period) { | |
645 | ast->rate = 1000000; | |
646 | ast->scale = frame_period; | |
647 | } else { | |
648 | ast->rate = 25; | |
649 | ast->scale = 1; | |
650 | } | |
651 | } | |
652 | avpriv_set_pts_info(st, 64, ast->scale, ast->rate); | |
653 | ||
654 | ast->cum_len = avio_rl32(pb); /* start */ | |
655 | st->nb_frames = avio_rl32(pb); | |
656 | ||
657 | st->start_time = 0; | |
658 | avio_rl32(pb); /* buffer size */ | |
659 | avio_rl32(pb); /* quality */ | |
660 | if (ast->cum_len*ast->scale/ast->rate > 3600) { | |
661 | av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n"); | |
662 | return AVERROR_INVALIDDATA; | |
663 | } | |
664 | ast->sample_size = avio_rl32(pb); /* sample ssize */ | |
665 | ast->cum_len *= FFMAX(1, ast->sample_size); | |
666 | av_dlog(s, "%"PRIu32" %"PRIu32" %d\n", | |
667 | ast->rate, ast->scale, ast->sample_size); | |
668 | ||
669 | switch (tag1) { | |
670 | case MKTAG('v', 'i', 'd', 's'): | |
671 | codec_type = AVMEDIA_TYPE_VIDEO; | |
672 | ||
673 | ast->sample_size = 0; | |
674 | st->avg_frame_rate = av_inv_q(st->time_base); | |
675 | break; | |
676 | case MKTAG('a', 'u', 'd', 's'): | |
677 | codec_type = AVMEDIA_TYPE_AUDIO; | |
678 | break; | |
679 | case MKTAG('t', 'x', 't', 's'): | |
680 | codec_type = AVMEDIA_TYPE_SUBTITLE; | |
681 | break; | |
682 | case MKTAG('d', 'a', 't', 's'): | |
683 | codec_type = AVMEDIA_TYPE_DATA; | |
684 | break; | |
685 | default: | |
686 | av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1); | |
687 | } | |
688 | if (ast->sample_size == 0) { | |
689 | st->duration = st->nb_frames; | |
690 | if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) { | |
691 | av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n"); | |
692 | st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end); | |
693 | } | |
694 | } | |
695 | ast->frame_offset = ast->cum_len; | |
696 | avio_skip(pb, size - 12 * 4); | |
697 | break; | |
698 | case MKTAG('s', 't', 'r', 'f'): | |
699 | /* stream header */ | |
700 | if (!size) | |
701 | break; | |
702 | if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) { | |
703 | avio_skip(pb, size); | |
704 | } else { | |
705 | uint64_t cur_pos = avio_tell(pb); | |
706 | unsigned esize; | |
707 | if (cur_pos < list_end) | |
708 | size = FFMIN(size, list_end - cur_pos); | |
709 | st = s->streams[stream_index]; | |
710 | if (st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) { | |
711 | avio_skip(pb, size); | |
712 | break; | |
713 | } | |
714 | switch (codec_type) { | |
715 | case AVMEDIA_TYPE_VIDEO: | |
716 | if (amv_file_format) { | |
717 | st->codec->width = avih_width; | |
718 | st->codec->height = avih_height; | |
719 | st->codec->codec_type = AVMEDIA_TYPE_VIDEO; | |
720 | st->codec->codec_id = AV_CODEC_ID_AMV; | |
721 | avio_skip(pb, size); | |
722 | break; | |
723 | } | |
724 | tag1 = ff_get_bmp_header(pb, st, &esize); | |
725 | ||
726 | if (tag1 == MKTAG('D', 'X', 'S', 'B') || | |
727 | tag1 == MKTAG('D', 'X', 'S', 'A')) { | |
728 | st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; | |
729 | st->codec->codec_tag = tag1; | |
730 | st->codec->codec_id = AV_CODEC_ID_XSUB; | |
731 | break; | |
732 | } | |
733 | ||
734 | if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) { | |
735 | if (esize == size-1 && (esize&1)) { | |
736 | st->codec->extradata_size = esize - 10 * 4; | |
737 | } else | |
738 | st->codec->extradata_size = size - 10 * 4; | |
739 | if (ff_get_extradata(st->codec, pb, st->codec->extradata_size) < 0) | |
740 | return AVERROR(ENOMEM); | |
741 | } | |
742 | ||
743 | // FIXME: check if the encoder really did this correctly | |
744 | if (st->codec->extradata_size & 1) | |
745 | avio_r8(pb); | |
746 | ||
747 | /* Extract palette from extradata if bpp <= 8. | |
748 | * This code assumes that extradata contains only palette. | |
749 | * This is true for all paletted codecs implemented in | |
750 | * FFmpeg. */ | |
751 | if (st->codec->extradata_size && | |
752 | (st->codec->bits_per_coded_sample <= 8)) { | |
753 | int pal_size = (1 << st->codec->bits_per_coded_sample) << 2; | |
754 | const uint8_t *pal_src; | |
755 | ||
756 | pal_size = FFMIN(pal_size, st->codec->extradata_size); | |
757 | pal_src = st->codec->extradata + | |
758 | st->codec->extradata_size - pal_size; | |
f6fa7814 DM |
759 | /* Exclude the "BottomUp" field from the palette */ |
760 | if (pal_src - st->codec->extradata >= 9 && | |
761 | !memcmp(st->codec->extradata + st->codec->extradata_size - 9, "BottomUp", 9)) | |
762 | pal_src -= 9; | |
2ba45a60 DM |
763 | for (i = 0; i < pal_size / 4; i++) |
764 | ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src+4*i); | |
765 | ast->has_pal = 1; | |
766 | } | |
767 | ||
768 | print_tag("video", tag1, 0); | |
769 | ||
770 | st->codec->codec_type = AVMEDIA_TYPE_VIDEO; | |
771 | st->codec->codec_tag = tag1; | |
772 | st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, | |
773 | tag1); | |
774 | /* This is needed to get the pict type which is necessary | |
775 | * for generating correct pts. */ | |
776 | st->need_parsing = AVSTREAM_PARSE_HEADERS; | |
777 | if (st->codec->codec_tag == MKTAG('V', 'S', 'S', 'H')) | |
778 | st->need_parsing = AVSTREAM_PARSE_FULL; | |
779 | ||
780 | if (st->codec->codec_tag == 0 && st->codec->height > 0 && | |
781 | st->codec->extradata_size < 1U << 30) { | |
782 | st->codec->extradata_size += 9; | |
783 | if ((ret = av_reallocp(&st->codec->extradata, | |
784 | st->codec->extradata_size + | |
785 | FF_INPUT_BUFFER_PADDING_SIZE)) < 0) { | |
786 | st->codec->extradata_size = 0; | |
787 | return ret; | |
788 | } else | |
789 | memcpy(st->codec->extradata + st->codec->extradata_size - 9, | |
790 | "BottomUp", 9); | |
791 | } | |
792 | st->codec->height = FFABS(st->codec->height); | |
793 | ||
794 | // avio_skip(pb, size - 5 * 4); | |
795 | break; | |
796 | case AVMEDIA_TYPE_AUDIO: | |
797 | ret = ff_get_wav_header(pb, st->codec, size); | |
798 | if (ret < 0) | |
799 | return ret; | |
800 | ast->dshow_block_align = st->codec->block_align; | |
801 | if (ast->sample_size && st->codec->block_align && | |
802 | ast->sample_size != st->codec->block_align) { | |
803 | av_log(s, | |
804 | AV_LOG_WARNING, | |
805 | "sample size (%d) != block align (%d)\n", | |
806 | ast->sample_size, | |
807 | st->codec->block_align); | |
808 | ast->sample_size = st->codec->block_align; | |
809 | } | |
810 | /* 2-aligned | |
811 | * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */ | |
812 | if (size & 1) | |
813 | avio_skip(pb, 1); | |
814 | /* Force parsing as several audio frames can be in | |
815 | * one packet and timestamps refer to packet start. */ | |
816 | st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS; | |
817 | /* ADTS header is in extradata, AAC without header must be | |
818 | * stored as exact frames. Parser not needed and it will | |
819 | * fail. */ | |
820 | if (st->codec->codec_id == AV_CODEC_ID_AAC && | |
821 | st->codec->extradata_size) | |
822 | st->need_parsing = AVSTREAM_PARSE_NONE; | |
823 | /* AVI files with Xan DPCM audio (wrongly) declare PCM | |
824 | * audio in the header but have Axan as stream_code_tag. */ | |
825 | if (st->codec->stream_codec_tag == AV_RL32("Axan")) { | |
826 | st->codec->codec_id = AV_CODEC_ID_XAN_DPCM; | |
827 | st->codec->codec_tag = 0; | |
828 | ast->dshow_block_align = 0; | |
829 | } | |
830 | if (amv_file_format) { | |
831 | st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_AMV; | |
832 | ast->dshow_block_align = 0; | |
833 | } | |
834 | if (st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align <= 4 && ast->dshow_block_align) { | |
835 | av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align); | |
836 | ast->dshow_block_align = 0; | |
837 | } | |
838 | if (st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 || | |
839 | st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 || | |
840 | st->codec->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) { | |
841 | av_log(s, AV_LOG_DEBUG, "overriding sample_size\n"); | |
842 | ast->sample_size = 0; | |
843 | } | |
844 | break; | |
845 | case AVMEDIA_TYPE_SUBTITLE: | |
846 | st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; | |
847 | st->request_probe= 1; | |
848 | avio_skip(pb, size); | |
849 | break; | |
850 | default: | |
851 | st->codec->codec_type = AVMEDIA_TYPE_DATA; | |
852 | st->codec->codec_id = AV_CODEC_ID_NONE; | |
853 | st->codec->codec_tag = 0; | |
854 | avio_skip(pb, size); | |
855 | break; | |
856 | } | |
857 | } | |
858 | break; | |
859 | case MKTAG('s', 't', 'r', 'd'): | |
860 | if (stream_index >= (unsigned)s->nb_streams | |
861 | || s->streams[stream_index]->codec->extradata_size | |
862 | || s->streams[stream_index]->codec->codec_tag == MKTAG('H','2','6','4')) { | |
863 | avio_skip(pb, size); | |
864 | } else { | |
865 | uint64_t cur_pos = avio_tell(pb); | |
866 | if (cur_pos < list_end) | |
867 | size = FFMIN(size, list_end - cur_pos); | |
868 | st = s->streams[stream_index]; | |
869 | ||
870 | if (size<(1<<30)) { | |
871 | if (ff_get_extradata(st->codec, pb, size) < 0) | |
872 | return AVERROR(ENOMEM); | |
873 | } | |
874 | ||
875 | if (st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly | |
876 | avio_r8(pb); | |
877 | ||
878 | ret = avi_extract_stream_metadata(st); | |
879 | if (ret < 0) { | |
880 | av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n"); | |
881 | } | |
882 | } | |
883 | break; | |
884 | case MKTAG('i', 'n', 'd', 'x'): | |
885 | i = avio_tell(pb); | |
886 | if (pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) && | |
887 | avi->use_odml && | |
888 | read_braindead_odml_indx(s, 0) < 0 && | |
889 | (s->error_recognition & AV_EF_EXPLODE)) | |
890 | goto fail; | |
891 | avio_seek(pb, i + size, SEEK_SET); | |
892 | break; | |
893 | case MKTAG('v', 'p', 'r', 'p'): | |
894 | if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) { | |
895 | AVRational active, active_aspect; | |
896 | ||
897 | st = s->streams[stream_index]; | |
898 | avio_rl32(pb); | |
899 | avio_rl32(pb); | |
900 | avio_rl32(pb); | |
901 | avio_rl32(pb); | |
902 | avio_rl32(pb); | |
903 | ||
904 | active_aspect.den = avio_rl16(pb); | |
905 | active_aspect.num = avio_rl16(pb); | |
906 | active.num = avio_rl32(pb); | |
907 | active.den = avio_rl32(pb); | |
908 | avio_rl32(pb); // nbFieldsPerFrame | |
909 | ||
910 | if (active_aspect.num && active_aspect.den && | |
911 | active.num && active.den) { | |
912 | st->sample_aspect_ratio = av_div_q(active_aspect, active); | |
913 | av_dlog(s, "vprp %d/%d %d/%d\n", | |
914 | active_aspect.num, active_aspect.den, | |
915 | active.num, active.den); | |
916 | } | |
917 | size -= 9 * 4; | |
918 | } | |
919 | avio_skip(pb, size); | |
920 | break; | |
921 | case MKTAG('s', 't', 'r', 'n'): | |
922 | if (s->nb_streams) { | |
923 | ret = avi_read_tag(s, s->streams[s->nb_streams - 1], tag, size); | |
924 | if (ret < 0) | |
925 | return ret; | |
926 | break; | |
927 | } | |
928 | default: | |
929 | if (size > 1000000) { | |
930 | av_log(s, AV_LOG_ERROR, | |
931 | "Something went wrong during header parsing, " | |
932 | "I will ignore it and try to continue anyway.\n"); | |
933 | if (s->error_recognition & AV_EF_EXPLODE) | |
934 | goto fail; | |
935 | avi->movi_list = avio_tell(pb) - 4; | |
936 | avi->movi_end = avi->fsize; | |
937 | goto end_of_header; | |
938 | } | |
939 | /* skip tag */ | |
940 | size += (size & 1); | |
941 | avio_skip(pb, size); | |
942 | break; | |
943 | } | |
944 | } | |
945 | ||
946 | end_of_header: | |
947 | /* check stream number */ | |
948 | if (stream_index != s->nb_streams - 1) { | |
949 | ||
950 | fail: | |
951 | return AVERROR_INVALIDDATA; | |
952 | } | |
953 | ||
954 | if (!avi->index_loaded && pb->seekable) | |
955 | avi_load_index(s); | |
956 | calculate_bitrate(s); | |
957 | avi->index_loaded |= 1; | |
958 | ||
959 | if ((ret = guess_ni_flag(s)) < 0) | |
960 | return ret; | |
961 | ||
962 | avi->non_interleaved |= ret | (s->flags & AVFMT_FLAG_SORT_DTS); | |
963 | ||
964 | dict_entry = av_dict_get(s->metadata, "ISFT", NULL, 0); | |
965 | if (dict_entry && !strcmp(dict_entry->value, "PotEncoder")) | |
966 | for (i = 0; i < s->nb_streams; i++) { | |
967 | AVStream *st = s->streams[i]; | |
968 | if ( st->codec->codec_id == AV_CODEC_ID_MPEG1VIDEO | |
969 | || st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) | |
970 | st->need_parsing = AVSTREAM_PARSE_FULL; | |
971 | } | |
972 | ||
973 | for (i = 0; i < s->nb_streams; i++) { | |
974 | AVStream *st = s->streams[i]; | |
975 | if (st->nb_index_entries) | |
976 | break; | |
977 | } | |
978 | // DV-in-AVI cannot be non-interleaved, if set this must be | |
979 | // a mis-detection. | |
980 | if (avi->dv_demux) | |
981 | avi->non_interleaved = 0; | |
982 | if (i == s->nb_streams && avi->non_interleaved) { | |
983 | av_log(s, AV_LOG_WARNING, | |
984 | "Non-interleaved AVI without index, switching to interleaved\n"); | |
985 | avi->non_interleaved = 0; | |
986 | } | |
987 | ||
988 | if (avi->non_interleaved) { | |
989 | av_log(s, AV_LOG_INFO, "non-interleaved AVI\n"); | |
990 | clean_index(s); | |
991 | } | |
992 | ||
993 | ff_metadata_conv_ctx(s, NULL, avi_metadata_conv); | |
994 | ff_metadata_conv_ctx(s, NULL, ff_riff_info_conv); | |
995 | ||
996 | return 0; | |
997 | } | |
998 | ||
f6fa7814 | 999 | static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt) |
2ba45a60 DM |
1000 | { |
1001 | if (pkt->size >= 7 && | |
1002 | pkt->size < INT_MAX - AVPROBE_PADDING_SIZE && | |
1003 | !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) { | |
1004 | uint8_t desc[256]; | |
1005 | int score = AVPROBE_SCORE_EXTENSION, ret; | |
1006 | AVIStream *ast = st->priv_data; | |
1007 | AVInputFormat *sub_demuxer; | |
1008 | AVRational time_base; | |
1009 | int size; | |
1010 | AVIOContext *pb = avio_alloc_context(pkt->data + 7, | |
1011 | pkt->size - 7, | |
1012 | 0, NULL, NULL, NULL, NULL); | |
1013 | AVProbeData pd; | |
1014 | unsigned int desc_len = avio_rl32(pb); | |
1015 | ||
1016 | if (desc_len > pb->buf_end - pb->buf_ptr) | |
1017 | goto error; | |
1018 | ||
1019 | ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc)); | |
1020 | avio_skip(pb, desc_len - ret); | |
1021 | if (*desc) | |
1022 | av_dict_set(&st->metadata, "title", desc, 0); | |
1023 | ||
1024 | avio_rl16(pb); /* flags? */ | |
1025 | avio_rl32(pb); /* data size */ | |
1026 | ||
1027 | size = pb->buf_end - pb->buf_ptr; | |
1028 | pd = (AVProbeData) { .buf = av_mallocz(size + AVPROBE_PADDING_SIZE), | |
1029 | .buf_size = size }; | |
1030 | if (!pd.buf) | |
1031 | goto error; | |
1032 | memcpy(pd.buf, pb->buf_ptr, size); | |
1033 | sub_demuxer = av_probe_input_format2(&pd, 1, &score); | |
1034 | av_freep(&pd.buf); | |
1035 | if (!sub_demuxer) | |
1036 | goto error; | |
1037 | ||
1038 | if (!(ast->sub_ctx = avformat_alloc_context())) | |
1039 | goto error; | |
1040 | ||
1041 | ast->sub_ctx->pb = pb; | |
f6fa7814 DM |
1042 | |
1043 | if (ff_copy_whitelists(ast->sub_ctx, s) < 0) | |
1044 | goto error; | |
1045 | ||
2ba45a60 DM |
1046 | if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) { |
1047 | ff_read_packet(ast->sub_ctx, &ast->sub_pkt); | |
1048 | *st->codec = *ast->sub_ctx->streams[0]->codec; | |
1049 | ast->sub_ctx->streams[0]->codec->extradata = NULL; | |
1050 | time_base = ast->sub_ctx->streams[0]->time_base; | |
1051 | avpriv_set_pts_info(st, 64, time_base.num, time_base.den); | |
1052 | } | |
1053 | ast->sub_buffer = pkt->data; | |
1054 | memset(pkt, 0, sizeof(*pkt)); | |
1055 | return 1; | |
1056 | ||
1057 | error: | |
f6fa7814 | 1058 | av_freep(&ast->sub_ctx); |
2ba45a60 DM |
1059 | av_freep(&pb); |
1060 | } | |
1061 | return 0; | |
1062 | } | |
1063 | ||
1064 | static AVStream *get_subtitle_pkt(AVFormatContext *s, AVStream *next_st, | |
1065 | AVPacket *pkt) | |
1066 | { | |
1067 | AVIStream *ast, *next_ast = next_st->priv_data; | |
1068 | int64_t ts, next_ts, ts_min = INT64_MAX; | |
1069 | AVStream *st, *sub_st = NULL; | |
1070 | int i; | |
1071 | ||
1072 | next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base, | |
1073 | AV_TIME_BASE_Q); | |
1074 | ||
1075 | for (i = 0; i < s->nb_streams; i++) { | |
1076 | st = s->streams[i]; | |
1077 | ast = st->priv_data; | |
1078 | if (st->discard < AVDISCARD_ALL && ast && ast->sub_pkt.data) { | |
1079 | ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q); | |
1080 | if (ts <= next_ts && ts < ts_min) { | |
1081 | ts_min = ts; | |
1082 | sub_st = st; | |
1083 | } | |
1084 | } | |
1085 | } | |
1086 | ||
1087 | if (sub_st) { | |
1088 | ast = sub_st->priv_data; | |
1089 | *pkt = ast->sub_pkt; | |
1090 | pkt->stream_index = sub_st->index; | |
1091 | ||
1092 | if (ff_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0) | |
1093 | ast->sub_pkt.data = NULL; | |
1094 | } | |
1095 | return sub_st; | |
1096 | } | |
1097 | ||
f6fa7814 | 1098 | static int get_stream_idx(const unsigned *d) |
2ba45a60 DM |
1099 | { |
1100 | if (d[0] >= '0' && d[0] <= '9' && | |
1101 | d[1] >= '0' && d[1] <= '9') { | |
1102 | return (d[0] - '0') * 10 + (d[1] - '0'); | |
1103 | } else { | |
1104 | return 100; // invalid stream ID | |
1105 | } | |
1106 | } | |
1107 | ||
1108 | /** | |
1109 | * | |
1110 | * @param exit_early set to 1 to just gather packet position without making the changes needed to actually read & return the packet | |
1111 | */ | |
1112 | static int avi_sync(AVFormatContext *s, int exit_early) | |
1113 | { | |
1114 | AVIContext *avi = s->priv_data; | |
1115 | AVIOContext *pb = s->pb; | |
1116 | int n; | |
1117 | unsigned int d[8]; | |
1118 | unsigned int size; | |
1119 | int64_t i, sync; | |
1120 | ||
1121 | start_sync: | |
1122 | memset(d, -1, sizeof(d)); | |
1123 | for (i = sync = avio_tell(pb); !avio_feof(pb); i++) { | |
1124 | int j; | |
1125 | ||
1126 | for (j = 0; j < 7; j++) | |
1127 | d[j] = d[j + 1]; | |
1128 | d[7] = avio_r8(pb); | |
1129 | ||
1130 | size = d[4] + (d[5] << 8) + (d[6] << 16) + (d[7] << 24); | |
1131 | ||
1132 | n = get_stream_idx(d + 2); | |
1133 | av_dlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n", | |
1134 | d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n); | |
1135 | if (i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127) | |
1136 | continue; | |
1137 | ||
1138 | // parse ix## | |
1139 | if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) || | |
1140 | // parse JUNK | |
1141 | (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') || | |
1142 | (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')) { | |
1143 | avio_skip(pb, size); | |
1144 | goto start_sync; | |
1145 | } | |
1146 | ||
1147 | // parse stray LIST | |
1148 | if (d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T') { | |
1149 | avio_skip(pb, 4); | |
1150 | goto start_sync; | |
1151 | } | |
1152 | ||
f6fa7814 | 1153 | n = get_stream_idx(d); |
2ba45a60 DM |
1154 | |
1155 | if (!((i - avi->last_pkt_pos) & 1) && | |
1156 | get_stream_idx(d + 1) < s->nb_streams) | |
1157 | continue; | |
1158 | ||
1159 | // detect ##ix chunk and skip | |
1160 | if (d[2] == 'i' && d[3] == 'x' && n < s->nb_streams) { | |
1161 | avio_skip(pb, size); | |
1162 | goto start_sync; | |
1163 | } | |
1164 | ||
f6fa7814 DM |
1165 | if (avi->dv_demux && n != 0) |
1166 | continue; | |
1167 | ||
2ba45a60 DM |
1168 | // parse ##dc/##wb |
1169 | if (n < s->nb_streams) { | |
1170 | AVStream *st; | |
1171 | AVIStream *ast; | |
1172 | st = s->streams[n]; | |
1173 | ast = st->priv_data; | |
1174 | ||
1175 | if (!ast) { | |
1176 | av_log(s, AV_LOG_WARNING, "Skipping foreign stream %d packet\n", n); | |
1177 | continue; | |
1178 | } | |
1179 | ||
1180 | if (s->nb_streams >= 2) { | |
1181 | AVStream *st1 = s->streams[1]; | |
1182 | AVIStream *ast1 = st1->priv_data; | |
1183 | // workaround for broken small-file-bug402.avi | |
1184 | if ( d[2] == 'w' && d[3] == 'b' | |
1185 | && n == 0 | |
1186 | && st ->codec->codec_type == AVMEDIA_TYPE_VIDEO | |
1187 | && st1->codec->codec_type == AVMEDIA_TYPE_AUDIO | |
1188 | && ast->prefix == 'd'*256+'c' | |
1189 | && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count) | |
1190 | ) { | |
1191 | n = 1; | |
1192 | st = st1; | |
1193 | ast = ast1; | |
1194 | av_log(s, AV_LOG_WARNING, | |
1195 | "Invalid stream + prefix combination, assuming audio.\n"); | |
1196 | } | |
1197 | } | |
1198 | ||
1199 | if (!avi->dv_demux && | |
1200 | ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* || | |
1201 | // FIXME: needs a little reordering | |
1202 | (st->discard >= AVDISCARD_NONKEY && | |
1203 | !(pkt->flags & AV_PKT_FLAG_KEY)) */ | |
1204 | || st->discard >= AVDISCARD_ALL)) { | |
1205 | if (!exit_early) { | |
1206 | ast->frame_offset += get_duration(ast, size); | |
1207 | avio_skip(pb, size); | |
1208 | goto start_sync; | |
1209 | } | |
1210 | } | |
1211 | ||
1212 | if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) { | |
1213 | int k = avio_r8(pb); | |
1214 | int last = (k + avio_r8(pb) - 1) & 0xFF; | |
1215 | ||
1216 | avio_rl16(pb); // flags | |
1217 | ||
1218 | // b + (g << 8) + (r << 16); | |
1219 | for (; k <= last; k++) | |
1220 | ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8; | |
1221 | ||
1222 | ast->has_pal = 1; | |
1223 | goto start_sync; | |
1224 | } else if (((ast->prefix_count < 5 || sync + 9 > i) && | |
1225 | d[2] < 128 && d[3] < 128) || | |
1226 | d[2] * 256 + d[3] == ast->prefix /* || | |
1227 | (d[2] == 'd' && d[3] == 'c') || | |
1228 | (d[2] == 'w' && d[3] == 'b') */) { | |
1229 | if (exit_early) | |
1230 | return 0; | |
1231 | if (d[2] * 256 + d[3] == ast->prefix) | |
1232 | ast->prefix_count++; | |
1233 | else { | |
1234 | ast->prefix = d[2] * 256 + d[3]; | |
1235 | ast->prefix_count = 0; | |
1236 | } | |
1237 | ||
1238 | avi->stream_index = n; | |
1239 | ast->packet_size = size + 8; | |
1240 | ast->remaining = size; | |
1241 | ||
1242 | if (size) { | |
1243 | uint64_t pos = avio_tell(pb) - 8; | |
1244 | if (!st->index_entries || !st->nb_index_entries || | |
1245 | st->index_entries[st->nb_index_entries - 1].pos < pos) { | |
1246 | av_add_index_entry(st, pos, ast->frame_offset, size, | |
1247 | 0, AVINDEX_KEYFRAME); | |
1248 | } | |
1249 | } | |
1250 | return 0; | |
1251 | } | |
1252 | } | |
1253 | } | |
1254 | ||
1255 | if (pb->error) | |
1256 | return pb->error; | |
1257 | return AVERROR_EOF; | |
1258 | } | |
1259 | ||
1260 | static int avi_read_packet(AVFormatContext *s, AVPacket *pkt) | |
1261 | { | |
1262 | AVIContext *avi = s->priv_data; | |
1263 | AVIOContext *pb = s->pb; | |
1264 | int err; | |
1265 | #if FF_API_DESTRUCT_PACKET | |
1266 | void *dstr; | |
1267 | #endif | |
1268 | ||
1269 | if (CONFIG_DV_DEMUXER && avi->dv_demux) { | |
1270 | int size = avpriv_dv_get_packet(avi->dv_demux, pkt); | |
1271 | if (size >= 0) | |
1272 | return size; | |
1273 | else | |
1274 | goto resync; | |
1275 | } | |
1276 | ||
1277 | if (avi->non_interleaved) { | |
1278 | int best_stream_index = 0; | |
1279 | AVStream *best_st = NULL; | |
1280 | AVIStream *best_ast; | |
1281 | int64_t best_ts = INT64_MAX; | |
1282 | int i; | |
1283 | ||
1284 | for (i = 0; i < s->nb_streams; i++) { | |
1285 | AVStream *st = s->streams[i]; | |
1286 | AVIStream *ast = st->priv_data; | |
1287 | int64_t ts = ast->frame_offset; | |
1288 | int64_t last_ts; | |
1289 | ||
1290 | if (!st->nb_index_entries) | |
1291 | continue; | |
1292 | ||
1293 | last_ts = st->index_entries[st->nb_index_entries - 1].timestamp; | |
1294 | if (!ast->remaining && ts > last_ts) | |
1295 | continue; | |
1296 | ||
1297 | ts = av_rescale_q(ts, st->time_base, | |
1298 | (AVRational) { FFMAX(1, ast->sample_size), | |
1299 | AV_TIME_BASE }); | |
1300 | ||
1301 | av_dlog(s, "%"PRId64" %d/%d %"PRId64"\n", ts, | |
1302 | st->time_base.num, st->time_base.den, ast->frame_offset); | |
1303 | if (ts < best_ts) { | |
1304 | best_ts = ts; | |
1305 | best_st = st; | |
1306 | best_stream_index = i; | |
1307 | } | |
1308 | } | |
1309 | if (!best_st) | |
1310 | return AVERROR_EOF; | |
1311 | ||
1312 | best_ast = best_st->priv_data; | |
1313 | best_ts = best_ast->frame_offset; | |
1314 | if (best_ast->remaining) { | |
1315 | i = av_index_search_timestamp(best_st, | |
1316 | best_ts, | |
1317 | AVSEEK_FLAG_ANY | | |
1318 | AVSEEK_FLAG_BACKWARD); | |
1319 | } else { | |
1320 | i = av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY); | |
1321 | if (i >= 0) | |
1322 | best_ast->frame_offset = best_st->index_entries[i].timestamp; | |
1323 | } | |
1324 | ||
1325 | if (i >= 0) { | |
1326 | int64_t pos = best_st->index_entries[i].pos; | |
1327 | pos += best_ast->packet_size - best_ast->remaining; | |
1328 | if (avio_seek(s->pb, pos + 8, SEEK_SET) < 0) | |
1329 | return AVERROR_EOF; | |
1330 | ||
1331 | av_assert0(best_ast->remaining <= best_ast->packet_size); | |
1332 | ||
1333 | avi->stream_index = best_stream_index; | |
1334 | if (!best_ast->remaining) | |
1335 | best_ast->packet_size = | |
1336 | best_ast->remaining = best_st->index_entries[i].size; | |
1337 | } | |
1338 | else | |
1339 | return AVERROR_EOF; | |
1340 | } | |
1341 | ||
1342 | resync: | |
1343 | if (avi->stream_index >= 0) { | |
1344 | AVStream *st = s->streams[avi->stream_index]; | |
1345 | AVIStream *ast = st->priv_data; | |
1346 | int size, err; | |
1347 | ||
1348 | if (get_subtitle_pkt(s, st, pkt)) | |
1349 | return 0; | |
1350 | ||
1351 | // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM | |
1352 | if (ast->sample_size <= 1) | |
1353 | size = INT_MAX; | |
1354 | else if (ast->sample_size < 32) | |
1355 | // arbitrary multiplier to avoid tiny packets for raw PCM data | |
1356 | size = 1024 * ast->sample_size; | |
1357 | else | |
1358 | size = ast->sample_size; | |
1359 | ||
1360 | if (size > ast->remaining) | |
1361 | size = ast->remaining; | |
1362 | avi->last_pkt_pos = avio_tell(pb); | |
1363 | err = av_get_packet(pb, pkt, size); | |
1364 | if (err < 0) | |
1365 | return err; | |
1366 | size = err; | |
1367 | ||
1368 | if (ast->has_pal && pkt->size < (unsigned)INT_MAX / 2) { | |
1369 | uint8_t *pal; | |
1370 | pal = av_packet_new_side_data(pkt, | |
1371 | AV_PKT_DATA_PALETTE, | |
1372 | AVPALETTE_SIZE); | |
1373 | if (!pal) { | |
1374 | av_log(s, AV_LOG_ERROR, | |
1375 | "Failed to allocate data for palette\n"); | |
1376 | } else { | |
1377 | memcpy(pal, ast->pal, AVPALETTE_SIZE); | |
1378 | ast->has_pal = 0; | |
1379 | } | |
1380 | } | |
1381 | ||
1382 | if (CONFIG_DV_DEMUXER && avi->dv_demux) { | |
1383 | AVBufferRef *avbuf = pkt->buf; | |
1384 | #if FF_API_DESTRUCT_PACKET | |
1385 | FF_DISABLE_DEPRECATION_WARNINGS | |
1386 | dstr = pkt->destruct; | |
1387 | FF_ENABLE_DEPRECATION_WARNINGS | |
1388 | #endif | |
1389 | size = avpriv_dv_produce_packet(avi->dv_demux, pkt, | |
1390 | pkt->data, pkt->size, pkt->pos); | |
1391 | #if FF_API_DESTRUCT_PACKET | |
1392 | FF_DISABLE_DEPRECATION_WARNINGS | |
1393 | pkt->destruct = dstr; | |
1394 | FF_ENABLE_DEPRECATION_WARNINGS | |
1395 | #endif | |
1396 | pkt->buf = avbuf; | |
1397 | pkt->flags |= AV_PKT_FLAG_KEY; | |
1398 | if (size < 0) | |
1399 | av_free_packet(pkt); | |
1400 | } else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE && | |
f6fa7814 | 1401 | !st->codec->codec_tag && read_gab2_sub(s, st, pkt)) { |
2ba45a60 DM |
1402 | ast->frame_offset++; |
1403 | avi->stream_index = -1; | |
1404 | ast->remaining = 0; | |
1405 | goto resync; | |
1406 | } else { | |
1407 | /* XXX: How to handle B-frames in AVI? */ | |
1408 | pkt->dts = ast->frame_offset; | |
1409 | // pkt->dts += ast->start; | |
1410 | if (ast->sample_size) | |
1411 | pkt->dts /= ast->sample_size; | |
1412 | av_dlog(s, | |
1413 | "dts:%"PRId64" offset:%"PRId64" %d/%d smpl_siz:%d " | |
1414 | "base:%d st:%d size:%d\n", | |
1415 | pkt->dts, | |
1416 | ast->frame_offset, | |
1417 | ast->scale, | |
1418 | ast->rate, | |
1419 | ast->sample_size, | |
1420 | AV_TIME_BASE, | |
1421 | avi->stream_index, | |
1422 | size); | |
1423 | pkt->stream_index = avi->stream_index; | |
1424 | ||
1425 | if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) { | |
1426 | AVIndexEntry *e; | |
1427 | int index; | |
1428 | ||
1429 | index = av_index_search_timestamp(st, ast->frame_offset, AVSEEK_FLAG_ANY); | |
1430 | e = &st->index_entries[index]; | |
1431 | ||
1432 | if (index >= 0 && e->timestamp == ast->frame_offset) { | |
1433 | if (index == st->nb_index_entries-1) { | |
1434 | int key=1; | |
1435 | int i; | |
1436 | uint32_t state=-1; | |
1437 | for (i=0; i<FFMIN(size,256); i++) { | |
1438 | if (st->codec->codec_id == AV_CODEC_ID_MPEG4) { | |
1439 | if (state == 0x1B6) { | |
1440 | key= !(pkt->data[i]&0xC0); | |
1441 | break; | |
1442 | } | |
1443 | }else | |
1444 | break; | |
1445 | state= (state<<8) + pkt->data[i]; | |
1446 | } | |
1447 | if (!key) | |
1448 | e->flags &= ~AVINDEX_KEYFRAME; | |
1449 | } | |
1450 | if (e->flags & AVINDEX_KEYFRAME) | |
1451 | pkt->flags |= AV_PKT_FLAG_KEY; | |
1452 | } | |
1453 | } else { | |
1454 | pkt->flags |= AV_PKT_FLAG_KEY; | |
1455 | } | |
1456 | ast->frame_offset += get_duration(ast, pkt->size); | |
1457 | } | |
1458 | ast->remaining -= err; | |
1459 | if (!ast->remaining) { | |
1460 | avi->stream_index = -1; | |
1461 | ast->packet_size = 0; | |
1462 | } | |
1463 | ||
1464 | if (!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos) { | |
1465 | av_free_packet(pkt); | |
1466 | goto resync; | |
1467 | } | |
1468 | ast->seek_pos= 0; | |
1469 | ||
1470 | if (!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1) { | |
1471 | int64_t dts= av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q); | |
1472 | ||
1473 | if (avi->dts_max - dts > 2*AV_TIME_BASE) { | |
1474 | avi->non_interleaved= 1; | |
1475 | av_log(s, AV_LOG_INFO, "Switching to NI mode, due to poor interleaving\n"); | |
1476 | }else if (avi->dts_max < dts) | |
1477 | avi->dts_max = dts; | |
1478 | } | |
1479 | ||
1480 | return 0; | |
1481 | } | |
1482 | ||
1483 | if ((err = avi_sync(s, 0)) < 0) | |
1484 | return err; | |
1485 | goto resync; | |
1486 | } | |
1487 | ||
1488 | /* XXX: We make the implicit supposition that the positions are sorted | |
1489 | * for each stream. */ | |
1490 | static int avi_read_idx1(AVFormatContext *s, int size) | |
1491 | { | |
1492 | AVIContext *avi = s->priv_data; | |
1493 | AVIOContext *pb = s->pb; | |
1494 | int nb_index_entries, i; | |
1495 | AVStream *st; | |
1496 | AVIStream *ast; | |
1497 | unsigned int index, tag, flags, pos, len, first_packet = 1; | |
1498 | unsigned last_pos = -1; | |
1499 | unsigned last_idx = -1; | |
1500 | int64_t idx1_pos, first_packet_pos = 0, data_offset = 0; | |
1501 | int anykey = 0; | |
1502 | ||
1503 | nb_index_entries = size / 16; | |
1504 | if (nb_index_entries <= 0) | |
1505 | return AVERROR_INVALIDDATA; | |
1506 | ||
1507 | idx1_pos = avio_tell(pb); | |
1508 | avio_seek(pb, avi->movi_list + 4, SEEK_SET); | |
1509 | if (avi_sync(s, 1) == 0) | |
1510 | first_packet_pos = avio_tell(pb) - 8; | |
1511 | avi->stream_index = -1; | |
1512 | avio_seek(pb, idx1_pos, SEEK_SET); | |
1513 | ||
1514 | if (s->nb_streams == 1 && s->streams[0]->codec->codec_tag == AV_RL32("MMES")) { | |
1515 | first_packet_pos = 0; | |
1516 | data_offset = avi->movi_list; | |
1517 | } | |
1518 | ||
1519 | /* Read the entries and sort them in each stream component. */ | |
1520 | for (i = 0; i < nb_index_entries; i++) { | |
1521 | if (avio_feof(pb)) | |
1522 | return -1; | |
1523 | ||
1524 | tag = avio_rl32(pb); | |
1525 | flags = avio_rl32(pb); | |
1526 | pos = avio_rl32(pb); | |
1527 | len = avio_rl32(pb); | |
1528 | av_dlog(s, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/", | |
1529 | i, tag, flags, pos, len); | |
1530 | ||
1531 | index = ((tag & 0xff) - '0') * 10; | |
1532 | index += (tag >> 8 & 0xff) - '0'; | |
1533 | if (index >= s->nb_streams) | |
1534 | continue; | |
1535 | st = s->streams[index]; | |
1536 | ast = st->priv_data; | |
1537 | ||
1538 | if (first_packet && first_packet_pos) { | |
1539 | data_offset = first_packet_pos - pos; | |
1540 | first_packet = 0; | |
1541 | } | |
1542 | pos += data_offset; | |
1543 | ||
1544 | av_dlog(s, "%d cum_len=%"PRId64"\n", len, ast->cum_len); | |
1545 | ||
1546 | // even if we have only a single stream, we should | |
1547 | // switch to non-interleaved to get correct timestamps | |
1548 | if (last_pos == pos) | |
1549 | avi->non_interleaved = 1; | |
1550 | if (last_idx != pos && len) { | |
1551 | av_add_index_entry(st, pos, ast->cum_len, len, 0, | |
1552 | (flags & AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0); | |
1553 | last_idx= pos; | |
1554 | } | |
1555 | ast->cum_len += get_duration(ast, len); | |
1556 | last_pos = pos; | |
1557 | anykey |= flags&AVIIF_INDEX; | |
1558 | } | |
1559 | if (!anykey) { | |
1560 | for (index = 0; index < s->nb_streams; index++) { | |
1561 | st = s->streams[index]; | |
1562 | if (st->nb_index_entries) | |
1563 | st->index_entries[0].flags |= AVINDEX_KEYFRAME; | |
1564 | } | |
1565 | } | |
1566 | return 0; | |
1567 | } | |
1568 | ||
1569 | /* Scan the index and consider any file with streams more than | |
1570 | * 2 seconds or 64MB apart non-interleaved. */ | |
1571 | static int check_stream_max_drift(AVFormatContext *s) | |
1572 | { | |
1573 | int64_t min_pos, pos; | |
1574 | int i; | |
1575 | int *idx = av_mallocz_array(s->nb_streams, sizeof(*idx)); | |
1576 | if (!idx) | |
1577 | return AVERROR(ENOMEM); | |
1578 | for (min_pos = pos = 0; min_pos != INT64_MAX; pos = min_pos + 1LU) { | |
1579 | int64_t max_dts = INT64_MIN / 2; | |
1580 | int64_t min_dts = INT64_MAX / 2; | |
1581 | int64_t max_buffer = 0; | |
1582 | ||
1583 | min_pos = INT64_MAX; | |
1584 | ||
1585 | for (i = 0; i < s->nb_streams; i++) { | |
1586 | AVStream *st = s->streams[i]; | |
1587 | AVIStream *ast = st->priv_data; | |
1588 | int n = st->nb_index_entries; | |
1589 | while (idx[i] < n && st->index_entries[idx[i]].pos < pos) | |
1590 | idx[i]++; | |
1591 | if (idx[i] < n) { | |
1592 | int64_t dts; | |
1593 | dts = av_rescale_q(st->index_entries[idx[i]].timestamp / | |
1594 | FFMAX(ast->sample_size, 1), | |
1595 | st->time_base, AV_TIME_BASE_Q); | |
1596 | min_dts = FFMIN(min_dts, dts); | |
1597 | min_pos = FFMIN(min_pos, st->index_entries[idx[i]].pos); | |
1598 | } | |
1599 | } | |
1600 | for (i = 0; i < s->nb_streams; i++) { | |
1601 | AVStream *st = s->streams[i]; | |
1602 | AVIStream *ast = st->priv_data; | |
1603 | ||
1604 | if (idx[i] && min_dts != INT64_MAX / 2) { | |
1605 | int64_t dts; | |
1606 | dts = av_rescale_q(st->index_entries[idx[i] - 1].timestamp / | |
1607 | FFMAX(ast->sample_size, 1), | |
1608 | st->time_base, AV_TIME_BASE_Q); | |
1609 | max_dts = FFMAX(max_dts, dts); | |
1610 | max_buffer = FFMAX(max_buffer, | |
1611 | av_rescale(dts - min_dts, | |
1612 | st->codec->bit_rate, | |
1613 | AV_TIME_BASE)); | |
1614 | } | |
1615 | } | |
1616 | if (max_dts - min_dts > 2 * AV_TIME_BASE || | |
1617 | max_buffer > 1024 * 1024 * 8 * 8) { | |
1618 | av_free(idx); | |
1619 | return 1; | |
1620 | } | |
1621 | } | |
1622 | av_free(idx); | |
1623 | return 0; | |
1624 | } | |
1625 | ||
1626 | static int guess_ni_flag(AVFormatContext *s) | |
1627 | { | |
1628 | int i; | |
1629 | int64_t last_start = 0; | |
1630 | int64_t first_end = INT64_MAX; | |
1631 | int64_t oldpos = avio_tell(s->pb); | |
1632 | ||
1633 | for (i = 0; i < s->nb_streams; i++) { | |
1634 | AVStream *st = s->streams[i]; | |
1635 | int n = st->nb_index_entries; | |
1636 | unsigned int size; | |
1637 | ||
1638 | if (n <= 0) | |
1639 | continue; | |
1640 | ||
1641 | if (n >= 2) { | |
1642 | int64_t pos = st->index_entries[0].pos; | |
1643 | avio_seek(s->pb, pos + 4, SEEK_SET); | |
1644 | size = avio_rl32(s->pb); | |
1645 | if (pos + size > st->index_entries[1].pos) | |
1646 | last_start = INT64_MAX; | |
1647 | } | |
1648 | ||
1649 | if (st->index_entries[0].pos > last_start) | |
1650 | last_start = st->index_entries[0].pos; | |
1651 | if (st->index_entries[n - 1].pos < first_end) | |
1652 | first_end = st->index_entries[n - 1].pos; | |
1653 | } | |
1654 | avio_seek(s->pb, oldpos, SEEK_SET); | |
1655 | ||
1656 | if (last_start > first_end) | |
1657 | return 1; | |
1658 | ||
1659 | return check_stream_max_drift(s); | |
1660 | } | |
1661 | ||
1662 | static int avi_load_index(AVFormatContext *s) | |
1663 | { | |
1664 | AVIContext *avi = s->priv_data; | |
1665 | AVIOContext *pb = s->pb; | |
1666 | uint32_t tag, size; | |
1667 | int64_t pos = avio_tell(pb); | |
1668 | int64_t next; | |
1669 | int ret = -1; | |
1670 | ||
1671 | if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0) | |
1672 | goto the_end; // maybe truncated file | |
1673 | av_dlog(s, "movi_end=0x%"PRIx64"\n", avi->movi_end); | |
1674 | for (;;) { | |
1675 | tag = avio_rl32(pb); | |
1676 | size = avio_rl32(pb); | |
1677 | if (avio_feof(pb)) | |
1678 | break; | |
1679 | next = avio_tell(pb) + size + (size & 1); | |
1680 | ||
1681 | av_dlog(s, "tag=%c%c%c%c size=0x%x\n", | |
1682 | tag & 0xff, | |
1683 | (tag >> 8) & 0xff, | |
1684 | (tag >> 16) & 0xff, | |
1685 | (tag >> 24) & 0xff, | |
1686 | size); | |
1687 | ||
1688 | if (tag == MKTAG('i', 'd', 'x', '1') && | |
1689 | avi_read_idx1(s, size) >= 0) { | |
1690 | avi->index_loaded=2; | |
1691 | ret = 0; | |
1692 | }else if (tag == MKTAG('L', 'I', 'S', 'T')) { | |
1693 | uint32_t tag1 = avio_rl32(pb); | |
1694 | ||
1695 | if (tag1 == MKTAG('I', 'N', 'F', 'O')) | |
1696 | ff_read_riff_info(s, size - 4); | |
1697 | }else if (!ret) | |
1698 | break; | |
1699 | ||
1700 | if (avio_seek(pb, next, SEEK_SET) < 0) | |
1701 | break; // something is wrong here | |
1702 | } | |
1703 | ||
1704 | the_end: | |
1705 | avio_seek(pb, pos, SEEK_SET); | |
1706 | return ret; | |
1707 | } | |
1708 | ||
1709 | static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp) | |
1710 | { | |
1711 | AVIStream *ast2 = st2->priv_data; | |
1712 | int64_t ts2 = av_rescale_q(timestamp, st->time_base, st2->time_base); | |
1713 | av_free_packet(&ast2->sub_pkt); | |
1714 | if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 || | |
1715 | avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0) | |
1716 | ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt); | |
1717 | } | |
1718 | ||
1719 | static int avi_read_seek(AVFormatContext *s, int stream_index, | |
1720 | int64_t timestamp, int flags) | |
1721 | { | |
1722 | AVIContext *avi = s->priv_data; | |
1723 | AVStream *st; | |
1724 | int i, index; | |
1725 | int64_t pos, pos_min; | |
1726 | AVIStream *ast; | |
1727 | ||
1728 | /* Does not matter which stream is requested dv in avi has the | |
1729 | * stream information in the first video stream. | |
1730 | */ | |
1731 | if (avi->dv_demux) | |
1732 | stream_index = 0; | |
1733 | ||
1734 | if (!avi->index_loaded) { | |
1735 | /* we only load the index on demand */ | |
1736 | avi_load_index(s); | |
1737 | avi->index_loaded |= 1; | |
1738 | } | |
1739 | av_assert0(stream_index >= 0); | |
1740 | ||
1741 | st = s->streams[stream_index]; | |
1742 | ast = st->priv_data; | |
1743 | index = av_index_search_timestamp(st, | |
1744 | timestamp * FFMAX(ast->sample_size, 1), | |
1745 | flags); | |
1746 | if (index < 0) { | |
1747 | if (st->nb_index_entries > 0) | |
1748 | av_log(s, AV_LOG_DEBUG, "Failed to find timestamp %"PRId64 " in index %"PRId64 " .. %"PRId64 "\n", | |
1749 | timestamp * FFMAX(ast->sample_size, 1), | |
1750 | st->index_entries[0].timestamp, | |
1751 | st->index_entries[st->nb_index_entries - 1].timestamp); | |
1752 | return AVERROR_INVALIDDATA; | |
1753 | } | |
1754 | ||
1755 | /* find the position */ | |
1756 | pos = st->index_entries[index].pos; | |
1757 | timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1); | |
1758 | ||
1759 | av_dlog(s, "XX %"PRId64" %d %"PRId64"\n", | |
1760 | timestamp, index, st->index_entries[index].timestamp); | |
1761 | ||
1762 | if (CONFIG_DV_DEMUXER && avi->dv_demux) { | |
1763 | /* One and only one real stream for DV in AVI, and it has video */ | |
1764 | /* offsets. Calling with other stream indexes should have failed */ | |
1765 | /* the av_index_search_timestamp call above. */ | |
1766 | ||
1767 | if (avio_seek(s->pb, pos, SEEK_SET) < 0) | |
1768 | return -1; | |
1769 | ||
1770 | /* Feed the DV video stream version of the timestamp to the */ | |
1771 | /* DV demux so it can synthesize correct timestamps. */ | |
1772 | ff_dv_offset_reset(avi->dv_demux, timestamp); | |
1773 | ||
1774 | avi->stream_index = -1; | |
1775 | return 0; | |
1776 | } | |
1777 | ||
1778 | pos_min = pos; | |
1779 | for (i = 0; i < s->nb_streams; i++) { | |
1780 | AVStream *st2 = s->streams[i]; | |
1781 | AVIStream *ast2 = st2->priv_data; | |
1782 | ||
1783 | ast2->packet_size = | |
1784 | ast2->remaining = 0; | |
1785 | ||
1786 | if (ast2->sub_ctx) { | |
1787 | seek_subtitle(st, st2, timestamp); | |
1788 | continue; | |
1789 | } | |
1790 | ||
1791 | if (st2->nb_index_entries <= 0) | |
1792 | continue; | |
1793 | ||
1794 | // av_assert1(st2->codec->block_align); | |
1795 | av_assert0(fabs(av_q2d(st2->time_base) - ast2->scale / (double)ast2->rate) < av_q2d(st2->time_base) * 0.00000001); | |
1796 | index = av_index_search_timestamp(st2, | |
1797 | av_rescale_q(timestamp, | |
1798 | st->time_base, | |
1799 | st2->time_base) * | |
1800 | FFMAX(ast2->sample_size, 1), | |
1801 | flags | | |
1802 | AVSEEK_FLAG_BACKWARD | | |
1803 | (st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0)); | |
1804 | if (index < 0) | |
1805 | index = 0; | |
1806 | ast2->seek_pos = st2->index_entries[index].pos; | |
1807 | pos_min = FFMIN(pos_min,ast2->seek_pos); | |
1808 | } | |
1809 | for (i = 0; i < s->nb_streams; i++) { | |
1810 | AVStream *st2 = s->streams[i]; | |
1811 | AVIStream *ast2 = st2->priv_data; | |
1812 | ||
1813 | if (ast2->sub_ctx || st2->nb_index_entries <= 0) | |
1814 | continue; | |
1815 | ||
1816 | index = av_index_search_timestamp( | |
1817 | st2, | |
1818 | av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1), | |
1819 | flags | AVSEEK_FLAG_BACKWARD | (st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0)); | |
1820 | if (index < 0) | |
1821 | index = 0; | |
1822 | while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min) | |
1823 | index--; | |
1824 | ast2->frame_offset = st2->index_entries[index].timestamp; | |
1825 | } | |
1826 | ||
1827 | /* do the seek */ | |
1828 | if (avio_seek(s->pb, pos_min, SEEK_SET) < 0) { | |
1829 | av_log(s, AV_LOG_ERROR, "Seek failed\n"); | |
1830 | return -1; | |
1831 | } | |
1832 | avi->stream_index = -1; | |
1833 | avi->dts_max = INT_MIN; | |
1834 | return 0; | |
1835 | } | |
1836 | ||
1837 | static int avi_read_close(AVFormatContext *s) | |
1838 | { | |
1839 | int i; | |
1840 | AVIContext *avi = s->priv_data; | |
1841 | ||
1842 | for (i = 0; i < s->nb_streams; i++) { | |
1843 | AVStream *st = s->streams[i]; | |
1844 | AVIStream *ast = st->priv_data; | |
1845 | if (ast) { | |
1846 | if (ast->sub_ctx) { | |
1847 | av_freep(&ast->sub_ctx->pb); | |
1848 | avformat_close_input(&ast->sub_ctx); | |
1849 | } | |
1850 | av_free(ast->sub_buffer); | |
1851 | av_free_packet(&ast->sub_pkt); | |
1852 | } | |
1853 | } | |
1854 | ||
1855 | av_free(avi->dv_demux); | |
1856 | ||
1857 | return 0; | |
1858 | } | |
1859 | ||
1860 | static int avi_probe(AVProbeData *p) | |
1861 | { | |
1862 | int i; | |
1863 | ||
1864 | /* check file header */ | |
1865 | for (i = 0; avi_headers[i][0]; i++) | |
1866 | if (!memcmp(p->buf, avi_headers[i], 4) && | |
1867 | !memcmp(p->buf + 8, avi_headers[i] + 4, 4)) | |
1868 | return AVPROBE_SCORE_MAX; | |
1869 | ||
1870 | return 0; | |
1871 | } | |
1872 | ||
1873 | AVInputFormat ff_avi_demuxer = { | |
1874 | .name = "avi", | |
1875 | .long_name = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"), | |
1876 | .priv_data_size = sizeof(AVIContext), | |
1877 | .extensions = "avi", | |
1878 | .read_probe = avi_probe, | |
1879 | .read_header = avi_read_header, | |
1880 | .read_packet = avi_read_packet, | |
1881 | .read_close = avi_read_close, | |
1882 | .read_seek = avi_read_seek, | |
1883 | .priv_class = &demuxer_class, | |
1884 | }; |