Open SL ES总结

1. 采用面向对象的 C 语言接口

  OpenSL ES 虽然是 C 语言编写，但是它的接口采用的是面向对象的方式，并不是提供一系列的函数接口，而是以 Interface 的方式来提供 API，这是理解 OpenSL ES API 的一个比较重要的点。
  例如，实例化引擎的过程如下：

SLObjectItf slObjEngine = NULL;
SLresult result = (*slObjEngine)->Realize(slObjEngine, SL_BOOLEAN_FALSE);

  由于C语言不存在this指针，所以参数中需要将对象本身传入。

2. Objects 和 Interfaces

  OpenSL ES 有两个必须理解的概念，就是Object 和 Interface，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 的时候需要做一些选择和判断
  如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 (*Destroy) (
        SLObjectItf self
    );

    ...
};

3. OpenSL ES 的状态机制

  任何一个 OpenSL ES 的对象，创建成功后，都进入 SL_OBJECT_STATE_UNREALIZED 状态，这种状态下，系统不会为它分配任何资源，直到调用 Realize 函数为止。

  Realize 后的对象，就会进入 SL_OBJECT_STATE_REALIZED 状态，这是一种“可用”的状态，只有在这种状态下，对象的各个功能和资源才能正常地访问。

  当一些系统事件发生后，比如出现错误或者 Audio 设备被其他应用抢占，OpenSL ES 对象会进入 SL_OBJECT_STATE_SUSPENDED 状态，如果希望恢复正常使用，需要调用 Resume 函数。

  当调用对象的 Destroy 函数后，则会释放资源，并回到 SL_OBJECT_STATE_UNREALIZED 状态。

  简言之，一个 OpenSL ES 对象的生命周期，就是从 create 到 destroy 的过程，生命周期的控制，都是通过开发者显示调用来完成的。

4. 常用的对象和结构体

  在 OpenSL ES 中，一切 API 的访问和控制都是通过 Interface 来完成的。

4.1 Engine Object 和 SLEngineItf Interface

  （1）管理 Audio Engine 的生命周期
  （2）提供管理接口: SLEngineItf，该接口可以用来创建所有其他的 Object 对象
  （3）提供设备属性查询接口：SLEngineCapabilitiesItf 和 SLAudioIODeviceCapabilitiesItf，这些接口可以查询设备的一些属性信息

  Engine Object 对象的创建方法如下：

SLObjectItf engineObject;
slCreateEngine( &engineObject, 0, nullptr, 0, nullptr, nullptr );

  初始化/销毁：

