1 /*
2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <stdint.h>
23
24 #include "config.h"
25
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/parseutils.h"
33 #include "libavutil/pixfmt.h"
34 #include "libavutil/thread.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
37
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/packet_internal.h"
41 #include "libavcodec/raw.h"
42
43 #include "avformat.h"
44 #include "avio_internal.h"
45 #include "id3v2.h"
46 #include "internal.h"
47 #if CONFIG_NETWORK
48 #include "network.h"
49 #endif
50 #include "url.h"
51
52 #include "libavutil/ffversion.h"
53 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
54
55 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
56
57 /**
58 * @file
59 * various utility functions for use within FFmpeg
60 */
61
avformat_version(void)62 unsigned avformat_version(void)
63 {
64 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
65 return LIBAVFORMAT_VERSION_INT;
66 }
67
avformat_configuration(void)68 const char *avformat_configuration(void)
69 {
70 return FFMPEG_CONFIGURATION;
71 }
72
avformat_license(void)73 const char *avformat_license(void)
74 {
75 #define LICENSE_PREFIX "libavformat license: "
76 return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
77 }
78
ff_lock_avformat(void)79 int ff_lock_avformat(void)
80 {
81 return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
82 }
83
ff_unlock_avformat(void)84 int ff_unlock_avformat(void)
85 {
86 return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
87 }
88
89 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
90
is_relative(int64_t ts)91 static int is_relative(int64_t ts) {
92 return ts > (RELATIVE_TS_BASE - (1LL<<48));
93 }
94
95 /**
96 * Wrap a given time stamp, if there is an indication for an overflow
97 *
98 * @param st stream
99 * @param timestamp the time stamp to wrap
100 * @return resulting time stamp
101 */
wrap_timestamp(const AVStream * st,int64_t timestamp)102 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
103 {
104 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
105 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
106 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
107 timestamp < st->pts_wrap_reference)
108 return timestamp + (1ULL << st->pts_wrap_bits);
109 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
110 timestamp >= st->pts_wrap_reference)
111 return timestamp - (1ULL << st->pts_wrap_bits);
112 }
113 return timestamp;
114 }
115
116 #if FF_API_FORMAT_GET_SET
MAKE_ACCESSORS(AVStream,stream,AVRational,r_frame_rate)117 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
118 #if FF_API_LAVF_FFSERVER
119 FF_DISABLE_DEPRECATION_WARNINGS
120 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
121 FF_ENABLE_DEPRECATION_WARNINGS
122 #endif
123 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
124 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
125 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
126 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
127 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
128 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
129 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
130 #if FF_API_OLD_OPEN_CALLBACKS
131 FF_DISABLE_DEPRECATION_WARNINGS
132 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
133 FF_ENABLE_DEPRECATION_WARNINGS
134 #endif
135 #endif
136
137 int64_t av_stream_get_end_pts(const AVStream *st)
138 {
139 if (st->internal->priv_pts) {
140 return st->internal->priv_pts->val;
141 } else
142 return AV_NOPTS_VALUE;
143 }
144
av_stream_get_parser(const AVStream * st)145 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
146 {
147 return st->parser;
148 }
149
av_format_inject_global_side_data(AVFormatContext * s)150 void av_format_inject_global_side_data(AVFormatContext *s)
151 {
152 int i;
153 s->internal->inject_global_side_data = 1;
154 for (i = 0; i < s->nb_streams; i++) {
155 AVStream *st = s->streams[i];
156 st->inject_global_side_data = 1;
157 }
158 }
159
ff_copy_whiteblacklists(AVFormatContext * dst,const AVFormatContext * src)160 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
161 {
162 av_assert0(!dst->codec_whitelist &&
163 !dst->format_whitelist &&
164 !dst->protocol_whitelist &&
165 !dst->protocol_blacklist);
166 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
167 dst->format_whitelist = av_strdup(src->format_whitelist);
168 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
169 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
170 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
171 || (src-> format_whitelist && !dst-> format_whitelist)
172 || (src->protocol_whitelist && !dst->protocol_whitelist)
173 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
174 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
175 return AVERROR(ENOMEM);
176 }
177 return 0;
178 }
179
find_decoder(AVFormatContext * s,const AVStream * st,enum AVCodecID codec_id)180 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
181 {
182 #if FF_API_LAVF_AVCTX
183 FF_DISABLE_DEPRECATION_WARNINGS
184 if (st->codec->codec)
185 return st->codec->codec;
186 FF_ENABLE_DEPRECATION_WARNINGS
187 #endif
188
189 switch (st->codecpar->codec_type) {
190 case AVMEDIA_TYPE_VIDEO:
191 if (s->video_codec) return s->video_codec;
192 break;
193 case AVMEDIA_TYPE_AUDIO:
194 if (s->audio_codec) return s->audio_codec;
195 break;
196 case AVMEDIA_TYPE_SUBTITLE:
197 if (s->subtitle_codec) return s->subtitle_codec;
198 break;
199 }
200
201 return avcodec_find_decoder(codec_id);
202 }
203
find_probe_decoder(AVFormatContext * s,const AVStream * st,enum AVCodecID codec_id)204 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
205 {
206 const AVCodec *codec;
207
208 #if CONFIG_H264_DECODER
209 /* Other parts of the code assume this decoder to be used for h264,
210 * so force it if possible. */
211 if (codec_id == AV_CODEC_ID_H264)
212 return avcodec_find_decoder_by_name("h264");
213 #endif
214
215 codec = find_decoder(s, st, codec_id);
216 if (!codec)
217 return NULL;
218
219 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
220 const AVCodec *probe_codec = NULL;
221 void *iter = NULL;
222 while ((probe_codec = av_codec_iterate(&iter))) {
223 if (probe_codec->id == codec->id &&
224 av_codec_is_decoder(probe_codec) &&
225 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
226 return probe_codec;
227 }
228 }
229 }
230
231 return codec;
232 }
233
234 #if FF_API_FORMAT_GET_SET
av_format_get_probe_score(const AVFormatContext * s)235 int av_format_get_probe_score(const AVFormatContext *s)
236 {
237 return s->probe_score;
238 }
239 #endif
240
241 /* an arbitrarily chosen "sane" max packet size -- 50M */
242 #define SANE_CHUNK_SIZE (50000000)
243
ffio_limit(AVIOContext * s,int size)244 int ffio_limit(AVIOContext *s, int size)
245 {
246 if (s->maxsize>= 0) {
247 int64_t remaining= s->maxsize - avio_tell(s);
248 if (remaining < size) {
249 int64_t newsize = avio_size(s);
250 if (!s->maxsize || s->maxsize<newsize)
251 s->maxsize = newsize - !newsize;
252 remaining= s->maxsize - avio_tell(s);
253 remaining= FFMAX(remaining, 0);
254 }
255
256 if (s->maxsize>= 0 && remaining+1 < size) {
257 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
258 size = remaining+1;
259 }
260 }
261 return size;
262 }
263
264 /* Read the data in sane-sized chunks and append to pkt.
265 * Return the number of bytes read or an error. */
append_packet_chunked(AVIOContext * s,AVPacket * pkt,int size)266 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
267 {
268 int orig_size = pkt->size;
269 int ret;
270
271 do {
272 int prev_size = pkt->size;
273 int read_size;
274
275 /* When the caller requests a lot of data, limit it to the amount
276 * left in file or SANE_CHUNK_SIZE when it is not known. */
277 read_size = size;
278 if (read_size > SANE_CHUNK_SIZE/10) {
279 read_size = ffio_limit(s, read_size);
280 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
281 if (s->maxsize < 0)
282 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
283 }
284
285 ret = av_grow_packet(pkt, read_size);
286 if (ret < 0)
287 break;
288
289 ret = avio_read(s, pkt->data + prev_size, read_size);
290 if (ret != read_size) {
291 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
292 break;
293 }
294
295 size -= read_size;
296 } while (size > 0);
297 if (size > 0)
298 pkt->flags |= AV_PKT_FLAG_CORRUPT;
299
300 if (!pkt->size)
301 av_packet_unref(pkt);
302 return pkt->size > orig_size ? pkt->size - orig_size : ret;
303 }
304
av_get_packet(AVIOContext * s,AVPacket * pkt,int size)305 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
306 {
307 av_init_packet(pkt);
308 pkt->data = NULL;
309 pkt->size = 0;
310 pkt->pos = avio_tell(s);
311
312 return append_packet_chunked(s, pkt, size);
313 }
314
av_append_packet(AVIOContext * s,AVPacket * pkt,int size)315 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
316 {
317 if (!pkt->size)
318 return av_get_packet(s, pkt, size);
319 return append_packet_chunked(s, pkt, size);
320 }
321
av_filename_number_test(const char * filename)322 int av_filename_number_test(const char *filename)
323 {
324 char buf[1024];
325 return filename &&
326 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
327 }
328
set_codec_from_probe_data(AVFormatContext * s,AVStream * st,AVProbeData * pd)329 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
330 AVProbeData *pd)
331 {
332 static const struct {
333 const char *name;
334 enum AVCodecID id;
335 enum AVMediaType type;
336 } fmt_id_type[] = {
337 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
338 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
339 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
340 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
341 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
342 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
343 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
344 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
345 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
346 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
347 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
348 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
349 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
350 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
351 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
352 { 0 }
353 };
354 int score;
355 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
356
357 if (fmt) {
358 int i;
359 av_log(s, AV_LOG_DEBUG,
360 "Probe with size=%d, packets=%d detected %s with score=%d\n",
361 pd->buf_size, s->max_probe_packets - st->probe_packets,
362 fmt->name, score);
363 for (i = 0; fmt_id_type[i].name; i++) {
364 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
365 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
366 st->codecpar->sample_rate)
367 continue;
368 if (st->request_probe > score &&
369 st->codecpar->codec_id != fmt_id_type[i].id)
370 continue;
371 st->codecpar->codec_id = fmt_id_type[i].id;
372 st->codecpar->codec_type = fmt_id_type[i].type;
373 st->internal->need_context_update = 1;
374 #if FF_API_LAVF_AVCTX
375 FF_DISABLE_DEPRECATION_WARNINGS
376 st->codec->codec_type = st->codecpar->codec_type;
377 st->codec->codec_id = st->codecpar->codec_id;
378 FF_ENABLE_DEPRECATION_WARNINGS
379 #endif
380 return score;
381 }
382 }
383 }
384 return 0;
385 }
386
387 /************************************************************/
388 /* input media file */
389
av_demuxer_open(AVFormatContext * ic)390 int av_demuxer_open(AVFormatContext *ic) {
391 int err;
392
393 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
394 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
395 return AVERROR(EINVAL);
396 }
397
398 if (ic->iformat->read_header) {
399 err = ic->iformat->read_header(ic);
400 if (err < 0)
401 return err;
402 }
403
404 if (ic->pb && !ic->internal->data_offset)
405 ic->internal->data_offset = avio_tell(ic->pb);
406
407 return 0;
408 }
409
410 /* Open input file and probe the format if necessary. */
init_input(AVFormatContext * s,const char * filename,AVDictionary ** options)411 static int init_input(AVFormatContext *s, const char *filename,
412 AVDictionary **options)
413 {
414 int ret;
415 AVProbeData pd = { filename, NULL, 0 };
416 int score = AVPROBE_SCORE_RETRY;
417
418 if (s->pb) {
419 s->flags |= AVFMT_FLAG_CUSTOM_IO;
420 if (!s->iformat)
421 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
422 s, 0, s->format_probesize);
423 else if (s->iformat->flags & AVFMT_NOFILE)
424 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
425 "will be ignored with AVFMT_NOFILE format.\n");
426 return 0;
427 }
428
429 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
430 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
431 return score;
432
433 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
434 return ret;
435
436 if (s->iformat)
437 return 0;
438 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
439 s, 0, s->format_probesize);
440 }
441
avformat_queue_attached_pictures(AVFormatContext * s)442 int avformat_queue_attached_pictures(AVFormatContext *s)
443 {
444 int i, ret;
445 for (i = 0; i < s->nb_streams; i++)
446 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
447 s->streams[i]->discard < AVDISCARD_ALL) {
448 if (s->streams[i]->attached_pic.size <= 0) {
449 av_log(s, AV_LOG_WARNING,
450 "Attached picture on stream %d has invalid size, "
451 "ignoring\n", i);
452 continue;
453 }
454
455 ret = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
456 &s->internal->raw_packet_buffer_end,
457 &s->streams[i]->attached_pic,
458 av_packet_ref, 0);
459 if (ret < 0)
460 return ret;
461 }
462 return 0;
463 }
464
update_stream_avctx(AVFormatContext * s)465 static int update_stream_avctx(AVFormatContext *s)
466 {
467 int i, ret;
468 for (i = 0; i < s->nb_streams; i++) {
469 AVStream *st = s->streams[i];
470
471 if (!st->internal->need_context_update)
472 continue;
473
474 /* close parser, because it depends on the codec */
475 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
476 av_parser_close(st->parser);
477 st->parser = NULL;
478 }
479
480 /* update internal codec context, for the parser */
481 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
482 if (ret < 0)
483 return ret;
484
485 #if FF_API_LAVF_AVCTX
486 FF_DISABLE_DEPRECATION_WARNINGS
487 /* update deprecated public codec context */
488 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
489 if (ret < 0)
490 return ret;
491 FF_ENABLE_DEPRECATION_WARNINGS
492 #endif
493
494 st->internal->need_context_update = 0;
495 }
496 return 0;
497 }
498
499
avformat_open_input(AVFormatContext ** ps,const char * filename,ff_const59 AVInputFormat * fmt,AVDictionary ** options)500 int avformat_open_input(AVFormatContext **ps, const char *filename,
501 ff_const59 AVInputFormat *fmt, AVDictionary **options)
502 {
503 AVFormatContext *s = *ps;
504 int i, ret = 0;
505 AVDictionary *tmp = NULL;
506 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
507
508 if (!s && !(s = avformat_alloc_context()))
509 return AVERROR(ENOMEM);
510 if (!s->av_class) {
511 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
512 return AVERROR(EINVAL);
513 }
514 if (fmt)
515 s->iformat = fmt;
516
517 if (options)
518 av_dict_copy(&tmp, *options, 0);
519
520 if (s->pb) // must be before any goto fail
521 s->flags |= AVFMT_FLAG_CUSTOM_IO;
522
523 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
524 goto fail;
525
526 if (!(s->url = av_strdup(filename ? filename : ""))) {
527 ret = AVERROR(ENOMEM);
528 goto fail;
529 }
530
531 #if FF_API_FORMAT_FILENAME
532 FF_DISABLE_DEPRECATION_WARNINGS
533 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
534 FF_ENABLE_DEPRECATION_WARNINGS
535 #endif
536 if ((ret = init_input(s, filename, &tmp)) < 0)
537 goto fail;
538 s->probe_score = ret;
539
540 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
541 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
542 if (!s->protocol_whitelist) {
543 ret = AVERROR(ENOMEM);
544 goto fail;
545 }
546 }
547
548 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
549 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
550 if (!s->protocol_blacklist) {
551 ret = AVERROR(ENOMEM);
552 goto fail;
553 }
554 }
555
556 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
557 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
558 ret = AVERROR(EINVAL);
559 goto fail;
560 }
561
562 avio_skip(s->pb, s->skip_initial_bytes);
563
564 /* Check filename in case an image number is expected. */
565 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
566 if (!av_filename_number_test(filename)) {
567 ret = AVERROR(EINVAL);
568 goto fail;
569 }
570 }
571
572 s->duration = s->start_time = AV_NOPTS_VALUE;
573
574 /* Allocate private data. */
575 if (s->iformat->priv_data_size > 0) {
576 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
577 ret = AVERROR(ENOMEM);
578 goto fail;
579 }
580 if (s->iformat->priv_class) {
581 *(const AVClass **) s->priv_data = s->iformat->priv_class;
582 av_opt_set_defaults(s->priv_data);
583 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
584 goto fail;
585 }
586 }
587
588 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
589 if (s->pb)
590 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
591
592
593 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
594 if ((ret = s->iformat->read_header(s)) < 0)
595 goto fail;
596
597 if (!s->metadata) {
598 s->metadata = s->internal->id3v2_meta;
599 s->internal->id3v2_meta = NULL;
600 } else if (s->internal->id3v2_meta) {
601 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
602 av_dict_free(&s->internal->id3v2_meta);
603 }
604
605 if (id3v2_extra_meta) {
606 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
607 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
608 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
609 goto close;
610 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
611 goto close;
612 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
613 goto close;
614 } else
615 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
616 }
617 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
618
619 if ((ret = avformat_queue_attached_pictures(s)) < 0)
620 goto close;
621
622 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
623 s->internal->data_offset = avio_tell(s->pb);
624
625 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
626
627 update_stream_avctx(s);
628
629 for (i = 0; i < s->nb_streams; i++)
630 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
631
632 if (options) {
633 av_dict_free(options);
634 *options = tmp;
635 }
636 *ps = s;
637 return 0;
638
639 close:
640 if (s->iformat->read_close)
641 s->iformat->read_close(s);
642 fail:
643 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
644 av_dict_free(&tmp);
645 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
646 avio_closep(&s->pb);
647 avformat_free_context(s);
648 *ps = NULL;
649 return ret;
650 }
651
652 /*******************************************************/
653
force_codec_ids(AVFormatContext * s,AVStream * st)654 static void force_codec_ids(AVFormatContext *s, AVStream *st)
655 {
656 switch (st->codecpar->codec_type) {
657 case AVMEDIA_TYPE_VIDEO:
658 if (s->video_codec_id)
659 st->codecpar->codec_id = s->video_codec_id;
660 break;
661 case AVMEDIA_TYPE_AUDIO:
662 if (s->audio_codec_id)
663 st->codecpar->codec_id = s->audio_codec_id;
664 break;
665 case AVMEDIA_TYPE_SUBTITLE:
666 if (s->subtitle_codec_id)
667 st->codecpar->codec_id = s->subtitle_codec_id;
668 break;
669 case AVMEDIA_TYPE_DATA:
670 if (s->data_codec_id)
671 st->codecpar->codec_id = s->data_codec_id;
672 break;
673 }
674 }
675
probe_codec(AVFormatContext * s,AVStream * st,const AVPacket * pkt)676 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
677 {
678 if (st->request_probe>0) {
679 AVProbeData *pd = &st->probe_data;
680 int end;
681 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
682 --st->probe_packets;
683
684 if (pkt) {
685 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
686 if (!new_buf) {
687 av_log(s, AV_LOG_WARNING,
688 "Failed to reallocate probe buffer for stream %d\n",
689 st->index);
690 goto no_packet;
691 }
692 pd->buf = new_buf;
693 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
694 pd->buf_size += pkt->size;
695 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
696 } else {
697 no_packet:
698 st->probe_packets = 0;
699 if (!pd->buf_size) {
700 av_log(s, AV_LOG_WARNING,
701 "nothing to probe for stream %d\n", st->index);
702 }
703 }
704
705 end= s->internal->raw_packet_buffer_remaining_size <= 0
706 || st->probe_packets<= 0;
707
708 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
709 int score = set_codec_from_probe_data(s, st, pd);
710 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
711 || end) {
712 pd->buf_size = 0;
713 av_freep(&pd->buf);
714 st->request_probe = -1;
715 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
716 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
717 } else
718 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
719 }
720 force_codec_ids(s, st);
721 }
722 }
723 return 0;
724 }
725
update_wrap_reference(AVFormatContext * s,AVStream * st,int stream_index,AVPacket * pkt)726 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
727 {
728 int64_t ref = pkt->dts;
729 int i, pts_wrap_behavior;
730 int64_t pts_wrap_reference;
731 AVProgram *first_program;
732
733 if (ref == AV_NOPTS_VALUE)
734 ref = pkt->pts;
735 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
736 return 0;
737 ref &= (1LL << st->pts_wrap_bits)-1;
738
739 // reference time stamp should be 60 s before first time stamp
740 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
741 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
742 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
743 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
744 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
745
746 first_program = av_find_program_from_stream(s, NULL, stream_index);
747
748 if (!first_program) {
749 int default_stream_index = av_find_default_stream_index(s);
750 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
751 for (i = 0; i < s->nb_streams; i++) {
752 if (av_find_program_from_stream(s, NULL, i))
753 continue;
754 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
755 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
756 }
757 }
758 else {
759 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
760 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
761 }
762 }
763 else {
764 AVProgram *program = first_program;
765 while (program) {
766 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
767 pts_wrap_reference = program->pts_wrap_reference;
768 pts_wrap_behavior = program->pts_wrap_behavior;
769 break;
770 }
771 program = av_find_program_from_stream(s, program, stream_index);
772 }
773
774 // update every program with differing pts_wrap_reference
775 program = first_program;
776 while (program) {
777 if (program->pts_wrap_reference != pts_wrap_reference) {
778 for (i = 0; i<program->nb_stream_indexes; i++) {
779 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
780 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
781 }
782
783 program->pts_wrap_reference = pts_wrap_reference;
784 program->pts_wrap_behavior = pts_wrap_behavior;
785 }
786 program = av_find_program_from_stream(s, program, stream_index);
787 }
788 }
789 return 1;
790 }
791
ff_read_packet(AVFormatContext * s,AVPacket * pkt)792 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
793 {
794 int ret, i, err;
795 AVStream *st;
796
797 pkt->data = NULL;
798 pkt->size = 0;
799 av_init_packet(pkt);
800
801 for (;;) {
802 AVPacketList *pktl = s->internal->raw_packet_buffer;
803 const AVPacket *pkt1;
804
805 if (pktl) {
806 st = s->streams[pktl->pkt.stream_index];
807 if (s->internal->raw_packet_buffer_remaining_size <= 0)
808 if ((err = probe_codec(s, st, NULL)) < 0)
809 return err;
810 if (st->request_probe <= 0) {
811 avpriv_packet_list_get(&s->internal->raw_packet_buffer,
812 &s->internal->raw_packet_buffer_end, pkt);
813 s->internal->raw_packet_buffer_remaining_size += pkt->size;
814 return 0;
815 }
816 }
817
818 ret = s->iformat->read_packet(s, pkt);
819 if (ret < 0) {
820 av_packet_unref(pkt);
821
822 /* Some demuxers return FFERROR_REDO when they consume
823 data and discard it (ignored streams, junk, extradata).
824 We must re-call the demuxer to get the real packet. */
825 if (ret == FFERROR_REDO)
826 continue;
827 if (!pktl || ret == AVERROR(EAGAIN))
828 return ret;
829 for (i = 0; i < s->nb_streams; i++) {
830 st = s->streams[i];
831 if (st->probe_packets || st->request_probe > 0)
832 if ((err = probe_codec(s, st, NULL)) < 0)
833 return err;
834 av_assert0(st->request_probe <= 0);
835 }
836 continue;
837 }
838
839 err = av_packet_make_refcounted(pkt);
840 if (err < 0) {
841 av_packet_unref(pkt);
842 return err;
843 }
844
845 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
846 av_log(s, AV_LOG_WARNING,
847 "Packet corrupt (stream = %d, dts = %s)",
848 pkt->stream_index, av_ts2str(pkt->dts));
849 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
850 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
851 av_packet_unref(pkt);
852 continue;
853 }
854 av_log(s, AV_LOG_WARNING, ".\n");
855 }
856
857 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
858 "Invalid stream index.\n");
859
860 st = s->streams[pkt->stream_index];
861
862 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
863 // correct first time stamps to negative values
864 if (!is_relative(st->first_dts))
865 st->first_dts = wrap_timestamp(st, st->first_dts);
866 if (!is_relative(st->start_time))
867 st->start_time = wrap_timestamp(st, st->start_time);
868 if (!is_relative(st->cur_dts))
869 st->cur_dts = wrap_timestamp(st, st->cur_dts);
870 }
871
872 pkt->dts = wrap_timestamp(st, pkt->dts);
873 pkt->pts = wrap_timestamp(st, pkt->pts);
874
875 force_codec_ids(s, st);
876
877 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
878 if (s->use_wallclock_as_timestamps)
879 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
880
881 if (!pktl && st->request_probe <= 0)
882 return ret;
883
884 err = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
885 &s->internal->raw_packet_buffer_end,
886 pkt, NULL, 0);
887 if (err < 0) {
888 av_packet_unref(pkt);
889 return err;
890 }
891 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
892 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
893
894 if ((err = probe_codec(s, st, pkt1)) < 0)
895 return err;
896 }
897 }
898
899
900 /**********************************************************/
901
determinable_frame_size(AVCodecContext * avctx)902 static int determinable_frame_size(AVCodecContext *avctx)
903 {
904 switch(avctx->codec_id) {
905 case AV_CODEC_ID_MP1:
906 case AV_CODEC_ID_MP2:
907 case AV_CODEC_ID_MP3:
908 case AV_CODEC_ID_CODEC2:
909 return 1;
910 }
911
912 return 0;
913 }
914
915 /**
916 * Return the frame duration in seconds. Return 0 if not available.
917 */
ff_compute_frame_duration(AVFormatContext * s,int * pnum,int * pden,AVStream * st,AVCodecParserContext * pc,AVPacket * pkt)918 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
919 AVCodecParserContext *pc, AVPacket *pkt)
920 {
921 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
922 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
923 int frame_size, sample_rate;
924
925 #if FF_API_LAVF_AVCTX
926 FF_DISABLE_DEPRECATION_WARNINGS
927 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
928 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
929 FF_ENABLE_DEPRECATION_WARNINGS
930 #endif
931
932 *pnum = 0;
933 *pden = 0;
934 switch (st->codecpar->codec_type) {
935 case AVMEDIA_TYPE_VIDEO:
936 if (st->r_frame_rate.num && !pc && s->iformat) {
937 *pnum = st->r_frame_rate.den;
938 *pden = st->r_frame_rate.num;
939 } else if (st->time_base.num * 1000LL > st->time_base.den) {
940 *pnum = st->time_base.num;
941 *pden = st->time_base.den;
942 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
943 av_assert0(st->internal->avctx->ticks_per_frame);
944 av_reduce(pnum, pden,
945 codec_framerate.den,
946 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
947 INT_MAX);
948
949 if (pc && pc->repeat_pict) {
950 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
951 av_reduce(pnum, pden,
952 (*pnum) * (1LL + pc->repeat_pict),
953 (*pden),
954 INT_MAX);
955 }
956 /* If this codec can be interlaced or progressive then we need
957 * a parser to compute duration of a packet. Thus if we have
958 * no parser in such case leave duration undefined. */
959 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
960 *pnum = *pden = 0;
961 }
962 break;
963 case AVMEDIA_TYPE_AUDIO:
964 if (st->internal->avctx_inited) {
965 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
966 sample_rate = st->internal->avctx->sample_rate;
967 } else {
968 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
969 sample_rate = st->codecpar->sample_rate;
970 }
971 if (frame_size <= 0 || sample_rate <= 0)
972 break;
973 *pnum = frame_size;
974 *pden = sample_rate;
975 break;
976 default:
977 break;
978 }
979 }
980
ff_is_intra_only(enum AVCodecID id)981 int ff_is_intra_only(enum AVCodecID id)
982 {
983 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
984 if (!d)
985 return 0;
986 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
987 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
988 return 0;
989 return 1;
990 }
991
has_decode_delay_been_guessed(AVStream * st)992 static int has_decode_delay_been_guessed(AVStream *st)
993 {
994 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
995 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
996 return 1;
997 #if CONFIG_H264_DECODER
998 if (st->internal->avctx->has_b_frames &&
999 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1000 return 1;
1001 #endif
1002 if (st->internal->avctx->has_b_frames<3)
1003 return st->nb_decoded_frames >= 7;
1004 else if (st->internal->avctx->has_b_frames<4)
1005 return st->nb_decoded_frames >= 18;
1006 else
1007 return st->nb_decoded_frames >= 20;
1008 }
1009
get_next_pkt(AVFormatContext * s,AVStream * st,AVPacketList * pktl)1010 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1011 {
1012 if (pktl->next)
1013 return pktl->next;
1014 if (pktl == s->internal->packet_buffer_end)
1015 return s->internal->parse_queue;
1016 return NULL;
1017 }
1018
select_from_pts_buffer(AVStream * st,int64_t * pts_buffer,int64_t dts)1019 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1020 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1021 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1022
1023 if(!onein_oneout) {
1024 int delay = st->internal->avctx->has_b_frames;
1025 int i;
1026
1027 if (dts == AV_NOPTS_VALUE) {
1028 int64_t best_score = INT64_MAX;
1029 for (i = 0; i<delay; i++) {
1030 if (st->pts_reorder_error_count[i]) {
1031 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1032 if (score < best_score) {
1033 best_score = score;
1034 dts = pts_buffer[i];
1035 }
1036 }
1037 }
1038 } else {
1039 for (i = 0; i<delay; i++) {
1040 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1041 int64_t diff = FFABS(pts_buffer[i] - dts)
1042 + (uint64_t)st->pts_reorder_error[i];
1043 diff = FFMAX(diff, st->pts_reorder_error[i]);
1044 st->pts_reorder_error[i] = diff;
1045 st->pts_reorder_error_count[i]++;
1046 if (st->pts_reorder_error_count[i] > 250) {
1047 st->pts_reorder_error[i] >>= 1;
1048 st->pts_reorder_error_count[i] >>= 1;
1049 }
1050 }
1051 }
1052 }
1053 }
1054
1055 if (dts == AV_NOPTS_VALUE)
1056 dts = pts_buffer[0];
1057
1058 return dts;
1059 }
1060
1061 /**
1062 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1063 * of the packets in a window.
1064 */
update_dts_from_pts(AVFormatContext * s,int stream_index,AVPacketList * pkt_buffer)1065 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1066 AVPacketList *pkt_buffer)
1067 {
1068 AVStream *st = s->streams[stream_index];
1069 int delay = st->internal->avctx->has_b_frames;
1070 int i;
1071
1072 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1073
1074 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1075 pts_buffer[i] = AV_NOPTS_VALUE;
1076
1077 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1078 if (pkt_buffer->pkt.stream_index != stream_index)
1079 continue;
1080
1081 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1082 pts_buffer[0] = pkt_buffer->pkt.pts;
1083 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1084 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1085
1086 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1087 }
1088 }
1089 }
1090
update_initial_timestamps(AVFormatContext * s,int stream_index,int64_t dts,int64_t pts,AVPacket * pkt)1091 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1092 int64_t dts, int64_t pts, AVPacket *pkt)
1093 {
1094 AVStream *st = s->streams[stream_index];
1095 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1096 AVPacketList *pktl_it;
1097
1098 uint64_t shift;
1099
1100 if (st->first_dts != AV_NOPTS_VALUE ||
1101 dts == AV_NOPTS_VALUE ||
1102 st->cur_dts == AV_NOPTS_VALUE ||
1103 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1104 is_relative(dts))
1105 return;
1106
1107 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1108 st->cur_dts = dts;
1109 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1110
1111 if (is_relative(pts))
1112 pts += shift;
1113
1114 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1115 if (pktl_it->pkt.stream_index != stream_index)
1116 continue;
1117 if (is_relative(pktl_it->pkt.pts))
1118 pktl_it->pkt.pts += shift;
1119
1120 if (is_relative(pktl_it->pkt.dts))
1121 pktl_it->pkt.dts += shift;
1122
1123 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1124 st->start_time = pktl_it->pkt.pts;
1125 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1126 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1127 }
1128 }
1129
1130 if (has_decode_delay_been_guessed(st)) {
1131 update_dts_from_pts(s, stream_index, pktl);
1132 }
1133
1134 if (st->start_time == AV_NOPTS_VALUE) {
1135 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1136 st->start_time = pts;
1137 }
1138 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1139 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1140 }
1141 }
1142
update_initial_durations(AVFormatContext * s,AVStream * st,int stream_index,int64_t duration)1143 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1144 int stream_index, int64_t duration)
1145 {
1146 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1147 int64_t cur_dts = RELATIVE_TS_BASE;
1148
1149 if (st->first_dts != AV_NOPTS_VALUE) {
1150 if (st->update_initial_durations_done)
1151 return;
1152 st->update_initial_durations_done = 1;
1153 cur_dts = st->first_dts;
1154 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1155 if (pktl->pkt.stream_index == stream_index) {
1156 if (pktl->pkt.pts != pktl->pkt.dts ||
1157 pktl->pkt.dts != AV_NOPTS_VALUE ||
1158 pktl->pkt.duration)
1159 break;
1160 cur_dts -= duration;
1161 }
1162 }
1163 if (pktl && pktl->pkt.dts != st->first_dts) {
1164 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1165 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1166 return;
1167 }
1168 if (!pktl) {
1169 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1170 return;
1171 }
1172 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1173 st->first_dts = cur_dts;
1174 } else if (st->cur_dts != RELATIVE_TS_BASE)
1175 return;
1176
1177 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1178 if (pktl->pkt.stream_index != stream_index)
1179 continue;
1180 if ((pktl->pkt.pts == pktl->pkt.dts ||
1181 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1182 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1183 pktl->pkt.dts == st->first_dts ||
1184 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1185 !pktl->pkt.duration) {
1186 pktl->pkt.dts = cur_dts;
1187 if (!st->internal->avctx->has_b_frames)
1188 pktl->pkt.pts = cur_dts;
1189 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1190 pktl->pkt.duration = duration;
1191 } else
1192 break;
1193 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1194 }
1195 if (!pktl)
1196 st->cur_dts = cur_dts;
1197 }
1198
compute_pkt_fields(AVFormatContext * s,AVStream * st,AVCodecParserContext * pc,AVPacket * pkt,int64_t next_dts,int64_t next_pts)1199 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1200 AVCodecParserContext *pc, AVPacket *pkt,
1201 int64_t next_dts, int64_t next_pts)
1202 {
1203 int num, den, presentation_delayed, delay, i;
1204 int64_t offset;
1205 AVRational duration;
1206 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1207 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1208
1209 if (s->flags & AVFMT_FLAG_NOFILLIN)
1210 return;
1211
1212 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1213 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1214 if (st->last_dts_for_order_check <= pkt->dts) {
1215 st->dts_ordered++;
1216 } else {
1217 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1218 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1219 pkt->dts,
1220 st->last_dts_for_order_check);
1221 st->dts_misordered++;
1222 }
1223 if (st->dts_ordered + st->dts_misordered > 250) {
1224 st->dts_ordered >>= 1;
1225 st->dts_misordered >>= 1;
1226 }
1227 }
1228
1229 st->last_dts_for_order_check = pkt->dts;
1230 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1231 pkt->dts = AV_NOPTS_VALUE;
1232 }
1233
1234 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1235 pkt->dts = AV_NOPTS_VALUE;
1236
1237 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1238 && !st->internal->avctx->has_b_frames)
1239 //FIXME Set low_delay = 0 when has_b_frames = 1
1240 st->internal->avctx->has_b_frames = 1;
1241
1242 /* do we have a video B-frame ? */
1243 delay = st->internal->avctx->has_b_frames;
1244 presentation_delayed = 0;
1245
1246 /* XXX: need has_b_frame, but cannot get it if the codec is
1247 * not initialized */
1248 if (delay &&
1249 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1250 presentation_delayed = 1;
1251
1252 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1253 st->pts_wrap_bits < 63 &&
1254 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1255 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1256 pkt->dts -= 1LL << st->pts_wrap_bits;
1257 } else
1258 pkt->pts += 1LL << st->pts_wrap_bits;
1259 }
1260
1261 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1262 * We take the conservative approach and discard both.
1263 * Note: If this is misbehaving for an H.264 file, then possibly
1264 * presentation_delayed is not set correctly. */
1265 if (delay == 1 && pkt->dts == pkt->pts &&
1266 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1267 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1268 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1269 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1270 pkt->dts = AV_NOPTS_VALUE;
1271 }
1272
1273 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1274 if (pkt->duration <= 0) {
1275 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1276 if (den && num) {
1277 duration = (AVRational) {num, den};
1278 pkt->duration = av_rescale_rnd(1,
1279 num * (int64_t) st->time_base.den,
1280 den * (int64_t) st->time_base.num,
1281 AV_ROUND_DOWN);
1282 }
1283 }
1284
1285 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1286 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1287
1288 /* Correct timestamps with byte offset if demuxers only have timestamps
1289 * on packet boundaries */
1290 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1291 /* this will estimate bitrate based on this frame's duration and size */
1292 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1293 if (pkt->pts != AV_NOPTS_VALUE)
1294 pkt->pts += offset;
1295 if (pkt->dts != AV_NOPTS_VALUE)
1296 pkt->dts += offset;
1297 }
1298
1299 /* This may be redundant, but it should not hurt. */
1300 if (pkt->dts != AV_NOPTS_VALUE &&
1301 pkt->pts != AV_NOPTS_VALUE &&
1302 pkt->pts > pkt->dts)
1303 presentation_delayed = 1;
1304
1305 if (s->debug & FF_FDEBUG_TS)
1306 av_log(s, AV_LOG_DEBUG,
1307 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1308 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1309 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1310
1311 /* Interpolate PTS and DTS if they are not present. We skip H264
1312 * currently because delay and has_b_frames are not reliably set. */
1313 if ((delay == 0 || (delay == 1 && pc)) &&
1314 onein_oneout) {
1315 if (presentation_delayed) {
1316 /* DTS = decompression timestamp */
1317 /* PTS = presentation timestamp */
1318 if (pkt->dts == AV_NOPTS_VALUE)
1319 pkt->dts = st->last_IP_pts;
1320 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1321 if (pkt->dts == AV_NOPTS_VALUE)
1322 pkt->dts = st->cur_dts;
1323
1324 /* This is tricky: the dts must be incremented by the duration
1325 * of the frame we are displaying, i.e. the last I- or P-frame. */
1326 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1327 st->last_IP_duration = pkt->duration;
1328 if (pkt->dts != AV_NOPTS_VALUE)
1329 st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1330 if (pkt->dts != AV_NOPTS_VALUE &&
1331 pkt->pts == AV_NOPTS_VALUE &&
1332 st->last_IP_duration > 0 &&
1333 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1334 next_dts != next_pts &&
1335 next_pts != AV_NOPTS_VALUE)
1336 pkt->pts = next_dts;
1337
1338 if ((uint64_t)pkt->duration <= INT32_MAX)
1339 st->last_IP_duration = pkt->duration;
1340 st->last_IP_pts = pkt->pts;
1341 /* Cannot compute PTS if not present (we can compute it only
1342 * by knowing the future. */
1343 } else if (pkt->pts != AV_NOPTS_VALUE ||
1344 pkt->dts != AV_NOPTS_VALUE ||
1345 pkt->duration > 0 ) {
1346
1347 /* presentation is not delayed : PTS and DTS are the same */
1348 if (pkt->pts == AV_NOPTS_VALUE)
1349 pkt->pts = pkt->dts;
1350 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1351 pkt->pts, pkt);
1352 if (pkt->pts == AV_NOPTS_VALUE)
1353 pkt->pts = st->cur_dts;
1354 pkt->dts = pkt->pts;
1355 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1356 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1357 }
1358 }
1359
1360 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1361 st->pts_buffer[0] = pkt->pts;
1362 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1363 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1364
1365 if(has_decode_delay_been_guessed(st))
1366 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1367 }
1368 // We skipped it above so we try here.
1369 if (!onein_oneout)
1370 // This should happen on the first packet
1371 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1372 if (pkt->dts > st->cur_dts)
1373 st->cur_dts = pkt->dts;
1374
1375 if (s->debug & FF_FDEBUG_TS)
1376 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1377 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1378
1379 /* update flags */
1380 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1381 pkt->flags |= AV_PKT_FLAG_KEY;
1382 #if FF_API_CONVERGENCE_DURATION
1383 FF_DISABLE_DEPRECATION_WARNINGS
1384 if (pc)
1385 pkt->convergence_duration = pc->convergence_duration;
1386 FF_ENABLE_DEPRECATION_WARNINGS
1387 #endif
1388 }
1389
1390 /**
1391 * Parse a packet, add all split parts to parse_queue.
1392 *
1393 * @param pkt Packet to parse; must not be NULL.
1394 * @param flush Indicates whether to flush. If set, pkt must be blank.
1395 */
parse_packet(AVFormatContext * s,AVPacket * pkt,int stream_index,int flush)1396 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1397 int stream_index, int flush)
1398 {
1399 AVPacket out_pkt;
1400 AVStream *st = s->streams[stream_index];
1401 uint8_t *data = pkt->data;
1402 int size = pkt->size;
1403 int ret = 0, got_output = flush;
1404
1405 if (size || flush) {
1406 av_init_packet(&out_pkt);
1407 } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1408 // preserve 0-size sync packets
1409 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1410 }
1411
1412 while (size > 0 || (flush && got_output)) {
1413 int len;
1414 int64_t next_pts = pkt->pts;
1415 int64_t next_dts = pkt->dts;
1416
1417 len = av_parser_parse2(st->parser, st->internal->avctx,
1418 &out_pkt.data, &out_pkt.size, data, size,
1419 pkt->pts, pkt->dts, pkt->pos);
1420
1421 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1422 pkt->pos = -1;
1423 /* increment read pointer */
1424 if (data)
1425 data += len;
1426 size -= len;
1427
1428 got_output = !!out_pkt.size;
1429
1430 if (!out_pkt.size)
1431 continue;
1432
1433 if (pkt->buf && out_pkt.data == pkt->data) {
1434 /* reference pkt->buf only when out_pkt.data is guaranteed to point
1435 * to data in it and not in the parser's internal buffer. */
1436 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1437 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1438 out_pkt.buf = av_buffer_ref(pkt->buf);
1439 if (!out_pkt.buf) {
1440 ret = AVERROR(ENOMEM);
1441 goto fail;
1442 }
1443 } else {
1444 ret = av_packet_make_refcounted(&out_pkt);
1445 if (ret < 0)
1446 goto fail;
1447 }
1448
1449 if (pkt->side_data) {
1450 out_pkt.side_data = pkt->side_data;
1451 out_pkt.side_data_elems = pkt->side_data_elems;
1452 pkt->side_data = NULL;
1453 pkt->side_data_elems = 0;
1454 }
1455
1456 /* set the duration */
1457 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1458 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1459 if (st->internal->avctx->sample_rate > 0) {
1460 out_pkt.duration =
1461 av_rescale_q_rnd(st->parser->duration,
1462 (AVRational) { 1, st->internal->avctx->sample_rate },
1463 st->time_base,
1464 AV_ROUND_DOWN);
1465 }
1466 }
1467
1468 out_pkt.stream_index = st->index;
1469 out_pkt.pts = st->parser->pts;
1470 out_pkt.dts = st->parser->dts;
1471 out_pkt.pos = st->parser->pos;
1472 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1473
1474 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1475 out_pkt.pos = st->parser->frame_offset;
1476
1477 if (st->parser->key_frame == 1 ||
1478 (st->parser->key_frame == -1 &&
1479 st->parser->pict_type == AV_PICTURE_TYPE_I))
1480 out_pkt.flags |= AV_PKT_FLAG_KEY;
1481
1482 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1483 out_pkt.flags |= AV_PKT_FLAG_KEY;
1484
1485 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1486
1487 ret = avpriv_packet_list_put(&s->internal->parse_queue,
1488 &s->internal->parse_queue_end,
1489 &out_pkt, NULL, 0);
1490 if (ret < 0) {
1491 av_packet_unref(&out_pkt);
1492 goto fail;
1493 }
1494 }
1495
1496 /* end of the stream => close and free the parser */
1497 if (flush) {
1498 av_parser_close(st->parser);
1499 st->parser = NULL;
1500 }
1501
1502 fail:
1503 av_packet_unref(pkt);
1504 return ret;
1505 }
1506
ts_to_samples(AVStream * st,int64_t ts)1507 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1508 {
1509 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1510 }
1511
read_frame_internal(AVFormatContext * s,AVPacket * pkt)1512 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1513 {
1514 int ret, i, got_packet = 0;
1515 AVDictionary *metadata = NULL;
1516
1517 while (!got_packet && !s->internal->parse_queue) {
1518 AVStream *st;
1519
1520 /* read next packet */
1521 ret = ff_read_packet(s, pkt);
1522 if (ret < 0) {
1523 if (ret == AVERROR(EAGAIN))
1524 return ret;
1525 /* flush the parsers */
1526 for (i = 0; i < s->nb_streams; i++) {
1527 st = s->streams[i];
1528 if (st->parser && st->need_parsing)
1529 parse_packet(s, pkt, st->index, 1);
1530 }
1531 /* all remaining packets are now in parse_queue =>
1532 * really terminate parsing */
1533 break;
1534 }
1535 ret = 0;
1536 st = s->streams[pkt->stream_index];
1537
1538 /* update context if required */
1539 if (st->internal->need_context_update) {
1540 if (avcodec_is_open(st->internal->avctx)) {
1541 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1542 avcodec_close(st->internal->avctx);
1543 st->info->found_decoder = 0;
1544 }
1545
1546 /* close parser, because it depends on the codec */
1547 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1548 av_parser_close(st->parser);
1549 st->parser = NULL;
1550 }
1551
1552 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1553 if (ret < 0) {
1554 av_packet_unref(pkt);
1555 return ret;
1556 }
1557
1558 #if FF_API_LAVF_AVCTX
1559 FF_DISABLE_DEPRECATION_WARNINGS
1560 /* update deprecated public codec context */
1561 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1562 if (ret < 0) {
1563 av_packet_unref(pkt);
1564 return ret;
1565 }
1566 FF_ENABLE_DEPRECATION_WARNINGS
1567 #endif
1568
1569 st->internal->need_context_update = 0;
1570 }
1571
1572 if (pkt->pts != AV_NOPTS_VALUE &&
1573 pkt->dts != AV_NOPTS_VALUE &&
1574 pkt->pts < pkt->dts) {
1575 av_log(s, AV_LOG_WARNING,
1576 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1577 pkt->stream_index,
1578 av_ts2str(pkt->pts),
1579 av_ts2str(pkt->dts),
1580 pkt->size);
1581 }
1582 if (s->debug & FF_FDEBUG_TS)
1583 av_log(s, AV_LOG_DEBUG,
1584 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1585 pkt->stream_index,
1586 av_ts2str(pkt->pts),
1587 av_ts2str(pkt->dts),
1588 pkt->size, pkt->duration, pkt->flags);
1589
1590 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1591 st->parser = av_parser_init(st->codecpar->codec_id);
1592 if (!st->parser) {
1593 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1594 "%s, packets or times may be invalid.\n",
1595 avcodec_get_name(st->codecpar->codec_id));
1596 /* no parser available: just output the raw packets */
1597 st->need_parsing = AVSTREAM_PARSE_NONE;
1598 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1599 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1600 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1601 st->parser->flags |= PARSER_FLAG_ONCE;
1602 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1603 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1604 }
1605
1606 if (!st->need_parsing || !st->parser) {
1607 /* no parsing needed: we just output the packet as is */
1608 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1609 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1610 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1611 ff_reduce_index(s, st->index);
1612 av_add_index_entry(st, pkt->pos, pkt->dts,
1613 0, 0, AVINDEX_KEYFRAME);
1614 }
1615 got_packet = 1;
1616 } else if (st->discard < AVDISCARD_ALL) {
1617 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1618 return ret;
1619 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1620 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1621 st->codecpar->channels = st->internal->avctx->channels;
1622 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1623 st->codecpar->codec_id = st->internal->avctx->codec_id;
1624 } else {
1625 /* free packet */
1626 av_packet_unref(pkt);
1627 }
1628 if (pkt->flags & AV_PKT_FLAG_KEY)
1629 st->skip_to_keyframe = 0;
1630 if (st->skip_to_keyframe) {
1631 av_packet_unref(pkt);
1632 got_packet = 0;
1633 }
1634 }
1635
1636 if (!got_packet && s->internal->parse_queue)
1637 ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1638
1639 if (ret >= 0) {
1640 AVStream *st = s->streams[pkt->stream_index];
1641 int discard_padding = 0;
1642 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1643 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1644 int64_t sample = ts_to_samples(st, pts);
1645 int duration = ts_to_samples(st, pkt->duration);
1646 int64_t end_sample = sample + duration;
1647 if (duration > 0 && end_sample >= st->first_discard_sample &&
1648 sample < st->last_discard_sample)
1649 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1650 }
1651 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1652 st->skip_samples = st->start_skip_samples;
1653 if (st->skip_samples || discard_padding) {
1654 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1655 if (p) {
1656 AV_WL32(p, st->skip_samples);
1657 AV_WL32(p + 4, discard_padding);
1658 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1659 }
1660 st->skip_samples = 0;
1661 }
1662
1663 if (st->inject_global_side_data) {
1664 for (i = 0; i < st->nb_side_data; i++) {
1665 AVPacketSideData *src_sd = &st->side_data[i];
1666 uint8_t *dst_data;
1667
1668 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1669 continue;
1670
1671 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1672 if (!dst_data) {
1673 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1674 continue;
1675 }
1676
1677 memcpy(dst_data, src_sd->data, src_sd->size);
1678 }
1679 st->inject_global_side_data = 0;
1680 }
1681 }
1682
1683 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1684 if (metadata) {
1685 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1686 av_dict_copy(&s->metadata, metadata, 0);
1687 av_dict_free(&metadata);
1688 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1689 }
1690
1691 #if FF_API_LAVF_AVCTX
1692 update_stream_avctx(s);
1693 #endif
1694
1695 if (s->debug & FF_FDEBUG_TS)
1696 av_log(s, AV_LOG_DEBUG,
1697 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1698 "size=%d, duration=%"PRId64", flags=%d\n",
1699 pkt->stream_index,
1700 av_ts2str(pkt->pts),
1701 av_ts2str(pkt->dts),
1702 pkt->size, pkt->duration, pkt->flags);
1703
1704 /* A demuxer might have returned EOF because of an IO error, let's
1705 * propagate this back to the user. */
1706 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1707 ret = s->pb->error;
1708
1709 return ret;
1710 }
1711
av_read_frame(AVFormatContext * s,AVPacket * pkt)1712 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1713 {
1714 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1715 int eof = 0;
1716 int ret;
1717 AVStream *st;
1718
1719 if (!genpts) {
1720 ret = s->internal->packet_buffer
1721 ? avpriv_packet_list_get(&s->internal->packet_buffer,
1722 &s->internal->packet_buffer_end, pkt)
1723 : read_frame_internal(s, pkt);
1724 if (ret < 0)
1725 return ret;
1726 goto return_packet;
1727 }
1728
1729 for (;;) {
1730 AVPacketList *pktl = s->internal->packet_buffer;
1731
1732 if (pktl) {
1733 AVPacket *next_pkt = &pktl->pkt;
1734
1735 if (next_pkt->dts != AV_NOPTS_VALUE) {
1736 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1737 // last dts seen for this stream. if any of packets following
1738 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1739 int64_t last_dts = next_pkt->dts;
1740 av_assert2(wrap_bits <= 64);
1741 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1742 if (pktl->pkt.stream_index == next_pkt->stream_index && wrap_bits <= 64 &&
1743 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1744 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1745 // not B-frame
1746 next_pkt->pts = pktl->pkt.dts;
1747 }
1748 if (last_dts != AV_NOPTS_VALUE) {
1749 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1750 last_dts = pktl->pkt.dts;
1751 }
1752 }
1753 pktl = pktl->next;
1754 }
1755 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1756 // Fixing the last reference frame had none pts issue (For MXF etc).
1757 // We only do this when
1758 // 1. eof.
1759 // 2. we are not able to resolve a pts value for current packet.
1760 // 3. the packets for this stream at the end of the files had valid dts.
1761 next_pkt->pts = last_dts + next_pkt->duration;
1762 }
1763 pktl = s->internal->packet_buffer;
1764 }
1765
1766 /* read packet from packet buffer, if there is data */
1767 st = s->streams[next_pkt->stream_index];
1768 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1769 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1770 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1771 &s->internal->packet_buffer_end, pkt);
1772 goto return_packet;
1773 }
1774 }
1775
1776 ret = read_frame_internal(s, pkt);
1777 if (ret < 0) {
1778 if (pktl && ret != AVERROR(EAGAIN)) {
1779 eof = 1;
1780 continue;
1781 } else
1782 return ret;
1783 }
1784
1785 ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1786 &s->internal->packet_buffer_end,
1787 pkt, NULL, 0);
1788 if (ret < 0) {
1789 av_packet_unref(pkt);
1790 return ret;
1791 }
1792 }
1793
1794 return_packet:
1795
1796 st = s->streams[pkt->stream_index];
1797 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1798 ff_reduce_index(s, st->index);
1799 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1800 }
1801
1802 if (is_relative(pkt->dts))
1803 pkt->dts -= RELATIVE_TS_BASE;
1804 if (is_relative(pkt->pts))
1805 pkt->pts -= RELATIVE_TS_BASE;
1806
1807 return ret;
1808 }
1809
1810 /* XXX: suppress the packet queue */
flush_packet_queue(AVFormatContext * s)1811 static void flush_packet_queue(AVFormatContext *s)
1812 {
1813 if (!s->internal)
1814 return;
1815 avpriv_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1816 avpriv_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1817 avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1818
1819 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1820 }
1821
1822 /*******************************************************/
1823 /* seek support */
1824
av_find_default_stream_index(AVFormatContext * s)1825 int av_find_default_stream_index(AVFormatContext *s)
1826 {
1827 int i;
1828 AVStream *st;
1829 int best_stream = 0;
1830 int best_score = INT_MIN;
1831
1832 if (s->nb_streams <= 0)
1833 return -1;
1834 for (i = 0; i < s->nb_streams; i++) {
1835 int score = 0;
1836 st = s->streams[i];
1837 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1838 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1839 score -= 400;
1840 if (st->codecpar->width && st->codecpar->height)
1841 score += 50;
1842 score+= 25;
1843 }
1844 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1845 if (st->codecpar->sample_rate)
1846 score += 50;
1847 }
1848 if (st->codec_info_nb_frames)
1849 score += 12;
1850
1851 if (st->discard != AVDISCARD_ALL)
1852 score += 200;
1853
1854 if (score > best_score) {
1855 best_score = score;
1856 best_stream = i;
1857 }
1858 }
1859 return best_stream;
1860 }
1861
1862 /** Flush the frame reader. */
ff_read_frame_flush(AVFormatContext * s)1863 void ff_read_frame_flush(AVFormatContext *s)
1864 {
1865 AVStream *st;
1866 int i, j;
1867
1868 flush_packet_queue(s);
1869
1870 /* Reset read state for each stream. */
1871 for (i = 0; i < s->nb_streams; i++) {
1872 st = s->streams[i];
1873
1874 if (st->parser) {
1875 av_parser_close(st->parser);
1876 st->parser = NULL;
1877 }
1878 st->last_IP_pts = AV_NOPTS_VALUE;
1879 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1880 if (st->first_dts == AV_NOPTS_VALUE)
1881 st->cur_dts = RELATIVE_TS_BASE;
1882 else
1883 /* We set the current DTS to an unspecified origin. */
1884 st->cur_dts = AV_NOPTS_VALUE;
1885
1886 st->probe_packets = s->max_probe_packets;
1887
1888 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1889 st->pts_buffer[j] = AV_NOPTS_VALUE;
1890
1891 if (s->internal->inject_global_side_data)
1892 st->inject_global_side_data = 1;
1893
1894 st->skip_samples = 0;
1895 }
1896 }
1897
ff_update_cur_dts(AVFormatContext * s,AVStream * ref_st,int64_t timestamp)1898 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1899 {
1900 int i;
1901
1902 for (i = 0; i < s->nb_streams; i++) {
1903 AVStream *st = s->streams[i];
1904
1905 st->cur_dts =
1906 av_rescale(timestamp,
1907 st->time_base.den * (int64_t) ref_st->time_base.num,
1908 st->time_base.num * (int64_t) ref_st->time_base.den);
1909 }
1910 }
1911
ff_reduce_index(AVFormatContext * s,int stream_index)1912 void ff_reduce_index(AVFormatContext *s, int stream_index)
1913 {
1914 AVStream *st = s->streams[stream_index];
1915 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1916
1917 if ((unsigned) st->nb_index_entries >= max_entries) {
1918 int i;
1919 for (i = 0; 2 * i < st->nb_index_entries; i++)
1920 st->index_entries[i] = st->index_entries[2 * i];
1921 st->nb_index_entries = i;
1922 }
1923 }
1924
ff_add_index_entry(AVIndexEntry ** index_entries,int * nb_index_entries,unsigned int * index_entries_allocated_size,int64_t pos,int64_t timestamp,int size,int distance,int flags)1925 int ff_add_index_entry(AVIndexEntry **index_entries,
1926 int *nb_index_entries,
1927 unsigned int *index_entries_allocated_size,
1928 int64_t pos, int64_t timestamp,
1929 int size, int distance, int flags)
1930 {
1931 AVIndexEntry *entries, *ie;
1932 int index;
1933
1934 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1935 return -1;
1936
1937 if (timestamp == AV_NOPTS_VALUE)
1938 return AVERROR(EINVAL);
1939
1940 if (size < 0 || size > 0x3FFFFFFF)
1941 return AVERROR(EINVAL);
1942
1943 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1944 timestamp -= RELATIVE_TS_BASE;
1945
1946 entries = av_fast_realloc(*index_entries,
1947 index_entries_allocated_size,
1948 (*nb_index_entries + 1) *
1949 sizeof(AVIndexEntry));
1950 if (!entries)
1951 return -1;
1952
1953 *index_entries = entries;
1954
1955 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1956 timestamp, AVSEEK_FLAG_ANY);
1957
1958 if (index < 0) {
1959 index = (*nb_index_entries)++;
1960 ie = &entries[index];
1961 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1962 } else {
1963 ie = &entries[index];
1964 if (ie->timestamp != timestamp) {
1965 if (ie->timestamp <= timestamp)
1966 return -1;
1967 memmove(entries + index + 1, entries + index,
1968 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1969 (*nb_index_entries)++;
1970 } else if (ie->pos == pos && distance < ie->min_distance)
1971 // do not reduce the distance
1972 distance = ie->min_distance;
1973 }
1974
1975 ie->pos = pos;
1976 ie->timestamp = timestamp;
1977 ie->min_distance = distance;
1978 ie->size = size;
1979 ie->flags = flags;
1980
1981 return index;
1982 }
1983
av_add_index_entry(AVStream * st,int64_t pos,int64_t timestamp,int size,int distance,int flags)1984 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1985 int size, int distance, int flags)
1986 {
1987 timestamp = wrap_timestamp(st, timestamp);
1988 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1989 &st->index_entries_allocated_size, pos,
1990 timestamp, size, distance, flags);
1991 }
1992
ff_index_search_timestamp(const AVIndexEntry * entries,int nb_entries,int64_t wanted_timestamp,int flags)1993 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1994 int64_t wanted_timestamp, int flags)
1995 {
1996 int a, b, m;
1997 int64_t timestamp;
1998
1999 a = -1;
2000 b = nb_entries;
2001
2002 // Optimize appending index entries at the end.
2003 if (b && entries[b - 1].timestamp < wanted_timestamp)
2004 a = b - 1;
2005
2006 while (b - a > 1) {
2007 m = (a + b) >> 1;
2008
2009 // Search for the next non-discarded packet.
2010 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2011 m++;
2012 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2013 m = b - 1;
2014 break;
2015 }
2016 }
2017
2018 timestamp = entries[m].timestamp;
2019 if (timestamp >= wanted_timestamp)
2020 b = m;
2021 if (timestamp <= wanted_timestamp)
2022 a = m;
2023 }
2024 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2025
2026 if (!(flags & AVSEEK_FLAG_ANY))
2027 while (m >= 0 && m < nb_entries &&
2028 !(entries[m].flags & AVINDEX_KEYFRAME))
2029 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2030
2031 if (m == nb_entries)
2032 return -1;
2033 return m;
2034 }
2035
ff_configure_buffers_for_index(AVFormatContext * s,int64_t time_tolerance)2036 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2037 {
2038 int ist1, ist2;
2039 int64_t pos_delta = 0;
2040 int64_t skip = 0;
2041 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2042 const char *proto = avio_find_protocol_name(s->url);
2043
2044 av_assert0(time_tolerance >= 0);
2045
2046 if (!proto) {
2047 av_log(s, AV_LOG_INFO,
2048 "Protocol name not provided, cannot determine if input is local or "
2049 "a network protocol, buffers and access patterns cannot be configured "
2050 "optimally without knowing the protocol\n");
2051 }
2052
2053 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2054 return;
2055
2056 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2057 AVStream *st1 = s->streams[ist1];
2058 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2059 AVStream *st2 = s->streams[ist2];
2060 int i1, i2;
2061
2062 if (ist1 == ist2)
2063 continue;
2064
2065 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2066 AVIndexEntry *e1 = &st1->index_entries[i1];
2067 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2068
2069 skip = FFMAX(skip, e1->size);
2070 for (; i2 < st2->nb_index_entries; i2++) {
2071 AVIndexEntry *e2 = &st2->index_entries[i2];
2072 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2073 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2074 continue;
2075 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2076 break;
2077 }
2078 }
2079 }
2080 }
2081
2082 pos_delta *= 2;
2083 /* XXX This could be adjusted depending on protocol*/
2084 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2085 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2086
2087 /* realloc the buffer and the original data will be retained */
2088 if (ffio_realloc_buf(s->pb, pos_delta)) {
2089 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2090 return;
2091 }
2092
2093 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2094 }
2095
2096 if (skip < (1<<23)) {
2097 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2098 }
2099 }
2100
av_index_search_timestamp(AVStream * st,int64_t wanted_timestamp,int flags)2101 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2102 {
2103 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2104 wanted_timestamp, flags);
2105 }
2106
ff_read_timestamp(AVFormatContext * s,int stream_index,int64_t * ppos,int64_t pos_limit,int64_t (* read_timestamp)(struct AVFormatContext *,int,int64_t *,int64_t))2107 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2108 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2109 {
2110 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2111 if (stream_index >= 0)
2112 ts = wrap_timestamp(s->streams[stream_index], ts);
2113 return ts;
2114 }
2115
ff_seek_frame_binary(AVFormatContext * s,int stream_index,int64_t target_ts,int flags)2116 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2117 int64_t target_ts, int flags)
2118 {
2119 const AVInputFormat *avif = s->iformat;
2120 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2121 int64_t ts_min, ts_max, ts;
2122 int index;
2123 int64_t ret;
2124 AVStream *st;
2125
2126 if (stream_index < 0)
2127 return -1;
2128
2129 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2130
2131 ts_max =
2132 ts_min = AV_NOPTS_VALUE;
2133 pos_limit = -1; // GCC falsely says it may be uninitialized.
2134
2135 st = s->streams[stream_index];
2136 if (st->index_entries) {
2137 AVIndexEntry *e;
2138
2139 /* FIXME: Whole function must be checked for non-keyframe entries in
2140 * index case, especially read_timestamp(). */
2141 index = av_index_search_timestamp(st, target_ts,
2142 flags | AVSEEK_FLAG_BACKWARD);
2143 index = FFMAX(index, 0);
2144 e = &st->index_entries[index];
2145
2146 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2147 pos_min = e->pos;
2148 ts_min = e->timestamp;
2149 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2150 pos_min, av_ts2str(ts_min));
2151 } else {
2152 av_assert1(index == 0);
2153 }
2154
2155 index = av_index_search_timestamp(st, target_ts,
2156 flags & ~AVSEEK_FLAG_BACKWARD);
2157 av_assert0(index < st->nb_index_entries);
2158 if (index >= 0) {
2159 e = &st->index_entries[index];
2160 av_assert1(e->timestamp >= target_ts);
2161 pos_max = e->pos;
2162 ts_max = e->timestamp;
2163 pos_limit = pos_max - e->min_distance;
2164 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2165 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2166 }
2167 }
2168
2169 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2170 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2171 if (pos < 0)
2172 return -1;
2173
2174 /* do the seek */
2175 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2176 return ret;
2177
2178 ff_read_frame_flush(s);
2179 ff_update_cur_dts(s, st, ts);
2180
2181 return 0;
2182 }
2183
ff_find_last_ts(AVFormatContext * s,int stream_index,int64_t * ts,int64_t * pos,int64_t (* read_timestamp)(struct AVFormatContext *,int,int64_t *,int64_t))2184 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2185 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2186 {
2187 int64_t step = 1024;
2188 int64_t limit, ts_max;
2189 int64_t filesize = avio_size(s->pb);
2190 int64_t pos_max = filesize - 1;
2191 do {
2192 limit = pos_max;
2193 pos_max = FFMAX(0, (pos_max) - step);
2194 ts_max = ff_read_timestamp(s, stream_index,
2195 &pos_max, limit, read_timestamp);
2196 step += step;
2197 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2198 if (ts_max == AV_NOPTS_VALUE)
2199 return -1;
2200
2201 for (;;) {
2202 int64_t tmp_pos = pos_max + 1;
2203 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2204 &tmp_pos, INT64_MAX, read_timestamp);
2205 if (tmp_ts == AV_NOPTS_VALUE)
2206 break;
2207 av_assert0(tmp_pos > pos_max);
2208 ts_max = tmp_ts;
2209 pos_max = tmp_pos;
2210 if (tmp_pos >= filesize)
2211 break;
2212 }
2213
2214 if (ts)
2215 *ts = ts_max;
2216 if (pos)
2217 *pos = pos_max;
2218
2219 return 0;
2220 }
2221
ff_gen_search(AVFormatContext * s,int stream_index,int64_t target_ts,int64_t pos_min,int64_t pos_max,int64_t pos_limit,int64_t ts_min,int64_t ts_max,int flags,int64_t * ts_ret,int64_t (* read_timestamp)(struct AVFormatContext *,int,int64_t *,int64_t))2222 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2223 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2224 int64_t ts_min, int64_t ts_max,
2225 int flags, int64_t *ts_ret,
2226 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2227 int64_t *, int64_t))
2228 {
2229 int64_t pos, ts;
2230 int64_t start_pos;
2231 int no_change;
2232 int ret;
2233
2234 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2235
2236 if (ts_min == AV_NOPTS_VALUE) {
2237 pos_min = s->internal->data_offset;
2238 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2239 if (ts_min == AV_NOPTS_VALUE)
2240 return -1;
2241 }
2242
2243 if (ts_min >= target_ts) {
2244 *ts_ret = ts_min;
2245 return pos_min;
2246 }
2247
2248 if (ts_max == AV_NOPTS_VALUE) {
2249 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2250 return ret;
2251 pos_limit = pos_max;
2252 }
2253
2254 if (ts_max <= target_ts) {
2255 *ts_ret = ts_max;
2256 return pos_max;
2257 }
2258
2259 av_assert0(ts_min < ts_max);
2260
2261 no_change = 0;
2262 while (pos_min < pos_limit) {
2263 av_log(s, AV_LOG_TRACE,
2264 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2265 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2266 av_assert0(pos_limit <= pos_max);
2267
2268 if (no_change == 0) {
2269 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2270 // interpolate position (better than dichotomy)
2271 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2272 ts_max - ts_min) +
2273 pos_min - approximate_keyframe_distance;
2274 } else if (no_change == 1) {
2275 // bisection if interpolation did not change min / max pos last time
2276 pos = (pos_min + pos_limit) >> 1;
2277 } else {
2278 /* linear search if bisection failed, can only happen if there
2279 * are very few or no keyframes between min/max */
2280 pos = pos_min;
2281 }
2282 if (pos <= pos_min)
2283 pos = pos_min + 1;
2284 else if (pos > pos_limit)
2285 pos = pos_limit;
2286 start_pos = pos;
2287
2288 // May pass pos_limit instead of -1.
2289 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2290 if (pos == pos_max)
2291 no_change++;
2292 else
2293 no_change = 0;
2294 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2295 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2296 pos_min, pos, pos_max,
2297 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2298 pos_limit, start_pos, no_change);
2299 if (ts == AV_NOPTS_VALUE) {
2300 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2301 return -1;
2302 }
2303 if (target_ts <= ts) {
2304 pos_limit = start_pos - 1;
2305 pos_max = pos;
2306 ts_max = ts;
2307 }
2308 if (target_ts >= ts) {
2309 pos_min = pos;
2310 ts_min = ts;
2311 }
2312 }
2313
2314 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2315 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2316 #if 0
2317 pos_min = pos;
2318 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2319 pos_min++;
2320 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2321 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2322 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2323 #endif
2324 *ts_ret = ts;
2325 return pos;
2326 }
2327
seek_frame_byte(AVFormatContext * s,int stream_index,int64_t pos,int flags)2328 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2329 int64_t pos, int flags)
2330 {
2331 int64_t pos_min, pos_max;
2332
2333 pos_min = s->internal->data_offset;
2334 pos_max = avio_size(s->pb) - 1;
2335
2336 if (pos < pos_min)
2337 pos = pos_min;
2338 else if (pos > pos_max)
2339 pos = pos_max;
2340
2341 avio_seek(s->pb, pos, SEEK_SET);
2342
2343 s->io_repositioned = 1;
2344
2345 return 0;
2346 }
2347
seek_frame_generic(AVFormatContext * s,int stream_index,int64_t timestamp,int flags)2348 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2349 int64_t timestamp, int flags)
2350 {
2351 int index;
2352 int64_t ret;
2353 AVStream *st;
2354 AVIndexEntry *ie;
2355
2356 st = s->streams[stream_index];
2357
2358 index = av_index_search_timestamp(st, timestamp, flags);
2359
2360 if (index < 0 && st->nb_index_entries &&
2361 timestamp < st->index_entries[0].timestamp)
2362 return -1;
2363
2364 if (index < 0 || index == st->nb_index_entries - 1) {
2365 AVPacket pkt;
2366 int nonkey = 0;
2367
2368 if (st->nb_index_entries) {
2369 av_assert0(st->index_entries);
2370 ie = &st->index_entries[st->nb_index_entries - 1];
2371 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2372 return ret;
2373 ff_update_cur_dts(s, st, ie->timestamp);
2374 } else {
2375 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2376 return ret;
2377 }
2378 for (;;) {
2379 int read_status;
2380 do {
2381 read_status = av_read_frame(s, &pkt);
2382 } while (read_status == AVERROR(EAGAIN));
2383 if (read_status < 0)
2384 break;
2385 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2386 if (pkt.flags & AV_PKT_FLAG_KEY) {
2387 av_packet_unref(&pkt);
2388 break;
2389 }
2390 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2391 av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
2392 av_packet_unref(&pkt);
2393 break;
2394 }
2395 }
2396 av_packet_unref(&pkt);
2397 }
2398 index = av_index_search_timestamp(st, timestamp, flags);
2399 }
2400 if (index < 0)
2401 return -1;
2402
2403 ff_read_frame_flush(s);
2404 if (s->iformat->read_seek)
2405 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2406 return 0;
2407 ie = &st->index_entries[index];
2408 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2409 return ret;
2410 ff_update_cur_dts(s, st, ie->timestamp);
2411
2412 return 0;
2413 }
2414
seek_frame_internal(AVFormatContext * s,int stream_index,int64_t timestamp,int flags)2415 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2416 int64_t timestamp, int flags)
2417 {
2418 int ret;
2419 AVStream *st;
2420
2421 if (flags & AVSEEK_FLAG_BYTE) {
2422 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2423 return -1;
2424 ff_read_frame_flush(s);
2425 return seek_frame_byte(s, stream_index, timestamp, flags);
2426 }
2427
2428 if (stream_index < 0) {
2429 stream_index = av_find_default_stream_index(s);
2430 if (stream_index < 0)
2431 return -1;
2432
2433 st = s->streams[stream_index];
2434 /* timestamp for default must be expressed in AV_TIME_BASE units */
2435 timestamp = av_rescale(timestamp, st->time_base.den,
2436 AV_TIME_BASE * (int64_t) st->time_base.num);
2437 }
2438
2439 /* first, we try the format specific seek */
2440 if (s->iformat->read_seek) {
2441 ff_read_frame_flush(s);
2442 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2443 } else
2444 ret = -1;
2445 if (ret >= 0)
2446 return 0;
2447
2448 if (s->iformat->read_timestamp &&
2449 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2450 ff_read_frame_flush(s);
2451 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2452 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2453 ff_read_frame_flush(s);
2454 return seek_frame_generic(s, stream_index, timestamp, flags);
2455 } else
2456 return -1;
2457 }
2458
av_seek_frame(AVFormatContext * s,int stream_index,int64_t timestamp,int flags)2459 int av_seek_frame(AVFormatContext *s, int stream_index,
2460 int64_t timestamp, int flags)
2461 {
2462 int ret;
2463
2464 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2465 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2466 if ((flags & AVSEEK_FLAG_BACKWARD))
2467 max_ts = timestamp;
2468 else
2469 min_ts = timestamp;
2470 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2471 flags & ~AVSEEK_FLAG_BACKWARD);
2472 }
2473
2474 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2475
2476 if (ret >= 0)
2477 ret = avformat_queue_attached_pictures(s);
2478
2479 return ret;
2480 }
2481
avformat_seek_file(AVFormatContext * s,int stream_index,int64_t min_ts,int64_t ts,int64_t max_ts,int flags)2482 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2483 int64_t ts, int64_t max_ts, int flags)
2484 {
2485 if (min_ts > ts || max_ts < ts)
2486 return -1;
2487 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2488 return AVERROR(EINVAL);
2489
2490 if (s->seek2any>0)
2491 flags |= AVSEEK_FLAG_ANY;
2492 flags &= ~AVSEEK_FLAG_BACKWARD;
2493
2494 if (s->iformat->read_seek2) {
2495 int ret;
2496 ff_read_frame_flush(s);
2497
2498 if (stream_index == -1 && s->nb_streams == 1) {
2499 AVRational time_base = s->streams[0]->time_base;
2500 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2501 min_ts = av_rescale_rnd(min_ts, time_base.den,
2502 time_base.num * (int64_t)AV_TIME_BASE,
2503 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2504 max_ts = av_rescale_rnd(max_ts, time_base.den,
2505 time_base.num * (int64_t)AV_TIME_BASE,
2506 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2507 stream_index = 0;
2508 }
2509
2510 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2511 ts, max_ts, flags);
2512
2513 if (ret >= 0)
2514 ret = avformat_queue_attached_pictures(s);
2515 return ret;
2516 }
2517
2518 if (s->iformat->read_timestamp) {
2519 // try to seek via read_timestamp()
2520 }
2521
2522 // Fall back on old API if new is not implemented but old is.
2523 // Note the old API has somewhat different semantics.
2524 if (s->iformat->read_seek || 1) {
2525 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2526 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2527 if (ret<0 && ts != min_ts && max_ts != ts) {
2528 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2529 if (ret >= 0)
2530 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2531 }
2532 return ret;
2533 }
2534
2535 // try some generic seek like seek_frame_generic() but with new ts semantics
2536 return -1; //unreachable
2537 }
2538
avformat_flush(AVFormatContext * s)2539 int avformat_flush(AVFormatContext *s)
2540 {
2541 ff_read_frame_flush(s);
2542 return 0;
2543 }
2544
2545 /*******************************************************/
2546
2547 /**
2548 * Return TRUE if the stream has accurate duration in any stream.
2549 *
2550 * @return TRUE if the stream has accurate duration for at least one component.
2551 */
has_duration(AVFormatContext * ic)2552 static int has_duration(AVFormatContext *ic)
2553 {
2554 int i;
2555 AVStream *st;
2556
2557 for (i = 0; i < ic->nb_streams; i++) {
2558 st = ic->streams[i];
2559 if (st->duration != AV_NOPTS_VALUE)
2560 return 1;
2561 }
2562 if (ic->duration != AV_NOPTS_VALUE)
2563 return 1;
2564 return 0;
2565 }
2566
2567 /**
2568 * Estimate the stream timings from the one of each components.
2569 *
2570 * Also computes the global bitrate if possible.
2571 */
update_stream_timings(AVFormatContext * ic)2572 static void update_stream_timings(AVFormatContext *ic)
2573 {
2574 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2575 int64_t duration, duration1, duration_text, filesize;
2576 int i;
2577 AVProgram *p;
2578
2579 start_time = INT64_MAX;
2580 start_time_text = INT64_MAX;
2581 end_time = INT64_MIN;
2582 end_time_text = INT64_MIN;
2583 duration = INT64_MIN;
2584 duration_text = INT64_MIN;
2585
2586 for (i = 0; i < ic->nb_streams; i++) {
2587 AVStream *st = ic->streams[i];
2588 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2589 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2590 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2591 start_time1 = av_rescale_q(st->start_time, st->time_base,
2592 AV_TIME_BASE_Q);
2593 if (is_text)
2594 start_time_text = FFMIN(start_time_text, start_time1);
2595 else
2596 start_time = FFMIN(start_time, start_time1);
2597 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2598 AV_TIME_BASE_Q,
2599 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2600 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2601 end_time1 += start_time1;
2602 if (is_text)
2603 end_time_text = FFMAX(end_time_text, end_time1);
2604 else
2605 end_time = FFMAX(end_time, end_time1);
2606 }
2607 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2608 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2609 p->start_time = start_time1;
2610 if (p->end_time < end_time1)
2611 p->end_time = end_time1;
2612 }
2613 }
2614 if (st->duration != AV_NOPTS_VALUE) {
2615 duration1 = av_rescale_q(st->duration, st->time_base,
2616 AV_TIME_BASE_Q);
2617 if (is_text)
2618 duration_text = FFMAX(duration_text, duration1);
2619 else
2620 duration = FFMAX(duration, duration1);
2621 }
2622 }
2623 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2624 start_time = start_time_text;
2625 else if (start_time > start_time_text)
2626 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2627
2628 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2629 end_time = end_time_text;
2630 else if (end_time < end_time_text)
2631 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2632
2633 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2634 duration = duration_text;
2635 else if (duration < duration_text)
2636 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2637
2638 if (start_time != INT64_MAX) {
2639 ic->start_time = start_time;
2640 if (end_time != INT64_MIN) {
2641 if (ic->nb_programs > 1) {
2642 for (i = 0; i < ic->nb_programs; i++) {
2643 p = ic->programs[i];
2644 if (p->start_time != AV_NOPTS_VALUE &&
2645 p->end_time > p->start_time &&
2646 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2647 duration = FFMAX(duration, p->end_time - p->start_time);
2648 }
2649 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2650 duration = FFMAX(duration, end_time - start_time);
2651 }
2652 }
2653 }
2654 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2655 ic->duration = duration;
2656 }
2657 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2658 /* compute the bitrate */
2659 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2660 (double) ic->duration;
2661 if (bitrate >= 0 && bitrate <= INT64_MAX)
2662 ic->bit_rate = bitrate;
2663 }
2664 }
2665
fill_all_stream_timings(AVFormatContext * ic)2666 static void fill_all_stream_timings(AVFormatContext *ic)
2667 {
2668 int i;
2669 AVStream *st;
2670
2671 update_stream_timings(ic);
2672 for (i = 0; i < ic->nb_streams; i++) {
2673 st = ic->streams[i];
2674 if (st->start_time == AV_NOPTS_VALUE) {
2675 if (ic->start_time != AV_NOPTS_VALUE)
2676 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2677 st->time_base);
2678 if (ic->duration != AV_NOPTS_VALUE)
2679 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2680 st->time_base);
2681 }
2682 }
2683 }
2684
estimate_timings_from_bit_rate(AVFormatContext * ic)2685 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2686 {
2687 int64_t filesize, duration;
2688 int i, show_warning = 0;
2689 AVStream *st;
2690
2691 /* if bit_rate is already set, we believe it */
2692 if (ic->bit_rate <= 0) {
2693 int64_t bit_rate = 0;
2694 for (i = 0; i < ic->nb_streams; i++) {
2695 st = ic->streams[i];
2696 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2697 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2698 if (st->codecpar->bit_rate > 0) {
2699 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2700 bit_rate = 0;
2701 break;
2702 }
2703 bit_rate += st->codecpar->bit_rate;
2704 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2705 // If we have a videostream with packets but without a bitrate
2706 // then consider the sum not known
2707 bit_rate = 0;
2708 break;
2709 }
2710 }
2711 ic->bit_rate = bit_rate;
2712 }
2713
2714 /* if duration is already set, we believe it */
2715 if (ic->duration == AV_NOPTS_VALUE &&
2716 ic->bit_rate != 0) {
2717 filesize = ic->pb ? avio_size(ic->pb) : 0;
2718 if (filesize > ic->internal->data_offset) {
2719 filesize -= ic->internal->data_offset;
2720 for (i = 0; i < ic->nb_streams; i++) {
2721 st = ic->streams[i];
2722 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2723 && st->duration == AV_NOPTS_VALUE) {
2724 duration = av_rescale(filesize, 8LL * st->time_base.den,
2725 ic->bit_rate *
2726 (int64_t) st->time_base.num);
2727 st->duration = duration;
2728 show_warning = 1;
2729 }
2730 }
2731 }
2732 }
2733 if (show_warning)
2734 av_log(ic, AV_LOG_WARNING,
2735 "Estimating duration from bitrate, this may be inaccurate\n");
2736 }
2737
2738 #define DURATION_MAX_READ_SIZE 250000LL
2739 #define DURATION_MAX_RETRY 6
2740
2741 /* only usable for MPEG-PS streams */
estimate_timings_from_pts(AVFormatContext * ic,int64_t old_offset)2742 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2743 {
2744 AVPacket pkt1, *pkt = &pkt1;
2745 AVStream *st;
2746 int num, den, read_size, i, ret;
2747 int found_duration = 0;
2748 int is_end;
2749 int64_t filesize, offset, duration;
2750 int retry = 0;
2751
2752 /* flush packet queue */
2753 flush_packet_queue(ic);
2754
2755 for (i = 0; i < ic->nb_streams; i++) {
2756 st = ic->streams[i];
2757 if (st->start_time == AV_NOPTS_VALUE &&
2758 st->first_dts == AV_NOPTS_VALUE &&
2759 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2760 av_log(ic, AV_LOG_WARNING,
2761 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2762
2763 if (st->parser) {
2764 av_parser_close(st->parser);
2765 st->parser = NULL;
2766 }
2767 }
2768
2769 if (ic->skip_estimate_duration_from_pts) {
2770 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2771 goto skip_duration_calc;
2772 }
2773
2774 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2775 /* estimate the end time (duration) */
2776 /* XXX: may need to support wrapping */
2777 filesize = ic->pb ? avio_size(ic->pb) : 0;
2778 do {
2779 is_end = found_duration;
2780 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2781 if (offset < 0)
2782 offset = 0;
2783
2784 avio_seek(ic->pb, offset, SEEK_SET);
2785 read_size = 0;
2786 for (;;) {
2787 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2788 break;
2789
2790 do {
2791 ret = ff_read_packet(ic, pkt);
2792 } while (ret == AVERROR(EAGAIN));
2793 if (ret != 0)
2794 break;
2795 read_size += pkt->size;
2796 st = ic->streams[pkt->stream_index];
2797 if (pkt->pts != AV_NOPTS_VALUE &&
2798 (st->start_time != AV_NOPTS_VALUE ||
2799 st->first_dts != AV_NOPTS_VALUE)) {
2800 if (pkt->duration == 0) {
2801 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2802 if (den && num) {
2803 pkt->duration = av_rescale_rnd(1,
2804 num * (int64_t) st->time_base.den,
2805 den * (int64_t) st->time_base.num,
2806 AV_ROUND_DOWN);
2807 }
2808 }
2809 duration = pkt->pts + pkt->duration;
2810 found_duration = 1;
2811 if (st->start_time != AV_NOPTS_VALUE)
2812 duration -= st->start_time;
2813 else
2814 duration -= st->first_dts;
2815 if (duration > 0) {
2816 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2817 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2818 st->duration = duration;
2819 st->info->last_duration = duration;
2820 }
2821 }
2822 av_packet_unref(pkt);
2823 }
2824
2825 /* check if all audio/video streams have valid duration */
2826 if (!is_end) {
2827 is_end = 1;
2828 for (i = 0; i < ic->nb_streams; i++) {
2829 st = ic->streams[i];
2830 switch (st->codecpar->codec_type) {
2831 case AVMEDIA_TYPE_VIDEO:
2832 case AVMEDIA_TYPE_AUDIO:
2833 if (st->duration == AV_NOPTS_VALUE)
2834 is_end = 0;
2835 }
2836 }
2837 }
2838 } while (!is_end &&
2839 offset &&
2840 ++retry <= DURATION_MAX_RETRY);
2841
2842 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2843
2844 /* warn about audio/video streams which duration could not be estimated */
2845 for (i = 0; i < ic->nb_streams; i++) {
2846 st = ic->streams[i];
2847 if (st->duration == AV_NOPTS_VALUE) {
2848 switch (st->codecpar->codec_type) {
2849 case AVMEDIA_TYPE_VIDEO:
2850 case AVMEDIA_TYPE_AUDIO:
2851 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2852 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2853 } else
2854 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2855 }
2856 }
2857 }
2858 skip_duration_calc:
2859 fill_all_stream_timings(ic);
2860
2861 avio_seek(ic->pb, old_offset, SEEK_SET);
2862 for (i = 0; i < ic->nb_streams; i++) {
2863 int j;
2864
2865 st = ic->streams[i];
2866 st->cur_dts = st->first_dts;
2867 st->last_IP_pts = AV_NOPTS_VALUE;
2868 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2869 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2870 st->pts_buffer[j] = AV_NOPTS_VALUE;
2871 }
2872 }
2873
2874 /* 1:1 map to AVDurationEstimationMethod */
2875 static const char *duration_name[] = {
2876 [AVFMT_DURATION_FROM_PTS] = "pts",
2877 [AVFMT_DURATION_FROM_STREAM] = "stream",
2878 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2879 };
2880
duration_estimate_name(enum AVDurationEstimationMethod method)2881 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2882 {
2883 return duration_name[method];
2884 }
2885
estimate_timings(AVFormatContext * ic,int64_t old_offset)2886 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2887 {
2888 int64_t file_size;
2889
2890 /* get the file size, if possible */
2891 if (ic->iformat->flags & AVFMT_NOFILE) {
2892 file_size = 0;
2893 } else {
2894 file_size = avio_size(ic->pb);
2895 file_size = FFMAX(0, file_size);
2896 }
2897
2898 if ((!strcmp(ic->iformat->name, "mpeg") ||
2899 !strcmp(ic->iformat->name, "mpegts")) &&
2900 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2901 /* get accurate estimate from the PTSes */
2902 estimate_timings_from_pts(ic, old_offset);
2903 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2904 } else if (has_duration(ic)) {
2905 /* at least one component has timings - we use them for all
2906 * the components */
2907 fill_all_stream_timings(ic);
2908 /* nut demuxer estimate the duration from PTS */
2909 if(!strcmp(ic->iformat->name, "nut"))
2910 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2911 else
2912 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2913 } else {
2914 /* less precise: use bitrate info */
2915 estimate_timings_from_bit_rate(ic);
2916 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2917 }
2918 update_stream_timings(ic);
2919
2920 {
2921 int i;
2922 AVStream av_unused *st;
2923 for (i = 0; i < ic->nb_streams; i++) {
2924 st = ic->streams[i];
2925 if (st->time_base.den)
2926 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2927 av_ts2timestr(st->start_time, &st->time_base),
2928 av_ts2timestr(st->duration, &st->time_base));
2929 }
2930 av_log(ic, AV_LOG_TRACE,
2931 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2932 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2933 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2934 duration_estimate_name(ic->duration_estimation_method),
2935 (int64_t)ic->bit_rate / 1000);
2936 }
2937 }
2938
has_codec_parameters(AVStream * st,const char ** errmsg_ptr)2939 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2940 {
2941 AVCodecContext *avctx = st->internal->avctx;
2942
2943 #define FAIL(errmsg) do { \
2944 if (errmsg_ptr) \
2945 *errmsg_ptr = errmsg; \
2946 return 0; \
2947 } while (0)
2948
2949 if ( avctx->codec_id == AV_CODEC_ID_NONE
2950 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2951 FAIL("unknown codec");
2952 switch (avctx->codec_type) {
2953 case AVMEDIA_TYPE_AUDIO:
2954 if (!avctx->frame_size && determinable_frame_size(avctx))
2955 FAIL("unspecified frame size");
2956 if (st->info->found_decoder >= 0 &&
2957 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2958 FAIL("unspecified sample format");
2959 if (!avctx->sample_rate)
2960 FAIL("unspecified sample rate");
2961 if (!avctx->channels)
2962 FAIL("unspecified number of channels");
2963 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2964 FAIL("no decodable DTS frames");
2965 break;
2966 case AVMEDIA_TYPE_VIDEO:
2967 if (!avctx->width)
2968 FAIL("unspecified size");
2969 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2970 FAIL("unspecified pixel format");
2971 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2972 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2973 FAIL("no frame in rv30/40 and no sar");
2974 break;
2975 case AVMEDIA_TYPE_SUBTITLE:
2976 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2977 FAIL("unspecified size");
2978 break;
2979 case AVMEDIA_TYPE_DATA:
2980 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2981 }
2982
2983 return 1;
2984 }
2985
2986 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
try_decode_frame(AVFormatContext * s,AVStream * st,const AVPacket * avpkt,AVDictionary ** options)2987 static int try_decode_frame(AVFormatContext *s, AVStream *st,
2988 const AVPacket *avpkt, AVDictionary **options)
2989 {
2990 AVCodecContext *avctx = st->internal->avctx;
2991 const AVCodec *codec;
2992 int got_picture = 1, ret = 0;
2993 AVFrame *frame = av_frame_alloc();
2994 AVSubtitle subtitle;
2995 AVPacket pkt = *avpkt;
2996 int do_skip_frame = 0;
2997 enum AVDiscard skip_frame;
2998
2999 if (!frame)
3000 return AVERROR(ENOMEM);
3001
3002 if (!avcodec_is_open(avctx) &&
3003 st->info->found_decoder <= 0 &&
3004 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3005 AVDictionary *thread_opt = NULL;
3006
3007 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3008
3009 if (!codec) {
3010 st->info->found_decoder = -st->codecpar->codec_id;
3011 ret = -1;
3012 goto fail;
3013 }
3014
3015 /* Force thread count to 1 since the H.264 decoder will not extract
3016 * SPS and PPS to extradata during multi-threaded decoding. */
3017 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3018 if (s->codec_whitelist)
3019 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3020 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3021 if (!options)
3022 av_dict_free(&thread_opt);
3023 if (ret < 0) {
3024 st->info->found_decoder = -avctx->codec_id;
3025 goto fail;
3026 }
3027 st->info->found_decoder = 1;
3028 } else if (!st->info->found_decoder)
3029 st->info->found_decoder = 1;
3030
3031 if (st->info->found_decoder < 0) {
3032 ret = -1;
3033 goto fail;
3034 }
3035
3036 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3037 do_skip_frame = 1;
3038 skip_frame = avctx->skip_frame;
3039 avctx->skip_frame = AVDISCARD_ALL;
3040 }
3041
3042 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3043 ret >= 0 &&
3044 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3045 (!st->codec_info_nb_frames &&
3046 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3047 got_picture = 0;
3048 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3049 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3050 ret = avcodec_send_packet(avctx, &pkt);
3051 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3052 break;
3053 if (ret >= 0)
3054 pkt.size = 0;
3055 ret = avcodec_receive_frame(avctx, frame);
3056 if (ret >= 0)
3057 got_picture = 1;
3058 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3059 ret = 0;
3060 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3061 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3062 &got_picture, &pkt);
3063 if (got_picture)
3064 avsubtitle_free(&subtitle);
3065 if (ret >= 0)
3066 pkt.size = 0;
3067 }
3068 if (ret >= 0) {
3069 if (got_picture)
3070 st->nb_decoded_frames++;
3071 ret = got_picture;
3072 }
3073 }
3074
3075 if (!pkt.data && !got_picture)
3076 ret = -1;
3077
3078 fail:
3079 if (do_skip_frame) {
3080 avctx->skip_frame = skip_frame;
3081 }
3082
3083 av_frame_free(&frame);
3084 return ret;
3085 }
3086
ff_codec_get_tag(const AVCodecTag * tags,enum AVCodecID id)3087 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3088 {
3089 while (tags->id != AV_CODEC_ID_NONE) {
3090 if (tags->id == id)
3091 return tags->tag;
3092 tags++;
3093 }
3094 return 0;
3095 }
3096
ff_codec_get_id(const AVCodecTag * tags,unsigned int tag)3097 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3098 {
3099 int i;
3100 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3101 if (tag == tags[i].tag)
3102 return tags[i].id;
3103 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3104 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3105 return tags[i].id;
3106 return AV_CODEC_ID_NONE;
3107 }
3108
ff_get_pcm_codec_id(int bps,int flt,int be,int sflags)3109 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3110 {
3111 if (bps <= 0 || bps > 64)
3112 return AV_CODEC_ID_NONE;
3113
3114 if (flt) {
3115 switch (bps) {
3116 case 32:
3117 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3118 case 64:
3119 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3120 default:
3121 return AV_CODEC_ID_NONE;
3122 }
3123 } else {
3124 bps += 7;
3125 bps >>= 3;
3126 if (sflags & (1 << (bps - 1))) {
3127 switch (bps) {
3128 case 1:
3129 return AV_CODEC_ID_PCM_S8;
3130 case 2:
3131 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3132 case 3:
3133 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3134 case 4:
3135 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3136 case 8:
3137 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3138 default:
3139 return AV_CODEC_ID_NONE;
3140 }
3141 } else {
3142 switch (bps) {
3143 case 1:
3144 return AV_CODEC_ID_PCM_U8;
3145 case 2:
3146 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3147 case 3:
3148 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3149 case 4:
3150 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3151 default:
3152 return AV_CODEC_ID_NONE;
3153 }
3154 }
3155 }
3156 }
3157
av_codec_get_tag(const AVCodecTag * const * tags,enum AVCodecID id)3158 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3159 {
3160 unsigned int tag;
3161 if (!av_codec_get_tag2(tags, id, &tag))
3162 return 0;
3163 return tag;
3164 }
3165
av_codec_get_tag2(const AVCodecTag * const * tags,enum AVCodecID id,unsigned int * tag)3166 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3167 unsigned int *tag)
3168 {
3169 int i;
3170 for (i = 0; tags && tags[i]; i++) {
3171 const AVCodecTag *codec_tags = tags[i];
3172 while (codec_tags->id != AV_CODEC_ID_NONE) {
3173 if (codec_tags->id == id) {
3174 *tag = codec_tags->tag;
3175 return 1;
3176 }
3177 codec_tags++;
3178 }
3179 }
3180 return 0;
3181 }
3182
av_codec_get_id(const AVCodecTag * const * tags,unsigned int tag)3183 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3184 {
3185 int i;
3186 for (i = 0; tags && tags[i]; i++) {
3187 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3188 if (id != AV_CODEC_ID_NONE)
3189 return id;
3190 }
3191 return AV_CODEC_ID_NONE;
3192 }
3193
compute_chapters_end(AVFormatContext * s)3194 static void compute_chapters_end(AVFormatContext *s)
3195 {
3196 unsigned int i, j;
3197 int64_t max_time = 0;
3198
3199 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3200 max_time = s->duration +
3201 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3202
3203 for (i = 0; i < s->nb_chapters; i++)
3204 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3205 AVChapter *ch = s->chapters[i];
3206 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3207 ch->time_base)
3208 : INT64_MAX;
3209
3210 for (j = 0; j < s->nb_chapters; j++) {
3211 AVChapter *ch1 = s->chapters[j];
3212 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3213 ch->time_base);
3214 if (j != i && next_start > ch->start && next_start < end)
3215 end = next_start;
3216 }
3217 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3218 }
3219 }
3220
get_std_framerate(int i)3221 static int get_std_framerate(int i)
3222 {
3223 if (i < 30*12)
3224 return (i + 1) * 1001;
3225 i -= 30*12;
3226
3227 if (i < 30)
3228 return (i + 31) * 1001 * 12;
3229 i -= 30;
3230
3231 if (i < 3)
3232 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3233
3234 i -= 3;
3235
3236 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3237 }
3238
3239 /* Is the time base unreliable?
3240 * This is a heuristic to balance between quick acceptance of the values in
3241 * the headers vs. some extra checks.
3242 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3243 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3244 * And there are "variable" fps files this needs to detect as well. */
tb_unreliable(AVCodecContext * c)3245 static int tb_unreliable(AVCodecContext *c)
3246 {
3247 if (c->time_base.den >= 101LL * c->time_base.num ||
3248 c->time_base.den < 5LL * c->time_base.num ||
3249 // c->codec_tag == AV_RL32("DIVX") ||
3250 // c->codec_tag == AV_RL32("XVID") ||
3251 c->codec_tag == AV_RL32("mp4v") ||
3252 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3253 c->codec_id == AV_CODEC_ID_GIF ||
3254 c->codec_id == AV_CODEC_ID_HEVC ||
3255 c->codec_id == AV_CODEC_ID_H264)
3256 return 1;
3257 return 0;
3258 }
3259
ff_alloc_extradata(AVCodecParameters * par,int size)3260 int ff_alloc_extradata(AVCodecParameters *par, int size)
3261 {
3262 av_freep(&par->extradata);
3263 par->extradata_size = 0;
3264
3265 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3266 return AVERROR(EINVAL);
3267
3268 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3269 if (!par->extradata)
3270 return AVERROR(ENOMEM);
3271
3272 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3273 par->extradata_size = size;
3274
3275 return 0;
3276 }
3277
ff_get_extradata(AVFormatContext * s,AVCodecParameters * par,AVIOContext * pb,int size)3278 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3279 {
3280 int ret = ff_alloc_extradata(par, size);
3281 if (ret < 0)
3282 return ret;
3283 ret = avio_read(pb, par->extradata, size);
3284 if (ret != size) {
3285 av_freep(&par->extradata);
3286 par->extradata_size = 0;
3287 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3288 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3289 }
3290
3291 return ret;
3292 }
3293
ff_rfps_add_frame(AVFormatContext * ic,AVStream * st,int64_t ts)3294 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3295 {
3296 int i, j;
3297 int64_t last = st->info->last_dts;
3298
3299 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3300 && ts - (uint64_t)last < INT64_MAX) {
3301 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3302 int64_t duration = ts - last;
3303
3304 if (!st->info->duration_error)
3305 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3306 if (!st->info->duration_error)
3307 return AVERROR(ENOMEM);
3308
3309 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3310 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3311 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3312 if (st->info->duration_error[0][1][i] < 1e10) {
3313 int framerate = get_std_framerate(i);
3314 double sdts = dts*framerate/(1001*12);
3315 for (j= 0; j<2; j++) {
3316 int64_t ticks = llrint(sdts+j*0.5);
3317 double error= sdts - ticks + j*0.5;
3318 st->info->duration_error[j][0][i] += error;
3319 st->info->duration_error[j][1][i] += error*error;
3320 }
3321 }
3322 }
3323 if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3324 st->info->duration_count++;
3325 st->info->rfps_duration_sum += duration;
3326 }
3327
3328 if (st->info->duration_count % 10 == 0) {
3329 int n = st->info->duration_count;
3330 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3331 if (st->info->duration_error[0][1][i] < 1e10) {
3332 double a0 = st->info->duration_error[0][0][i] / n;
3333 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3334 double a1 = st->info->duration_error[1][0][i] / n;
3335 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3336 if (error0 > 0.04 && error1 > 0.04) {
3337 st->info->duration_error[0][1][i] = 2e10;
3338 st->info->duration_error[1][1][i] = 2e10;
3339 }
3340 }
3341 }
3342 }
3343
3344 // ignore the first 4 values, they might have some random jitter
3345 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3346 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3347 }
3348 if (ts != AV_NOPTS_VALUE)
3349 st->info->last_dts = ts;
3350
3351 return 0;
3352 }
3353
ff_rfps_calculate(AVFormatContext * ic)3354 void ff_rfps_calculate(AVFormatContext *ic)
3355 {
3356 int i, j;
3357
3358 for (i = 0; i < ic->nb_streams; i++) {
3359 AVStream *st = ic->streams[i];
3360
3361 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3362 continue;
3363 // the check for tb_unreliable() is not completely correct, since this is not about handling
3364 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3365 // ipmovie.c produces.
3366 if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3367 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3368 if (st->info->duration_count>1 && !st->r_frame_rate.num
3369 && tb_unreliable(st->internal->avctx)) {
3370 int num = 0;
3371 double best_error= 0.01;
3372 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3373
3374 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3375 int k;
3376
3377 if (st->info->codec_info_duration &&
3378 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3379 continue;
3380 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3381 continue;
3382
3383 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3384 continue;
3385
3386 for (k= 0; k<2; k++) {
3387 int n = st->info->duration_count;
3388 double a= st->info->duration_error[k][0][j] / n;
3389 double error= st->info->duration_error[k][1][j]/n - a*a;
3390
3391 if (error < best_error && best_error> 0.000000001) {
3392 best_error= error;
3393 num = get_std_framerate(j);
3394 }
3395 if (error < 0.02)
3396 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3397 }
3398 }
3399 // do not increase frame rate by more than 1 % in order to match a standard rate.
3400 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3401 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3402 }
3403 if ( !st->avg_frame_rate.num
3404 && st->r_frame_rate.num && st->info->rfps_duration_sum
3405 && st->info->codec_info_duration <= 0
3406 && st->info->duration_count > 2
3407 && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3408 ) {
3409 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3410 st->avg_frame_rate = st->r_frame_rate;
3411 }
3412
3413 av_freep(&st->info->duration_error);
3414 st->info->last_dts = AV_NOPTS_VALUE;
3415 st->info->duration_count = 0;
3416 st->info->rfps_duration_sum = 0;
3417 }
3418 }
3419
extract_extradata_check(AVStream * st)3420 static int extract_extradata_check(AVStream *st)
3421 {
3422 const AVBitStreamFilter *f;
3423
3424 f = av_bsf_get_by_name("extract_extradata");
3425 if (!f)
3426 return 0;
3427
3428 if (f->codec_ids) {
3429 const enum AVCodecID *ids;
3430 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3431 if (*ids == st->codecpar->codec_id)
3432 return 1;
3433 }
3434
3435 return 0;
3436 }
3437
extract_extradata_init(AVStream * st)3438 static int extract_extradata_init(AVStream *st)
3439 {
3440 AVStreamInternal *sti = st->internal;
3441 const AVBitStreamFilter *f;
3442 int ret;
3443
3444 f = av_bsf_get_by_name("extract_extradata");
3445 if (!f)
3446 goto finish;
3447
3448 /* check that the codec id is supported */
3449 ret = extract_extradata_check(st);
3450 if (!ret)
3451 goto finish;
3452
3453 sti->extract_extradata.pkt = av_packet_alloc();
3454 if (!sti->extract_extradata.pkt)
3455 return AVERROR(ENOMEM);
3456
3457 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3458 if (ret < 0)
3459 goto fail;
3460
3461 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3462 st->codecpar);
3463 if (ret < 0)
3464 goto fail;
3465
3466 sti->extract_extradata.bsf->time_base_in = st->time_base;
3467
3468 ret = av_bsf_init(sti->extract_extradata.bsf);
3469 if (ret < 0)
3470 goto fail;
3471
3472 finish:
3473 sti->extract_extradata.inited = 1;
3474
3475 return 0;
3476 fail:
3477 av_bsf_free(&sti->extract_extradata.bsf);
3478 av_packet_free(&sti->extract_extradata.pkt);
3479 return ret;
3480 }
3481
extract_extradata(AVStream * st,const AVPacket * pkt)3482 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3483 {
3484 AVStreamInternal *sti = st->internal;
3485 AVPacket *pkt_ref;
3486 int ret;
3487
3488 if (!sti->extract_extradata.inited) {
3489 ret = extract_extradata_init(st);
3490 if (ret < 0)
3491 return ret;
3492 }
3493
3494 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3495 return 0;
3496
3497 pkt_ref = sti->extract_extradata.pkt;
3498 ret = av_packet_ref(pkt_ref, pkt);
3499 if (ret < 0)
3500 return ret;
3501
3502 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3503 if (ret < 0) {
3504 av_packet_unref(pkt_ref);
3505 return ret;
3506 }
3507
3508 while (ret >= 0 && !sti->avctx->extradata) {
3509 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3510 if (ret < 0) {
3511 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3512 return ret;
3513 continue;
3514 }
3515
3516 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3517 AVPacketSideData *side_data = &pkt_ref->side_data[i];
3518 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3519 sti->avctx->extradata = side_data->data;
3520 sti->avctx->extradata_size = side_data->size;
3521 side_data->data = NULL;
3522 side_data->size = 0;
3523 break;
3524 }
3525 }
3526 av_packet_unref(pkt_ref);
3527 }
3528
3529 return 0;
3530 }
3531
add_coded_side_data(AVStream * st,AVCodecContext * avctx)3532 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3533 {
3534 int i;
3535
3536 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3537 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3538 uint8_t *dst_data;
3539 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3540 if (!dst_data)
3541 return AVERROR(ENOMEM);
3542 memcpy(dst_data, sd_src->data, sd_src->size);
3543 }
3544 return 0;
3545 }
3546
avformat_find_stream_info(AVFormatContext * ic,AVDictionary ** options)3547 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3548 {
3549 int i, count = 0, ret = 0, j;
3550 int64_t read_size;
3551 AVStream *st;
3552 AVCodecContext *avctx;
3553 AVPacket pkt1;
3554 int64_t old_offset = avio_tell(ic->pb);
3555 // new streams might appear, no options for those
3556 int orig_nb_streams = ic->nb_streams;
3557 int flush_codecs;
3558 int64_t max_analyze_duration = ic->max_analyze_duration;
3559 int64_t max_stream_analyze_duration;
3560 int64_t max_subtitle_analyze_duration;
3561 int64_t probesize = ic->probesize;
3562 int eof_reached = 0;
3563 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3564
3565 flush_codecs = probesize > 0;
3566
3567 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3568
3569 max_stream_analyze_duration = max_analyze_duration;
3570 max_subtitle_analyze_duration = max_analyze_duration;
3571 if (!max_analyze_duration) {
3572 max_stream_analyze_duration =
3573 max_analyze_duration = 5*AV_TIME_BASE;
3574 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3575 if (!strcmp(ic->iformat->name, "flv"))
3576 max_stream_analyze_duration = 90*AV_TIME_BASE;
3577 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3578 max_stream_analyze_duration = 7*AV_TIME_BASE;
3579 }
3580
3581 if (ic->pb)
3582 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3583 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3584
3585 for (i = 0; i < ic->nb_streams; i++) {
3586 const AVCodec *codec;
3587 AVDictionary *thread_opt = NULL;
3588 st = ic->streams[i];
3589 avctx = st->internal->avctx;
3590
3591 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3592 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3593 /* if (!st->time_base.num)
3594 st->time_base = */
3595 if (!avctx->time_base.num)
3596 avctx->time_base = st->time_base;
3597 }
3598
3599 /* check if the caller has overridden the codec id */
3600 #if FF_API_LAVF_AVCTX
3601 FF_DISABLE_DEPRECATION_WARNINGS
3602 if (st->codec->codec_id != st->internal->orig_codec_id) {
3603 st->codecpar->codec_id = st->codec->codec_id;
3604 st->codecpar->codec_type = st->codec->codec_type;
3605 st->internal->orig_codec_id = st->codec->codec_id;
3606 }
3607 FF_ENABLE_DEPRECATION_WARNINGS
3608 #endif
3609 // only for the split stuff
3610 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3611 st->parser = av_parser_init(st->codecpar->codec_id);
3612 if (st->parser) {
3613 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3614 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3615 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3616 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3617 }
3618 } else if (st->need_parsing) {
3619 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3620 "%s, packets or times may be invalid.\n",
3621 avcodec_get_name(st->codecpar->codec_id));
3622 }
3623 }
3624
3625 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3626 st->internal->orig_codec_id = st->codecpar->codec_id;
3627
3628 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3629 if (ret < 0)
3630 goto find_stream_info_err;
3631 if (st->request_probe <= 0)
3632 st->internal->avctx_inited = 1;
3633
3634 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3635
3636 /* Force thread count to 1 since the H.264 decoder will not extract
3637 * SPS and PPS to extradata during multi-threaded decoding. */
3638 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3639
3640 if (ic->codec_whitelist)
3641 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3642
3643 /* Ensure that subtitle_header is properly set. */
3644 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3645 && codec && !avctx->codec) {
3646 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3647 av_log(ic, AV_LOG_WARNING,
3648 "Failed to open codec in %s\n",__FUNCTION__);
3649 }
3650
3651 // Try to just open decoders, in case this is enough to get parameters.
3652 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3653 if (codec && !avctx->codec)
3654 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3655 av_log(ic, AV_LOG_WARNING,
3656 "Failed to open codec in %s\n",__FUNCTION__);
3657 }
3658 if (!options)
3659 av_dict_free(&thread_opt);
3660 }
3661
3662 for (i = 0; i < ic->nb_streams; i++) {
3663 #if FF_API_R_FRAME_RATE
3664 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3665 #endif
3666 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3667 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3668 }
3669
3670 read_size = 0;
3671 for (;;) {
3672 const AVPacket *pkt;
3673 int analyzed_all_streams;
3674 if (ff_check_interrupt(&ic->interrupt_callback)) {
3675 ret = AVERROR_EXIT;
3676 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3677 break;
3678 }
3679
3680 /* check if one codec still needs to be handled */
3681 for (i = 0; i < ic->nb_streams; i++) {
3682 int fps_analyze_framecount = 20;
3683 int count;
3684
3685 st = ic->streams[i];
3686 if (!has_codec_parameters(st, NULL))
3687 break;
3688 /* If the timebase is coarse (like the usual millisecond precision
3689 * of mkv), we need to analyze more frames to reliably arrive at
3690 * the correct fps. */
3691 if (av_q2d(st->time_base) > 0.0005)
3692 fps_analyze_framecount *= 2;
3693 if (!tb_unreliable(st->internal->avctx))
3694 fps_analyze_framecount = 0;
3695 if (ic->fps_probe_size >= 0)
3696 fps_analyze_framecount = ic->fps_probe_size;
3697 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3698 fps_analyze_framecount = 0;
3699 /* variable fps and no guess at the real fps */
3700 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3701 st->info->codec_info_duration_fields/2 :
3702 st->info->duration_count;
3703 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3704 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3705 if (count < fps_analyze_framecount)
3706 break;
3707 }
3708 // Look at the first 3 frames if there is evidence of frame delay
3709 // but the decoder delay is not set.
3710 if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3711 break;
3712 if (!st->internal->avctx->extradata &&
3713 (!st->internal->extract_extradata.inited ||
3714 st->internal->extract_extradata.bsf) &&
3715 extract_extradata_check(st))
3716 break;
3717 if (st->first_dts == AV_NOPTS_VALUE &&
3718 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3719 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3720 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3721 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3722 break;
3723 }
3724 analyzed_all_streams = 0;
3725 if (!missing_streams || !*missing_streams)
3726 if (i == ic->nb_streams) {
3727 analyzed_all_streams = 1;
3728 /* NOTE: If the format has no header, then we need to read some
3729 * packets to get most of the streams, so we cannot stop here. */
3730 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3731 /* If we found the info for all the codecs, we can stop. */
3732 ret = count;
3733 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3734 flush_codecs = 0;
3735 break;
3736 }
3737 }
3738 /* We did not get all the codec info, but we read too much data. */
3739 if (read_size >= probesize) {
3740 ret = count;
3741 av_log(ic, AV_LOG_DEBUG,
3742 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3743 for (i = 0; i < ic->nb_streams; i++)
3744 if (!ic->streams[i]->r_frame_rate.num &&
3745 ic->streams[i]->info->duration_count <= 1 &&
3746 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3747 strcmp(ic->iformat->name, "image2"))
3748 av_log(ic, AV_LOG_WARNING,
3749 "Stream #%d: not enough frames to estimate rate; "
3750 "consider increasing probesize\n", i);
3751 break;
3752 }
3753
3754 /* NOTE: A new stream can be added there if no header in file
3755 * (AVFMTCTX_NOHEADER). */
3756 ret = read_frame_internal(ic, &pkt1);
3757 if (ret == AVERROR(EAGAIN))
3758 continue;
3759
3760 if (ret < 0) {
3761 /* EOF or error*/
3762 eof_reached = 1;
3763 break;
3764 }
3765
3766 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3767 ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3768 &ic->internal->packet_buffer_end,
3769 &pkt1, NULL, 0);
3770 if (ret < 0)
3771 goto unref_then_goto_end;
3772
3773 pkt = &ic->internal->packet_buffer_end->pkt;
3774 } else {
3775 pkt = &pkt1;
3776 }
3777
3778 st = ic->streams[pkt->stream_index];
3779 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3780 read_size += pkt->size;
3781
3782 avctx = st->internal->avctx;
3783 if (!st->internal->avctx_inited) {
3784 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3785 if (ret < 0)
3786 goto unref_then_goto_end;
3787 st->internal->avctx_inited = 1;
3788 }
3789
3790 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3791 /* check for non-increasing dts */
3792 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3793 st->info->fps_last_dts >= pkt->dts) {
3794 av_log(ic, AV_LOG_DEBUG,
3795 "Non-increasing DTS in stream %d: packet %d with DTS "
3796 "%"PRId64", packet %d with DTS %"PRId64"\n",
3797 st->index, st->info->fps_last_dts_idx,
3798 st->info->fps_last_dts, st->codec_info_nb_frames,
3799 pkt->dts);
3800 st->info->fps_first_dts =
3801 st->info->fps_last_dts = AV_NOPTS_VALUE;
3802 }
3803 /* Check for a discontinuity in dts. If the difference in dts
3804 * is more than 1000 times the average packet duration in the
3805 * sequence, we treat it as a discontinuity. */
3806 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3807 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3808 (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3809 (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3810 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3811 av_log(ic, AV_LOG_WARNING,
3812 "DTS discontinuity in stream %d: packet %d with DTS "
3813 "%"PRId64", packet %d with DTS %"PRId64"\n",
3814 st->index, st->info->fps_last_dts_idx,
3815 st->info->fps_last_dts, st->codec_info_nb_frames,
3816 pkt->dts);
3817 st->info->fps_first_dts =
3818 st->info->fps_last_dts = AV_NOPTS_VALUE;
3819 }
3820
3821 /* update stored dts values */
3822 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3823 st->info->fps_first_dts = pkt->dts;
3824 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3825 }
3826 st->info->fps_last_dts = pkt->dts;
3827 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3828 }
3829 if (st->codec_info_nb_frames>1) {
3830 int64_t t = 0;
3831 int64_t limit;
3832
3833 if (st->time_base.den > 0)
3834 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3835 if (st->avg_frame_rate.num > 0)
3836 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3837
3838 if ( t == 0
3839 && st->codec_info_nb_frames>30
3840 && st->info->fps_first_dts != AV_NOPTS_VALUE
3841 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3842 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3843
3844 if (analyzed_all_streams) limit = max_analyze_duration;
3845 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3846 else limit = max_stream_analyze_duration;
3847
3848 if (t >= limit) {
3849 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3850 limit,
3851 t, pkt->stream_index);
3852 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3853 av_packet_unref(&pkt1);
3854 break;
3855 }
3856 if (pkt->duration) {
3857 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3858 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3859 } else
3860 st->info->codec_info_duration += pkt->duration;
3861 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3862 }
3863 }
3864 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3865 #if FF_API_R_FRAME_RATE
3866 ff_rfps_add_frame(ic, st, pkt->dts);
3867 #endif
3868 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3869 st->info->frame_delay_evidence = 1;
3870 }
3871 if (!st->internal->avctx->extradata) {
3872 ret = extract_extradata(st, pkt);
3873 if (ret < 0)
3874 goto unref_then_goto_end;
3875 }
3876
3877 /* If still no information, we try to open the codec and to
3878 * decompress the frame. We try to avoid that in most cases as
3879 * it takes longer and uses more memory. For MPEG-4, we need to
3880 * decompress for QuickTime.
3881 *
3882 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3883 * least one frame of codec data, this makes sure the codec initializes
3884 * the channel configuration and does not only trust the values from
3885 * the container. */
3886 try_decode_frame(ic, st, pkt,
3887 (options && i < orig_nb_streams) ? &options[i] : NULL);
3888
3889 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3890 av_packet_unref(&pkt1);
3891
3892 st->codec_info_nb_frames++;
3893 count++;
3894 }
3895
3896 if (eof_reached) {
3897 int stream_index;
3898 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3899 st = ic->streams[stream_index];
3900 avctx = st->internal->avctx;
3901 if (!has_codec_parameters(st, NULL)) {
3902 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3903 if (codec && !avctx->codec) {
3904 AVDictionary *opts = NULL;
3905 if (ic->codec_whitelist)
3906 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3907 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3908 av_log(ic, AV_LOG_WARNING,
3909 "Failed to open codec in %s\n",__FUNCTION__);
3910 av_dict_free(&opts);
3911 }
3912 }
3913
3914 // EOF already reached while reading the stream above.
3915 // So continue with reoordering DTS with whatever delay we have.
3916 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3917 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3918 }
3919 }
3920 }
3921
3922 if (flush_codecs) {
3923 AVPacket empty_pkt = { 0 };
3924 int err = 0;
3925 av_init_packet(&empty_pkt);
3926
3927 for (i = 0; i < ic->nb_streams; i++) {
3928
3929 st = ic->streams[i];
3930
3931 /* flush the decoders */
3932 if (st->info->found_decoder == 1) {
3933 do {
3934 err = try_decode_frame(ic, st, &empty_pkt,
3935 (options && i < orig_nb_streams)
3936 ? &options[i] : NULL);
3937 } while (err > 0 && !has_codec_parameters(st, NULL));
3938
3939 if (err < 0) {
3940 av_log(ic, AV_LOG_INFO,
3941 "decoding for stream %d failed\n", st->index);
3942 }
3943 }
3944 }
3945 }
3946
3947 ff_rfps_calculate(ic);
3948
3949 for (i = 0; i < ic->nb_streams; i++) {
3950 st = ic->streams[i];
3951 avctx = st->internal->avctx;
3952 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3953 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3954 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3955 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3956 avctx->codec_tag= tag;
3957 }
3958
3959 /* estimate average framerate if not set by demuxer */
3960 if (st->info->codec_info_duration_fields &&
3961 !st->avg_frame_rate.num &&
3962 st->info->codec_info_duration) {
3963 int best_fps = 0;
3964 double best_error = 0.01;
3965 AVRational codec_frame_rate = avctx->framerate;
3966
3967 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3968 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3969 st->info->codec_info_duration < 0)
3970 continue;
3971 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3972 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3973 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3974
3975 /* Round guessed framerate to a "standard" framerate if it's
3976 * within 1% of the original estimate. */
3977 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3978 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3979 double error = fabs(av_q2d(st->avg_frame_rate) /
3980 av_q2d(std_fps) - 1);
3981
3982 if (error < best_error) {
3983 best_error = error;
3984 best_fps = std_fps.num;
3985 }
3986
3987 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3988 error = fabs(av_q2d(codec_frame_rate) /
3989 av_q2d(std_fps) - 1);
3990 if (error < best_error) {
3991 best_error = error;
3992 best_fps = std_fps.num;
3993 }
3994 }
3995 }
3996 if (best_fps)
3997 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3998 best_fps, 12 * 1001, INT_MAX);
3999 }
4000
4001 if (!st->r_frame_rate.num) {
4002 if ( avctx->time_base.den * (int64_t) st->time_base.num
4003 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4004 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4005 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4006 } else {
4007 st->r_frame_rate.num = st->time_base.den;
4008 st->r_frame_rate.den = st->time_base.num;
4009 }
4010 }
4011 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
4012 AVRational hw_ratio = { avctx->height, avctx->width };
4013 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
4014 hw_ratio);
4015 }
4016 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4017 if (!avctx->bits_per_coded_sample)
4018 avctx->bits_per_coded_sample =
4019 av_get_bits_per_sample(avctx->codec_id);
4020 // set stream disposition based on audio service type
4021 switch (avctx->audio_service_type) {
4022 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4023 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4024 break;
4025 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4026 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4027 break;
4028 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4029 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4030 break;
4031 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4032 st->disposition = AV_DISPOSITION_COMMENT;
4033 break;
4034 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4035 st->disposition = AV_DISPOSITION_KARAOKE;
4036 break;
4037 }
4038 }
4039 }
4040
4041 if (probesize)
4042 estimate_timings(ic, old_offset);
4043
4044 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4045
4046 if (ret >= 0 && ic->nb_streams)
4047 /* We could not have all the codec parameters before EOF. */
4048 ret = -1;
4049 for (i = 0; i < ic->nb_streams; i++) {
4050 const char *errmsg;
4051 st = ic->streams[i];
4052
4053 /* if no packet was ever seen, update context now for has_codec_parameters */
4054 if (!st->internal->avctx_inited) {
4055 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4056 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4057 st->codecpar->format = st->internal->avctx->sample_fmt;
4058 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4059 if (ret < 0)
4060 goto find_stream_info_err;
4061 }
4062 if (!has_codec_parameters(st, &errmsg)) {
4063 char buf[256];
4064 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4065 av_log(ic, AV_LOG_WARNING,
4066 "Could not find codec parameters for stream %d (%s): %s\n"
4067 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4068 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4069 } else {
4070 ret = 0;
4071 }
4072 }
4073
4074 compute_chapters_end(ic);
4075
4076 /* update the stream parameters from the internal codec contexts */
4077 for (i = 0; i < ic->nb_streams; i++) {
4078 st = ic->streams[i];
4079
4080 if (st->internal->avctx_inited) {
4081 int orig_w = st->codecpar->width;
4082 int orig_h = st->codecpar->height;
4083 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4084 if (ret < 0)
4085 goto find_stream_info_err;
4086 ret = add_coded_side_data(st, st->internal->avctx);
4087 if (ret < 0)
4088 goto find_stream_info_err;
4089 #if FF_API_LOWRES
4090 // The decoder might reduce the video size by the lowres factor.
4091 if (st->internal->avctx->lowres && orig_w) {
4092 st->codecpar->width = orig_w;
4093 st->codecpar->height = orig_h;
4094 }
4095 #endif
4096 }
4097
4098 #if FF_API_LAVF_AVCTX
4099 FF_DISABLE_DEPRECATION_WARNINGS
4100 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4101 if (ret < 0)
4102 goto find_stream_info_err;
4103
4104 #if FF_API_LOWRES
4105 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4106 // by the lowres factor.
4107 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4108 st->codec->lowres = st->internal->avctx->lowres;
4109 st->codec->width = st->internal->avctx->width;
4110 st->codec->height = st->internal->avctx->height;
4111 }
4112 #endif
4113
4114 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4115 st->codec->time_base = st->internal->avctx->time_base;
4116 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4117 }
4118 st->codec->framerate = st->avg_frame_rate;
4119
4120 if (st->internal->avctx->subtitle_header) {
4121 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4122 if (!st->codec->subtitle_header)
4123 goto find_stream_info_err;
4124 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4125 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4126 st->codec->subtitle_header_size);
4127 }
4128
4129 // Fields unavailable in AVCodecParameters
4130 st->codec->coded_width = st->internal->avctx->coded_width;
4131 st->codec->coded_height = st->internal->avctx->coded_height;
4132 st->codec->properties = st->internal->avctx->properties;
4133 FF_ENABLE_DEPRECATION_WARNINGS
4134 #endif
4135
4136 st->internal->avctx_inited = 0;
4137 }
4138
4139 find_stream_info_err:
4140 for (i = 0; i < ic->nb_streams; i++) {
4141 st = ic->streams[i];
4142 if (st->info)
4143 av_freep(&st->info->duration_error);
4144 avcodec_close(ic->streams[i]->internal->avctx);
4145 av_freep(&ic->streams[i]->info);
4146 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4147 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4148 }
4149 if (ic->pb)
4150 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4151 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4152 return ret;
4153
4154 unref_then_goto_end:
4155 av_packet_unref(&pkt1);
4156 goto find_stream_info_err;
4157 }
4158
av_find_program_from_stream(AVFormatContext * ic,AVProgram * last,int s)4159 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4160 {
4161 int i, j;
4162
4163 for (i = 0; i < ic->nb_programs; i++) {
4164 if (ic->programs[i] == last) {
4165 last = NULL;
4166 } else {
4167 if (!last)
4168 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4169 if (ic->programs[i]->stream_index[j] == s)
4170 return ic->programs[i];
4171 }
4172 }
4173 return NULL;
4174 }
4175
av_find_best_stream(AVFormatContext * ic,enum AVMediaType type,int wanted_stream_nb,int related_stream,AVCodec ** decoder_ret,int flags)4176 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4177 int wanted_stream_nb, int related_stream,
4178 AVCodec **decoder_ret, int flags)
4179 {
4180 int i, nb_streams = ic->nb_streams;
4181 int ret = AVERROR_STREAM_NOT_FOUND;
4182 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4183 int count, multiframe, disposition;
4184 int64_t best_bitrate = -1;
4185 int64_t bitrate;
4186 unsigned *program = NULL;
4187 const AVCodec *decoder = NULL, *best_decoder = NULL;
4188
4189 if (related_stream >= 0 && wanted_stream_nb < 0) {
4190 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4191 if (p) {
4192 program = p->stream_index;
4193 nb_streams = p->nb_stream_indexes;
4194 }
4195 }
4196 for (i = 0; i < nb_streams; i++) {
4197 int real_stream_index = program ? program[i] : i;
4198 AVStream *st = ic->streams[real_stream_index];
4199 AVCodecParameters *par = st->codecpar;
4200 if (par->codec_type != type)
4201 continue;
4202 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4203 continue;
4204 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4205 continue;
4206 if (decoder_ret) {
4207 decoder = find_decoder(ic, st, par->codec_id);
4208 if (!decoder) {
4209 if (ret < 0)
4210 ret = AVERROR_DECODER_NOT_FOUND;
4211 continue;
4212 }
4213 }
4214 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4215 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4216 count = st->codec_info_nb_frames;
4217 bitrate = par->bit_rate;
4218 multiframe = FFMIN(5, count);
4219 if ((best_disposition > disposition) ||
4220 (best_disposition == disposition && best_multiframe > multiframe) ||
4221 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4222 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4223 continue;
4224 best_disposition = disposition;
4225 best_count = count;
4226 best_bitrate = bitrate;
4227 best_multiframe = multiframe;
4228 ret = real_stream_index;
4229 best_decoder = decoder;
4230 if (program && i == nb_streams - 1 && ret < 0) {
4231 program = NULL;
4232 nb_streams = ic->nb_streams;
4233 /* no related stream found, try again with everything */
4234 i = 0;
4235 }
4236 }
4237 if (decoder_ret)
4238 *decoder_ret = (AVCodec*)best_decoder;
4239 return ret;
4240 }
4241
4242 /*******************************************************/
4243
av_read_play(AVFormatContext * s)4244 int av_read_play(AVFormatContext *s)
4245 {
4246 if (s->iformat->read_play)
4247 return s->iformat->read_play(s);
4248 if (s->pb)
4249 return avio_pause(s->pb, 0);
4250 return AVERROR(ENOSYS);
4251 }
4252
av_read_pause(AVFormatContext * s)4253 int av_read_pause(AVFormatContext *s)
4254 {
4255 if (s->iformat->read_pause)
4256 return s->iformat->read_pause(s);
4257 if (s->pb)
4258 return avio_pause(s->pb, 1);
4259 return AVERROR(ENOSYS);
4260 }
4261
ff_stream_encode_params_copy(AVStream * dst,const AVStream * src)4262 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4263 {
4264 int ret, i;
4265
4266 dst->id = src->id;
4267 dst->time_base = src->time_base;
4268 dst->nb_frames = src->nb_frames;
4269 dst->disposition = src->disposition;
4270 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4271 dst->avg_frame_rate = src->avg_frame_rate;
4272 dst->r_frame_rate = src->r_frame_rate;
4273
4274 av_dict_free(&dst->metadata);
4275 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4276 if (ret < 0)
4277 return ret;
4278
4279 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4280 if (ret < 0)
4281 return ret;
4282
4283 /* Free existing side data*/
4284 for (i = 0; i < dst->nb_side_data; i++)
4285 av_free(dst->side_data[i].data);
4286 av_freep(&dst->side_data);
4287 dst->nb_side_data = 0;
4288
4289 /* Copy side data if present */
4290 if (src->nb_side_data) {
4291 dst->side_data = av_mallocz_array(src->nb_side_data,
4292 sizeof(AVPacketSideData));
4293 if (!dst->side_data)
4294 return AVERROR(ENOMEM);
4295 dst->nb_side_data = src->nb_side_data;
4296
4297 for (i = 0; i < src->nb_side_data; i++) {
4298 uint8_t *data = av_memdup(src->side_data[i].data,
4299 src->side_data[i].size);
4300 if (!data)
4301 return AVERROR(ENOMEM);
4302 dst->side_data[i].type = src->side_data[i].type;
4303 dst->side_data[i].size = src->side_data[i].size;
4304 dst->side_data[i].data = data;
4305 }
4306 }
4307
4308 #if FF_API_LAVF_FFSERVER
4309 FF_DISABLE_DEPRECATION_WARNINGS
4310 av_freep(&dst->recommended_encoder_configuration);
4311 if (src->recommended_encoder_configuration) {
4312 const char *conf_str = src->recommended_encoder_configuration;
4313 dst->recommended_encoder_configuration = av_strdup(conf_str);
4314 if (!dst->recommended_encoder_configuration)
4315 return AVERROR(ENOMEM);
4316 }
4317 FF_ENABLE_DEPRECATION_WARNINGS
4318 #endif
4319
4320 return 0;
4321 }
4322
free_stream(AVStream ** pst)4323 static void free_stream(AVStream **pst)
4324 {
4325 AVStream *st = *pst;
4326 int i;
4327
4328 if (!st)
4329 return;
4330
4331 for (i = 0; i < st->nb_side_data; i++)
4332 av_freep(&st->side_data[i].data);
4333 av_freep(&st->side_data);
4334
4335 if (st->parser)
4336 av_parser_close(st->parser);
4337
4338 if (st->attached_pic.data)
4339 av_packet_unref(&st->attached_pic);
4340
4341 if (st->internal) {
4342 avcodec_free_context(&st->internal->avctx);
4343 av_bsf_free(&st->internal->bsfc);
4344 av_freep(&st->internal->priv_pts);
4345 av_bsf_free(&st->internal->extract_extradata.bsf);
4346 av_packet_free(&st->internal->extract_extradata.pkt);
4347 }
4348 av_freep(&st->internal);
4349
4350 av_dict_free(&st->metadata);
4351 avcodec_parameters_free(&st->codecpar);
4352 av_freep(&st->probe_data.buf);
4353 av_freep(&st->index_entries);
4354 #if FF_API_LAVF_AVCTX
4355 FF_DISABLE_DEPRECATION_WARNINGS
4356 avcodec_free_context(&st->codec);
4357 FF_ENABLE_DEPRECATION_WARNINGS
4358 #endif
4359 av_freep(&st->priv_data);
4360 if (st->info)
4361 av_freep(&st->info->duration_error);
4362 av_freep(&st->info);
4363 #if FF_API_LAVF_FFSERVER
4364 FF_DISABLE_DEPRECATION_WARNINGS
4365 av_freep(&st->recommended_encoder_configuration);
4366 FF_ENABLE_DEPRECATION_WARNINGS
4367 #endif
4368
4369 av_freep(pst);
4370 }
4371
ff_free_stream(AVFormatContext * s,AVStream * st)4372 void ff_free_stream(AVFormatContext *s, AVStream *st)
4373 {
4374 av_assert0(s->nb_streams>0);
4375 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4376
4377 free_stream(&s->streams[ --s->nb_streams ]);
4378 }
4379
avformat_free_context(AVFormatContext * s)4380 void avformat_free_context(AVFormatContext *s)
4381 {
4382 int i;
4383
4384 if (!s)
4385 return;
4386
4387 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4388 s->oformat->deinit(s);
4389
4390 av_opt_free(s);
4391 if (s->iformat && s->iformat->priv_class && s->priv_data)
4392 av_opt_free(s->priv_data);
4393 if (s->oformat && s->oformat->priv_class && s->priv_data)
4394 av_opt_free(s->priv_data);
4395
4396 for (i = 0; i < s->nb_streams; i++)
4397 free_stream(&s->streams[i]);
4398 s->nb_streams = 0;
4399
4400 for (i = 0; i < s->nb_programs; i++) {
4401 av_dict_free(&s->programs[i]->metadata);
4402 av_freep(&s->programs[i]->stream_index);
4403 av_freep(&s->programs[i]);
4404 }
4405 s->nb_programs = 0;
4406
4407 av_freep(&s->programs);
4408 av_freep(&s->priv_data);
4409 while (s->nb_chapters--) {
4410 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4411 av_freep(&s->chapters[s->nb_chapters]);
4412 }
4413 av_freep(&s->chapters);
4414 av_dict_free(&s->metadata);
4415 av_dict_free(&s->internal->id3v2_meta);
4416 av_freep(&s->streams);
4417 flush_packet_queue(s);
4418 av_freep(&s->internal);
4419 av_freep(&s->url);
4420 av_free(s);
4421 }
4422
avformat_close_input(AVFormatContext ** ps)4423 void avformat_close_input(AVFormatContext **ps)
4424 {
4425 AVFormatContext *s;
4426 AVIOContext *pb;
4427
4428 if (!ps || !*ps)
4429 return;
4430
4431 s = *ps;
4432 pb = s->pb;
4433
4434 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4435 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4436 pb = NULL;
4437
4438 flush_packet_queue(s);
4439
4440 if (s->iformat)
4441 if (s->iformat->read_close)
4442 s->iformat->read_close(s);
4443
4444 avformat_free_context(s);
4445
4446 *ps = NULL;
4447
4448 avio_close(pb);
4449 }
4450
avformat_new_stream(AVFormatContext * s,const AVCodec * c)4451 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4452 {
4453 AVStream *st;
4454 int i;
4455 AVStream **streams;
4456
4457 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4458 if (s->max_streams < INT_MAX/sizeof(*streams))
4459 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4460 return NULL;
4461 }
4462 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4463 if (!streams)
4464 return NULL;
4465 s->streams = streams;
4466
4467 st = av_mallocz(sizeof(AVStream));
4468 if (!st)
4469 return NULL;
4470 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4471 av_free(st);
4472 return NULL;
4473 }
4474 st->info->last_dts = AV_NOPTS_VALUE;
4475
4476 #if FF_API_LAVF_AVCTX
4477 FF_DISABLE_DEPRECATION_WARNINGS
4478 st->codec = avcodec_alloc_context3(c);
4479 if (!st->codec) {
4480 av_free(st->info);
4481 av_free(st);
4482 return NULL;
4483 }
4484 FF_ENABLE_DEPRECATION_WARNINGS
4485 #endif
4486
4487 st->internal = av_mallocz(sizeof(*st->internal));
4488 if (!st->internal)
4489 goto fail;
4490
4491 st->codecpar = avcodec_parameters_alloc();
4492 if (!st->codecpar)
4493 goto fail;
4494
4495 st->internal->avctx = avcodec_alloc_context3(NULL);
4496 if (!st->internal->avctx)
4497 goto fail;
4498
4499 if (s->iformat) {
4500 #if FF_API_LAVF_AVCTX
4501 FF_DISABLE_DEPRECATION_WARNINGS
4502 /* no default bitrate if decoding */
4503 st->codec->bit_rate = 0;
4504 FF_ENABLE_DEPRECATION_WARNINGS
4505 #endif
4506
4507 /* default pts setting is MPEG-like */
4508 avpriv_set_pts_info(st, 33, 1, 90000);
4509 /* we set the current DTS to 0 so that formats without any timestamps
4510 * but durations get some timestamps, formats with some unknown
4511 * timestamps have their first few packets buffered and the
4512 * timestamps corrected before they are returned to the user */
4513 st->cur_dts = RELATIVE_TS_BASE;
4514 } else {
4515 st->cur_dts = AV_NOPTS_VALUE;
4516 }
4517
4518 st->index = s->nb_streams;
4519 st->start_time = AV_NOPTS_VALUE;
4520 st->duration = AV_NOPTS_VALUE;
4521 st->first_dts = AV_NOPTS_VALUE;
4522 st->probe_packets = s->max_probe_packets;
4523 st->pts_wrap_reference = AV_NOPTS_VALUE;
4524 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4525
4526 st->last_IP_pts = AV_NOPTS_VALUE;
4527 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4528 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4529 st->pts_buffer[i] = AV_NOPTS_VALUE;
4530
4531 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4532
4533 #if FF_API_R_FRAME_RATE
4534 st->info->last_dts = AV_NOPTS_VALUE;
4535 #endif
4536 st->info->fps_first_dts = AV_NOPTS_VALUE;
4537 st->info->fps_last_dts = AV_NOPTS_VALUE;
4538
4539 st->inject_global_side_data = s->internal->inject_global_side_data;
4540
4541 st->internal->need_context_update = 1;
4542
4543 s->streams[s->nb_streams++] = st;
4544 return st;
4545 fail:
4546 free_stream(&st);
4547 return NULL;
4548 }
4549
av_new_program(AVFormatContext * ac,int id)4550 AVProgram *av_new_program(AVFormatContext *ac, int id)
4551 {
4552 AVProgram *program = NULL;
4553 int i;
4554
4555 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4556
4557 for (i = 0; i < ac->nb_programs; i++)
4558 if (ac->programs[i]->id == id)
4559 program = ac->programs[i];
4560
4561 if (!program) {
4562 program = av_mallocz(sizeof(AVProgram));
4563 if (!program)
4564 return NULL;
4565 dynarray_add(&ac->programs, &ac->nb_programs, program);
4566 program->discard = AVDISCARD_NONE;
4567 program->pmt_version = -1;
4568 }
4569 program->id = id;
4570 program->pts_wrap_reference = AV_NOPTS_VALUE;
4571 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4572
4573 program->start_time =
4574 program->end_time = AV_NOPTS_VALUE;
4575
4576 return program;
4577 }
4578
avpriv_new_chapter(AVFormatContext * s,int id,AVRational time_base,int64_t start,int64_t end,const char * title)4579 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4580 int64_t start, int64_t end, const char *title)
4581 {
4582 AVChapter *chapter = NULL;
4583 int i;
4584
4585 if (end != AV_NOPTS_VALUE && start > end) {
4586 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4587 return NULL;
4588 }
4589
4590 for (i = 0; i < s->nb_chapters; i++)
4591 if (s->chapters[i]->id == id)
4592 chapter = s->chapters[i];
4593
4594 if (!chapter) {
4595 chapter = av_mallocz(sizeof(AVChapter));
4596 if (!chapter)
4597 return NULL;
4598 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4599 }
4600 av_dict_set(&chapter->metadata, "title", title, 0);
4601 chapter->id = id;
4602 chapter->time_base = time_base;
4603 chapter->start = start;
4604 chapter->end = end;
4605
4606 return chapter;
4607 }
4608
av_program_add_stream_index(AVFormatContext * ac,int progid,unsigned idx)4609 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4610 {
4611 int i, j;
4612 AVProgram *program = NULL;
4613 void *tmp;
4614
4615 if (idx >= ac->nb_streams) {
4616 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4617 return;
4618 }
4619
4620 for (i = 0; i < ac->nb_programs; i++) {
4621 if (ac->programs[i]->id != progid)
4622 continue;
4623 program = ac->programs[i];
4624 for (j = 0; j < program->nb_stream_indexes; j++)
4625 if (program->stream_index[j] == idx)
4626 return;
4627
4628 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4629 if (!tmp)
4630 return;
4631 program->stream_index = tmp;
4632 program->stream_index[program->nb_stream_indexes++] = idx;
4633 return;
4634 }
4635 }
4636
ff_ntp_time(void)4637 uint64_t ff_ntp_time(void)
4638 {
4639 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4640 }
4641
ff_get_formatted_ntp_time(uint64_t ntp_time_us)4642 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4643 {
4644 uint64_t ntp_ts, frac_part, sec;
4645 uint32_t usec;
4646
4647 //current ntp time in seconds and micro seconds
4648 sec = ntp_time_us / 1000000;
4649 usec = ntp_time_us % 1000000;
4650
4651 //encoding in ntp timestamp format
4652 frac_part = usec * 0xFFFFFFFFULL;
4653 frac_part /= 1000000;
4654
4655 if (sec > 0xFFFFFFFFULL)
4656 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4657
4658 ntp_ts = sec << 32;
4659 ntp_ts |= frac_part;
4660
4661 return ntp_ts;
4662 }
4663
av_get_frame_filename2(char * buf,int buf_size,const char * path,int number,int flags)4664 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4665 {
4666 const char *p;
4667 char *q, buf1[20], c;
4668 int nd, len, percentd_found;
4669
4670 q = buf;
4671 p = path;
4672 percentd_found = 0;
4673 for (;;) {
4674 c = *p++;
4675 if (c == '\0')
4676 break;
4677 if (c == '%') {
4678 do {
4679 nd = 0;
4680 while (av_isdigit(*p))
4681 nd = nd * 10 + *p++ - '0';
4682 c = *p++;
4683 } while (av_isdigit(c));
4684
4685 switch (c) {
4686 case '%':
4687 goto addchar;
4688 case 'd':
4689 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4690 goto fail;
4691 percentd_found = 1;
4692 if (number < 0)
4693 nd += 1;
4694 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4695 len = strlen(buf1);
4696 if ((q - buf + len) > buf_size - 1)
4697 goto fail;
4698 memcpy(q, buf1, len);
4699 q += len;
4700 break;
4701 default:
4702 goto fail;
4703 }
4704 } else {
4705 addchar:
4706 if ((q - buf) < buf_size - 1)
4707 *q++ = c;
4708 }
4709 }
4710 if (!percentd_found)
4711 goto fail;
4712 *q = '\0';
4713 return 0;
4714 fail:
4715 *q = '\0';
4716 return -1;
4717 }
4718
av_get_frame_filename(char * buf,int buf_size,const char * path,int number)4719 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4720 {
4721 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4722 }
4723
av_url_split(char * proto,int proto_size,char * authorization,int authorization_size,char * hostname,int hostname_size,int * port_ptr,char * path,int path_size,const char * url)4724 void av_url_split(char *proto, int proto_size,
4725 char *authorization, int authorization_size,
4726 char *hostname, int hostname_size,
4727 int *port_ptr, char *path, int path_size, const char *url)
4728 {
4729 const char *p, *ls, *at, *at2, *col, *brk;
4730
4731 if (port_ptr)
4732 *port_ptr = -1;
4733 if (proto_size > 0)
4734 proto[0] = 0;
4735 if (authorization_size > 0)
4736 authorization[0] = 0;
4737 if (hostname_size > 0)
4738 hostname[0] = 0;
4739 if (path_size > 0)
4740 path[0] = 0;
4741
4742 /* parse protocol */
4743 if ((p = strchr(url, ':'))) {
4744 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4745 p++; /* skip ':' */
4746 if (*p == '/')
4747 p++;
4748 if (*p == '/')
4749 p++;
4750 } else {
4751 /* no protocol means plain filename */
4752 av_strlcpy(path, url, path_size);
4753 return;
4754 }
4755
4756 /* separate path from hostname */
4757 ls = p + strcspn(p, "/?#");
4758 av_strlcpy(path, ls, path_size);
4759
4760 /* the rest is hostname, use that to parse auth/port */
4761 if (ls != p) {
4762 /* authorization (user[:pass]@hostname) */
4763 at2 = p;
4764 while ((at = strchr(p, '@')) && at < ls) {
4765 av_strlcpy(authorization, at2,
4766 FFMIN(authorization_size, at + 1 - at2));
4767 p = at + 1; /* skip '@' */
4768 }
4769
4770 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4771 /* [host]:port */
4772 av_strlcpy(hostname, p + 1,
4773 FFMIN(hostname_size, brk - p));
4774 if (brk[1] == ':' && port_ptr)
4775 *port_ptr = atoi(brk + 2);
4776 } else if ((col = strchr(p, ':')) && col < ls) {
4777 av_strlcpy(hostname, p,
4778 FFMIN(col + 1 - p, hostname_size));
4779 if (port_ptr)
4780 *port_ptr = atoi(col + 1);
4781 } else
4782 av_strlcpy(hostname, p,
4783 FFMIN(ls + 1 - p, hostname_size));
4784 }
4785 }
4786
ff_mkdir_p(const char * path)4787 int ff_mkdir_p(const char *path)
4788 {
4789 int ret = 0;
4790 char *temp = av_strdup(path);
4791 char *pos = temp;
4792 char tmp_ch = '\0';
4793
4794 if (!path || !temp) {
4795 return -1;
4796 }
4797
4798 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4799 pos++;
4800 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4801 pos += 2;
4802 }
4803
4804 for ( ; *pos != '\0'; ++pos) {
4805 if (*pos == '/' || *pos == '\\') {
4806 tmp_ch = *pos;
4807 *pos = '\0';
4808 ret = mkdir(temp, 0755);
4809 *pos = tmp_ch;
4810 }
4811 }
4812
4813 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4814 ret = mkdir(temp, 0755);
4815 }
4816
4817 av_free(temp);
4818 return ret;
4819 }
4820
ff_data_to_hex(char * buff,const uint8_t * src,int s,int lowercase)4821 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4822 {
4823 int i;
4824 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4825 '4', '5', '6', '7',
4826 '8', '9', 'A', 'B',
4827 'C', 'D', 'E', 'F' };
4828 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4829 '4', '5', '6', '7',
4830 '8', '9', 'a', 'b',
4831 'c', 'd', 'e', 'f' };
4832 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4833
4834 for (i = 0; i < s; i++) {
4835 buff[i * 2] = hex_table[src[i] >> 4];
4836 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4837 }
4838
4839 return buff;
4840 }
4841
ff_hex_to_data(uint8_t * data,const char * p)4842 int ff_hex_to_data(uint8_t *data, const char *p)
4843 {
4844 int c, len, v;
4845
4846 len = 0;
4847 v = 1;
4848 for (;;) {
4849 p += strspn(p, SPACE_CHARS);
4850 if (*p == '\0')
4851 break;
4852 c = av_toupper((unsigned char) *p++);
4853 if (c >= '0' && c <= '9')
4854 c = c - '0';
4855 else if (c >= 'A' && c <= 'F')
4856 c = c - 'A' + 10;
4857 else
4858 break;
4859 v = (v << 4) | c;
4860 if (v & 0x100) {
4861 if (data)
4862 data[len] = v;
4863 len++;
4864 v = 1;
4865 }
4866 }
4867 return len;
4868 }
4869
avpriv_set_pts_info(AVStream * s,int pts_wrap_bits,unsigned int pts_num,unsigned int pts_den)4870 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4871 unsigned int pts_num, unsigned int pts_den)
4872 {
4873 AVRational new_tb;
4874 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4875 if (new_tb.num != pts_num)
4876 av_log(NULL, AV_LOG_DEBUG,
4877 "st:%d removing common factor %d from timebase\n",
4878 s->index, pts_num / new_tb.num);
4879 } else
4880 av_log(NULL, AV_LOG_WARNING,
4881 "st:%d has too large timebase, reducing\n", s->index);
4882
4883 if (new_tb.num <= 0 || new_tb.den <= 0) {
4884 av_log(NULL, AV_LOG_ERROR,
4885 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4886 new_tb.num, new_tb.den,
4887 s->index);
4888 return;
4889 }
4890 s->time_base = new_tb;
4891 #if FF_API_LAVF_AVCTX
4892 FF_DISABLE_DEPRECATION_WARNINGS
4893 s->codec->pkt_timebase = new_tb;
4894 FF_ENABLE_DEPRECATION_WARNINGS
4895 #endif
4896 s->internal->avctx->pkt_timebase = new_tb;
4897 s->pts_wrap_bits = pts_wrap_bits;
4898 }
4899
ff_parse_key_value(const char * str,ff_parse_key_val_cb callback_get_buf,void * context)4900 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4901 void *context)
4902 {
4903 const char *ptr = str;
4904
4905 /* Parse key=value pairs. */
4906 for (;;) {
4907 const char *key;
4908 char *dest = NULL, *dest_end;
4909 int key_len, dest_len = 0;
4910
4911 /* Skip whitespace and potential commas. */
4912 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4913 ptr++;
4914 if (!*ptr)
4915 break;
4916
4917 key = ptr;
4918
4919 if (!(ptr = strchr(key, '=')))
4920 break;
4921 ptr++;
4922 key_len = ptr - key;
4923
4924 callback_get_buf(context, key, key_len, &dest, &dest_len);
4925 dest_end = dest + dest_len - 1;
4926
4927 if (*ptr == '\"') {
4928 ptr++;
4929 while (*ptr && *ptr != '\"') {
4930 if (*ptr == '\\') {
4931 if (!ptr[1])
4932 break;
4933 if (dest && dest < dest_end)
4934 *dest++ = ptr[1];
4935 ptr += 2;
4936 } else {
4937 if (dest && dest < dest_end)
4938 *dest++ = *ptr;
4939 ptr++;
4940 }
4941 }
4942 if (*ptr == '\"')
4943 ptr++;
4944 } else {
4945 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4946 if (dest && dest < dest_end)
4947 *dest++ = *ptr;
4948 }
4949 if (dest)
4950 *dest = 0;
4951 }
4952 }
4953
ff_find_stream_index(AVFormatContext * s,int id)4954 int ff_find_stream_index(AVFormatContext *s, int id)
4955 {
4956 int i;
4957 for (i = 0; i < s->nb_streams; i++)
4958 if (s->streams[i]->id == id)
4959 return i;
4960 return -1;
4961 }
4962
avformat_query_codec(const AVOutputFormat * ofmt,enum AVCodecID codec_id,int std_compliance)4963 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4964 int std_compliance)
4965 {
4966 if (ofmt) {
4967 unsigned int codec_tag;
4968 if (ofmt->query_codec)
4969 return ofmt->query_codec(codec_id, std_compliance);
4970 else if (ofmt->codec_tag)
4971 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4972 else if (codec_id == ofmt->video_codec ||
4973 codec_id == ofmt->audio_codec ||
4974 codec_id == ofmt->subtitle_codec ||
4975 codec_id == ofmt->data_codec)
4976 return 1;
4977 }
4978 return AVERROR_PATCHWELCOME;
4979 }
4980
avformat_network_init(void)4981 int avformat_network_init(void)
4982 {
4983 #if CONFIG_NETWORK
4984 int ret;
4985 if ((ret = ff_network_init()) < 0)
4986 return ret;
4987 if ((ret = ff_tls_init()) < 0)
4988 return ret;
4989 #endif
4990 return 0;
4991 }
4992
avformat_network_deinit(void)4993 int avformat_network_deinit(void)
4994 {
4995 #if CONFIG_NETWORK
4996 ff_network_close();
4997 ff_tls_deinit();
4998 #endif
4999 return 0;
5000 }
5001
ff_add_param_change(AVPacket * pkt,int32_t channels,uint64_t channel_layout,int32_t sample_rate,int32_t width,int32_t height)5002 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5003 uint64_t channel_layout, int32_t sample_rate,
5004 int32_t width, int32_t height)
5005 {
5006 uint32_t flags = 0;
5007 int size = 4;
5008 uint8_t *data;
5009 if (!pkt)
5010 return AVERROR(EINVAL);
5011 if (channels) {
5012 size += 4;
5013 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5014 }
5015 if (channel_layout) {
5016 size += 8;
5017 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5018 }
5019 if (sample_rate) {
5020 size += 4;
5021 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5022 }
5023 if (width || height) {
5024 size += 8;
5025 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5026 }
5027 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5028 if (!data)
5029 return AVERROR(ENOMEM);
5030 bytestream_put_le32(&data, flags);
5031 if (channels)
5032 bytestream_put_le32(&data, channels);
5033 if (channel_layout)
5034 bytestream_put_le64(&data, channel_layout);
5035 if (sample_rate)
5036 bytestream_put_le32(&data, sample_rate);
5037 if (width || height) {
5038 bytestream_put_le32(&data, width);
5039 bytestream_put_le32(&data, height);
5040 }
5041 return 0;
5042 }
5043
av_guess_sample_aspect_ratio(AVFormatContext * format,AVStream * stream,AVFrame * frame)5044 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5045 {
5046 AVRational undef = {0, 1};
5047 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5048 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5049 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5050
5051 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5052 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5053 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5054 stream_sample_aspect_ratio = undef;
5055
5056 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5057 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5058 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5059 frame_sample_aspect_ratio = undef;
5060
5061 if (stream_sample_aspect_ratio.num)
5062 return stream_sample_aspect_ratio;
5063 else
5064 return frame_sample_aspect_ratio;
5065 }
5066
av_guess_frame_rate(AVFormatContext * format,AVStream * st,AVFrame * frame)5067 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5068 {
5069 AVRational fr = st->r_frame_rate;
5070 AVRational codec_fr = st->internal->avctx->framerate;
5071 AVRational avg_fr = st->avg_frame_rate;
5072
5073 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5074 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5075 fr = avg_fr;
5076 }
5077
5078
5079 if (st->internal->avctx->ticks_per_frame > 1) {
5080 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5081 (fr.num == 0 || av_q2d(codec_fr) < av_q2d(fr)*0.7 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1))
5082 fr = codec_fr;
5083 }
5084
5085 return fr;
5086 }
5087
5088 /**
5089 * Matches a stream specifier (but ignores requested index).
5090 *
5091 * @param indexptr set to point to the requested stream index if there is one
5092 *
5093 * @return <0 on error
5094 * 0 if st is NOT a matching stream
5095 * >0 if st is a matching stream
5096 */
match_stream_specifier(AVFormatContext * s,AVStream * st,const char * spec,const char ** indexptr,AVProgram ** p)5097 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5098 const char *spec, const char **indexptr, AVProgram **p)
5099 {
5100 int match = 1; /* Stores if the specifier matches so far. */
5101 while (*spec) {
5102 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5103 if (indexptr)
5104 *indexptr = spec;
5105 return match;
5106 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5107 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5108 enum AVMediaType type;
5109 int nopic = 0;
5110
5111 switch (*spec++) {
5112 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5113 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5114 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5115 case 'd': type = AVMEDIA_TYPE_DATA; break;
5116 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5117 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5118 default: av_assert0(0);
5119 }
5120 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5121 return AVERROR(EINVAL);
5122
5123 #if FF_API_LAVF_AVCTX
5124 FF_DISABLE_DEPRECATION_WARNINGS
5125 if (type != st->codecpar->codec_type
5126 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5127 match = 0;
5128 FF_ENABLE_DEPRECATION_WARNINGS
5129 #else
5130 if (type != st->codecpar->codec_type)
5131 match = 0;
5132 #endif
5133 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5134 match = 0;
5135 } else if (*spec == 'p' && *(spec + 1) == ':') {
5136 int prog_id, i, j;
5137 int found = 0;
5138 char *endptr;
5139 spec += 2;
5140 prog_id = strtol(spec, &endptr, 0);
5141 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5142 if (spec == endptr || (*endptr && *endptr++ != ':'))
5143 return AVERROR(EINVAL);
5144 spec = endptr;
5145 if (match) {
5146 for (i = 0; i < s->nb_programs; i++) {
5147 if (s->programs[i]->id != prog_id)
5148 continue;
5149
5150 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5151 if (st->index == s->programs[i]->stream_index[j]) {
5152 found = 1;
5153 if (p)
5154 *p = s->programs[i];
5155 i = s->nb_programs;
5156 break;
5157 }
5158 }
5159 }
5160 }
5161 if (!found)
5162 match = 0;
5163 } else if (*spec == '#' ||
5164 (*spec == 'i' && *(spec + 1) == ':')) {
5165 int stream_id;
5166 char *endptr;
5167 spec += 1 + (*spec == 'i');
5168 stream_id = strtol(spec, &endptr, 0);
5169 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5170 return AVERROR(EINVAL);
5171 return match && (stream_id == st->id);
5172 } else if (*spec == 'm' && *(spec + 1) == ':') {
5173 AVDictionaryEntry *tag;
5174 char *key, *val;
5175 int ret;
5176
5177 if (match) {
5178 spec += 2;
5179 val = strchr(spec, ':');
5180
5181 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5182 if (!key)
5183 return AVERROR(ENOMEM);
5184
5185 tag = av_dict_get(st->metadata, key, NULL, 0);
5186 if (tag) {
5187 if (!val || !strcmp(tag->value, val + 1))
5188 ret = 1;
5189 else
5190 ret = 0;
5191 } else
5192 ret = 0;
5193
5194 av_freep(&key);
5195 }
5196 return match && ret;
5197 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5198 AVCodecParameters *par = st->codecpar;
5199 #if FF_API_LAVF_AVCTX
5200 FF_DISABLE_DEPRECATION_WARNINGS
5201 AVCodecContext *codec = st->codec;
5202 FF_ENABLE_DEPRECATION_WARNINGS
5203 #endif
5204 int val;
5205 switch (par->codec_type) {
5206 case AVMEDIA_TYPE_AUDIO:
5207 val = par->sample_rate && par->channels;
5208 #if FF_API_LAVF_AVCTX
5209 val = val || (codec->sample_rate && codec->channels);
5210 #endif
5211 if (par->format == AV_SAMPLE_FMT_NONE
5212 #if FF_API_LAVF_AVCTX
5213 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5214 #endif
5215 )
5216 return 0;
5217 break;
5218 case AVMEDIA_TYPE_VIDEO:
5219 val = par->width && par->height;
5220 #if FF_API_LAVF_AVCTX
5221 val = val || (codec->width && codec->height);
5222 #endif
5223 if (par->format == AV_PIX_FMT_NONE
5224 #if FF_API_LAVF_AVCTX
5225 && codec->pix_fmt == AV_PIX_FMT_NONE
5226 #endif
5227 )
5228 return 0;
5229 break;
5230 case AVMEDIA_TYPE_UNKNOWN:
5231 val = 0;
5232 break;
5233 default:
5234 val = 1;
5235 break;
5236 }
5237 #if FF_API_LAVF_AVCTX
5238 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5239 #else
5240 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5241 #endif
5242 } else {
5243 return AVERROR(EINVAL);
5244 }
5245 }
5246
5247 return match;
5248 }
5249
5250
avformat_match_stream_specifier(AVFormatContext * s,AVStream * st,const char * spec)5251 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5252 const char *spec)
5253 {
5254 int ret, index;
5255 char *endptr;
5256 const char *indexptr = NULL;
5257 AVProgram *p = NULL;
5258 int nb_streams;
5259
5260 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5261 if (ret < 0)
5262 goto error;
5263
5264 if (!indexptr)
5265 return ret;
5266
5267 index = strtol(indexptr, &endptr, 0);
5268 if (*endptr) { /* We can't have anything after the requested index. */
5269 ret = AVERROR(EINVAL);
5270 goto error;
5271 }
5272
5273 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5274 if (spec == indexptr)
5275 return (index == st->index);
5276
5277 /* If we requested a matching stream index, we have to ensure st is that. */
5278 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5279 for (int i = 0; i < nb_streams && index >= 0; i++) {
5280 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5281 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5282 if (ret < 0)
5283 goto error;
5284 if (ret > 0 && index-- == 0 && st == candidate)
5285 return 1;
5286 }
5287 return 0;
5288
5289 error:
5290 if (ret == AVERROR(EINVAL))
5291 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5292 return ret;
5293 }
5294
ff_generate_avci_extradata(AVStream * st)5295 int ff_generate_avci_extradata(AVStream *st)
5296 {
5297 static const uint8_t avci100_1080p_extradata[] = {
5298 // SPS
5299 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5300 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5301 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5302 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5303 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5304 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5305 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5306 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5307 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5308 // PPS
5309 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5310 0xd0
5311 };
5312 static const uint8_t avci100_1080i_extradata[] = {
5313 // SPS
5314 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5315 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5316 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5317 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5318 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5319 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5320 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5321 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5322 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5323 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5324 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5325 // PPS
5326 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5327 0xd0
5328 };
5329 static const uint8_t avci50_1080p_extradata[] = {
5330 // SPS
5331 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5332 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5333 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5334 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5335 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5336 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5337 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5338 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5339 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5340 // PPS
5341 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5342 0x11
5343 };
5344 static const uint8_t avci50_1080i_extradata[] = {
5345 // SPS
5346 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5347 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5348 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5349 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5350 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5351 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5352 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5353 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5354 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5355 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5356 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5357 // PPS
5358 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5359 0x11
5360 };
5361 static const uint8_t avci100_720p_extradata[] = {
5362 // SPS
5363 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5364 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5365 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5366 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5367 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5368 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5369 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5370 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5371 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5372 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5373 // PPS
5374 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5375 0x11
5376 };
5377 static const uint8_t avci50_720p_extradata[] = {
5378 // SPS
5379 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5380 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5381 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5382 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5383 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5384 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5385 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5386 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5387 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5388 // PPS
5389 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5390 0x11
5391 };
5392
5393 const uint8_t *data = NULL;
5394 int ret, size = 0;
5395
5396 if (st->codecpar->width == 1920) {
5397 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5398 data = avci100_1080p_extradata;
5399 size = sizeof(avci100_1080p_extradata);
5400 } else {
5401 data = avci100_1080i_extradata;
5402 size = sizeof(avci100_1080i_extradata);
5403 }
5404 } else if (st->codecpar->width == 1440) {
5405 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5406 data = avci50_1080p_extradata;
5407 size = sizeof(avci50_1080p_extradata);
5408 } else {
5409 data = avci50_1080i_extradata;
5410 size = sizeof(avci50_1080i_extradata);
5411 }
5412 } else if (st->codecpar->width == 1280) {
5413 data = avci100_720p_extradata;
5414 size = sizeof(avci100_720p_extradata);
5415 } else if (st->codecpar->width == 960) {
5416 data = avci50_720p_extradata;
5417 size = sizeof(avci50_720p_extradata);
5418 }
5419
5420 if (!size)
5421 return 0;
5422
5423 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5424 return ret;
5425 memcpy(st->codecpar->extradata, data, size);
5426
5427 return 0;
5428 }
5429
av_stream_get_side_data(const AVStream * st,enum AVPacketSideDataType type,int * size)5430 uint8_t *av_stream_get_side_data(const AVStream *st,
5431 enum AVPacketSideDataType type, int *size)
5432 {
5433 int i;
5434
5435 for (i = 0; i < st->nb_side_data; i++) {
5436 if (st->side_data[i].type == type) {
5437 if (size)
5438 *size = st->side_data[i].size;
5439 return st->side_data[i].data;
5440 }
5441 }
5442 if (size)
5443 *size = 0;
5444 return NULL;
5445 }
5446
av_stream_add_side_data(AVStream * st,enum AVPacketSideDataType type,uint8_t * data,size_t size)5447 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5448 uint8_t *data, size_t size)
5449 {
5450 AVPacketSideData *sd, *tmp;
5451 int i;
5452
5453 for (i = 0; i < st->nb_side_data; i++) {
5454 sd = &st->side_data[i];
5455
5456 if (sd->type == type) {
5457 av_freep(&sd->data);
5458 sd->data = data;
5459 sd->size = size;
5460 return 0;
5461 }
5462 }
5463
5464 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5465 return AVERROR(ERANGE);
5466
5467 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5468 if (!tmp) {
5469 return AVERROR(ENOMEM);
5470 }
5471
5472 st->side_data = tmp;
5473 st->nb_side_data++;
5474
5475 sd = &st->side_data[st->nb_side_data - 1];
5476 sd->type = type;
5477 sd->data = data;
5478 sd->size = size;
5479
5480 return 0;
5481 }
5482
av_stream_new_side_data(AVStream * st,enum AVPacketSideDataType type,int size)5483 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5484 int size)
5485 {
5486 int ret;
5487 uint8_t *data = av_malloc(size);
5488
5489 if (!data)
5490 return NULL;
5491
5492 ret = av_stream_add_side_data(st, type, data, size);
5493 if (ret < 0) {
5494 av_freep(&data);
5495 return NULL;
5496 }
5497
5498 return data;
5499 }
5500
ff_stream_add_bitstream_filter(AVStream * st,const char * name,const char * args)5501 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5502 {
5503 int ret;
5504 const AVBitStreamFilter *bsf;
5505 AVBSFContext *bsfc;
5506
5507 av_assert0(!st->internal->bsfc);
5508
5509 if (!(bsf = av_bsf_get_by_name(name))) {
5510 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5511 return AVERROR_BSF_NOT_FOUND;
5512 }
5513
5514 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5515 return ret;
5516
5517 bsfc->time_base_in = st->time_base;
5518 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5519 av_bsf_free(&bsfc);
5520 return ret;
5521 }
5522
5523 if (args && bsfc->filter->priv_class) {
5524 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5525 const char * shorthand[2] = {NULL};
5526
5527 if (opt)
5528 shorthand[0] = opt->name;
5529
5530 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5531 av_bsf_free(&bsfc);
5532 return ret;
5533 }
5534 }
5535
5536 if ((ret = av_bsf_init(bsfc)) < 0) {
5537 av_bsf_free(&bsfc);
5538 return ret;
5539 }
5540
5541 st->internal->bsfc = bsfc;
5542
5543 av_log(NULL, AV_LOG_VERBOSE,
5544 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5545 name, args ? args : "");
5546 return 1;
5547 }
5548
5549 #if FF_API_OLD_BSF
5550 FF_DISABLE_DEPRECATION_WARNINGS
av_apply_bitstream_filters(AVCodecContext * codec,AVPacket * pkt,AVBitStreamFilterContext * bsfc)5551 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5552 AVBitStreamFilterContext *bsfc)
5553 {
5554 int ret = 0;
5555 while (bsfc) {
5556 AVPacket new_pkt = *pkt;
5557 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5558 &new_pkt.data, &new_pkt.size,
5559 pkt->data, pkt->size,
5560 pkt->flags & AV_PKT_FLAG_KEY);
5561 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5562 av_packet_unref(pkt);
5563 memset(pkt, 0, sizeof(*pkt));
5564 return 0;
5565 }
5566 if(a == 0 && new_pkt.data != pkt->data) {
5567 uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
5568 if (t) {
5569 memcpy(t, new_pkt.data, new_pkt.size);
5570 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5571 new_pkt.data = t;
5572 new_pkt.buf = NULL;
5573 a = 1;
5574 } else {
5575 a = AVERROR(ENOMEM);
5576 }
5577 }
5578 if (a > 0) {
5579 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5580 av_buffer_default_free, NULL, 0);
5581 if (new_pkt.buf) {
5582 pkt->side_data = NULL;
5583 pkt->side_data_elems = 0;
5584 av_packet_unref(pkt);
5585 } else {
5586 av_freep(&new_pkt.data);
5587 a = AVERROR(ENOMEM);
5588 }
5589 }
5590 if (a < 0) {
5591 av_log(codec, AV_LOG_ERROR,
5592 "Failed to open bitstream filter %s for stream %d with codec %s",
5593 bsfc->filter->name, pkt->stream_index,
5594 codec->codec ? codec->codec->name : "copy");
5595 ret = a;
5596 break;
5597 }
5598 *pkt = new_pkt;
5599
5600 bsfc = bsfc->next;
5601 }
5602 return ret;
5603 }
5604 FF_ENABLE_DEPRECATION_WARNINGS
5605 #endif
5606
ff_format_output_open(AVFormatContext * s,const char * url,AVDictionary ** options)5607 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5608 {
5609 if (!s->oformat)
5610 return AVERROR(EINVAL);
5611
5612 if (!(s->oformat->flags & AVFMT_NOFILE))
5613 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5614 return 0;
5615 }
5616
ff_format_io_close(AVFormatContext * s,AVIOContext ** pb)5617 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5618 {
5619 if (*pb)
5620 s->io_close(s, *pb);
5621 *pb = NULL;
5622 }
5623
ff_is_http_proto(char * filename)5624 int ff_is_http_proto(char *filename) {
5625 const char *proto = avio_find_protocol_name(filename);
5626 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5627 }
5628
ff_parse_creation_time_metadata(AVFormatContext * s,int64_t * timestamp,int return_seconds)5629 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5630 {
5631 AVDictionaryEntry *entry;
5632 int64_t parsed_timestamp;
5633 int ret;
5634 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5635 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5636 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5637 return 1;
5638 } else {
5639 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5640 return ret;
5641 }
5642 }
5643 return 0;
5644 }
5645
ff_standardize_creation_time(AVFormatContext * s)5646 int ff_standardize_creation_time(AVFormatContext *s)
5647 {
5648 int64_t timestamp;
5649 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5650 if (ret == 1)
5651 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5652 return ret;
5653 }
5654
ff_get_packet_palette(AVFormatContext * s,AVPacket * pkt,int ret,uint32_t * palette)5655 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5656 {
5657 uint8_t *side_data;
5658 int size;
5659
5660 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5661 if (side_data) {
5662 if (size != AVPALETTE_SIZE) {
5663 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5664 return AVERROR_INVALIDDATA;
5665 }
5666 memcpy(palette, side_data, AVPALETTE_SIZE);
5667 return 1;
5668 }
5669
5670 if (ret == CONTAINS_PAL) {
5671 int i;
5672 for (i = 0; i < AVPALETTE_COUNT; i++)
5673 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5674 return 1;
5675 }
5676
5677 return 0;
5678 }
5679
ff_bprint_to_codecpar_extradata(AVCodecParameters * par,struct AVBPrint * buf)5680 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5681 {
5682 int ret;
5683 char *str;
5684
5685 ret = av_bprint_finalize(buf, &str);
5686 if (ret < 0)
5687 return ret;
5688 if (!av_bprint_is_complete(buf)) {
5689 av_free(str);
5690 return AVERROR(ENOMEM);
5691 }
5692
5693 par->extradata = str;
5694 /* Note: the string is NUL terminated (so extradata can be read as a
5695 * string), but the ending character is not accounted in the size (in
5696 * binary formats you are likely not supposed to mux that character). When
5697 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5698 * zeros. */
5699 par->extradata_size = buf->len;
5700 return 0;
5701 }
5702
avformat_transfer_internal_stream_timing_info(const AVOutputFormat * ofmt,AVStream * ost,const AVStream * ist,enum AVTimebaseSource copy_tb)5703 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5704 AVStream *ost, const AVStream *ist,
5705 enum AVTimebaseSource copy_tb)
5706 {
5707 //TODO: use [io]st->internal->avctx
5708 const AVCodecContext *dec_ctx = ist->codec;
5709 AVCodecContext *enc_ctx = ost->codec;
5710
5711 enc_ctx->time_base = ist->time_base;
5712 /*
5713 * Avi is a special case here because it supports variable fps but
5714 * having the fps and timebase differe significantly adds quite some
5715 * overhead
5716 */
5717 if (!strcmp(ofmt->name, "avi")) {
5718 #if FF_API_R_FRAME_RATE
5719 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5720 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5721 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5722 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5723 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5724 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5725 enc_ctx->time_base.num = ist->r_frame_rate.den;
5726 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5727 enc_ctx->ticks_per_frame = 2;
5728 } else
5729 #endif
5730 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5731 && av_q2d(ist->time_base) < 1.0/500
5732 || copy_tb == AVFMT_TBCF_DECODER) {
5733 enc_ctx->time_base = dec_ctx->time_base;
5734 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5735 enc_ctx->time_base.den *= 2;
5736 enc_ctx->ticks_per_frame = 2;
5737 }
5738 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5739 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5740 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5741 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5742 && av_q2d(ist->time_base) < 1.0/500
5743 || copy_tb == AVFMT_TBCF_DECODER) {
5744 enc_ctx->time_base = dec_ctx->time_base;
5745 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5746 }
5747 }
5748
5749 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5750 && dec_ctx->time_base.num < dec_ctx->time_base.den
5751 && dec_ctx->time_base.num > 0
5752 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5753 enc_ctx->time_base = dec_ctx->time_base;
5754 }
5755
5756 if (ost->avg_frame_rate.num)
5757 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5758
5759 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5760 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5761
5762 return 0;
5763 }
5764
av_stream_get_codec_timebase(const AVStream * st)5765 AVRational av_stream_get_codec_timebase(const AVStream *st)
5766 {
5767 // See avformat_transfer_internal_stream_timing_info() TODO.
5768 #if FF_API_LAVF_AVCTX
5769 FF_DISABLE_DEPRECATION_WARNINGS
5770 return st->codec->time_base;
5771 FF_ENABLE_DEPRECATION_WARNINGS
5772 #else
5773 return st->internal->avctx->time_base;
5774 #endif
5775 }
5776
ff_format_set_url(AVFormatContext * s,char * url)5777 void ff_format_set_url(AVFormatContext *s, char *url)
5778 {
5779 av_assert0(url);
5780 av_freep(&s->url);
5781 s->url = url;
5782 #if FF_API_FORMAT_FILENAME
5783 FF_DISABLE_DEPRECATION_WARNINGS
5784 av_strlcpy(s->filename, url, sizeof(s->filename));
5785 FF_ENABLE_DEPRECATION_WARNINGS
5786 #endif
5787 }
5788