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