Android FFmpeg视频播放器三 音频封装格式解码播放

Android FFmpeg视频播放器一解封装

Android Android FFmpeg视频播放器二 视频封装格式解码播放

视频解封装之后就会得到音频流和视频流,解封状得到的数据是AVPackage类型数据,需要进一步解码成AVFrame一帧一帧数据才能进行播放。

1.从AVPackage队列获取数据进行解码操作
pthread_create(&pid_audio_decode, nullptr, task_audio_decode, this);

/**
 * 音频解码线程回调
 * @param args
 * @return
 */
void *task_audio_decode(void * args) {
    auto *audio_channel = static_cast(args);
    audio_channel->audio_decode();
    return nullptr;
}

/**
 *  音频:取出队列的压缩包 进行解码 解码后的原始包 再push队列中去 (音频:PCM数据)
 */
void AudioChannel::audio_decode() {
    AVPacket *pkt = nullptr;
    while (isPlaying) {
        if (isPlaying && frames.size() > AV_MAX_SIZE) {
            av_usleep(10000);
            continue;
        }
        /*阻塞式函数*/
        int ret = packets.getQueueAndDel(pkt);
        if (!isPlaying) {
            /*如果关闭了播放,跳出循环,releaseAVPacket(&pkt);*/
            break;
        }

        if (!ret) {
            /*压缩包加入队列慢,继续*/
            continue;
        }

        /*
         * 1.发送pkt(压缩包)给缓冲区,
         * 2.从缓冲区拿出来(原始包)
         * */
        ret = avcodec_send_packet(codecContext, pkt);

        if (ret) {
            /* avcodec_send_packet 出现了错误,结束循环*/
            break;
        }

        /*AVFrame: 解码后的视频原始数据包 pcm */
        AVFrame *frame = av_frame_alloc();
        /*从 FFmpeg缓冲区 获取 原始包*/
        ret = avcodec_receive_frame(codecContext, frame);
        if (ret == AVERROR(EAGAIN)) {
            /*有可能音频帧也会获取失败,重新获取一次*/
            continue; //
        } else if (ret != 0) {
            if (frame) {
                releaseAVFrame(&frame);
            }
            break;
        }
        /*原始包-- PCM数据 将PCM数据添加到帧队列*/
        frames.insertToQueue(frame);
        av_packet_unref(pkt);
        releaseAVPacket(&pkt);
    }
    
    /*释放结构体内部成员在堆区分配的内存*/
    av_packet_unref(pkt);
    /*释放AVPacket **/
    releaseAVPacket(&pkt);
}

  • pthread_create:AVPackage解码得到AVFrame耗时操作,创建线程
  • getQueueAndDel:从AVPackage队列获取数据,阻塞队列,如果队列为空会进行wait阻塞
  • avcodec_send_packet:将获取到的AVPackage数据发送给ffmpeg缓冲区,ffmpeg会进行解码操作。
  • avcodec_receive_frame:从ffmpeg缓冲区得到解码之后的pcm数据。
  • frames.insertToQueue(frame):将pcm数据添加到帧队列中。
2.初始化OpenSL ES
 /*第二线线程:视频:从队列取出原始包,播放  音频播放OpenSLES*/
pthread_create(&pid_audio_play, nullptr, task_audio_play, this);


/**
 * 音频播放子线程回调
 * @param args
 * @return
 */
void *task_audio_play(void *args) {
    auto *audio_channel = static_cast(args);
    audio_channel->audio_play();
    return nullptr;
}


/**
 * 音频:从队列取出原始包PCM,OpenSLES音频播放
 */
