Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

在安卓中使用oboe项目如何在C++中判断是否支持24位的录音

  1. User

    在安卓中使用oboe项目如何在C++中判断是否支持24位的录音

  2. Assistant

    要在安卓中使用oboe项目来判断是否支持24位的录音,可以调用oboe库的函数,先获取当前设备支持的最大的采样位数,然后与24比较即可。

    以下是示例代码:

    #include <oboe/Oboe.h>
    
    // 判断是否支持24位采样
    bool isSupport24Bit() {
        oboe::AudioStreamBuilder builder;
        int maxBits = builder.getDefaultSampleFormat() * 8; // 获取设备支持的最大采样位数
        return (maxBits >= 24); // 比较是否支持24位采样
    }
    

    在使用该函数前,需要先在项目中添加oboe库的依赖。

  3. User

    没有getDefaultSampleFormat这个方法

  4. Assistant

    抱歉,可能是我理解有误。getDefaultSampleFormat()这个方法在Oboe 1.3.0及之后的版本才被引入。

    如果你使用的是早期版本的Oboe库,则应该使用oboe::AudioStream::getFormat()方法来获取当前设备支持的音频格式,如下所示:

    #include <oboe/Oboe.h>
    
    // 判断是否支持24位采样
    bool isSupport24Bit() {
        oboe::AudioStreamBuilder builder;
        oboe::AudioStream *stream = nullptr;
        // 创建一个临时流,并获取当前设备支持的音频格式
        if (builder.openStream(&stream) == oboe::Result::OK) {
            const oboe::AudioFormat format = stream->getFormat();
            stream->close();
            // 根据音频格式判断是否支持24位采样
            switch (format) {
                case oboe::AudioFormat::I24:
                case oboe::AudioFormat::FLOAT:
                    return true;
                default:
                    return false;
            }
        } else {
            return false;
        }
    }
    

    在上述代码中,我们创建一个临时的音频流,并通过调用AudioStream::getFormat()方法获取当前设备支持的最大采样位数。根据不同的采样位数来判断是否支持24位的录音。

  5. User

    fun isSupport24bit():Boolean{ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { LogUtil.d("是否支持24位") AudioTrack.ERROR_BAD_VALUE!=AudioTrack.getMinBufferSize( 48000, AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_24BIT_PACKED ) }else false } c++如何调用以上kotlin代码

  6. Assistant

    要在 C++ 中调用 Kotlin 代码,需要使用 JNI(Java Native Interface)技术。下面是一个简单的示例:

    首先在 Kotlin 中定义一个静态方法 isSupport24bit:

    object AudioUtil {
        @JvmStatic
        fun isSupport24bit(): Boolean {
            return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                Log.d("AudioUtil", "是否支持24位")
                AudioTrack.ERROR_BAD_VALUE != AudioTrack.getMinBufferSize(
                    48000,
                    AudioFormat.CHANNEL_OUT_MONO,
                    AudioFormat.ENCODING_PCM_24BIT_PACKED
                )
            } else false
        }
    }
    

    这个方法会返回当前设备是否支持 24 位的音频录制。我们使用 @JvmStatic 注解表示它是一个静态方法,它会被编译成 Java 类,供 C++ 代码调用。

    接下来,在 C++ 代码中使用 JNI 调用该静态方法:

    #include <jni.h>
    
    JNIEXPORT jboolean JNICALL Java_com_example_audio_AudioUtil_isSupport24bit(JNIEnv *env, jobject obj)
    {
        jclass clazz = env->FindClass("com/example/audio/AudioUtil");
        jmethodID methodId = env->GetStaticMethodID(clazz, "isSupport24bit", "()Z");
        jboolean result = env->CallStaticBooleanMethod(clazz, methodId);
        env->DeleteLocalRef(clazz);
        return result;
    }
    

    在 JNI 中,我们需要通过 JNIEnv 参数获取当前运行环境,并通过它调用 Kotlin 中的静态方法。具体步骤如下:

    1. 首先通过 env->FindClass 方法获取 Kotlin 中定义的类(这里是 com.example.audio.AudioUtil)的引用。
    2. 再通过 env->GetStaticMethodID 方法获取 isSupport24bit 方法的 ID。
    3. 再通过 env->CallStaticBooleanMethod 方法调用 isSupport24bit 方法,在 Kotlin 中执行计算,并将结果返回给 C++。
    4. 最后通过 env->DeleteLocalRef 方法释放类引用,防止引用泄漏。

    最后,需要在 Android Studio 中配置 CMakeLists.txt 文件,以便生成对应的 C++ 代码。假设你的包名为 com.example.audio,你应该将以下代码添加到 CMakeLists.txt 中:

    # 添加 Kotlin 源文件到 C++ 库
    set(KOTLIN_SOURCES
        ${PROJECT_SOURCE_DIR}/app/src/main/kotlin/com/example/audio/AudioUtil.kt
    )
    
    # 添加 C++ 库
    add_library(audio_util SHARED audio_util.cpp ${KOTLIN_SOURCES})
    
    # Android 库依赖
    target_link_libraries(audio_util android)
    
    # Kotlin 库依赖
    find_library(KOTLIN_LIB kotlin-stdlib-jdk7 PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../../kotlin/lib)
    target_link_libraries(audio_util ${KOTLIN_LIB})
    

    这里用 KOTLIN_SOURCES 定义 Kotlin 源代码的路径,用 add_library 添加C++库和 Kotlin 库的依赖,用 target_link_libraries 方法添加 Android 库依赖和 Kotlin 库依赖。

    至此,我们就实现了在 C++ 中调用 Kotlin 代码判断是否支持 24 位的音频录制。

  7. User

    如何在jni中的其他线程全局使用JNIEnv *env

  8. Assistant

    在 JNI 中创建其他线程时,不能直接在其他线程中使用主线程的 JNIEnv 指针,因为 JNIEnv 指针是与线程相关的,不能在线程之间共享。因此,在其他线程中需要单独获取一个 JNIEnv 指针。

    如果是已经附加到 JVM 的线程,可以使用 JNIEnv *env 参数来获取当前线程的 JNIEnv 指针。例如,在其他线程中使用 Java 方法时:

    void *thread_func(void *arg) {
        JNIEnv *env;
        g_vm->AttachCurrentThread(&env, nullptr);
        jclass clazz = env->FindClass("com/example/MyClass");
        jmethodID methodId = env->GetStaticMethodID(clazz, "myMethod", "()V");
        env->CallStaticVoidMethod(clazz, methodId);
        g_vm->DetachCurrentThread();
        return nullptr;
    }
    

    这里,g_vm 是一个全局变量,用于保存 JVM 实例的指针。AttachCurrentThread 方法会将当前线程附加到 JVM 实例上,并获取当前线程的 JNIEnv 指针。在 JNI 使用完毕后,需要调用 DetachCurrentThread 方法将当前线程从 JVM 实例中分离,并释放相关资源。

    如果是在其他线程中创建新的 JVM 实例并调用 Java 方法,则需要使用 JNI_CreateJavaVM 方法创建一个新的 JVM 实例,然后调用 AttachCurrentThread 方法获取 JNIEnv 指针。例如:

    void *thread_func(void *arg) {
        JNIEnv *env;
        JavaVM *jvm;
        JNIEnv *env_main = nullptr;
        g_vm->GetEnv((void **)&env_main, JNI_VERSION_1_6);
        if (env_main == nullptr) {
            JavaVMInitArgs vm_args;
            JavaVMOption options[1];
            options[0].optionString = "-Djava.class.path=/system/framework/myapp.jar";
            vm_args.version = JNI_VERSION_1_6;
            vm_args.nOptions = 1;
            vm_args.options = options;
            vm_args.ignoreUnrecognized = JNI_TRUE;
            JNI_CreateJavaVM(&jvm, (void **)&env, &vm_args);
        } else {
            g_vm->AttachCurrentThread(&env, nullptr);
            jvm = g_vm;
        }
        jclass clazz = env->FindClass("com/example/MyClass");
        jmethodID methodId = env->GetStaticMethodID(clazz, "myMethod", "()V");
        env->CallStaticVoidMethod(clazz, methodId);
        jvm->DestroyJavaVM();
        return nullptr;
    }
    

    在这里,如果当前线程已经与 JVM 实例关联,则可以通过 GetEnv 方法获取主线程的 JNIEnv 指针;否则,我们需要使用 JNI_CreateJavaVM 方法创建一个新的 JVM 实例,并通过 AttachCurrentThread 方法获取当前线程的 JNIEnv 指针。在 JNI 使用完毕后,需要调用 DestroyJavaVM 方法销毁 JVM 实例。

  9. User

    如果频繁调用这个方法会影响性能吗

  10. Assistant

    如果频繁调用这个方法,会对性能造成一定的影响。

    在 Android 中,Kotlin 代码的调用通常是通过 JNI 接口实现的,在JNI接口中需要频繁地创建和销毁JNIEnv指针,这可能会影响性能。此外,Kotlin 代码中的很多操作也需要频繁地进行JNI调用,这也会影响性能。因此,如果频繁调用isSupport24bit这个方法,也会对应用程序的性能产生一定的影响。

    为了减少JNI调用对性能的影响,可以使用缓存技术。例如,将isSupport24bit的结果缓存在全局变量中,当需要访问该结果时,直接访问该全局变量,而不是通过JNI调用isSupport24bit来获取结果。这样可以避免频繁创建和销毁JNIEnv指针,从而提高应用程序的性能。另外,我们也可以使用线程池等技术,避免频繁创建和销毁线程,提高代码的效率。