#include <KisAndroidMediaEncoderRunnable.h>

Inheritance diagram for KisAndroidMediaEncoderRunnable:

Classes
class	Audio

class	Context

struct	EncoderImage

class	Format

Static Public Member Functions
static KisAndroidMediaEncoderRunnable *	create (const KisMediaEncoderWrapperSettings &settings, QObject *parent=nullptr)

static void	getSupportedFormats (QVector< KisMediaEncoderFormat * > &outSupportedFormats)

Protected Member Functions
EncodeResult	encode (QString &outErrorMessage) override

	KisAndroidMediaEncoderRunnable (const KisMediaEncoderWrapperSettings &settings, QObject *parent)

Protected Member Functions inherited from KisMediaEncoderRunnable
bool	isCancelled () const

	KisMediaEncoderRunnable (const KisMediaEncoderWrapperSettings &settings, QObject *parent)

bool	nextFrame (Frame &outFrame)

void	rewindFrames ()

void	setOutputFrameNoMultiplier (double outputFrameNoMultiplier)

const KisMediaEncoderWrapperSettings	settings ()

Private Member Functions
int	drain (Context &ctx, long long initialTimeout, bool audio)

int	drainAudio (Context &ctx, long long initialTimeout)

int	drainVideo (Context &ctx, long long initialTimeout)

EncodeResult	prepare (Context &ctx, bool audio)

EncodeResult	prepareAudio (Context &ctx)

EncodeResult	prepareVideo (Context &ctx)

Static Private Member Functions
static void	checkFormatSupport (Context &ctx, int formatId, QVector< KisMediaEncoderFormat * > &outSupportedFormats)

static bool	readAudioInputBuffer (Context &ctx, void *&outBuffer, int &outSize)

static bool	readEncoderImage (Context &ctx, EncoderImage &outImage)

static bool	readPlaneBuffer (Context &ctx, int index, uint8_t *&outBuffer)

static bool	readPlanePixelStride (Context &ctx, int index, int &outPixelStride)

static bool	readPlaneRowStride (Context &ctx, int index, int &outRowStride)

Static Private Attributes
static constexpr int	DRAIN_CANCELLED = -3

static constexpr int	DRAIN_END_OF_STREAM = -1

static constexpr int	DRAIN_ERROR = -2

static constexpr int	FORMAT_MP4_AV1 = 2

static constexpr int	FORMAT_MP4_H264 = 0

static constexpr int	FORMAT_WEBM_VP8 = 1

static constexpr int	STATUS_END_OF_STREAM = 2

static constexpr int	STATUS_ERROR_DRAIN_AUDIO_MUXER_ADD_TRACK = 704

static constexpr int	STATUS_ERROR_DRAIN_VIDEO_MUXER_ADD_TRACK = 404

static constexpr int	STATUS_ERROR_START_AUDIO_ENCODER = 108

static constexpr int	STATUS_ERROR_START_AUDIO_FORMAT = 107

static constexpr int	STATUS_ERROR_START_VIDEO_ENCODER = 104

static constexpr int	STATUS_NEEDS_COPY = 3

static constexpr int	STATUS_OK = 0

static constexpr int	STATUS_TIMEOUT = 1

Additional Inherited Members
Public Slots inherited from KisMediaEncoderRunnable
void	slotHandleCancelRequested ()

Signals inherited from KisMediaEncoderRunnable
void	sigCancelled ()

void	sigCompleted ()

void	sigFailed (const QString &errorMessage)

void	sigProgressUpdated (int frameNo)

void	sigStarted ()

Public Member Functions inherited from KisMediaEncoderRunnable
void	run () override

Protected Types inherited from KisMediaEncoderRunnable
enum class	EncodeResult { Completed , Cancelled , Failed }

Detailed Description

Definition at line 13 of file KisAndroidMediaEncoderRunnable.h.

Constructor & Destructor Documentation

◆ KisAndroidMediaEncoderRunnable()

KisAndroidMediaEncoderRunnable::KisAndroidMediaEncoderRunnable	(	const KisMediaEncoderWrapperSettings &	settings,
		QObject *	parent )

protected

Definition at line 640 of file KisAndroidMediaEncoderRunnable.cpp.

    : KisMediaEncoderRunnable(settings, parent)
{
}