void AudioChannel::audio_play() {
    /*用于接收 执行成功或者失败的返回值*/
    SLresult result;

    /*创建引擎对象并获取  创建引擎对象:SLObjectItf engineObject*/
    result = slCreateEngine(&engineObject, 0, 0, 0, 0, 0);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("创建引擎 slCreateEngine error");
        return;
    }

    /*
     * 初始化引擎
     * SL_BOOLEAN_FALSE:同步等待创建成功
     * */
    result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("创建引擎 Realize error");
        return;
    }

    /*
     * 获取引擎接口
     * */
    result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineInterface);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("创建引擎接口 Realize error");
        return;
    }

    /*健壮判断*/
    if (engineInterface) {
        LOGD("创建引擎接口 create success");
    } else {
        LOGD("创建引擎接口 create error");
        return;
    }

    /*创建混音器  环境特效,混响特效 */
    result = (*engineInterface)->CreateOutputMix(engineInterface, &outputMixObject,
                                                 0, nullptr, nullptr);
    if (SL_RESULT_SUCCESS != result) {
        LOGD("初始化混音器 CreateOutputMix failed");
        return;
    }

    /*
     * 初始化混音器
     * SL_BOOLEAN_FALSE:同步等待创建成功
     * */
    result = (*outputMixObject)->Realize(outputMixObject,
                                         SL_BOOLEAN_FALSE);  
    if (SL_RESULT_SUCCESS != result) {
        LOGD("初始化混音器 (*outputMixObject)->Realize failed");
        return;
    }


    /*创建buffer缓存类型的队列 */
    SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {
            SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
                                                       10};

    /*
     * 声明PCM 数据参数集 format_pcm
     * pcm数据格式不能直接播放,需要设置PCM的参数集
     * SL_DATAFORMAT_PCM:数据格式为pcm格式
     * 2:双声道
     * SL_SAMPLINGRATE_44_1:采样率为44100
     * SL_PCMSAMPLEFORMAT_FIXED_16:采样格式为16bit
     * SL_PCMSAMPLEFORMAT_FIXED_16:数据大小为16bit
     * SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT:左右声道(双声道)
     * SL_BYTEORDER_LITTLEENDIAN:小端模式 字节序(小端) 例如:int类型四个字节(高位在前 还是 低位在前 的排序方式,一般都是小端)
     * */
    SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM,
                                   2,
                                   SL_SAMPLINGRATE_44_1,
                                   SL_PCMSAMPLEFORMAT_FIXED_16,
                                   SL_PCMSAMPLEFORMAT_FIXED_16,
                                   SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,
                                   SL_BYTEORDER_LITTLEENDIAN};

    /**
     * 使用数据源 和PCM数据格式,初始化SLDataSource
     * 独立声卡:24bit  集成声卡16bit
     */
    SLDataSource audioSrc = {&loc_bufq, &format_pcm};

    /*
     * 配置音轨(输出)
     * 设置混音器
     * SL_DATALOCATOR_OUTPUTMIX:输出混音器类型
     * */
    SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX,
                                          outputMixObject};
    /*得到outmix最终混音器*/
    SLDataSink audioSnk = {&loc_outmix, NULL};

    /* 需要的接口 操作队列的接口*/
    const SLInterfaceID ids[1] = {SL_IID_BUFFERQUEUE};
    const SLboolean req[1] = {SL_BOOLEAN_TRUE};

    /*
     * 创建播放器 SLObjectItf bqPlayerObject
     * 参数1:引擎接口
     * 参数2:播放器
     * 参数3:音频配置信息
     * 参数4:混音器
     * 参数5:开放的参数的个数
     * 参数6:代表我们需要 Buff
     * 参数7:代表我们上面的Buff 需要开放出去
     * */
    result = (*engineInterface)->CreateAudioPlayer(engineInterface,
                                                   &bqPlayerObject,
                                                   &audioSrc,
                                                   &audioSnk,

                                                   1,
                                                   ids,
                                                   req
    );

    if (SL_RESULT_SUCCESS != result) {
        LOGD("创建播放器 CreateAudioPlayer failed!");
        return;
    }

    /*
     * 初始化播放器:SLObjectItf bqPlayerObject
     * SL_BOOLEAN_FALSE:同步等待创建成功
     * */
    result = (*bqPlayerObject)->Realize(bqPlayerObject,
                                        SL_BOOLEAN_FALSE);
    if (SL_RESULT_SUCCESS != result) {
        LOGD("实例化播放器 CreateAudioPlayer failed!");
        return;
    }
    LOGD("创建播放器 CreateAudioPlayer success!");

    /*
     * 获取播放器接口 播放全部使用播放器接口
     * SL_IID_PLAY:播放接口 == iplayer
     * */
    result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_PLAY,
                                             &bqPlayerPlay);
    if (SL_RESULT_SUCCESS != result) {
        LOGD("获取播放接口 GetInterface SL_IID_PLAY failed!");
        return;
    }
    LOGI("创建播放器 Success");


    /*
     * 设置回调函数
     * 获取播放器队列接口:SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue
     * 播放需要的队列
     * */
    result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_BUFFERQUEUE,
                                             &bqPlayerBufferQueue);
    if (result != SL_RESULT_SUCCESS) {
        LOGD("获取播放队列 GetInterface SL_IID_BUFFERQUEUE failed!");
        return;
    }

    /*
     * 设置回调 void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
     * 传入刚刚设置好的队列
     * 给回调函数的参数
     * */
    (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue,
                                             bqPlayerCallback,
                                             this);
    LOGI("设置播放回调函数 Success");

    /*设置播放器状态为播放状态*/
    (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING);
    LOGI("设置播放器状态为播放状态 Success");

    /*手动激活回调函数*/
    bqPlayerCallback(bqPlayerBufferQueue, this);
    LOGI("手动激活回调函数 Success");
}
  • pthread_create:创建音频播放线程。
  • slCreateEngine:创建OpenSL ES 引擎对象:SLObjectItf engineObject。
  • Realize(engineObject, SL_BOOLEAN_FALSE):同步的方式初始化引擎对象engineObject
  • (*engineObject)->GetInterface:通过引擎对象获取引擎接口。
  • (*engineInterface)->CreateOutputMix:通过引擎接口创建混音器对象outputMixObject
  • Realize(outputMixObject,SL_BOOLEAN_FALSE):同步初始化混合音器对象
  • SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,10}:创建buffer缓存类型的队列
  • SLDataFormat_PCM format_pcm:设置PCM数据格式,通道数量、采样率、位深、大小端。
  • SLDataSource audioSrc = {&loc_bufq, &format_pcm}:前面的缓存队列和数据PCM格式是为了初始化SLDataSource
  • CreateAudioPlayer:创建播放器 SLObjectItf bqPlayerObject
  • Realize(bqPlayerObject, SL_BOOLEAN_FALSE):实例化音频播放器
  • (*bqPlayerObject)->GetInterface:创建播放器接口,播放全部使用播放器接口bqPlayerPlay
  • (*bqPlayerObject)->GetInterface:得到播放器接口队列bqPlayerBufferQueue
  • RegisterCallback:注册接口播放器队列回调,bqPlayerCallback这个是一个函数指针是一个回调函数。
  • bqPlayerCallback(bqPlayerBufferQueue, this):执行函数bqPlayerCallback,将接口队列当作参数进行传递。
