Android音视频十三OpenSL ES介绍&基于OpenSL ES实现音频采集

Posted 顾修忠

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android音视频十三OpenSL ES介绍&基于OpenSL ES实现音频采集相关的知识,希望对你有一定的参考价值。

人间观察
勿再别人的心中修行自己,
勿再自己的心中强求别人。

前言

最近写文章有点偷懒了,离上次写文章大概一个月了。

一般android音频的采集在java层使用AudioRecord类进行采集。

但是为什么要学OpenSL呢?除了C/C++的性能优势(不过其实java的效率也不低)之外,最主要是你如果使用java层的接口,还需要通过一层JNI,比较复杂,性能消耗也大。如果用OpenSL的话就能直接在C/C++里面把事情都处理了。所以有时候为了开发更加高效的 Android 音频应用需要在底层直接进行录音采集播放等,免去java和jni层的互相通信。

那这篇文章主要介绍Android在JNI层如何使用OpenSL ES进行音频的采集。

OpenSL ES介绍

此节介绍有些摘自网络,只为学习使用,只为更好更全的介绍下OpenSL ES。如有侵权将删除!

什么是OpenSL ES

这个在前一篇文章的利用OpenSL ES播放pcm数据的时候也有所介绍。这里再介绍下。

OpenSL ES全称为Open Sound Library for Embedded Systems,即嵌入式音频加速标准。OpenSL ES是无授权费、跨平台、针对嵌入式系统精心优化的硬件音频加速 API。它为嵌入式移动多媒体设备上的本地 应用程序开发者提供了标准化、高性能、低响应时间的音频功能实现方法,同时还实现了软/硬件音频性能的直接跨平台部署,不仅降低了执行难度,而且促进了高级音频市场的发展。简单来说OpenSL ES是一个嵌入式跨平台免费的音频处理库。 所以它不是Android特有的。

OpenSL ES 与 Android的关系

官网介绍地址:https://source.android.com/devices/audio/latency_app.html

可以看到Android 实现的 OpenSL ES 只是 OpenSL 1.0.1 的子集,并且进行了扩展,因此,对于 OpenSL ES API 的使用,我们还需要特别留意哪些是 Android 支持的,哪些是不支持的。

OpenSL ES的特性以及优劣势

特性:

1C 语言接口,兼容 C++,需要在 NDK 下开发,能更好地集成在 native 应用中
(2)运行于 native 层,需要自己管理资源的申请与释放,没有 Dalvik 虚拟机的垃圾回收机制
(3)支持 PCM 数据的采集,支持的配置:16bit 位宽,16000 Hz采样率,单通道。(其他的配置不能保证兼容所有平台)
(4)支持 PCM 数据的播放,支持的配置:8bit/16bit 位宽,单通道/双通道,小端模式,采样率(8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 Hz)
(5)支持播放的音频数据来源:res 文件夹下的音频、assets 文件夹下的音频、sdcard 目录下的音频、在线网络音频、代码中定义的音频二进制数据等等

优势:

1)避免音频数据频繁在 native 层和 Java 层拷贝,提高效率
(2)相比于 Java API,可以更灵活地控制参数
(3)由于是 C 代码,因此可以做深度优化,比如采用 NEON 优化
(4)代码细节更难被反编译

劣势:

1)不支持版本低于 Android 2.3 (API 9) 的设备
(2)没有全部实现 OpenSL ES 定义的特性和功能
(3)不支持 MIDI 
(4)不支持直接播放 DRM 或者 加密的内容
(5)不支持音频数据的编解码,如需编解码,需要使用 MediaCodec API 或者第三方库
(6)在音频延时方面,相比于上层 API,并没有特别明显地改进

更多介绍

可以看下android 中文官网。里面也有一些demo

https://developer.android.google.cn/ndk/guides/audio/opensl

ok,了解了OpenSL ES 的 一些背景后,我们接下来开始介绍OpenSL ES 的API和实现录音采集功能。