Member Function Documentation

◆ checkFormatSupport()

void KisAndroidMediaEncoderRunnable::checkFormatSupport	(	Context &	ctx,
		int	formatId,
		QVector< KisMediaEncoderFormat * > &	outSupportedFormats )

staticprivate

Definition at line 1198 of file KisAndroidMediaEncoderRunnable.cpp.

{
    QVector<Format::Encoder> videoEncoders;
    QVector<Format::Encoder> audioEncoders;
 
    const QPair<QVector<Format::Encoder> *, const char *> ps[] = {
        {&videoEncoders, "getSupportsForVideoFormat"},
        {&audioEncoders, "getSupportsForAudioFormat"},
    };
 
    for (const QPair<QVector<Format::Encoder> *, const char *> &p : ps) {
        QJniObject supports = QJniObject::callStaticObjectMethod("org/krita/android/VideoEncoder",
                                                                 p.second,
                                                                 "(I)Ljava/util/List;",
                                                                 jint(formatId));
        if (ctx.checkObject(QStringLiteral("supports"), supports)) {
            return;
        }
 
        jint count = supports.callMethod<jint>("size", "()I");
        if (ctx.checkException(QStringLiteral("size"))) {
            return;
        }
 
        for (jint i = 0; i < count; ++i) {
            QJniObject entry = supports.callObjectMethod("get", "(I)Ljava/lang/Object;", i);
            if (ctx.checkObject(QStringLiteral("entry"), entry)) {
                continue;
            }
 
            QJniObject name = entry.getObjectField("name", "Ljava/lang/String;");
            if (ctx.checkObject(QStringLiteral("name"), name)) {
                continue;
            }
 
            QString nameString = name.toString();
            if (ctx.checkException(QStringLiteral("nameString")) || nameString.isEmpty()) {
                continue;
            }
 
            bool hardware = entry.getField<jboolean>("hardware");
            if (ctx.checkException(QStringLiteral("hardware"))) {
                continue;
            }
 
            p.first->append({nameString, hardware});
        }
    }
 
    if (!videoEncoders.isEmpty()) {
        outSupportedFormats.append(new Format(formatId, videoEncoders, audioEncoders));
    }
}

References KisAndroidMediaEncoderRunnable::Context::checkException(), KisAndroidMediaEncoderRunnable::Context::checkObject(), and p.

◆ create()

KisAndroidMediaEncoderRunnable * KisAndroidMediaEncoderRunnable::create	(	const KisMediaEncoderWrapperSettings &	settings,
		QObject *	parent = nullptr )

static

Definition at line 621 of file KisAndroidMediaEncoderRunnable.cpp.

{
    if (settings.format->type() == KisMediaEncoderFormat::Type::AndroidMediaEncoder) {
        return new KisAndroidMediaEncoderRunnable(settings, parent);
    } else {
        return nullptr;
    }
}

References KisMediaEncoderFormat::AndroidMediaEncoder, KisMediaEncoderWrapperSettings::format, KisAndroidMediaEncoderRunnable(), KisMediaEncoderRunnable::settings(), and KisMediaEncoderFormat::type().

◆ drain()

int KisAndroidMediaEncoderRunnable::drain	(	Context &	ctx,
		long long	initialTimeout,
		bool	audio )

private

Definition at line 1085 of file KisAndroidMediaEncoderRunnable.cpp.

{
    const char *methodName = audio ? "drainAudio" : "drainVideo";
    QString title = audio ? QStringLiteral("drainAudio") : QStringLiteral("drainVideo");
 
    int count = 0;
    long long timeout = initialTimeout;
    while (true) {
        if (isCancelled()) {
            return DRAIN_CANCELLED;
        }
 
        int drainResult = int(ctx.encoder().callMethod<jint>(methodName, "(J)I", jlong(timeout)));
 
        if (ctx.checkResult(title, drainResult)) {
            return DRAIN_ERROR;
 
        } else if (drainResult == STATUS_TIMEOUT) {
            break;
 
        } else if (drainResult == STATUS_END_OF_STREAM) {
            return DRAIN_END_OF_STREAM;
 
        } else {
            KIS_SAFE_ASSERT_RECOVER_NOOP(drainResult == STATUS_OK);
            ++count;
        }
    }
    return count;
}

