first commit

Sources/ffmpeg/ffmpeg_enc.c

@@ -0,0 +1,888 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <math.h>
+#include <stdint.h>
+
+#include "ffmpeg.h"
+
+#include "libavutil/avassert.h"
+#include "libavutil/avstring.h"
+#include "libavutil/avutil.h"
+#include "libavutil/dict.h"
+#include "libavutil/display.h"
+#include "libavutil/eval.h"
+#include "libavutil/frame.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/log.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/rational.h"
+#include "libavutil/timestamp.h"
+
+#include "libavcodec/avcodec.h"
+
+#include "libavformat/avformat.h"
+
+struct Encoder {
+    AVFrame *sq_frame;
+
+    // packet for receiving encoded output
+    AVPacket *pkt;
+
+    // combined size of all the packets received from the encoder
+    uint64_t data_size;
+
+    // number of packets received from the encoder
+    uint64_t packets_encoded;
+
+    int opened;
+};
+
+void enc_free(Encoder **penc)
+{
+    Encoder *enc = *penc;
+
+    if (!enc)
+        return;
+
+    av_frame_free(&enc->sq_frame);
+
+    av_packet_free(&enc->pkt);
+
+    av_freep(penc);
+}
+
+int enc_alloc(Encoder **penc, const AVCodec *codec)
+{
+    Encoder *enc;
+
+    *penc = NULL;
+
+    enc = av_mallocz(sizeof(*enc));
+    if (!enc)
+        return AVERROR(ENOMEM);
+
+    enc->pkt = av_packet_alloc();
+    if (!enc->pkt)
+        goto fail;
+
+    *penc = enc;
+
+    return 0;
+fail:
+    enc_free(&enc);
+    return AVERROR(ENOMEM);
+}
+
+static int hw_device_setup_for_encode(OutputStream *ost, AVBufferRef *frames_ref)
+{
+    const AVCodecHWConfig *config;
+    HWDevice *dev = NULL;
+    int i;
+
+    if (frames_ref &&
+        ((AVHWFramesContext*)frames_ref->data)->format ==
+        ost->enc_ctx->pix_fmt) {
+        // Matching format, will try to use hw_frames_ctx.
+    } else {
+        frames_ref = NULL;
+    }
+
+    for (i = 0;; i++) {
+        config = avcodec_get_hw_config(ost->enc_ctx->codec, i);
+        if (!config)
+            break;
+
+        if (frames_ref &&
+            config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX &&
+            (config->pix_fmt == AV_PIX_FMT_NONE ||
+             config->pix_fmt == ost->enc_ctx->pix_fmt)) {
+            av_log(ost->enc_ctx, AV_LOG_VERBOSE, "Using input "
+                   "frames context (format %s) with %s encoder.\n",
+                   av_get_pix_fmt_name(ost->enc_ctx->pix_fmt),
+                   ost->enc_ctx->codec->name);
+            ost->enc_ctx->hw_frames_ctx = av_buffer_ref(frames_ref);
+            if (!ost->enc_ctx->hw_frames_ctx)
+                return AVERROR(ENOMEM);
+            return 0;
+        }
+
+        if (!dev &&
+            config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX)
+            dev = hw_device_get_by_type(config->device_type);
+    }
+
+    if (dev) {
+        av_log(ost->enc_ctx, AV_LOG_VERBOSE, "Using device %s "
+               "(type %s) with %s encoder.\n", dev->name,
+               av_hwdevice_get_type_name(dev->type), ost->enc_ctx->codec->name);
+        ost->enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
+        if (!ost->enc_ctx->hw_device_ctx)
+            return AVERROR(ENOMEM);
+    } else {
+        // No device required, or no device available.
+    }
+    return 0;
+}
+
+static int set_encoder_id(OutputFile *of, OutputStream *ost)
+{
+    const char *cname = ost->enc_ctx->codec->name;
+    uint8_t *encoder_string;
+    int encoder_string_len;
+
+    if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
+        return 0;
+
+    encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(cname) + 2;
+    encoder_string     = av_mallocz(encoder_string_len);
+    if (!encoder_string)
+        return AVERROR(ENOMEM);
+
+    if (!of->bitexact && !ost->bitexact)
+        av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
+    else
+        av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
+    av_strlcat(encoder_string, cname, encoder_string_len);
+    av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
+                AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
+
+    return 0;
+}
+
+int enc_open(OutputStream *ost, const AVFrame *frame)
+{
+    InputStream *ist = ost->ist;
+    Encoder              *e = ost->enc;
+    AVCodecContext *enc_ctx = ost->enc_ctx;
+    AVCodecContext *dec_ctx = NULL;
+    const AVCodec      *enc = enc_ctx->codec;
+    OutputFile      *of = output_files[ost->file_index];
+    FrameData *fd;
+    int ret;
+
+    if (e->opened)
+        return 0;
+
+    // frame is always non-NULL for audio and video
+    av_assert0(frame || (enc->type != AVMEDIA_TYPE_VIDEO && enc->type != AVMEDIA_TYPE_AUDIO));
+
+    if (frame) {
+        av_assert0(frame->opaque_ref);
+        fd = (FrameData*)frame->opaque_ref->data;
+    }
+
+    ret = set_encoder_id(output_files[ost->file_index], ost);
+    if (ret < 0)
+        return ret;
+
+    if (ist) {
+        dec_ctx = ist->dec_ctx;
+    }
+
+    // the timebase is chosen by filtering code
+    if (ost->type == AVMEDIA_TYPE_AUDIO || ost->type == AVMEDIA_TYPE_VIDEO) {
+        enc_ctx->time_base      = frame->time_base;
+        enc_ctx->framerate      = fd->frame_rate_filter;
+        ost->st->avg_frame_rate = fd->frame_rate_filter;
+    }
+
+    switch (enc_ctx->codec_type) {
+    case AVMEDIA_TYPE_AUDIO:
+        enc_ctx->sample_fmt     = frame->format;
+        enc_ctx->sample_rate    = frame->sample_rate;
+        ret = av_channel_layout_copy(&enc_ctx->ch_layout, &frame->ch_layout);
+        if (ret < 0)
+            return ret;
+
+        if (ost->bits_per_raw_sample)
+            enc_ctx->bits_per_raw_sample = ost->bits_per_raw_sample;
+        else
+            enc_ctx->bits_per_raw_sample = FFMIN(fd->bits_per_raw_sample,
+                                                 av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
+        break;
+
+    case AVMEDIA_TYPE_VIDEO: {
+        enc_ctx->width  = frame->width;
+        enc_ctx->height = frame->height;
+        enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
+            ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
+            av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
+            frame->sample_aspect_ratio;
+
+        enc_ctx->pix_fmt = frame->format;
+
+        if (ost->bits_per_raw_sample)
+            enc_ctx->bits_per_raw_sample = ost->bits_per_raw_sample;
+        else
+            enc_ctx->bits_per_raw_sample = FFMIN(fd->bits_per_raw_sample,
+                                                 av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
+
+        enc_ctx->color_range            = frame->color_range;
+        enc_ctx->color_primaries        = frame->color_primaries;
+        enc_ctx->color_trc              = frame->color_trc;
+        enc_ctx->colorspace             = frame->colorspace;
+        enc_ctx->chroma_sample_location = frame->chroma_location;
+
+        if (enc_ctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) ||
+            (frame->flags & AV_FRAME_FLAG_INTERLACED)
+#if FFMPEG_OPT_TOP
+            || ost->top_field_first >= 0
+#endif
+            ) {
+            int top_field_first =
+#if FFMPEG_OPT_TOP
+                ost->top_field_first >= 0 ?
+                ost->top_field_first :
+#endif
+                !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
+
+            if (enc->id == AV_CODEC_ID_MJPEG)
+                enc_ctx->field_order = top_field_first ? AV_FIELD_TT : AV_FIELD_BB;
+            else
+                enc_ctx->field_order = top_field_first ? AV_FIELD_TB : AV_FIELD_BT;
+        } else
+            enc_ctx->field_order = AV_FIELD_PROGRESSIVE;
+
+        break;
+        }
+    case AVMEDIA_TYPE_SUBTITLE:
+        if (ost->enc_timebase.num)
+            av_log(ost, AV_LOG_WARNING,
+                   "-enc_time_base not supported for subtitles, ignoring\n");
+        enc_ctx->time_base = AV_TIME_BASE_Q;
+
+        if (!enc_ctx->width) {
+            enc_ctx->width     = ost->ist->par->width;
+            enc_ctx->height    = ost->ist->par->height;
+        }
+        if (dec_ctx && dec_ctx->subtitle_header) {
+            /* ASS code assumes this buffer is null terminated so add extra byte. */
+            enc_ctx->subtitle_header = av_mallocz(dec_ctx->subtitle_header_size + 1);
+            if (!enc_ctx->subtitle_header)
+                return AVERROR(ENOMEM);
+            memcpy(enc_ctx->subtitle_header, dec_ctx->subtitle_header,
+                   dec_ctx->subtitle_header_size);
+            enc_ctx->subtitle_header_size = dec_ctx->subtitle_header_size;
+        }
+
+        break;
+    default:
+        av_assert0(0);
+        break;
+    }
+
+    if (ost->bitexact)
+        enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
+
+    if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
+        av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
+
+    if (enc->capabilities & AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE) {
+        ret = av_dict_set(&ost->encoder_opts, "flags", "+copy_opaque", AV_DICT_MULTIKEY);
+        if (ret < 0)
+            return ret;
+    }
+
+    av_dict_set(&ost->encoder_opts, "flags", "+frame_duration", AV_DICT_MULTIKEY);
+
+    ret = hw_device_setup_for_encode(ost, frame ? frame->hw_frames_ctx : NULL);
+    if (ret < 0) {
+        av_log(ost, AV_LOG_ERROR,
+               "Encoding hardware device setup failed: %s\n", av_err2str(ret));
+        return ret;
+    }
+
+    if ((ret = avcodec_open2(ost->enc_ctx, enc, &ost->encoder_opts)) < 0) {
+        if (ret != AVERROR_EXPERIMENTAL)
+            av_log(ost, AV_LOG_ERROR, "Error while opening encoder - maybe "
+                   "incorrect parameters such as bit_rate, rate, width or height.\n");
+        return ret;
+    }
+
+    e->opened = 1;
+
+    if (ost->sq_idx_encode >= 0) {
+        e->sq_frame = av_frame_alloc();
+        if (!e->sq_frame)
+            return AVERROR(ENOMEM);
+    }
+
+    if (ost->enc_ctx->frame_size) {
+        av_assert0(ost->sq_idx_encode >= 0);
+        sq_frame_samples(output_files[ost->file_index]->sq_encode,
+                         ost->sq_idx_encode, ost->enc_ctx->frame_size);
+    }
+
+    ret = check_avoptions(ost->encoder_opts);
+    if (ret < 0)
+        return ret;
+
+    if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000 &&
+        ost->enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
+        av_log(ost, AV_LOG_WARNING, "The bitrate parameter is set too low."
+                                    " It takes bits/s as argument, not kbits/s\n");
+
+    ret = avcodec_parameters_from_context(ost->par_in, ost->enc_ctx);
+    if (ret < 0) {
+        av_log(ost, AV_LOG_FATAL,
+               "Error initializing the output stream codec context.\n");
+        return ret;
+    }
+
+    /*
+     * Add global input side data. For now this is naive, and copies it
+     * from the input stream's global side data. All side data should
+     * really be funneled over AVFrame and libavfilter, then added back to
+     * packet side data, and then potentially using the first packet for
+     * global side data.
+     */
+    if (ist) {
+        int i;
+        for (i = 0; i < ist->st->codecpar->nb_coded_side_data; i++) {
+            AVPacketSideData *sd_src = &ist->st->codecpar->coded_side_data[i];
+            if (sd_src->type != AV_PKT_DATA_CPB_PROPERTIES) {
+                AVPacketSideData *sd_dst = av_packet_side_data_new(&ost->par_in->coded_side_data,
+                                                                   &ost->par_in->nb_coded_side_data,
+                                                                   sd_src->type, sd_src->size, 0);
+                if (!sd_dst)
+                    return AVERROR(ENOMEM);
+                memcpy(sd_dst->data, sd_src->data, sd_src->size);
+                if (ist->autorotate && sd_src->type == AV_PKT_DATA_DISPLAYMATRIX)
+                    av_display_rotation_set((int32_t *)sd_dst->data, 0);
+            }
+        }
+    }
+
+    // copy timebase while removing common factors
+    if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
+        ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
+
+    ret = of_stream_init(of, ost);
+    if (ret < 0)
+        return ret;
+
+    return 0;
+}
+
+static int check_recording_time(OutputStream *ost, int64_t ts, AVRational tb)
+{
+    OutputFile *of = output_files[ost->file_index];
+
+    if (of->recording_time != INT64_MAX &&
+        av_compare_ts(ts, tb, of->recording_time, AV_TIME_BASE_Q) >= 0) {
+        close_output_stream(ost);
+        return 0;
+    }
+    return 1;
+}
+
+int enc_subtitle(OutputFile *of, OutputStream *ost, const AVSubtitle *sub)
+{
+    Encoder *e = ost->enc;
+    int subtitle_out_max_size = 1024 * 1024;
+    int subtitle_out_size, nb, i, ret;
+    AVCodecContext *enc;
+    AVPacket *pkt = e->pkt;
+    int64_t pts;
+
+    if (sub->pts == AV_NOPTS_VALUE) {
+        av_log(ost, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
+        return exit_on_error ? AVERROR(EINVAL) : 0;
+    }
+    if (ost->finished ||
+        (of->start_time != AV_NOPTS_VALUE && sub->pts < of->start_time))
+        return 0;
+
+    enc = ost->enc_ctx;
+
+    /* Note: DVB subtitle need one packet to draw them and one other
+       packet to clear them */
+    /* XXX: signal it in the codec context ? */
+    if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
+        nb = 2;
+    else if (enc->codec_id == AV_CODEC_ID_ASS)
+        nb = FFMAX(sub->num_rects, 1);
+    else
+        nb = 1;
+
+    /* shift timestamp to honor -ss and make check_recording_time() work with -t */
+    pts = sub->pts;
+    if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
+        pts -= output_files[ost->file_index]->start_time;
+    for (i = 0; i < nb; i++) {
+        AVSubtitle local_sub = *sub;
+
+        if (!check_recording_time(ost, pts, AV_TIME_BASE_Q))
+            return 0;
+
+        ret = av_new_packet(pkt, subtitle_out_max_size);
+        if (ret < 0)
+            return AVERROR(ENOMEM);
+
+        local_sub.pts = pts;
+        // start_display_time is required to be 0
+        local_sub.pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
+        local_sub.end_display_time  -= sub->start_display_time;
+        local_sub.start_display_time = 0;
+
+        if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE && i == 1)
+            local_sub.num_rects = 0;
+        else if (enc->codec_id == AV_CODEC_ID_ASS && sub->num_rects > 0) {
+            local_sub.num_rects = 1;
+            local_sub.rects += i;
+        }
+
+        ost->frames_encoded++;
+
+        subtitle_out_size = avcodec_encode_subtitle(enc, pkt->data, pkt->size, &local_sub);
+        if (subtitle_out_size < 0) {
+            av_log(ost, AV_LOG_FATAL, "Subtitle encoding failed\n");
+            return subtitle_out_size;
+        }
+
+        av_shrink_packet(pkt, subtitle_out_size);
+        pkt->time_base = AV_TIME_BASE_Q;
+        pkt->pts       = sub->pts;
+        pkt->duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
+        if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
+            /* XXX: the pts correction is handled here. Maybe handling
+               it in the codec would be better */
+            if (i == 0)
+                pkt->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
+            else
+                pkt->pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
+        }
+        pkt->dts = pkt->pts;
+
+        ret = of_output_packet(of, ost, pkt);
+        if (ret < 0)
+            return ret;
+    }
+
+    return 0;
+}
+
+void enc_stats_write(OutputStream *ost, EncStats *es,
+                     const AVFrame *frame, const AVPacket *pkt,
+                     uint64_t frame_num)
+{
+    Encoder      *e = ost->enc;
+    AVIOContext *io = es->io;
+    AVRational   tb = frame ? frame->time_base : pkt->time_base;
+    int64_t     pts = frame ? frame->pts : pkt->pts;
+
+    AVRational  tbi = (AVRational){ 0, 1};
+    int64_t    ptsi = INT64_MAX;
+
+    const FrameData *fd;
+
+    if ((frame && frame->opaque_ref) || (pkt && pkt->opaque_ref)) {
+        fd   = (const FrameData*)(frame ? frame->opaque_ref->data : pkt->opaque_ref->data);
+        tbi  = fd->dec.tb;
+        ptsi = fd->dec.pts;
+    }
+
+    for (size_t i = 0; i < es->nb_components; i++) {
+        const EncStatsComponent *c = &es->components[i];
+
+        switch (c->type) {
+        case ENC_STATS_LITERAL:         avio_write (io, c->str,     c->str_len);                    continue;
+        case ENC_STATS_FILE_IDX:        avio_printf(io, "%d",       ost->file_index);               continue;
+        case ENC_STATS_STREAM_IDX:      avio_printf(io, "%d",       ost->index);                    continue;
+        case ENC_STATS_TIMEBASE:        avio_printf(io, "%d/%d",    tb.num, tb.den);                continue;
+        case ENC_STATS_TIMEBASE_IN:     avio_printf(io, "%d/%d",    tbi.num, tbi.den);              continue;
+        case ENC_STATS_PTS:             avio_printf(io, "%"PRId64,  pts);                           continue;
+        case ENC_STATS_PTS_IN:          avio_printf(io, "%"PRId64,  ptsi);                          continue;
+        case ENC_STATS_PTS_TIME:        avio_printf(io, "%g",       pts * av_q2d(tb));              continue;
+        case ENC_STATS_PTS_TIME_IN:     avio_printf(io, "%g",       ptsi == INT64_MAX ?
+                                                                    INFINITY : ptsi * av_q2d(tbi)); continue;
+        case ENC_STATS_FRAME_NUM:       avio_printf(io, "%"PRIu64,  frame_num);                     continue;
+        case ENC_STATS_FRAME_NUM_IN:    avio_printf(io, "%"PRIu64,  fd ? fd->dec.frame_num : -1);   continue;
+        }
+
+        if (frame) {
+            switch (c->type) {
+            case ENC_STATS_SAMPLE_NUM:  avio_printf(io, "%"PRIu64,  ost->samples_encoded);          continue;
+            case ENC_STATS_NB_SAMPLES:  avio_printf(io, "%d",       frame->nb_samples);             continue;
+            default: av_assert0(0);
+            }
+        } else {
+            switch (c->type) {
+            case ENC_STATS_DTS:         avio_printf(io, "%"PRId64,  pkt->dts);                      continue;
+            case ENC_STATS_DTS_TIME:    avio_printf(io, "%g",       pkt->dts * av_q2d(tb));         continue;
+            case ENC_STATS_PKT_SIZE:    avio_printf(io, "%d",       pkt->size);                     continue;
+            case ENC_STATS_BITRATE: {
+                double duration = FFMAX(pkt->duration, 1) * av_q2d(tb);
+                avio_printf(io, "%g",  8.0 * pkt->size / duration);
+                continue;
+            }
+            case ENC_STATS_AVG_BITRATE: {
+                double duration = pkt->dts * av_q2d(tb);
+                avio_printf(io, "%g",  duration > 0 ? 8.0 * e->data_size / duration : -1.);
+                continue;
+            }
+            default: av_assert0(0);
+            }
+        }
+    }
+    avio_w8(io, '\n');
+    avio_flush(io);
+}
+
+static inline double psnr(double d)
+{
+    return -10.0 * log10(d);
+}
+
+static int update_video_stats(OutputStream *ost, const AVPacket *pkt, int write_vstats)
+{
+    Encoder        *e = ost->enc;
+    const uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
+                                                NULL);
+    AVCodecContext *enc = ost->enc_ctx;
+    enum AVPictureType pict_type;
+    int64_t frame_number;
+    double ti1, bitrate, avg_bitrate;
+    double psnr_val = -1;
+
+    ost->quality   = sd ? AV_RL32(sd) : -1;
+    pict_type      = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
+
+    if ((enc->flags & AV_CODEC_FLAG_PSNR) && sd && sd[5]) {
+        // FIXME the scaling assumes 8bit
+        double error = AV_RL64(sd + 8) / (enc->width * enc->height * 255.0 * 255.0);
+        if (error >= 0 && error <= 1)
+            psnr_val = psnr(error);
+    }
+
+    if (!write_vstats)
+        return 0;
+
+    /* this is executed just the first time update_video_stats is called */
+    if (!vstats_file) {
+        vstats_file = fopen(vstats_filename, "w");
+        if (!vstats_file) {
+            perror("fopen");
+            return AVERROR(errno);
+        }
+    }
+
+    frame_number = e->packets_encoded;
+    if (vstats_version <= 1) {
+        fprintf(vstats_file, "frame= %5"PRId64" q= %2.1f ", frame_number,
+                ost->quality / (float)FF_QP2LAMBDA);
+    } else  {
+        fprintf(vstats_file, "out= %2d st= %2d frame= %5"PRId64" q= %2.1f ", ost->file_index, ost->index, frame_number,
+                ost->quality / (float)FF_QP2LAMBDA);
+    }
+
+    if (psnr_val >= 0)
+        fprintf(vstats_file, "PSNR= %6.2f ", psnr_val);
+
+    fprintf(vstats_file,"f_size= %6d ", pkt->size);
+    /* compute pts value */
+    ti1 = pkt->dts * av_q2d(pkt->time_base);
+    if (ti1 < 0.01)
+        ti1 = 0.01;
+
+    bitrate     = (pkt->size * 8) / av_q2d(enc->time_base) / 1000.0;
+    avg_bitrate = (double)(e->data_size * 8) / ti1 / 1000.0;
+    fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
+           (double)e->data_size / 1024, ti1, bitrate, avg_bitrate);
+    fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(pict_type));
+
+    return 0;
+}
+
+static int encode_frame(OutputFile *of, OutputStream *ost, AVFrame *frame)
+{
+    Encoder            *e = ost->enc;
+    AVCodecContext   *enc = ost->enc_ctx;
+    AVPacket         *pkt = e->pkt;
+    const char *type_desc = av_get_media_type_string(enc->codec_type);
+    const char    *action = frame ? "encode" : "flush";
+    int ret;
+
+    if (frame) {
+        if (ost->enc_stats_pre.io)
+            enc_stats_write(ost, &ost->enc_stats_pre, frame, NULL,
+                            ost->frames_encoded);
+
+        ost->frames_encoded++;
+        ost->samples_encoded += frame->nb_samples;
+
+        if (debug_ts) {
+            av_log(ost, AV_LOG_INFO, "encoder <- type:%s "
+                   "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
+                   type_desc,
+                   av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
+                   enc->time_base.num, enc->time_base.den);
+        }
+
+        if (frame->sample_aspect_ratio.num && !ost->frame_aspect_ratio.num)
+            enc->sample_aspect_ratio = frame->sample_aspect_ratio;
+    }
+
+    update_benchmark(NULL);
+
+    ret = avcodec_send_frame(enc, frame);
+    if (ret < 0 && !(ret == AVERROR_EOF && !frame)) {
+        av_log(ost, AV_LOG_ERROR, "Error submitting %s frame to the encoder\n",
+               type_desc);
+        return ret;
+    }
+
+    while (1) {
+        av_packet_unref(pkt);
+
+        ret = avcodec_receive_packet(enc, pkt);
+        update_benchmark("%s_%s %d.%d", action, type_desc,
+                         ost->file_index, ost->index);
+
+        pkt->time_base = enc->time_base;
+
+        /* if two pass, output log on success and EOF */
+        if ((ret >= 0 || ret == AVERROR_EOF) && ost->logfile && enc->stats_out)
+            fprintf(ost->logfile, "%s", enc->stats_out);
+
+        if (ret == AVERROR(EAGAIN)) {
+            av_assert0(frame); // should never happen during flushing
+            return 0;
+        } else if (ret == AVERROR_EOF) {
+            ret = of_output_packet(of, ost, NULL);
+            return ret < 0 ? ret : AVERROR_EOF;
+        } else if (ret < 0) {
+            av_log(ost, AV_LOG_ERROR, "%s encoding failed\n", type_desc);
+            return ret;
+        }
+
+        if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
+            ret = update_video_stats(ost, pkt, !!vstats_filename);
+            if (ret < 0)
+                return ret;
+        }
+
+        if (ost->enc_stats_post.io)
+            enc_stats_write(ost, &ost->enc_stats_post, NULL, pkt,
+                            e->packets_encoded);
+
+        if (debug_ts) {
+            av_log(ost, AV_LOG_INFO, "encoder -> type:%s "
+                   "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s "
+                   "duration:%s duration_time:%s\n",
+                   type_desc,
+                   av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &enc->time_base),
+                   av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &enc->time_base),
+                   av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, &enc->time_base));
+        }
+
+        if ((ret = trigger_fix_sub_duration_heartbeat(ost, pkt)) < 0) {
+            av_log(NULL, AV_LOG_ERROR,
+                   "Subtitle heartbeat logic failed in %s! (%s)\n",
+                   __func__, av_err2str(ret));
+            return ret;
+        }
+
+        e->data_size += pkt->size;
+
+        e->packets_encoded++;
+
+        ret = of_output_packet(of, ost, pkt);
+        if (ret < 0)
+            return ret;
+    }
+
+    av_assert0(0);
+}
+
+static int submit_encode_frame(OutputFile *of, OutputStream *ost,
+                               AVFrame *frame)
+{
+    Encoder *e = ost->enc;
+    int ret;
+
+    if (ost->sq_idx_encode < 0)
+        return encode_frame(of, ost, frame);
+
+    if (frame) {
+        ret = av_frame_ref(e->sq_frame, frame);
+        if (ret < 0)
+            return ret;
+        frame = e->sq_frame;
+    }
+
+    ret = sq_send(of->sq_encode, ost->sq_idx_encode,
+                  SQFRAME(frame));
+    if (ret < 0) {
+        if (frame)
+            av_frame_unref(frame);
+        if (ret != AVERROR_EOF)
+            return ret;
+    }
+
+    while (1) {
+        AVFrame *enc_frame = e->sq_frame;
+
+        ret = sq_receive(of->sq_encode, ost->sq_idx_encode,
+                               SQFRAME(enc_frame));
+        if (ret == AVERROR_EOF) {
+            enc_frame = NULL;
+        } else if (ret < 0) {
+            return (ret == AVERROR(EAGAIN)) ? 0 : ret;
+        }
+
+        ret = encode_frame(of, ost, enc_frame);
+        if (enc_frame)
+            av_frame_unref(enc_frame);
+        if (ret < 0) {
+            if (ret == AVERROR_EOF)
+                close_output_stream(ost);
+            return ret;
+        }
+    }
+}
+
+static int do_audio_out(OutputFile *of, OutputStream *ost,
+                        AVFrame *frame)
+{
+    AVCodecContext *enc = ost->enc_ctx;
+    int ret;
+
+    if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
+        enc->ch_layout.nb_channels != frame->ch_layout.nb_channels) {
+        av_log(ost, AV_LOG_ERROR,
+               "Audio channel count changed and encoder does not support parameter changes\n");
+        return 0;
+    }
+
+    if (!check_recording_time(ost, frame->pts, frame->time_base))
+        return 0;
+
+    ret = submit_encode_frame(of, ost, frame);
+    return (ret < 0 && ret != AVERROR_EOF) ? ret : 0;
+}
+
+static enum AVPictureType forced_kf_apply(void *logctx, KeyframeForceCtx *kf,
+                                          AVRational tb, const AVFrame *in_picture)
+{
+    double pts_time;
+
+    if (kf->ref_pts == AV_NOPTS_VALUE)
+        kf->ref_pts = in_picture->pts;
+
+    pts_time = (in_picture->pts - kf->ref_pts) * av_q2d(tb);
+    if (kf->index < kf->nb_pts &&
+        av_compare_ts(in_picture->pts, tb, kf->pts[kf->index], AV_TIME_BASE_Q) >= 0) {
+        kf->index++;
+        goto force_keyframe;
+    } else if (kf->pexpr) {
+        double res;
+        kf->expr_const_values[FKF_T] = pts_time;
+        res = av_expr_eval(kf->pexpr,
+                           kf->expr_const_values, NULL);
+        av_log(logctx, AV_LOG_TRACE,
+               "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
+               kf->expr_const_values[FKF_N],
+               kf->expr_const_values[FKF_N_FORCED],
+               kf->expr_const_values[FKF_PREV_FORCED_N],
+               kf->expr_const_values[FKF_T],
+               kf->expr_const_values[FKF_PREV_FORCED_T],
+               res);
+
+        kf->expr_const_values[FKF_N] += 1;
+
+        if (res) {
+            kf->expr_const_values[FKF_PREV_FORCED_N] = kf->expr_const_values[FKF_N] - 1;
+            kf->expr_const_values[FKF_PREV_FORCED_T] = kf->expr_const_values[FKF_T];
+            kf->expr_const_values[FKF_N_FORCED]     += 1;
+            goto force_keyframe;
+        }
+    } else if (kf->type == KF_FORCE_SOURCE && (in_picture->flags & AV_FRAME_FLAG_KEY)) {
+        goto force_keyframe;
+    }
+
+    return AV_PICTURE_TYPE_NONE;
+
+force_keyframe:
+    av_log(logctx, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
+    return AV_PICTURE_TYPE_I;
+}
+
+/* May modify/reset frame */
+static int do_video_out(OutputFile *of, OutputStream *ost, AVFrame *in_picture)
+{
+    int ret;
+    AVCodecContext *enc = ost->enc_ctx;
+
+    if (!check_recording_time(ost, in_picture->pts, ost->enc_ctx->time_base))
+        return 0;
+
+    in_picture->quality = enc->global_quality;
+    in_picture->pict_type = forced_kf_apply(ost, &ost->kf, enc->time_base, in_picture);
+
+#if FFMPEG_OPT_TOP
+    if (ost->top_field_first >= 0) {
+        in_picture->flags &= ~AV_FRAME_FLAG_TOP_FIELD_FIRST;
+        in_picture->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * (!!ost->top_field_first);
+    }
+#endif
+
+    ret = submit_encode_frame(of, ost, in_picture);
+    return (ret == AVERROR_EOF) ? 0 : ret;
+}
+
+int enc_frame(OutputStream *ost, AVFrame *frame)
+{
+    OutputFile *of = output_files[ost->file_index];
+    int ret;
+
+    ret = enc_open(ost, frame);
+    if (ret < 0)
+        return ret;
+
+    return ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ?
+           do_video_out(of, ost, frame) : do_audio_out(of, ost, frame);
+}
+
+int enc_flush(void)
+{
+    int ret;
+
+    for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
+        OutputFile      *of = output_files[ost->file_index];
+        if (ost->sq_idx_encode >= 0)
+            sq_send(of->sq_encode, ost->sq_idx_encode, SQFRAME(NULL));
+    }
+
+    for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
+        Encoder          *e = ost->enc;
+        AVCodecContext *enc = ost->enc_ctx;
+        OutputFile      *of = output_files[ost->file_index];
+
+        if (!enc || !e->opened ||
+            (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO))
+            continue;
+
+        ret = submit_encode_frame(of, ost, NULL);
+        if (ret != AVERROR_EOF)
+            return ret;
+    }
+
+    return 0;
+}

