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的特性以及优劣势
特性：
（1）C 语言接口，兼容 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都是在操作Object和Interface。Android为了更方便的使用OpenSL ES把OpenSL ES 的API设计成了类似面向对象的java的使用方式了。Object 可以想象成 Java 的 Object 类，Interface 可以想象成 Java 的 Interface，但它们并不完全相同。他们的关系：
（1） 每个 Object 可能会存在一个或者多个 Interface，官方为每一种 Object 都定义了一系列的 Interface
（2）每个 Object 对象都提供了一些最基础的操作，比如：Realize，Resume，GetState，Destroy 等等，如果希望使用该对象支持的功能函数，则必须通过其 GetInterface 函数拿到 Interface 接口，然后通过 Interface 来访问功能函数
（3）并不是每个系统上都实现了 OpenSL ES 为 Object 定义的所有 Interface，所以在获取 Interface 的时候需要做一些选择和判断
所有的Object在OpenSL里面我们拿到的都是一个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 中的 SLDataSource 和 SLDataSink 结构体，主要用于构建 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 制作音乐播放器，能暂停和调整音量（附源码下载）