References KisAndroidMediaEncoderRunnable::Context::checkResult(), DRAIN_CANCELLED, DRAIN_END_OF_STREAM, DRAIN_ERROR, KisAndroidMediaEncoderRunnable::Context::encoder(), KisMediaEncoderRunnable::isCancelled(), KIS_SAFE_ASSERT_RECOVER_NOOP, STATUS_END_OF_STREAM, STATUS_OK, and STATUS_TIMEOUT.

◆ drainAudio()

int KisAndroidMediaEncoderRunnable::drainAudio	(	Context &	ctx,
		long long	initialTimeout )

private

Definition at line 1080 of file KisAndroidMediaEncoderRunnable.cpp.

{
    return drain(ctx, initialTimeout, true);
}

References drain().

◆ drainVideo()

int KisAndroidMediaEncoderRunnable::drainVideo	(	Context &	ctx,
		long long	initialTimeout )

private

Definition at line 1075 of file KisAndroidMediaEncoderRunnable.cpp.

{
    return drain(ctx, initialTimeout, false);
}

References drain().

◆ encode()

KisMediaEncoderRunnable::EncodeResult KisAndroidMediaEncoderRunnable::encode ( QString & outErrorMessage )

overrideprotectedvirtual

Implements KisMediaEncoderRunnable.

Definition at line 646 of file KisAndroidMediaEncoderRunnable.cpp.