Sources/ffmpeg/ffmpeg_hw.c

@@ -0,0 +1,363 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+
+#include "libavutil/avstring.h"
+#include "libavutil/pixdesc.h"
+#include "libavfilter/buffersink.h"
+
+#include "ffmpeg.h"
+
+static int nb_hw_devices;
+static HWDevice **hw_devices;
+
+HWDevice *hw_device_get_by_type(enum AVHWDeviceType type)
+{
+    HWDevice *found = NULL;
+    int i;
+    for (i = 0; i < nb_hw_devices; i++) {
+        if (hw_devices[i]->type == type) {
+            if (found)
+                return NULL;
+            found = hw_devices[i];
+        }
+    }
+    return found;
+}
+
+HWDevice *hw_device_get_by_name(const char *name)
+{
+    int i;
+    for (i = 0; i < nb_hw_devices; i++) {
+        if (!strcmp(hw_devices[i]->name, name))
+            return hw_devices[i];
+    }
+    return NULL;
+}
+
+static HWDevice *hw_device_add(void)
+{
+    int err;
+    err = av_reallocp_array(&hw_devices, nb_hw_devices + 1,
+                            sizeof(*hw_devices));
+    if (err) {
+        nb_hw_devices = 0;
+        return NULL;
+    }
+    hw_devices[nb_hw_devices] = av_mallocz(sizeof(HWDevice));
+    if (!hw_devices[nb_hw_devices])
+        return NULL;
+    return hw_devices[nb_hw_devices++];
+}
+
+static char *hw_device_default_name(enum AVHWDeviceType type)
+{
+    // Make an automatic name of the form "type%d".  We arbitrarily
+    // limit at 1000 anonymous devices of the same type - there is
+    // probably something else very wrong if you get to this limit.
+    const char *type_name = av_hwdevice_get_type_name(type);
+    char *name;
+    size_t index_pos;
+    int index, index_limit = 1000;
+    index_pos = strlen(type_name);
+    name = av_malloc(index_pos + 4);
+    if (!name)
+        return NULL;
+    for (index = 0; index < index_limit; index++) {
+        snprintf(name, index_pos + 4, "%s%d", type_name, index);
+        if (!hw_device_get_by_name(name))
+            break;
+    }
+    if (index >= index_limit) {
+        av_freep(&name);
+        return NULL;
+    }
+    return name;
+}
+
+int hw_device_init_from_string(const char *arg, HWDevice **dev_out)
+{
+    // "type=name"
+    // "type=name,key=value,key2=value2"
+    // "type=name:device,key=value,key2=value2"
+    // "type:device,key=value,key2=value2"
+    // -> av_hwdevice_ctx_create()
+    // "type=name@name"
+    // "type@name"
+    // -> av_hwdevice_ctx_create_derived()
+
+    AVDictionary *options = NULL;
+    const char *type_name = NULL, *name = NULL, *device = NULL;
+    enum AVHWDeviceType type;
+    HWDevice *dev, *src;
+    AVBufferRef *device_ref = NULL;
+    int err;
+    const char *errmsg, *p, *q;
+    size_t k;
+
+    k = strcspn(arg, ":=@");
+    p = arg + k;
+
+    type_name = av_strndup(arg, k);
+    if (!type_name) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+    type = av_hwdevice_find_type_by_name(type_name);
+    if (type == AV_HWDEVICE_TYPE_NONE) {
+        errmsg = "unknown device type";
+        goto invalid;
+    }
+
+    if (*p == '=') {
+        k = strcspn(p + 1, ":@,");
+
+        name = av_strndup(p + 1, k);
+        if (!name) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+        if (hw_device_get_by_name(name)) {
+            errmsg = "named device already exists";
+            goto invalid;
+        }
+
+        p += 1 + k;
+    } else {
+        name = hw_device_default_name(type);
+        if (!name) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    if (!*p) {
+        // New device with no parameters.
+        err = av_hwdevice_ctx_create(&device_ref, type,
+                                     NULL, NULL, 0);
+        if (err < 0)
+            goto fail;
+
+    } else if (*p == ':') {
+        // New device with some parameters.
+        ++p;
+        q = strchr(p, ',');
+        if (q) {
+            if (q - p > 0) {
+                device = av_strndup(p, q - p);
+                if (!device) {
+                    err = AVERROR(ENOMEM);
+                    goto fail;
+                }
+            }
+            err = av_dict_parse_string(&options, q + 1, "=", ",", 0);
+            if (err < 0) {
+                errmsg = "failed to parse options";
+                goto invalid;
+            }
+        }
+
+        err = av_hwdevice_ctx_create(&device_ref, type,
+                                     q ? device : p[0] ? p : NULL,
+                                     options, 0);
+        if (err < 0)
+            goto fail;
+
+    } else if (*p == '@') {
+        // Derive from existing device.
+
+        src = hw_device_get_by_name(p + 1);
+        if (!src) {
+            errmsg = "invalid source device name";
+            goto invalid;
+        }
+
+        err = av_hwdevice_ctx_create_derived(&device_ref, type,
+                                             src->device_ref, 0);
+        if (err < 0)
+            goto fail;
+    } else if (*p == ',') {
+        err = av_dict_parse_string(&options, p + 1, "=", ",", 0);
+
+        if (err < 0) {
+            errmsg = "failed to parse options";
+            goto invalid;
+        }
+
+        err = av_hwdevice_ctx_create(&device_ref, type,
+                                     NULL, options, 0);
+        if (err < 0)
+            goto fail;
+    } else {
+        errmsg = "parse error";
+        goto invalid;
+    }
+
+    dev = hw_device_add();
+    if (!dev) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    dev->name = name;
+    dev->type = type;
+    dev->device_ref = device_ref;
+
+    if (dev_out)
+        *dev_out = dev;
+
+    name = NULL;
+    err = 0;
+done:
+    av_freep(&type_name);
+    av_freep(&name);
+    av_freep(&device);
+    av_dict_free(&options);
+    return err;
+invalid:
+    av_log(NULL, AV_LOG_ERROR,
+           "Invalid device specification \"%s\": %s\n", arg, errmsg);
+    err = AVERROR(EINVAL);
+    goto done;
+fail:
+    av_log(NULL, AV_LOG_ERROR,
+           "Device creation failed: %d.\n", err);
+    av_buffer_unref(&device_ref);
+    goto done;
+}
+
+int hw_device_init_from_type(enum AVHWDeviceType type,
+                             const char *device,
+                             HWDevice **dev_out)
+{
+    AVBufferRef *device_ref = NULL;
+    HWDevice *dev;
+    char *name;
+    int err;
+
+    name = hw_device_default_name(type);
+    if (!name) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    err = av_hwdevice_ctx_create(&device_ref, type, device, NULL, 0);
+    if (err < 0) {
+        av_log(NULL, AV_LOG_ERROR,
+               "Device creation failed: %d.\n", err);
+        goto fail;
+    }
+
+    dev = hw_device_add();
+    if (!dev) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    dev->name = name;
+    dev->type = type;
+    dev->device_ref = device_ref;
+
+    if (dev_out)
+        *dev_out = dev;
+
+    return 0;
+
+fail:
+    av_freep(&name);
+    av_buffer_unref(&device_ref);
+    return err;
+}
+
+void hw_device_free_all(void)
+{
+    int i;
+    for (i = 0; i < nb_hw_devices; i++) {
+        av_freep(&hw_devices[i]->name);
+        av_buffer_unref(&hw_devices[i]->device_ref);
+        av_freep(&hw_devices[i]);
+    }
+    av_freep(&hw_devices);
+    nb_hw_devices = 0;
+}
+
+int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input)
+{
+    InputStream *ist = avctx->opaque;
+    AVFrame *output = NULL;
+    enum AVPixelFormat output_format = ist->hwaccel_output_format;
+    int err;
+
+    if (input->format == output_format) {
+        // Nothing to do.
+        return 0;
+    }
+
+    output = av_frame_alloc();
+    if (!output)
+        return AVERROR(ENOMEM);
+
+    output->format = output_format;
+
+    err = av_hwframe_transfer_data(output, input, 0);
+    if (err < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to transfer data to "
+               "output frame: %d.\n", err);
+        goto fail;
+    }
+
+    err = av_frame_copy_props(output, input);
+    if (err < 0) {
+        av_frame_unref(output);
+        goto fail;
+    }
+
+    av_frame_unref(input);
+    av_frame_move_ref(input, output);
+    av_frame_free(&output);
+
+    return 0;
+
+fail:
+    av_frame_free(&output);
+    return err;
+}
+
+AVBufferRef *hw_device_for_filter(void)
+{
+    // Pick the last hardware device if the user doesn't pick the device for
+    // filters explicitly with the filter_hw_device option.
+    if (filter_hw_device)
+        return filter_hw_device->device_ref;
+    else if (nb_hw_devices > 0) {
+        HWDevice *dev = hw_devices[nb_hw_devices - 1];
+
+        if (nb_hw_devices > 1)
+            av_log(NULL, AV_LOG_WARNING, "There are %d hardware devices. device "
+                   "%s of type %s is picked for filters by default. Set hardware "
+                   "device explicitly with the filter_hw_device option if device "
+                   "%s is not usable for filters.\n",
+                   nb_hw_devices, dev->name,
+                   av_hwdevice_get_type_name(dev->type), dev->name);
+
+        return dev->device_ref;
+    }
+
+    return NULL;
+}

