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