Inheritance diagram for KisLibavMediaEncoderRunnable::Context:

Public Member Functions
	Context (KisLibavMediaEncoderRunnable *runnable, QString &outErrorMessage)

EncodeResult	encode (const KisMediaEncoderWrapperSettings &settings, const Format &format, QByteArray &paletteData, bool writePalette)

	~Context () override

Public Member Functions inherited from KisLibavEncoderContext
bool	convertFrame (QImage &inOutImage, AVPixelFormat &outPixelFormat) const

SwsContext *	getSwsContextFor (int inputWidth, int inputHeight, AVPixelFormat inputFormat, int outputWidth, int outputHeight, AVPixelFormat outputFormat, int flags)

int	getSwsFlags (const QString &scaleFilter) const

	KisLibavEncoderContext (QString *outErrorMessage=nullptr)

void	setErrorMessage (const QString &errorMessage)

void	setInternalErrorMessage (const QString &detail)

virtual	~KisLibavEncoderContext ()

Private Member Functions
bool	filterFrame (AVStream stream, AVFrame frame)

bool	handleFrame (AVStream stream, AVFrame frame)

bool	isCancelled () const

void	setInternalErrorMessageAv (const QString &detail, int err)

Static Private Member Functions
static int64_t	seekAvio (void *opaque, int64_t offset, int whence)

static int64_t	seekCurAvio (QIODevice *output, qint64 offset)

static int64_t	seekSetAvio (QIODevice *output, qint64 offset)

static int	writeAvioPacket (void *opaque, KisLibav::WriteAvioPacketBuf buf, int bufSize)

Private Attributes
AVFilterContext *	m_buffersinkContext = nullptr

AVFilterContext *	m_buffersrcContext = nullptr

AVCodecContext *	m_codecContext = nullptr

AVCodecParameters *	m_codecParameters = nullptr

AVFrame *	m_filteredFrame = nullptr

AVFilterInOut *	m_filterInputs = nullptr

AVFilterInOut *	m_filterOutputs = nullptr

AVFilterInOut *	m_filterPaletteOutputs = nullptr

AVFormatContext *	m_formatContext = nullptr

AVFrame *	m_frame = nullptr

AVFilterGraph *	m_graphContext = nullptr

AVPacket *	m_packet = nullptr

AVFrame *	m_paletteFrame = nullptr

AVFilterContext *	m_palettesrcContext = nullptr

KisLibavMediaEncoderRunnable *	m_runnable

Detailed Description

Definition at line 261 of file KisLibavMediaEncoderRunnable.cpp.

Constructor & Destructor Documentation

◆ Context()

KisLibavMediaEncoderRunnable::Context::Context	(	KisLibavMediaEncoderRunnable *	runnable,
		QString &	outErrorMessage )

inline

Definition at line 264 of file KisLibavMediaEncoderRunnable.cpp.

        : KisLibavEncoderContext(&outErrorMessage)
        , m_runnable(runnable)
    {
    }

◆ ~Context()

KisLibavMediaEncoderRunnable::Context::~Context ( )

inlineoverride

Definition at line 270 of file KisLibavMediaEncoderRunnable.cpp.

    {
        if (m_formatContext && m_formatContext->pb) {
            avio_context_free(&m_formatContext->pb);
        }
        avfilter_graph_free(&m_graphContext);
        avfilter_inout_free(&m_filterInputs);
        avfilter_inout_free(&m_filterOutputs);
        avfilter_inout_free(&m_filterPaletteOutputs);
        av_packet_free(&m_packet);
        av_frame_free(&m_frame);
        av_frame_free(&m_filteredFrame);
        av_frame_free(&m_paletteFrame);
        avcodec_parameters_free(&m_codecParameters);
        avformat_free_context(m_formatContext);
        avcodec_free_context(&m_codecContext);
    }

References m_codecContext, m_codecParameters, m_filteredFrame, m_filterInputs, m_filterOutputs, m_filterPaletteOutputs, m_formatContext, m_frame, m_graphContext, m_packet, and m_paletteFrame.

Member Function Documentation

◆ encode()