添加权限

要想录音无论是使用java层的AudioRecord还是底层的OpenSL ES都需要在AndroidManifest.xml的配置文件里面增加录音权限。

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

引用相关库文件以及头文件

在Android中使用OpenSLES首先需要把Android 系统提供的so链接到外面自己的so。在CMakeLists.txt脚本中添加链接库OpenSLES。库的名字可以在你的ndk目录下找到,类似目录 :

/Users/guxiuzhong/Library/Android/sdk/ndk/21.1.6352462/platforms/android-19/arch-x86/usr/lib/libOpenSLES.so

然后需要去掉lib前缀即可。当工程编译的时候它会自动找这个目录的。

CMake方式 在CMakeLists.txt中配置

target_link_libraries(
                OpenSLES
   							// ...省略其它需要链接的so
        )

NDK Build方式 在Makefile文件Android.mk添加链接选项

LOCAL_LDLIBS += -lOepnSLES

头文件添加

#include <SLES/OpenSLES.h>
#include <SLES/OpenSLES_Android.h>

OpenSLES重要概念

Objects和Interfaces

OpenSL ES的开发中有两个必须理解的概念,一个是Object,另一个是Interface。因为很多的API都是在操作ObjectInterface。Android为了更方便的使用OpenSL ESOpenSL ES 的API设计成了类似面向对象的java的使用方式了。Object 可以想象成 Java 的 Object 类,Interface 可以想象成 Java 的 Interface,但它们并不完全相同。他们的关系:
(1) 每个 Object 可能会存在一个或者多个 Interface,官方为每一种 Object 都定义了一系列的 Interface
(2)每个 Object 对象都提供了一些最基础的操作,比如:RealizeResumeGetStateDestroy 等等,如果希望使用该对象支持的功能函数,则必须通过其 GetInterface 函数拿到 Interface 接口,然后通过 Interface 来访问功能函数
(3)并不是每个系统上都实现了 OpenSL ES 为 Object 定义的所有 Interface,所以在获取 Interface 的时候需要做一些选择和判断

所有的ObjectOpenSL里面我们拿到的都是一个SLObjectItf

typedef const struct SLObjectItf_ * const * SLObjectItf;
struct SLObjectItf_ 
	SLresult (*Realize) (
		SLObjectItf self,
		SLboolean async
	);
	SLresult (*Resume) (
		SLObjectItf self,
		SLboolean async
	);
	SLresult (*GetState) (
		SLObjectItf self,
		SLuint32 * pState
	);
	SLresult (*GetInterface) (
		SLObjectItf self,
		const SLInterfaceID iid,
		void * pInterface
	);
	SLresult (*RegisterCallback) (
		SLObjectItf self,
		slObjectCallback callback,
		void * pContext
	);
	void (*AbortAsyncOperation) (
		SLObjectItf self
	);
	void (*Destroy) (
		SLObjectItf self
	);
	SLresult (*SetPriority) (
		SLObjectItf self,
		SLint32 priority,
		SLboolean preemptable
	);
	SLresult (*GetPriority) (
		SLObjectItf self,
		SLint32 *pPriority,
		SLboolean *pPreemptable
	);
	SLresult (*SetLossOfControlInterfaces) (
		SLObjectItf self,
		SLint16 numInterfaces,
		SLInterfaceID * pInterfaceIDs,
		SLboolean enabled
	);
;

任何创建出来的Object都必须调用 Realize 方法做初始化,在不需要的时候可以使用 Destroy 方法来释放资源。

GetInterface

GetInterface可以说是OpenSL里使用频率最高的方法,通过它我们可以获取Object里面的Interface。

由于一个Object里面可能包含了多个Interface,所以GetInterface方法有个SLInterfaceID参数来指定到的需要获取Object里面的那个Interface。