{
    Format *format = static_cast<Format *>(settings().format);
 
    QTemporaryFile tempFile;
    QString tempFilePath;
    if (tempFile.open()) {
        tempFilePath = tempFile.fileName();
        tempFile.close();
    } else {
        warnFile << "Failed to open temporary file:" << tempFile.errorString();
        // Keep going, we might not actually need a temporary file.
    }
 
    Context ctx(&outErrorMessage);
    int outputWidth = settings().outputSize.width();
    int outputHeight = settings().outputSize.height();
 
    // Set up audio if we were given some.
    std::unique_ptr<Audio> audio;
    if (!settings().audioFile.isEmpty()) {
        // We always use these fixed parameters: 16 bit PCM, 2 channels and a
        // sample rate according to the format. The Android media encoder makes
        // it appear like you can create audio tracks with other parameters, but
        // if it doesn't like the parameters it just gives you something else,
        // which obviously just results in nonsense. We'll go with known good
        // parameters instead, they'll also play back consistently everywhere.
        audio = std::make_unique<Audio>(mlt_audio_s16, format->audioSampleRate(), 2);
        if (!audio->open(ctx, settings())) {
            return EncodeResult::Failed;
        }
 
        switch (audio->pullFrame(ctx)) {
        case Audio::PULL_FRAME_OK:
            break;
        case Audio::PULL_FRAME_END_OF_STREAM:
            // There's no frames, which can happen if our animation range start
            // is beyond the end of the file. Just export without audio then.
            audio.reset();
            break;
        default:
            return EncodeResult::Failed;
        }
    }
 
    // Set up the encoder.
    {
        QJniObject outputPath = QJniObject::fromString(settings().outputFile);
        if (ctx.checkObject(QStringLiteral("outputPath"), outputPath)) {
            return EncodeResult::Failed;
        }
 
        QJniObject tempPath = QJniObject::fromString(tempFilePath);
        if (ctx.checkObject(QStringLiteral("tempPath"), tempPath)) {
            return EncodeResult::Failed;
        }
 
        QJniObject videoEncoderName =
            QJniObject::fromString(format->getVideoEncoderPreference(settings().formatPreferences));
        ctx.checkException(QStringLiteral("videoEncoderName"));
 
        jint audioSampleRate;
        jint audioChannelCount;
        QJniObject audioEncoderName;
        QJniObject audioFormatName;
        if (audio) {
            audioSampleRate = jint(audio->sampleRate());
            audioChannelCount = jint(audio->channelCount());
            audioEncoderName = QJniObject::fromString(format->getAudioEncoderPreference(settings().formatPreferences));
            ctx.checkException(QStringLiteral("audioEncoderName"));
            audioFormatName = QJniObject::fromString(audio->formatName());
            ctx.checkException(QStringLiteral("audioFormatName"));
        } else {
            audioSampleRate = jint(0);
            audioChannelCount = jint(0);
        }
 
        ctx.setEncoder(QJniObject(
            "org/krita/android/VideoEncoder",
            "(IIIFLjava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;III)V",
            jint(format->formatId()),
            jint(outputWidth),
            jint(outputHeight),
            jfloat(settings().outputFps),
            outputPath.object<jstring>(),
            tempPath.object<jstring>(),
            videoEncoderName.object<jstring>(),
            jint(format->getVideoBitratePreference(settings().formatPreferences)),
            audio ? audioEncoderName.object<jstring>() : nullptr,
            audio ? audioFormatName.object<jstring>() : nullptr,
            jint(audioSampleRate),
            jint(audioChannelCount),
            jint(format->getAudioBitratePreference(settings().formatPreferences))));
        if (ctx.checkObject(QStringLiteral("encoder"), ctx.encoder())) {
            return EncodeResult::Failed;
        }
    }
 
    if (isCancelled()) {
        return EncodeResult::Cancelled;
    }
 
    // Start the encoding.
    {
        QJniObject activity = QJniObject::callStaticObjectMethod("org/qtproject/qt5/android/QtNative",
                                                                 "activity",
                                                                 "()Landroid/app/Activity;");
        if (ctx.checkObject(QStringLiteral("activity"), activity)) {
            return EncodeResult::Failed;
        }
 
        int startResult =
            int(ctx.encoder().callMethod<jint>("start", "(Landroid/content/Context;)I", activity.object<jobject>()));
        if (ctx.checkResult(QStringLiteral("start"), startResult)) {
            return EncodeResult::Failed;
        }
    }
 
    // Encode the frames.
    Frame frame;
    int swsFlags = ctx.getSwsFlags(settings().scaleFilter);
    while (nextFrame(frame)) {
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        // Grab the next frame from disk.
        QImage inputImage;
        if (!frame.readImage(inputImage)) {
            // If we don't have audio, we can just skip the frame and hope it's
            // okay. In timelapses it often is, you're not gonna notice a single
            // frame missing in the video. However, if we have an animation with
            // audio, skipping a frame would make a mess and be hard to resync,
            // so in that case we just give up and bail out.
            if (audio) {
                ctx.setInternalErrorMessage(QStringLiteral("failed to read frame %1").arg(frame.path()));
                return EncodeResult::Failed;
            } else {
                continue;
            }
        }
 
        AVPixelFormat inputPixelFormat;
        if (!ctx.convertFrame(inputImage, inputPixelFormat)) {
            // Dito to the above, try to skip frames we don't understand, don't
            // bother when there's audio involved.
            if (audio) {
                ctx.setInternalErrorMessage(QStringLiteral("failed to convert frame %1").arg(frame.path()));
                return EncodeResult::Failed;
            } else {
                continue;
            }
        }
 
        int instances = frame.instances();
        for (int i = 0; i < instances; ++i) {
            // Grab a buffer from the encoder.
            EncodeResult prepareVideoResult = prepareVideo(ctx);
            if (prepareVideoResult != EncodeResult::Completed) {
                return prepareVideoResult;
            }
 
            // Retrieve the buffer layout.
            EncoderImage encoderImage;
            if (!readEncoderImage(ctx, encoderImage)) {
                return EncodeResult::Failed;
            }
 
            // Map the buffer layout to a libswscale-befitting arrangement. The
            // layout may either have the YUV components in separate buffers or it
            // may have the U and V components combined into a single buffer, where
            // either U or V can come first. Which one we get depends on hardware.
            uint8_t *dstBuffers[4] = {nullptr, nullptr, nullptr, nullptr};
            int dstLinesizes[4] = {0, 0, 0, 0};
            AVPixelFormat outputPixelFormat;
            if (encoderImage.pixelStrideU == 1 && encoderImage.pixelStrideV == 1) {
                // Separate Y, U and V buffers.
                outputPixelFormat = AV_PIX_FMT_YUV420P;
                dstBuffers[0] = encoderImage.bufferY;
                dstBuffers[1] = encoderImage.bufferU;
                dstBuffers[2] = encoderImage.bufferV;
                dstLinesizes[0] = encoderImage.rowStrideY;
                dstLinesizes[1] = encoderImage.rowStrideU;
                dstLinesizes[2] = encoderImage.rowStrideV;
 
            } else if (encoderImage.pixelStrideU == 2 && encoderImage.pixelStrideV == 2
                       && encoderImage.bufferU + 1 == encoderImage.bufferV) {
                // One Y buffer and one combined UV buffer, U comes first.
                outputPixelFormat = AV_PIX_FMT_NV12;
                dstBuffers[0] = encoderImage.bufferY;
                dstBuffers[1] = encoderImage.bufferU;
                dstLinesizes[0] = encoderImage.rowStrideY;
                dstLinesizes[1] = encoderImage.rowStrideU;
 
            } else if (encoderImage.pixelStrideU == 2 && encoderImage.pixelStrideV == 2
                       && encoderImage.bufferV + 1 == encoderImage.bufferU) {
                // One Y buffer and one combined UV buffer, V comes first.
                outputPixelFormat = AV_PIX_FMT_NV21;
                dstBuffers[0] = encoderImage.bufferY;
                dstBuffers[1] = encoderImage.bufferV;
                dstLinesizes[0] = encoderImage.rowStrideY;
                dstLinesizes[1] = encoderImage.rowStrideV;
 
            } else {
                ctx.setInternalErrorMessage(QStringLiteral("unknown buffer format u%1/%2 v%3/%4")
                                                .arg(quintptr(encoderImage.bufferU), 0, 16)
                                                .arg(encoderImage.pixelStrideU)
                                                .arg(quintptr(encoderImage.bufferV), 0, 16)
                                                .arg(encoderImage.pixelStrideV));
                return EncodeResult::Failed;
            }
 
            SwsContext *swsContext = ctx.getSwsContextFor(inputImage.width(),
                                                          inputImage.height(),
                                                          inputPixelFormat,
                                                          outputWidth,
                                                          outputHeight,
                                                          outputPixelFormat,
                                                          swsFlags);
            if (!swsContext) {
                ctx.setInternalErrorMessage(QStringLiteral("sws_getCachedContext"));
                return EncodeResult::Failed;
            }
 
            if (instances == 1) {
                // Just a single frame, scale it into the native buffer.
                const uint8_t *srcBuffers[] = {inputImage.bits(), nullptr, nullptr, nullptr};
                const int srcLinesizes[] = {inputImage.bytesPerLine(), 0, 0, 0};
                sws_scale(swsContext, srcBuffers, srcLinesizes, 0, inputImage.height(), dstBuffers, dstLinesizes);
 
            } else {
                // Repeated frame, scale it into an intermediate buffer, then
                // copy it over to the native one for each instance.
                if (i == 0 || ctx.imageFormat() != outputPixelFormat) {
                    if (ctx.imageFormat() != outputPixelFormat) {
                        if (!ctx.allocateImage(outputWidth, outputHeight, outputPixelFormat)) {
                            warnFile << "Encoder changed pixel format from" << int(ctx.imageFormat()) << "to"
                                     << int(outputPixelFormat);
                            return EncodeResult::Failed;
                        }
                    }
 
                    const uint8_t *srcBuffers[] = {inputImage.bits(), nullptr, nullptr, nullptr};
                    const int srcLinesizes[] = {inputImage.bytesPerLine(), 0, 0, 0};
                    sws_scale(swsContext,
                              srcBuffers,
                              srcLinesizes,
                              0,
                              inputImage.height(),
                              ctx.imageBuffers(),
                              ctx.imageLinesizes());
                }
 
                av_image_copy2(dstBuffers,
                               dstLinesizes,
                               ctx.imageBuffers(),
                               ctx.imageLinesizes(),
                               outputPixelFormat,
                               outputWidth,
                               outputHeight);
            }
 
            int commitResult = int(ctx.encoder().callMethod<jint>("commitVideo", "()I"));
            if (ctx.checkResult(QStringLiteral("commitVideo"), commitResult)) {
                return EncodeResult::Failed;
            }
 
            if (audio && !audio->isFinished()) {
                int pullFrameResult = audio->pullFrame(ctx);
                if (pullFrameResult == Audio::PULL_FRAME_OK) {
                    do {
                        EncodeResult prepareAudioResult = prepareAudio(ctx);
                        if (prepareAudioResult != EncodeResult::Completed) {
                            return prepareAudioResult;
                        }
 
                        if (!audio->pushSamples(ctx)) {
                            return EncodeResult::Failed;
                        }
                    } while (audio->isSampleDataRemaining());
                    audio->finishFrame();
 
                } else if (pullFrameResult == Audio::PULL_FRAME_END_OF_STREAM) {
                    EncodeResult prepareAudioResult = prepareAudio(ctx);
                    if (prepareAudioResult != EncodeResult::Completed) {
                        return prepareAudioResult;
                    }
 
                    if (!audio->finish(ctx)) {
                        return EncodeResult::Failed;
                    }
 
                } else {
                    return EncodeResult::Failed;
                }
            }
        }
    }
 
    if (isCancelled()) {
        return EncodeResult::Cancelled;
    }
 
    // Finish the encoder streams.
    {
        // Need a buffer from the encoder to tell it that it's done.
        EncodeResult prepareVideoResult = prepareVideo(ctx);
        if (prepareVideoResult != EncodeResult::Completed) {
            return prepareVideoResult;
        }
 
        // Hand empty buffer back with the end of stream flag set.
        int finishVideoResult = int(ctx.encoder().callMethod<jint>("finishVideo", "()I"));
        if (ctx.checkResult(QStringLiteral("finishVideo"), finishVideoResult)) {
            return EncodeResult::Failed;
        }
 
        // Same procedure with audio, but it might already have finished.
        if (audio && !audio->isFinished()) {
            EncodeResult prepareAudioResult = prepareAudio(ctx);
            if (prepareAudioResult != EncodeResult::Completed) {
                return prepareAudioResult;
            }
 
            if (!audio->finish(ctx)) {
                return EncodeResult::Failed;
            }
        }
    }
 
    // Drain all remaining frames and samples out of the encoders.
    bool videoStreamEnded = false;
    bool audioStreamEnded = !audio;
    do {
        if (!videoStreamEnded) {
            int drainVideoResult = drainVideo(ctx, 1000000LL);
            if (drainVideoResult == DRAIN_END_OF_STREAM) {
                videoStreamEnded = true;
            } else if (drainVideoResult == DRAIN_ERROR) {
                return EncodeResult::Failed;
            } else if (drainVideoResult == DRAIN_CANCELLED) {
                return EncodeResult::Cancelled;
            } else {
                KIS_SAFE_ASSERT_RECOVER_NOOP(drainVideoResult >= 0);
            }
        }
        if (!audioStreamEnded) {
            int drainAudioResult = drainAudio(ctx, 1000000LL);
            if (drainAudioResult == DRAIN_END_OF_STREAM) {
                audioStreamEnded = true;
            } else if (drainAudioResult == DRAIN_ERROR) {
                return EncodeResult::Failed;
            } else if (drainAudioResult == DRAIN_CANCELLED) {
                return EncodeResult::Cancelled;
            } else {
                KIS_SAFE_ASSERT_RECOVER_NOOP(drainAudioResult >= 0);
            }
        }
    } while (!videoStreamEnded || !audioStreamEnded);
 
    // Close the encoder, copy the temporary file to the output file if needed.
    {
        int closeResult = int(ctx.encoder().callMethod<jint>("close", "()I"));
        if (ctx.checkResult(QStringLiteral("close"), closeResult)) {
            return EncodeResult::Failed;
        }
 
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        if (closeResult == STATUS_NEEDS_COPY) {
            QString copyErrorMessage;
            if (!KisAndroidUtils::copyFile(tempFilePath, settings().outputFile, &copyErrorMessage)) {
                ctx.setInternalErrorMessage(copyErrorMessage);
                return EncodeResult::Failed;
            }
        }
    }
 
    return EncodeResult::Completed;
}

