avformat: Free the internal codec context at the end
[libav.git] / libavformat / utils.c
1 /*
2 * various utility functions for use within Libav
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 *
5 * This file is part of Libav.
6 *
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #undef NDEBUG
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdint.h>
26
27 #include "config.h"
28
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38
39 #include "libavcodec/bytestream.h"
40 #include "libavcodec/internal.h"
41
42 #include "audiointerleave.h"
43 #include "avformat.h"
44 #include "id3v2.h"
45 #include "internal.h"
46 #include "metadata.h"
47 #if CONFIG_NETWORK
48 #include "network.h"
49 #endif
50 #include "riff.h"
51 #include "url.h"
52
53 /**
54 * @file
55 * various utility functions for use within Libav
56 */
57
58 unsigned avformat_version(void)
59 {
60 return LIBAVFORMAT_VERSION_INT;
61 }
62
63 const char *avformat_configuration(void)
64 {
65 return LIBAV_CONFIGURATION;
66 }
67
68 const char *avformat_license(void)
69 {
70 #define LICENSE_PREFIX "libavformat license: "
71 return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
72 }
73
74 /* an arbitrarily chosen "sane" max packet size -- 50M */
75 #define SANE_CHUNK_SIZE (50000000)
76
77 /* Read the data in sane-sized chunks and append to pkt.
78 * Return the number of bytes read or an error. */
79 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
80 {
81 int64_t chunk_size = size;
82 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
83 int orig_size = pkt->size;
84 int ret = 0;
85
86 do {
87 int prev_size = pkt->size;
88 int read_size;
89
90 /* When the caller requests a lot of data, limit it to the amount
91 * left in file or SANE_CHUNK_SIZE when it is not known. */
92 if (size > SANE_CHUNK_SIZE) {
93 int64_t filesize = avio_size(s) - avio_tell(s);
94 chunk_size = FFMAX(filesize, SANE_CHUNK_SIZE);
95 }
96 read_size = FFMIN(size, chunk_size);
97
98 ret = av_grow_packet(pkt, read_size);
99 if (ret < 0)
100 break;
101
102 ret = avio_read(s, pkt->data + prev_size, read_size);
103 if (ret != read_size) {
104 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
105 break;
106 }
107
108 size -= read_size;
109 } while (size > 0);
110
111 pkt->pos = orig_pos;
112 if (!pkt->size)
113 av_packet_unref(pkt);
114 return pkt->size > orig_size ? pkt->size - orig_size : ret;
115 }
116
117 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
118 {
119 av_init_packet(pkt);
120 pkt->data = NULL;
121 pkt->size = 0;
122 pkt->pos = avio_tell(s);
123
124 return append_packet_chunked(s, pkt, size);
125 }
126
127 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
128 {
129 if (!pkt->size)
130 return av_get_packet(s, pkt, size);
131 return append_packet_chunked(s, pkt, size);
132 }
133
134 int av_filename_number_test(const char *filename)
135 {
136 char buf[1024];
137 return filename &&
138 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
139 }
140
141 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
142 AVProbeData *pd, int score)
143 {
144 static const struct {
145 const char *name;
146 enum AVCodecID id;
147 enum AVMediaType type;
148 } fmt_id_type[] = {
149 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
150 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
151 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
152 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
153 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
154 { "latm", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
155 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
156 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
157 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
158 { 0 }
159 };
160 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
161
162 if (fmt) {
163 int i;
164 av_log(s, AV_LOG_DEBUG,
165 "Probe with size=%d, packets=%d detected %s with score=%d\n",
166 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
167 fmt->name, score);
168 for (i = 0; fmt_id_type[i].name; i++) {
169 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
170 st->codecpar->codec_id = fmt_id_type[i].id;
171 st->codecpar->codec_type = fmt_id_type[i].type;
172 #if FF_API_LAVF_AVCTX
173 FF_DISABLE_DEPRECATION_WARNINGS
174 st->codec->codec_type = st->codecpar->codec_type;
175 st->codec->codec_id = st->codecpar->codec_id;
176 FF_ENABLE_DEPRECATION_WARNINGS
177 #endif
178 break;
179 }
180 }
181 }
182 return !!fmt;
183 }
184
185 /************************************************************/
186 /* input media file */
187
188 /* Open input file and probe the format if necessary. */
189 static int init_input(AVFormatContext *s, const char *filename,
190 AVDictionary **options)
191 {
192 int ret;
193 AVProbeData pd = { filename, NULL, 0 };
194
195 if (s->pb) {
196 s->flags |= AVFMT_FLAG_CUSTOM_IO;
197 if (!s->iformat)
198 return av_probe_input_buffer(s->pb, &s->iformat, filename,
199 s, 0, s->probesize);
200 else if (s->iformat->flags & AVFMT_NOFILE)
201 return AVERROR(EINVAL);
202 return 0;
203 }
204
205 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
206 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
207 return 0;
208
209 ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ, options);
210 if (ret < 0)
211 return ret;
212 if (s->iformat)
213 return 0;
214 return av_probe_input_buffer(s->pb, &s->iformat, filename,
215 s, 0, s->probesize);
216 }
217
218 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
219 AVPacketList **plast_pktl, int ref)
220 {
221 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
222 int ret;
223
224 if (!pktl)
225 return AVERROR(ENOMEM);
226
227 if (ref) {
228 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
229 av_free(pktl);
230 return ret;
231 }
232 } else {
233 pktl->pkt = *pkt;
234 }
235
236 if (*packet_buffer)
237 (*plast_pktl)->next = pktl;
238 else
239 *packet_buffer = pktl;
240
241 /* Add the packet in the buffered packet list. */
242 *plast_pktl = pktl;
243 return 0;
244 }
245
246 static int queue_attached_pictures(AVFormatContext *s)
247 {
248 int i, ret;
249 for (i = 0; i < s->nb_streams; i++)
250 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
251 s->streams[i]->discard < AVDISCARD_ALL) {
252
253 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
254 &s->streams[i]->attached_pic,
255 &s->internal->raw_packet_buffer_end, 1);
256 if (ret < 0)
257 return ret;
258 }
259 return 0;
260 }
261
262 #if FF_API_LAVF_AVCTX
263 FF_DISABLE_DEPRECATION_WARNINGS
264 static int update_stream_avctx(AVFormatContext *s)
265 {
266 int i, ret;
267 for (i = 0; i < s->nb_streams; i++) {
268 AVStream *st = s->streams[i];
269
270 if (!st->internal->need_codec_update)
271 continue;
272
273 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
274 if (ret < 0)
275 return ret;
276
277 st->internal->need_codec_update = 0;
278 }
279 return 0;
280 }
281 FF_ENABLE_DEPRECATION_WARNINGS
282 #endif
283
284 int avformat_open_input(AVFormatContext **ps, const char *filename,
285 AVInputFormat *fmt, AVDictionary **options)
286 {
287 AVFormatContext *s = *ps;
288 int i, ret = 0;
289 AVDictionary *tmp = NULL;
290 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
291
292 if (!s && !(s = avformat_alloc_context()))
293 return AVERROR(ENOMEM);
294 if (fmt)
295 s->iformat = fmt;
296
297 if (options)
298 av_dict_copy(&tmp, *options, 0);
299
300 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
301 goto fail;
302
303 if ((ret = init_input(s, filename, &tmp)) < 0)
304 goto fail;
305
306 /* Check filename in case an image number is expected. */
307 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
308 if (!av_filename_number_test(filename)) {
309 ret = AVERROR(EINVAL);
310 goto fail;
311 }
312 }
313
314 s->duration = s->start_time = AV_NOPTS_VALUE;
315 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
316
317 /* Allocate private data. */
318 if (s->iformat->priv_data_size > 0) {
319 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
320 ret = AVERROR(ENOMEM);
321 goto fail;
322 }
323 if (s->iformat->priv_class) {
324 *(const AVClass **) s->priv_data = s->iformat->priv_class;
325 av_opt_set_defaults(s->priv_data);
326 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
327 goto fail;
328 }
329 }
330
331 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
332 if (s->pb)
333 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
334
335 if (s->iformat->read_header)
336 if ((ret = s->iformat->read_header(s)) < 0)
337 goto fail;
338
339 if (id3v2_extra_meta &&
340 (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
341 goto fail;
342 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
343
344 if ((ret = queue_attached_pictures(s)) < 0)
345 goto fail;
346
347 if (s->pb && !s->internal->data_offset)
348 s->internal->data_offset = avio_tell(s->pb);
349
350 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
351
352 #if FF_API_LAVF_AVCTX
353 update_stream_avctx(s);
354 #endif
355
356 for (i = 0; i < s->nb_streams; i++)
357 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
358
359 if (options) {
360 av_dict_free(options);
361 *options = tmp;
362 }
363 *ps = s;
364 return 0;
365
366 fail:
367 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
368 av_dict_free(&tmp);
369 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
370 avio_close(s->pb);
371 avformat_free_context(s);
372 *ps = NULL;
373 return ret;
374 }
375
376 /*******************************************************/
377
378 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
379 {
380 if (st->codecpar->codec_id == AV_CODEC_ID_PROBE) {
381 AVProbeData *pd = &st->probe_data;
382 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
383 --st->probe_packets;
384
385 if (pkt) {
386 int err;
387 if ((err = av_reallocp(&pd->buf, pd->buf_size + pkt->size +
388 AVPROBE_PADDING_SIZE)) < 0)
389 return err;
390 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
391 pd->buf_size += pkt->size;
392 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
393 } else {
394 st->probe_packets = 0;
395 if (!pd->buf_size) {
396 av_log(s, AV_LOG_ERROR,
397 "nothing to probe for stream %d\n", st->index);
398 return 0;
399 }
400 }
401
402 if (!st->probe_packets ||
403 av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
404 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0
405 ? AVPROBE_SCORE_MAX / 4 : 0);
406 if (st->codecpar->codec_id != AV_CODEC_ID_PROBE) {
407 pd->buf_size = 0;
408 av_freep(&pd->buf);
409 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
410 }
411 }
412 }
413 return 0;
414 }
415
416 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
417 {
418 int ret, i, err;
419 AVStream *st;
420
421 for (;;) {
422 AVPacketList *pktl = s->internal->raw_packet_buffer;
423
424 if (pktl) {
425 *pkt = pktl->pkt;
426 st = s->streams[pkt->stream_index];
427 if (st->codecpar->codec_id != AV_CODEC_ID_PROBE ||
428 !st->probe_packets ||
429 s->internal->raw_packet_buffer_remaining_size < pkt->size) {
430 AVProbeData *pd;
431 if (st->probe_packets)
432 if ((err = probe_codec(s, st, NULL)) < 0)
433 return err;
434 pd = &st->probe_data;
435 av_freep(&pd->buf);
436 pd->buf_size = 0;
437 s->internal->raw_packet_buffer = pktl->next;
438 s->internal->raw_packet_buffer_remaining_size += pkt->size;
439 av_free(pktl);
440 return 0;
441 }
442 }
443
444 pkt->data = NULL;
445 pkt->size = 0;
446 av_init_packet(pkt);
447 ret = s->iformat->read_packet(s, pkt);
448 if (ret < 0) {
449 if (!pktl || ret == AVERROR(EAGAIN))
450 return ret;
451 for (i = 0; i < s->nb_streams; i++) {
452 st = s->streams[i];
453 if (st->probe_packets)
454 if ((err = probe_codec(s, st, NULL)) < 0)
455 return err;
456 }
457 continue;
458 }
459
460 if (!pkt->buf) {
461 AVPacket tmp = { 0 };
462 ret = av_packet_ref(&tmp, pkt);
463 if (ret < 0)
464 return ret;
465 *pkt = tmp;
466 }
467
468 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
469 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
470 av_log(s, AV_LOG_WARNING,
471 "Dropped corrupted packet (stream = %d)\n",
472 pkt->stream_index);
473 av_packet_unref(pkt);
474 continue;
475 }
476
477 st = s->streams[pkt->stream_index];
478
479 switch (st->codecpar->codec_type) {
480 case AVMEDIA_TYPE_VIDEO:
481 if (s->video_codec_id)
482 st->codecpar->codec_id = s->video_codec_id;
483 break;
484 case AVMEDIA_TYPE_AUDIO:
485 if (s->audio_codec_id)
486 st->codecpar->codec_id = s->audio_codec_id;
487 break;
488 case AVMEDIA_TYPE_SUBTITLE:
489 if (s->subtitle_codec_id)
490 st->codecpar->codec_id = s->subtitle_codec_id;
491 break;
492 }
493
494 if (!pktl && (st->codecpar->codec_id != AV_CODEC_ID_PROBE ||
495 !st->probe_packets))
496 return ret;
497
498 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
499 &s->internal->raw_packet_buffer_end, 0);
500 if (err)
501 return err;
502 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
503
504 if ((err = probe_codec(s, st, pkt)) < 0)
505 return err;
506 }
507 }
508
509 /**********************************************************/
510
511 /**
512 * Return the frame duration in seconds. Return 0 if not available.
513 */
514 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
515 AVCodecParserContext *pc, AVPacket *pkt)
516 {
517 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
518 (AVRational){ 0, 1 };
519 int frame_size;
520
521 *pnum = 0;
522 *pden = 0;
523 switch (st->codecpar->codec_type) {
524 case AVMEDIA_TYPE_VIDEO:
525 if (st->avg_frame_rate.num) {
526 *pnum = st->avg_frame_rate.den;
527 *pden = st->avg_frame_rate.num;
528 } else if (st->time_base.num * 1000LL > st->time_base.den) {
529 *pnum = st->time_base.num;
530 *pden = st->time_base.den;
531 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
532 *pnum = codec_framerate.den;
533 *pden = codec_framerate.num;
534 if (pc && pc->repeat_pict) {
535 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
536 *pden /= 1 + pc->repeat_pict;
537 else
538 *pnum *= 1 + pc->repeat_pict;
539 }
540 /* If this codec can be interlaced or progressive then we need
541 * a parser to compute duration of a packet. Thus if we have
542 * no parser in such case leave duration undefined. */
543 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
544 *pnum = *pden = 0;
545 }
546 break;
547 case AVMEDIA_TYPE_AUDIO:
548 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
549 if (frame_size <= 0 || st->codecpar->sample_rate <= 0)
550 break;
551 *pnum = frame_size;
552 *pden = st->codecpar->sample_rate;
553 break;
554 default:
555 break;
556 }
557 }
558
559 static int is_intra_only(enum AVCodecID id)
560 {
561 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
562 if (!d)
563 return 0;
564 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
565 return 0;
566 return 1;
567 }
568
569 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
570 int64_t dts, int64_t pts)
571 {
572 AVStream *st = s->streams[stream_index];
573 AVPacketList *pktl = s->internal->packet_buffer;
574
575 if (st->first_dts != AV_NOPTS_VALUE ||
576 dts == AV_NOPTS_VALUE ||
577 st->cur_dts == AV_NOPTS_VALUE)
578 return;
579
580 st->first_dts = dts - st->cur_dts;
581 st->cur_dts = dts;
582
583 for (; pktl; pktl = pktl->next) {
584 if (pktl->pkt.stream_index != stream_index)
585 continue;
586 // FIXME: think more about this check
587 if (pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
588 pktl->pkt.pts += st->first_dts;
589
590 if (pktl->pkt.dts != AV_NOPTS_VALUE)
591 pktl->pkt.dts += st->first_dts;
592
593 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
594 st->start_time = pktl->pkt.pts;
595 }
596 if (st->start_time == AV_NOPTS_VALUE)
597 st->start_time = pts;
598 }
599
600 static void update_initial_durations(AVFormatContext *s, AVStream *st,
601 int stream_index, int duration)
602 {
603 AVPacketList *pktl = s->internal->packet_buffer;
604 int64_t cur_dts = 0;
605
606 if (st->first_dts != AV_NOPTS_VALUE) {
607 cur_dts = st->first_dts;
608 for (; pktl; pktl = pktl->next) {
609 if (pktl->pkt.stream_index == stream_index) {
610 if (pktl->pkt.pts != pktl->pkt.dts ||
611 pktl->pkt.dts != AV_NOPTS_VALUE ||
612 pktl->pkt.duration)
613 break;
614 cur_dts -= duration;
615 }
616 }
617 pktl = s->internal->packet_buffer;
618 st->first_dts = cur_dts;
619 } else if (st->cur_dts)
620 return;
621
622 for (; pktl; pktl = pktl->next) {
623 if (pktl->pkt.stream_index != stream_index)
624 continue;
625 if (pktl->pkt.pts == pktl->pkt.dts &&
626 pktl->pkt.dts == AV_NOPTS_VALUE &&
627 !pktl->pkt.duration) {
628 pktl->pkt.dts = cur_dts;
629 if (!st->internal->avctx->has_b_frames)
630 pktl->pkt.pts = cur_dts;
631 cur_dts += duration;
632 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
633 pktl->pkt.duration = duration;
634 } else
635 break;
636 }
637 if (st->first_dts == AV_NOPTS_VALUE)
638 st->cur_dts = cur_dts;
639 }
640
641 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
642 AVCodecParserContext *pc, AVPacket *pkt)
643 {
644 int num, den, presentation_delayed, delay, i;
645 int64_t offset;
646
647 if (s->flags & AVFMT_FLAG_NOFILLIN)
648 return;
649
650 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
651 pkt->dts = AV_NOPTS_VALUE;
652
653 /* do we have a video B-frame ? */
654 delay = st->internal->avctx->has_b_frames;
655 presentation_delayed = 0;
656
657 /* XXX: need has_b_frame, but cannot get it if the codec is
658 * not initialized */
659 if (delay &&
660 pc && pc->pict_type != AV_PICTURE_TYPE_B)
661 presentation_delayed = 1;
662
663 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
664 st->pts_wrap_bits < 63 &&
665 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
666 pkt->dts -= 1LL << st->pts_wrap_bits;
667 }
668
669 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
670 * We take the conservative approach and discard both.
671 * Note: If this is misbehaving for an H.264 file, then possibly
672 * presentation_delayed is not set correctly. */
673 if (delay == 1 && pkt->dts == pkt->pts &&
674 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
675 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
676 pkt->dts = AV_NOPTS_VALUE;
677 }
678
679 if (pkt->duration == 0 && st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
680 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
681 if (den && num) {
682 pkt->duration = av_rescale_rnd(1, num * (int64_t) st->time_base.den,
683 den * (int64_t) st->time_base.num,
684 AV_ROUND_DOWN);
685
686 if (pkt->duration != 0 && s->internal->packet_buffer)
687 update_initial_durations(s, st, pkt->stream_index,
688 pkt->duration);
689 }
690 }
691
692 /* Correct timestamps with byte offset if demuxers only have timestamps
693 * on packet boundaries */
694 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
695 /* this will estimate bitrate based on this frame's duration and size */
696 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
697 if (pkt->pts != AV_NOPTS_VALUE)
698 pkt->pts += offset;
699 if (pkt->dts != AV_NOPTS_VALUE)
700 pkt->dts += offset;
701 }
702
703 /* This may be redundant, but it should not hurt. */
704 if (pkt->dts != AV_NOPTS_VALUE &&
705 pkt->pts != AV_NOPTS_VALUE &&
706 pkt->pts > pkt->dts)
707 presentation_delayed = 1;
708
709 av_log(NULL, AV_LOG_TRACE,
710 "IN delayed:%d pts:%"PRId64", dts:%"PRId64" "
711 "cur_dts:%"PRId64" st:%d pc:%p\n",
712 presentation_delayed, pkt->pts, pkt->dts, st->cur_dts,
713 pkt->stream_index, pc);
714 /* Interpolate PTS and DTS if they are not present. We skip H.264
715 * currently because delay and has_b_frames are not reliably set. */
716 if ((delay == 0 || (delay == 1 && pc)) &&
717 st->codecpar->codec_id != AV_CODEC_ID_H264) {
718 if (presentation_delayed) {
719 /* DTS = decompression timestamp */
720 /* PTS = presentation timestamp */
721 if (pkt->dts == AV_NOPTS_VALUE)
722 pkt->dts = st->last_IP_pts;
723 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
724 if (pkt->dts == AV_NOPTS_VALUE)
725 pkt->dts = st->cur_dts;
726
727 /* This is tricky: the dts must be incremented by the duration
728 * of the frame we are displaying, i.e. the last I- or P-frame. */
729 if (st->last_IP_duration == 0)
730 st->last_IP_duration = pkt->duration;
731 if (pkt->dts != AV_NOPTS_VALUE)
732 st->cur_dts = pkt->dts + st->last_IP_duration;
733 st->last_IP_duration = pkt->duration;
734 st->last_IP_pts = pkt->pts;
735 /* Cannot compute PTS if not present (we can compute it only
736 * by knowing the future. */
737 } else if (pkt->pts != AV_NOPTS_VALUE ||
738 pkt->dts != AV_NOPTS_VALUE ||
739 pkt->duration ||
740 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
741 int duration = pkt->duration;
742 if (!duration && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
743 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
744 if (den && num) {
745 duration = av_rescale_rnd(1,
746 num * (int64_t) st->time_base.den,
747 den * (int64_t) st->time_base.num,
748 AV_ROUND_DOWN);
749 if (duration != 0 && s->internal->packet_buffer)
750 update_initial_durations(s, st, pkt->stream_index,
751 duration);
752 }
753 }
754
755 if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
756 duration) {
757 /* presentation is not delayed : PTS and DTS are the same */
758 if (pkt->pts == AV_NOPTS_VALUE)
759 pkt->pts = pkt->dts;
760 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
761 pkt->pts);
762 if (pkt->pts == AV_NOPTS_VALUE)
763 pkt->pts = st->cur_dts;
764 pkt->dts = pkt->pts;
765 if (pkt->pts != AV_NOPTS_VALUE)
766 st->cur_dts = pkt->pts + duration;
767 }
768 }
769 }
770
771 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
772 st->pts_buffer[0] = pkt->pts;
773 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
774 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
775 if (pkt->dts == AV_NOPTS_VALUE)
776 pkt->dts = st->pts_buffer[0];
777 // We skipped it above so we try here.
778 if (st->codecpar->codec_id == AV_CODEC_ID_H264)
779 // This should happen on the first packet
780 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
781 if (pkt->dts > st->cur_dts)
782 st->cur_dts = pkt->dts;
783 }
784
785 av_log(NULL, AV_LOG_TRACE,
786 "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n",
787 presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
788
789 /* update flags */
790 if (is_intra_only(st->codecpar->codec_id))
791 pkt->flags |= AV_PKT_FLAG_KEY;
792 #if FF_API_CONVERGENCE_DURATION
793 FF_DISABLE_DEPRECATION_WARNINGS
794 if (pc)
795 pkt->convergence_duration = pc->convergence_duration;
796 FF_ENABLE_DEPRECATION_WARNINGS
797 #endif
798 }
799
800 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
801 {
802 while (*pkt_buf) {
803 AVPacketList *pktl = *pkt_buf;
804 *pkt_buf = pktl->next;
805 av_packet_unref(&pktl->pkt);
806 av_freep(&pktl);
807 }
808 *pkt_buf_end = NULL;
809 }
810
811 /**
812 * Parse a packet, add all split parts to parse_queue.
813 *
814 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
815 */
816 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
817 {
818 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
819 AVStream *st = s->streams[stream_index];
820 uint8_t *data = pkt ? pkt->data : NULL;
821 int size = pkt ? pkt->size : 0;
822 int ret = 0, got_output = 0;
823
824 if (!pkt) {
825 av_init_packet(&flush_pkt);
826 pkt = &flush_pkt;
827 got_output = 1;
828 }
829
830 while (size > 0 || (pkt == &flush_pkt && got_output)) {
831 int len;
832
833 av_init_packet(&out_pkt);
834 len = av_parser_parse2(st->parser, st->internal->avctx,
835 &out_pkt.data, &out_pkt.size, data, size,
836 pkt->pts, pkt->dts, pkt->pos);
837
838 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
839 /* increment read pointer */
840 data += len;
841 size -= len;
842
843 got_output = !!out_pkt.size;
844
845 if (!out_pkt.size)
846 continue;
847
848 if (pkt->side_data) {
849 out_pkt.side_data = pkt->side_data;
850 out_pkt.side_data_elems = pkt->side_data_elems;
851 pkt->side_data = NULL;
852 pkt->side_data_elems = 0;
853 }
854
855 /* set the duration */
856 out_pkt.duration = 0;
857 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
858 if (st->internal->avctx->sample_rate > 0) {
859 out_pkt.duration =
860 av_rescale_q_rnd(st->parser->duration,
861 (AVRational) { 1, st->internal->avctx->sample_rate },
862 st->time_base,
863 AV_ROUND_DOWN);
864 }
865 }
866
867 out_pkt.stream_index = st->index;
868 out_pkt.pts = st->parser->pts;
869 out_pkt.dts = st->parser->dts;
870 out_pkt.pos = st->parser->pos;
871
872 if (st->parser->key_frame == 1 ||
873 (st->parser->key_frame == -1 &&
874 st->parser->pict_type == AV_PICTURE_TYPE_I))
875 out_pkt.flags |= AV_PKT_FLAG_KEY;
876
877 compute_pkt_fields(s, st, st->parser, &out_pkt);
878
879 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
880 out_pkt.flags & AV_PKT_FLAG_KEY) {
881 ff_reduce_index(s, st->index);
882 av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
883 0, 0, AVINDEX_KEYFRAME);
884 }
885
886 if ((ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
887 &s->internal->parse_queue_end,
888 1))) {
889 av_packet_unref(&out_pkt);
890 goto fail;
891 }
892 }
893
894 /* end of the stream => close and free the parser */
895 if (pkt == &flush_pkt) {
896 av_parser_close(st->parser);
897 st->parser = NULL;
898 }
899
900 fail:
901 av_packet_unref(pkt);
902 return ret;
903 }
904
905 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
906 AVPacketList **pkt_buffer_end,
907 AVPacket *pkt)
908 {
909 AVPacketList *pktl;
910 av_assert0(*pkt_buffer);
911 pktl = *pkt_buffer;
912 *pkt = pktl->pkt;
913 *pkt_buffer = pktl->next;
914 if (!pktl->next)
915 *pkt_buffer_end = NULL;
916 av_freep(&pktl);
917 return 0;
918 }
919
920 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
921 {
922 int ret = 0, i, got_packet = 0;
923 AVDictionary *metadata = NULL;
924
925 av_init_packet(pkt);
926
927 while (!got_packet && !s->internal->parse_queue) {
928 AVStream *st;
929 AVPacket cur_pkt;
930
931 /* read next packet */
932 ret = ff_read_packet(s, &cur_pkt);
933 if (ret < 0) {
934 if (ret == AVERROR(EAGAIN))
935 return ret;
936 /* flush the parsers */
937 for (i = 0; i < s->nb_streams; i++) {
938 st = s->streams[i];
939 if (st->parser && st->need_parsing)
940 parse_packet(s, NULL, st->index);
941 }
942 /* all remaining packets are now in parse_queue =>
943 * really terminate parsing */
944 break;
945 }
946 ret = 0;
947 st = s->streams[cur_pkt.stream_index];
948
949 if (cur_pkt.pts != AV_NOPTS_VALUE &&
950 cur_pkt.dts != AV_NOPTS_VALUE &&
951 cur_pkt.pts < cur_pkt.dts) {
952 av_log(s, AV_LOG_WARNING,
953 "Invalid timestamps stream=%d, pts=%"PRId64", "
954 "dts=%"PRId64", size=%d\n",
955 cur_pkt.stream_index, cur_pkt.pts,
956 cur_pkt.dts, cur_pkt.size);
957 }
958 if (s->debug & FF_FDEBUG_TS)
959 av_log(s, AV_LOG_DEBUG,
960 "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", "
961 "size=%d, duration=%"PRId64", flags=%d\n",
962 cur_pkt.stream_index, cur_pkt.pts, cur_pkt.dts,
963 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
964
965 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
966 st->parser = av_parser_init(st->codecpar->codec_id);
967 if (!st->parser)
968 /* no parser available: just output the raw packets */
969 st->need_parsing = AVSTREAM_PARSE_NONE;
970 else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
971 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
972 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
973 st->parser->flags |= PARSER_FLAG_ONCE;
974 }
975
976 if (!st->need_parsing || !st->parser) {
977 /* no parsing needed: we just output the packet as is */
978 *pkt = cur_pkt;
979 compute_pkt_fields(s, st, NULL, pkt);
980 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
981 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
982 ff_reduce_index(s, st->index);
983 av_add_index_entry(st, pkt->pos, pkt->dts,
984 0, 0, AVINDEX_KEYFRAME);
985 }
986 got_packet = 1;
987 } else if (st->discard < AVDISCARD_ALL) {
988 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
989 return ret;
990 } else {
991 /* free packet */
992 av_packet_unref(&cur_pkt);
993 }
994 }
995
996 if (!got_packet && s->internal->parse_queue)
997 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
998
999 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1000 if (metadata) {
1001 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1002 av_dict_copy(&s->metadata, metadata, 0);
1003 av_dict_free(&metadata);
1004 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1005 }
1006
1007 #if FF_API_LAVF_AVCTX
1008 update_stream_avctx(s);
1009 #endif
1010
1011 if (s->debug & FF_FDEBUG_TS)
1012 av_log(s, AV_LOG_DEBUG,
1013 "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", "
1014 "size=%d, duration=%"PRId64", flags=%d\n",
1015 pkt->stream_index, pkt->pts, pkt->dts,
1016 pkt->size, pkt->duration, pkt->flags);
1017
1018 return ret;
1019 }
1020
1021 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1022 {
1023 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1024 int eof = 0;
1025
1026 if (!genpts)
1027 return s->internal->packet_buffer
1028 ? read_from_packet_buffer(&s->internal->packet_buffer,
1029 &s->internal->packet_buffer_end, pkt)
1030 : read_frame_internal(s, pkt);
1031
1032 for (;;) {
1033 int ret;
1034 AVPacketList *pktl = s->internal->packet_buffer;
1035
1036 if (pktl) {
1037 AVPacket *next_pkt = &pktl->pkt;
1038
1039 if (next_pkt->dts != AV_NOPTS_VALUE) {
1040 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1041 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1042 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1043 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1044 av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1045 // not B-frame
1046 next_pkt->pts = pktl->pkt.dts;
1047 }
1048 pktl = pktl->next;
1049 }
1050 pktl = s->internal->packet_buffer;
1051 }
1052
1053 /* read packet from packet buffer, if there is data */
1054 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1055 next_pkt->dts != AV_NOPTS_VALUE && !eof))
1056 return read_from_packet_buffer(&s->internal->packet_buffer,
1057 &s->internal->packet_buffer_end, pkt);
1058 }
1059
1060 ret = read_frame_internal(s, pkt);
1061 if (ret < 0) {
1062 if (pktl && ret != AVERROR(EAGAIN)) {
1063 eof = 1;
1064 continue;
1065 } else
1066 return ret;
1067 }
1068
1069 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1070 &s->internal->packet_buffer_end, 1);
1071 if (ret < 0)
1072 return ret;
1073 }
1074 }
1075
1076 /* XXX: suppress the packet queue */
1077 static void flush_packet_queue(AVFormatContext *s)
1078 {
1079 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1080 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1081 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1082
1083 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1084 }
1085
1086 /*******************************************************/
1087 /* seek support */
1088
1089 int av_find_default_stream_index(AVFormatContext *s)
1090 {
1091 int first_audio_index = -1;
1092 int i;
1093 AVStream *st;
1094
1095 if (s->nb_streams <= 0)
1096 return -1;
1097 for (i = 0; i < s->nb_streams; i++) {
1098 st = s->streams[i];
1099 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1100 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1101 return i;
1102 }
1103 if (first_audio_index < 0 &&
1104 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
1105 first_audio_index = i;
1106 }
1107 return first_audio_index >= 0 ? first_audio_index : 0;
1108 }
1109
1110 /** Flush the frame reader. */
1111 void ff_read_frame_flush(AVFormatContext *s)
1112 {
1113 AVStream *st;
1114 int i, j;
1115
1116 flush_packet_queue(s);
1117
1118 /* Reset read state for each stream. */
1119 for (i = 0; i < s->nb_streams; i++) {
1120 st = s->streams[i];
1121
1122 if (st->parser) {
1123 av_parser_close(st->parser);
1124 st->parser = NULL;
1125 }
1126 st->last_IP_pts = AV_NOPTS_VALUE;
1127 /* We set the current DTS to an unspecified origin. */
1128 st->cur_dts = AV_NOPTS_VALUE;
1129
1130 st->probe_packets = MAX_PROBE_PACKETS;
1131
1132 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1133 st->pts_buffer[j] = AV_NOPTS_VALUE;
1134 }
1135 }
1136
1137 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1138 {
1139 int i;
1140
1141 for (i = 0; i < s->nb_streams; i++) {
1142 AVStream *st = s->streams[i];
1143
1144 st->cur_dts =
1145 av_rescale(timestamp,
1146 st->time_base.den * (int64_t) ref_st->time_base.num,
1147 st->time_base.num * (int64_t) ref_st->time_base.den);
1148 }
1149 }
1150
1151 void ff_reduce_index(AVFormatContext *s, int stream_index)
1152 {
1153 AVStream *st = s->streams[stream_index];
1154 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1155
1156 if ((unsigned) st->nb_index_entries >= max_entries) {
1157 int i;
1158 for (i = 0; 2 * i < st->nb_index_entries; i++)
1159 st->index_entries[i] = st->index_entries[2 * i];
1160 st->nb_index_entries = i;
1161 }
1162 }
1163
1164 int ff_add_index_entry(AVIndexEntry **index_entries,
1165 int *nb_index_entries,
1166 unsigned int *index_entries_allocated_size,
1167 int64_t pos, int64_t timestamp,
1168 int size, int distance, int flags)
1169 {
1170 AVIndexEntry *entries, *ie;
1171 int index;
1172
1173 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1174 return -1;
1175
1176 entries = av_fast_realloc(*index_entries,
1177 index_entries_allocated_size,
1178 (*nb_index_entries + 1) *
1179 sizeof(AVIndexEntry));
1180 if (!entries)
1181 return -1;
1182
1183 *index_entries = entries;
1184
1185 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1186 timestamp, AVSEEK_FLAG_ANY);
1187
1188 if (index < 0) {
1189 index = (*nb_index_entries)++;
1190 ie = &entries[index];
1191 assert(index == 0 || ie[-1].timestamp < timestamp);
1192 } else {
1193 ie = &entries[index];
1194 if (ie->timestamp != timestamp) {
1195 if (ie->timestamp <= timestamp)
1196 return -1;
1197 memmove(entries + index + 1, entries + index,
1198 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1199 (*nb_index_entries)++;
1200 } else if (ie->pos == pos && distance < ie->min_distance)
1201 // do not reduce the distance
1202 distance = ie->min_distance;
1203 }
1204
1205 ie->pos = pos;
1206 ie->timestamp = timestamp;
1207 ie->min_distance = distance;
1208 ie->size = size;
1209 ie->flags = flags;
1210
1211 return index;
1212 }
1213
1214 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1215 int size, int distance, int flags)
1216 {
1217 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1218 &st->index_entries_allocated_size, pos,
1219 timestamp, size, distance, flags);
1220 }
1221
1222 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1223 int64_t wanted_timestamp, int flags)
1224 {
1225 int a, b, m;
1226 int64_t timestamp;
1227
1228 a = -1;
1229 b = nb_entries;
1230
1231 // Optimize appending index entries at the end.
1232 if (b && entries[b - 1].timestamp < wanted_timestamp)
1233 a = b - 1;
1234
1235 while (b - a > 1) {
1236 m = (a + b) >> 1;
1237 timestamp = entries[m].timestamp;
1238 if (timestamp >= wanted_timestamp)
1239 b = m;
1240 if (timestamp <= wanted_timestamp)
1241 a = m;
1242 }
1243 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1244
1245 if (!(flags & AVSEEK_FLAG_ANY))
1246 while (m >= 0 && m < nb_entries &&
1247 !(entries[m].flags & AVINDEX_KEYFRAME))
1248 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1249
1250 if (m == nb_entries)
1251 return -1;
1252 return m;
1253 }
1254
1255 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1256 {
1257 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1258 wanted_timestamp, flags);
1259 }
1260
1261 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1262 int64_t target_ts, int flags)
1263 {
1264 AVInputFormat *avif = s->iformat;
1265 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1266 int64_t ts_min, ts_max, ts;
1267 int index;
1268 int64_t ret;
1269 AVStream *st;
1270
1271 if (stream_index < 0)
1272 return -1;
1273
1274 av_log(s, AV_LOG_TRACE, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1275
1276 ts_max =
1277 ts_min = AV_NOPTS_VALUE;
1278 pos_limit = -1; // GCC falsely says it may be uninitialized.
1279
1280 st = s->streams[stream_index];
1281 if (st->index_entries) {
1282 AVIndexEntry *e;
1283
1284 /* FIXME: Whole function must be checked for non-keyframe entries in
1285 * index case, especially read_timestamp(). */
1286 index = av_index_search_timestamp(st, target_ts,
1287 flags | AVSEEK_FLAG_BACKWARD);
1288 index = FFMAX(index, 0);
1289 e = &st->index_entries[index];
1290
1291 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1292 pos_min = e->pos;
1293 ts_min = e->timestamp;
1294 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1295 pos_min, ts_min);
1296 } else {
1297 assert(index == 0);
1298 }
1299
1300 index = av_index_search_timestamp(st, target_ts,
1301 flags & ~AVSEEK_FLAG_BACKWARD);
1302 assert(index < st->nb_index_entries);
1303 if (index >= 0) {
1304 e = &st->index_entries[index];
1305 assert(e->timestamp >= target_ts);
1306 pos_max = e->pos;
1307 ts_max = e->timestamp;
1308 pos_limit = pos_max - e->min_distance;
1309 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1310 " dts_max=%"PRId64"\n", pos_max, pos_limit, ts_max);
1311 }
1312 }
1313
1314 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1315 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1316 if (pos < 0)
1317 return -1;
1318
1319 /* do the seek */
1320 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1321 return ret;
1322
1323 ff_update_cur_dts(s, st, ts);
1324
1325 return 0;
1326 }
1327
1328 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1329 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1330 int64_t ts_min, int64_t ts_max,
1331 int flags, int64_t *ts_ret,
1332 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1333 int64_t *, int64_t))
1334 {
1335 int64_t pos, ts;
1336 int64_t start_pos, filesize;
1337 int no_change;
1338
1339 av_log(s, AV_LOG_TRACE, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1340
1341 if (ts_min == AV_NOPTS_VALUE) {
1342 pos_min = s->internal->data_offset;
1343 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1344 if (ts_min == AV_NOPTS_VALUE)
1345 return -1;
1346 }
1347
1348 if (ts_max == AV_NOPTS_VALUE) {
1349 int step = 1024;
1350 filesize = avio_size(s->pb);
1351 pos_max = filesize - 1;
1352 do {
1353 pos_max -= step;
1354 ts_max = read_timestamp(s, stream_index, &pos_max,
1355 pos_max + step);
1356 step += step;
1357 } while (ts_max == AV_NOPTS_VALUE && pos_max >= step);
1358 if (ts_max == AV_NOPTS_VALUE)
1359 return -1;
1360
1361 for (;;) {
1362 int64_t tmp_pos = pos_max + 1;
1363 int64_t tmp_ts = read_timestamp(s, stream_index,
1364 &tmp_pos, INT64_MAX);
1365 if (tmp_ts == AV_NOPTS_VALUE)
1366 break;
1367 ts_max = tmp_ts;
1368 pos_max = tmp_pos;
1369 if (tmp_pos >= filesize)
1370 break;
1371 }
1372 pos_limit = pos_max;
1373 }
1374
1375 if (ts_min > ts_max)
1376 return -1;
1377 else if (ts_min == ts_max)
1378 pos_limit = pos_min;
1379
1380 no_change = 0;
1381 while (pos_min < pos_limit) {
1382 av_log(s, AV_LOG_TRACE, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64
1383 " dts_max=%"PRId64"\n", pos_min, pos_max, ts_min, ts_max);
1384 assert(pos_limit <= pos_max);
1385
1386 if (no_change == 0) {
1387 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1388 // interpolate position (better than dichotomy)
1389 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1390 ts_max - ts_min) +
1391 pos_min - approximate_keyframe_distance;
1392 } else if (no_change == 1) {
1393 // bisection if interpolation did not change min / max pos last time
1394 pos = (pos_min + pos_limit) >> 1;
1395 } else {
1396 /* linear search if bisection failed, can only happen if there
1397 * are very few or no keyframes between min/max */
1398 pos = pos_min;
1399 }
1400 if (pos <= pos_min)
1401 pos = pos_min + 1;
1402 else if (pos > pos_limit)
1403 pos = pos_limit;
1404 start_pos = pos;
1405
1406 // May pass pos_limit instead of -1.
1407 ts = read_timestamp(s, stream_index, &pos, INT64_MAX);
1408 if (pos == pos_max)
1409 no_change++;
1410 else
1411 no_change = 0;
1412 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64
1413 " target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1414 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1415 pos_limit, start_pos, no_change);
1416 if (ts == AV_NOPTS_VALUE) {
1417 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1418 return -1;
1419 }
1420 assert(ts != AV_NOPTS_VALUE);
1421 if (target_ts <= ts) {
1422 pos_limit = start_pos - 1;
1423 pos_max = pos;
1424 ts_max = ts;
1425 }
1426 if (target_ts >= ts) {
1427 pos_min = pos;
1428 ts_min = ts;
1429 }
1430 }
1431
1432 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1433 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1434 pos_min = pos;
1435 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1436 pos_min++;
1437 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1438 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1439 pos, ts_min, target_ts, ts_max);
1440 *ts_ret = ts;
1441 return pos;
1442 }
1443
1444 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1445 int64_t pos, int flags)
1446 {
1447 int64_t pos_min, pos_max;
1448
1449 pos_min = s->internal->data_offset;
1450 pos_max = avio_size(s->pb) - 1;
1451
1452 if (pos < pos_min)
1453 pos = pos_min;
1454 else if (pos > pos_max)
1455 pos = pos_max;
1456
1457 avio_seek(s->pb, pos, SEEK_SET);
1458
1459 return 0;
1460 }
1461
1462 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1463 int64_t timestamp, int flags)
1464 {
1465 int index;
1466 int64_t ret;
1467 AVStream *st;
1468 AVIndexEntry *ie;
1469
1470 st = s->streams[stream_index];
1471
1472 index = av_index_search_timestamp(st, timestamp, flags);
1473
1474 if (index < 0 && st->nb_index_entries &&
1475 timestamp < st->index_entries[0].timestamp)
1476 return -1;
1477
1478 if (index < 0 || index == st->nb_index_entries - 1) {
1479 AVPacket pkt;
1480
1481 if (st->nb_index_entries) {
1482 assert(st->index_entries);
1483 ie = &st->index_entries[st->nb_index_entries - 1];
1484 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1485 return ret;
1486 ff_update_cur_dts(s, st, ie->timestamp);
1487 } else {
1488 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
1489 return ret;
1490 }
1491 for (;;) {
1492 int read_status;
1493 do {
1494 read_status = av_read_frame(s, &pkt);
1495 } while (read_status == AVERROR(EAGAIN));
1496 if (read_status < 0)
1497 break;
1498 av_packet_unref(&pkt);
1499 if (stream_index == pkt.stream_index)
1500 if ((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1501 break;
1502 }
1503 index = av_index_search_timestamp(st, timestamp, flags);
1504 }
1505 if (index < 0)
1506 return -1;
1507
1508 ff_read_frame_flush(s);
1509 if (s->iformat->read_seek)
1510 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1511 return 0;
1512 ie = &st->index_entries[index];
1513 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1514 return ret;
1515 ff_update_cur_dts(s, st, ie->timestamp);
1516
1517 return 0;
1518 }
1519
1520 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1521 int64_t timestamp, int flags)
1522 {
1523 int ret;
1524 AVStream *st;
1525
1526 if (flags & AVSEEK_FLAG_BYTE) {
1527 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1528 return -1;
1529 ff_read_frame_flush(s);
1530 return seek_frame_byte(s, stream_index, timestamp, flags);
1531 }
1532
1533 if (stream_index < 0) {
1534 stream_index = av_find_default_stream_index(s);
1535 if (stream_index < 0)
1536 return -1;
1537
1538 st = s->streams[stream_index];
1539 /* timestamp for default must be expressed in AV_TIME_BASE units */
1540 timestamp = av_rescale(timestamp, st->time_base.den,
1541 AV_TIME_BASE * (int64_t) st->time_base.num);
1542 }
1543
1544 /* first, we try the format specific seek */
1545 if (s->iformat->read_seek) {
1546 ff_read_frame_flush(s);
1547 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1548 } else
1549 ret = -1;
1550 if (ret >= 0)
1551 return 0;
1552
1553 if (s->iformat->read_timestamp &&
1554 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1555 ff_read_frame_flush(s);
1556 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1557 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1558 ff_read_frame_flush(s);
1559 return seek_frame_generic(s, stream_index, timestamp, flags);
1560 } else
1561 return -1;
1562 }
1563
1564 int av_seek_frame(AVFormatContext *s, int stream_index,
1565 int64_t timestamp, int flags)
1566 {
1567 int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1568
1569 if (ret >= 0)
1570 ret = queue_attached_pictures(s);
1571
1572 return ret;
1573 }
1574
1575 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
1576 int64_t ts, int64_t max_ts, int flags)
1577 {
1578 if (min_ts > ts || max_ts < ts)
1579 return -1;
1580
1581 if (s->iformat->read_seek2) {
1582 int ret;
1583 ff_read_frame_flush(s);
1584 ret = s->iformat->read_seek2(s, stream_index, min_ts,
1585 ts, max_ts, flags);
1586
1587 if (ret >= 0)
1588 ret = queue_attached_pictures(s);
1589 return ret;
1590 }
1591
1592 if (s->iformat->read_timestamp) {
1593 // try to seek via read_timestamp()
1594 }
1595
1596 // Fall back on old API if new is not implemented but old is.
1597 // Note the old API has somewhat different semantics.
1598 if (s->iformat->read_seek || 1)
1599 return av_seek_frame(s, stream_index, ts,
1600 flags | ((uint64_t) ts - min_ts >
1601 (uint64_t) max_ts - ts
1602 ? AVSEEK_FLAG_BACKWARD : 0));
1603
1604 // try some generic seek like seek_frame_generic() but with new ts semantics
1605 }
1606
1607 /*******************************************************/
1608
1609 /**
1610 * Return TRUE if the stream has accurate duration in any stream.
1611 *
1612 * @return TRUE if the stream has accurate duration for at least one component.
1613 */
1614 static int has_duration(AVFormatContext *ic)
1615 {
1616 int i;
1617 AVStream *st;
1618
1619 for (i = 0; i < ic->nb_streams; i++) {
1620 st = ic->streams[i];
1621 if (st->duration != AV_NOPTS_VALUE)
1622 return 1;
1623 }
1624 if (ic->duration != AV_NOPTS_VALUE)
1625 return 1;
1626 return 0;
1627 }
1628
1629 /**
1630 * Estimate the stream timings from the one of each components.
1631 *
1632 * Also computes the global bitrate if possible.
1633 */
1634 static void update_stream_timings(AVFormatContext *ic)
1635 {
1636 int64_t start_time, start_time1, end_time, end_time1;
1637 int64_t duration, duration1, filesize;
1638 int i;
1639 AVStream *st;
1640
1641 start_time = INT64_MAX;
1642 end_time = INT64_MIN;
1643 duration = INT64_MIN;
1644 for (i = 0; i < ic->nb_streams; i++) {
1645 st = ic->streams[i];
1646 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1647 start_time1 = av_rescale_q(st->start_time, st->time_base,
1648 AV_TIME_BASE_Q);
1649 start_time = FFMIN(start_time, start_time1);
1650 if (st->duration != AV_NOPTS_VALUE) {
1651 end_time1 = start_time1 +
1652 av_rescale_q(st->duration, st->time_base,
1653 AV_TIME_BASE_Q);
1654 end_time = FFMAX(end_time, end_time1);
1655 }
1656 }
1657 if (st->duration != AV_NOPTS_VALUE) {
1658 duration1 = av_rescale_q(st->duration, st->time_base,
1659 AV_TIME_BASE_Q);
1660 duration = FFMAX(duration, duration1);
1661 }
1662 }
1663 if (start_time != INT64_MAX) {
1664 ic->start_time = start_time;
1665 if (end_time != INT64_MIN)
1666 duration = FFMAX(duration, end_time - start_time);
1667 }
1668 if (duration != INT64_MIN) {
1669 ic->duration = duration;
1670 if (ic->pb && (filesize = avio_size(ic->pb)) > 0)
1671 /* compute the bitrate */
1672 ic->bit_rate = (double) filesize * 8.0 * AV_TIME_BASE /
1673 (double) ic->duration;
1674 }
1675 }
1676
1677 static void fill_all_stream_timings(AVFormatContext *ic)
1678 {
1679 int i;
1680 AVStream *st;
1681
1682 update_stream_timings(ic);
1683 for (i = 0; i < ic->nb_streams; i++) {
1684 st = ic->streams[i];
1685 if (st->start_time == AV_NOPTS_VALUE) {
1686 if (ic->start_time != AV_NOPTS_VALUE)
1687 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
1688 st->time_base);
1689 if (ic->duration != AV_NOPTS_VALUE)
1690 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
1691 st->time_base);
1692 }
1693 }
1694 }
1695
1696 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1697 {
1698 int64_t filesize, duration;
1699 int i;
1700 AVStream *st;
1701
1702 /* if bit_rate is already set, we believe it */
1703 if (ic->bit_rate <= 0) {
1704 int bit_rate = 0;
1705 for (i = 0; i < ic->nb_streams; i++) {
1706 st = ic->streams[i];
1707 if (st->codecpar->bit_rate > 0) {
1708 if (INT_MAX - st->codecpar->bit_rate < bit_rate) {
1709 bit_rate = 0;
1710 break;
1711 }
1712 bit_rate += st->codecpar->bit_rate;
1713 }
1714 }
1715 ic->bit_rate = bit_rate;
1716 }
1717
1718 /* if duration is already set, we believe it */
1719 if (ic->duration == AV_NOPTS_VALUE &&
1720 ic->bit_rate != 0) {
1721 filesize = ic->pb ? avio_size(ic->pb) : 0;
1722 if (filesize > 0) {
1723 for (i = 0; i < ic->nb_streams; i++) {
1724 st = ic->streams[i];
1725 duration = av_rescale(8 * filesize, st->time_base.den,
1726 ic->bit_rate *
1727 (int64_t) st->time_base.num);
1728 if (st->duration == AV_NOPTS_VALUE)
1729 st->duration = duration;
1730 }
1731 }
1732 }
1733 }
1734
1735 #define DURATION_MAX_READ_SIZE 250000
1736 #define DURATION_MAX_RETRY 3
1737
1738 /* only usable for MPEG-PS streams */
1739 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1740 {
1741 AVPacket pkt1, *pkt = &pkt1;
1742 AVStream *st;
1743 int read_size, i, ret;
1744 int64_t end_time;
1745 int64_t filesize, offset, duration;
1746 int retry = 0;
1747
1748 /* flush packet queue */
1749 flush_packet_queue(ic);
1750
1751 for (i = 0; i < ic->nb_streams; i++) {
1752 st = ic->streams[i];
1753 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1754 av_log(ic, AV_LOG_WARNING,
1755 "start time is not set in estimate_timings_from_pts\n");
1756
1757 if (st->parser) {
1758 av_parser_close(st->parser);
1759 st->parser = NULL;
1760 }
1761 }
1762
1763 /* estimate the end time (duration) */
1764 /* XXX: may need to support wrapping */
1765 filesize = ic->pb ? avio_size(ic->pb) : 0;
1766 end_time = AV_NOPTS_VALUE;
1767 do {
1768 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
1769 if (offset < 0)
1770 offset = 0;
1771
1772 avio_seek(ic->pb, offset, SEEK_SET);
1773 read_size = 0;
1774 for (;;) {
1775 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
1776 break;
1777
1778 do {
1779 ret = ff_read_packet(ic, pkt);
1780 } while (ret == AVERROR(EAGAIN));
1781 if (ret != 0)
1782 break;
1783 read_size += pkt->size;
1784 st = ic->streams[pkt->stream_index];
1785 if (pkt->pts != AV_NOPTS_VALUE &&
1786 (st->start_time != AV_NOPTS_VALUE ||
1787 st->first_dts != AV_NOPTS_VALUE)) {
1788 duration = end_time = pkt->pts;
1789 if (st->start_time != AV_NOPTS_VALUE)
1790 duration -= st->start_time;
1791 else
1792 duration -= st->first_dts;
1793 if (duration < 0)
1794 duration += 1LL << st->pts_wrap_bits;
1795 if (duration > 0) {
1796 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1797 st->duration = duration;
1798 }
1799 }
1800 av_packet_unref(pkt);
1801 }
1802 } while (end_time == AV_NOPTS_VALUE &&
1803 filesize > (DURATION_MAX_READ_SIZE << retry) &&
1804 ++retry <= DURATION_MAX_RETRY);
1805
1806 fill_all_stream_timings(ic);
1807
1808 avio_seek(ic->pb, old_offset, SEEK_SET);
1809 for (i = 0; i < ic->nb_streams; i++) {
1810 st = ic->streams[i];
1811 st->cur_dts = st->first_dts;
1812 st->last_IP_pts = AV_NOPTS_VALUE;
1813 }
1814 }
1815
1816 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1817 {
1818 int64_t file_size;
1819
1820 /* get the file size, if possible */
1821 if (ic->iformat->flags & AVFMT_NOFILE) {
1822 file_size = 0;
1823 } else {
1824 file_size = avio_size(ic->pb);
1825 file_size = FFMAX(0, file_size);
1826 }
1827
1828 if ((!strcmp(ic->iformat->name, "mpeg") ||
1829 !strcmp(ic->iformat->name, "mpegts")) &&
1830 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1831 /* get accurate estimate from the PTSes */
1832 estimate_timings_from_pts(ic, old_offset);
1833 } else if (has_duration(ic)) {
1834 /* at least one component has timings - we use them for all
1835 * the components */
1836 fill_all_stream_timings(ic);
1837 } else {
1838 av_log(ic, AV_LOG_WARNING,
1839 "Estimating duration from bitrate, this may be inaccurate\n");
1840 /* less precise: use bitrate info */
1841 estimate_timings_from_bit_rate(ic);
1842 }
1843 update_stream_timings(ic);
1844
1845 {
1846 int i;
1847 AVStream av_unused *st;
1848 for (i = 0; i < ic->nb_streams; i++) {
1849 st = ic->streams[i];
1850 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
1851 (double) st->start_time / AV_TIME_BASE,
1852 (double) st->duration / AV_TIME_BASE);
1853 }
1854 av_log(ic, AV_LOG_TRACE,
1855 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1856 (double) ic->start_time / AV_TIME_BASE,
1857 (double) ic->duration / AV_TIME_BASE,
1858 ic->bit_rate / 1000);
1859 }
1860 }
1861
1862 static int has_codec_parameters(AVStream *st)
1863 {
1864 AVCodecContext *avctx = st->internal->avctx;
1865 int val;
1866
1867 switch (avctx->codec_type) {
1868 case AVMEDIA_TYPE_AUDIO:
1869 val = avctx->sample_rate && avctx->channels;
1870 if (st->info->found_decoder >= 0 &&
1871 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
1872 return 0;
1873 break;
1874 case AVMEDIA_TYPE_VIDEO:
1875 val = avctx->width;
1876 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
1877 return 0;
1878 break;
1879 default:
1880 val = 1;
1881 break;
1882 }
1883 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
1884 }
1885
1886 static int has_decode_delay_been_guessed(AVStream *st)
1887 {
1888 return st->internal->avctx->codec_id != AV_CODEC_ID_H264 ||
1889 st->info->nb_decoded_frames >= 6;
1890 }
1891
1892 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
1893 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
1894 AVDictionary **options)
1895 {
1896 AVCodecContext *avctx = st->internal->avctx;
1897 const AVCodec *codec;
1898 int got_picture = 1, ret = 0;
1899 AVFrame *frame = av_frame_alloc();
1900 AVPacket pkt = *avpkt;
1901
1902 if (!frame)
1903 return AVERROR(ENOMEM);
1904
1905 if (!avcodec_is_open(avctx) && !st->info->found_decoder) {
1906 AVDictionary *thread_opt = NULL;
1907
1908 #if FF_API_LAVF_AVCTX
1909 FF_DISABLE_DEPRECATION_WARNINGS
1910 codec = st->codec->codec ? st->codec->codec
1911 : avcodec_find_decoder(st->codecpar->codec_id);
1912 FF_ENABLE_DEPRECATION_WARNINGS
1913 #else
1914 codec = avcodec_find_decoder(st->codecpar->codec_id);
1915 #endif
1916
1917 if (!codec) {
1918 st->info->found_decoder = -1;
1919 ret = -1;
1920 goto fail;
1921 }
1922
1923 /* Force thread count to 1 since the H.264 decoder will not extract
1924 * SPS and PPS to extradata during multi-threaded decoding. */
1925 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
1926 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
1927 if (!options)
1928 av_dict_free(&thread_opt);
1929 if (ret < 0) {
1930 st->info->found_decoder = -1;
1931 goto fail;
1932 }
1933 st->info->found_decoder = 1;
1934 } else if (!st->info->found_decoder)
1935 st->info->found_decoder = 1;
1936
1937 if (st->info->found_decoder < 0) {
1938 ret = -1;
1939 goto fail;
1940 }
1941
1942 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
1943 ret >= 0 &&
1944 (!has_codec_parameters(st) || !has_decode_delay_been_guessed(st) ||
1945 (!st->codec_info_nb_frames &&
1946 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
1947 got_picture = 0;
1948 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
1949 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1950 ret = avcodec_send_packet(avctx, &pkt);
1951 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1952 break;
1953 if (ret >= 0)
1954 pkt.size = 0;
1955 ret = avcodec_receive_frame(avctx, frame);
1956 if (ret >= 0)
1957 got_picture = 1;
1958 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1959 ret = 0;
1960 }
1961 if (ret >= 0) {
1962 if (got_picture)
1963 st->info->nb_decoded_frames++;
1964 ret = got_picture;
1965 }
1966 }
1967
1968 fail:
1969 av_frame_free(&frame);
1970 return ret;
1971 }
1972
1973 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
1974 {
1975 while (tags->id != AV_CODEC_ID_NONE) {
1976 if (tags->id == id)
1977 return tags->tag;
1978 tags++;
1979 }
1980 return 0;
1981 }
1982
1983 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
1984 {
1985 int i;
1986 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
1987 if (tag == tags[i].tag)
1988 return tags[i].id;
1989 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
1990 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
1991 return tags[i].id;
1992 return AV_CODEC_ID_NONE;
1993 }
1994
1995 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
1996 {
1997 if (flt) {
1998 switch (bps) {
1999 case 32:
2000 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2001 case 64:
2002 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2003 default:
2004 return AV_CODEC_ID_NONE;
2005 }
2006 } else {
2007 bps >>= 3;
2008 if (sflags & (1 << (bps - 1))) {
2009 switch (bps) {
2010 case 1:
2011 return AV_CODEC_ID_PCM_S8;
2012 case 2:
2013 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2014 case 3:
2015 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2016 case 4:
2017 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2018 default:
2019 return AV_CODEC_ID_NONE;
2020 }
2021 } else {
2022 switch (bps) {
2023 case 1:
2024 return AV_CODEC_ID_PCM_U8;
2025 case 2:
2026 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2027 case 3:
2028 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2029 case 4:
2030 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2031 default:
2032 return AV_CODEC_ID_NONE;
2033 }
2034 }
2035 }
2036 }
2037
2038 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2039 {
2040 int i;
2041 for (i = 0; tags && tags[i]; i++) {
2042 int tag = ff_codec_get_tag(tags[i], id);
2043 if (tag)
2044 return tag;
2045 }
2046 return 0;
2047 }
2048
2049 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2050 {
2051 int i;
2052 for (i = 0; tags && tags[i]; i++) {
2053 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2054 if (id != AV_CODEC_ID_NONE)
2055 return id;
2056 }
2057 return AV_CODEC_ID_NONE;
2058 }
2059
2060 static void compute_chapters_end(AVFormatContext *s)
2061 {
2062 unsigned int i, j;
2063 int64_t max_time = s->duration +
2064 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2065
2066 for (i = 0; i < s->nb_chapters; i++)
2067 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2068 AVChapter *ch = s->chapters[i];
2069 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2070 ch->time_base)
2071 : INT64_MAX;
2072
2073 for (j = 0; j < s->nb_chapters; j++) {
2074 AVChapter *ch1 = s->chapters[j];
2075 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2076 ch->time_base);
2077 if (j != i && next_start > ch->start && next_start < end)
2078 end = next_start;
2079 }
2080 ch->end = (end == INT64_MAX) ? ch->start : end;
2081 }
2082 }
2083
2084 static int get_std_framerate(int i)
2085 {
2086 if (i < 60 * 12)
2087 return (i + 1) * 1001;
2088 else
2089 return ((const int[]) { 24, 30, 60, 12, 15 })[i - 60 * 12] * 1000 * 12;
2090 }
2091
2092 static int extract_extradata_init(AVStream *st)
2093 {
2094 AVStreamInternal *i = st->internal;
2095 const AVBitStreamFilter *f;
2096 int ret;
2097
2098 f = av_bsf_get_by_name("extract_extradata");
2099 if (!f)
2100 goto finish;
2101
2102 /* check that the codec id is supported */
2103 if (f->codec_ids) {
2104 const enum AVCodecID *ids;
2105 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
2106 if (*ids == st->codecpar->codec_id)
2107 break;
2108 if (*ids == AV_CODEC_ID_NONE)
2109 goto finish;
2110 }
2111
2112 i->extract_extradata.pkt = av_packet_alloc();
2113 if (!i->extract_extradata.pkt)
2114 return AVERROR(ENOMEM);
2115
2116 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
2117 if (ret < 0)
2118 goto fail;
2119
2120 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
2121 st->codecpar);
2122 if (ret < 0)
2123 goto fail;
2124
2125 i->extract_extradata.bsf->time_base_in = st->time_base;
2126
2127 /* if init fails here, we assume extracting extradata is just not
2128 * supported for this codec, so we return success */
2129 ret = av_bsf_init(i->extract_extradata.bsf);
2130 if (ret < 0) {
2131 av_bsf_free(&i->extract_extradata.bsf);
2132 ret = 0;
2133 }
2134
2135 finish:
2136 i->extract_extradata.inited = 1;
2137
2138 return 0;
2139 fail:
2140 av_bsf_free(&i->extract_extradata.bsf);
2141 av_packet_free(&i->extract_extradata.pkt);
2142 return ret;
2143 }
2144
2145 static int extract_extradata(AVStream *st, AVPacket *pkt)
2146 {
2147 AVStreamInternal *i = st->internal;
2148 AVPacket *pkt_ref;
2149 int ret;
2150
2151 if (!i->extract_extradata.inited) {
2152 ret = extract_extradata_init(st);
2153 if (ret < 0)
2154 return ret;
2155 }
2156
2157 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
2158 return 0;
2159
2160 pkt_ref = i->extract_extradata.pkt;
2161 ret = av_packet_ref(pkt_ref, pkt);
2162 if (ret < 0)
2163 return ret;
2164
2165 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
2166 if (ret < 0) {
2167 av_packet_unref(pkt_ref);
2168 return ret;
2169 }
2170
2171 while (ret >= 0 && !i->avctx->extradata) {
2172 int extradata_size;
2173 uint8_t *extradata;
2174
2175 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
2176 if (ret < 0) {
2177 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2178 return ret;
2179 continue;
2180 }
2181
2182 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
2183 &extradata_size);
2184
2185 if (extradata) {
2186 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
2187 if (!i->avctx->extradata) {
2188 av_packet_unref(pkt_ref);
2189 return AVERROR(ENOMEM);
2190 }
2191 memcpy(i->avctx->extradata, extradata, extradata_size);
2192 i->avctx->extradata_size = extradata_size;
2193 }
2194 av_packet_unref(pkt_ref);
2195 }
2196
2197 return 0;
2198 }
2199
2200 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2201 {
2202 int i, count, ret, read_size, j;
2203 AVStream *st;
2204 AVCodecContext *avctx;
2205 AVPacket pkt1, *pkt;
2206 int64_t old_offset = avio_tell(ic->pb);
2207 // new streams might appear, no options for those
2208 int orig_nb_streams = ic->nb_streams;
2209
2210 for (i = 0; i < ic->nb_streams; i++) {
2211 const AVCodec *codec;
2212 AVDictionary *thread_opt = NULL;
2213 st = ic->streams[i];
2214 avctx = st->internal->avctx;
2215
2216 // only for the split stuff
2217 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2218 st->parser = av_parser_init(st->codecpar->codec_id);
2219 if (st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser)
2220 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2221 }
2222
2223 /* check if the caller has overridden the codec id */
2224 #if FF_API_LAVF_AVCTX
2225 FF_DISABLE_DEPRECATION_WARNINGS
2226 if (st->codec->codec_id != st->internal->orig_codec_id) {
2227 st->codecpar->codec_id = st->codec->codec_id;
2228 st->codecpar->codec_type = st->codec->codec_type;
2229 st->internal->orig_codec_id = st->codec->codec_id;
2230 }
2231 FF_ENABLE_DEPRECATION_WARNINGS
2232 #endif
2233 if (st->codecpar->codec_id != st->internal->orig_codec_id)
2234 st->internal->orig_codec_id = st->codecpar->codec_id;
2235
2236 ret = avcodec_parameters_to_context(avctx, st->codecpar);
2237 if (ret < 0)
2238 goto find_stream_info_err;
2239 if (st->codecpar->codec_id != AV_CODEC_ID_PROBE &&
2240 st->codecpar->codec_id != AV_CODEC_ID_NONE)
2241 st->internal->avctx_inited = 1;
2242
2243 #if FF_API_LAVF_AVCTX
2244 FF_DISABLE_DEPRECATION_WARNINGS
2245 codec = st->codec->codec ? st->codec->codec
2246 : avcodec_find_decoder(st->codecpar->codec_id);
2247 FF_ENABLE_DEPRECATION_WARNINGS
2248 #else
2249 codec = avcodec_find_decoder(st->codecpar->codec_id);
2250 #endif
2251
2252 /* Force thread count to 1 since the H.264 decoder will not extract
2253 * SPS and PPS to extradata during multi-threaded decoding. */
2254 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2255
2256 /* Ensure that subtitle_header is properly set. */
2257 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
2258 && codec && !avctx->codec)
2259 avcodec_open2(avctx, codec,
2260 options ? &options[i] : &thread_opt);
2261
2262 // Try to just open decoders, in case this is enough to get parameters.
2263 if (!has_codec_parameters(st)) {
2264 if (codec && !avctx->codec)
2265 avcodec_open2(avctx, codec,
2266 options ? &options[i] : &thread_opt);
2267 }
2268 if (!options)
2269 av_dict_free(&thread_opt);
2270 }
2271
2272 for (i = 0; i < ic->nb_streams; i++) {
2273 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2274 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2275 }
2276
2277 count = 0;
2278 read_size = 0;
2279 for (;;) {
2280 if (ff_check_interrupt(&ic->interrupt_callback)) {
2281 ret = AVERROR_EXIT;
2282 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2283 break;
2284 }
2285
2286 /* check if one codec still needs to be handled */
2287 for (i = 0; i < ic->nb_streams; i++) {
2288 int fps_analyze_framecount = 20;
2289
2290 st = ic->streams[i];
2291 if (!has_codec_parameters(st))
2292 break;
2293 /* If the timebase is coarse (like the usual millisecond precision
2294 * of mkv), we need to analyze more frames to reliably arrive at
2295 * the correct fps. */
2296 if (av_q2d(st->time_base) > 0.0005)
2297 fps_analyze_framecount *= 2;
2298 if (ic->fps_probe_size >= 0)
2299 fps_analyze_framecount = ic->fps_probe_size;
2300 /* variable fps and no guess at the real fps */
2301 if (!st->avg_frame_rate.num &&
2302 st->codec_info_nb_frames < fps_analyze_framecount &&
2303 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2304 break;
2305 if (!st->codecpar->extradata &&
2306 !st->internal->avctx->extradata &&
2307 (!st->internal->extract_extradata.inited ||
2308 st->internal->extract_extradata.bsf))
2309 break;
2310 if (st->first_dts == AV_NOPTS_VALUE &&
2311 st->codec_info_nb_frames < ic->max_ts_probe &&
2312 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2313 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
2314 break;
2315 }
2316 if (i == ic->nb_streams) {
2317 /* NOTE: If the format has no header, then we need to read some
2318 * packets to get most of the streams, so we cannot stop here. */
2319 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2320 /* If we found the info for all the codecs, we can stop. */
2321 ret = count;
2322 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2323 break;
2324 }
2325 }
2326 /* We did not get all the codec info, but we read too much data. */
2327 if (read_size >= ic->probesize) {
2328 ret = count;
2329 av_log(ic, AV_LOG_DEBUG,
2330 "Probe buffer size limit %d reached\n", ic->probesize);
2331 break;
2332 }
2333
2334 /* NOTE: A new stream can be added there if no header in file
2335 * (AVFMTCTX_NOHEADER). */
2336 ret = read_frame_internal(ic, &pkt1);
2337 if (ret == AVERROR(EAGAIN))
2338 continue;
2339
2340 if (ret < 0) {
2341 /* EOF or error*/
2342 AVPacket empty_pkt = { 0 };
2343 int err = 0;
2344 av_init_packet(&empty_pkt);
2345
2346 /* We could not have all the codec parameters before EOF. */
2347 ret = -1;
2348 for (i = 0; i < ic->nb_streams; i++) {
2349 st = ic->streams[i];
2350
2351 /* flush the decoders */
2352 if (st->info->found_decoder == 1) {
2353 do {
2354 err = try_decode_frame(ic, st, &empty_pkt,
2355 (options && i < orig_nb_streams)
2356 ? &options[i] : NULL);
2357 } while (err > 0 && !has_codec_parameters(st));
2358 }
2359
2360 if (err < 0) {
2361 av_log(ic, AV_LOG_WARNING,
2362 "decoding for stream %d failed\n", st->index);
2363 } else if (!has_codec_parameters(st)) {
2364 char buf[256];
2365 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
2366 av_log(ic, AV_LOG_WARNING,
2367 "Could not find codec parameters (%s)\n", buf);
2368 } else {
2369 ret = 0;
2370 }
2371 }
2372 break;
2373 }
2374
2375 pkt = &pkt1;
2376
2377 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
2378 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
2379 &ic->internal->packet_buffer_end, 0);
2380 if (ret < 0)
2381 goto find_stream_info_err;
2382 }
2383
2384 read_size += pkt->size;
2385
2386 st = ic->streams[pkt->stream_index];
2387 avctx = st->internal->avctx;
2388 if (!st->internal->avctx_inited) {
2389 ret = avcodec_parameters_to_context(avctx, st->codecpar);
2390 if (ret < 0)
2391 goto find_stream_info_err;
2392 st->internal->avctx_inited = 1;
2393 }
2394
2395 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2396 /* check for non-increasing dts */
2397 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2398 st->info->fps_last_dts >= pkt->dts) {
2399 av_log(ic, AV_LOG_WARNING,
2400 "Non-increasing DTS in stream %d: packet %d with DTS "
2401 "%"PRId64", packet %d with DTS %"PRId64"\n",
2402 st->index, st->info->fps_last_dts_idx,
2403 st->info->fps_last_dts, st->codec_info_nb_frames,
2404 pkt->dts);
2405 st->info->fps_first_dts =
2406 st->info->fps_last_dts = AV_NOPTS_VALUE;
2407 }
2408 /* Check for a discontinuity in dts. If the difference in dts
2409 * is more than 1000 times the average packet duration in the
2410 * sequence, we treat it as a discontinuity. */
2411 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2412 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2413 (pkt->dts - st->info->fps_last_dts) / 1000 >
2414 (st->info->fps_last_dts - st->info->fps_first_dts) /
2415 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2416 av_log(ic, AV_LOG_WARNING,
2417 "DTS discontinuity in stream %d: packet %d with DTS "
2418 "%"PRId64", packet %d with DTS %"PRId64"\n",
2419 st->index, st->info->fps_last_dts_idx,
2420 st->info->fps_last_dts, st->codec_info_nb_frames,
2421 pkt->dts);
2422 st->info->fps_first_dts =
2423 st->info->fps_last_dts = AV_NOPTS_VALUE;
2424 }
2425
2426 /* update stored dts values */
2427 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2428 st->info->fps_first_dts = pkt->dts;
2429 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2430 }
2431 st->info->fps_last_dts = pkt->dts;
2432 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2433
2434 /* check max_analyze_duration */
2435 if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
2436 AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2437 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached\n",
2438 ic->max_analyze_duration);
2439 if (ic->flags & AVFMT_FLAG_NOBUFFER)
2440 av_packet_unref(pkt);
2441 break;
2442 }
2443 }
2444 if (!st->internal->avctx->extradata) {
2445 ret = extract_extradata(st, pkt);
2446 if (ret < 0)
2447 goto find_stream_info_err;
2448 }
2449
2450 /* If still no information, we try to open the codec and to
2451 * decompress the frame. We try to avoid that in most cases as
2452 * it takes longer and uses more memory. For MPEG-4, we need to
2453 * decompress for QuickTime.
2454 *
2455 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2456 * least one frame of codec data, this makes sure the codec initializes
2457 * the channel configuration and does not only trust the values from
2458 * the container. */
2459 try_decode_frame(ic, st, pkt,
2460 (options && i < orig_nb_streams) ? &options[i] : NULL);
2461
2462 if (ic->flags & AVFMT_FLAG_NOBUFFER)
2463 av_packet_unref(pkt);
2464
2465 st->codec_info_nb_frames++;
2466 count++;
2467 }
2468
2469 for (i = 0; i < ic->nb_streams; i++) {
2470 st = ic->streams[i];
2471 avctx = st->internal->avctx;
2472 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
2473 /* estimate average framerate if not set by demuxer */
2474 if (!st->avg_frame_rate.num &&
2475 st->info->fps_last_dts != st->info->fps_first_dts) {
2476 int64_t delta_dts = st->info->fps_last_dts -
2477 st->info->fps_first_dts;
2478 int delta_packets = st->info->fps_last_dts_idx -
2479 st->info->fps_first_dts_idx;
2480 int best_fps = 0;
2481 double best_error = 0.01;
2482
2483 if (delta_dts >= INT64_MAX / st->time_base.num ||
2484 delta_packets >= INT64_MAX / st->time_base.den ||
2485 delta_dts < 0)
2486 continue;
2487 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2488 delta_packets * (int64_t) st->time_base.den,
2489 delta_dts * (int64_t) st->time_base.num, 60000);
2490
2491 /* Round guessed framerate to a "standard" framerate if it's
2492 * within 1% of the original estimate. */
2493 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
2494 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
2495 double error = fabs(av_q2d(st->avg_frame_rate) /
2496 av_q2d(std_fps) - 1);
2497
2498 if (error < best_error) {
2499 best_error = error;
2500 best_fps = std_fps.num;
2501 }
2502 }
2503 if (best_fps)
2504 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2505 best_fps, 12 * 1001, INT_MAX);
2506 }
2507 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2508 if (!avctx->bits_per_coded_sample)
2509 avctx->bits_per_coded_sample =
2510 av_get_bits_per_sample(avctx->codec_id);
2511 // set stream disposition based on audio service type
2512 switch (avctx->audio_service_type) {
2513 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2514 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
2515 break;
2516 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2517 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
2518 break;
2519 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2520 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
2521 break;
2522 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2523 st->disposition = AV_DISPOSITION_COMMENT;
2524 break;
2525 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2526 st->disposition = AV_DISPOSITION_KARAOKE;
2527 break;
2528 }
2529 }
2530 }
2531
2532 compute_chapters_end(ic);
2533
2534 /* update the stream parameters from the internal codec contexts */
2535 for (i = 0; i < ic->nb_streams; i++) {
2536 st = ic->streams[i];
2537 if (!st->internal->avctx_inited)
2538 continue;
2539
2540 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
2541 if (ret < 0)
2542 goto find_stream_info_err;
2543
2544 #if FF_API_LAVF_AVCTX
2545 FF_DISABLE_DEPRECATION_WARNINGS
2546 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
2547 if (ret < 0)
2548 goto find_stream_info_err;
2549
2550 if (st->internal->avctx->subtitle_header) {
2551 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
2552 if (!st->codec->subtitle_header)
2553 goto find_stream_info_err;
2554 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
2555 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
2556 st->codec->subtitle_header_size);
2557 }
2558 FF_ENABLE_DEPRECATION_WARNINGS
2559 #endif
2560
2561 st->internal->avctx_inited = 0;
2562 }
2563
2564 estimate_timings(ic, old_offset);
2565
2566 find_stream_info_err:
2567 for (i = 0; i < ic->nb_streams; i++) {
2568 avcodec_close(ic->streams[i]->internal->avctx);
2569 av_freep(&ic->streams[i]->info);
2570 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
2571 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
2572 }
2573 return ret;
2574 }
2575
2576 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2577 {
2578 int i, j;
2579
2580 for (i = 0; i < ic->nb_programs; i++)
2581 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2582 if (ic->programs[i]->stream_index[j] == s)
2583 return ic->programs[i];
2584 return NULL;
2585 }
2586
2587 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
2588 int wanted_stream_nb, int related_stream,
2589 AVCodec **decoder_ret, int flags)
2590 {
2591 int i, nb_streams = ic->nb_streams;
2592 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2593 unsigned *program = NULL;
2594 AVCodec *decoder = NULL, *best_decoder = NULL;
2595
2596 if (related_stream >= 0 && wanted_stream_nb < 0) {
2597 AVProgram *p = find_program_from_stream(ic, related_stream);
2598 if (p) {
2599 program = p->stream_index;
2600 nb_streams = p->nb_stream_indexes;
2601 }
2602 }
2603 for (i = 0; i < nb_streams; i++) {
2604 int real_stream_index = program ? program[i] : i;
2605 AVStream *st = ic->streams[real_stream_index];
2606 AVCodecParameters *par = st->codecpar;
2607 if (par->codec_type != type)
2608 continue;
2609 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2610 continue;
2611 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
2612 AV_DISPOSITION_VISUAL_IMPAIRED))
2613 continue;
2614 if (decoder_ret) {
2615 decoder = avcodec_find_decoder(par->codec_id);
2616 if (!decoder) {
2617 if (ret < 0)
2618 ret = AVERROR_DECODER_NOT_FOUND;
2619 continue;
2620 }
2621 }
2622 if (best_count >= st->codec_info_nb_frames)
2623 continue;
2624 best_count = st->codec_info_nb_frames;
2625 ret = real_stream_index;
2626 best_decoder = decoder;
2627 if (program && i == nb_streams - 1 && ret < 0) {
2628 program = NULL;
2629 nb_streams = ic->nb_streams;
2630 /* no related stream found, try again with everything */
2631 i = 0;
2632 }
2633 }
2634 if (decoder_ret)
2635 *decoder_ret = best_decoder;
2636 return ret;
2637 }
2638
2639 /*******************************************************/
2640
2641 int av_read_play(AVFormatContext *s)
2642 {
2643 if (s->iformat->read_play)
2644 return s->iformat->read_play(s);
2645 if (s->pb)
2646 return avio_pause(s->pb, 0);
2647 return AVERROR(ENOSYS);
2648 }
2649
2650 int av_read_pause(AVFormatContext *s)
2651 {
2652 if (s->iformat->read_pause)
2653 return s->iformat->read_pause(s);
2654 if (s->pb)
2655 return avio_pause(s->pb, 1);
2656 return AVERROR(ENOSYS);
2657 }
2658
2659 static void free_stream(AVStream **pst)
2660 {
2661 AVStream *st = *pst;
2662 int i;
2663
2664 if (!st)
2665 return;
2666
2667 for (i = 0; i < st->nb_side_data; i++)
2668 av_freep(&st->side_data[i].data);
2669 av_freep(&st->side_data);
2670
2671 if (st->parser)
2672 av_parser_close(st->parser);
2673
2674 if (st->attached_pic.data)
2675 av_packet_unref(&st->attached_pic);
2676
2677 if (st->internal) {
2678 avcodec_free_context(&st->internal->avctx);
2679 av_bsf_free(&st->internal->extract_extradata.bsf);
2680 av_packet_free(&st->internal->extract_extradata.pkt);
2681 }
2682 av_freep(&st->internal);
2683
2684 av_dict_free(&st->metadata);
2685 avcodec_parameters_free(&st->codecpar);
2686 av_freep(&st->probe_data.buf);
2687 av_free(st->index_entries);
2688 #if FF_API_LAVF_AVCTX
2689 FF_DISABLE_DEPRECATION_WARNINGS
2690 av_free(st->codec->extradata);
2691 av_free(st->codec->subtitle_header);
2692 av_free(st->codec);
2693 FF_ENABLE_DEPRECATION_WARNINGS
2694 #endif
2695 av_free(st->priv_data);
2696 av_free(st->info);
2697
2698 av_freep(pst);
2699 }
2700
2701 void avformat_free_context(AVFormatContext *s)
2702 {
2703 int i;
2704
2705 if (!s)
2706 return;
2707
2708 av_opt_free(s);
2709 if (s->iformat && s->iformat->priv_class && s->priv_data)
2710 av_opt_free(s->priv_data);
2711
2712 for (i = 0; i < s->nb_streams; i++)
2713 free_stream(&s->streams[i]);
2714
2715 for (i = s->nb_programs - 1; i >= 0; i--) {
2716 av_dict_free(&s->programs[i]->metadata);
2717 av_freep(&s->programs[i]->stream_index);
2718 av_freep(&s->programs[i]);
2719 }
2720 av_freep(&s->programs);
2721 av_freep(&s->priv_data);
2722 while (s->nb_chapters--) {
2723 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2724 av_free(s->chapters[s->nb_chapters]);
2725 }
2726 av_freep(&s->chapters);
2727 av_dict_free(&s->metadata);
2728 av_freep(&s->streams);
2729 av_freep(&s->internal);
2730 av_free(s);
2731 }
2732
2733 void avformat_close_input(AVFormatContext **ps)
2734 {
2735 AVFormatContext *s = *ps;
2736 AVIOContext *pb = s->pb;
2737
2738 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
2739 (s->flags & AVFMT_FLAG_CUSTOM_IO))
2740 pb = NULL;
2741
2742 flush_packet_queue(s);
2743
2744 if (s->iformat)
2745 if (s->iformat->read_close)
2746 s->iformat->read_close(s);
2747
2748 avformat_free_context(s);
2749
2750 *ps = NULL;
2751
2752 avio_close(pb);
2753 }
2754
2755 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
2756 {
2757 AVStream *st;
2758 int i;
2759
2760 if (av_reallocp_array(&s->streams, s->nb_streams + 1,
2761 sizeof(*s->streams)) < 0) {
2762 s->nb_streams = 0;
2763 return NULL;
2764 }
2765
2766 st = av_mallocz(sizeof(AVStream));
2767 if (!st)
2768 return NULL;
2769 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2770 av_free(st);
2771 return NULL;
2772 }
2773
2774 #if FF_API_LAVF_AVCTX
2775 FF_DISABLE_DEPRECATION_WARNINGS
2776 st->codec = avcodec_alloc_context3(c);
2777 if (!st->codec) {
2778 av_free(st->info);
2779 av_free(st);
2780 return NULL;
2781 }
2782 FF_ENABLE_DEPRECATION_WARNINGS
2783 #endif
2784
2785 st->internal = av_mallocz(sizeof(*st->internal));
2786 if (!st->internal)
2787 goto fail;
2788
2789 if (s->iformat) {
2790 #if FF_API_LAVF_AVCTX
2791 FF_DISABLE_DEPRECATION_WARNINGS
2792 /* no default bitrate if decoding */
2793 st->codec->bit_rate = 0;
2794 FF_ENABLE_DEPRECATION_WARNINGS
2795 #endif
2796
2797 /* default pts setting is MPEG-like */
2798 avpriv_set_pts_info(st, 33, 1, 90000);
2799 /* we set the current DTS to 0 so that formats without any timestamps
2800 * but durations get some timestamps, formats with some unknown
2801 * timestamps have their first few packets buffered and the
2802 * timestamps corrected before they are returned to the user */
2803 st->cur_dts = 0;
2804 } else {
2805 st->cur_dts = AV_NOPTS_VALUE;
2806 }
2807
2808 st->codecpar = avcodec_parameters_alloc();
2809 if (!st->codecpar)
2810 goto fail;
2811
2812 st->internal->avctx = avcodec_alloc_context3(NULL);
2813 if (!st->internal->avctx)
2814 goto fail;
2815
2816 st->index = s->nb_streams;
2817 st->start_time = AV_NOPTS_VALUE;
2818 st->duration = AV_NOPTS_VALUE;
2819 st->first_dts = AV_NOPTS_VALUE;
2820 st->probe_packets = MAX_PROBE_PACKETS;
2821
2822 st->last_IP_pts = AV_NOPTS_VALUE;
2823 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
2824 st->pts_buffer[i] = AV_NOPTS_VALUE;
2825
2826 st->sample_aspect_ratio = (AVRational) { 0, 1 };
2827
2828 st->info->fps_first_dts = AV_NOPTS_VALUE;
2829 st->info->fps_last_dts = AV_NOPTS_VALUE;
2830
2831 #if FF_API_LAVF_AVCTX
2832 st->internal->need_codec_update = 1;
2833 #endif
2834
2835 s->streams[s->nb_streams++] = st;
2836 return st;
2837 fail:
2838 free_stream(&st);
2839 return NULL;
2840 }
2841
2842 AVProgram *av_new_program(AVFormatContext *ac, int id)
2843 {
2844 AVProgram *program = NULL;
2845 int i;
2846
2847 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
2848
2849 for (i = 0; i < ac->nb_programs; i++)
2850 if (ac->programs[i]->id == id)
2851 program = ac->programs[i];
2852
2853 if (!program) {
2854 program = av_mallocz(sizeof(AVProgram));
2855 if (!program)
2856 return NULL;
2857 dynarray_add(&ac->programs, &ac->nb_programs, program);
2858 program->discard = AVDISCARD_NONE;
2859 }
2860 program->id = id;
2861
2862 return program;
2863 }
2864
2865 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
2866 int64_t start, int64_t end, const char *title)
2867 {
2868 AVChapter *chapter = NULL;
2869 int i;
2870
2871 for (i = 0; i < s->nb_chapters; i++)
2872 if (s->chapters[i]->id == id)
2873 chapter = s->chapters[i];
2874
2875 if (!chapter) {
2876 chapter = av_mallocz(sizeof(AVChapter));
2877 if (!chapter)
2878 return NULL;
2879 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2880 }
2881 av_dict_set(&chapter->metadata, "title", title, 0);
2882 chapter->id = id;
2883 chapter->time_base = time_base;
2884 chapter->start = start;
2885 chapter->end = end;
2886
2887 return chapter;
2888 }
2889
2890 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
2891 {
2892 int i, j;
2893 AVProgram *program = NULL;
2894
2895 if (idx >= ac->nb_streams) {
2896 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2897 return;
2898 }
2899
2900 for (i = 0; i < ac->nb_programs; i++) {
2901 if (ac->programs[i]->id != progid)
2902 continue;
2903 program = ac->programs[i];
2904 for (j = 0; j < program->nb_stream_indexes; j++)
2905 if (program->stream_index[j] == idx)
2906 return;
2907
2908 if (av_reallocp_array(&program->stream_index,
2909 program->nb_stream_indexes + 1,
2910 sizeof(*program->stream_index)) < 0) {
2911 program->nb_stream_indexes = 0;
2912 return;
2913 }
2914 program->stream_index[program->nb_stream_indexes++] = idx;
2915 return;
2916 }
2917 }
2918
2919 uint64_t ff_ntp_time(void)
2920 {
2921 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
2922 }
2923
2924 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
2925 {
2926 const char *p;
2927 char *q, buf1[20], c;
2928 int nd, len, percentd_found;
2929
2930 q = buf;
2931 p = path;
2932 percentd_found = 0;
2933 for (;;) {
2934 c = *p++;
2935 if (c == '\0')
2936 break;
2937 if (c == '%') {
2938 do {
2939 nd = 0;
2940 while (av_isdigit(*p))
2941 nd = nd * 10 + *p++ - '0';
2942 c = *p++;
2943 } while (av_isdigit(c));
2944
2945 switch (c) {
2946 case '%':
2947 goto addchar;
2948 case 'd':
2949 if (percentd_found)
2950 goto fail;
2951 percentd_found = 1;
2952 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2953 len = strlen(buf1);
2954 if ((q - buf + len) > buf_size - 1)
2955 goto fail;
2956 memcpy(q, buf1, len);
2957 q += len;
2958 break;
2959 default:
2960 goto fail;
2961 }
2962 } else {
2963 addchar:
2964 if ((q - buf) < buf_size - 1)
2965 *q++ = c;
2966 }
2967 }
2968 if (!percentd_found)
2969 goto fail;
2970 *q = '\0';
2971 return 0;
2972 fail:
2973 *q = '\0';
2974 return -1;
2975 }
2976
2977 void av_url_split(char *proto, int proto_size,
2978 char *authorization, int authorization_size,
2979 char *hostname, int hostname_size,
2980 int *port_ptr, char *path, int path_size, const char *url)
2981 {
2982 const char *p, *ls, *at, *col, *brk;
2983
2984 if (port_ptr)
2985 *port_ptr = -1;
2986 if (proto_size > 0)
2987 proto[0] = 0;
2988 if (authorization_size > 0)
2989 authorization[0] = 0;
2990 if (hostname_size > 0)
2991 hostname[0] = 0;
2992 if (path_size > 0)
2993 path[0] = 0;
2994
2995 /* parse protocol */
2996 if ((p = strchr(url, ':'))) {
2997 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2998 p++; /* skip ':' */
2999 if (*p == '/')
3000 p++;
3001 if (*p == '/')
3002 p++;
3003 } else {
3004 /* no protocol means plain filename */
3005 av_strlcpy(path, url, path_size);
3006 return;
3007 }
3008
3009 /* separate path from hostname */
3010 ls = strchr(p, '/');
3011 if (!ls)
3012 ls = strchr(p, '?');
3013 if (ls)
3014 av_strlcpy(path, ls, path_size);
3015 else
3016 ls = &p[strlen(p)]; // XXX
3017
3018 /* the rest is hostname, use that to parse auth/port */
3019 if (ls != p) {
3020 /* authorization (user[:pass]@hostname) */
3021 if ((at = strchr(p, '@')) && at < ls) {
3022 av_strlcpy(authorization, p,
3023 FFMIN(authorization_size, at + 1 - p));
3024 p = at + 1; /* skip '@' */
3025 }
3026
3027 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3028 /* [host]:port */
3029 av_strlcpy(hostname, p + 1,
3030 FFMIN(hostname_size, brk - p));
3031 if (brk[1] == ':' && port_ptr)
3032 *port_ptr = atoi(brk + 2);
3033 } else if ((col = strchr(p, ':')) && col < ls) {
3034 av_strlcpy(hostname, p,
3035 FFMIN(col + 1 - p, hostname_size));
3036 if (port_ptr)
3037 *port_ptr = atoi(col + 1);
3038 } else
3039 av_strlcpy(hostname, p,
3040 FFMIN(ls + 1 - p, hostname_size));
3041 }
3042 }
3043
3044 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3045 {
3046 int i;
3047 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3048 '4', '5', '6', '7',
3049 '8', '9', 'A', 'B',
3050 'C', 'D', 'E', 'F' };
3051 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3052 '4', '5', '6', '7',
3053 '8', '9', 'a', 'b',
3054 'c', 'd', 'e', 'f' };
3055 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3056
3057 for (i = 0; i < s; i++) {
3058 buff[i * 2] = hex_table[src[i] >> 4];
3059 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3060 }
3061
3062 return buff;
3063 }
3064
3065 int ff_hex_to_data(uint8_t *data, const char *p)
3066 {
3067 int c, len, v;
3068
3069 len = 0;
3070 v = 1;
3071 for (;;) {
3072 p += strspn(p, SPACE_CHARS);
3073 if (*p == '\0')
3074 break;
3075 c = av_toupper((unsigned char) *p++);
3076 if (c >= '0' && c <= '9')
3077 c = c - '0';
3078 else if (c >= 'A' && c <= 'F')
3079 c = c - 'A' + 10;
3080 else
3081 break;
3082 v = (v << 4) | c;
3083 if (v & 0x100) {
3084 if (data)
3085 data[len] = v;
3086 len++;
3087 v = 1;
3088 }
3089 }
3090 return len;
3091 }
3092
3093 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3094 unsigned int pts_num, unsigned int pts_den)
3095 {
3096 AVRational new_tb;
3097 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3098 if (new_tb.num != pts_num)
3099 av_log(NULL, AV_LOG_DEBUG,
3100 "st:%d removing common factor %d from timebase\n",
3101 s->index, pts_num / new_tb.num);
3102 } else
3103 av_log(NULL, AV_LOG_WARNING,
3104 "st:%d has too large timebase, reducing\n", s->index);
3105
3106 if (new_tb.num <= 0 || new_tb.den <= 0) {
3107 av_log(NULL, AV_LOG_ERROR,
3108 "Ignoring attempt to set invalid timebase for st:%d\n",
3109 s->index);
3110 return;
3111 }
3112 s->time_base = new_tb;
3113 s->pts_wrap_bits = pts_wrap_bits;
3114 }
3115
3116 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3117 void *context)
3118 {
3119 const char *ptr = str;
3120
3121 /* Parse key=value pairs. */
3122 for (;;) {
3123 const char *key;
3124 char *dest = NULL, *dest_end;
3125 int key_len, dest_len = 0;
3126
3127 /* Skip whitespace and potential commas. */
3128 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3129 ptr++;
3130 if (!*ptr)
3131 break;
3132
3133 key = ptr;
3134
3135 if (!(ptr = strchr(key, '=')))
3136 break;
3137 ptr++;
3138 key_len = ptr - key;
3139
3140 callback_get_buf(context, key, key_len, &dest, &dest_len);
3141 dest_end = dest + dest_len - 1;
3142
3143 if (*ptr == '\"') {
3144 ptr++;
3145 while (*ptr && *ptr != '\"') {
3146 if (*ptr == '\\') {
3147 if (!ptr[1])
3148 break;
3149 if (dest && dest < dest_end)
3150 *dest++ = ptr[1];
3151 ptr += 2;
3152 } else {
3153 if (dest && dest < dest_end)
3154 *dest++ = *ptr;
3155 ptr++;