本文将带您了解关于使用java-ffmpeg包装器，还是只使用java运行时来执行ffmpeg？的新内容，同时我们还将为您解释java封装ffmpeg的相关知识，另外，我们还将为您提供关于Androi
本文将带您了解关于使用java-ffmpeg包装器，还是只使用java运行时来执行ffmpeg？的新内容，同时我们还将为您解释java封装ffmpeg的相关知识，另外，我们还将为您提供关于Android使用FFmpeg(一)--编译ffmpeg、Android使用FFmpeg(七)--ffmpeg实现暂停、快退快进播放、Android使用FFmpeg(三)--ffmpeg实现视频播放、Android使用FFmpeg(五)--ffmpeg实现音频播放(使用openSL ES进行播放)的实用信息。
本文目录一览：- 使用java-ffmpeg包装器，还是只使用java运行时来执行ffmpeg？（java封装ffmpeg）
- Android使用FFmpeg(一)--编译ffmpeg
- Android使用FFmpeg(七)--ffmpeg实现暂停、快退快进播放
- Android使用FFmpeg(三)--ffmpeg实现视频播放
- Android使用FFmpeg(五)--ffmpeg实现音频播放(使用openSL ES进行播放)
使用java-ffmpeg包装器，还是只使用java运行时来执行ffmpeg？（java封装ffmpeg）
我对Java还是很陌生，需要编写一个程序来侦听视频转换指令，并在新指令到达时转换视频（指令存储在Amazon SQS中，但这与我的问题无关）
我面临一个选择，要么使用Java RunTime来执行ffmpeg转换（例如从命令行执行），要么可以使用以Java http://fmj-
sf.net/ffmpeg-java/getting_started.php编写的ffmpeg包装器
我更喜欢使用Java Runtime直接执行ffmpeg，并避免使用java-
ffmpeg包装器，因为我必须学习该库。所以我的问题是，直接使用运行时，使用java-ffmpeg包装器比使用exec
ffmpeg有什么好处吗？我不需要ffmpeg播放视频，只需转换视频
谢谢
答案1
小编典典如果我没记错的话，您链接到的“ ffmpeg包装器”项目已过时并且不会维护。ffmpeg是一个非常活跃的项目，经常进行很多更改并发布。
您应该查看Xuggler项目，该项目提供了您想要执行的操作的Java API，并且它们与ffmpeg紧密集成。
http://www.xuggle.com/xuggler/
如果您选择沿着Runtime.exec（）路径运行，则此Red5线程应该很有用：
http://www.nabble.com/java-call-ffmpeg-
ts15886850.html
Android使用FFmpeg(一)--编译ffmpeg
关于
Android使用FFmpeg(一)--编译ffmpeg
Android使用FFmpeg(二)--Android Studio配置ffmpeg
Android使用FFmpeg(三)--ffmpeg实现视频播放
Android使用FFmpeg(四)--ffmpeg实现音频播放(使用AudioTrack进行播放)
Android使用FFmpeg(五)--ffmpeg实现音频播放(使用openSL ES进行播放)
Android使用FFmpeg(六)--ffmpeg实现音视频同步播放
Android使用FFmpeg(七)--ffmpeg实现暂停、快退快进播放
前言
ffmpeg简介
在现今这个阶段，越来越多的app会涉及到音视频，那么学会使用ffmpeg就很有必要了。在这个系类中将讲解如何把ffmpeg编译成动态库，以及使用ffmpeg实现音视频播放和音视频的采集。
编译环境
Linux/Ubuntu/centos都行
在windows环境下可以安装虚拟机或者购买一个云主机，作者在金山云购买的一个Ubuntu主机。
准备工作
下载配置ndk，下载ffmpeg并解压。
开始
配置ndk
如果你已经配置ok，请跳过这一步。
我们打开自己的虚拟机或者云服务器并且获取到root权限。创建文件夹ndk_build并进入到文件夹中，下载ndk，并解压
mkdir ndk_build//新建文件夹
cd ndk_build//进入到文件夹
wget +linux版本的下载链接地址//下载ndk
unzip + 压缩文件//解压
配置ndk
vim ~/.bashrc//进入环境变量配置
export NDKROOT=/home/ndk_build/android-ndk-r14b//配置你的安装路径
export PATH=$NDKROOT:$PATH//配置路径
:wq!//保存退出
source ~/.bashrc//执行环境变量
ndk-build//查看是否安装成功，只要不是显示ndk-build not found，则表示安装成功
下载编译ffmpeg
下载ffmpeg并解压
下载ffmpeg并解压.png
wget http://ffmpeg.org/releases/ffmpeg-2.6.9.tar.gz
tar -xzf ffmpeg-2.6.9.tar.gz
修改configure文件并新建android_build.sh文件，编辑android_build.sh
#!/bin/bash
make clean
export NDK=/home/ndk_build/android-ndk-r14b
export SYSROOT=$NDK/platforms/android-9/arch-arm/
export TOOLCHAIN=$NDK/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64
export CPU=arm
export PREFIX=$(pwd)/android/$CPU
export ADDI_CFLAGS="-marm"
./configure --target-os=linux \
--prefix=$PREFIX --arch=arm \
--disable-doc \
--enable-shared \
--disable-static \
--disable-yasm \
--disable-symver \
--enable-gpl \
--disable-ffmpeg \
--disable-ffplay \
--disable-ffprobe \
--disable-ffserver \
--disable-doc \
--disable-symver \
--cross-prefix=$TOOLCHAIN/bin/arm-linux-androideabi- \
--enable-cross-compile \
--sysroot=$SYSROOT \
--extra-cflags="-Os -fpic $ADDI_CFLAGS" \
--extra-ldflags="$ADDI_LDFLAGS" \
$ADDITIONAL_CONFIGURE_FLAG
make clean
make
make install
其中NDK是你自己刚刚配置的ndk路径，SYSROOT为platforms中的路径，TOOLCHAIN为toolchains里面中的路径，依次配置好过后保存并退出。
修改configure，如果你不修改的话，编译出来过后的.so文件后面会有一串数字，无法使用，所以得修改他的命名规则。
将该文件中的如下四行：
SLIBNAME_WITH_MAJOR=''$(SLIBNAME).$(LIBMAJOR)''
LIB_INSTALL_EXTRA_CMD=''$$(RANLIB)"$(LIBDIR)/$(LIBNAME)"''
SLIB_INSTALL_NAME=''$(SLIBNAME_WITH_VERSION)''
SLIB_INSTALL_LINKS=''$(SLIBNAME_WITH_MAJOR)$(SLIBNAME)''
替换为：
SLIBNAME_WITH_MAJOR=''$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)''
LIB_INSTALL_EXTRA_CMD=''$$(RANLIB)"$(LIBDIR)/$(LIBNAME)"''
SLIB_INSTALL_NAME=''$(SLIBNAME_WITH_MAJOR)''
SLIB_INSTALL_LINKS=''$(SLIBNAME)''
编译.sh文件
···
./android_build.sh
···
当编译成功过后会在文件夹中出现android文件夹，
在lib文件夹中就有你需要的.so文件了
这样就差不多编译完成，如果你需要编译一份别人已经编译过的ffmpeg，那么请先执行./confifure --disable-yasm，然后再自己编译。
如果还没编译好但是急需的朋友可以直接下载使用。
so下载地址
Android使用FFmpeg(七)--ffmpeg实现暂停、快退快进播放
Android使用FFmpeg(一)--编译ffmpeg
Android使用FFmpeg(二)--Android Studio配置ffmpeg
Android使用FFmpeg(三)--ffmpeg实现视频播放
Android使用FFmpeg(四)--ffmpeg实现音频播放(使用AudioTrack进行播放)
Android使用FFmpeg(五)--ffmpeg实现音频播放(使用openSL ES进行播放)
Android使用FFmpeg(六)--ffmpeg实现音视频同步播放
Android使用FFmpeg(七)--ffmpeg实现暂停、快退快进播放
前言
这篇文章关于ffmpeg的解决方案仅提供参考，如有错误，欢迎指正。
播放、暂停
在音视频播放的时候，我们均是将读取到的Packet放入到队列中，然后再从队列中取出packet进行解码播放。所以在播放、暂停时可以在队列的取出上面做文章。
int FFmpegMusic::get(AVPacket *avPacket) {
LOGE("取出队列")
pthread_mutex_lock(&mutex);
while (isPlay){
if(!queue.empty()&&isPause){
LOGE("ispause %d",isPause);
//如果队列中有数据可以拿出来
if(av_packet_ref(avPacket,queue.front())){
break;
}
//取成功了，弹出队列，销毁packet
AVPacket *packet2 = queue.front();
queue.pop();
av_free(packet2);
break;
} else{
LOGE("音频执行wait")
LOGE("ispause %d",isPause);
pthread_cond_wait(&cond,&mutex);
}
}
pthread_mutex_unlock(&mutex);
return 0;
}
如上，我们控制isPause的值来让线程进入wait状态，如果需要继续播放的话需唤醒线程，继续从队列中取出packet
if(isPause==1){
isPause=0;
} else{
isPause=1;
pthread_cond_signal(&cond);
}
进度条
进度条在java层使用的SeekBar，需要取到视频的总时间以及播放的时间。
视频总时间，注意是在获取视频信息(avformat_find_stream_info(pFormatCtx, NULL))过后才能得到总时间：
//得到播放总时间
if(pFormatCtx->duration != AV_NOPTS_VALUE){
duration = pFormatCtx->duration;//微秒
}
因为播放时是以音频为基础，所以需要得到音频的播放时间，因为在播放音频时有单独记录音频的播放时间，所以我们可以直接得到：
return ffmpegMusic->clock;
在java层实时绘制取到音频播放时间并绘制进度，while(true)的条件为是否正在播放，这里为了方便，所以这样写：
new Thread(new Runnable() {
@Override
public void run() {
while (true){
try {
Message message = new Message();
message.what = (int) Player.getCurrentPosition()*1000;
handler.sendMessage(message);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}).start();
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
mSeekBar.setProgress(msg.what);
}
};
快退、快进
主要涉及到跳帧函数:int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags);
AVFormatContext *s：封装格式上下文
int stream_index：音频流或者视频流
int64_t timestamp：时间，如果流为-1，那么时间的单位为AV_TIME_BASE；如果为具体的流，那么时间单位为AVStream.time_base 。
int flags：功能flag
大概思路：
清空队列-->av_seek_frame-->av_read_frame-->put队列
注意：因为系统自带的队列没有clear函数，如果使用queue.pop将会使效率非常慢，会有卡顿迹象，所以作者将queue换成了vector，这样可以直接clear，在清空队列的时候效率大大提高。
void seekTo(int mesc) {
if (mesc <= 0) {
mesc=0;
}
//清空vector
ffmpegMusic->queue.clear();
ffmpegVideo->queue.clear();
//跳帧
//-1表示默认流
if (av_seek_frame(pFormatCtx, -1, mesc * AV_TIME_BASE, AVSEEK_FLAG_BACKWARD) < 0) {
LOGE("failed")
} else {
LOGE("success")
}
//如果是确认某一个流，
av_seek_frame(pFormatCtx, ffmpegVideo->index, (int64_t) (mesc /av_q2d(ffmpegVideo->time_base)), AVSEEK_FLAG_BACKWARD);
av_seek_frame(pFormatCtx, ffmpegMusic->index, (int64_t) (mesc /av_q2d(ffmpegMusic->time_base)), AVSEEK_FLAG_BACKWARD);
}
//while循环一直在线程中执行
while (isPlay) {
ret = av_read_frame(pFormatCtx, packet);
if (ret == 0) {
if (ffmpegVideo && ffmpegVideo->isPlay && packet->stream_index == ffmpegVideo->index
) {
//将视频packet压入队列
ffmpegVideo->put(packet);
} else if (ffmpegMusic && ffmpegMusic->isPlay &&
packet->stream_index == ffmpegMusic->index) {
ffmpegMusic->put(packet);
}
av_packet_unref(packet);
} else if (ret == AVERROR_EOF) {
// 读完了
//读取完毕 但是不一定播放完毕
while (isPlay) {
if (ffmpegVideo->queue.empty() && ffmpegMusic->queue.empty()) {
break;
}
// LOGE("等待播放完成");
av_usleep(10000);
}
}
}
需要跳转时直接调用这个函数即可：
seekTo(gettime/1000);//将毫秒转为秒
Android使用FFmpeg(三)--ffmpeg实现视频播放
前言
如果你已经准备好ffmpeg的开发环境，那么我们在这篇文章中实现对视频的一个播放，如果还没有准备好，请看前面的内容。
正文
Ok，上图就是使用ffmpeg实现了一个视频的播放的大概流程图，那么，我们将根据流程图来编写代码，这样子，代码的编写就会显得比较简单，比较好理解了。
1.注册各大组件，这一步很重要，如果不注册就无法使用后面的函数了。
av_register_all();
2.在解码之前我们得获取里面的内容吧，所以这一步就是打开地址并且获取里面的内容。其中avFormatContext是内容的一个上下文，inputPath为输入的地址。
AVFormatContext *avFormatContext = avformat_alloc_context();//获取上下文
avformat_open_input(&avFormatContext, inputPath, NULL, NULL)//解封装
avformat_find_stream_info(avFormatContext, NULL)
3.我们在上面已经获取了内容，但是在一个音视频中包括了音频流，视频流和字幕流，所以在所有的内容当中，我们应当找出相对应的视频流。
int video_index=-1;
for (int i = 0; i < avFormatContext->nb_streams; ++i) {
if (avFormatContext->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
//如果是视频流,标记一哈
video_index = i;
}
}
4.在第三步的时候已经找到了视频流，那么我们就对视频流进行解码、转换和绘制。
a.如果要进行解码，那么得有解码的装置并打开解码的装置。
//获取解码的装置上下文
AVCodecContext *avCodecContext = avFormatContext->streams[video_index]->codec;
//获取解码的装置
AVCodec *avCodec = avcodec_find_decoder(avCodecContext->codec_id);
//打开解码的装置
if (avcodec_open2(avCodecContext, avCodec, NULL) < 0) {
LOGE("打开失败")
return;
}
b.申请AVPacket和AVFrame，其中AVPacket的作用是：保存解码之前的数据和一些附加信息，如显示时间戳（pts）、解码时间戳（dts）、数据时长，所在媒体流的索引等；AVFrame的作用是：存放解码过后的数据。
具体可参考：http://blog.csdn.net/leixiaohua1020/article/details/11693997
//申请AVPacket
AVPacket *packet = (AVPacket *) av_malloc(sizeof(AVPacket));
av_init_packet(packet);
//申请AVFrame
AVFrame *frame = av_frame_alloc();//分配一个AVFrame结构体,AVFrame结构体一般用于存储原始数据，指向解码后的原始帧
AVFrame *rgb_frame = av_frame_alloc();//分配一个AVFrame结构体，指向存放转换成rgb后的帧
c.因为rgb_frame是一个缓存区域，所以需要设置。
//缓存区
uint8_t *out_buffer= (uint8_t *)av_malloc(avpicture_get_size(AV_PIX_FMT_RGBA,
avCodecContext->width,avCodecContext->height));
//与缓存区相关联，设置rgb_frame缓存区
avpicture_fill((AVPicture *)rgb_frame,out_buffer,AV_PIX_FMT_RGBA,avCodecContext->width,avCodecContext->height);
d.因为是原生绘制，即是说需要ANativeWindow。
//取到nativewindow
ANativeWindow *nativeWindow=ANativeWindow_fromSurface(env,surface);
if(nativeWindow==0){
LOGE("nativewindow取到失败")
return;
}
//视频缓冲区
ANativeWindow_Buffer native_outBuffer;
e.一切准备妥当，那么我们开始解码。
while (av_read_frame(avFormatContext, packet) >= 0) {
LOGE("解码 %d",packet->stream_index)
LOGE("VINDEX %d",video_index)
if(packet->stream_index==video_index){
LOGE("解码 hhhhh")
//如果是视频流
//解码
avcodec_decode_video2(avCodecContext, frame, &frameCount, packet)
}
av_free_packet(packet);
}
f.以下均在循环里面进行，当解码一帧成功过后，我们转换成rgb格式并且绘制。
if (frameCount) {
LOGE("转换并绘制")
//说明有内容
//绘制之前配置nativewindow
ANativeWindow_setBuffersGeometry(nativeWindow,avCodecContext->width,avCodecContext->height,WINDOW_FORMAT_RGBA_8888);
//上锁
ANativeWindow_lock(nativeWindow, &native_outBuffer, NULL);
//转换为rgb格式
sws_scale(swsContext,(const uint8_t *const *)frame->data,frame->linesize,0,
frame->height,rgb_frame->data,
rgb_frame->linesize);
// rgb_frame是有画面数据
uint8_t *dst= (uint8_t *) native_outBuffer.bits;
// 拿到一行有多少个字节 RGBA
int destStride=native_outBuffer.stride*4;
//像素数据的首地址
uint8_t * src= rgb_frame->data[0];
// 实际内存一行数量
int srcStride = rgb_frame->linesize[0];
//int i=0;
for (int i = 0; i < avCodecContext->height; ++i) {
// memcpy(void *dest, const void *src, size_t n)
//将rgb_frame中每一行的数据复制给nativewindow
memcpy(dst + i * destStride, src + i * srcStride, srcStride);
}
//解锁
ANativeWindow_unlockAndPost(nativeWindow);
usleep(1000 * 16);
}
在上面的代码中，因为转换成rgb格式过后的内容是存在ffmpeg所指向的地址而不是ANativeWindow所指向的所在地址，所以要绘制的话我们需要将内容复制到ANativeWindow中。
5.完成过后得释放资源，不然就造成内存泄露了。
ANativeWindow_release(nativeWindow);
av_frame_free(&frame);
av_frame_free(&rgb_frame);
avcodec_close(avCodecContext);
avformat_free_context(avFormatContext);
env->ReleaseStringUTFChars(inputStr_, inputPath);
6.java层代码，因为是原生绘制，所以需要传入Surface，所以创建一个类继承SurfaceView。
class VideoView : SurfaceView {
constructor(context: Context) : super(context) {}
constructor(context: Context, attrs: AttributeSet) : super(context, attrs) {
init()
}
private fun init() {
val holder = holder
holder.setFormat(PixelFormat.RGBA_8888)
}
constructor(context: Context, attrs: AttributeSet, defStyleAttr: Int) : super(context, attrs, defStyleAttr) {}
fun player(input: String) {
Thread(Runnable {
// 绘制功能 不需要交给SurfaveView VideoView.this.getHolder().getSurface()
render(input, this@VideoView.holder.surface)
}).start()
}
external fun render(input: String, surface: Surface)
companion object {
init {
System.loadLibrary("avcodec-56")
System.loadLibrary("avdevice-56")
System.loadLibrary("avfilter-5")
System.loadLibrary("avformat-56")
System.loadLibrary("avutil-54")
System.loadLibrary("postproc-53")
System.loadLibrary("swresample-1")
System.loadLibrary("swscale-3")
System.loadLibrary("native-lib")
}
}
}
小结
以上就是对视频的解封装，解码，转换，绘制的一个过程，过程清晰明了，按着这个步奏来就应该来说比较简单，另外，请在真机上测试，同时导入自己想测试的视频，什么格式都可以。
Android使用FFmpeg(五)--ffmpeg实现音频播放(使用openSL ES进行播放)
关于
Android使用FFmpeg(一)--编译ffmpeg
Android使用FFmpeg(二)--Android Studio配置ffmpeg
Android使用FFmpeg(三)--ffmpeg实现视频播放
Android使用FFmpeg(四)--ffmpeg实现音频播放(使用AudioTrack进行播放)
Android使用FFmpeg(五)--ffmpeg实现音频播放(使用openSL ES进行播放)
Android使用FFmpeg(六)--ffmpeg实现音视频同步播放
Android使用FFmpeg(七)--ffmpeg实现暂停、快退快进播放
准备工作
openSL ES了解
正文
实现整体思路：使用ffmpeg解封装、解码视频得到pcm数据-->数据添加到opensl es缓冲区中-->播放
实现具体思路：因为在上篇中详细讲解了将视频通过ffmpeg解码成pcm，所以在这篇中将详细讲解如何通过opensl es播放。
我们还是根据流程图来进行代码的编写，注释已经写好，代码不懂之处可以看注释：
1.创建引擎：
//创建引擎
void createEngine(){
slCreateEngine(&engineObject,0,NULL,0,NULL,NULL);//创建引擎
(*engineObject)->Realize(engineObject,SL_BOOLEAN_FALSE);//实现engineObject接口对象
(*engineObject)->GetInterface(engineObject,SL_IID_ENGINE,&engineEngine);//通过引擎调用接口初始化SLEngineItf
}
2.创建混音器：
//创建混音器
void createMixVolume(){
(*engineEngine)->CreateOutputMix(engineEngine,&outputMixObject,0,0,0);//用引擎对象创建混音器接口对象
(*outputMixObject)->Realize(outputMixObject,SL_BOOLEAN_FALSE);//实现混音器接口对象
SLresult sLresult = (*outputMixObject)->GetInterface(outputMixObject,SL_IID_ENVIRONMENTALREVERB,&outputMixEnvironmentalReverb);//利用混音器实例对象接口初始化具体的混音器对象
//设置
if (SL_RESULT_SUCCESS == sLresult) {
(*outputMixEnvironmentalReverb)->
SetEnvironmentalReverbProperties(outputMixEnvironmentalReverb, &settings);
}
}
3.创建播放器并播放：
void createPlayer(){
//初始化ffmpeg
int rate;
int channels;
createFFmpeg(&rate,&channels);
LOGE("RATE %d",rate);
LOGE("channels %d",channels);
/*
* typedef struct SLDataLocator_AndroidBufferQueue_ {
SLuint32 locatorType;//缓冲区队列类型
SLuint32 numBuffers;//buffer位数
} */
SLDataLocator_AndroidBufferQueue android_queue = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,2};
/**
typedef struct SLDataFormat_PCM_ {
SLuint32 formatType; pcm
SLuint32 numChannels; 通道数
SLuint32 samplesPerSec; 采样率
SLuint32 bitsPerSample; 采样位数
SLuint32 containerSize; 包含位数
SLuint32 channelMask; 立体声
SLuint32 endianness; end标志位
} SLDataFormat_PCM;
*/
SLDataFormat_PCM pcm = {SL_DATAFORMAT_PCM,channels,rate*1000
,SL_PCMSAMPLEFORMAT_FIXED_16
,SL_PCMSAMPLEFORMAT_FIXED_16
,SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT,SL_BYTEORDER_LITTLEENDIAN};
/*
* typedef struct SLDataSource_ {
void *pLocator;//缓冲区队列
void *pFormat;//数据样式,配置信息
} SLDataSource;
* */
SLDataSource dataSource = {&android_queue,&pcm};
SLDataLocator_OutputMix slDataLocator_outputMix={SL_DATALOCATOR_OUTPUTMIX,outputMixObject};
SLDataSink slDataSink = {&slDataLocator_outputMix,NULL};
const SLInterfaceID ids[3]={SL_IID_BUFFERQUEUE,SL_IID_EFFECTSEND,SL_IID_VOLUME};
const SLboolean req[3]={SL_BOOLEAN_FALSE,SL_BOOLEAN_FALSE,SL_BOOLEAN_FALSE};
/*
* SLresult (*CreateAudioPlayer) (
SLEngineItf self,
SLObjectItf * pPlayer,
SLDataSource *pAudioSrc,//数据设置
SLDataSink *pAudioSnk,//关联混音器
SLuint32 numInterfaces,
const SLInterfaceID * pInterfaceIds,
const SLboolean * pInterfaceRequired
);
* */
LOGE("执行到此处")
(*engineEngine)->CreateAudioPlayer(engineEngine,&audioplayer,&dataSource,&slDataSink,3,ids,req);
(*audioplayer)->Realize(audioplayer,SL_BOOLEAN_FALSE);
LOGE("执行到此处2")
(*audioplayer)->GetInterface(audioplayer,SL_IID_PLAY,&slPlayItf);//初始化播放器
//注册缓冲区,通过缓冲区里面 的数据进行播放
(*audioplayer)->GetInterface(audioplayer,SL_IID_BUFFERQUEUE,&slBufferQueueItf);
//设置回调接口
(*slBufferQueueItf)->RegisterCallback(slBufferQueueItf,getQueueCallBack,NULL);
//播放
(*slPlayItf)->SetPlayState(slPlayItf,SL_PLAYSTATE_PLAYING);
//开始播放
getQueueCallBack(slBufferQueueItf,NULL);
}
//回调的函数
void getQueueCallBack(SLAndroidSimpleBufferQueueItf slBufferQueueItf, void* context){
buffersize=0;
getPcm(&buffer,&buffersize);
if(buffer!=NULL&&buffersize!=0){
//将得到的数据加入到队列中
(*slBufferQueueItf)->Enqueue(slBufferQueueItf,buffer,buffersize);
}
}
4.释放资源，从下往上依次释放：
void realseResource(){
if(audioplayer!=NULL){
(*audioplayer)->Destroy(audioplayer);
audioplayer=NULL;
slBufferQueueItf=NULL;
slPlayItf=NULL;
}
if(outputMixObject!=NULL){
(*outputMixObject)->Destroy(outputMixObject);
outputMixObject=NULL;
outputMixEnvironmentalReverb=NULL;
}
if(engineObject!=NULL){
(*engineObject)->Destroy(engineObject);
engineObject=NULL;
engineEngine=NULL;
}
realseFFmpeg();
}
5.关于使用ffmpeg得到pcm，我们将其单独写入一个cpp文件中，分为三部分：创建，得到pcm，释放资源。方便在openSL ES这边进行一个调用。具体代码的注释和思路在上篇中已经讲解，不懂的请看上篇的内容。这里的代码只是将整体的代码进行了分类和模块化。
//
// Created by david on 2017/9/25.
//
#include "FFmpegMusic.h"
AVFormatContext *pFormatCtx;
AVCodecContext *pCodecCtx;
AVCodec *pCodex;
AVPacket *packet;
AVFrame *frame;
SwrContext *swrContext;
uint8_t *out_buffer;
int out_channer_nb;
int audio_stream_idx=-1;
//opensl es调用 int * rate,int *channel
int createFFmpeg(int *rate,int *channel){
av_register_all();
char *input = "/sdcard/input.mp3";
pFormatCtx = avformat_alloc_context();
LOGE("Lujng %s",input);
LOGE("xxx %p",pFormatCtx);
int error;
char buf[] = "";
//打开视频地址并获取里面的内容(解封装)
if (error = avformat_open_input(&pFormatCtx, input, NULL, NULL) < 0) {
av_strerror(error, buf, 1024);
// LOGE("%s" ,inputPath)
LOGE("Couldn''t open file %s: %d(%s)", input, error, buf);
// LOGE("%d",error)
LOGE("打开视频失败")
}
//3.获取视频信息
if(avformat_find_stream_info(pFormatCtx,NULL) < 0){
LOGE("%s","获取视频信息失败");
return -1;
}
int i=0;
for (int i = 0; i < pFormatCtx->nb_streams; ++i) {
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
LOGE(" 找到音频id %d", pFormatCtx->streams[i]->codec->codec_type);
audio_stream_idx=i;
break;
}
}
// mp3的解码的装置
// 获取音频编解码的装置
pCodecCtx=pFormatCtx->streams[audio_stream_idx]->codec;
LOGE("获取视频编码器上下文 %p ",pCodecCtx);
pCodex = avcodec_find_decoder(pCodecCtx->codec_id);
LOGE("获取视频编码 %p",pCodex);
if (avcodec_open2(pCodecCtx, pCodex, NULL)<0) {
}
packet = (AVPacket *)av_malloc(sizeof(AVPacket));
// av_init_packet(packet);
// 音频数据
frame = av_frame_alloc();
// mp3 里面所包含的编码格式 转换成 pcm SwcContext
swrContext = swr_alloc();
int length=0;
int got_frame;
// 44100*2
out_buffer = (uint8_t *) av_malloc(44100 * 2);
uint64_t out_ch_layout=AV_CH_LAYOUT_STEREO;
// 输出采样位数 16位
enum AVSampleFormat out_formart=AV_SAMPLE_FMT_S16;
//输出的采样率必须与输入相同
int out_sample_rate = pCodecCtx->sample_rate;
swr_alloc_set_opts(swrContext, out_ch_layout, out_formart, out_sample_rate,
pCodecCtx->channel_layout, pCodecCtx->sample_fmt, pCodecCtx->sample_rate, 0,
NULL);
swr_init(swrContext);
// 获取通道数 2
out_channer_nb = av_get_channel_layout_nb_channels(AV_CH_LAYOUT_STEREO);
*rate = pCodecCtx->sample_rate;
*channel = pCodecCtx->channels;
return 0;
}
//
int getPcm(void **pcm,size_t *pcm_size){
int frameCount=0;
int got_frame;
while (av_read_frame(pFormatCtx, packet) >= 0) {
if (packet->stream_index == audio_stream_idx) {
// 解码 mp3 编码格式frame----pcm frame
avcodec_decode_audio4(pCodecCtx, frame, &got_frame, packet);
if (got_frame) {
LOGE("解码");
/**
* int swr_convert(struct SwrContext *s, uint8_t **out, int out_count,
const uint8_t **in , int in_count);
*/
swr_convert(swrContext, &out_buffer, 44100 * 2, (const uint8_t **) frame->data, frame->nb_samples);
// 缓冲区的大小
int size = av_samples_get_buffer_size(NULL, out_channer_nb, frame->nb_samples,
AV_SAMPLE_FMT_S16, 1);
*pcm = out_buffer;
*pcm_size = size;
break;
}
}
}
return 0;
}
void realseFFmpeg(){
av_free_packet(packet);
av_free(out_buffer);
av_frame_free(&frame);
swr_free(&swrContext);
avcodec_close(pCodecCtx);
avformat_close_input(&pFormatCtx);
}
小结
按照流程图来编写代码清晰明朗，只是一些细节的地方注意就行。另外注意以下几点：
1.测试时请使用真机测试，因为没有使用x86的cpu的.so；
2.注意添加权限；
3.注意将music.cpp添加到CMakeLists.txt中；
4.测试时请在手机中存入input.xxx的音频文件。
源码地址
今天关于使用java-ffmpeg包装器，还是只使用java运行时来执行ffmpeg？和java封装ffmpeg的讲解已经结束，谢谢您的阅读，如果想了解更多关于Android使用FFmpeg(一)--编译ffmpeg、Android使用FFmpeg(七)--ffmpeg实现暂停、快退快进播放、Android使用FFmpeg(三)--ffmpeg实现视频播放、Android使用FFmpeg(五)--ffmpeg实现音频播放(使用openSL ES进行播放)的相关知识，请在本站搜索。
本文标签：