◆ getSupportedFormats()

void KisAndroidMediaEncoderRunnable::getSupportedFormats ( QVector< KisMediaEncoderFormat * > & outSupportedFormats )

static

Definition at line 631 of file KisAndroidMediaEncoderRunnable.cpp.

{
    Context ctx;
    int formatIds[] = {FORMAT_MP4_H264, FORMAT_WEBM_VP8, FORMAT_MP4_AV1};
    for (int formatId : formatIds) {
        checkFormatSupport(ctx, formatId, outSupportedFormats);
    }
}

References checkFormatSupport(), FORMAT_MP4_AV1, FORMAT_MP4_H264, and FORMAT_WEBM_VP8.

◆ prepare()

KisMediaEncoderRunnable::EncodeResult KisAndroidMediaEncoderRunnable::prepare	(	Context &	ctx,
		bool	audio )

private

Definition at line 1039 of file KisAndroidMediaEncoderRunnable.cpp.

{
    const char *methodName = audio ? "prepareAudio" : "prepareVideo";
    QString title = audio ? QStringLiteral("prepareAudio") : QStringLiteral("prepareVideo");
 
    while (true) {
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        int prepareResult = int(ctx.encoder().callMethod<jint>(methodName, "(J)I", jlong(100000LL)));
        if (ctx.checkResult(title, prepareResult)) {
            return EncodeResult::Failed;
 
        } else if (prepareResult == STATUS_TIMEOUT) {
            int drainResult = drain(ctx, 0LL, audio);
            if (drainResult == DRAIN_END_OF_STREAM) {
                ctx.setInternalErrorMessage(QStringLiteral("unexpected end of %1 stream")
                                                .arg(audio ? QStringLiteral("audio") : QStringLiteral("video")));
                return EncodeResult::Failed;
            } else if (drainResult == DRAIN_ERROR) {
                return EncodeResult::Failed;
            } else if (drainResult == DRAIN_CANCELLED) {
                return EncodeResult::Cancelled;
            } else {
                KIS_SAFE_ASSERT_RECOVER_NOOP(drainResult >= 0);
            }
 
        } else {
            KIS_SAFE_ASSERT_RECOVER_NOOP(prepareResult == STATUS_OK);
            break;
        }
    }
    return EncodeResult::Completed;
}