比如我们通过EngineObject去获取SL_IID_ENGINE这个id的Interface,而这个id对应的Interface就是SLEngineItf:

    SLEngineItf engineEngine = NULL;
    SLObjectItf engineObject = NULL;
    // 创建引擎对象,调用全局方法创建一个引擎对象(OpenSL ES唯一入口)
    SLresult result;
    result = slCreateEngine(&engineObject, 1, pEngineOptions, 0, nullptr, nullptr);
    assert(SL_RESULT_SUCCESS == result);
    /* Realizing the SL Engine in synchronous mode. */
    //实例化这个对象
    result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
    assert(SL_RESULT_SUCCESS == result);
    // get the engine interface, which is needed in order to create other objects
    //从这个对象里面获取引擎接口
    (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
    assert(SL_RESULT_SUCCESS == result);

当调用每一个API后要检测其返回值是否等于 「SL_RESULT_SUCCESS」

Interface

Interface则是方法的集合,例如SLRecordItf里面包含了和录音相关的方法,SLPlayItf包含了和播放相关的方法。我们功能都是通过调用Interfaces的方法去实现的。

SLEngineItf 这个interface,SLEngineItf是OpenSL里面最重要的一个Interface,我们可以通过它去创建各种Object,例如播放器、录音器、混音器的Object,然后在用这些Object去获取各种Interface去实现各种功能。

比如:

	SLresult (*CreateAudioPlayer) (
		SLEngineItf self,
		SLObjectItf * pPlayer,
		SLDataSource *pAudiosrc,
		SLDataSink *pAudioSnk,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*CreateAudioRecorder) (
		SLEngineItf self,
		SLObjectItf * pRecorder,
		SLDataSource *pAudioSrc,
		SLDataSink *pAudioSnk,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
// 还有很多其它的,可以看下OpenSLES.h的头文件

Object的生命周期

OpenSL ES 的 Object 一般有三种状态,分别是:UNREALIZED (不可用),REALIZED(可用),SUSPENDED(挂起)。

Object 处于 UNREALIZED (不可用)状态时,系统不会为其分配资源;调用 Realize 方法后便进入 REALIZED(可用)状态,此时对象的各个功能和资源可以正常访问;当系统音频相关的硬件设备被其他进程占用时,OpenSL ES Object 便会进入 SUSPENDED (挂起)状态,随后调用 Resume 方法可使对象重回 REALIZED(可用)状态;当 Object 使用结束后,调用 Destroy 方法释放资源,是对象重回 UNREALIZED (不可用)状态。

录音

demo就简单的把采集到的pcm文件保存到sd卡目录的文件下了,主要是如何用OpenSL ES实现音频pcm数据的采集。

明白了上面的OpenSL ES的设计思想和Object和Interface的API使用流程代码就容易看得懂了。

创建引擎对象

需要调用slCreateEngine()这个全局方法来创建

SL_API SLresult SLAPIENTRY slCreateEngine(
	SLObjectItf             *pEngine, // 引擎对象地址,用于传出对象,是一个输出参数
	SLuint32                numOptions, //配置参数数量,传1
	const SLEngineOption    *pEngineOptions,// 配置参数,为枚举数组
	SLuint32                numInterfaces,//支持的接口数量
	const SLInterfaceID     *pInterfaceIds,//具体的要支持的接口,是枚举的数组
	const SLboolean         * pInterfaceRequired//具体的要支持的接口是开放的还是关闭的,也是一个数组,后三个参数长度是一致的
);

创建之后按照上面介绍的标准流程三步走,调用Realize来实例化这个对象,之后通过GetInterface从这个对象里面获取引擎接口。所以创建引擎对象的代码片段为:

// 成员变量
SLEngineItf engineEngine = NULL;
SLObjectItf engineObject = NULL;

void AudioRecorder::createEngine() 
    SLEngineOption pEngineOptions[] = (SLuint32) SL_ENGINEOPTION_THREADSAFE,
                                       (SLuint32) SL_BOOLEAN_TRUE;
    // 创建引擎对象,//调用全局方法创建一个引擎对象(OpenSL ES唯一入口)
    SLresult result;
    result = slCreateEngine(
            &engineObject, //对象地址,用于传出对象
            1, //配置参数数量
            pEngineOptions, //配置参数,为枚举数组
            0,  //支持的接口数量
            nullptr, //具体的要支持的接口,是枚举的数组
            nullptr//具体的要支持的接口是开放的还是关闭的,也是一个数组,这三个参数长度是一致的
            );
    assert(SL_RESULT_SUCCESS == result);
    /* Realizing the SL Engine in synchronous mode. */
    //实例化这个对象
    result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
    assert(SL_RESULT_SUCCESS == result);
    // get the engine interface, which is needed in order to create other objects
    //从这个对象里面获取引擎接口
    (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
    assert(SL_RESULT_SUCCESS == result);

设置采集设备(麦克风)输入输出配置

    SLDataLocator_IODevice ioDevice = 
            SL_DATALOCATOR_IODEVICE,  //类型 这里只能是SL_DATALOCATOR_IODEVICE
            SL_IODEVICE_AUDIOINPUT,//device类型  选择了音频输入类型
            SL_DEFAULTDEVICEID_AUDIOINPUT, //deviceID 对应的是SL_DEFAULTDEVICEID_AUDIOINPUT
            NULL//device实例
    ;
    // 输入,SLDataSource 表示音频数据来源的信息
    SLDataSource recSource = 
            &ioDevice,//SLDataLocator_IODevice配置输入
            NULL//输入格式,采集的并不需要
    ;
    // 数据源简单缓冲队列定位器,输出buffer队列
    SLDataLocator_AndroidSimpleBufferQueue recBufferQueue = 
            SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, //类型 这里只能是SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE
            NUM_BUFFER_QUEUE //buffer的数量
    ;
    // PCM 数据源格式 //设置输出数据的格式
    SLDataFormat_PCM pcm = 
            SL_DATAFORMAT_PCM, //输出PCM格式的数据
            2,  //  //输出的声道数量2 个声道(立体声)
            SL_SAMPLINGRATE_44_1, //输出的采样频率,这里是44100Hz
            SL_PCMSAMPLEFORMAT_FIXED_16, //输出的采样格式,这里是16bit
            SL_PCMSAMPLEFORMAT_FIXED_16,//一般来说,跟随上一个参数
            SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,//双声道配置,如果单声道可以用 SL_SPEAKER_FRONT_CENTER
            SL_BYTEORDER_LITTLEENDIAN //PCM数据的大小端排列
    ;
    // 输出,SLDataSink 表示音频数据输出信息
    SLDataSink dataSink = 
            &recBufferQueue, //SLDataFormat_PCM配置输出
            &pcm //输出数据格式
    ;

OpenSL ES 中的 SLDataSourceSLDataSink 结构体,主要用于构建 audio player 和 recorder 对象,其中 SLDataSource 表示音频数据来源的信息,SLDataSink 表示音频数据输出信息。

创建录音器-创建录音对象和获取录音相关的接口

SLEngineItf来创建录音器,调用CreateAudioRecorder方法

    //创建录制的对象,并且指定开放SL_IID_ANDROIDSIMPLEBUFFERQUEUE这个接口
    SLInterfaceID iids[NUM_RECORDER_EXPLICIT_INTERFACES] = SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
                                                            SL_IID_ANDROIDCONFIGURATION;
    SLboolean required[NUM_RECORDER_EXPLICIT_INTERFACES] = SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE;
    /* Create the audio recorder */
    // 创建 audio recorder 对象
    result = (*engineEngine)->CreateAudioRecorder(engineEngine, //引擎接口
                                                  &recorderObject, //录制对象地址,用于传出对象
                                                  &recSource,//输入配置
                                                  &dataSink,//输出配置
                                                  NUM_RECORDER_EXPLICIT_INTERFACES,//支持的接口数量
                                                  iids, //具体的要支持的接口
                                                  required //具体的要支持的接口是开放的还是关闭的
    );
    assert(SL_RESULT_SUCCESS == result);

    assert(SL_RESULT_SUCCESS == result);
    /* Realize the recorder in synchronous mode. */ //实例化这个录制对象
    result = (*recorderObject)->Realize(recorderObject, SL_BOOLEAN_FALSE);
    assert(SL_RESULT_SUCCESS == result);
    /* Get the buffer queue interface which was explicitly requested *///获取Buffer接口
    result = (*recorderObject)->GetInterface(recorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
                                             (void *) &recorderBuffQueueItf);
    assert(SL_RESULT_SUCCESS == result);

    /* get the record interface */ //获取录制接口
    (*recorderObject)->GetInterface(recorderObject, SL_IID_RECORD, &recorderRecord);
    assert(SL_RESULT_SUCCESS == result);

还是先创建出来的Object后,然后调用 Realize 方法做初始化,再调用GetInterface来获取Object里面的那个Interface。SL_IID_RECORD就是录音器的接口方法的id,输出参数recorderRecord就是录音接口,后续的启动录音停止录音都是对它操作。

设置数据回调方法并且开始录制

通过回调函数RegisterCallback后并设置开始录制状态来获取录制的音频 PCM 数据。

    buffer = new uint8_t[BUFFER_SIZE]; //数据缓存区,
    bufferSize = BUFFER_SIZE;
    //设置数据回调接口AudioRecorderCallback,最后一个参数是可以传输自定义的上下文引用
    (*recorderBuffQueueItf)->RegisterCallback(recorderBuffQueueItf, AudioRecorderCallback, this);
    assert(SL_RESULT_SUCCESS == result);
    /* Start recording */
    // 开始录制音频,//设置录制器为录制状态 SL_RECORDSTATE_RECORDING
    result = (*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_RECORDING);
    assert(SL_RESULT_SUCCESS == result);

    // 在设置完录制状态后一定需要先Enqueue一次,这样的话才会开始采集回调
    /* Enqueue buffers to map the region of memory allocated to store the recorded data */
    (*recorderBuffQueueItf)->Enqueue(recorderBuffQueueItf, buffer, BUFFER_SIZE);
    assert(SL_RESULT_SUCCESS == result);
    LOGD("Starting recording tid=%ld", syscall(SYS_gettid));//线程id

其中RegisterCallback的第1个参数是获取Buffer接口,第2个参数是一个函数的地址,录音时

OpenSL ES 会自动进行回调,需要注意的是回调方法AudioRecorderCallback不是在UI线程回调,是一个子线程。第3个参数是给回调方法传入的参数,可以传任何数据,这里就传入了this,方便在回调方法里获取一些成员变量等。回调函数如下:

void AudioRecorderCallback(SLAndroidSimpleBufferQueueItf bufferQueueItf, void *context) 
    //注意这个是另外一条采集线程回调
    AudioRecorder *recorderContext = (AudioRecorder *) context;
    assert(recorderContext != NULL);
    if (recorderContext->buffer != NULL) 
        fwrite(recorderContext->buffer, recorderContext->bufferSize, 1, recorderContext->pfile);
        LOGD("save a frame audio data,pid=%ld", syscall(SYS_gettid));
        SLresult result;
        SLuint32 state;
        result = (*(recorderContext->recorderRecord))->GetRecordState(
                recorderContext->recorderRecord, &state);
        assert(SL_RESULT_SUCCESS == result);
        (void) result;
        LOGD("state=%d", state);
        if (state == SL_RECORDSTATE_RECORDING) 
            //取完数据,需要调用Enqueue触发下一次数据回调
            result = (*bufferQueueItf)->Enqueue(bufferQueueItf, recorderContext->buffer,
                                                recorderContext->bufferSize);
            assert(SL_RESULT_SUCCESS == result);
            (void) result;
        
    

需要注意的点如注释所写: 在设置完录制状态后一定需要先Enqueue一次,这样的话才会开始采集回调,然后每处理完一次后需要再次Enqueue来达到循环录音。

停止录音

对于停止录音,就是对录音接口SLRecordItf修改录制状态为SL_RECORDSTATE_STOPPED即可

void AudioRecorder::stopRecord() 
    // 停止录制
    if (recorderRecord != nullptr) 
        //设置录制器为停止状态 SL_RECORDSTATE_STOPPED
        SLresult result = result = (*recorderRecord)->SetRecordState(recorderRecord,
                                                                     SL_RECORDSTATE_STOPPED);
        assert(SL_RESULT_SUCCESS == result);
        fclose(pfile);
        pfile = nullptr;
        delete buffer;
        LOGD("stopRecord done");
    

释放录音和OpenSL ES的资源

// 释放资源,释放OpenSL ES资源
void AudioRecorder::release() 
    //只需要销毁OpenSL ES对象,接口不需要做Destroy处理。
    if (recorderObject != nullptr) 
        (*recorderObject)->Destroy(recorderObject);
        recorderObject = NULL;
        recorderRecord = NULL;
        recorderBuffQueueItf = NULL;
        configItf = NULL;
    
    // destroy engine object, and invalidate all associated interfaces
    if (engineObject != NULL) 
        // 释放引擎对象的资源
        (*engineObject)->Destroy(engineObject);
        engineObject = NULL;
        engineEngine = NULL;
    
    LOGD("release done");

调用测试

有个Audacity软件可以进行播放未压缩的音频pcm文件。当然你也可以用前一篇文章我们介绍的AudioTrack和OpenSL ES进行播放来验证声音是否ok。

JNI层如下代码,比较简单就贴一下了:

AudioRecorder *audioRecorder;
extern "C"
JNIEXPORT void JNICALL
Java_com_bj_gxz_pcmplay_AudioRecorder_startRecord(JNIEnv *env, jobject thiz) 
    if (audioRecorder == nullptr) 
        audioRecorder = new AudioRecorder();
        audioRecorder->startRecord();
    

extern "C"
JNIEXPORT void JNICALL
Java_com_bj_gxz_pcmplay_AudioRecorder_stopRecord(JNIEnv *env, jobject thiz) 
    if (audioRecorder != nullptr) 
        audioRecorder->stopRecord();
    

extern "C"
JNIEXPORT void JNICALL
Java_com_bj_gxz_pcmplay_AudioRecorder_release(JNIEnv *env, jobject thiz) 
    if (audioRecorder != nullptr) 
        audioRecorder->release();
        delete audioRecorder;
        audioRecorder = nullptr;
    

对应java层:

/**
 * Created by guxiuzhong on 2021/06/05 2:03 下午
 */
public class AudioRecorder 
    static 
        System.loadLibrary("native-lib");
    

    public native void startRecord();

    public native void stopRecord();

    public native void release();

源码

https://github.com/ta893115871/PCMPlay

总结

学习了OpenSL ES的一些基础知识,以及它的优缺点,使用场景。

学习了OpenSL ES采集音频的流程。

以上是关于Android音视频十三OpenSL ES介绍&基于OpenSL ES实现音频采集的主要内容,如果未能解决你的问题,请参考以下文章

Android音视频十三OpenSL ES介绍&基于OpenSL ES实现音频采集

Android音视频十三OpenSL ES介绍&基于OpenSL ES实现音频采集

Android 音视频深入 十三 OpenSL ES 制作音乐播放器,能暂停和调整音量(附源码下载)

Android音视频OpenSL ES音频播放示例一

Android音视频学习第7章:使用OpenSL ES进行音频解码

Android OpenSL ES 开发:Android OpenSL 介绍和开发流程说明