EncodeResult KisLibavMediaEncoderRunnable::Context::encode	(	const KisMediaEncoderWrapperSettings &	settings,
		const Format &	format,
		QByteArray &	paletteData,
		bool	writePalette )

inline

Definition at line 288 of file KisLibavMediaEncoderRunnable.cpp.

    {
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        QString formatName = format.formatName();
        if (formatName.isEmpty()) {
            setInternalErrorMessage(QStringLiteral("Unknown format name"));
            return EncodeResult::Failed;
        }
 
        AVCodecID codecId = format.codecId();
        if (codecId == AV_CODEC_ID_NONE) {
            setInternalErrorMessage(QStringLiteral("Unknown codec"));
            return EncodeResult::Failed;
        }
 
        const AVOutputFormat *outputFormat = av_guess_format(formatName.toUtf8().constData(), nullptr, nullptr);
        if (!outputFormat) {
            setInternalErrorMessage(QStringLiteral("av_guess_format failed for %1").arg(formatName));
            return EncodeResult::Failed;
        }
 
        const AVCodec *codec = avcodec_find_encoder(codecId);
        if (!codec) {
            setInternalErrorMessage(QStringLiteral("avcodec_find_encoder failed for %1").arg(int(codecId)));
            return EncodeResult::Failed;
        }
 
        m_codecContext = avcodec_alloc_context3(codec);
        if (!m_codecContext) {
            setInternalErrorMessage(QStringLiteral("avcodec_alloc_context3 failed for %1").arg(int(codecId)));
            return EncodeResult::Failed;
        }
 
        int outputWidth = settings.outputSize.width();
        int outputHeight = settings.outputSize.height();
        double framerate = settings.outputFps;
 
        m_codecContext->width = outputWidth;
        m_codecContext->height = outputHeight;
        m_codecContext->pix_fmt = format.pixelFormat(false);
        m_codecContext->framerate = av_d2q(framerate, 1000000000);
        m_codecContext->time_base = av_inv_q(m_codecContext->framerate);
        format.setCodecParams(m_codecContext);
 
        int err = avformat_alloc_output_context2(&m_formatContext, outputFormat, nullptr, nullptr);
        if (err != 0) {
            setInternalErrorMessageAv(QStringLiteral("avformat_alloc_output_context2 failed"), err);
            return EncodeResult::Failed;
        }
 
        format.setOutputParams(m_formatContext);
 
        AVStream *stream = avformat_new_stream(m_formatContext, nullptr);
        if (!stream) {
            setInternalErrorMessage(QStringLiteral("avformat_new_stream failed"));
            return EncodeResult::Failed;
        }
 
        stream->avg_frame_rate = m_codecContext->framerate;
        stream->time_base = m_codecContext->time_base;
        err = avcodec_open2(m_codecContext, codec, nullptr);
        if (err != 0) {
            setInternalErrorMessageAv(QStringLiteral("avcodec_open2 failed"), err);
            return EncodeResult::Failed;
        }
 
        m_codecParameters = avcodec_parameters_alloc();
        if (!m_codecParameters) {
            setInternalErrorMessage(QStringLiteral("avcodec_parameters_alloc failed"));
            return EncodeResult::Failed;
        }
 
        err = avcodec_parameters_from_context(m_codecParameters, m_codecContext);
        if (err != 0) {
            setInternalErrorMessageAv(QStringLiteral("avcodec_parameters_from_context failed"), err);
            return EncodeResult::Failed;
        }
 
        err = avcodec_parameters_copy(stream->codecpar, m_codecParameters);
        avcodec_parameters_free(&m_codecParameters);
        if (err != 0) {
            setInternalErrorMessageAv(QStringLiteral("avcodec_parameters_copy failed"), err);
            return EncodeResult::Failed;
        }
 
        if (m_formatContext->oformat->flags & AVFMT_GLOBALHEADER) {
            m_formatContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
        }
 
        QByteArray filterDesc = format.filterDesc();
        if (!filterDesc.isEmpty()) {
            const AVFilter *buffersrcFilter = avfilter_get_by_name("buffer");
            if (!buffersrcFilter) {
                setInternalErrorMessage(QStringLiteral("buffer filter not found"));
                return EncodeResult::Failed;
            }
 
            const AVFilter *buffersinkFilter = avfilter_get_by_name("buffersink");
            if (!buffersinkFilter) {
                setInternalErrorMessage(QStringLiteral("buffersink filter not found"));
                return EncodeResult::Failed;
            }
 
            m_filteredFrame = av_frame_alloc();
            if (!m_filteredFrame) {
                setInternalErrorMessage(QStringLiteral("filter av_frame_alloc failed"));
                return EncodeResult::Failed;
            }
 
            if (!paletteData.isEmpty()) {
                m_filterPaletteOutputs = avfilter_inout_alloc();
                if (!m_filterPaletteOutputs) {
                    setInternalErrorMessage(QStringLiteral("palette outputs avfilter_inout_alloc failed"));
                    return EncodeResult::Failed;
                }
            }
 
            m_filterOutputs = avfilter_inout_alloc();
            if (!m_filterOutputs) {
                setInternalErrorMessage(QStringLiteral("filter outputs avfilter_inout_alloc failed"));
                return EncodeResult::Failed;
            }
 
            m_filterInputs = avfilter_inout_alloc();
            if (!m_filterInputs) {
                setInternalErrorMessage(QStringLiteral("filter inputs avfilter_inout_alloc failed"));
                return EncodeResult::Failed;
            }
 
            m_graphContext = avfilter_graph_alloc();
            if (!m_graphContext) {
                setInternalErrorMessage(QStringLiteral("avfilter_graph_alloc failed"));
                return EncodeResult::Failed;
            }
 
            {
                QByteArray buffersrcArgs =
                    QStringLiteral("video_size=%1x%2:pix_fmt=%3:time_base=%4/%5:pixel_aspect=%6/%7")
                        .arg(outputWidth)
                        .arg(outputHeight)
                        .arg(int(format.pixelFormat(true)))
                        .arg(stream->time_base.num)
                        .arg(stream->time_base.den)
                        .arg(m_codecContext->sample_aspect_ratio.num)
                        .arg(m_codecContext->sample_aspect_ratio.den)
                        .toUtf8();
                err = avfilter_graph_create_filter(&m_buffersrcContext,
                                                   buffersrcFilter,
                                                   "in",
                                                   buffersrcArgs.constData(),
                                                   nullptr,
                                                   m_graphContext);
                if (err < 0) {
                    setInternalErrorMessageAv(QStringLiteral("buffersrc avfilter_graph_create_filter failed"), err);
                    return EncodeResult::Failed;
                }
            }
 
            if (!paletteData.isEmpty()) {
                KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paletteData.size() == KisLibav::GIF_PALETTE_BYTES,
                                                     EncodeResult::Failed);
                QByteArray palettesrcArgs =
                    QStringLiteral("video_size=%1x%1:pix_fmt=%2:time_base=1/24:pixel_aspect=0/1")
                        .arg(KisLibav::GIF_PALETTE_DIMENSION)
                        .arg(int(AV_PIX_FMT_BGRA))
                        .toUtf8();
                err = avfilter_graph_create_filter(&m_palettesrcContext,
                                                   buffersrcFilter,
                                                   "palette",
                                                   palettesrcArgs.constData(),
                                                   nullptr,
                                                   m_graphContext);
                if (err < 0) {
                    setInternalErrorMessageAv(QStringLiteral("palettesrc avfilter_graph_create_filter failed"), err);
                    return EncodeResult::Failed;
                }
            }
 
            m_buffersinkContext = avfilter_graph_alloc_filter(m_graphContext, buffersinkFilter, "out");
            if (!m_buffersinkContext) {
                setInternalErrorMessageAv(QStringLiteral("buffersink avfilter_graph_alloc_filter failed"), err);
                return EncodeResult::Failed;
            }
 
            QVector<AVPixelFormat> pixFmts = format.filterPixelFormats();
#if LIBAVUTIL_VERSION_MAJOR >= 60
            // Option int lists and "pix_fmt" got deprecated and replaced with array
            // options and "pixel_formats".
            unsigned int pixFmtsCount = 0;
            for (AVPixelFormat pixFmt : pixFmts) {
                if (pixFmt == AV_PIX_FMT_NONE) {
                    break;
                } else {
                    ++pixFmtsCount;
                }
            }
            err = av_opt_set_array(m_buffersinkContext,
                                   "pixel_formats",
                                   AV_OPT_SEARCH_CHILDREN | AV_OPT_ARRAY_REPLACE,
                                   0,
                                   pixFmtsCount,
                                   AV_OPT_TYPE_PIXEL_FMT,
                                   pixFmts.constData());
#else
            err = av_opt_set_int_list(m_buffersinkContext,
                                      "pix_fmts",
                                      pixFmts.constData(),
                                      AV_PIX_FMT_NONE,
                                      AV_OPT_SEARCH_CHILDREN);
#endif
            if (err < 0) {
                setInternalErrorMessageAv(QStringLiteral("buffersink av_opt_set failed"), err);
                return EncodeResult::Failed;
            }
 
            err = avfilter_init_str(m_buffersinkContext, nullptr);
            if (err < 0) {
                setInternalErrorMessageAv(QStringLiteral("buffersink avfilter_init_str failed"), err);
                return EncodeResult::Failed;
            }
 
            if (m_filterPaletteOutputs) {
                m_filterPaletteOutputs->name = av_strdup("palette");
                m_filterPaletteOutputs->filter_ctx = m_palettesrcContext;
                m_filterPaletteOutputs->pad_idx = 0;
                m_filterPaletteOutputs->next = nullptr;
            }
 
            m_filterOutputs->name = av_strdup("in");
            m_filterOutputs->filter_ctx = m_buffersrcContext;
            m_filterOutputs->pad_idx = 0;
            m_filterOutputs->next = m_filterPaletteOutputs;
            m_filterPaletteOutputs = nullptr;
 
            m_filterInputs->name = av_strdup("out");
            m_filterInputs->filter_ctx = m_buffersinkContext;
            m_filterInputs->pad_idx = 0;
            m_filterInputs->next = nullptr;
 
            err = avfilter_graph_parse_ptr(m_graphContext,
                                           filterDesc.constData(),
                                           &m_filterInputs,
                                           &m_filterOutputs,
                                           nullptr);
            if (err < 0) {
                setInternalErrorMessageAv(QStringLiteral("avfilter_graph_parse_ptr failed"), err);
                return EncodeResult::Failed;
            }
 
            err = avfilter_graph_config(m_graphContext, nullptr);
            if (err < 0) {
                setInternalErrorMessageAv(
                    QStringLiteral("avfilter_graph_config failed").arg(QString::fromUtf8(filterDesc)),
                    err);
                return EncodeResult::Failed;
            }
 
            avfilter_inout_free(&m_filterOutputs);
            avfilter_inout_free(&m_filterInputs);
        }
 
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        std::unique_ptr<QIODevice> output;
        if (writePalette) {
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paletteData.isEmpty(), EncodeResult::Failed);
            output = std::make_unique<QBuffer>(&paletteData);
            if (!output->open(QIODevice::WriteOnly | QIODevice::Truncate)) {
                setInternalErrorMessage(
                    QStringLiteral("failed to open palette output buffer: %1").arg(output->errorString()));
                return EncodeResult::Failed;
            }
        } else {
            output = std::make_unique<QFile>(settings.outputFile);
            if (!output->open(QIODevice::WriteOnly | QIODevice::Truncate)) {
                setInternalErrorMessage(QStringLiteral("failed to open output file '%1': %2")
                                            .arg(settings.outputFile)
                                            .arg(output->errorString()));
                return EncodeResult::Failed;
            }
        }
 
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        QByteArray buffer;
        buffer.resize(KisLibav::BUFFER_SIZE);
        m_formatContext->pb = avio_alloc_context(reinterpret_cast<unsigned char *>(buffer.data()),
                                                 buffer.size(),
                                                 AVIO_FLAG_WRITE,
                                                 output.get(),
                                                 nullptr,
                                                 &Context::writeAvioPacket,
                                                 &Context::seekAvio);
        if (!m_formatContext->pb) {
            setInternalErrorMessage(QStringLiteral("avio_alloc_context failed"));
            return EncodeResult::Failed;
        }
 
        m_formatContext->flags |= AVFMT_FLAG_CUSTOM_IO;
        m_formatContext->pb->seekable = AVIO_SEEKABLE_NORMAL;
 
        err = avformat_write_header(m_formatContext, nullptr);
        if (err != 0) {
            setInternalErrorMessageAv(QStringLiteral("avformat_write_header failed"), err);
            return EncodeResult::Failed;
        }
 
        m_frame = av_frame_alloc();
        if (!m_frame) {
            setInternalErrorMessage(QStringLiteral("av_frame_alloc failed"));
            return EncodeResult::Failed;
        }
 
        m_frame->width = outputWidth;
        m_frame->height = outputHeight;
        m_frame->format = format.pixelFormat(true);
 
        err = av_frame_get_buffer(m_frame, 0);
        if (err != 0) {
            setInternalErrorMessageAv(QStringLiteral("av_frame_get_buffer failed"), err);
            return EncodeResult::Failed;
        }
 
        m_packet = av_packet_alloc();
        if (!m_packet) {
            setInternalErrorMessage(QStringLiteral("av_packet_alloc failed"));
            return EncodeResult::Failed;
        }
 
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        if (m_palettesrcContext) {
            m_paletteFrame = av_frame_alloc();
            if (!m_paletteFrame) {
                setInternalErrorMessage(QStringLiteral("palette av_frame_alloc failed"));
                return EncodeResult::Failed;
            }
 
            m_paletteFrame->width = KisLibav::GIF_PALETTE_DIMENSION;
            m_paletteFrame->height = KisLibav::GIF_PALETTE_DIMENSION;
            m_paletteFrame->format = AV_PIX_FMT_BGRA;
 
            err = av_frame_get_buffer(m_paletteFrame, 0);
            if (err != 0) {
                setInternalErrorMessageAv(QStringLiteral("palette av_frame_get_buffer failed"), err);
                return EncodeResult::Failed;
            }
 
            err = av_frame_make_writable(m_paletteFrame);
            if (err != 0) {
                setInternalErrorMessageAv(QStringLiteral("palette av_frame_make_writable failed"), err);
                return EncodeResult::Failed;
            }
 
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paletteData.size() == KisLibav::GIF_PALETTE_BYTES,
                                                 EncodeResult::Failed);
            memcpy(m_paletteFrame->data[0], paletteData.constData(), KisLibav::GIF_PALETTE_BYTES);
            err = av_buffersrc_add_frame_flags(m_palettesrcContext, m_paletteFrame, AV_BUFFERSRC_FLAG_KEEP_REF);
            if (err < 0) {
                setInternalErrorMessageAv(QStringLiteral("palette feed av_buffersrc_add_frame_flags failed"), err);
                return EncodeResult::Failed;
            }
 
            err = av_buffersrc_add_frame_flags(m_palettesrcContext, nullptr, AV_BUFFERSRC_FLAG_KEEP_REF);
            if (err < 0) {
                setInternalErrorMessageAv(QStringLiteral("palette flush v_buffersrc_add_frame_flags failed"), err);
                return EncodeResult::Failed;
            }
        }
 
        m_frame->pts = 0;
        Frame inputFrame;
        int swsFlags = getSwsFlags(settings.scaleFilter);
        while (m_runnable->nextFrame(inputFrame)) {
            if (isCancelled()) {
                return EncodeResult::Cancelled;
            }
 
            // Grab the next frame from disk.
            QImage inputImage;
            AVPixelFormat inputPixelFormat;
            if (!inputFrame.readImage(inputImage) || !convertFrame(inputImage, inputPixelFormat)) {
                continue; // Keep going, some frames may be corrupted.
            }
 
            int inputWidth = inputImage.width();
            int inputHeight = inputImage.height();
            if (inputWidth <= 0 || inputHeight <= 0 || inputImage.isNull()) {
                setInternalErrorMessage(QStringLiteral("null frame image"));
                return EncodeResult::Failed;
            }
 
            int instances = inputFrame.instances();
            if (instances < 1) {
                setInternalErrorMessage(QStringLiteral("frame has %1 instances < 1").arg(instances));
                return EncodeResult::Failed;
            }
 
            err = av_frame_make_writable(m_frame);
            if (err != 0) {
                setInternalErrorMessageAv(QStringLiteral("frame av_frame_make_writable failed"), err);
                return EncodeResult::Failed;
            }
 
            SwsContext *swsContext = getSwsContextFor(inputWidth,
                                                      inputHeight,
                                                      inputPixelFormat,
                                                      outputWidth,
                                                      outputHeight,
                                                      AVPixelFormat(m_frame->format),
                                                      swsFlags);
            if (!swsContext) {
                setInternalErrorMessage(QStringLiteral("sws_getCachedContext failed"));
                return EncodeResult::Failed;
            }
 
            const uint8_t *data = reinterpret_cast<const uint8_t *>(inputImage.constBits());
            const int stride = inputImage.bytesPerLine();
            sws_scale(swsContext, &data, &stride, 0, inputHeight, m_frame->data, m_frame->linesize);
 
            for (int i = 0; i < instances; ++i) {
                if (!filterFrame(stream, m_frame)) {
                    return EncodeResult::Failed;
                }
                ++m_frame->pts;
            }
        }
 
        av_frame_free(&m_frame);
 
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        if (!filterFrame(stream, nullptr)) {
            return EncodeResult::Failed;
        }
 
        av_packet_free(&m_packet);
 
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        err = av_write_trailer(m_formatContext);
        if (err != 0) {
            setInternalErrorMessageAv(QStringLiteral("av_write_trailer failed"), err);
            return EncodeResult::Failed;
        }
 
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        avio_flush(m_formatContext->pb);
        avio_context_free(&m_formatContext->pb);
 
        // QIODevice doesn't have a flush function, so we gotta go via a cast.
        QFile *outputFile = qobject_cast<QFile *>(output.get());
        if (outputFile && !outputFile->flush()) {
            setInternalErrorMessage(QStringLiteral("failed to flush output file '%1': %2")
                                        .arg(settings.outputFile)
                                        .arg(outputFile->errorString()));
            return EncodeResult::Failed;
        }
        output->close();
 
        return EncodeResult::Completed;
    }