References KisMediaEncoderRunnable::Cancelled, KisAndroidMediaEncoderRunnable::Context::checkResult(), KisMediaEncoderRunnable::Completed, drain(), DRAIN_CANCELLED, DRAIN_END_OF_STREAM, DRAIN_ERROR, KisAndroidMediaEncoderRunnable::Context::encoder(), KisMediaEncoderRunnable::Failed, KisMediaEncoderRunnable::isCancelled(), KIS_SAFE_ASSERT_RECOVER_NOOP, KisLibavEncoderContext::setInternalErrorMessage(), STATUS_OK, and STATUS_TIMEOUT.

◆ prepareAudio()

KisMediaEncoderRunnable::EncodeResult KisAndroidMediaEncoderRunnable::prepareAudio ( Context & ctx )

private

Definition at line 1034 of file KisAndroidMediaEncoderRunnable.cpp.

{
    return prepare(ctx, true);
}

References prepare().

◆ prepareVideo()

KisMediaEncoderRunnable::EncodeResult KisAndroidMediaEncoderRunnable::prepareVideo ( Context & ctx )

private

Definition at line 1029 of file KisAndroidMediaEncoderRunnable.cpp.

{
    return prepare(ctx, false);
}

References prepare().

◆ readAudioInputBuffer()

bool KisAndroidMediaEncoderRunnable::readAudioInputBuffer	(	Context &	ctx,
		void *&	outBuffer,
		int &	outSize )