(*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
(*engineObject)->Destroy(engineObject);

  下面我们就可以愉快地使用 engineEngine 来创建所有 OpenSL ES 的其他对象了。

4.2 Media Object

  OpenSL ES 里面另一组比较重要的对象就是 Media Object ，代表着多媒体功能的抽象，比如：player、recorder 等等。

  我们可以通过 SLEngineItf 提供的 CreateAudioPlayer 方法来创建一个 player 对象实例，可以通过 SLEngineItf 提供的 CreateAudioRecorder 方法来创建一个 recorder 实例。

4.3 SLDataSource 和 SLDataSink

  OpenSL ES 里面，这两个结构体均是作为创建 Media Object 对象时的参数而存在的，
  SLDataSource 代表着输入源的信息，即数据从哪儿来、输入的数据参数是怎样的；
  SLDataSink 则代表着输出的信息，即数据输出到哪儿、以什么样的参数来输出。
  Data Source 的定义如下：

typedef struct SLDataSource_ {
      void *pLocator;
      void *pFormat;
} SLDataSource;

  Data Sink 的定义如下：

typedef struct SLDataSink_ {
    void *pLocator;
    void *pFormat;
} SLDataSink;

  其中，pLocator 主要有如下几种：

SLDataLocator_Address
SLDataLocator_BufferQueue
SLDataLocator_IODevice
SLDataLocator_MIDIBufferQueue
SLDataLocator_URI

  也就是说，Media Object 对象的输入源/输出源，既可以是 URL，也可以 Device，或者来自于缓冲区队列等等，完全是由 Media Object 对象的具体类型和应用场景来配置。

  不同的 Media Object 对象实例，data source 和 data sink 的具体内容是不一样的。

  对于 player 而言：

image.png

对于 recorder 而言：

image.png
引自：https://blog.51cto.com/ticktick/1771239
下面是一个播放音频的完整示例：

#include <jni.h>
#include <string>
#include <android/log.h>

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

#define  LOGE(...) __android_log_print(ANDROID_LOG_ERROR,"test",__VA_ARGS__)

static SLObjectItf  g_slObjEngine = NULL;

SLEngineItf CreatSLEngineItf()
{
    //a 创建引擎对象
    SLresult result = slCreateEngine(&g_slObjEngine, 0, 0, 0, 0, 0);
    if (result != SL_RESULT_SUCCESS)
        return  NULL;

    //b 实例化引擎对象
    result = (*g_slObjEngine)->Realize(g_slObjEngine, SL_BOOLEAN_FALSE); //SL_BOOLEAN_FALSE等待对象创建
    if (result != SL_RESULT_SUCCESS)
        return  NULL;

    //c 获取接口
    SLEngineItf slEngineItf;
    result = (*g_slObjEngine)->GetInterface(g_slObjEngine, SL_IID_ENGINE, &slEngineItf);
    if (result != SL_RESULT_SUCCESS)
        return  NULL;

    return slEngineItf;
}

//回调函数
void AudioCallBack(SLAndroidSimpleBufferQueueItf bf, void *context)
{
    LOGE("AudioCallBack ");
    static FILE *s_file   = NULL;
    static char *s_buf    = NULL;

    if (!s_buf) {
        s_buf = new char[1024 * 1024];
    }
    if (!s_file) {
        s_file = fopen("/sdcard/test.pcm", "rb");
    }
    if (!s_file) {
        LOGE("fopen failed!");
        return;
    }

    if (feof(s_file) == 0) {
        int len = fread(s_buf, 1, 1024, s_file);
        if (len > 0) {
            (*bf)->Enqueue(bf, s_buf, len);
        }
    }
}


void playAudio() {
    //1 创建引擎
    SLEngineItf pEngineItf = CreatSLEngineItf();
    if (pEngineItf)
    {
        LOGE("CreatSLEngineItf success!");

    } else
    {
        LOGE("CreatSLEngineItf failed!");
    }

    //2 创建混音器
    //----输出混音器
    SLObjectItf slObjMix = NULL;
    SLresult result = (*pEngineItf)->CreateOutputMix(pEngineItf, &slObjMix, 0, 0, 0);
    if (result != SL_RESULT_SUCCESS)
    {
        LOGE("CreateOutputMix failed!");
    };

    //----实例化
    result = (*slObjMix)->Realize(slObjMix, SL_BOOLEAN_FALSE);
    if (result != SL_RESULT_SUCCESS)
    {
        LOGE("slObjMix Realize failed!");
    };

    SLDataLocator_OutputMix outmix = {SL_DATALOCATOR_OUTPUTMIX, slObjMix};
    SLDataSink slDataSink = {&outmix, 0};

    //3 配置音频信息
    //----创建缓冲队列
    SLDataLocator_AndroidSimpleBufferQueue bufQueue = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 10};

    //----音频格式配置
    SLDataFormat_PCM dataFormat_pcm = {
            SL_DATAFORMAT_PCM,
            2,                                                   //通道数
            SL_SAMPLINGRATE_44_1,                             //采样率
            SL_PCMSAMPLEFORMAT_FIXED_16,                     // bitsPerSample
            SL_PCMSAMPLEFORMAT_FIXED_16,                     // containerSize
            SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,  //声道
            SL_BYTEORDER_LITTLEENDIAN                        //字节序,小端
    };
    //----播放器使用的结构体
    SLDataSource slDataSource = {&bufQueue, &dataFormat_pcm};

    // 4 创建播放器
    SLObjectItf  slObjPlayer = NULL;
    const SLInterfaceID  itfIds[] = { SL_IID_BUFFERQUEUE };          //接口id
    const SLboolean      itfReqs[] = { SL_BOOLEAN_TRUE  };          //接口开放

    result = (*pEngineItf)->CreateAudioPlayer(pEngineItf, &slObjPlayer, &slDataSource, &slDataSink,
                                              sizeof(itfIds) / sizeof(SLInterfaceID), itfIds, itfReqs);
    if (result != SL_RESULT_SUCCESS)
    {
        LOGE("CreateAudioPlayer  failed!");
    } else {
        LOGE("CreateAudioPlayer  success!");
    };
    //实例化
    (*slObjPlayer)->Realize(slObjPlayer, SL_BOOLEAN_FALSE);

    //获取接口
    SLPlayItf slPlayItf = NULL;
    result = (*slObjPlayer)->GetInterface(slObjPlayer, SL_IID_PLAY, &slPlayItf);
    if (result != SL_RESULT_SUCCESS)
    {
        LOGE("slObjPlayer GetInterface  failed!");
    } else{
        LOGE("slObjPlayer GetInterface  success!");
    };

    //获取缓冲队列接口
    SLAndroidSimpleBufferQueueItf slBufQueue = NULL;
    result =(*slObjPlayer)->GetInterface(slObjPlayer, SL_IID_BUFFERQUEUE, &slBufQueue);
    if (result != SL_RESULT_SUCCESS)
    {
        LOGE("slObjPlayer GetInterface BUFFERQUEUE failed!");
    } else {
        LOGE("slObjPlayer GetInterface BUFFERQUEUE success!");
    };

    //设置回调函数,播放队列为空的时候调用
    //第二个参数是回调函数 第三个参数是 给回调函数传的参数
    (*slBufQueue)->RegisterCallback(slBufQueue, AudioCallBack, 0);
    //设置状态 播放
    (*slPlayItf)->SetPlayState(slPlayItf, SL_PLAYSTATE_PLAYING);

    //启动队列回调
    (*slBufQueue)->Enqueue(slBufQueue, "", 1);
}

参考：https://blog.csdn.net/u010141160/article/details/82871244
https://www.cnblogs.com/renhui/p/9565464.html
https://www.jianshu.com/p/2b8d2de9a47b