FFmpeg音频播放器(7)-使用OpenSLES播放音频

流程

1.创建并且实现引擎对象

SLObjectItf engineObject;
slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
 (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);

2.获取引擎接口

SLEngineItf engineItf;
 (*enginObject)->GetInterface(engineObject,SL_IID_ENGINE,&engineItf);

3.创建并且实现输出混音器对象

SLObjectItf mixObject;
(*engineItf)->CreateOutputMix(engineItf, &mixObject, 0, 0, 0);

4.设置播放器参数，创建初始化播放器对象

SLDataLocator_AndroidSimpleBufferQueue
        android_queue = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
//pcm格式
SLDataFormat_PCM pcm = {SL_DATAFORMAT_PCM,
                        2,//两声道
                        SL_SAMPLINGRATE_48,//48000采样率
                        SL_PCMSAMPLEFORMAT_FIXED_16,
                        SL_PCMSAMPLEFORMAT_FIXED_16,
                        SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,//
                        SL_BYTEORDER_LITTLEENDIAN};

SLDataSource slDataSource = {&android_queue, &pcm};

//输出管道
SLDataLocator_OutputMix outputMix = {SL_DATALOCATOR_OUTPUTMIX, mixObject};
SLDataSink audioSnk = {&outputMix, NULL};

const SLInterfaceID ids[3] = {SL_IID_BUFFERQUEUE, SL_IID_EFFECTSEND, SL_IID_VOLUME};
const SLboolean req[3] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};

SLObjectItf playerObject;//播放器对象
(*engineItf)->CreateAudioPlayer(engineItf, &playerObject,&slDataSource,&audioSnk,1,ids,req);
(*playerObject)->Realize(playerObject,SL_BOOLEAN_FALSE);

5.通过播放器对象获取相关接口

//获取播放接口
SLPlayItf playItf;
(*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playItf);
//获取缓冲接口
SLBufferQueueItf bufferQueueItf;
(*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE, &bufferQueueItf);

6. 注册回调缓冲，设置播放状态，调用回调函数

//注册缓冲回调
(*bufferQueueItf)->RegisterCallback(bufferQueueItf, playCallback, NULL);
//设置播放状态
(*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING);
playCallback(bufferQueueItf, NULL);

具体回调如下，getPCM在后面会有实现

void playCallback(SLAndroidSimpleBufferQueueItf bq, void *args) {
    //获取pcm数据
    uint8_t *data;
    int size = getPCM(&data);
    if (size > 0) {
        (*bq)->Enqueue(bq, data, size);
    }
}

具体实现

为了能够获取pcm数据，我们使用多线程进行音频解码，通过条件变量，实现一个生产者消费者的模型，解码过程为生产过程,回调播放为消费过程。将解码得到的AVFrame加入到vector队列中，然后在播放回调时取出AVFrame，使用swr_convert转成pcm数据。

1.初始化同步锁，条件变量，启动解码线程

申明全局的变量

static pthread_mutex_t mutex;
//条件变量
static pthread_cond_t notfull; //队列未达到最大缓冲容量，存
static pthread_cond_t notempty;//队列不为空，取

初始化同步锁和条件变量，启动解码线程（放在创建播放器前面）

//初始化同步锁和条件变量
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&notfull, NULL);
pthread_cond_init(&notempty, NULL);

//初始化解码线程
pthread_t pid;
char *path = (char *) env->GetStringUTFChars(_path, 0);
pthread_create(&pid, NULL, decodeAudio, path);

2.解码音频，将AVFrame加入vector队列

申明全局变量

static std::vector<AVFrame *> queue;
static SwrContext *swr_ctx;
static int out_ch_layout_nb;
static enum AVSampleFormat out_sample_fmt;
#define QUEUE_SIZE 5
#define MAX_AUDIO_SIZE 48000*4

解码音频和[第4节]类似，只不过把解码出来的AVFrame加入到队列了。

void *decodeAudio(void *args) {
    char *path = (char *) args;
    av_register_all();
    //打开文件
    ...
    //获取音频索引
   ...
    //获取解码器
    ...
    //打开解码器
    ...
    //初始化SwrContext
    swr_ctx = swr_alloc();
    ..
    //分配AVPacket和AVFrame内存，用于接收音频数据，解码数据
    AVPacket *packet = av_packet_alloc();
    AVFrame *frame = av_frame_alloc();
    int got_frame;//接收解码结果
    int index = 0;

    //初始化
    while (av_read_frame(fmt_ctx, packet) == 0) {//将音频数据读入packet
        if (packet->stream_index == audio_stream_index) {//取音频索引packet
            if (avcodec_decode_audio4(codec_ctx, frame, &got_frame, packet) <
                0) {//将packet解码成AVFrame
                LOGE("decode error:%d", index);
                break;
            }
            if (got_frame > 0) {
                LOGI("decode frame:%d", index++);
                addFrame(frame);
            }
        }
    }
    //释放资源
    ...
}

为了保证音频播放的实时性，队列里的AVFrame数量不能太多。在后面章节中，我们会将AVFrame通过Filter过滤，然后才加入到队列中。因此在addFrame方法中，如果超出最大缓冲大小，需要通过pthread_cond_wait阻塞住，等待消费，代码如下：

void addFrame(AVFrame *src) {
    AVFrame *frame = av_frame_alloc();
    if (av_frame_ref(frame, src) >= 0) {//复制frame
        pthread_mutex_lock(&mutex);
        if (queue.size() == QUEUE_SIZE) {
            LOGI("wait for add frame...%d", queue.size());
            pthread_cond_wait(&notfull, &mutex);//等待队列不为满信号
        }
        queue.push_back(frame);
        pthread_cond_signal(&notempty);//发送不为空信号
        pthread_mutex_unlock(&mutex);
    }
}

3.获取pcm数据，通过opensles回调函数播放pcm

通过之前注册的缓冲回调，我们可以把加入到队列的AVFrame消费掉。
首先要有一个getFrame方法

AVFrame *getFrame() {
    pthread_mutex_lock(&mutex);
    while (true) {
        if (!queue.empty()) {
            AVFrame *out = av_frame_alloc();
            AVFrame *src = queue.front();
            if (av_frame_ref(out, src) < 0)break;
            queue.erase(queue.begin());//删除元素
            av_free(src);
            if (queue.size() < QUEUE_SIZE)pthread_cond_signal(&notfull);//发送notfull信号
            pthread_mutex_unlock(&mutex);
            return out;
        } else {//为空等待添加
            LOGI("wait for get frame");
            pthread_cond_wait(&notempty, &mutex);
        }
    }
    pthread_mutex_unlock(&mutex);
    return NULL;
}

然后是实现最初的getPCM方法，如下：

int getPCM(uint8_t **out) {
    AVFrame *frame = getFrame();
    if (frame) {
        uint8_t *data = (uint8_t *) av_malloc(MAX_AUDIO_SIZE);
        swr_convert(swr_ctx, &data, MAX_AUDIO_SIZE, (const uint8_t **) frame->data,
                    frame->nb_samples);
        int out_size = av_samples_get_buffer_size(NULL, out_ch_layout_nb, frame->nb_samples,
                                                  out_sample_fmt, 0);
        *out = data;
        return out_size;
    }
    return 0;
}

这里，通过swr_convert将AVFrame数据转化成uint8_t数组，然后就可以缓冲队列接口里的Enqueue播放了。
项目地址