3.OpenSL ES播放PCM格式的音频数据
/**
 * 回调函数
 * @param bq  SLAndroidSimpleBufferQueueItf队列
 * @param args  this  给回调函数的参数
 */
void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *args) {

    auto *audio_channel = static_cast(args);
    int pcm_size = audio_channel->getPCM();

    /*
     * PCM数据添加数据到缓冲区里面去,声音就播放出来了
     * bq:队列接口本身,因为没有this,所以把自己传进去了
     * audio_channel->out_buffers:音频PCM数据
     * pcm_size:PCM数据大小
     * */
    (*bq)->Enqueue(
            bq,
            audio_channel->out_buffers,
            pcm_size);
}


/**
 * 输入的音频数据的采样率可能是各种各样的,为了兼容所以需要重采样 
 * @return  重采样之后音频数据的大小
 */
int AudioChannel::getPCM() {
    int pcm_data_size = 0;
    /*
     * PCM数据在队列frames队列中:frame->data == PCM数据
     * */
    AVFrame *frame = 0;
    while (isPlaying) {
        int ret = frames.getQueueAndDel(frame);
        if (!isPlaying) {
            break;
        }
        if (!ret) {
            /*原始包加入队列慢,再次获取一下*/
            continue;
        }

        /*
         * 开始重采样  
         * 数据源10个48000  目标:44100 11个44100
         * 第一个参数:获取下一个输入样本相对于下一个输出样本将经历的延迟
         * 第二个参数: 输出采样率
         * 第三个参数:输入采样率
         * 第四个参数:先上取
         * */
        int dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, frame->sample_rate) +frame->nb_samples,
                                            out_sample_rate,  
                                            frame->sample_rate,  
                                            AV_ROUND_UP);  

        /*
         * pcm的处理逻辑
         * 音频播放器的数据格式是在下面定义的
         * 而原始数据(待播放的音频pcm数据)
         * 重采样工作
         * 返回的结果:每个通道输出的样本数(注意:是转换后的)    做一个简单的重采样实验(通道基本上都是:1024)
         * */
        int samples_per_channel = swr_convert(swr_ctx,
                                              /*输出区域*/
                                              /*重采样后的buffer数据*/
                                              &out_buffers,
                                              /*单通道的样本数 无法与out_buffers对应,需要pcm_data_size从新计算*/
                                              dst_nb_samples, 
                                                /*输入区域*/
                                                /*队列的AVFrame *PCM数据 未重采样的*/
                                              (const uint8_t **) frame->data, 
                                              /*输入的样本数*/
                                              frame->nb_samples);

        /*由于out_buffers 和 dst_nb_samples 无法对应,所以需要重新计算
         * 计算公式:样本数量*位深(16位2个字节)*通道数量
         * 比如:941通道样本数  *  2样本格式字节数  *  2声道数  =3764
         * */
        pcm_data_size = samples_per_channel * out_sample_size *
                        out_channels; 

        break; 

    }  


    /*
     * FFmpeg录制麦克风  输出 每一个音频包的size == 4096
     * 4096是单声道的样本数,  44100是每秒钟采样的数
     * 样本数 = 采样率 * 声道数 * 位声
     * 采样率 44100是每秒钟采样的次数
     * */

    av_frame_unref(frame);
    av_frame_free(&frame);

    return pcm_data_size;
}

  • 音频播放,初始化OpenSL ES之后,只需要通过音频缓冲队列的Enqueue方法将数据添加到队列就可以播放音频了
  • getPCM():从音频AVFrame帧队列,获取已经将解码的PCM数据,获取之后不能直接使用,因为音频的采样率不确定,为了兼容性需要进行重采样,然后重新计算重采样之后的数据大小。
  • swr_convert:对数据进行重采样,dst_nb_samples这个是单通道的样本数,out_buffers这个是重采样之后PCM数据大小。
  • PCM数据包大小计算:单通道样本数*通道数*位深
4.音频播放结束之后OpenSL ES资源释放
void AudioChannel::stop() {

    /*设置停止状态*/
    if (bqPlayerPlay) {
        (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_STOPPED);
        bqPlayerPlay = nullptr;
    }

    /*销毁播放器*/
    if (bqPlayerObject) {
        (*bqPlayerObject)->Destroy(bqPlayerObject);
        bqPlayerObject = nullptr;
        bqPlayerBufferQueue = nullptr;
    }

    /*销毁混音器*/
    if (outputMixObject) {
        (*outputMixObject)->Destroy(outputMixObject);
        outputMixObject = nullptr;
    }

    /*销毁引擎*/
    if (engineObject) {
        (*engineObject)->Destroy(engineObject);
        engineObject = nullptr;
        engineInterface = nullptr;
    }


}

总结:音频播放流程:将AVPackage解码成AVFrame数据->将AVFrame帧数据放入队列->对OpenSL ES进行初始化,得到缓存队列接口->为了兼容性对数据进行重采样->将重采样的数据加入到缓冲接口队列中去因为就播放出来了。

你可能感兴趣的:(Android,NDK,android,音视频,OpenSL,ES,播放PCM)