#include <KisAndroidMediaEncoderRunnable.h>

Inheritance diagram for KisAndroidMediaEncoderRunnable:

Classes
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)

const KisMediaEncoderWrapperSettings	settings ()

Private Member Functions
bool	copyTemporaryToOutputFile (Context &ctx, const QString &tempPath, const QString &outputPath)

int	drain (Context &ctx, long long initialTimeout)

EncodeResult	prepare (Context &ctx)

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

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_MUXER_ADD_TRACK = 404

static constexpr int	STATUS_ERROR_START_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 405 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 849 of file KisAndroidMediaEncoderRunnable.cpp.

{
    QJniObject supports = QJniObject::callStaticObjectMethod("org/krita/android/VideoEncoder",
                                                             "getSupportsForFormat",
                                                             "(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;
    }
 
    QVector<Format::Encoder> encoders;
    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;
        }
 
        encoders.append({nameString, hardware});
    }
 
    if (!encoders.isEmpty()) {
        outSupportedFormats.append(new Format(formatId, encoders));
    }
}

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

◆ copyTemporaryToOutputFile()

bool KisAndroidMediaEncoderRunnable::copyTemporaryToOutputFile	(	Context &	ctx,
		const QString &	tempPath,
		const QString &	outputPath )

private

Definition at line 740 of file KisAndroidMediaEncoderRunnable.cpp.

{
    QFile tempFile(tempPath);
    if (!tempFile.open(QIODevice::ReadOnly)) {
        ctx.setInternalErrorMessage(
            QStringLiteral("failed to open temp file '%1': %2").arg(tempPath).arg(tempFile.errorString()));
        return false;
    }
 
    QFile outputFile(outputPath);
    if (!outputFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
        ctx.setInternalErrorMessage(
            QStringLiteral("failed to open output file '%1': %2").arg(outputPath).arg(outputFile.errorString()));
        return false;
    }
 
    QByteArray buffer;
    buffer.resize(BUFSIZ);
    while (true) {
        qint64 read = tempFile.read(buffer.data(), BUFSIZ);
        if (read < 0) {
            ctx.setInternalErrorMessage(
                QStringLiteral("failed to read from temp file '%1': %2").arg(tempPath).arg(tempFile.errorString()));
            return false;
        } else if (read > 0) {
            qint64 written = outputFile.write(buffer, read);
            if (written < 0) {
                ctx.setInternalErrorMessage(QStringLiteral("failed to write %1 byte(s) to output file '%2': %3")
                                                .arg(read)
                                                .arg(outputPath)
                                                .arg(outputFile.errorString()));
                return false;
            } else if (written != read) {
                ctx.setInternalErrorMessage(
                    QStringLiteral("tried to write %1 byte(s) to output file '%2', but only wrote %3")
                        .arg(read)
                        .arg(outputPath)
                        .arg(written));
                return false;
            }
        } else {
            if (outputFile.flush()) {
                return true;
            } else {
                ctx.setInternalErrorMessage(QStringLiteral("failed to flush output file '%1': %2")
                                                .arg(outputPath)
                                                .arg(outputFile.errorString()));
                return false;
            }
        }
    }
}

References KisAndroidMediaEncoderRunnable::Context::setInternalErrorMessage().

◆ create()

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

static

Definition at line 386 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 )

private

Definition at line 712 of file KisAndroidMediaEncoderRunnable.cpp.