staticprivate

Definition at line 1170 of file KisAndroidMediaEncoderRunnable.cpp.

{
    QJniObject audioBuffer = ctx.encoder().callObjectMethod("getInputAudioBuffer", "()Ljava/nio/ByteBuffer;", jint());
    if (ctx.checkObject(QStringLiteral("audioBuffer"), audioBuffer)) {
        return false;
    }
 
    void *buffer = ctx.env()->GetDirectBufferAddress(audioBuffer.object<jobject>());
    if (!buffer) {
        ctx.setInternalErrorMessage(QStringLiteral("null audio buffer"));
        return false;
    }
 
    jint size = audioBuffer.callMethod<jint>("remaining", "()I");
    if (ctx.checkException(QStringLiteral("remaining"))) {
        return false;
    }
 
    if (size <= 0) {
        ctx.setInternalErrorMessage(QStringLiteral("audio buffer with size %1").arg(size));
        return false;
    }
 
    outBuffer = buffer;
    outSize = size;
    return true;
}

References KisAndroidMediaEncoderRunnable::Context::checkException(), KisAndroidMediaEncoderRunnable::Context::checkObject(), KisAndroidMediaEncoderRunnable::Context::encoder(), KisAndroidMediaEncoderRunnable::Context::env(), and KisLibavEncoderContext::setInternalErrorMessage().

