ffmpeg播放器开发 详细记录+代码实现3
2018-09-17 本文已影响0人
李星星星星星
请接上一个简书内容观看，会对上一章的代码进行改进和修改~~~
ffmpeg播放器3-音频解码与opensl es播放
1.ffmpeg 解码音频并播放的开发
实现 DNFFmpeg的 start()方法
//cmake中加入OpenSLES库
target_link_libraries(XXX OpenSLES)
2.相关知识整理
简书链接:
https://www.jianshu.com/p/e94652ee371c
Android 播放 PCM 有:
1.Java SDK : AudioTrack （AudioRecorder录音）
2.NDK : OPenSL ES （效率比较好）
RGB、YUV：图像原始格式
PCM: 声音的原始格式
采样率：1s 采集多少次声音 采集频率 HZ
采样位：16bit 2字节
声道数：单声道、双声道
大端： 0xab 0xcd
小端： 0xcd 0xab
3.代码实现:
...之前的创建类:
创建 DNPlayer.java，用于调用so中的方法
创建 mylog.h, 用于定义一些宏
创建 DNFFmpeg.h & .cpp ，用于提供方法给 native-lib.cpp 调用
创建 JavaCallHelper.h & .cpp ，用于so调用java的方法（即回调）
创建 AudioChannel.h & .cpp ，用于音频开发
创建 VideoChannel& .cpp ，用于视频开发
... 新创建类：
safeQueue.h 用户创建线程安全的队列
BaseChannel.h 用于音频和视频开发类的父类，存放一些共用的方法和信息
1. DNPlayer.java：
在surfaceChanged回调中调用 native_setSurface（Surface surface）方法传入 Surface
编写start()方法 ->调用 native_start()方法
...
2. BaseChannel.h
#ifndef MYFFMPEGPLAYER_BASECHANNEL_H
#define MYFFMPEGPLAYER_BASECHANNEL_H
extern "C"{
#include <libavcodec/avcodec.h>
};
#include "safe_queue.h"
class BaseChannel {
public:
BaseChannel(int i,AVCodecContext *avCodecContext) : index(i),avCodecContext(avCodecContext) {
// 设置释放队列中的AVPacket 对象数据的方法回调
packets.setReleaseCallBack(BaseChannel::releaseAVPacket);
// 设置释放队列中的 AVFrame 对象数据的方法回调
frames.setReleaseCallBack(BaseChannel::releaseAVFrame);
};
virtual ~BaseChannel() {
packets.clear();
frames.clear();
};
// 释放 AVPacket
static void releaseAVPacket(AVPacket*& packet){
if(packet){
av_packet_free(&packet);
packet = 0;
}
}
// 释放 AVFrame
static void releaseAVFrame(AVFrame*& frame){
if(frame){
av_frame_free(&frame);
frame = 0;
}
}
// 抽象方法 解码+播放
virtual void start() = 0;
int index;
// 线程安全的队列 用于存放压缩后的包
SafeQueue<AVPacket*> packets;
// 线程安全的队列 用于存放解码后的数据
SafeQueue<AVFrame*> frames;
// 解码器上下文
AVCodecContext *avCodecContext = 0;
bool isPlaying;// 是否工作
};
#endif //MYFFMPEGPLAYER_BASECHANNEL_H
3.safe_queue.h
#ifndef DNRECORDER_SAFE_QUEUE_H
#define DNRECORDER_SAFE_QUEUE_H
#include <queue>
#include <pthread.h>
using namespace std;
//线程安全的队列
template<typename T>
class SafeQueue {
typedef void (*ReleaseCallBack)(T &);
typedef void (*SyncHandle)(queue<T> &);
public:
SafeQueue() {
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
}
~SafeQueue() {
pthread_cond_destroy(&cond);
pthread_mutex_destroy(&mutex);
}
void push(const T new_value) {
pthread_mutex_lock(&mutex);
if (work) {
q.push(new_value);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
}
pthread_mutex_unlock(&mutex);
}
int pop(T &value) {
int ret = 0;
pthread_mutex_lock(&mutex);
//在多核处理器下 由于竞争可能虚假唤醒 包括jdk也说明了
while (work && q.empty()) {
pthread_cond_wait(&cond, &mutex);
}
if (!q.empty()) {
value = q.front();
q.pop();
ret = 1;
}
pthread_mutex_unlock(&mutex);
return ret;
}
void setWork(int work) {
pthread_mutex_lock(&mutex);
this->work = work;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
}
int empty() {
return q.empty();
}
int size() {
return q.size();
}
void clear() {
pthread_mutex_lock(&mutex);
int size = q.size();
for (int i = 0; i < size; ++i) {
T value = q.front();
releaseCallBack(value);
q.pop();
}
pthread_mutex_unlock(&mutex);
}
void sync() {
pthread_mutex_lock(&mutex);
// 同步代码块 能在线程安全的背景下操作 queue :例如 主动丢包
syncHandle(q);
pthread_mutex_unlock(&mutex);
}
void setReleaseCallBack(ReleaseCallBack r) {
releaseCallBack = r;
}
void setSyncHandle(SyncHandle s) {
syncHandle = s;
}
private:
pthread_cond_t cond;
pthread_mutex_t mutex;
queue<T> q;
// 是否工作 1工作 0不工作
int work;
ReleaseCallBack releaseCallBack;
SyncHandle syncHandle;
};
#endif //DNRECORDER_SAFE_QUEUE_H
4.AudioChannel.h & AudioChannel.cpp
AudioChannel.h:
#ifndef MYFFMPEGPLAYER_AUDIOCHANNEL_H
#define MYFFMPEGPLAYER_AUDIOCHANNEL_H
#include "BaseChannel.h"
#include <SLES/OpenSLES.h>
#include <SLES/OpenSLES_Android.h>
extern "C"{
#include <libswresample/swresample.h>
};
class AudioChannel : public BaseChannel{
public:
AudioChannel(int i, AVCodecContext *avCodecContext);
~AudioChannel();
// 解码+播放
void start();
// 解码
void decode();
// 播放
void play();
int getPcm();
uint8_t *data = 0;
int out_channels;
int out_samplesize;
int out_sample_rate;
private:
/**
* OpenSL ES
*/
// 引擎与引擎接口
SLObjectItf engineObject = 0;
SLEngineItf engineInterface = 0;
//混音器
SLObjectItf outputMixObject = 0;
//播放器
SLObjectItf bqPlayerObject = 0;
//播放器接口
SLPlayItf bqPlayerInterface = 0;
SLAndroidSimpleBufferQueueItf bqPlayerBufferQueueInterface =0;
//重采样
SwrContext *swrContext = 0;
// 解码线程
pthread_t pid_decode;
// 播放线程
pthread_t pid_play;
};
#endif //MYFFMPEGPLAYER_AUDIOCHANNEL_H
AudioChannel.cpp:
// 解码线程
void *task_decodes(void *args) {
AudioChannel *audioChannel = static_cast<AudioChannel *>(args);
audioChannel->decode();
return 0;
}
// 播放线程
void *task_plays(void *args) {
AudioChannel *audioChannel = static_cast<AudioChannel *>(args);
audioChannel->play();
return 0;
}
AudioChannel::AudioChannel(int i, AVCodecContext *avCodecContext) : BaseChannel(i,
avCodecContext) {
out_channels = av_get_channel_layout_nb_channels(AV_CH_LAYOUT_STEREO);
out_samplesize = av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
out_sample_rate = 44100;
//44100个16位 44100 * 2
// 44100*(双声道)*(16位)
data = static_cast<uint8_t *>(malloc(out_sample_rate * out_channels * out_samplesize));
memset(data,0,out_sample_rate * out_channels * out_samplesize);
}
AudioChannel::~AudioChannel(){
if(data){
free(data);
data = 0;
}
}
//返回获取的pcm数据大小
int AudioChannel::getPcm() {
int data_size = 0;
AVFrame *frame;
int ret = frames.pop(frame);
if (!isPlaying) {
if (ret) {
releaseAVFrame(frame);
}
return data_size;
}
//48000HZ 8位 =》 44100 16位
//重采样
// 假设我们输入了10个数据 ，swrContext转码器 这一次处理了8个数据
// 那么如果不加delays(上次没处理完的数据) , 积压
int64_t delays = swr_get_delay(swrContext, frame->sample_rate);
// 将 nb_samples 个数据 由 sample_rate采样率转成 44100 后 返回多少个数据
// 10 个 48000 = nb 个 44100
// AV_ROUND_UP : 向上取整 1.1 = 2
int64_t max_samples = av_rescale_rnd(delays + frame->nb_samples, out_sample_rate,
frame->sample_rate, AV_ROUND_UP);
//上下文+输出缓冲区+输出缓冲区能接受的最大数据量+输入数据+输入数据个数
//返回 每一个声道的输出数据
int samples = swr_convert(swrContext, &data, max_samples, (const uint8_t **) frame->data,
frame->nb_samples);
//获得 samples 个 * 2 声道 * 2字节（16位）
data_size = samples * out_samplesize * out_channels;
return data_size;
}
void AudioChannel::start() {
//0+输出声道+输出采样位+输出采样率+ 输入的3个参数
swrContext = swr_alloc_set_opts(0, AV_CH_LAYOUT_STEREO, AV_SAMPLE_FMT_S16, out_sample_rate,
avCodecContext->channel_layout, avCodecContext->sample_fmt,
avCodecContext->sample_rate, 0, 0);
//初始化
swr_init(swrContext);
isPlaying = 1;
packets.setWork(1);
frames.setWork(1);
//1.解码
pthread_create(&pid_decode, NULL, task_decodes, this);
//2.播放
pthread_create(&pid_play, NULL, task_plays, this);
}
// 解码
void AudioChannel::decode() {
AVPacket *avPacket = 0;
while (isPlaying) {
//取出一个数据包
int ret = packets.pop(avPacket);
if (!isPlaying) {
break;
}
if (!ret) {
continue;
}
// 把包丢给解码器
ret = avcodec_send_packet(avCodecContext, avPacket);
releaseAVPacket(avPacket);
if (ret != 0) {
break;
}
AVFrame *avFrame = av_frame_alloc();
// 从解码器中读取解码后的数据包
ret = avcodec_receive_frame(avCodecContext, avFrame);
if (ret == AVERROR(EAGAIN)) {
// 读取失败 需要重试
continue;
} else if (ret != 0) {
break;
}
frames.push(avFrame);
}
releaseAVPacket(avPacket);
}
//回调函数 用于 播放
void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context) {
AudioChannel *audioChannel = static_cast<AudioChannel *>(context);
//获得pcm 数据 多少个字节 data
int dataSize = audioChannel->getPcm();
if(dataSize > 0 ){
// 接收16位数据
(*bq)->Enqueue(bq,audioChannel->data,dataSize);
}
}
// 播放
void AudioChannel::play() {
/**
* 1、创建引擎并获取引擎接口
*/
SLresult result;
// 1.1 创建引擎 SLObjectItf engineObject
result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
if (SL_RESULT_SUCCESS != result) {
return;
}
// 1.2 初始化引擎 init
result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
if (SL_RESULT_SUCCESS != result) {
return;
}
// 1.3 获取引擎接口SLEngineItf engineInterface
result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE,
&engineInterface);
if (SL_RESULT_SUCCESS != result) {
return;
}
/**
* 2、设置混音器
*/
// 2.1 创建混音器SLObjectItf outputMixObject
result = (*engineInterface)->CreateOutputMix(engineInterface, &outputMixObject, 0,
0, 0);
if (SL_RESULT_SUCCESS != result) {
return;
}
// 2.2 初始化混音器outputMixObject
result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
if (SL_RESULT_SUCCESS != result) {
return;
}
/**
* 3、创建播放器
*/
//3.1 配置输入声音信息
//创建buffer缓冲类型的队列 2个队列
SLDataLocator_AndroidSimpleBufferQueue android_queue = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
2};
//pcm数据格式
//pcm+2(双声道)+44100(采样率)+ 16(采样位)+16(数据的大小)+LEFT|RIGHT(双声道)+小端数据
SLDataFormat_PCM 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};
//数据源 将上述配置信息放到这个数据源中
SLDataSource slDataSource = {&android_queue, &pcm};
//3.2 配置音轨(输出)
//设置混音器
SLDataLocator_OutputMix outputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
SLDataSink audioSnk = {&outputMix, NULL};
//需要的接口 操作队列的接口
const SLInterfaceID ids[1] = {SL_IID_BUFFERQUEUE};
const SLboolean req[1] = {SL_BOOLEAN_TRUE};
//3.3 创建播放器
(*engineInterface)->CreateAudioPlayer(engineInterface, &bqPlayerObject, &slDataSource,
&audioSnk, 1,
ids, req);
//初始化播放器
(*bqPlayerObject)->Realize(bqPlayerObject, SL_BOOLEAN_FALSE);
//得到接口后调用 获取Player接口
(*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_PLAY, &bqPlayerInterface);
/**
* 4、设置播放回调函数
*/
//获取播放器队列接口
(*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_BUFFERQUEUE,
&bqPlayerBufferQueueInterface);
//设置回调
(*bqPlayerBufferQueueInterface)->RegisterCallback(bqPlayerBufferQueueInterface,
bqPlayerCallback, this);
/**
* 5、设置播放状态
*/
(*bqPlayerInterface)->SetPlayState(bqPlayerInterface, SL_PLAYSTATE_PLAYING);
/**
* 6、手动激活一下这个回调
*/
bqPlayerCallback(bqPlayerBufferQueueInterface, this);
}
5.DNFFmpeg.h & DNFFmpeg.cpp
DNFFmpeg.h:
#ifndef MYFFMPEGPLAYER_DNFFMPEG_H
#define MYFFMPEGPLAYER_DNFFMPEG_H
#include "mylog.h"
#include <cstring>
#include <pthread.h>
#include "DNFFmpeg.h"
#include "JavaCallHelper.h"
#include "AudioChannel.h"
#include "VideoChannel.h"
extern "C" {
#include <libavformat/avformat.h>
}
class DNFFmpeg {
public:
DNFFmpeg(JavaCallHelper* callHelper,const char* dataSource);
~DNFFmpeg();
// 播放器准备工作
void prepare();
// 线程中调用该方法,用于实现具体解码音视频代码
void _prepare();
// 播放
void start();
// 线程中调用该方法 用于实现具体的播放代码
void _start();
void setRenderFrameCallback(RenderFrameCallback callback);
private:
// 音视频地址
char *dataSource;
// 解码线程
pthread_t pid;
// 解码器上下文
AVFormatContext *formatContext = 0;
// 播放线程
pthread_t pid_start;
// ...
JavaCallHelper* callHelper = 0;
AudioChannel *audioChannel = 0;
VideoChannel *videoChannel = 0;
//是否正在播放
bool isPlaying = 0;
// 开始播放的回调 解码器解码完成后调用 native_window
RenderFrameCallback callback;
};
#endif //MYFFMPEGPLAYER_DNFFMPEG_H
DNFFmpeg.cpp:
#include "DNFFmpeg.h"
// 解码线程
void* task_prepare(void* args){
DNFFmpeg *dnfFmpeg = static_cast<DNFFmpeg *>(args);
//调用解码方法
dnfFmpeg->_prepare();
return 0;
}
// 播放线程
void* task_start(void* args){
DNFFmpeg *dnfFmpeg = static_cast<DNFFmpeg *>(args);
//调用解码方法
dnfFmpeg->_start();
return 0;
}
DNFFmpeg::DNFFmpeg(JavaCallHelper *callHelper, const char *dataSource){
this->callHelper = callHelper;
//防止 dataSource参数 指向的内存被释放
this->dataSource = new char[strlen(dataSource)+1];
strcpy(this->dataSource,dataSource);
}
DNFFmpeg::~DNFFmpeg() {
//释放
DELETE(dataSource);
DELETE(callHelper);
}
void DNFFmpeg::prepare() {
// 创建一个解码的线程
pthread_create(&pid,NULL,task_prepare,this);
}
// 解码器打开的实现方法
void DNFFmpeg::_prepare() {
// 初始化网络 让ffmpeg能够使用网络
avformat_network_init();
//1、打开媒体地址(文件地址、直播地址)
// AVFormatContext 包含了 视频的 信息(宽、高等)
formatContext = 0;
//文件路径不对 手机没网
int ret = avformat_open_input(&formatContext,dataSource,0,0);
//ret不为0表示 打开媒体失败
if(ret != 0){
LOGFFE("打开媒体失败:%s",av_err2str(ret));
callHelper->onPreError(THREAD_CHILD,FFMPEG_CAN_NOT_OPEN_URL);
return;
}
//2、查找媒体中的 音视频流 (给 contxt里的 streams等成员赋)
ret = avformat_find_stream_info(formatContext,0);
// 小于0 则失败
if (ret < 0){
LOGFFE("查找流失败:%s",av_err2str(ret));
callHelper->onPreError(THREAD_CHILD,FFMPEG_CAN_NOT_FIND_STREAMS);
return;
}
//nb_streams :几个流(几段视频/音频)
for (int i = 0; i < formatContext->nb_streams; ++i) {
//可能代表是一个视频 也可能代表是一个音频
AVStream *stream = formatContext->streams[i];
//包含了 解码 这段流 的各种参数信息(宽、高、码率、帧率)
AVCodecParameters *codecpar = stream->codecpar;
//无论视频还是音频都需要干的一些事情（获得解码器）
// 1、通过 当前流 使用的 编码方式，查找解码器
AVCodec *dec = avcodec_find_decoder(codecpar->codec_id);
if(dec == NULL){
LOGFFE("查找解码器失败:%s",av_err2str(ret));
callHelper->onPreError(THREAD_CHILD,FFMPEG_FIND_DECODER_FAIL);
return;
}
//2、获得解码器上下文
AVCodecContext *context = avcodec_alloc_context3(dec);
if(context == NULL){
LOGFFE("创建解码上下文失败:%s",av_err2str(ret));
callHelper->onPreError(THREAD_CHILD,FFMPEG_ALLOC_CODEC_CONTEXT_FAIL);
return;
}
//3、设置上下文内的一些参数 (context->width)
// context->width = codecpar->width;
// context->height = codecpar->height;
ret = avcodec_parameters_to_context(context,codecpar);
//失败
if(ret < 0){
LOGFFE("设置解码上下文参数失败:%s",av_err2str(ret));
callHelper->onPreError(THREAD_CHILD,FFMPEG_CODEC_CONTEXT_PARAMETERS_FAIL);
return;
}
// 4、打开解码器
ret = avcodec_open2(context,dec,0);
if (ret != 0){
LOGFFE("打开解码器失败:%s",av_err2str(ret));
callHelper->onPreError(THREAD_CHILD,FFMPEG_OPEN_DECODER_FAIL);
return;
}
//音频
if (codecpar->codec_type == AVMEDIA_TYPE_AUDIO){
audioChannel = new AudioChannel(i,context);
} else if(codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
videoChannel = new VideoChannel(i,context);
// 设置播放的回调
videoChannel->setRenderFrameCallBack(callback);
}
}
//没有音视频 (很少见)
if(!audioChannel && !videoChannel){
LOGFFE("没有音视频");
callHelper->onPreError(THREAD_CHILD,FFMPEG_NOMEDIA);
return;
}
// 准备完了 通知java 你随时可以开始播放
callHelper->onPrepare(THREAD_CHILD);
}
void DNFFmpeg::start() {
//正在播放
isPlaying = 1;
if(videoChannel){
// 设置 videoChannel工作状态
videoChannel->start();
}
if(audioChannel){
// 设置 audioChannel工作状态
audioChannel->start();
}
pthread_create(&pid_start,0,task_start,this);
}
void DNFFmpeg::_start() {
// 1.读取媒体数据包(音视频数据包)
int ret;
while(isPlaying){
// 创建一个AVPacket
AVPacket *packet = av_packet_alloc();
// 读取流数据并塞入 AVPacket
ret = av_read_frame(formatContext,packet);
// ret == 0 成功 其他 失败
if(ret == 0){
// 通过 packet->stream_index 判断 是音频还是视频
// packet->stream_index 可以通过 解码循环中存放的序号做对比
if(audioChannel && packet->stream_index == audioChannel->index){
audioChannel->packets.push(packet);
}else if(videoChannel && packet->stream_index == videoChannel->index){
videoChannel->packets.push(packet);
}
}else if(ret == AVERROR_EOF){
// 读取完成 但是还没有播放完
}else{
}
}
// 2.解码
}
void DNFFmpeg::setRenderFrameCallback(RenderFrameCallback callback) {
this->callback = callback;
}
...
