LCOV - code coverage report
Current view: top level - libavformat - mux.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 515 745 69.1 %
Date: 2017-12-17 04:34:43 Functions: 25 30 83.3 %

          Line data    Source code
       1             : /*
       2             :  * muxing 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 "avformat.h"
      23             : #include "avio_internal.h"
      24             : #include "internal.h"
      25             : #include "libavcodec/internal.h"
      26             : #include "libavcodec/bytestream.h"
      27             : #include "libavutil/opt.h"
      28             : #include "libavutil/dict.h"
      29             : #include "libavutil/pixdesc.h"
      30             : #include "libavutil/timestamp.h"
      31             : #include "metadata.h"
      32             : #include "id3v2.h"
      33             : #include "libavutil/avassert.h"
      34             : #include "libavutil/avstring.h"
      35             : #include "libavutil/internal.h"
      36             : #include "libavutil/mathematics.h"
      37             : #include "libavutil/parseutils.h"
      38             : #include "libavutil/time.h"
      39             : #include "riff.h"
      40             : #include "audiointerleave.h"
      41             : #include "url.h"
      42             : #include <stdarg.h>
      43             : #if CONFIG_NETWORK
      44             : #include "network.h"
      45             : #endif
      46             : 
      47             : /**
      48             :  * @file
      49             :  * muxing functions for use within libavformat
      50             :  */
      51             : 
      52             : /* fraction handling */
      53             : 
      54             : /**
      55             :  * f = val + (num / den) + 0.5.
      56             :  *
      57             :  * 'num' is normalized so that it is such as 0 <= num < den.
      58             :  *
      59             :  * @param f fractional number
      60             :  * @param val integer value
      61             :  * @param num must be >= 0
      62             :  * @param den must be >= 1
      63             :  */
      64        5578 : static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
      65             : {
      66        5578 :     num += (den >> 1);
      67        5578 :     if (num >= den) {
      68           0 :         val += num / den;
      69           0 :         num  = num % den;
      70             :     }
      71        5578 :     f->val = val;
      72        5578 :     f->num = num;
      73        5578 :     f->den = den;
      74        5578 : }
      75             : 
      76             : /**
      77             :  * Fractional addition to f: f = f + (incr / f->den).
      78             :  *
      79             :  * @param f fractional number
      80             :  * @param incr increment, can be positive or negative
      81             :  */
      82      421335 : static void frac_add(FFFrac *f, int64_t incr)
      83             : {
      84             :     int64_t num, den;
      85             : 
      86      421335 :     num = f->num + incr;
      87      421335 :     den = f->den;
      88      421335 :     if (num < 0) {
      89           0 :         f->val += num / den;
      90           0 :         num     = num % den;
      91           0 :         if (num < 0) {
      92           0 :             num += den;
      93           0 :             f->val--;
      94             :         }
      95      421335 :     } else if (num >= den) {
      96      397431 :         f->val += num / den;
      97      397431 :         num     = num % den;
      98             :     }
      99      421335 :     f->num = num;
     100      421335 : }
     101             : 
     102        1760 : AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
     103             : {
     104             :     AVRational q;
     105             :     int j;
     106             : 
     107        1760 :     q = st->time_base;
     108             : 
     109       14080 :     for (j=2; j<14; j+= 1+(j>2))
     110       24759 :         while (q.den / q.num < min_precision && q.num % j == 0)
     111         119 :             q.num /= j;
     112       22849 :     while (q.den / q.num < min_precision && q.den < (1<<24))
     113       19329 :         q.den <<= 1;
     114             : 
     115        1760 :     return q;
     116             : }
     117             : 
     118          10 : enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
     119             : {
     120          10 :     AVCodecParameters *par = st->codecpar;
     121          10 :     const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
     122             : 
     123          10 :     if (par->chroma_location != AVCHROMA_LOC_UNSPECIFIED)
     124           5 :         return par->chroma_location;
     125             : 
     126           5 :     if (pix_desc) {
     127           5 :         if (pix_desc->log2_chroma_h == 0) {
     128           2 :             return AVCHROMA_LOC_TOPLEFT;
     129           3 :         } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
     130           3 :             if (par->field_order == AV_FIELD_UNKNOWN || par->field_order == AV_FIELD_PROGRESSIVE) {
     131           3 :                 switch (par->codec_id) {
     132           0 :                 case AV_CODEC_ID_MJPEG:
     133           0 :                 case AV_CODEC_ID_MPEG1VIDEO: return AVCHROMA_LOC_CENTER;
     134             :                 }
     135             :             }
     136           3 :             if (par->field_order == AV_FIELD_UNKNOWN || par->field_order != AV_FIELD_PROGRESSIVE) {
     137           0 :                 switch (par->codec_id) {
     138           0 :                 case AV_CODEC_ID_MPEG2VIDEO: return AVCHROMA_LOC_LEFT;
     139             :                 }
     140             :             }
     141             :         }
     142             :     }
     143             : 
     144           3 :     return AVCHROMA_LOC_UNSPECIFIED;
     145             : 
     146             : }
     147             : 
     148        5436 : int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
     149             :                                    const char *format, const char *filename)
     150             : {
     151        5436 :     AVFormatContext *s = avformat_alloc_context();
     152        5436 :     int ret = 0;
     153             : 
     154        5436 :     *avctx = NULL;
     155        5436 :     if (!s)
     156           0 :         goto nomem;
     157             : 
     158        5436 :     if (!oformat) {
     159        5416 :         if (format) {
     160        5258 :             oformat = av_guess_format(format, NULL, NULL);
     161        5258 :             if (!oformat) {
     162           0 :                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
     163           0 :                 ret = AVERROR(EINVAL);
     164           0 :                 goto error;
     165             :             }
     166             :         } else {
     167         158 :             oformat = av_guess_format(NULL, filename, NULL);
     168         158 :             if (!oformat) {
     169           0 :                 ret = AVERROR(EINVAL);
     170           0 :                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
     171             :                        filename);
     172           0 :                 goto error;
     173             :             }
     174             :         }
     175             :     }
     176             : 
     177        5436 :     s->oformat = oformat;
     178        5436 :     if (s->oformat->priv_data_size > 0) {
     179        3338 :         s->priv_data = av_mallocz(s->oformat->priv_data_size);
     180        3338 :         if (!s->priv_data)
     181           0 :             goto nomem;
     182        3338 :         if (s->oformat->priv_class) {
     183        3124 :             *(const AVClass**)s->priv_data= s->oformat->priv_class;
     184        3124 :             av_opt_set_defaults(s->priv_data);
     185             :         }
     186             :     } else
     187        2098 :         s->priv_data = NULL;
     188             : 
     189        5436 :     if (filename)
     190        5422 :         av_strlcpy(s->filename, filename, sizeof(s->filename));
     191        5436 :     *avctx = s;
     192        5436 :     return 0;
     193           0 : nomem:
     194           0 :     av_log(s, AV_LOG_ERROR, "Out of memory\n");
     195           0 :     ret = AVERROR(ENOMEM);
     196           0 : error:
     197           0 :     avformat_free_context(s);
     198           0 :     return ret;
     199             : }
     200             : 
     201        1731 : static int validate_codec_tag(AVFormatContext *s, AVStream *st)
     202             : {
     203             :     const AVCodecTag *avctag;
     204             :     int n;
     205        1731 :     enum AVCodecID id = AV_CODEC_ID_NONE;
     206        1731 :     int64_t tag  = -1;
     207             : 
     208             :     /**
     209             :      * Check that tag + id is in the table
     210             :      * If neither is in the table -> OK
     211             :      * If tag is in the table with another id -> FAIL
     212             :      * If id is in the table with another tag -> FAIL unless strict < normal
     213             :      */
     214        2394 :     for (n = 0; s->oformat->codec_tag[n]; n++) {
     215        2365 :         avctag = s->oformat->codec_tag[n];
     216      189331 :         while (avctag->id != AV_CODEC_ID_NONE) {
     217      186303 :             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codecpar->codec_tag)) {
     218        1702 :                 id = avctag->id;
     219        1702 :                 if (id == st->codecpar->codec_id)
     220        1702 :                     return 1;
     221             :             }
     222      184601 :             if (avctag->id == st->codecpar->codec_id)
     223      125789 :                 tag = avctag->tag;
     224      184601 :             avctag++;
     225             :         }
     226             :     }
     227          29 :     if (id != AV_CODEC_ID_NONE)
     228           0 :         return 0;
     229          29 :     if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
     230          25 :         return 0;
     231           4 :     return 1;
     232             : }
     233             : 
     234             : 
     235        5510 : static int init_muxer(AVFormatContext *s, AVDictionary **options)
     236             : {
     237        5510 :     int ret = 0, i;
     238             :     AVStream *st;
     239        5510 :     AVDictionary *tmp = NULL;
     240        5510 :     AVCodecParameters *par = NULL;
     241        5510 :     AVOutputFormat *of = s->oformat;
     242             :     const AVCodecDescriptor *desc;
     243             :     AVDictionaryEntry *e;
     244             : 
     245        5510 :     if (options)
     246        5510 :         av_dict_copy(&tmp, *options, 0);
     247             : 
     248        5510 :     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
     249           0 :         goto fail;
     250        8634 :     if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
     251        3124 :         (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
     252           0 :         goto fail;
     253             : 
     254             : #if FF_API_LAVF_AVCTX
     255             : FF_DISABLE_DEPRECATION_WARNINGS
     256        5510 :     if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) {
     257        4457 :         if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
     258          12 :             av_log(s, AV_LOG_WARNING,
     259             :                    "The AVFormatContext is not in set to bitexact mode, only "
     260             :                    "the AVCodecContext. If this is not intended, set "
     261             :                    "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
     262             :         }
     263             :     }
     264             : FF_ENABLE_DEPRECATION_WARNINGS
     265             : #endif
     266             : 
     267             :     // some sanity checks
     268        5510 :     if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
     269           0 :         av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
     270           0 :         ret = AVERROR(EINVAL);
     271           0 :         goto fail;
     272             :     }
     273             : 
     274       11188 :     for (i = 0; i < s->nb_streams; i++) {
     275        5678 :         st  = s->streams[i];
     276        5678 :         par = st->codecpar;
     277             : 
     278             : #if FF_API_LAVF_AVCTX
     279             : FF_DISABLE_DEPRECATION_WARNINGS
     280        5731 :         if (st->codecpar->codec_type == AVMEDIA_TYPE_UNKNOWN &&
     281          53 :             st->codec->codec_type    != AVMEDIA_TYPE_UNKNOWN) {
     282           0 :             av_log(s, AV_LOG_WARNING, "Using AVStream.codec to pass codec "
     283             :                    "parameters to muxers is deprecated, use AVStream.codecpar "
     284             :                    "instead.\n");
     285           0 :             ret = avcodec_parameters_from_context(st->codecpar, st->codec);
     286           0 :             if (ret < 0)
     287           0 :                 goto fail;
     288             :         }
     289             : FF_ENABLE_DEPRECATION_WARNINGS
     290             : #endif
     291             : 
     292        5678 :         if (!st->time_base.num) {
     293             :             /* fall back on the default timebase values */
     294           5 :             if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
     295           0 :                 avpriv_set_pts_info(st, 64, 1, par->sample_rate);
     296             :             else
     297           5 :                 avpriv_set_pts_info(st, 33, 1, 90000);
     298             :         }
     299             : 
     300        5678 :         switch (par->codec_type) {
     301        1193 :         case AVMEDIA_TYPE_AUDIO:
     302        1193 :             if (par->sample_rate <= 0) {
     303           0 :                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
     304           0 :                 ret = AVERROR(EINVAL);
     305           0 :                 goto fail;
     306             :             }
     307        1193 :             if (!par->block_align)
     308         567 :                 par->block_align = par->channels *
     309         378 :                                    av_get_bits_per_sample(par->codec_id) >> 3;
     310        1193 :             break;
     311        4385 :         case AVMEDIA_TYPE_VIDEO:
     312        4385 :             if ((par->width <= 0 || par->height <= 0) &&
     313           0 :                 !(of->flags & AVFMT_NODIMENSIONS)) {
     314           0 :                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
     315           0 :                 ret = AVERROR(EINVAL);
     316           0 :                 goto fail;
     317             :             }
     318        4385 :             if (av_cmp_q(st->sample_aspect_ratio, par->sample_aspect_ratio)
     319           0 :                 && fabs(av_q2d(st->sample_aspect_ratio) - av_q2d(par->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
     320             :             ) {
     321           0 :                 if (st->sample_aspect_ratio.num != 0 &&
     322           0 :                     st->sample_aspect_ratio.den != 0 &&
     323           0 :                     par->sample_aspect_ratio.num != 0 &&
     324           0 :                     par->sample_aspect_ratio.den != 0) {
     325           0 :                     av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
     326             :                            "(%d/%d) and encoder layer (%d/%d)\n",
     327             :                            st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
     328             :                            par->sample_aspect_ratio.num,
     329             :                            par->sample_aspect_ratio.den);
     330           0 :                     ret = AVERROR(EINVAL);
     331           0 :                     goto fail;
     332             :                 }
     333             :             }
     334        4385 :             break;
     335             :         }
     336             : 
     337        5678 :         desc = avcodec_descriptor_get(par->codec_id);
     338        5678 :         if (desc && desc->props & AV_CODEC_PROP_REORDER)
     339         251 :             st->internal->reorder = 1;
     340             : 
     341        5678 :         if (of->codec_tag) {
     342        2764 :             if (   par->codec_tag
     343        1727 :                 && par->codec_id == AV_CODEC_ID_RAWVIDEO
     344        1691 :                 && (   av_codec_get_tag(of->codec_tag, par->codec_id) == 0
     345        1674 :                     || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
     346          29 :                 && !validate_codec_tag(s, st)) {
     347             :                 // the current rawvideo encoding system ends up setting
     348             :                 // the wrong codec_tag for avi/mov, we override it here
     349          25 :                 par->codec_tag = 0;
     350             :             }
     351        2764 :             if (par->codec_tag) {
     352        1702 :                 if (!validate_codec_tag(s, st)) {
     353           0 :                     const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
     354           0 :                     av_log(s, AV_LOG_ERROR,
     355             :                            "Tag %s incompatible with output codec id '%d' (%s)\n",
     356           0 :                            av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
     357           0 :                     ret = AVERROR_INVALIDDATA;
     358           0 :                     goto fail;
     359             :                 }
     360             :             } else
     361        1062 :                 par->codec_tag = av_codec_get_tag(of->codec_tag, par->codec_id);
     362             :         }
     363             : 
     364        5678 :         if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT)
     365        5677 :             s->internal->nb_interleaved_streams++;
     366             :     }
     367             : 
     368        5510 :     if (!s->priv_data && of->priv_data_size > 0) {
     369          74 :         s->priv_data = av_mallocz(of->priv_data_size);
     370          74 :         if (!s->priv_data) {
     371           0 :             ret = AVERROR(ENOMEM);
     372           0 :             goto fail;
     373             :         }
     374          74 :         if (of->priv_class) {
     375          74 :             *(const AVClass **)s->priv_data = of->priv_class;
     376          74 :             av_opt_set_defaults(s->priv_data);
     377          74 :             if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
     378           0 :                 goto fail;
     379             :         }
     380             :     }
     381             : 
     382             :     /* set muxer identification string */
     383        5510 :     if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
     384         928 :         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
     385             :     } else {
     386        4582 :         av_dict_set(&s->metadata, "encoder", NULL, 0);
     387             :     }
     388             : 
     389       11023 :     for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
     390           3 :         av_dict_set(&s->metadata, e->key, NULL, 0);
     391             :     }
     392             : 
     393        5510 :     if (options) {
     394        5510 :          av_dict_free(options);
     395        5510 :          *options = tmp;
     396             :     }
     397             : 
     398        5510 :     if (s->oformat->init) {
     399         453 :         if ((ret = s->oformat->init(s)) < 0) {
     400           0 :             if (s->oformat->deinit)
     401           0 :                 s->oformat->deinit(s);
     402           0 :             return ret;
     403             :         }
     404         453 :         return ret == 0;
     405             :     }
     406             : 
     407        5057 :     return 0;
     408             : 
     409           0 : fail:
     410           0 :     av_dict_free(&tmp);
     411           0 :     return ret;
     412             : }
     413             : 
     414        5510 : static int init_pts(AVFormatContext *s)
     415             : {
     416             :     int i;
     417             :     AVStream *st;
     418             : 
     419             :     /* init PTS generation */
     420       11188 :     for (i = 0; i < s->nb_streams; i++) {
     421        5678 :         int64_t den = AV_NOPTS_VALUE;
     422        5678 :         st = s->streams[i];
     423             : 
     424        5678 :         switch (st->codecpar->codec_type) {
     425        1193 :         case AVMEDIA_TYPE_AUDIO:
     426        1193 :             den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
     427        1193 :             break;
     428        4385 :         case AVMEDIA_TYPE_VIDEO:
     429        4385 :             den = (int64_t)st->time_base.num * st->time_base.den;
     430        4385 :             break;
     431         100 :         default:
     432         100 :             break;
     433             :         }
     434             : 
     435        5678 :         if (!st->internal->priv_pts)
     436        5633 :             st->internal->priv_pts = av_mallocz(sizeof(*st->internal->priv_pts));
     437        5678 :         if (!st->internal->priv_pts)
     438           0 :             return AVERROR(ENOMEM);
     439             : 
     440        5678 :         if (den != AV_NOPTS_VALUE) {
     441        5578 :             if (den <= 0)
     442           0 :                 return AVERROR_INVALIDDATA;
     443             : 
     444        5578 :             frac_init(st->internal->priv_pts, 0, 0, den);
     445             :         }
     446             :     }
     447             : 
     448        5510 :     if (s->avoid_negative_ts < 0) {
     449             :         av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
     450        3658 :         if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
     451        2812 :             s->avoid_negative_ts = 0;
     452             :         } else
     453         846 :             s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;
     454             :     }
     455             : 
     456        5510 :     return 0;
     457             : }
     458             : 
     459      423968 : static void flush_if_needed(AVFormatContext *s)
     460             : {
     461      423968 :     if (s->pb && s->pb->error >= 0) {
     462      423868 :         if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
     463           0 :             avio_flush(s->pb);
     464      423868 :         else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
     465      423868 :             avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
     466             :     }
     467      423968 : }
     468             : 
     469        5510 : int avformat_init_output(AVFormatContext *s, AVDictionary **options)
     470             : {
     471        5510 :     int ret = 0;
     472             : 
     473        5510 :     if ((ret = init_muxer(s, options)) < 0)
     474           0 :         return ret;
     475             : 
     476        5510 :     s->internal->initialized = 1;
     477        5510 :     s->internal->streams_initialized = ret;
     478             : 
     479        5510 :     if (s->oformat->init && ret) {
     480         189 :         if ((ret = init_pts(s)) < 0)
     481           0 :             return ret;
     482             : 
     483         189 :         return AVSTREAM_INIT_IN_INIT_OUTPUT;
     484             :     }
     485             : 
     486        5321 :     return AVSTREAM_INIT_IN_WRITE_HEADER;
     487             : }
     488             : 
     489        5510 : int avformat_write_header(AVFormatContext *s, AVDictionary **options)
     490             : {
     491        5510 :     int ret = 0;
     492        5510 :     int already_initialized = s->internal->initialized;
     493        5510 :     int streams_already_initialized = s->internal->streams_initialized;
     494             : 
     495        5510 :     if (!already_initialized)
     496        5505 :         if ((ret = avformat_init_output(s, options)) < 0)
     497           0 :             return ret;
     498             : 
     499        5510 :     if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
     500        5412 :         avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_HEADER);
     501        5510 :     if (s->oformat->write_header) {
     502        4746 :         ret = s->oformat->write_header(s);
     503        4746 :         if (ret >= 0 && s->pb && s->pb->error < 0)
     504           0 :             ret = s->pb->error;
     505        4746 :         if (ret < 0)
     506           0 :             goto fail;
     507        4746 :         flush_if_needed(s);
     508             :     }
     509        5510 :     if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
     510        5412 :         avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_UNKNOWN);
     511             : 
     512        5510 :     if (!s->internal->streams_initialized) {
     513        5321 :         if ((ret = init_pts(s)) < 0)
     514           0 :             goto fail;
     515             :     }
     516             : 
     517        5510 :     return streams_already_initialized;
     518             : 
     519           0 : fail:
     520           0 :     if (s->oformat->deinit)
     521           0 :         s->oformat->deinit(s);
     522           0 :     return ret;
     523             : }
     524             : 
     525             : #define AV_PKT_FLAG_UNCODED_FRAME 0x2000
     526             : 
     527             : /* Note: using sizeof(AVFrame) from outside lavu is unsafe in general, but
     528             :    it is only being used internally to this file as a consistency check.
     529             :    The value is chosen to be very unlikely to appear on its own and to cause
     530             :    immediate failure if used anywhere as a real size. */
     531             : #define UNCODED_FRAME_PACKET_SIZE (INT_MIN / 3 * 2 + (int)sizeof(AVFrame))
     532             : 
     533             : 
     534             : #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
     535             : FF_DISABLE_DEPRECATION_WARNINGS
     536             : //FIXME merge with compute_pkt_fields
     537      422676 : static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
     538             : {
     539      422676 :     int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
     540             :     int num, den, i;
     541             :     int frame_size;
     542             : 
     543      821718 :     if (!s->internal->missing_ts_warning &&
     544      561880 :         !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
     545      325676 :         (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC) || (st->disposition & AV_DISPOSITION_TIMED_THUMBNAILS)) &&
     546      325353 :         (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
     547         321 :         av_log(s, AV_LOG_WARNING,
     548             :                "Timestamps are unset in a packet for stream %d. "
     549             :                "This is deprecated and will stop working in the future. "
     550             :                "Fix your code to set the timestamps properly\n", st->index);
     551         321 :         s->internal->missing_ts_warning = 1;
     552             :     }
     553             : 
     554      422676 :     if (s->debug & FF_FDEBUG_TS)
     555           0 :         av_log(s, AV_LOG_TRACE, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
     556           0 :             av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
     557             : 
     558      422676 :     if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
     559           1 :         av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
     560             :                pkt->duration, pkt->stream_index);
     561           1 :         pkt->duration = 0;
     562             :     }
     563             : 
     564             :     /* duration field */
     565      422676 :     if (pkt->duration == 0) {
     566       88015 :         ff_compute_frame_duration(s, &num, &den, st, NULL, pkt);
     567       88015 :         if (den && num) {
     568       87139 :             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
     569             :         }
     570             :     }
     571             : 
     572      422676 :     if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
     573        2153 :         pkt->pts = pkt->dts;
     574             : 
     575             :     //XXX/FIXME this is a temporary hack until all encoders output pts
     576      422676 :     if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
     577             :         static int warned;
     578       23328 :         if (!warned) {
     579         311 :             av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
     580         311 :             warned = 1;
     581             :         }
     582       23328 :         pkt->dts =
     583             : //        pkt->pts= st->cur_dts;
     584       23328 :             pkt->pts = st->internal->priv_pts->val;
     585             :     }
     586             : 
     587             :     //calculate dts from pts
     588      422676 :     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
     589           0 :         st->pts_buffer[0] = pkt->pts;
     590           0 :         for (i = 1; i < delay + 1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
     591           0 :             st->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
     592           0 :         for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
     593           0 :             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
     594             : 
     595           0 :         pkt->dts = st->pts_buffer[0];
     596             :     }
     597             : 
     598      835914 :     if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
     599      692537 :         ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
     600      558587 :           st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE &&
     601      558568 :           st->codecpar->codec_type != AVMEDIA_TYPE_DATA &&
     602      692443 :           st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
     603         225 :         av_log(s, AV_LOG_ERROR,
     604             :                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
     605         150 :                st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
     606          75 :         return AVERROR(EINVAL);
     607             :     }
     608      422601 :     if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
     609           0 :         av_log(s, AV_LOG_ERROR,
     610             :                "pts (%s) < dts (%s) in stream %d\n",
     611           0 :                av_ts2str(pkt->pts), av_ts2str(pkt->dts),
     612             :                st->index);
     613           0 :         return AVERROR(EINVAL);
     614             :     }
     615             : 
     616      422601 :     if (s->debug & FF_FDEBUG_TS)
     617           0 :         av_log(s, AV_LOG_TRACE, "av_write_frame: pts2:%s dts2:%s\n",
     618           0 :             av_ts2str(pkt->pts), av_ts2str(pkt->dts));
     619             : 
     620      422601 :     st->cur_dts = pkt->dts;
     621      422601 :     st->internal->priv_pts->val = pkt->dts;
     622             : 
     623             :     /* update pts */
     624      422601 :     switch (st->codecpar->codec_type) {
     625      315132 :     case AVMEDIA_TYPE_AUDIO:
     626      630264 :         frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
     627      630264 :                      ((AVFrame *)pkt->data)->nb_samples :
     628      315132 :                      av_get_audio_frame_duration(st->codec, pkt->size);
     629             : 
     630             :         /* HACK/FIXME, we skip the initial 0 size packets as they are most
     631             :          * likely equal to the encoder delay, but it would be better if we
     632             :          * had the real timestamps from the encoder */
     633      315132 :         if (frame_size >= 0 && (pkt->size || st->internal->priv_pts->num != st->internal->priv_pts->den >> 1 || st->internal->priv_pts->val)) {
     634      315132 :             frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * frame_size);
     635             :         }
     636      315132 :         break;
     637      106203 :     case AVMEDIA_TYPE_VIDEO:
     638      106203 :         frac_add(st->internal->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
     639      106203 :         break;
     640             :     }
     641      422601 :     return 0;
     642             : }
     643             : FF_ENABLE_DEPRECATION_WARNINGS
     644             : #endif
     645             : 
     646             : /**
     647             :  * Make timestamps non negative, move side data from payload to internal struct, call muxer, and restore
     648             :  * sidedata.
     649             :  *
     650             :  * FIXME: this function should NEVER get undefined pts/dts beside when the
     651             :  * AVFMT_NOTIMESTAMPS is set.
     652             :  * Those additional safety checks should be dropped once the correct checks
     653             :  * are set in the callers.
     654             :  */
     655      422383 : static int write_packet(AVFormatContext *s, AVPacket *pkt)
     656             : {
     657             :     int ret;
     658             :     int64_t pts_backup, dts_backup;
     659             : 
     660      422383 :     pts_backup = pkt->pts;
     661      422383 :     dts_backup = pkt->dts;
     662             : 
     663             :     // If the timestamp offsetting below is adjusted, adjust
     664             :     // ff_interleaved_peek similarly.
     665      422383 :     if (s->output_ts_offset) {
     666           0 :         AVStream *st = s->streams[pkt->stream_index];
     667           0 :         int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
     668             : 
     669           0 :         if (pkt->dts != AV_NOPTS_VALUE)
     670           0 :             pkt->dts += offset;
     671           0 :         if (pkt->pts != AV_NOPTS_VALUE)
     672           0 :             pkt->pts += offset;
     673             :     }
     674             : 
     675      422383 :     if (s->avoid_negative_ts > 0) {
     676       97421 :         AVStream *st = s->streams[pkt->stream_index];
     677       97421 :         int64_t offset = st->mux_ts_offset;
     678       97421 :         int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
     679             : 
     680       97421 :         if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
     681       90291 :             (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
     682          56 :             s->internal->offset = -ts;
     683          56 :             s->internal->offset_timebase = st->time_base;
     684             :         }
     685             : 
     686       97421 :         if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
     687        1023 :             offset = st->mux_ts_offset =
     688        1023 :                 av_rescale_q_rnd(s->internal->offset,
     689        1023 :                                  s->internal->offset_timebase,
     690             :                                  st->time_base,
     691             :                                  AV_ROUND_UP);
     692             :         }
     693             : 
     694       97421 :         if (pkt->dts != AV_NOPTS_VALUE)
     695       97421 :             pkt->dts += offset;
     696       97421 :         if (pkt->pts != AV_NOPTS_VALUE)
     697       97330 :             pkt->pts += offset;
     698             : 
     699       97421 :         if (s->internal->avoid_negative_ts_use_pts) {
     700         327 :             if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
     701           0 :                 av_log(s, AV_LOG_WARNING, "failed to avoid negative "
     702             :                     "pts %s in stream %d.\n"
     703             :                     "Try -avoid_negative_ts 1 as a possible workaround.\n",
     704           0 :                     av_ts2str(pkt->pts),
     705             :                     pkt->stream_index
     706             :                 );
     707             :             }
     708             :         } else {
     709             :             av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
     710       97094 :             if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
     711           0 :                 av_log(s, AV_LOG_WARNING,
     712             :                     "Packets poorly interleaved, failed to avoid negative "
     713             :                     "timestamp %s in stream %d.\n"
     714             :                     "Try -max_interleave_delta 0 as a possible workaround.\n",
     715           0 :                     av_ts2str(pkt->dts),
     716             :                     pkt->stream_index
     717             :                 );
     718             :             }
     719             :         }
     720             :     }
     721             : 
     722      422383 :     if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
     723           0 :         AVFrame *frame = (AVFrame *)pkt->data;
     724           0 :         av_assert0(pkt->size == UNCODED_FRAME_PACKET_SIZE);
     725           0 :         ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, &frame, 0);
     726           0 :         av_frame_free(&frame);
     727             :     } else {
     728      422383 :         ret = s->oformat->write_packet(s, pkt);
     729             :     }
     730             : 
     731      422383 :     if (s->pb && ret >= 0) {
     732      419174 :         flush_if_needed(s);
     733      419174 :         if (s->pb->error < 0)
     734           0 :             ret = s->pb->error;
     735             :     }
     736             : 
     737      422383 :     if (ret < 0) {
     738          45 :         pkt->pts = pts_backup;
     739          45 :         pkt->dts = dts_backup;
     740             :     }
     741             : 
     742      422383 :     return ret;
     743             : }
     744             : 
     745      422724 : static int check_packet(AVFormatContext *s, AVPacket *pkt)
     746             : {
     747      422724 :     if (!pkt)
     748          48 :         return 0;
     749             : 
     750      422676 :     if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {
     751           0 :         av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",
     752             :                pkt->stream_index);
     753           0 :         return AVERROR(EINVAL);
     754             :     }
     755             : 
     756      422676 :     if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
     757           0 :         av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");
     758           0 :         return AVERROR(EINVAL);
     759             :     }
     760             : 
     761      422676 :     return 0;
     762             : }
     763             : 
     764      422724 : static int prepare_input_packet(AVFormatContext *s, AVPacket *pkt)
     765             : {
     766             :     int ret;
     767             : 
     768      422724 :     ret = check_packet(s, pkt);
     769      422724 :     if (ret < 0)
     770           0 :         return ret;
     771             : 
     772             : #if !FF_API_COMPUTE_PKT_FIELDS2 || !FF_API_LAVF_AVCTX
     773             :     /* sanitize the timestamps */
     774             :     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
     775             :         AVStream *st = s->streams[pkt->stream_index];
     776             : 
     777             :         /* when there is no reordering (so dts is equal to pts), but
     778             :          * only one of them is set, set the other as well */
     779             :         if (!st->internal->reorder) {
     780             :             if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
     781             :                 pkt->pts = pkt->dts;
     782             :             if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
     783             :                 pkt->dts = pkt->pts;
     784             :         }
     785             : 
     786             :         /* check that the timestamps are set */
     787             :         if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
     788             :             av_log(s, AV_LOG_ERROR,
     789             :                    "Timestamps are unset in a packet for stream %d\n", st->index);
     790             :             return AVERROR(EINVAL);
     791             :         }
     792             : 
     793             :         /* check that the dts are increasing (or at least non-decreasing,
     794             :          * if the format allows it */
     795             :         if (st->cur_dts != AV_NOPTS_VALUE &&
     796             :             ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) ||
     797             :              st->cur_dts > pkt->dts)) {
     798             :             av_log(s, AV_LOG_ERROR,
     799             :                    "Application provided invalid, non monotonically increasing "
     800             :                    "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
     801             :                    st->index, st->cur_dts, pkt->dts);
     802             :             return AVERROR(EINVAL);
     803             :         }
     804             : 
     805             :         if (pkt->pts < pkt->dts) {
     806             :             av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
     807             :                    pkt->pts, pkt->dts, st->index);
     808             :             return AVERROR(EINVAL);
     809             :         }
     810             :     }
     811             : #endif
     812             : 
     813      422724 :     return 0;
     814             : }
     815             : 
     816      422676 : static int do_packet_auto_bsf(AVFormatContext *s, AVPacket *pkt) {
     817      422676 :     AVStream *st = s->streams[pkt->stream_index];
     818             :     int i, ret;
     819             : 
     820      422676 :     if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
     821        5939 :         return 1;
     822             : 
     823      416737 :     if (s->oformat->check_bitstream) {
     824       16836 :         if (!st->internal->bitstream_checked) {
     825         195 :             if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
     826           0 :                 return ret;
     827         195 :             else if (ret == 1)
     828         195 :                 st->internal->bitstream_checked = 1;
     829             :         }
     830             :     }
     831             : 
     832      417134 :     for (i = 0; i < st->internal->nb_bsfcs; i++) {
     833         397 :         AVBSFContext *ctx = st->internal->bsfcs[i];
     834             :         // TODO: when any bitstream filter requires flushing at EOF, we'll need to
     835             :         // flush each stream's BSF chain on write_trailer.
     836         397 :         if ((ret = av_bsf_send_packet(ctx, pkt)) < 0) {
     837           0 :             av_log(ctx, AV_LOG_ERROR,
     838             :                     "Failed to send packet to filter %s for stream %d\n",
     839           0 :                     ctx->filter->name, pkt->stream_index);
     840           0 :             return ret;
     841             :         }
     842             :         // TODO: when any automatically-added bitstream filter is generating multiple
     843             :         // output packets for a single input one, we'll need to call this in a loop
     844             :         // and write each output packet.
     845         397 :         if ((ret = av_bsf_receive_packet(ctx, pkt)) < 0) {
     846           0 :             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
     847           0 :                 return 0;
     848           0 :             av_log(ctx, AV_LOG_ERROR,
     849             :                     "Failed to send packet to filter %s for stream %d\n",
     850           0 :                     ctx->filter->name, pkt->stream_index);
     851           0 :             if (s->error_recognition & AV_EF_EXPLODE)
     852           0 :                 return ret;
     853           0 :             return 0;
     854             :         }
     855             :     }
     856      416737 :     return 1;
     857             : }
     858             : 
     859        7273 : int av_write_frame(AVFormatContext *s, AVPacket *pkt)
     860             : {
     861             :     int ret;
     862             : 
     863        7273 :     ret = prepare_input_packet(s, pkt);
     864        7273 :     if (ret < 0)
     865           0 :         return ret;
     866             : 
     867        7273 :     if (!pkt) {
     868          48 :         if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
     869          48 :             ret = s->oformat->write_packet(s, NULL);
     870          48 :             flush_if_needed(s);
     871          48 :             if (ret >= 0 && s->pb && s->pb->error < 0)
     872           0 :                 ret = s->pb->error;
     873          48 :             return ret;
     874             :         }
     875           0 :         return 1;
     876             :     }
     877             : 
     878        7225 :     ret = do_packet_auto_bsf(s, pkt);
     879        7225 :     if (ret <= 0)
     880           0 :         return ret;
     881             : 
     882             : #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
     883        7225 :     ret = compute_muxer_pkt_fields(s, s->streams[pkt->stream_index], pkt);
     884             : 
     885        7225 :     if (ret < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
     886           0 :         return ret;
     887             : #endif
     888             : 
     889        7225 :     ret = write_packet(s, pkt);
     890        7225 :     if (ret >= 0 && s->pb && s->pb->error < 0)
     891           0 :         ret = s->pb->error;
     892             : 
     893        7225 :     if (ret >= 0)
     894        7180 :         s->streams[pkt->stream_index]->nb_frames++;
     895        7225 :     return ret;
     896             : }
     897             : 
     898             : #define CHUNK_START 0x1000
     899             : 
     900      415171 : int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
     901             :                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
     902             : {
     903             :     int ret;
     904             :     AVPacketList **next_point, *this_pktl;
     905      415171 :     AVStream *st   = s->streams[pkt->stream_index];
     906      415171 :     int chunked    = s->max_chunk_size || s->max_chunk_duration;
     907             : 
     908      415171 :     this_pktl      = av_mallocz(sizeof(AVPacketList));
     909      415171 :     if (!this_pktl)
     910           0 :         return AVERROR(ENOMEM);
     911      415171 :     if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
     912           0 :         av_assert0(pkt->size == UNCODED_FRAME_PACKET_SIZE);
     913           0 :         av_assert0(((AVFrame *)pkt->data)->buf);
     914           0 :         this_pktl->pkt = *pkt;
     915           0 :         pkt->buf = NULL;
     916           0 :         pkt->side_data = NULL;
     917           0 :         pkt->side_data_elems = 0;
     918             :     } else {
     919      415171 :         if ((ret = av_packet_ref(&this_pktl->pkt, pkt)) < 0) {
     920           0 :             av_free(this_pktl);
     921           0 :             return ret;
     922             :         }
     923             :     }
     924             : 
     925      415171 :     if (s->streams[pkt->stream_index]->last_in_packet_buffer) {
     926        5534 :         next_point = &(st->last_in_packet_buffer->next);
     927             :     } else {
     928      409637 :         next_point = &s->internal->packet_buffer;
     929             :     }
     930             : 
     931      415171 :     if (chunked) {
     932           0 :         uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
     933           0 :         st->interleaver_chunk_size     += pkt->size;
     934           0 :         st->interleaver_chunk_duration += pkt->duration;
     935           0 :         if (   (s->max_chunk_size && st->interleaver_chunk_size > s->max_chunk_size)
     936           0 :             || (max && st->interleaver_chunk_duration           > max)) {
     937           0 :             st->interleaver_chunk_size      = 0;
     938           0 :             this_pktl->pkt.flags |= CHUNK_START;
     939           0 :             if (max && st->interleaver_chunk_duration > max) {
     940           0 :                 int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
     941           0 :                 int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
     942             : 
     943           0 :                 st->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
     944             :             } else
     945           0 :                 st->interleaver_chunk_duration = 0;
     946             :         }
     947             :     }
     948      415171 :     if (*next_point) {
     949        7797 :         if (chunked && !(this_pktl->pkt.flags & CHUNK_START))
     950           0 :             goto next_non_null;
     951             : 
     952        7797 :         if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) {
     953        9415 :             while (   *next_point
     954        6455 :                    && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
     955        6455 :                        || !compare(s, &(*next_point)->pkt, pkt)))
     956        3495 :                 next_point = &(*next_point)->next;
     957        2960 :             if (*next_point)
     958        2960 :                 goto next_non_null;
     959             :         } else {
     960        4837 :             next_point = &(s->internal->packet_buffer_end->next);
     961             :         }
     962             :     }
     963             :     av_assert1(!*next_point);
     964             : 
     965      412211 :     s->internal->packet_buffer_end = this_pktl;
     966      415171 : next_non_null:
     967             : 
     968      415171 :     this_pktl->next = *next_point;
     969             : 
     970      830342 :     s->streams[pkt->stream_index]->last_in_packet_buffer =
     971      830342 :         *next_point                                      = this_pktl;
     972             : 
     973      415171 :     av_packet_unref(pkt);
     974             : 
     975      415171 :     return 0;
     976             : }
     977             : 
     978       13673 : static int interleave_compare_dts(AVFormatContext *s, AVPacket *next,
     979             :                                   AVPacket *pkt)
     980             : {
     981       13673 :     AVStream *st  = s->streams[pkt->stream_index];
     982       13673 :     AVStream *st2 = s->streams[next->stream_index];
     983       13673 :     int comp      = av_compare_ts(next->dts, st2->time_base, pkt->dts,
     984             :                                   st->time_base);
     985       13673 :     if (s->audio_preload && ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))) {
     986           0 :         int64_t ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO);
     987           0 :         int64_t ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO);
     988           0 :         if (ts == ts2) {
     989           0 :             ts= ( pkt ->dts* st->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)* st->time_base.den)*st2->time_base.den
     990           0 :                -( next->dts*st2->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)*st2->time_base.den)* st->time_base.den;
     991           0 :             ts2=0;
     992             :         }
     993           0 :         comp= (ts>ts2) - (ts<ts2);
     994             :     }
     995             : 
     996       13673 :     if (comp == 0)
     997        1147 :         return pkt->stream_index < next->stream_index;
     998       12526 :     return comp > 0;
     999             : }
    1000             : 
    1001      835134 : int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
    1002             :                                  AVPacket *pkt, int flush)
    1003             : {
    1004             :     AVPacketList *pktl;
    1005      835134 :     int stream_count = 0;
    1006      835134 :     int noninterleaved_count = 0;
    1007             :     int i, ret;
    1008      835134 :     int eof = flush;
    1009             : 
    1010      835134 :     if (pkt) {
    1011      414667 :         if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0)
    1012           0 :             return ret;
    1013             :     }
    1014             : 
    1015     1696967 :     for (i = 0; i < s->nb_streams; i++) {
    1016      861833 :         if (s->streams[i]->last_in_packet_buffer) {
    1017      440469 :             ++stream_count;
    1018      842599 :         } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
    1019      841907 :                    s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP8 &&
    1020      420672 :                    s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP9) {
    1021      420619 :             ++noninterleaved_count;
    1022             :         }
    1023             :     }
    1024             : 
    1025      835134 :     if (s->internal->nb_interleaved_streams == stream_count)
    1026      414118 :         flush = 1;
    1027             : 
    1028     1669317 :     if (s->max_interleave_delta > 0 &&
    1029     1261606 :         s->internal->packet_buffer &&
    1030       13165 :         !flush &&
    1031       13165 :         s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
    1032             :     ) {
    1033       12808 :         AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
    1034       12808 :         int64_t delta_dts = INT64_MIN;
    1035       12808 :         int64_t top_dts = av_rescale_q(top_pkt->dts,
    1036       12808 :                                        s->streams[top_pkt->stream_index]->time_base,
    1037       12808 :                                        AV_TIME_BASE_Q);
    1038             : 
    1039       38547 :         for (i = 0; i < s->nb_streams; i++) {
    1040             :             int64_t last_dts;
    1041       25739 :             const AVPacketList *last = s->streams[i]->last_in_packet_buffer;
    1042             : 
    1043       25739 :             if (!last)
    1044       12905 :                 continue;
    1045             : 
    1046       12834 :             last_dts = av_rescale_q(last->pkt.dts,
    1047       12834 :                                     s->streams[i]->time_base,
    1048       12834 :                                     AV_TIME_BASE_Q);
    1049       12834 :             delta_dts = FFMAX(delta_dts, last_dts - top_dts);
    1050             :         }
    1051             : 
    1052       12808 :         if (delta_dts > s->max_interleave_delta) {
    1053          21 :             av_log(s, AV_LOG_DEBUG,
    1054             :                    "Delay between the first packet and last packet in the "
    1055             :                    "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
    1056             :                    delta_dts, s->max_interleave_delta);
    1057          21 :             flush = 1;
    1058             :         }
    1059             :     }
    1060             : 
    1061      835134 :     if (s->internal->packet_buffer &&
    1062         672 :         eof &&
    1063         672 :         (s->flags & AVFMT_FLAG_SHORTEST) &&
    1064           0 :         s->internal->shortest_end == AV_NOPTS_VALUE) {
    1065           0 :         AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
    1066             : 
    1067           0 :         s->internal->shortest_end = av_rescale_q(top_pkt->dts,
    1068           0 :                                        s->streams[top_pkt->stream_index]->time_base,
    1069           0 :                                        AV_TIME_BASE_Q);
    1070             :     }
    1071             : 
    1072      835134 :     if (s->internal->shortest_end != AV_NOPTS_VALUE) {
    1073           0 :         while (s->internal->packet_buffer) {
    1074           0 :             AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
    1075             :             AVStream *st;
    1076           0 :             int64_t top_dts = av_rescale_q(top_pkt->dts,
    1077           0 :                                         s->streams[top_pkt->stream_index]->time_base,
    1078           0 :                                         AV_TIME_BASE_Q);
    1079             : 
    1080           0 :             if (s->internal->shortest_end + 1 >= top_dts)
    1081           0 :                 break;
    1082             : 
    1083           0 :             pktl = s->internal->packet_buffer;
    1084           0 :             st   = s->streams[pktl->pkt.stream_index];
    1085             : 
    1086           0 :             s->internal->packet_buffer = pktl->next;
    1087           0 :             if (!s->internal->packet_buffer)
    1088           0 :                 s->internal->packet_buffer_end = NULL;
    1089             : 
    1090           0 :             if (st->last_in_packet_buffer == pktl)
    1091           0 :                 st->last_in_packet_buffer = NULL;
    1092             : 
    1093           0 :             av_packet_unref(&pktl->pkt);
    1094           0 :             av_freep(&pktl);
    1095           0 :             flush = 0;
    1096             :         }
    1097             :     }
    1098             : 
    1099      835134 :     if (stream_count && flush) {
    1100             :         AVStream *st;
    1101      414753 :         pktl = s->internal->packet_buffer;
    1102      414753 :         *out = pktl->pkt;
    1103      414753 :         st   = s->streams[out->stream_index];
    1104             : 
    1105      414753 :         s->internal->packet_buffer = pktl->next;
    1106      414753 :         if (!s->internal->packet_buffer)
    1107      401788 :             s->internal->packet_buffer_end = NULL;
    1108             : 
    1109      414753 :         if (st->last_in_packet_buffer == pktl)
    1110      409398 :             st->last_in_packet_buffer = NULL;
    1111      414753 :         av_freep(&pktl);
    1112             : 
    1113      414753 :         return 1;
    1114             :     } else {
    1115      420381 :         av_init_packet(out);
    1116      420381 :         return 0;
    1117             :     }
    1118             : }
    1119             : 
    1120         136 : int ff_interleaved_peek(AVFormatContext *s, int stream,
    1121             :                         AVPacket *pkt, int add_offset)
    1122             : {
    1123         136 :     AVPacketList *pktl = s->internal->packet_buffer;
    1124         288 :     while (pktl) {
    1125          21 :         if (pktl->pkt.stream_index == stream) {
    1126           5 :             *pkt = pktl->pkt;
    1127           5 :             if (add_offset) {
    1128           5 :                 AVStream *st = s->streams[pkt->stream_index];
    1129           5 :                 int64_t offset = st->mux_ts_offset;
    1130             : 
    1131           5 :                 if (s->output_ts_offset)
    1132           0 :                     offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
    1133             : 
    1134           5 :                 if (pkt->dts != AV_NOPTS_VALUE)
    1135           5 :                     pkt->dts += offset;
    1136           5 :                 if (pkt->pts != AV_NOPTS_VALUE)
    1137           5 :                     pkt->pts += offset;
    1138             :             }
    1139           5 :             return 0;
    1140             :         }
    1141          16 :         pktl = pktl->next;
    1142             :     }
    1143         131 :     return AVERROR(ENOENT);
    1144             : }
    1145             : 
    1146             : /**
    1147             :  * Interleave an AVPacket correctly so it can be muxed.
    1148             :  * @param out the interleaved packet will be output here
    1149             :  * @param in the input packet
    1150             :  * @param flush 1 if no further packets are available as input and all
    1151             :  *              remaining packets should be output
    1152             :  * @return 1 if a packet was output, 0 if no packet could be output,
    1153             :  *         < 0 if an error occurred
    1154             :  */
    1155      836119 : static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
    1156             : {
    1157      836119 :     if (s->oformat->interleave_packet) {
    1158        1289 :         int ret = s->oformat->interleave_packet(s, out, in, flush);
    1159        1289 :         if (in)
    1160         784 :             av_packet_unref(in);
    1161        1289 :         return ret;
    1162             :     } else
    1163      834830 :         return ff_interleave_packet_per_dts(s, out, in, flush);
    1164             : }
    1165             : 
    1166      415451 : int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
    1167             : {
    1168      415451 :     int ret, flush = 0;
    1169             : 
    1170      415451 :     ret = prepare_input_packet(s, pkt);
    1171      415451 :     if (ret < 0)
    1172           0 :         goto fail;
    1173             : 
    1174      415451 :     if (pkt) {
    1175      415451 :         AVStream *st = s->streams[pkt->stream_index];
    1176             : 
    1177      415451 :         ret = do_packet_auto_bsf(s, pkt);
    1178      415451 :         if (ret == 0)
    1179           0 :             return 0;
    1180      415451 :         else if (ret < 0)
    1181           0 :             goto fail;
    1182             : 
    1183      415451 :         if (s->debug & FF_FDEBUG_TS)
    1184           0 :             av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
    1185           0 :                 pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
    1186             : 
    1187             : #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
    1188      415451 :         if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
    1189           0 :             goto fail;
    1190             : #endif
    1191             : 
    1192      415451 :         if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
    1193           0 :             ret = AVERROR(EINVAL);
    1194           0 :             goto fail;
    1195             :         }
    1196             :     } else {
    1197           0 :         av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
    1198           0 :         flush = 1;
    1199             :     }
    1200             : 
    1201      414470 :     for (;; ) {
    1202             :         AVPacket opkt;
    1203      829921 :         int ret = interleave_packet(s, &opkt, pkt, flush);
    1204      829921 :         if (pkt) {
    1205      415451 :             memset(pkt, 0, sizeof(*pkt));
    1206      415451 :             av_init_packet(pkt);
    1207      415451 :             pkt = NULL;
    1208             :         }
    1209      829921 :         if (ret <= 0) //FIXME cleanup needed for ret<0 ?
    1210      830902 :             return ret;
    1211             : 
    1212      414470 :         ret = write_packet(s, &opkt);
    1213      414470 :         if (ret >= 0)
    1214      414470 :             s->streams[opkt.stream_index]->nb_frames++;
    1215             : 
    1216      414470 :         av_packet_unref(&opkt);
    1217             : 
    1218      414470 :         if (ret < 0)
    1219           0 :             return ret;
    1220      414470 :         if(s->pb && s->pb->error)
    1221           0 :             return s->pb->error;
    1222             :     }
    1223           0 : fail:
    1224           0 :     av_packet_unref(pkt);
    1225           0 :     return ret;
    1226             : }
    1227             : 
    1228        6198 : int av_write_trailer(AVFormatContext *s)
    1229             : {
    1230             :     int ret, i;
    1231             : 
    1232         688 :     for (;; ) {
    1233             :         AVPacket pkt;
    1234        6198 :         ret = interleave_packet(s, &pkt, NULL, 1);
    1235        6198 :         if (ret < 0)
    1236           0 :             goto fail;
    1237        6198 :         if (!ret)
    1238        5510 :             break;
    1239             : 
    1240         688 :         ret = write_packet(s, &pkt);
    1241         688 :         if (ret >= 0)
    1242         688 :             s->streams[pkt.stream_index]->nb_frames++;
    1243             : 
    1244         688 :         av_packet_unref(&pkt);
    1245             : 
    1246         688 :         if (ret < 0)
    1247           0 :             goto fail;
    1248         688 :         if(s->pb && s->pb->error)
    1249           0 :             goto fail;
    1250             :     }
    1251             : 
    1252        5510 : fail:
    1253        5510 :     if (s->oformat->write_trailer) {
    1254        3364 :         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
    1255        3303 :             avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);
    1256        3364 :         if (ret >= 0) {
    1257        3364 :         ret = s->oformat->write_trailer(s);
    1258             :         } else {
    1259           0 :             s->oformat->write_trailer(s);
    1260             :         }
    1261             :     }
    1262             : 
    1263        5510 :     if (s->oformat->deinit)
    1264        1997 :         s->oformat->deinit(s);
    1265             : 
    1266       11020 :     s->internal->initialized =
    1267       11020 :     s->internal->streams_initialized = 0;
    1268             : 
    1269        5510 :     if (s->pb)
    1270        5412 :        avio_flush(s->pb);
    1271        5510 :     if (ret == 0)
    1272        5510 :        ret = s->pb ? s->pb->error : 0;
    1273       11188 :     for (i = 0; i < s->nb_streams; i++) {
    1274        5678 :         av_freep(&s->streams[i]->priv_data);
    1275        5678 :         av_freep(&s->streams[i]->index_entries);
    1276             :     }
    1277        5510 :     if (s->oformat->priv_class)
    1278        3198 :         av_opt_free(s->priv_data);
    1279        5510 :     av_freep(&s->priv_data);
    1280        5510 :     return ret;
    1281             : }
    1282             : 
    1283           0 : int av_get_output_timestamp(struct AVFormatContext *s, int stream,
    1284             :                             int64_t *dts, int64_t *wall)
    1285             : {
    1286           0 :     if (!s->oformat || !s->oformat->get_output_timestamp)
    1287           0 :         return AVERROR(ENOSYS);
    1288           0 :     s->oformat->get_output_timestamp(s, stream, dts, wall);
    1289           0 :     return 0;
    1290             : }
    1291             : 
    1292        2561 : int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
    1293             :                      AVFormatContext *src, int interleave)
    1294             : {
    1295             :     AVPacket local_pkt;
    1296             :     int ret;
    1297             : 
    1298        2561 :     local_pkt = *pkt;
    1299        2561 :     local_pkt.stream_index = dst_stream;
    1300        2561 :     if (pkt->pts != AV_NOPTS_VALUE)
    1301        2561 :         local_pkt.pts = av_rescale_q(pkt->pts,
    1302        2561 :                                      src->streams[pkt->stream_index]->time_base,
    1303        2561 :                                      dst->streams[dst_stream]->time_base);
    1304        2561 :     if (pkt->dts != AV_NOPTS_VALUE)
    1305        2561 :         local_pkt.dts = av_rescale_q(pkt->dts,
    1306        2561 :                                      src->streams[pkt->stream_index]->time_base,
    1307        2561 :                                      dst->streams[dst_stream]->time_base);
    1308        2561 :     if (pkt->duration)
    1309        2561 :         local_pkt.duration = av_rescale_q(pkt->duration,
    1310        2561 :                                           src->streams[pkt->stream_index]->time_base,
    1311        2561 :                                           dst->streams[dst_stream]->time_base);
    1312             : 
    1313        2561 :     if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
    1314        2561 :     else            ret = av_write_frame(dst, &local_pkt);
    1315        2561 :     pkt->buf = local_pkt.buf;
    1316        2561 :     pkt->side_data       = local_pkt.side_data;
    1317        2561 :     pkt->side_data_elems = local_pkt.side_data_elems;
    1318        2561 :     return ret;
    1319             : }
    1320             : 
    1321           0 : static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
    1322             :                                            AVFrame *frame, int interleaved)
    1323             : {
    1324             :     AVPacket pkt, *pktp;
    1325             : 
    1326           0 :     av_assert0(s->oformat);
    1327           0 :     if (!s->oformat->write_uncoded_frame)
    1328           0 :         return AVERROR(ENOSYS);
    1329             : 
    1330           0 :     if (!frame) {
    1331           0 :         pktp = NULL;
    1332             :     } else {
    1333           0 :         pktp = &pkt;
    1334           0 :         av_init_packet(&pkt);
    1335           0 :         pkt.data = (void *)frame;
    1336           0 :         pkt.size         = UNCODED_FRAME_PACKET_SIZE;
    1337           0 :         pkt.pts          =
    1338           0 :         pkt.dts          = frame->pts;
    1339           0 :         pkt.duration     = frame->pkt_duration;
    1340           0 :         pkt.stream_index = stream_index;
    1341           0 :         pkt.flags |= AV_PKT_FLAG_UNCODED_FRAME;
    1342             :     }
    1343             : 
    1344           0 :     return interleaved ? av_interleaved_write_frame(s, pktp) :
    1345             :                          av_write_frame(s, pktp);
    1346             : }
    1347             : 
    1348           0 : int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
    1349             :                            AVFrame *frame)
    1350             : {
    1351           0 :     return av_write_uncoded_frame_internal(s, stream_index, frame, 0);
    1352             : }
    1353             : 
    1354           0 : int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index,
    1355             :                                        AVFrame *frame)
    1356             : {
    1357           0 :     return av_write_uncoded_frame_internal(s, stream_index, frame, 1);
    1358             : }
    1359             : 
    1360           0 : int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
    1361             : {
    1362           0 :     av_assert0(s->oformat);
    1363           0 :     if (!s->oformat->write_uncoded_frame)
    1364           0 :         return AVERROR(ENOSYS);
    1365           0 :     return s->oformat->write_uncoded_frame(s, stream_index, NULL,
    1366             :                                            AV_WRITE_UNCODED_FRAME_QUERY);
    1367             : }

Generated by: LCOV version 1.13