android rtmp推流直播学习（二）----视频软编码x2

上篇文章我们已经采集到了视频源数据,这篇文章将介绍对视屏源数据的编码

准备工作：
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(&param,"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(&param,"baseline");
    LOGD("open video encoder");
    videoEncHandle = x264_encoder_open(&param);
    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脚本编译开源库为静态，或动态库，方便使用

项目地址