Sources/ffmpeg/ffmpeg_mux.c

@@ -0,0 +1,951 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdatomic.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "ffmpeg.h"
+#include "ffmpeg_mux.h"
+#include "objpool.h"
+#include "sync_queue.h"
+#include "thread_queue.h"
+
+#include "libavutil/fifo.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/log.h"
+#include "libavutil/mem.h"
+#include "libavutil/timestamp.h"
+#include "libavutil/thread.h"
+
+#include "libavcodec/packet.h"
+
+#include "libavformat/avformat.h"
+#include "libavformat/avio.h"
+
+int want_sdp = 1;
+
+static Muxer *mux_from_of(OutputFile *of)
+{
+    return (Muxer*)of;
+}
+
+static int64_t filesize(AVIOContext *pb)
+{
+    int64_t ret = -1;
+
+    if (pb) {
+        ret = avio_size(pb);
+        if (ret <= 0) // FIXME improve avio_size() so it works with non seekable output too
+            ret = avio_tell(pb);
+    }
+
+    return ret;
+}
+
+static int write_packet(Muxer *mux, OutputStream *ost, AVPacket *pkt)
+{
+    MuxStream *ms = ms_from_ost(ost);
+    AVFormatContext *s = mux->fc;
+    int64_t fs;
+    uint64_t frame_num;
+    int ret;
+
+    fs = filesize(s->pb);
+    atomic_store(&mux->last_filesize, fs);
+    if (fs >= mux->limit_filesize) {
+        ret = AVERROR_EOF;
+        goto fail;
+    }
+
+    if (ost->type == AVMEDIA_TYPE_VIDEO && ost->vsync_method == VSYNC_DROP)
+        pkt->pts = pkt->dts = AV_NOPTS_VALUE;
+
+    // rescale timestamps to the stream timebase
+    if (ost->type == AVMEDIA_TYPE_AUDIO && !ost->enc) {
+        // use av_rescale_delta() for streamcopying audio, to preserve
+        // accuracy with coarse input timebases
+        int duration = av_get_audio_frame_duration2(ost->st->codecpar, pkt->size);
+
+        if (!duration)
+            duration = ost->st->codecpar->frame_size;
+
+        pkt->dts = av_rescale_delta(pkt->time_base, pkt->dts,
+                                    (AVRational){1, ost->st->codecpar->sample_rate}, duration,
+                                    &ms->ts_rescale_delta_last, ost->st->time_base);
+        pkt->pts = pkt->dts;
+
+        pkt->duration = av_rescale_q(pkt->duration, pkt->time_base, ost->st->time_base);
+    } else
+        av_packet_rescale_ts(pkt, pkt->time_base, ost->st->time_base);
+    pkt->time_base = ost->st->time_base;
+
+    if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
+        if (pkt->dts != AV_NOPTS_VALUE &&
+            pkt->pts != AV_NOPTS_VALUE &&
+            pkt->dts > pkt->pts) {
+            av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
+                   pkt->dts, pkt->pts,
+                   ost->file_index, ost->st->index);
+            pkt->pts =
+            pkt->dts = pkt->pts + pkt->dts + ms->last_mux_dts + 1
+                     - FFMIN3(pkt->pts, pkt->dts, ms->last_mux_dts + 1)
+                     - FFMAX3(pkt->pts, pkt->dts, ms->last_mux_dts + 1);
+        }
+        if ((ost->type == AVMEDIA_TYPE_AUDIO || ost->type == AVMEDIA_TYPE_VIDEO || ost->type == AVMEDIA_TYPE_SUBTITLE) &&
+            pkt->dts != AV_NOPTS_VALUE &&
+            ms->last_mux_dts != AV_NOPTS_VALUE) {
+            int64_t max = ms->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
+            if (pkt->dts < max) {
+                int loglevel = max - pkt->dts > 2 || ost->type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
+                if (exit_on_error)
+                    loglevel = AV_LOG_ERROR;
+                av_log(s, loglevel, "Non-monotonic DTS in output stream "
+                       "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
+                       ost->file_index, ost->st->index, ms->last_mux_dts, pkt->dts);
+                if (exit_on_error) {
+                    ret = AVERROR(EINVAL);
+                    goto fail;
+                }
+
+                av_log(s, loglevel, "changing to %"PRId64". This may result "
+                       "in incorrect timestamps in the output file.\n",
+                       max);
+                if (pkt->pts >= pkt->dts)
+                    pkt->pts = FFMAX(pkt->pts, max);
+                pkt->dts = max;
+            }
+        }
+    }
+    ms->last_mux_dts = pkt->dts;
+
+    ms->data_size_mux += pkt->size;
+    frame_num = atomic_fetch_add(&ost->packets_written, 1);
+
+    pkt->stream_index = ost->index;
+
+    if (debug_ts) {
+        av_log(ost, AV_LOG_INFO, "muxer <- type:%s "
+                "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s duration:%s duration_time:%s size:%d\n",
+                av_get_media_type_string(ost->type),
+                av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
+                av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
+                av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, &ost->st->time_base),
+                pkt->size
+              );
+    }
+
+    if (ms->stats.io)
+        enc_stats_write(ost, &ms->stats, NULL, pkt, frame_num);
+
+    ret = av_interleaved_write_frame(s, pkt);
+    if (ret < 0) {
+        av_log(ost, AV_LOG_ERROR,
+               "Error submitting a packet to the muxer: %s\n",
+               av_err2str(ret));
+        goto fail;
+    }
+
+    return 0;
+fail:
+    av_packet_unref(pkt);
+    return ret;
+}
+
+static int sync_queue_process(Muxer *mux, OutputStream *ost, AVPacket *pkt, int *stream_eof)
+{
+    OutputFile *of = &mux->of;
+
+    if (ost->sq_idx_mux >= 0) {
+        int ret = sq_send(mux->sq_mux, ost->sq_idx_mux, SQPKT(pkt));
+        if (ret < 0) {
+            if (ret == AVERROR_EOF)
+                *stream_eof = 1;
+
+            return ret;
+        }
+
+        while (1) {
+            ret = sq_receive(mux->sq_mux, -1, SQPKT(mux->sq_pkt));
+            if (ret < 0) {
+                /* n.b.: We forward EOF from the sync queue, terminating muxing.
+                 * This assumes that if a muxing sync queue is present, then all
+                 * the streams use it. That is true currently, but may change in
+                 * the future, then this code needs to be revisited.
+                 */
+                return ret == AVERROR(EAGAIN) ? 0 : ret;
+            }
+
+            ret = write_packet(mux, of->streams[ret],
+                               mux->sq_pkt);
+            if (ret < 0)
+                return ret;
+        }
+    } else if (pkt)
+        return write_packet(mux, ost, pkt);
+
+    return 0;
+}
+
+static void thread_set_name(OutputFile *of)
+{
+    char name[16];
+    snprintf(name, sizeof(name), "mux%d:%s", of->index, of->format->name);
+    ff_thread_setname(name);
+}
+
+static void *muxer_thread(void *arg)
+{
+    Muxer     *mux = arg;
+    OutputFile *of = &mux->of;
+    AVPacket  *pkt = NULL;
+    int        ret = 0;
+
+    pkt = av_packet_alloc();
+    if (!pkt) {
+        ret = AVERROR(ENOMEM);
+        goto finish;
+    }
+
+    thread_set_name(of);
+
+    while (1) {
+        OutputStream *ost;
+        int stream_idx, stream_eof = 0;
+
+        ret = tq_receive(mux->tq, &stream_idx, pkt);
+        if (stream_idx < 0) {
+            av_log(mux, AV_LOG_VERBOSE, "All streams finished\n");
+            ret = 0;
+            break;
+        }
+
+        ost = of->streams[stream_idx];
+        ret = sync_queue_process(mux, ost, ret < 0 ? NULL : pkt, &stream_eof);
+        av_packet_unref(pkt);
+        if (ret == AVERROR_EOF) {
+            if (stream_eof) {
+                tq_receive_finish(mux->tq, stream_idx);
+            } else {
+                av_log(mux, AV_LOG_VERBOSE, "Muxer returned EOF\n");
+                ret = 0;
+                break;
+            }
+        } else if (ret < 0) {
+            av_log(mux, AV_LOG_ERROR, "Error muxing a packet\n");
+            break;
+        }
+    }
+
+finish:
+    av_packet_free(&pkt);
+
+    for (unsigned int i = 0; i < mux->fc->nb_streams; i++)
+        tq_receive_finish(mux->tq, i);
+
+    av_log(mux, AV_LOG_VERBOSE, "Terminating muxer thread\n");
+
+    return (void*)(intptr_t)ret;
+}
+
+static int thread_submit_packet(Muxer *mux, OutputStream *ost, AVPacket *pkt)
+{
+    int ret = 0;
+
+    if (!pkt || ost->finished & MUXER_FINISHED)
+        goto finish;
+
+    ret = tq_send(mux->tq, ost->index, pkt);
+    if (ret < 0)
+        goto finish;
+
+    return 0;
+
+finish:
+    if (pkt)
+        av_packet_unref(pkt);
+
+    ost->finished |= MUXER_FINISHED;
+    tq_send_finish(mux->tq, ost->index);
+    return ret == AVERROR_EOF ? 0 : ret;
+}
+
+static int queue_packet(OutputStream *ost, AVPacket *pkt)
+{
+    MuxStream *ms = ms_from_ost(ost);
+    AVPacket *tmp_pkt = NULL;
+    int ret;
+
+    if (!av_fifo_can_write(ms->muxing_queue)) {
+        size_t cur_size = av_fifo_can_read(ms->muxing_queue);
+        size_t pkt_size = pkt ? pkt->size : 0;
+        unsigned int are_we_over_size =
+            (ms->muxing_queue_data_size + pkt_size) > ms->muxing_queue_data_threshold;
+        size_t limit    = are_we_over_size ? ms->max_muxing_queue_size : SIZE_MAX;
+        size_t new_size = FFMIN(2 * cur_size, limit);
+
+        if (new_size <= cur_size) {
+            av_log(ost, AV_LOG_ERROR,
+                   "Too many packets buffered for output stream %d:%d.\n",
+                   ost->file_index, ost->st->index);
+            return AVERROR(ENOSPC);
+        }
+        ret = av_fifo_grow2(ms->muxing_queue, new_size - cur_size);
+        if (ret < 0)
+            return ret;
+    }
+
+    if (pkt) {
+        ret = av_packet_make_refcounted(pkt);
+        if (ret < 0)
+            return ret;
+
+        tmp_pkt = av_packet_alloc();
+        if (!tmp_pkt)
+            return AVERROR(ENOMEM);
+
+        av_packet_move_ref(tmp_pkt, pkt);
+        ms->muxing_queue_data_size += tmp_pkt->size;
+    }
+    av_fifo_write(ms->muxing_queue, &tmp_pkt, 1);
+
+    return 0;
+}
+
+static int submit_packet(Muxer *mux, AVPacket *pkt, OutputStream *ost)
+{
+    int ret;
+
+    if (mux->tq) {
+        return thread_submit_packet(mux, ost, pkt);
+    } else {
+        /* the muxer is not initialized yet, buffer the packet */
+        ret = queue_packet(ost, pkt);
+        if (ret < 0) {
+            if (pkt)
+                av_packet_unref(pkt);
+            return ret;
+        }
+    }
+
+    return 0;
+}
+
+int of_output_packet(OutputFile *of, OutputStream *ost, AVPacket *pkt)
+{
+    Muxer *mux = mux_from_of(of);
+    MuxStream *ms = ms_from_ost(ost);
+    const char *err_msg;
+    int ret = 0;
+
+    if (pkt && pkt->dts != AV_NOPTS_VALUE)
+        ost->last_mux_dts = av_rescale_q(pkt->dts, pkt->time_base, AV_TIME_BASE_Q);
+
+    /* apply the output bitstream filters */
+    if (ms->bsf_ctx) {
+        int bsf_eof = 0;
+
+        if (pkt)
+            av_packet_rescale_ts(pkt, pkt->time_base, ms->bsf_ctx->time_base_in);
+
+        ret = av_bsf_send_packet(ms->bsf_ctx, pkt);
+        if (ret < 0) {
+            err_msg = "submitting a packet for bitstream filtering";
+            goto fail;
+        }
+
+        while (!bsf_eof) {
+            ret = av_bsf_receive_packet(ms->bsf_ctx, ms->bsf_pkt);
+            if (ret == AVERROR(EAGAIN))
+                return 0;
+            else if (ret == AVERROR_EOF)
+                bsf_eof = 1;
+            else if (ret < 0) {
+                err_msg = "applying bitstream filters to a packet";
+                goto fail;
+            }
+
+            if (!bsf_eof)
+                ms->bsf_pkt->time_base = ms->bsf_ctx->time_base_out;
+
+            ret = submit_packet(mux, bsf_eof ? NULL : ms->bsf_pkt, ost);
+            if (ret < 0)
+                goto mux_fail;
+        }
+    } else {
+        ret = submit_packet(mux, pkt, ost);
+        if (ret < 0)
+            goto mux_fail;
+    }
+
+    return 0;
+
+mux_fail:
+    err_msg = "submitting a packet to the muxer";
+
+fail:
+    av_log(ost, AV_LOG_ERROR, "Error %s\n", err_msg);
+    return exit_on_error ? ret : 0;
+}
+
+int of_streamcopy(OutputStream *ost, const AVPacket *pkt, int64_t dts)
+{
+    OutputFile *of = output_files[ost->file_index];
+    MuxStream  *ms = ms_from_ost(ost);
+    int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
+    int64_t ts_offset;
+    AVPacket *opkt = ms->pkt;
+    int ret;
+
+    av_packet_unref(opkt);
+
+    if (of->recording_time != INT64_MAX &&
+        dts >= of->recording_time + start_time)
+        pkt = NULL;
+
+    // EOF: flush output bitstream filters.
+    if (!pkt)
+        return of_output_packet(of, ost, NULL);
+
+    if (!ms->streamcopy_started && !(pkt->flags & AV_PKT_FLAG_KEY) &&
+        !ms->copy_initial_nonkeyframes)
+        return 0;
+
+    if (!ms->streamcopy_started) {
+        if (!ms->copy_prior_start &&
+            (pkt->pts == AV_NOPTS_VALUE ?
+             dts < ms->ts_copy_start :
+             pkt->pts < av_rescale_q(ms->ts_copy_start, AV_TIME_BASE_Q, pkt->time_base)))
+            return 0;
+
+        if (of->start_time != AV_NOPTS_VALUE && dts < of->start_time)
+            return 0;
+    }
+
+    ret = av_packet_ref(opkt, pkt);
+    if (ret < 0)
+        return ret;
+
+    ts_offset = av_rescale_q(start_time, AV_TIME_BASE_Q, opkt->time_base);
+
+    if (pkt->pts != AV_NOPTS_VALUE)
+        opkt->pts -= ts_offset;
+
+    if (pkt->dts == AV_NOPTS_VALUE) {
+        opkt->dts = av_rescale_q(dts, AV_TIME_BASE_Q, opkt->time_base);
+    } else if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+        opkt->pts = opkt->dts - ts_offset;
+    }
+    opkt->dts -= ts_offset;
+
+    {
+        int ret = trigger_fix_sub_duration_heartbeat(ost, pkt);
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_ERROR,
+                   "Subtitle heartbeat logic failed in %s! (%s)\n",
+                   __func__, av_err2str(ret));
+            return ret;
+        }
+    }
+
+    ret = of_output_packet(of, ost, opkt);
+    if (ret < 0)
+        return ret;
+
+    ms->streamcopy_started = 1;
+
+    return 0;
+}
+
+static int thread_stop(Muxer *mux)
+{
+    void *ret;
+
+    if (!mux || !mux->tq)
+        return 0;
+
+    for (unsigned int i = 0; i < mux->fc->nb_streams; i++)
+        tq_send_finish(mux->tq, i);
+
+    pthread_join(mux->thread, &ret);
+
+    tq_free(&mux->tq);
+
+    return (int)(intptr_t)ret;
+}
+
+static int thread_start(Muxer *mux)
+{
+    AVFormatContext *fc = mux->fc;
+    ObjPool *op;
+    int ret;
+
+    op = objpool_alloc_packets();
+    if (!op)
+        return AVERROR(ENOMEM);
+
+    mux->tq = tq_alloc(fc->nb_streams, mux->thread_queue_size, op, pkt_move);
+    if (!mux->tq) {
+        objpool_free(&op);
+        return AVERROR(ENOMEM);
+    }
+
+    ret = pthread_create(&mux->thread, NULL, muxer_thread, (void*)mux);
+    if (ret) {
+        tq_free(&mux->tq);
+        return AVERROR(ret);
+    }
+
+    /* flush the muxing queues */
+    for (int i = 0; i < fc->nb_streams; i++) {
+        OutputStream *ost = mux->of.streams[i];
+        MuxStream     *ms = ms_from_ost(ost);
+        AVPacket *pkt;
+
+        while (av_fifo_read(ms->muxing_queue, &pkt, 1) >= 0) {
+            ret = thread_submit_packet(mux, ost, pkt);
+            if (pkt) {
+                ms->muxing_queue_data_size -= pkt->size;
+                av_packet_free(&pkt);
+            }
+            if (ret < 0)
+                return ret;
+        }
+    }
+
+    return 0;
+}
+
+static int print_sdp(void)
+{
+    char sdp[16384];
+    int i;
+    int j, ret;
+    AVIOContext *sdp_pb;
+    AVFormatContext **avc;
+
+    for (i = 0; i < nb_output_files; i++) {
+        if (!mux_from_of(output_files[i])->header_written)
+            return 0;
+    }
+
+    avc = av_malloc_array(nb_output_files, sizeof(*avc));
+    if (!avc)
+        return AVERROR(ENOMEM);
+    for (i = 0, j = 0; i < nb_output_files; i++) {
+        if (!strcmp(output_files[i]->format->name, "rtp")) {
+            avc[j] = mux_from_of(output_files[i])->fc;
+            j++;
+        }
+    }
+
+    if (!j) {
+        av_log(NULL, AV_LOG_ERROR, "No output streams in the SDP.\n");
+        ret = AVERROR(EINVAL);
+        goto fail;
+    }
+
+    ret = av_sdp_create(avc, j, sdp, sizeof(sdp));
+    if (ret < 0)
+        goto fail;
+
+    if (!sdp_filename) {
+        printf("SDP:\n%s\n", sdp);
+        fflush(stdout);
+    } else {
+        ret = avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL);
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
+            goto fail;
+        }
+
+        avio_print(sdp_pb, sdp);
+        avio_closep(&sdp_pb);
+        av_freep(&sdp_filename);
+    }
+
+    // SDP successfully written, allow muxer threads to start
+    ret = 1;
+
+fail:
+    av_freep(&avc);
+    return ret;
+}
+
+int mux_check_init(Muxer *mux)
+{
+    OutputFile *of = &mux->of;
+    AVFormatContext *fc = mux->fc;
+    int ret, i;
+
+    for (i = 0; i < fc->nb_streams; i++) {
+        OutputStream *ost = of->streams[i];
+        if (!ost->initialized)
+            return 0;
+    }
+
+    ret = avformat_write_header(fc, &mux->opts);
+    if (ret < 0) {
+        av_log(mux, AV_LOG_ERROR, "Could not write header (incorrect codec "
+               "parameters ?): %s\n", av_err2str(ret));
+        return ret;
+    }
+    //assert_avoptions(of->opts);
+    mux->header_written = 1;
+
+    av_dump_format(fc, of->index, fc->url, 1);
+    nb_output_dumped++;
+
+    if (sdp_filename || want_sdp) {
+        ret = print_sdp();
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_ERROR, "Error writing the SDP.\n");
+            return ret;
+        } else if (ret == 1) {
+            /* SDP is written only after all the muxers are ready, so now we
+             * start ALL the threads */
+            for (i = 0; i < nb_output_files; i++) {
+                ret = thread_start(mux_from_of(output_files[i]));
+                if (ret < 0)
+                    return ret;
+            }
+        }
+    } else {
+        ret = thread_start(mux_from_of(of));
+        if (ret < 0)
+            return ret;
+    }
+
+    return 0;
+}
+
+static int bsf_init(MuxStream *ms)
+{
+    OutputStream *ost = &ms->ost;
+    AVBSFContext *ctx = ms->bsf_ctx;
+    int ret;
+
+    if (!ctx)
+        return avcodec_parameters_copy(ost->st->codecpar, ost->par_in);
+
+    ret = avcodec_parameters_copy(ctx->par_in, ost->par_in);
+    if (ret < 0)
+        return ret;
+
+    ctx->time_base_in = ost->st->time_base;
+
+    ret = av_bsf_init(ctx);
+    if (ret < 0) {
+        av_log(ms, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
+               ctx->filter->name);
+        return ret;
+    }
+
+    ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
+    if (ret < 0)
+        return ret;
+    ost->st->time_base = ctx->time_base_out;
+
+    ms->bsf_pkt = av_packet_alloc();
+    if (!ms->bsf_pkt)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+int of_stream_init(OutputFile *of, OutputStream *ost)
+{
+    Muxer *mux = mux_from_of(of);
+    MuxStream *ms = ms_from_ost(ost);
+    int ret;
+
+    /* initialize bitstream filters for the output stream
+     * needs to be done here, because the codec id for streamcopy is not
+     * known until now */
+    ret = bsf_init(ms);
+    if (ret < 0)
+        return ret;
+
+    if (ms->stream_duration) {
+        ost->st->duration = av_rescale_q(ms->stream_duration, ms->stream_duration_tb,
+                                         ost->st->time_base);
+    }
+
+    ost->initialized = 1;
+
+    return mux_check_init(mux);
+}
+
+static int check_written(OutputFile *of)
+{
+    int64_t total_packets_written = 0;
+    int pass1_used = 1;
+    int ret = 0;
+
+    for (int i = 0; i < of->nb_streams; i++) {
+        OutputStream *ost = of->streams[i];
+        uint64_t packets_written = atomic_load(&ost->packets_written);
+
+        total_packets_written += packets_written;
+
+        if (ost->enc_ctx &&
+            (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2))
+             != AV_CODEC_FLAG_PASS1)
+            pass1_used = 0;
+
+        if (!packets_written &&
+            (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM)) {
+            av_log(ost, AV_LOG_FATAL, "Empty output stream\n");
+            ret = err_merge(ret, AVERROR(EINVAL));
+        }
+    }
+
+    if (!total_packets_written) {
+        int level = AV_LOG_WARNING;
+
+        if (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT) {
+            ret = err_merge(ret, AVERROR(EINVAL));
+            level = AV_LOG_FATAL;
+        }
+
+        av_log(of, level, "Output file is empty, nothing was encoded%s\n",
+               pass1_used ? "" : "(check -ss / -t / -frames parameters if used)");
+    }
+
+    return ret;
+}
+
+static void mux_final_stats(Muxer *mux)
+{
+    OutputFile *of = &mux->of;
+    uint64_t total_packets = 0, total_size = 0;
+    uint64_t video_size = 0, audio_size = 0, subtitle_size = 0,
+             extra_size = 0, other_size = 0;
+
+    uint8_t overhead[16] = "unknown";
+    int64_t file_size = of_filesize(of);
+
+    av_log(of, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
+           of->index, of->url);
+
+    for (int j = 0; j < of->nb_streams; j++) {
+        OutputStream *ost = of->streams[j];
+        MuxStream     *ms = ms_from_ost(ost);
+        const AVCodecParameters *par = ost->st->codecpar;
+        const  enum AVMediaType type = par->codec_type;
+        const uint64_t s = ms->data_size_mux;
+
+        switch (type) {
+        case AVMEDIA_TYPE_VIDEO:    video_size    += s; break;
+        case AVMEDIA_TYPE_AUDIO:    audio_size    += s; break;
+        case AVMEDIA_TYPE_SUBTITLE: subtitle_size += s; break;
+        default:                    other_size    += s; break;
+        }
+
+        extra_size    += par->extradata_size;
+        total_size    += s;
+        total_packets += atomic_load(&ost->packets_written);
+
+        av_log(of, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
+               of->index, j, av_get_media_type_string(type));
+        if (ost->enc) {
+            av_log(of, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
+                   ost->frames_encoded);
+            if (type == AVMEDIA_TYPE_AUDIO)
+                av_log(of, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
+            av_log(of, AV_LOG_VERBOSE, "; ");
+        }
+
+        av_log(of, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
+               atomic_load(&ost->packets_written), s);
+
+        av_log(of, AV_LOG_VERBOSE, "\n");
+    }
+
+    av_log(of, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
+           total_packets, total_size);
+
+    if (total_size && file_size > 0 && file_size >= total_size) {
+        snprintf(overhead, sizeof(overhead), "%f%%",
+                 100.0 * (file_size - total_size) / total_size);
+    }
+
+    av_log(of, AV_LOG_INFO,
+           "video:%1.0fkB audio:%1.0fkB subtitle:%1.0fkB other streams:%1.0fkB "
+           "global headers:%1.0fkB muxing overhead: %s\n",
+           video_size    / 1024.0,
+           audio_size    / 1024.0,
+           subtitle_size / 1024.0,
+           other_size    / 1024.0,
+           extra_size    / 1024.0,
+           overhead);
+}
+
+int of_write_trailer(OutputFile *of)
+{
+    Muxer *mux = mux_from_of(of);
+    AVFormatContext *fc = mux->fc;
+    int ret, mux_result = 0;
+
+    if (!mux->tq) {
+        av_log(mux, AV_LOG_ERROR,
+               "Nothing was written into output file, because "
+               "at least one of its streams received no packets.\n");
+        return AVERROR(EINVAL);
+    }
+
+    mux_result = thread_stop(mux);
+
+    ret = av_write_trailer(fc);
+    if (ret < 0) {
+        av_log(mux, AV_LOG_ERROR, "Error writing trailer: %s\n", av_err2str(ret));
+        mux_result = err_merge(mux_result, ret);
+    }
+
+    mux->last_filesize = filesize(fc->pb);
+
+    if (!(of->format->flags & AVFMT_NOFILE)) {
+        ret = avio_closep(&fc->pb);
+        if (ret < 0) {
+            av_log(mux, AV_LOG_ERROR, "Error closing file: %s\n", av_err2str(ret));
+            mux_result = err_merge(mux_result, ret);
+        }
+    }
+
+    mux_final_stats(mux);
+
+    // check whether anything was actually written
+    ret = check_written(of);
+    mux_result = err_merge(mux_result, ret);
+
+    return mux_result;
+}
+
+static void ost_free(OutputStream **post)
+{
+    OutputStream *ost = *post;
+    MuxStream *ms;
+
+    if (!ost)
+        return;
+    ms = ms_from_ost(ost);
+
+    enc_free(&ost->enc);
+
+    if (ost->logfile) {
+        if (fclose(ost->logfile))
+            av_log(ms, AV_LOG_ERROR,
+                   "Error closing logfile, loss of information possible: %s\n",
+                   av_err2str(AVERROR(errno)));
+        ost->logfile = NULL;
+    }
+
+    if (ms->muxing_queue) {
+        AVPacket *pkt;
+        while (av_fifo_read(ms->muxing_queue, &pkt, 1) >= 0)
+            av_packet_free(&pkt);
+        av_fifo_freep2(&ms->muxing_queue);
+    }
+
+    avcodec_parameters_free(&ost->par_in);
+
+    av_bsf_free(&ms->bsf_ctx);
+    av_packet_free(&ms->bsf_pkt);
+
+    av_packet_free(&ms->pkt);
+    av_dict_free(&ost->encoder_opts);
+
+    av_freep(&ost->kf.pts);
+    av_expr_free(ost->kf.pexpr);
+
+    av_freep(&ost->logfile_prefix);
+    av_freep(&ost->apad);
+
+#if FFMPEG_OPT_MAP_CHANNEL
+    av_freep(&ost->audio_channels_map);
+    ost->audio_channels_mapped = 0;
+#endif
+
+    av_dict_free(&ost->sws_dict);
+    av_dict_free(&ost->swr_opts);
+
+    if (ost->enc_ctx)
+        av_freep(&ost->enc_ctx->stats_in);
+    avcodec_free_context(&ost->enc_ctx);
+
+    for (int i = 0; i < ost->enc_stats_pre.nb_components; i++)
+        av_freep(&ost->enc_stats_pre.components[i].str);
+    av_freep(&ost->enc_stats_pre.components);
+
+    for (int i = 0; i < ost->enc_stats_post.nb_components; i++)
+        av_freep(&ost->enc_stats_post.components[i].str);
+    av_freep(&ost->enc_stats_post.components);
+
+    for (int i = 0; i < ms->stats.nb_components; i++)
+        av_freep(&ms->stats.components[i].str);
+    av_freep(&ms->stats.components);
+
+    av_freep(post);
+}
+
+static void fc_close(AVFormatContext **pfc)
+{
+    AVFormatContext *fc = *pfc;
+
+    if (!fc)
+        return;
+
+    if (!(fc->oformat->flags & AVFMT_NOFILE))
+        avio_closep(&fc->pb);
+    avformat_free_context(fc);
+
+    *pfc = NULL;
+}
+
+void of_free(OutputFile **pof)
+{
+    OutputFile *of = *pof;
+    Muxer *mux;
+
+    if (!of)
+        return;
+    mux = mux_from_of(of);
+
+    thread_stop(mux);
+
+    sq_free(&of->sq_encode);
+    sq_free(&mux->sq_mux);
+
+    for (int i = 0; i < of->nb_streams; i++)
+        ost_free(&of->streams[i]);
+    av_freep(&of->streams);
+
+    av_dict_free(&mux->opts);
+
+    av_packet_free(&mux->sq_pkt);
+
+    fc_close(&mux->fc);
+
+    av_freep(pof);
+}
+
+int64_t of_filesize(OutputFile *of)
+{
+    Muxer *mux = mux_from_of(of);
+    return atomic_load(&mux->last_filesize);
+}

Sources/ffmpeg/include/ffmpeg.h

@@ -0,0 +1,955 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef FFTOOLS_FFMPEG_H
+#define FFTOOLS_FFMPEG_H
+
+#include "config.h"
+
+#include <stdatomic.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+
+#include "cmdutils.h"
+#include "sync_queue.h"
+
+#include "libavformat/avformat.h"
+#include "libavformat/avio.h"
+
+#include "libavcodec/avcodec.h"
+#include "libavcodec/bsf.h"
+
+#include "libavfilter/avfilter.h"
+
+#include "libavutil/avutil.h"
+#include "libavutil/dict.h"
+#include "libavutil/eval.h"
+#include "libavutil/fifo.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/pixfmt.h"
+#include "libavutil/rational.h"
+#include "libavutil/thread.h"
+#include "libavutil/threadmessage.h"
+
+#include "libswresample/swresample.h"
+
+// deprecated features
+#define FFMPEG_OPT_PSNR 1
+#define FFMPEG_OPT_MAP_CHANNEL 1
+#define FFMPEG_OPT_MAP_SYNC 1
+#define FFMPEG_ROTATION_METADATA 1
+#define FFMPEG_OPT_QPHIST 1
+#define FFMPEG_OPT_ADRIFT_THRESHOLD 1
+#define FFMPEG_OPT_ENC_TIME_BASE_NUM 1
+#define FFMPEG_OPT_TOP 1
+#define FFMPEG_OPT_FORCE_KF_SOURCE_NO_DROP 1
+
+enum VideoSyncMethod {
+    VSYNC_AUTO = -1,
+    VSYNC_PASSTHROUGH,
+    VSYNC_CFR,
+    VSYNC_VFR,
+    VSYNC_VSCFR,
+    VSYNC_DROP,
+};
+
+enum EncTimeBase {
+    ENC_TIME_BASE_DEMUX  = -1,
+    ENC_TIME_BASE_FILTER = -2,
+};
+
+enum HWAccelID {
+    HWACCEL_NONE = 0,
+    HWACCEL_AUTO,
+    HWACCEL_GENERIC,
+};
+
+typedef struct HWDevice {
+    const char *name;
+    enum AVHWDeviceType type;
+    AVBufferRef *device_ref;
+} HWDevice;
+
+/* select an input stream for an output stream */
+typedef struct StreamMap {
+    int disabled;           /* 1 is this mapping is disabled by a negative map */
+    int file_index;
+    int stream_index;
+    char *linklabel;       /* name of an output link, for mapping lavfi outputs */
+} StreamMap;
+
+#if FFMPEG_OPT_MAP_CHANNEL
+typedef struct {
+    int  file_idx,  stream_idx,  channel_idx; // input
+    int ofile_idx, ostream_idx;               // output
+} AudioChannelMap;
+#endif
+
+typedef struct DemuxPktData {
+    // estimated dts in AV_TIME_BASE_Q,
+    // to be used when real dts is missing
+    int64_t dts_est;
+} DemuxPktData;
+
+typedef struct OptionsContext {
+    OptionGroup *g;
+
+    /* input/output options */
+    int64_t start_time;
+    int64_t start_time_eof;
+    int seek_timestamp;
+    const char *format;
+
+    SpecifierOpt *codec_names;
+    int        nb_codec_names;
+    SpecifierOpt *audio_ch_layouts;
+    int        nb_audio_ch_layouts;
+    SpecifierOpt *audio_channels;
+    int        nb_audio_channels;
+    SpecifierOpt *audio_sample_rate;
+    int        nb_audio_sample_rate;
+    SpecifierOpt *frame_rates;
+    int        nb_frame_rates;
+    SpecifierOpt *max_frame_rates;
+    int        nb_max_frame_rates;
+    SpecifierOpt *frame_sizes;
+    int        nb_frame_sizes;
+    SpecifierOpt *frame_pix_fmts;
+    int        nb_frame_pix_fmts;
+
+    /* input options */
+    int64_t input_ts_offset;
+    int loop;
+    int rate_emu;
+    float readrate;
+    double readrate_initial_burst;
+    int accurate_seek;
+    int thread_queue_size;
+    int input_sync_ref;
+    int find_stream_info;
+
+    SpecifierOpt *ts_scale;
+    int        nb_ts_scale;
+    SpecifierOpt *dump_attachment;
+    int        nb_dump_attachment;
+    SpecifierOpt *hwaccels;
+    int        nb_hwaccels;
+    SpecifierOpt *hwaccel_devices;
+    int        nb_hwaccel_devices;
+    SpecifierOpt *hwaccel_output_formats;
+    int        nb_hwaccel_output_formats;
+    SpecifierOpt *autorotate;
+    int        nb_autorotate;
+
+    /* output options */
+    StreamMap *stream_maps;
+    int     nb_stream_maps;
+#if FFMPEG_OPT_MAP_CHANNEL
+    AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
+    int           nb_audio_channel_maps; /* number of (valid) -map_channel settings */
+#endif
+    const char **attachments;
+    int       nb_attachments;
+
+    int chapters_input_file;
+
+    int64_t recording_time;
+    int64_t stop_time;
+    int64_t limit_filesize;
+    float mux_preload;
+    float mux_max_delay;
+    float shortest_buf_duration;
+    int shortest;
+    int bitexact;
+
+    int video_disable;
+    int audio_disable;
+    int subtitle_disable;
+    int data_disable;
+
+    // keys are stream indices
+    AVDictionary *streamid;
+
+    SpecifierOpt *metadata;
+    int        nb_metadata;
+    SpecifierOpt *max_frames;
+    int        nb_max_frames;
+    SpecifierOpt *bitstream_filters;
+    int        nb_bitstream_filters;
+    SpecifierOpt *codec_tags;
+    int        nb_codec_tags;
+    SpecifierOpt *sample_fmts;
+    int        nb_sample_fmts;
+    SpecifierOpt *qscale;
+    int        nb_qscale;
+    SpecifierOpt *forced_key_frames;
+    int        nb_forced_key_frames;
+    SpecifierOpt *fps_mode;
+    int        nb_fps_mode;
+    SpecifierOpt *force_fps;
+    int        nb_force_fps;
+    SpecifierOpt *frame_aspect_ratios;
+    int        nb_frame_aspect_ratios;
+    SpecifierOpt *display_rotations;
+    int        nb_display_rotations;
+    SpecifierOpt *display_hflips;
+    int        nb_display_hflips;
+    SpecifierOpt *display_vflips;
+    int        nb_display_vflips;
+    SpecifierOpt *rc_overrides;
+    int        nb_rc_overrides;
+    SpecifierOpt *intra_matrices;
+    int        nb_intra_matrices;
+    SpecifierOpt *inter_matrices;
+    int        nb_inter_matrices;
+    SpecifierOpt *chroma_intra_matrices;
+    int        nb_chroma_intra_matrices;
+#if FFMPEG_OPT_TOP
+    SpecifierOpt *top_field_first;
+    int        nb_top_field_first;
+#endif
+    SpecifierOpt *metadata_map;
+    int        nb_metadata_map;
+    SpecifierOpt *presets;
+    int        nb_presets;
+    SpecifierOpt *copy_initial_nonkeyframes;
+    int        nb_copy_initial_nonkeyframes;
+    SpecifierOpt *copy_prior_start;
+    int        nb_copy_prior_start;
+    SpecifierOpt *filters;
+    int        nb_filters;
+    SpecifierOpt *filter_scripts;
+    int        nb_filter_scripts;
+    SpecifierOpt *reinit_filters;
+    int        nb_reinit_filters;
+    SpecifierOpt *fix_sub_duration;
+    int        nb_fix_sub_duration;
+    SpecifierOpt *fix_sub_duration_heartbeat;
+    int        nb_fix_sub_duration_heartbeat;
+    SpecifierOpt *canvas_sizes;
+    int        nb_canvas_sizes;
+    SpecifierOpt *pass;
+    int        nb_pass;
+    SpecifierOpt *passlogfiles;
+    int        nb_passlogfiles;
+    SpecifierOpt *max_muxing_queue_size;
+    int        nb_max_muxing_queue_size;
+    SpecifierOpt *muxing_queue_data_threshold;
+    int        nb_muxing_queue_data_threshold;
+    SpecifierOpt *guess_layout_max;
+    int        nb_guess_layout_max;
+    SpecifierOpt *apad;
+    int        nb_apad;
+    SpecifierOpt *discard;
+    int        nb_discard;
+    SpecifierOpt *disposition;
+    int        nb_disposition;
+    SpecifierOpt *program;
+    int        nb_program;
+    SpecifierOpt *time_bases;
+    int        nb_time_bases;
+    SpecifierOpt *enc_time_bases;
+    int        nb_enc_time_bases;
+    SpecifierOpt *autoscale;
+    int        nb_autoscale;
+    SpecifierOpt *bits_per_raw_sample;
+    int        nb_bits_per_raw_sample;
+    SpecifierOpt *enc_stats_pre;
+    int        nb_enc_stats_pre;
+    SpecifierOpt *enc_stats_post;
+    int        nb_enc_stats_post;
+    SpecifierOpt *mux_stats;
+    int        nb_mux_stats;
+    SpecifierOpt *enc_stats_pre_fmt;
+    int        nb_enc_stats_pre_fmt;
+    SpecifierOpt *enc_stats_post_fmt;
+    int        nb_enc_stats_post_fmt;
+    SpecifierOpt *mux_stats_fmt;
+    int        nb_mux_stats_fmt;
+} OptionsContext;
+
+typedef struct InputFilter {
+    struct FilterGraph *graph;
+    uint8_t            *name;
+} InputFilter;
+
+typedef struct OutputFilter {
+    struct OutputStream *ost;
+    struct FilterGraph  *graph;
+    uint8_t             *name;
+
+    /* for filters that are not yet bound to an output stream,
+     * this stores the output linklabel, if any */
+    uint8_t             *linklabel;
+
+    enum AVMediaType     type;
+
+    /* pts of the last frame received from this filter, in AV_TIME_BASE_Q */
+    int64_t last_pts;
+
+    uint64_t nb_frames_dup;
+    uint64_t nb_frames_drop;
+} OutputFilter;
+
+typedef struct FilterGraph {
+    const AVClass *class;
+    int            index;
+
+    AVFilterGraph *graph;
+
+    InputFilter   **inputs;
+    int          nb_inputs;
+    OutputFilter **outputs;
+    int         nb_outputs;
+} FilterGraph;
+
+typedef struct Decoder Decoder;
+
+typedef struct InputStream {
+    const AVClass *class;
+
+    int file_index;
+    int index;
+
+    AVStream *st;
+    int discard;             /* true if stream data should be discarded */
+    int user_set_discard;
+    int decoding_needed;     /* non zero if the packets must be decoded in 'raw_fifo', see DECODING_FOR_* */
+#define DECODING_FOR_OST    1
+#define DECODING_FOR_FILTER 2
+
+    /**
+     * Codec parameters - to be used by the decoding/streamcopy code.
+     * st->codecpar should not be accessed, because it may be modified
+     * concurrently by the demuxing thread.
+     */
+    AVCodecParameters *par;
+    Decoder *decoder;
+    AVCodecContext *dec_ctx;
+    const AVCodec *dec;
+    const AVCodecDescriptor *codec_desc;
+
+    AVRational framerate_guessed;
+
+    int64_t nb_samples; /* number of samples in the last decoded audio frame before looping */
+
+    AVDictionary *decoder_opts;
+    AVRational framerate;               /* framerate forced with -r */
+#if FFMPEG_OPT_TOP
+    int top_field_first;
+#endif
+
+    int autorotate;
+
+    int fix_sub_duration;
+
+    struct sub2video {
+        int w, h;
+    } sub2video;
+
+    /* decoded data from this stream goes into all those filters
+     * currently video and audio only */
+    InputFilter **filters;
+    int        nb_filters;
+
+    /*
+     * Output targets that do not go through lavfi, i.e. subtitles or
+     * streamcopy. Those two cases are distinguished by the OutputStream
+     * having an encoder or not.
+     */
+    struct OutputStream **outputs;
+    int                nb_outputs;
+
+    int reinit_filters;
+
+    /* hwaccel options */
+    enum HWAccelID hwaccel_id;
+    enum AVHWDeviceType hwaccel_device_type;
+    char  *hwaccel_device;
+    enum AVPixelFormat hwaccel_output_format;
+
+    /* stats */
+    // number of frames/samples retrieved from the decoder
+    uint64_t frames_decoded;
+    uint64_t samples_decoded;
+    uint64_t decode_errors;
+} InputStream;
+
+typedef struct LastFrameDuration {
+    int     stream_idx;
+    int64_t duration;
+} LastFrameDuration;
+
+typedef struct InputFile {
+    const AVClass *class;
+
+    int index;
+
+    // input format has no timestamps
+    int format_nots;
+
+    AVFormatContext *ctx;
+    int eof_reached;      /* true if eof reached */
+    int eagain;           /* true if last read attempt returned EAGAIN */
+    int64_t input_ts_offset;
+    int input_sync_ref;
+    /**
+     * Effective format start time based on enabled streams.
+     */
+    int64_t start_time_effective;
+    int64_t ts_offset;
+    int64_t start_time;   /* user-specified start time in AV_TIME_BASE or AV_NOPTS_VALUE */
+    int64_t recording_time;
+
+    /* streams that ffmpeg is aware of;
+     * there may be extra streams in ctx that are not mapped to an InputStream
+     * if new streams appear dynamically during demuxing */
+    InputStream **streams;
+    int        nb_streams;
+
+    float readrate;
+    int accurate_seek;
+
+    /* when looping the input file, this queue is used by decoders to report
+     * the last frame duration back to the demuxer thread */
+    AVThreadMessageQueue *audio_duration_queue;
+    int                   audio_duration_queue_size;
+} InputFile;
+
+enum forced_keyframes_const {
+    FKF_N,
+    FKF_N_FORCED,
+    FKF_PREV_FORCED_N,
+    FKF_PREV_FORCED_T,
+    FKF_T,
+    FKF_NB
+};
+
+#define ABORT_ON_FLAG_EMPTY_OUTPUT        (1 <<  0)
+#define ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM (1 <<  1)
+
+enum EncStatsType {
+    ENC_STATS_LITERAL = 0,
+    ENC_STATS_FILE_IDX,
+    ENC_STATS_STREAM_IDX,
+    ENC_STATS_FRAME_NUM,
+    ENC_STATS_FRAME_NUM_IN,
+    ENC_STATS_TIMEBASE,
+    ENC_STATS_TIMEBASE_IN,
+    ENC_STATS_PTS,
+    ENC_STATS_PTS_TIME,
+    ENC_STATS_PTS_IN,
+    ENC_STATS_PTS_TIME_IN,
+    ENC_STATS_DTS,
+    ENC_STATS_DTS_TIME,
+    ENC_STATS_SAMPLE_NUM,
+    ENC_STATS_NB_SAMPLES,
+    ENC_STATS_PKT_SIZE,
+    ENC_STATS_BITRATE,
+    ENC_STATS_AVG_BITRATE,
+};
+
+typedef struct EncStatsComponent {
+    enum EncStatsType type;
+
+    uint8_t *str;
+    size_t   str_len;
+} EncStatsComponent;
+
+typedef struct EncStats {
+    EncStatsComponent  *components;
+    int              nb_components;
+
+    AVIOContext        *io;
+} EncStats;
+
+extern const char *const forced_keyframes_const_names[];
+
+typedef enum {
+    ENCODER_FINISHED = 1,
+    MUXER_FINISHED = 2,
+} OSTFinished ;
+
+enum {
+    KF_FORCE_SOURCE         = 1,
+#if FFMPEG_OPT_FORCE_KF_SOURCE_NO_DROP
+    KF_FORCE_SOURCE_NO_DROP = 2,
+#endif
+};
+
+typedef struct KeyframeForceCtx {
+    int          type;
+
+    int64_t      ref_pts;
+
+    // timestamps of the forced keyframes, in AV_TIME_BASE_Q
+    int64_t     *pts;
+    int       nb_pts;
+    int          index;
+
+    AVExpr      *pexpr;
+    double       expr_const_values[FKF_NB];
+
+    int          dropped_keyframe;
+} KeyframeForceCtx;
+
+typedef struct Encoder Encoder;
+
+typedef struct OutputStream {
+    const AVClass *class;
+
+    enum AVMediaType type;
+
+    int file_index;          /* file index */
+    int index;               /* stream index in the output file */
+
+    /**
+     * Codec parameters for packets submitted to the muxer (i.e. before
+     * bitstream filtering, if any).
+     */
+    AVCodecParameters *par_in;
+
+    /* input stream that is the source for this output stream;
+     * may be NULL for streams with no well-defined source, e.g.
+     * attachments or outputs from complex filtergraphs */
+    InputStream *ist;
+
+    AVStream *st;            /* stream in the output file */
+    /* dts of the last packet sent to the muxing queue, in AV_TIME_BASE_Q */
+    int64_t last_mux_dts;
+
+    AVRational enc_timebase;
+
+    Encoder *enc;
+    AVCodecContext *enc_ctx;
+
+    /* video only */
+    AVRational frame_rate;
+    AVRational max_frame_rate;
+    enum VideoSyncMethod vsync_method;
+    int is_cfr;
+    int force_fps;
+#if FFMPEG_OPT_TOP
+    int top_field_first;
+#endif
+#if FFMPEG_ROTATION_METADATA
+    int rotate_overridden;
+#endif
+    int autoscale;
+    int bitexact;
+    int bits_per_raw_sample;
+#if FFMPEG_ROTATION_METADATA
+    double rotate_override_value;
+#endif
+
+    AVRational frame_aspect_ratio;
+
+    KeyframeForceCtx kf;
+
+    /* audio only */
+#if FFMPEG_OPT_MAP_CHANNEL
+    int *audio_channels_map;             /* list of the channels id to pick from the source stream */
+    int audio_channels_mapped;           /* number of channels in audio_channels_map */
+#endif
+
+    char *logfile_prefix;
+    FILE *logfile;
+
+    OutputFilter *filter;
+
+    AVDictionary *encoder_opts;
+    AVDictionary *sws_dict;
+    AVDictionary *swr_opts;
+    char *apad;
+    OSTFinished finished;        /* no more packets should be written for this stream */
+    int unavailable;                     /* true if the steram is unavailable (possibly temporarily) */
+
+    // init_output_stream() has been called for this stream
+    // The encoder and the bitstream filters have been initialized and the stream
+    // parameters are set in the AVStream.
+    int initialized;
+
+    const char *attachment_filename;
+
+    int keep_pix_fmt;
+
+    /* stats */
+    // number of packets send to the muxer
+    atomic_uint_least64_t packets_written;
+    // number of frames/samples sent to the encoder
+    uint64_t frames_encoded;
+    uint64_t samples_encoded;
+
+    /* packet quality factor */
+    int quality;
+
+    int sq_idx_encode;
+    int sq_idx_mux;
+
+    EncStats enc_stats_pre;
+    EncStats enc_stats_post;
+
+    /*
+     * bool on whether this stream should be utilized for splitting
+     * subtitles utilizing fix_sub_duration at random access points.
+     */
+    unsigned int fix_sub_duration_heartbeat;
+} OutputStream;
+
+typedef struct OutputFile {
+    const AVClass *class;
+
+    int index;
+
+    const AVOutputFormat *format;
+    const char           *url;
+
+    OutputStream **streams;
+    int         nb_streams;
+
+    SyncQueue *sq_encode;
+
+    int64_t recording_time;  ///< desired length of the resulting file in microseconds == AV_TIME_BASE units
+    int64_t start_time;      ///< start time in microseconds == AV_TIME_BASE units
+
+    int shortest;
+    int bitexact;
+} OutputFile;
+
+// optionally attached as opaque_ref to decoded AVFrames
+typedef struct FrameData {
+    // properties that come from the decoder
+    struct {
+        uint64_t   frame_num;
+
+        int64_t    pts;
+        AVRational tb;
+    } dec;
+
+    AVRational frame_rate_filter;
+
+    int        bits_per_raw_sample;
+} FrameData;
+
+extern InputFile   **input_files;
+extern int        nb_input_files;
+
+extern OutputFile   **output_files;
+extern int         nb_output_files;
+
+extern FilterGraph **filtergraphs;
+extern int        nb_filtergraphs;
+
+extern char *vstats_filename;
+extern char *sdp_filename;
+
+extern float dts_delta_threshold;
+extern float dts_error_threshold;
+
+extern enum VideoSyncMethod video_sync_method;
+extern float frame_drop_threshold;
+extern int do_benchmark;
+extern int do_benchmark_all;
+extern int do_hex_dump;
+extern int do_pkt_dump;
+extern int copy_ts;
+extern int start_at_zero;
+extern int copy_tb;
+extern int debug_ts;
+extern int exit_on_error;
+extern int abort_on_flags;
+extern int print_stats;
+extern int64_t stats_period;
+extern int stdin_interaction;
+extern AVIOContext *progress_avio;
+extern float max_error_rate;
+
+extern char *filter_nbthreads;
+extern int filter_complex_nbthreads;
+extern int vstats_version;
+extern int auto_conversion_filters;
+
+extern const AVIOInterruptCB int_cb;
+
+extern const OptionDef options[];
+extern HWDevice *filter_hw_device;
+
+extern unsigned nb_output_dumped;
+
+extern int ignore_unknown_streams;
+extern int copy_unknown_streams;
+
+extern int recast_media;
+
+extern FILE *vstats_file;
+
+#if FFMPEG_OPT_PSNR
+extern int do_psnr;
+#endif
+
+void term_init(void);
+void term_exit(void);
+
+void show_usage(void);
+
+void remove_avoptions(AVDictionary **a, AVDictionary *b);
+int check_avoptions(AVDictionary *m);
+
+int assert_file_overwrite(const char *filename);
+char *file_read(const char *filename);
+AVDictionary *strip_specifiers(const AVDictionary *dict);
+int find_codec(void *logctx, const char *name,
+               enum AVMediaType type, int encoder, const AVCodec **codec);
+int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global);
+
+int check_filter_outputs(void);
+int filtergraph_is_simple(const FilterGraph *fg);
+int init_simple_filtergraph(InputStream *ist, OutputStream *ost,
+                            char *graph_desc);
+int init_complex_filtergraph(FilterGraph *fg);
+
+int copy_av_subtitle(AVSubtitle *dst, const AVSubtitle *src);
+int subtitle_wrap_frame(AVFrame *frame, AVSubtitle *subtitle, int copy);
+
+/**
+ * Get our axiliary frame data attached to the frame, allocating it
+ * if needed.
+ */
+FrameData *frame_data(AVFrame *frame);
+
+int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame, int keep_reference);
+int ifilter_send_eof(InputFilter *ifilter, int64_t pts, AVRational tb);
+int ifilter_sub2video(InputFilter *ifilter, const AVFrame *frame);
+void ifilter_sub2video_heartbeat(InputFilter *ifilter, int64_t pts, AVRational tb);
+
+/**
+ * Set up fallback filtering parameters from a decoder context. They will only
+ * be used if no frames are ever sent on this input, otherwise the actual
+ * parameters are taken from the frame.
+ */
+int ifilter_parameters_from_dec(InputFilter *ifilter, const AVCodecContext *dec);
+
+int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost);
+
+/**
+ * Create a new filtergraph in the global filtergraph list.
+ *
+ * @param graph_desc Graph description; an av_malloc()ed string, filtergraph
+ *                   takes ownership of it.
+ */
+int fg_create(FilterGraph **pfg, char *graph_desc);
+
+void fg_free(FilterGraph **pfg);
+
+/**
+ * Perform a step of transcoding for the specified filter graph.
+ *
+ * @param[in]  graph     filter graph to consider
+ * @param[out] best_ist  input stream where a frame would allow to continue
+ * @return  0 for success, <0 for error
+ */
+int fg_transcode_step(FilterGraph *graph, InputStream **best_ist);
+
+void fg_send_command(FilterGraph *fg, double time, const char *target,
+                     const char *command, const char *arg, int all_filters);
+
+/**
+ * Get and encode new output from specified filtergraph, without causing
+ * activity.
+ *
+ * @return  0 for success, <0 for severe errors
+ */
+int reap_filters(FilterGraph *fg, int flush);
+
+int ffmpeg_parse_options(int argc, char **argv);
+
+void enc_stats_write(OutputStream *ost, EncStats *es,
+                     const AVFrame *frame, const AVPacket *pkt,
+                     uint64_t frame_num);
+
+HWDevice *hw_device_get_by_name(const char *name);
+HWDevice *hw_device_get_by_type(enum AVHWDeviceType type);
+int hw_device_init_from_string(const char *arg, HWDevice **dev);
+int hw_device_init_from_type(enum AVHWDeviceType type,
+                             const char *device,
+                             HWDevice **dev_out);
+void hw_device_free_all(void);
+
+/**
+ * Get a hardware device to be used with this filtergraph.
+ * The returned reference is owned by the callee, the caller
+ * must ref it explicitly for long-term use.
+ */
+AVBufferRef *hw_device_for_filter(void);
+
+int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input);
+
+int dec_open(InputStream *ist);
+void dec_free(Decoder **pdec);
+
+/**
+ * Submit a packet for decoding
+ *
+ * When pkt==NULL and no_eof=0, there will be no more input. Flush decoders and
+ * mark all downstreams as finished.
+ *
+ * When pkt==NULL and no_eof=1, the stream was reset (e.g. after a seek). Flush
+ * decoders and await further input.
+ */
+int dec_packet(InputStream *ist, const AVPacket *pkt, int no_eof);
+
+int enc_alloc(Encoder **penc, const AVCodec *codec);
+void enc_free(Encoder **penc);
+
+int enc_open(OutputStream *ost, const AVFrame *frame);
+int enc_subtitle(OutputFile *of, OutputStream *ost, const AVSubtitle *sub);
+int enc_frame(OutputStream *ost, AVFrame *frame);
+int enc_flush(void);
+
+/*
+ * Initialize muxing state for the given stream, should be called
+ * after the codec/streamcopy setup has been done.
+ *
+ * Open the muxer once all the streams have been initialized.
+ */
+int of_stream_init(OutputFile *of, OutputStream *ost);
+int of_write_trailer(OutputFile *of);
+int of_open(const OptionsContext *o, const char *filename);
+void of_free(OutputFile **pof);
+
+void of_enc_stats_close(void);
+
+int of_output_packet(OutputFile *of, OutputStream *ost, AVPacket *pkt);
+
+/**
+ * @param dts predicted packet dts in AV_TIME_BASE_Q
+ */
+int of_streamcopy(OutputStream *ost, const AVPacket *pkt, int64_t dts);
+
+int64_t of_filesize(OutputFile *of);
+
+int ifile_open(const OptionsContext *o, const char *filename);
+void ifile_close(InputFile **f);
+
+/**
+ * Get next input packet from the demuxer.
+ *
+ * @param pkt the packet is written here when this function returns 0
+ * @return
+ * - 0 when a packet has been read successfully
+ * - 1 when stream end was reached, but the stream is looped;
+ *     caller should flush decoders and read from this demuxer again
+ * - a negative error code on failure
+ */
+int ifile_get_packet(InputFile *f, AVPacket **pkt);
+
+int ist_output_add(InputStream *ist, OutputStream *ost);
+int ist_filter_add(InputStream *ist, InputFilter *ifilter, int is_simple);
+
+/**
+ * Find an unused input stream of given type.
+ */
+InputStream *ist_find_unused(enum AVMediaType type);
+
+/* iterate over all input streams in all input files;
+ * pass NULL to start iteration */
+InputStream *ist_iter(InputStream *prev);
+
+/* iterate over all output streams in all output files;
+ * pass NULL to start iteration */
+OutputStream *ost_iter(OutputStream *prev);
+
+void close_output_stream(OutputStream *ost);
+int trigger_fix_sub_duration_heartbeat(OutputStream *ost, const AVPacket *pkt);
+int fix_sub_duration_heartbeat(InputStream *ist, int64_t signal_pts);
+void update_benchmark(const char *fmt, ...);
+
+/**
+ * Merge two return codes - return one of the error codes if at least one of
+ * them was negative, 0 otherwise.
+ * Currently just picks the first one, eventually we might want to do something
+ * more sophisticated, like sorting them by priority.
+ */
+static inline int err_merge(int err0, int err1)
+{
+    return (err0 < 0) ? err0 : FFMIN(err1, 0);
+}
+
+#define SPECIFIER_OPT_FMT_str  "%s"
+#define SPECIFIER_OPT_FMT_i    "%i"
+#define SPECIFIER_OPT_FMT_i64  "%"PRId64
+#define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
+#define SPECIFIER_OPT_FMT_f    "%f"
+#define SPECIFIER_OPT_FMT_dbl  "%lf"
+
+#define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
+{\
+    char namestr[128] = "";\
+    const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
+    for (int _i = 0; opt_name_##name[_i]; _i++)\
+        av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[_i], opt_name_##name[_i+1] ? (opt_name_##name[_i+2] ? ", " : " or ") : "");\
+    av_log(NULL, AV_LOG_WARNING, "Multiple %s options specified for stream %d, only the last option '-%s%s%s "SPECIFIER_OPT_FMT_##type"' will be used.\n",\
+           namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
+}
+
+#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
+{\
+    int _ret, _matches = 0;\
+    SpecifierOpt *so;\
+    for (int _i = 0; _i < o->nb_ ## name; _i++) {\
+        char *spec = o->name[_i].specifier;\
+        if ((_ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
+            outvar = o->name[_i].u.type;\
+            so = &o->name[_i];\
+            _matches++;\
+        } else if (_ret < 0)\
+            return _ret;\
+    }\
+    if (_matches > 1)\
+       WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
+}
+
+#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
+{\
+    int i;\
+    for (i = 0; i < o->nb_ ## name; i++) {\
+        char *spec = o->name[i].specifier;\
+        if (!strcmp(spec, mediatype))\
+            outvar = o->name[i].u.type;\
+    }\
+}
+
+extern const char * const opt_name_codec_names[];
+extern const char * const opt_name_codec_tags[];
+extern const char * const opt_name_frame_rates[];
+#if FFMPEG_OPT_TOP
+extern const char * const opt_name_top_field_first[];
+#endif
+
+static inline void pkt_move(void *dst, void *src)
+{
+    av_packet_move_ref(dst, src);
+}
+
+static inline void frame_move(void *dst, void *src)
+{
+    av_frame_move_ref(dst, src);
+}
+
+#endif /* FFTOOLS_FFMPEG_H */

Sources/ffmpeg/include/ffmpeg_mux.h

@@ -0,0 +1,123 @@
+/*
+ * Muxer internal APIs - should not be included outside of ffmpeg_mux*
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef FFTOOLS_FFMPEG_MUX_H
+#define FFTOOLS_FFMPEG_MUX_H
+
+#include <stdatomic.h>
+#include <stdint.h>
+
+#include "thread_queue.h"
+
+#include "libavformat/avformat.h"
+
+#include "libavcodec/packet.h"
+
+#include "libavutil/dict.h"
+#include "libavutil/fifo.h"
+#include "libavutil/thread.h"
+
+typedef struct MuxStream {
+    OutputStream ost;
+
+    // name used for logging
+    char log_name[32];
+
+    /* the packets are buffered here until the muxer is ready to be initialized */
+    AVFifo *muxing_queue;
+
+    AVBSFContext *bsf_ctx;
+    AVPacket     *bsf_pkt;
+
+    AVPacket     *pkt;
+
+    EncStats stats;
+
+    int64_t max_frames;
+
+    /*
+     * The size of the AVPackets' buffers in queue.
+     * Updated when a packet is either pushed or pulled from the queue.
+     */
+    size_t muxing_queue_data_size;
+
+    int max_muxing_queue_size;
+
+    /* Threshold after which max_muxing_queue_size will be in effect */
+    size_t muxing_queue_data_threshold;
+
+    // timestamp from which the streamcopied streams should start,
+    // in AV_TIME_BASE_Q;
+    // everything before it should be discarded
+    int64_t ts_copy_start;
+
+    /* dts of the last packet sent to the muxer, in the stream timebase
+     * used for making up missing dts values */
+    int64_t last_mux_dts;
+
+    int64_t    stream_duration;
+    AVRational stream_duration_tb;
+
+    // state for av_rescale_delta() call for audio in write_packet()
+    int64_t ts_rescale_delta_last;
+
+    // combined size of all the packets sent to the muxer
+    uint64_t data_size_mux;
+
+    int copy_initial_nonkeyframes;
+    int copy_prior_start;
+    int streamcopy_started;
+} MuxStream;
+
+typedef struct Muxer {
+    OutputFile of;
+
+    // name used for logging
+    char log_name[32];
+
+    AVFormatContext *fc;
+
+    pthread_t    thread;
+    ThreadQueue *tq;
+
+    AVDictionary *opts;
+
+    int thread_queue_size;
+
+    /* filesize limit expressed in bytes */
+    int64_t limit_filesize;
+    atomic_int_least64_t last_filesize;
+    int header_written;
+
+    SyncQueue *sq_mux;
+    AVPacket *sq_pkt;
+} Muxer;
+
+/* whether we want to print an SDP, set in of_open() */
+extern int want_sdp;
+
+int mux_check_init(Muxer *mux);
+
+static MuxStream *ms_from_ost(OutputStream *ost)
+{
+    return (MuxStream*)ost;
+}
+
+#endif /* FFTOOLS_FFMPEG_MUX_H */