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