{
    int count = 0;
    long long timeout = initialTimeout;
    while (true) {
        if (isCancelled()) {
            return DRAIN_CANCELLED;
        }
 
        int drainResult = int(ctx.encoder().callMethod<jint>("drain", "(J)I", jlong(timeout)));
 
        if (ctx.checkResult(QStringLiteral("drain"), 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.

◆ encode()

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

overrideprotectedvirtual

Implements KisMediaEncoderRunnable.

Definition at line 411 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 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 encoderName = QJniObject::fromString(format->getEncoderPreference(settings().formatPreferences));
        ctx.checkException(QStringLiteral("encoderName"));
 
        ctx.setEncoder(QJniObject("org/krita/android/VideoEncoder",
                                  "(IIIFLjava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V",
                                  jint(format->formatId()),
                                  jint(outputWidth),
                                  jint(outputHeight),
                                  jfloat(settings().outputFps),
                                  outputPath.object<jstring>(),
                                  tempPath.object<jstring>(),
                                  encoderName.object<jstring>(),
                                  jint(format->getBitratePreference(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;
    while (nextFrame(frame)) {
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        // Grab the next frame from disk.
        QImage inputImage;
        AVPixelFormat inputPixelFormat;
        if (frame.readImage(inputImage)) {
            switch (inputImage.format()) {
            case QImage::Format_RGB32:
                inputPixelFormat = AV_PIX_FMT_BGR0;
                break;
            case QImage::Format_ARGB32:
                inputPixelFormat = AV_PIX_FMT_BGRA;
                break;
            default:
                // The above are the only formats I can get the the recorder to
                // produce, so I'm not gonna get experimental with this.
                inputPixelFormat = AV_PIX_FMT_BGRA;
                inputImage = inputImage.convertToFormat(QImage::Format_ARGB32);
                if (inputImage.isNull()) {
                    warnFile << "Frame conversion from" << inputImage.format() << "failed";
                    continue;
                }
                break;
            }
        } else {
            continue; // Keep going, some frames may be corrupted.
        }
 
        int instances = frame.instances();
        for (int i = 0; i < instances; ++i) {
            // Grab a buffer from the encoder.
            EncodeResult prepareResult = prepare(ctx);
            if (prepareResult != EncodeResult::Completed) {
                return prepareResult;
            }
 
            // 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,
                                                          SWS_FAST_BILINEAR);
            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>("commit", "()I"));
            if (ctx.checkResult(QStringLiteral("commit"), commitResult)) {
                return EncodeResult::Failed;
            }
        }
    }
 
    if (isCancelled()) {
        return EncodeResult::Cancelled;
    }
 
    // Finish the encoder stream.
    {
        // Need a buffer from the encoder to tell it that it's done.
        EncodeResult prepareResult = prepare(ctx);
        if (prepareResult != EncodeResult::Completed) {
            return prepareResult;
        }
        // Hand an empty buffer back with the end of stream flag set.
        int finishResult = int(ctx.encoder().callMethod<jint>("finish", "()I"));
        if (ctx.checkResult(QStringLiteral("finish"), finishResult)) {
            return EncodeResult::Failed;
        }
    }
 
    // Drain all remaining frames out of the encoder.
    while (true) {
        int drainResult = drain(ctx, 1000000LL);
        if (drainResult == DRAIN_END_OF_STREAM) {
            break;
        } else if (drainResult == DRAIN_ERROR) {
            return EncodeResult::Failed;
        } else if (drainResult == DRAIN_CANCELLED) {
            return EncodeResult::Cancelled;
        } else {
            KIS_SAFE_ASSERT_RECOVER_NOOP(drainResult >= 0);
        }
    }
 
    // 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) {
            if (!copyTemporaryToOutputFile(ctx, tempFilePath, settings().outputFile)) {
                return EncodeResult::Failed;
            }
        }
    }
 
    return EncodeResult::Completed;
}

◆ getSupportedFormats()

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

static

Definition at line 396 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 )

private

Definition at line 680 of file KisAndroidMediaEncoderRunnable.cpp.

{
    while (true) {
        if (isCancelled()) {
            return EncodeResult::Cancelled;
        }
 
        int prepareResult = int(ctx.encoder().callMethod<jint>("prepare", "(J)I", jlong(100000LL)));
        if (ctx.checkResult(QStringLiteral("prepare"), prepareResult)) {
            return EncodeResult::Failed;
 
        } else if (prepareResult == STATUS_TIMEOUT) {
            int drainResult = drain(ctx, 0LL);
            if (drainResult == DRAIN_END_OF_STREAM) {
                ctx.setInternalErrorMessage(QStringLiteral("unexpected end of stream"));
                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, KisAndroidMediaEncoderRunnable::Context::setInternalErrorMessage(), STATUS_OK, and STATUS_TIMEOUT.

◆ readEncoderImage()

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

staticprivate

Definition at line 795 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 803 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 KisAndroidMediaEncoderRunnable::Context::setInternalErrorMessage().

◆ readPlanePixelStride()

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

staticprivate

Definition at line 835 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 KisAndroidMediaEncoderRunnable::Context::setInternalErrorMessage().

◆ readPlaneRowStride()

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

staticprivate

Definition at line 821 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;
}