◆ readEncoderImage()

bool KisAndroidMediaEncoderRunnable::readEncoderImage	(	Context &	ctx,
		EncoderImage &	outImage )

staticprivate

Definition at line 1116 of file KisAndroidMediaEncoderRunnable.cpp.

{
    return readPlaneBuffer(ctx, 0, outImage.bufferY) && readPlaneBuffer(ctx, 1, outImage.bufferU)
        && readPlaneBuffer(ctx, 2, outImage.bufferV) && readPlaneRowStride(ctx, 0, outImage.rowStrideY)
        && readPlaneRowStride(ctx, 1, outImage.rowStrideU) && readPlaneRowStride(ctx, 2, outImage.rowStrideV)
        && readPlanePixelStride(ctx, 1, outImage.pixelStrideU) && readPlanePixelStride(ctx, 2, outImage.pixelStrideV);
}

◆ readPlaneBuffer()

bool KisAndroidMediaEncoderRunnable::readPlaneBuffer	(	Context &	ctx,
		int	index,
		uint8_t *&	outBuffer )

staticprivate

Definition at line 1124 of file KisAndroidMediaEncoderRunnable.cpp.

{
    QJniObject plane =
        ctx.encoder().callObjectMethod("getInputImagePlaneBuffer", "(I)Ljava/nio/ByteBuffer;", jint(index));
    if (ctx.checkObject(QStringLiteral("plane"), plane)) {
        return false;
    }
 
    uint8_t *buffer = static_cast<uint8_t *>(ctx.env()->GetDirectBufferAddress(plane.object<jobject>()));
    if (!buffer) {
        ctx.setInternalErrorMessage(QStringLiteral("null plane buffer %1").arg(index));
        return false;
    }
 
    outBuffer = buffer;
    return true;
}

References KisAndroidMediaEncoderRunnable::Context::checkObject(), KisAndroidMediaEncoderRunnable::Context::encoder(), KisAndroidMediaEncoderRunnable::Context::env(), and KisLibavEncoderContext::setInternalErrorMessage().

◆ readPlanePixelStride()

bool KisAndroidMediaEncoderRunnable::readPlanePixelStride	(	Context &	ctx,
		int	index,
		int &	outPixelStride )

staticprivate

Definition at line 1156 of file KisAndroidMediaEncoderRunnable.cpp.

{
    jint pixelStride = ctx.encoder().callMethod<jint>("getInputImagePlanePixelStride", "(I)I", jint(index));
    if (ctx.checkException(QStringLiteral("pixelStride"))) {
        return false;
    } else if (pixelStride <= 0) {
        ctx.setInternalErrorMessage(QStringLiteral("invalid pixel stride %1: %2").arg(index).arg(pixelStride));
        return false;
    }
 
    outPixelStride = int(pixelStride);
    return true;
}

References KisAndroidMediaEncoderRunnable::Context::checkException(), KisAndroidMediaEncoderRunnable::Context::encoder(), and KisLibavEncoderContext::setInternalErrorMessage().

◆ readPlaneRowStride()

bool KisAndroidMediaEncoderRunnable::readPlaneRowStride	(	Context &	ctx,
		int	index,
		int &	outRowStride )

staticprivate

Definition at line 1142 of file KisAndroidMediaEncoderRunnable.cpp.

{
    jint rowStride = ctx.encoder().callMethod<jint>("getInputImagePlaneRowStride", "(I)I", jint(index));
    if (ctx.checkException(QStringLiteral("rowStride"))) {
        return false;
    } else if (rowStride <= 0) {
        ctx.setInternalErrorMessage(QStringLiteral("invalid row stride %1: %2").arg(index).arg(rowStride));
        return false;
    }
 
    outRowStride = int(rowStride);
    return true;
}