◆ filterFrame()

bool KisLibavMediaEncoderRunnable::Context::filterFrame	(	AVStream *	stream,
		AVFrame *	frame )

inlineprivate

Definition at line 776 of file KisLibavMediaEncoderRunnable.cpp.

    {
        if (m_buffersrcContext) {
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_buffersinkContext, false);
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_filteredFrame, false);
            int err = av_buffersrc_add_frame_flags(m_buffersrcContext, frame, AV_BUFFERSRC_FLAG_KEEP_REF);
            if (err < 0) {
                setInternalErrorMessageAv(QStringLiteral("feed av_buffersrc_add_frame_flags failed"), err);
                return false;
            }
 
            while (true) {
                err = av_buffersink_get_frame(m_buffersinkContext, m_filteredFrame);
                if (err == AVERROR(EAGAIN) || err == AVERROR_EOF) {
                    return true;
                } else if (err != 0) {
                    setInternalErrorMessageAv(QStringLiteral("av_buffersink_get_frame failed"), err);
                    return false;
                }
 
                bool ok = handleFrame(stream, m_filteredFrame);
                av_frame_unref(m_filteredFrame);
                return ok;
            }
        } else {
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!m_buffersinkContext, false);
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!m_filteredFrame, false);
            return handleFrame(stream, frame);
        }
    }

