common/jni/NdkMediaCodec-jni.cpp

/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* Original code copied from NDK Native-media sample code */

//#define LOG_NDEBUG 0
#define LOG_TAG "NdkMediaCodec-jni"
#include <log/log.h>

#include <android/native_window_jni.h>
#include <assert.h>
#include <jni.h>
#include <string.h>
#include <unistd.h>


#include "media/NdkMediaExtractor.h"
#include "media/NdkMediaCodec.h"
#include "media/NdkMediaCrypto.h"
#include "media/NdkMediaDataSource.h"
#include "media/NdkMediaFormat.h"
#include "media/NdkMediaMuxer.h"

extern "C" jlong Java_android_media_cts_NdkMediaCodec_AMediaCodecCreateCodecByName(
        JNIEnv *env, jclass /*clazz*/, jstring name) {

    if (name == NULL) {
        return 0;
    }

    const char *tmp = env->GetStringUTFChars(name, NULL);
    if (tmp == NULL) {
        return 0;
    }

    AMediaCodec *codec = AMediaCodec_createCodecByName(tmp);
    if (codec == NULL) {
        env->ReleaseStringUTFChars(name, tmp);
        return 0;
    }

    env->ReleaseStringUTFChars(name, tmp);
    return reinterpret_cast<jlong>(codec);

}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecDelete(
        JNIEnv * /*env*/, jclass /*clazz*/, jlong codec) {
    media_status_t err = AMediaCodec_delete(reinterpret_cast<AMediaCodec *>(codec));
    return err == AMEDIA_OK;
}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecStart(
        JNIEnv * /*env*/, jclass /*clazz*/, jlong codec) {
    media_status_t err = AMediaCodec_start(reinterpret_cast<AMediaCodec *>(codec));
    return err == AMEDIA_OK;
}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecStop(
        JNIEnv * /*env*/, jclass /*clazz*/, jlong codec) {
    media_status_t err = AMediaCodec_stop(reinterpret_cast<AMediaCodec *>(codec));
    return err == AMEDIA_OK;
}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecConfigure(
        JNIEnv *env,
        jclass /*clazz*/,
        jlong codec,
        jstring mime,
        jint width,
        jint height,
        jint colorFormat,
        jint bitRate,
        jint frameRate,
        jint iFrameInterval,
        jobject csd0,
        jobject csd1,
        jint flags,
        jint lowLatency,
        jobject surface,
        jint range,
        jint standard,
        jint transfer) {

    AMediaFormat* format = AMediaFormat_new();
    if (format == NULL) {
        return false;
    }

    const char *tmp = env->GetStringUTFChars(mime, NULL);
    if (tmp == NULL) {
        AMediaFormat_delete(format);
        return false;
    }

    AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, tmp);
    env->ReleaseStringUTFChars(mime, tmp);

    const char *keys[] = {
            AMEDIAFORMAT_KEY_WIDTH,
            AMEDIAFORMAT_KEY_HEIGHT,
            AMEDIAFORMAT_KEY_COLOR_FORMAT,
            AMEDIAFORMAT_KEY_BIT_RATE,
            AMEDIAFORMAT_KEY_FRAME_RATE,
            AMEDIAFORMAT_KEY_I_FRAME_INTERVAL,
            // need to specify the actual string, since this test needs
            // to run on API 29, where the symbol doesn't exist
            "low-latency", // AMEDIAFORMAT_KEY_LOW_LATENCY
            AMEDIAFORMAT_KEY_COLOR_RANGE,
            AMEDIAFORMAT_KEY_COLOR_STANDARD,
            AMEDIAFORMAT_KEY_COLOR_TRANSFER,
    };

    jint values[] = {width, height, colorFormat, bitRate, frameRate, iFrameInterval, lowLatency,
                     range, standard, transfer};
    for (size_t i = 0; i < sizeof(values) / sizeof(values[0]); i++) {
        if (values[i] >= 0) {
            AMediaFormat_setInt32(format, keys[i], values[i]);
        }
    }

    if (csd0 != NULL) {
        void *csd0Ptr = env->GetDirectBufferAddress(csd0);
        jlong csd0Size = env->GetDirectBufferCapacity(csd0);
        AMediaFormat_setBuffer(format, "csd-0", csd0Ptr, csd0Size);
    }

    if (csd1 != NULL) {
        void *csd1Ptr = env->GetDirectBufferAddress(csd1);
        jlong csd1Size = env->GetDirectBufferCapacity(csd1);
        AMediaFormat_setBuffer(format, "csd-1", csd1Ptr, csd1Size);
    }

    media_status_t err = AMediaCodec_configure(
            reinterpret_cast<AMediaCodec *>(codec),
            format,
            surface == NULL ? NULL : ANativeWindow_fromSurface(env, surface),
            NULL,
            flags);

    AMediaFormat_delete(format);
    return err == AMEDIA_OK;

}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecSetInputSurface(
        JNIEnv* env, jclass /*clazz*/, jlong codec, jobject surface) {

    media_status_t err = AMediaCodec_setInputSurface(
            reinterpret_cast<AMediaCodec *>(codec),
            ANativeWindow_fromSurface(env, surface));

    return err == AMEDIA_OK;

}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecSetNativeInputSurface(
        JNIEnv* /*env*/, jclass /*clazz*/, jlong codec, jlong nativeWindow) {

    media_status_t err = AMediaCodec_setInputSurface(
            reinterpret_cast<AMediaCodec *>(codec),
            reinterpret_cast<ANativeWindow *>(nativeWindow));

    return err == AMEDIA_OK;

}

