上篇文章我们已经采集到了视频源数据,这篇文章将介绍对视屏源数据的编码
准备工作：
1.x264开源库:http://www.videolan.org/developers/x264.html
2.可编译jni项目的android studio工程
1.对于x264来源库的使用，可以选择直接下载，复制到项目里面，也可以通过编译脚本编译为静态库使用。
2.可编译jni的android studio项目
android studio现在可支持cmake编译接你工程,通过CMakeLists来配置
具体步骤：
1.创建支持jni的android studio项目
创建新项目：
RPU@QG`U`F_6@@3DPOUG@WU.png
勾选c++支持
6AP6SNBFKH`BS_GA`_CL~VV.png
然后一直到项目的创建完成
这时会发现项目目录里面多了个CMakeLists.txt配置文件，这就是android studio支持jni的配置文件，跟eclipse的Android.mk配置文件类似
打开build.gradle文件，你会发现在defaultConfig节点下面多了
externalNativeBuild {
cmake {
cppFlags "-fexceptions"
abiFilters "armeabi-v7a"
arguments "-DANDROID_PLATFORM=android-9"
}
}
这是配置jni支持的手机cpu类型
在android节点下面多了
externalNativeBuild {
cmake {
path "CMakeLists.txt"
}
}
此处就是cmake的配置文件路径
2.CMakeLists简单配置
1.设置全局路径：
set(my_lib_path ${CMAKE_SOURCE_DIR}/src/main/cpp/lib)
2.导入第三方库
#导入编译好的静态库
add_library(x264 STATIC IMPORTED)
#设置导入的路径
set_target_properties(x264 PROPERTIES IMPORTED_LOCATION ${my_lib_path}/libx264.a)
3.设置头文件
include_directories(src/main/cpp)
4.宏定义
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
具体可参照项目CMakeLists配置
3.引入x264开源库
当项目创建完成之后，你会发现在与java同级目录下多了个cpp文件夹，这个文件夹就是用来写c++的，只需将下载下来的x264或者编译好的静态库拷贝到cpp下面，再在CMakeLists配置一下就行了
4.编码
1.初始化x264编码器:
LOGD("video encoder setting");
x264_param_t param;
//ultrafast cpu占用最小，zerolatency 不缓存帧
x264_param_default_preset(¶m,"ultrafast","zerolatency");
param.i_csp = X264_CSP_I420;
//配置x264编码器参数 宽高调换，因为视频解码参数为旋转90度的参数
param.i_width = mHeight;
param.i_height = mWidth;
param.i_keyint_max = 10*2;
param.i_fps_num = 10;//帧率分子
param.i_fps_den = 1;//帧率分母
param.i_threads = 1; // 建议为cpu个数
param.b_repeat_headers = 1;//复制sps和pps放在每个关键帧的前面 该参数设置是让每个关键帧(I帧)都附带sps/pps。
// param.b_cabac = 1; //自适应上下文算术编码，baseline 不支持
param.rc.i_bitrate = mBitrate/1000;//码率(比特率,单位Kbps)
param.rc.i_rc_method = X264_RC_ABR;//参数i_rc_method表示码率控制，CQP(恒定质量)，CRF(恒定码率)，ABR(平均码率)
param.rc.i_vbv_buffer_size = mBitrate/1000;//设置了i_vbv_max_bitrate必须设置此参数，码率控制区大小,单位kbps
param.rc.i_vbv_max_bitrate = (int) (mBitrate / 1000 * 1.2);//瞬时最大码率
param.rc.f_rf_constant_max =45;
param.rc.b_mb_tree = 0;
x264_param_apply_profile(¶m,"baseline");
LOGD("open video encoder");
videoEncHandle = x264_encoder_open(¶m);
pic_in = (x264_picture_t *) malloc(sizeof(x264_picture_t));
pic_out = (x264_picture_t *) malloc(sizeof(x264_picture_t));
//配置x264编码器参数 宽高调换，因为视频解码参数为旋转90度的参数
x264_picture_alloc(pic_in,X264_CSP_I420,param.i_width,param.i_height);
x264_picture_init(pic_out);
2.编码
前篇视频采集的源数据是nv21数据及yuv420sp，需要转换成yuv420p数据，转换方法
public static void Nv21ToI420(byte[] data, byte[] dstData, int w, int h) {
int size = w * h;
// Y
System.arraycopy(data, 0, dstData, 0, size);
for (int i = 0; i < size / 4; i++) {
dstData[size + i] = data[size + i * 2 + 1]; //U
dstData[size + size / 4 + i] = data[size + i * 2]; //V
}
}
由于视频采集的数据是被旋转90度的，所以要显示原数据需要旋转，旋转算法：
void Stream::n420_spin(char *dstyuv, char *srcdata, int imageWidth, int imageHeight) {
int i = 0, j = 0;
int index = 0;
int tempindex = 0;
int div = 0;
for (i = 0; i < imageWidth; i++) {
// div = i + 1; //逆时针旋转90度
div = imageWidth -i;//顺时针旋转90度
tempindex = 0;
for (j = 0; j < imageHeight; j++) {
tempindex += imageWidth;
dstyuv[index++] = srcdata[tempindex - div];
}
}
//u起始位置
int start = imageWidth * imageHeight;
//u v 数据的长度
int udiv = start >> 2;
//u v 数据宽度
int uWidth = imageWidth >> 1;
//u v 数据高度
int uHeight = imageHeight >> 1;
//数据 下标位置
index = start;
for (i = 0; i < uWidth; i++) {
// div = i + 1; //逆时针旋转90度
div = uHeight -i;//顺时针旋转90度
tempindex = start;
for (j = 0; j < uHeight; j++) {
tempindex += uHeight;
dstyuv[index] = srcdata[tempindex - div];
dstyuv[index + udiv] = srcdata[tempindex - div + udiv];
index++;
}
}
}
数据还原之后就需要视频编码：
void Stream::add_video_yuv420(UCHAR * yuv,jboolean isBack) {
UCHAR * buf = new UCHAR[mWidth*mHeight*3/2];
//旋转算法 次算法为顺时针旋转90度算法
if(isBack){
n420_spin((char *) buf, (char *) yuv, mWidth, mHeight);
} else{
n420_spin2((char *) buf, (char *) yuv, mWidth, mHeight);
}
isEncoding = 1;
if(!readyPushing || !pushing){
LOGD("pusher thread is not start readyPushing:%d pushing:%d",readyPushing,pushing);
pthread_mutex_lock(&encoder_mutex);
pthread_cond_signal(&encoder_cond);
pthread_mutex_unlock(&encoder_mutex);
isEncoding = 0;
return;
}
pthread_mutex_lock(&encoder_mutex);
//将yuv数据分别拷贝
memcpy(pic_in->img.plane[0], buf, (size_t) (mWidth * mHeight));//y
memcpy(pic_in->img.plane[1],buf+mWidth*mHeight, (size_t) (mWidth * mHeight >> 2));//u
memcpy(pic_in->img.plane[2],buf+mWidth*mHeight+(mWidth*mHeight>>2),(size_t) (mWidth * mHeight >> 2));//v
free(buf);
int nNal = -1;
x264_nal_t *nal = NULL;
long l = (long) RTMP_GetTime();
// LOGD("编码开始");
//编码
if(!x264_encoder_encode(videoEncHandle,&nal,&nNal,pic_in,pic_out)){
LOGD("encode faile");
pthread_cond_signal(&encoder_cond);
pthread_mutex_unlock(&encoder_mutex);
isEncoding = 0;
return;
}
pic_in->i_pts++;
pic_out->i_pts++;
int sps_len,pps_len;
UCHAR *sps;
UCHAR *pps;
//获取sps pps 和视频数据帧
for (int i = 0; i < nNal; i++) {
if(nal[i].i_type == NAL_SPS){
sps_len = nal[i].i_payload - 4;
sps = (UCHAR *) malloc((size_t) (sps_len + 1));
memcpy(sps,nal[i].p_payload+4, (size_t) sps_len);
} else if(nal[i].i_type == NAL_PPS){
pps_len = nal[i].i_payload - 4;
pps = (UCHAR *) malloc((size_t) (pps_len + 1));
memcpy(pps,nal[i].p_payload+4, (size_t) pps_len);
add_264_header(pps,sps,pps_len,sps_len);
free(sps);
free(pps);
} else{
add_264_body(nal[i].p_payload,nal[i].i_payload);
}
}
// LOGD("编码完成");
pthread_cond_signal(&encoder_cond);
pthread_mutex_unlock(&encoder_mutex);
isEncoding = 0;
}
5.调用
//java方法与jni比较
//com.dzm.live.LivePusher.initVedioEncode
//Java_com_dzm_live_LivePusher_initVedioEncode
JNIEXPORT void JNICALL
Java_com_dzm_live_LivePusher_initVedioEncode(JNIEnv *env, jobject instance,jint threadSize) {
if(!stream)
return;
stream->initVideoEncoder(threadSize);
}
static {
System.loadLibrary("Dvr");
}
/**
* 初始化视频编码器
*/
public native void initVedioEncode(int threadSize);
创建jni项目的时候系统会自动创建java调用c++的调用类，可仿照修改
总结：
1.想学习软编吗，需要学习jni只有，要有c++基础，主要是android studio的CMakeLists配置，稍有差错将导致编译不通过
2.视频编解码学习是一个长期的过程，推荐雷神的学习博客,原雷神一路走好，感谢
3.开源库的编译，可以学习通过linux脚本编译开源库为静态，或动态库，方便使用