References handleFrame(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_buffersinkContext, m_buffersrcContext, m_filteredFrame, and setInternalErrorMessageAv().

◆ handleFrame()

bool KisLibavMediaEncoderRunnable::Context::handleFrame	(	AVStream *	stream,
		AVFrame *	frame )

inlineprivate

Definition at line 807 of file KisLibavMediaEncoderRunnable.cpp.

    {
        int err = avcodec_send_frame(m_codecContext, frame);
        if (err != 0) {
            setInternalErrorMessageAv(QStringLiteral("avcodec_send_frame failed"), err);
            return false;
        }
 
        while (true) {
            err = avcodec_receive_packet(m_codecContext, m_packet);
            if (err == AVERROR(EAGAIN) || err == AVERROR_EOF) {
                return true;
            } else if (err != 0) {
                setInternalErrorMessageAv(QStringLiteral("avcodec_receive_packet failed"), err);
                return false;
            }
 
            av_packet_rescale_ts(m_packet, m_codecContext->time_base, stream->time_base);
            m_packet->stream_index = stream->index;
 
            err = av_interleaved_write_frame(m_formatContext, m_packet);
            if (err != 0) {
                setInternalErrorMessageAv(QStringLiteral("av_interleaved_write_frame failed"), err);
                return false;
            }
        }
    }

References m_codecContext, m_formatContext, m_packet, and setInternalErrorMessageAv().

◆ isCancelled()

bool KisLibavMediaEncoderRunnable::Context::isCancelled ( ) const

inlineprivate

Definition at line 771 of file KisLibavMediaEncoderRunnable.cpp.

    {
        return m_runnable->isCancelled();
    }

References KisMediaEncoderRunnable::isCancelled(), and m_runnable.

◆ seekAvio()

static int64_t KisLibavMediaEncoderRunnable::Context::seekAvio	(	void *	opaque,
		int64_t	offset,
		int	whence )

inlinestaticprivate

Definition at line 878 of file KisLibavMediaEncoderRunnable.cpp.

    {
        QIODevice *output = static_cast<QIODevice *>(opaque);
        if (whence & AVSEEK_SIZE) {
            warnFile << "AVSEEK_SIZE unsupported with whence" << whence;
            return 0;
        } else {
            switch (whence & ~AVSEEK_FORCE) {
            case SEEK_SET:
                return seekSetAvio(output, offset);
            case SEEK_CUR:
                return seekCurAvio(output, offset);
            default:
                warnFile << "Unsupported seek whence" << whence;
                return AVERROR(EINVAL);
            }
        }
    }

References seekCurAvio(), seekSetAvio(), and warnFile.

◆ seekCurAvio()

static int64_t KisLibavMediaEncoderRunnable::Context::seekCurAvio	(	QIODevice *	output,
		qint64	offset )

inlinestaticprivate

Definition at line 863 of file KisLibavMediaEncoderRunnable.cpp.

    {
        qint64 pos = output->pos();
        if (pos < 0) {
            return AVERROR(EIO);
        }
 
        qint64 targetPos = qMax(qint64(0), pos + offset);
        if (targetPos != pos && !output->seek(targetPos)) {
            return AVERROR(EIO);
        }
 
        return targetPos;
    }

◆ seekSetAvio()

static int64_t KisLibavMediaEncoderRunnable::Context::seekSetAvio	(	QIODevice *	output,
		qint64	offset )

inlinestaticprivate

Definition at line 854 of file KisLibavMediaEncoderRunnable.cpp.

    {
        if (output->seek(offset)) {
            return offset;
        } else {
            return AVERROR(EIO);
        }
    }

◆ setInternalErrorMessageAv()

void KisLibavMediaEncoderRunnable::Context::setInternalErrorMessageAv	(	const QString &	detail,
		int	err )

inlineprivate

Definition at line 835 of file KisLibavMediaEncoderRunnable.cpp.

    {
        setInternalErrorMessage(
            QStringLiteral("%1: %2 (%3)").arg(detail).arg(QString::fromUtf8(av_err2str(err))).arg(err));
    }

References KisLibavEncoderContext::setInternalErrorMessage().

◆ writeAvioPacket()

static int KisLibavMediaEncoderRunnable::Context::writeAvioPacket	(	void *	opaque,
		KisLibav::WriteAvioPacketBuf	buf,
		int	bufSize )

inlinestaticprivate

Definition at line 841 of file KisLibavMediaEncoderRunnable.cpp.

    {
        QIODevice *output = static_cast<QIODevice *>(opaque);
        if (bufSize > 0) {
            qint64 toWrite = bufSize;
            qint64 written = output->write(reinterpret_cast<const char *>(buf), toWrite);
            if (written != toWrite) {
                return AVERROR(EIO);
            }
        }
        return bufSize;
    }