extern "C" jlong Java_android_media_cts_NdkMediaCodec_AMediaCodecCreateInputSurface(
        JNIEnv* /*env*/, jclass /*clazz*/, jlong codec) {

    ANativeWindow *nativeWindow;
    media_status_t err = AMediaCodec_createInputSurface(
            reinterpret_cast<AMediaCodec *>(codec),
            &nativeWindow);

     if (err == AMEDIA_OK) {
         return reinterpret_cast<jlong>(nativeWindow);
     }

     return 0;

}

extern "C" jlong Java_android_media_cts_NdkMediaCodec_AMediaCodecCreatePersistentInputSurface(
        JNIEnv* /*env*/, jclass /*clazz*/) {

    ANativeWindow *nativeWindow;
    media_status_t err = AMediaCodec_createPersistentInputSurface(&nativeWindow);

     if (err == AMEDIA_OK) {
         return reinterpret_cast<jlong>(nativeWindow);
     }

     return 0;

}

extern "C" jstring Java_android_media_cts_NdkMediaCodec_AMediaCodecGetOutputFormatString(
        JNIEnv* env, jclass /*clazz*/, jlong codec) {

    AMediaFormat *format = AMediaCodec_getOutputFormat(reinterpret_cast<AMediaCodec *>(codec));
    const char *str = AMediaFormat_toString(format);
    jstring jstr = env->NewStringUTF(str);
    AMediaFormat_delete(format);
    return jstr;

}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecSignalEndOfInputStream(
        JNIEnv* /*env*/, jclass /*clazz*/, jlong codec) {

    media_status_t err = AMediaCodec_signalEndOfInputStream(reinterpret_cast<AMediaCodec *>(codec));
    return err == AMEDIA_OK;

}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecReleaseOutputBuffer(
        JNIEnv* /*env*/, jclass /*clazz*/, jlong codec, jint index, jboolean render) {

    media_status_t err = AMediaCodec_releaseOutputBuffer(
            reinterpret_cast<AMediaCodec *>(codec),
            index,
            render);

    return err == AMEDIA_OK;

}

static jobject AMediaCodecGetBuffer(
        JNIEnv* env,
        jlong codec,
        jint index,
        uint8_t *(*getBuffer)(AMediaCodec*, size_t, size_t*)) {

    size_t bufsize;
    uint8_t *buf = getBuffer(
            reinterpret_cast<AMediaCodec *>(codec),
            index,
            &bufsize);

    return env->NewDirectByteBuffer(buf, bufsize);

}

extern "C" jobject Java_android_media_cts_NdkMediaCodec_AMediaCodecGetOutputBuffer(
        JNIEnv* env, jclass /*clazz*/, jlong codec, jint index) {

    return AMediaCodecGetBuffer(env, codec, index, AMediaCodec_getOutputBuffer);

}

extern "C" jlongArray Java_android_media_cts_NdkMediaCodec_AMediaCodecDequeueOutputBuffer(
        JNIEnv* env, jclass /*clazz*/, jlong codec, jlong timeoutUs) {

    AMediaCodecBufferInfo info;
    memset(&info, 0, sizeof(info));
    int status = AMediaCodec_dequeueOutputBuffer(
        reinterpret_cast<AMediaCodec *>(codec),
        &info,
        timeoutUs);

    jlong ret[5] = {0};
    ret[0] = status;
    ret[1] = 0; // NdkMediaCodec calls ABuffer::data, which already adds offset
    ret[2] = info.size;
    ret[3] = info.presentationTimeUs;
    ret[4] = info.flags;

    jlongArray jret = env->NewLongArray(5);
    env->SetLongArrayRegion(jret, 0, 5, ret);
    return jret;

}

extern "C" jobject Java_android_media_cts_NdkMediaCodec_AMediaCodecGetInputBuffer(
        JNIEnv* env, jclass /*clazz*/, jlong codec, jint index) {

    return AMediaCodecGetBuffer(env, codec, index, AMediaCodec_getInputBuffer);

}

extern "C" jint Java_android_media_cts_NdkMediaCodec_AMediaCodecDequeueInputBuffer(
        JNIEnv* /*env*/, jclass /*clazz*/, jlong codec, jlong timeoutUs) {

    return AMediaCodec_dequeueInputBuffer(
            reinterpret_cast<AMediaCodec *>(codec),
            timeoutUs);

}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecQueueInputBuffer(
        JNIEnv* /*env*/,
        jclass /*clazz*/,
        jlong codec,
        jint index,
        jint offset,
        jint size,
        jlong presentationTimeUs,
        jint flags) {

    media_status_t err = AMediaCodec_queueInputBuffer(
            reinterpret_cast<AMediaCodec *>(codec),
            index,
            offset,
            size,
            presentationTimeUs,
            flags);

    return err == AMEDIA_OK;

}

extern "C" jboolean Java_android_media_cts_NdkMediaCodec_AMediaCodecSetParameter(
        JNIEnv* env, jclass /*clazz*/, jlong codec, jstring jkey, jint value) {

    AMediaFormat* params = AMediaFormat_new();
    if (params == NULL) {
        return false;
    }

    const char *key = env->GetStringUTFChars(jkey, NULL);
    if (key == NULL) {
        AMediaFormat_delete(params);
        return false;
    }

    AMediaFormat_setInt32(params, key, value);
    media_status_t err = AMediaCodec_setParameters(
            reinterpret_cast<AMediaCodec *>(codec),
            params);
    env->ReleaseStringUTFChars(jkey, key);
    AMediaFormat_delete(params);
    return err == AMEDIA_OK;

}