程序博客网 > seo软件

Ubuntu下为AndroidStudio编译并使用x264(二)AndroidStudio部分

来源：互联网 发布：seo软件 编辑：程序博客网 时间：2024/06/07 05:24
Android使用C/C++代码或库需要通过JNI方式，详细的可见相关文章。

1. 添加C/C++源文件

复制/opt/android/ndk/android-ndk-r10e/resources/x264下的文件:
x264.h
x264_config.h
到jni目录下

在jni目录下添加
x264encoder.h
x264encoder.cpp
main.cpp
三个源文件，详细源码如下：

  1. /*
  2.  * \File
  3.  * x264encoder.h
  4.  * \Author
  5.  * Hank
  6.  */
  7. #ifndef x264encoder_h 
  8. #define x264encoder_h 


  11. extern "C" 
  12. { 
  13. #include "stdint.h" 
  14. #include "x264.h" 


  17.     enum bitrate_level 
  18.     { 
  19.         HIGH_LEVEL = 0, 
  20.         STANDARD_LEVEL = 1, 
  21.         MEDIUM_LEVEL = 2, 
  22.         LOW_LEVEL = 3, 
  23.     }; 


  26.     class X264Encoder 
  27.     { 
  28.         public: 
  29.             X264Encoder(); 
  30.             ~X264Encoder(); 


  33.             bool openX264Encoder(); 
  34.             // long x264EncoderProcess(uint8_t *pSrcData, int srcDataSize, x264_nal_t **nals, int& nalsCount);


  37.             long x264EncoderProcess(x264_picture_t *pPicture, x264_nal_t **nals, int& nalsCount);


  40.             bool closeX264Encoder(); 


  43.             void setSourceFormat(unsigned int sourcformat); 
  44.             void setResolution(unsigned int w, unsigned int h); 
  45.             void setBitrate(unsigned int i_bitrate); 
  46.             void setFps(unsigned int fps); 
  47.             void setI_KeyInt_Max(unsigned int i_frame_max); 
  48.             void setQp_Max(unsigned int qp_max); 
  49.             void setQp_Min(unsigned int qp_min); 


  52.             void forceIDRFrame(); 


  55.             void upgradeBitrateLevel(); 
  56.             void declineBitrateLevel(); 
  57.             void setLeastBitrateLevel(); 




  62.         private: 
  63.             x264_param_t *pParameter; 
  64.             x264_t *x264EncoderHandle; 
  65.             // x264_picture_t *pPicture; 
  66.             x264_picture_t *pOutput; 


  69.             unsigned int sourceFormat; 
  70.             // unsigned int i_bitrate; 
  71.             unsigned int bitratelevel; 
  72.             unsigned int i_fps; 
  73.             unsigned int i_keyint_max; 
  74.             unsigned int width; 
  75.             unsigned int height; 
  76.             unsigned int qp_max; 
  77.             unsigned int qp_min; 


  80.             unsigned int current_f_rf_constant; 
  81.             unsigned int userSetting_f_rf_constant; 


  84.             int64_t frameNo; 


  87.             bool isForceIDRFrameEnabled; 
  88.      }; 
  89. } 
  90. #endif

/*
 * \File
 *   x264encoder.cpp
 * \Author
 *   Hank
 */

  1. #include <stdlib.h> 
  2. #include <string.h> 
  3. #include "x264encoder.h" 


  6. // new version for x264 encoder 
  7. X264Encoder::X264Encoder() 
  8. { 
  9.      this->bitratelevel = STANDARD_LEVEL; 
  10.      qp_max = 30; 
  11.      qp_min = 0; 
  12.      i_fps = 20; 
  13.      i_keyint_max = 300; 
  14.      width = 352; 
  15.      height = 288; 


  18.      frameNo = 0; 
  19.      isForceIDRFrameEnabled = false; 


  22.      pParameter = NULL; 
  23.      x264EncoderHandle = NULL; 
  24.      // pPicture = NULL; 
  25.      pOutput = NULL; 
  26. } 


  29. X264Encoder::~X264Encoder() 
  30. { 
  31.      this->closeX264Encoder(); 
  32. } 


  35. void X264Encoder::setSourceFormat(unsigned int sourcformat) 
  36. { 
  37.      this->sourceFormat = sourcformat; 
  38. } 


  41. void X264Encoder::setResolution(unsigned int w, unsigned int h) 
  42. { 
  43.      width = w; 
  44.      height = h; 
  45. } 


  48. void X264Encoder::setBitrate(unsigned int i_bitrate) 
  49. { 
  50.      if (i_bitrate > 0 && i_bitrate <= 64) { 
  51.           this->bitratelevel = LOW_LEVEL; 
  52.      }else if(i_bitrate > 64 && i_bitrate <= 128){ 
  53.           this->bitratelevel = MEDIUM_LEVEL; 
  54.      }else if (i_bitrate > 128 && i_bitrate <= 256) { 
  55.           this->bitratelevel = STANDARD_LEVEL; 
  56.      }else if (i_bitrate > 256 && i_bitrate <= 384) { 
  57.           this->bitratelevel = HIGH_LEVEL; 
  58.      }else if (i_bitrate > 384 && i_bitrate <= 512) { 
  59.           this->bitratelevel = HIGH_LEVEL; 
  60.      }else { 
  61.           this->bitratelevel = STANDARD_LEVEL; 
  62.      } 
  63. } 


  66. void X264Encoder::setFps(unsigned int fps) 
  67. { 
  68.      i_fps = fps; 
  69. } 


  72. void X264Encoder::setI_KeyInt_Max(unsigned int i_frame_max) 
  73. { 
  74.      i_keyint_max = i_frame_max; 
  75. } 


  78. void X264Encoder::setQp_Max(unsigned int qp_max) 
  79. { 
  80.      this->qp_max = qp_max; 
  81. } 


  84. void X264Encoder::setQp_Min(unsigned int qp_min) 
  85. { 
  86.      this->qp_min = qp_min; 
  87. } 


  90. bool X264Encoder::openX264Encoder() { 
  91.     this->closeX264Encoder(); 


  94.     if(!pParameter) 
  95.     { 
  96.         pParameter = (x264_param_t *)malloc(sizeof(x264_param_t)); 


  99.         if (!pParameter) { 
  100.             this->closeX264Encoder(); 
  101.             return false; 
  102.         } 
  103.         memset(pParameter, 0, sizeof(x264_param_t)); 
  104.     } 


  107.     int ret = x264_param_default_preset(pParameter, "ultrafast", "zerolatency"); 
  108.     if (ret != 0) { 
  109.         this->closeX264Encoder(); 
  110.         return false; 
  111.     } 


  114.     pParameter->i_level_idc = 30; 


  117.     pParameter->i_width = width;
  118.     pParameter->i_height = height;


  121.     pParameter->b_deterministic = 1; 
  122.     // pParameter->b_sliced_threads = 1; 
  123.     pParameter->i_threads = 1; 


  126.     pParameter->i_csp = X264_CSP_I420;//X264_CSP_NV12;//X264_CSP_I420; 


  129.     pParameter->i_fps_num = i_fps;
  130.     pParameter->i_fps_den = 1;
  131.     pParameter->i_bframe = 0;
  132.     pParameter->i_keyint_max = i_keyint_max;
  133.     
  134.     // pParameter->b_open_gop = 1;
  135.     
  136.     // pParameter->rc.i_bitrate = i_bitrate;
  137.     
  138.     pParameter->rc.i_rc_method = X264_RC_CRF;//X264_RC_CQP;
  139.     
  140.     if (this->bitratelevel == LOW_LEVEL) {
  141.     pParameter->rc.f_rf_constant = 32;
  142.     }else if(this->bitratelevel == MEDIUM_LEVEL){
  143.     pParameter->rc.f_rf_constant = 29;
  144.     }else if (this->bitratelevel == STANDARD_LEVEL) {
  145.     pParameter->rc.f_rf_constant = 26;
  146.     }else if (this->bitratelevel == HIGH_LEVEL) {
  147.     pParameter->rc.f_rf_constant = 24;
  148.     }else {
  149.     pParameter->rc.f_rf_constant = 24;
  150.     }
  151.     
  152.     current_f_rf_constant = pParameter->rc.f_rf_constant;
  153.     userSetting_f_rf_constant = pParameter->rc.f_rf_constant;
  154.     
  155.     // from huxiaopeng
  156.     pParameter->analyse.b_transform_8x8 = 1;
  157.     pParameter->rc.f_aq_strength = 1.5;
  158.     
  159.     pParameter->rc.i_aq_mode = 0;
  160.     pParameter->rc.f_qcompress = 0.0;
  161.     pParameter->rc.f_ip_factor = 0.5;
  162.     pParameter->rc.f_rate_tolerance = 0.1;
  163.     
  164.     pParameter->analyse.i_direct_mv_pred = X264_DIRECT_PRED_AUTO;
  165.     pParameter->analyse.i_me_method = X264_ME_DIA;
  166.     pParameter->analyse.i_me_range = 16;
  167.     pParameter->analyse.i_subpel_refine = 2;
  168.     // pParameter->analyse.i_noise_reduction = 1;
  169.     
  170.     pParameter->i_slice_max_size = 1200;
  171.     
  172.     // pParameter->i_nal_hrd = X264_NAL_HRD_NONE;
  173.     
  174.     pParameter->b_deblocking_filter = 1;
  175.     pParameter->i_deblocking_filter_alphac0 = 4;
  176.     pParameter->i_deblocking_filter_beta = 4;
  177.     
  178.     pParameter->rc.b_mb_tree = 0;
  179.     
  180.     pParameter->i_log_level = X264_LOG_NONE;
  181.     
  182.     if(x264_param_apply_profile(pParameter, "baseline"))
  183.     //if(x264_param_apply_profile(pParameter, "main"))
  184.     {
  185.     this->closeX264Encoder();
  186.     
  187.     return false;
  188.     }
  189.     
  190.     if (!x264EncoderHandle) {
  191.     x264EncoderHandle = x264_encoder_open(pParameter);
  192.     
  193.     if (!x264EncoderHandle) {
  194.     this->closeX264Encoder();
  195.     
  196.     return false;
  197.     }
  198.     }


  201.     if (!pOutput) {
  202.     pOutput = (x264_picture_t *)malloc(sizeof(x264_picture_t));
  203.     
  204.     if (!pOutput) {
  205.     this->closeX264Encoder();
  206.     return false;
  207.     }
  208.     
  209.     memset(pOutput, 0, sizeof(x264_picture_t));
  210.     }
  211.     
  212.     return true;
  213. }


  216. void X264Encoder::forceIDRFrame() 
  217. { 
  218.         isForceIDRFrameEnabled = true; 
  219. } 


  222. void X264Encoder::upgradeBitrateLevel() 
  223. { 
  224.         /* 
  225.            if (this->bitratelevel == HIGH_LEVEL) { 
  226.            return; 
  227.            } 


  230.            this->bitratelevel++; 


  233.            if (this->bitratelevel == LOW_LEVEL) { 
  234.            pParameter->rc.f_rf_constant = 30; 
  235.            }else if(this->bitratelevel == MEDIUM_LEVEL){ 
  236.            pParameter->rc.f_rf_constant = 27; 
  237.            }else if (this->bitratelevel == STANDARD_LEVEL) { 
  238.            pParameter->rc.f_rf_constant = 24; 
  239.            }else if (this->bitratelevel == HIGH_LEVEL) { 
  240.            pParameter->rc.f_rf_constant = 22; 
  241.            }else { 
  242.            pParameter->rc.f_rf_constant = 23; 
  243.            } 
  244.          */ 


  247.         if (userSetting_f_rf_constant >= current_f_rf_constant) { 
  248.                 return; 
  249.         } 


  252.         pParameter->rc.f_rf_constant--; 
  253.         current_f_rf_constant = pParameter->rc.f_rf_constant; 


  256.         x264_encoder_reconfig(x264EncoderHandle, pParameter); 
  257. } 


  260. void X264Encoder::setLeastBitrateLevel() 
  261. { 
  262.         pParameter->rc.f_rf_constant = 32; 
  263.         current_f_rf_constant = pParameter->rc.f_rf_constant; 


  266.         x264_encoder_reconfig(x264EncoderHandle, pParameter); 
  267. } 


  270. void X264Encoder::declineBitrateLevel() 
  271. { 


  274.         if (32 <= current_f_rf_constant) { 
  275.                 return; 
  276.         } 


  279.         pParameter->rc.f_rf_constant++; 
  280.         current_f_rf_constant = pParameter->rc.f_rf_constant; 


  283.         x264_encoder_reconfig(x264EncoderHandle, pParameter); 
  284. } 


  287. long X264Encoder::x264EncoderProcess(x264_picture_t *pPicture, x264_nal_t **nals, int& nalsCount)
  288. { 
  289.     pPicture->i_pts = (int64_t)(frameNo * pParameter->i_fps_den);
  290.     pPicture->i_type = X264_TYPE_AUTO;
  291.     pPicture->i_qpplus1 = 0;//X264_QP_AUTO;
  292.     
  293.     if (isForceIDRFrameEnabled) {
  294.     pPicture->i_type = X264_TYPE_IDR;
  295.     isForceIDRFrameEnabled = false;
  296.     }
  297.     
  298.     int32_t framesize = -1;
  299.     
  300.     
  301.     framesize = x264_encoder_encode(x264EncoderHandle, nals, &nalsCount, pPicture, pOutput);
  302.     
  303.     
  304.     if (framesize>0) {
  305.     frameNo++;
  306.     }
  307.     
  308.     return framesize;
  309. } 


  312.  
  313. bool X264Encoder::closeX264Encoder() 
  314. { 
  315.     if (pOutput) {
  316.     free(pOutput);
  317.     pOutput = NULL;
  318.     }
  319.     /*
  320.     if (pPicture) {
  321.     free(pPicture);
  322.     pPicture = NULL;
  323.     }
  324.     */
  325.     if (pParameter) {
  326.     free(pParameter);
  327.     pParameter = NULL;
  328.     }
  329.     
  330.     if (x264EncoderHandle) {
  331.     x264_encoder_close(x264EncoderHandle);
  332.     x264EncoderHandle = NULL;
  333.     }
  334.     
  335.     return true;
  336. }

/*
 * \File
 *   main.cpp
 * \Author
 *   Hank
 */


  1. #include <string.h>
  2. #include <stdlib.h>
  3. #include <arpa/inet.h>
  4. #include <stdio.h>
  5. #include <wchar.h>
  6. #include <time.h>


  9. #include <jni.h>


  12. /*for android logs*/
  13. #include <android/log.h>


  16. #include "x264.h"
  17. #include "x264_config.h"
  18. #include "x264encoder.h"


  21. #define LOG_TAG "android-ffmpeg-tutorial01"
  22. #define LOGI(...) __android_log_print(4, LOG_TAG, __VA_ARGS__);
  23. #define LOGE(...) __android_log_print(6, LOG_TAG, __VA_ARGS__);






  30. jint naMain(JNIEnv *pEnv, jobject pObj, jobject pMainAct, 
  31.                 jstring pFileName, jint pNumOfFrames,
  32.                 jint picWidth, jint picHeight) {
  33.     /* Preset */
  34.     int numOfFrames = pNumOfFrames;
  35.     int pictureWidth = picWidth;
  36.     int pictureHeight = picHeight;
  37.     int presetBitrate = 512;
  38.     int presetFps = 25;
  39.     int pictureSize = pictureWidth * pictureHeight;
  40.     int encodeTime = 0;
  41.     
  42.     X264Encoder x264Encoder;
  43.     
  44.     x264Encoder.setBitrate(presetBitrate);
  45.     x264Encoder.setResolution(pictureWidth,pictureHeight);
  46.     x264Encoder.setFps(presetFps);
  47.     
  48.     char *yuvFilename = NULL;
  49.     char *avcFilename = NULL;
  50.     char str[80];
  51.     
  52.     FILE *inputFile = NULL;
  53.     FILE *outputFile = NULL;
  54.     
  55.     // Get C string from JNI jstring
  56.     yuvFilename = (char *)pEnv->GetStringUTFChars(pFileName, NULL);
  57.     if((inputFile = fopen(yuvFilename,"rb")) == NULL){
  58.     LOGI("Can not open inputfile %s", yuvFilename);
  59.     return -1;
  60.     }
  61.     
  62.     strcpy(str, yuvFilename);
  63.     strcat(str, ".h264");
  64.     avcFilename = str;
  65.     LOGI("Output file: %s", avcFilename);
  66.     if ((outputFile = fopen(avcFilename,"wb")) == NULL) {
  67.     LOGI("Can not open outputfile %s", avcFilename);
  68.     return -1;
  69.     }
  70.     
  71.     
  72.     x264_picture_t inputPicture;
  73.     x264_picture_alloc(&inputPicture, X264_CSP_I420, pictureWidth, pictureHeight);
  74.     
  75.     x264_nal_t *p_nals = NULL;
  76.     int nalsCount = 0;
  77.     int ret = 0;
  78.     int j = 0;
  79.     
  80.     
  81.     if(x264Encoder.openX264Encoder())
  82.     {
  83.     struct timeval start, end;
  84.     struct timeval sum;
  85.     sum.tv_sec = 0;
  86.     sum.tv_usec = 0;
  87.     
  88.     /* Including the time of read & write file
  89.     gettimeofday(&start, NULL);
  90.     LOGI("Encode start time : %ld.%ld", start.tv_sec, start.tv_usec);
  91.     */
  92.     
  93.     for(j=0; j<numOfFrames; j++)
  94.     {
  95.             ret = fread(inputPicture.img.plane[0],1,pictureSize, inputFile);
  96.             if (ret < pictureSize)
  97.             {
  98.             break;
  99.             }
  100.             fread(inputPicture.img.plane[1],1,pictureSize/4, inputFile);
  101.             fread(inputPicture.img.plane[2],1,pictureSize/4, inputFile);
  102.             
  103.             gettimeofday(&start, NULL);
  104.             
  105.             x264Encoder.x264EncoderProcess(&inputPicture,&p_nals,nalsCount);
  106.             
  107.             gettimeofday(&end, NULL);
  108.             
  109.             if (end.tv_sec > start.tv_sec) {
  110.             sum.tv_sec += (end.tv_sec - (start.tv_sec + 1));
  111.             sum.tv_usec += ((1000000 - start.tv_usec) + end.tv_usec);
  112.             LOGI("A Spend time: %ld.%ld", sum.tv_sec, sum.tv_usec);
  113.             } else {
  114.             sum.tv_sec += (end.tv_sec - start.tv_sec);
  115.             sum.tv_usec += (end.tv_usec-start.tv_usec);
  116.             LOGI("B Spend time: %ld.%ld", sum.tv_sec, sum.tv_usec);
  117.             }
  118.             
  119.             if(p_nals)
  120.             {
  121.             for(int i=0; i<nalsCount; i++)
  122.             {
  123.             ret = fwrite(p_nals[i].p_payload, p_nals[i].i_payload, 1, outputFile);
  124.             LOGI("Write NO %d frame", j);
  125.             LOGI("Should write %d bytes, in fact write %d bytes into %s", p_nals[i].i_payload, ret, avcFilename);
  126.             }
  127.             }
  128.     }
  129.     
  130.     /* Including the time of read & write file
  131.     gettimeofday(&end, NULL);
  132.     LOGI("Encode end time : %ld.%ld", end.tv_sec, end.tv_usec);
  133.     if (end.tv_sec > start.tv_sec){
  134.     encodeTime = (end.tv_sec - (start.tv_sec+1))*1000000 + ((1000000-start.tv_usec) + end.tv_usec);
  135.     LOGI("Spend time: %ld.%ld", (end.tv_sec - (start.tv_sec+1)), ((1000000-start.tv_usec) + end.tv_usec));
  136.     } else {
  137.     encodeTime = (end.tv_sec - start.tv_sec)*1000000+(end.tv_usec-start.tv_usec);
  138.     LOGI("Spend time: %ld.%ld", (end.tv_sec - start.tv_sec), end.tv_usec-start.tv_usec);
  139.     }
  140.     */
  141.     encodeTime = (sum.tv_sec + (sum.tv_usec/1000000))*1000000 + (sum.tv_usec%1000000);
  142.     LOGI("Spend time: %ld.%ld", sum.tv_sec, sum.tv_usec);
  143.     
  144.     }
  145.     
  146.     fclose(inputFile);
  147.     fclose(outputFile);
  148.     
  149.     LOGI("Closed the files!");
  150.     
  151.     x264_picture_clean(&inputPicture);
  152.     
  153.     x264Encoder.closeX264Encoder();
  154.     LOGI("Closed the handler of encoder!");
  155.     
  156.     return encodeTime;
  157.     //return 0;
  158. }




  163. static const JNINativeMethod gMethods[] = { 
  164.     {"naMain",
  165.     "(Lroman10/tutorial/android_ffmpeg_tutorial01/MainActivity;Ljava/lang/String;III)I",
  166.     (void*)naMain
  167.     },
  168. };


  171. jint JNI_OnLoad(JavaVM* vm, void *reserved)
  172. {
  173.     JNIEnv* env = NULL; jint result = -1;
  174.     
  175.     if((vm->GetEnv((void**)&env, JNI_VERSION_1_6)) != JNI_OK) return -1;
  176.     
  177.     jclass clazz; static const char* const
  178.     kClassName="roman10/tutorial/android_ffmpeg_tutorial01/MainActivity";
  179.     
  180.     clazz = env->FindClass(kClassName); if(clazz == NULL) { printf("cannot
  181.     get class:%s\n", kClassName); return -1; }
  182.     
  183.     if(env->RegisterNatives(clazz, gMethods,
  184.     sizeof(gMethods)/sizeof(gMethods[0]))!= JNI_OK) { printf("register
  185.     native method failed!\n"); return -1; }
  186.     
  187.     return JNI_VERSION_1_6;
  188. }

2. 修改相关配置并编译

1). 修改jni/Android.mk成如下：
#
# \File
#   Android.mk
#
LOCAL_PATH := $(call my-dir)


include $(CLEAR_VARS)


LOCAL_MODULE    := tutorial01
#LOCAL_SRC_FILES := tutorial01.c
LOCAL_SRC_FILES := x264encoder.cpp main.cpp
LOCAL_LDLIBS := -llog -ljnigraphics -lz 
#LOCAL_SHARED_LIBRARIES := libavformat libavcodec libswscale libavutil
LOCAL_SHARED_LIBRARIES := libx264


include $(BUILD_SHARED_LIBRARY)
$(call import-module,x264-snapshot-20151015-2245/android/arm)




2). 修改 jni/Application.mk成如下：
#
# \File
#   Android.mk
#
APP_ABI := armeabi
#APP_ABI := armeabi-v7a
APP_PLATFORM := android-10




3). 修改 src/build.gradle成如下
apply plugin: 'com.android.application'


android {
    compileSdkVersion 23
    buildToolsVersion "23.0.1"


    defaultConfig {
        applicationId "roman10.tutorial.android_ffmpeg_tutorial01"
        minSdkVersion 19
        targetSdkVersion 23


        sourceSets.main{
            jni.srcDirs=[]
            jniLibs.srcDir "src/main/libs"
        }
    }


    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
        }
        debug {
            debuggable true
            jniDebuggable true
            renderscriptDebuggable false
        }
    }
}


dependencies {
    compile 'com.android.support:support-v4:18.0.0'
}


4). 编译
在main目录下：
$ cd app/src/main
$ ndk-build
[armeabi] Compile++ thumb: tutorial01 <= x264encoder.cpp
[armeabi] Compile++ thumb: tutorial01 <= main.cpp
[armeabi] Prebuilt       : libx264.so <= <NDK>/sources/x264-snapshot-20151015-2245/android/arm/lib/
[armeabi] SharedLibrary  : libtutorial01.so
[armeabi] Install        : libtutorial01.so => libs/armeabi/libtutorial01.so
[armeabi] Install        : libx264.so => libs/armeabi/libx264.so


表示编码成功；


3. 修改java源文件

修改MainActivity.java，添加调用的接口
public class MainActivity extends Activity {
    
    // 调用参数的预定义
    private static final String FRAME_DUMP_FOLDER_PATH = Environment.getExternalStorageDirectory()
        + File.separator + "android-264-encoder";
    private static final String INPUT_YUV_FILENAME = "test_1920x1080.yuv";
    private static int pWidth = 1920;
    private static int pHeight = 1080;




    @override
    protected Void doInBackground(Void... params){
        // 实际调用
        encodeTime = naMain(mlOuterAct,
            FRAME_DUMP_FOLDER_PATH + File.separator + INPUT_YUV_FILENAME,
            mlNumOfFrames,
            pWidth, pHeight );
    }




    /*
     *  接口声明
     *    pVideoFileName : 表示输入文件名
     *    pNumOfFrame    : 编码帧数
     *    Width          : YUV源文件的图像宽度
     *    Height         : YUV源文件的图像高度
     */
    private static native int naMain(MainActivity pObject,
          String pVideoFileName, int pNumOfFrame,
          int Width, int Height);


    // 库加载
    static {
        System.loadLibrary("x264");
        System.loadLibrary("tutorial01");
    }
}
​
再以android工程方式，编译运行；
1 0
seo软件 seo软件
原创粉丝点击
热门IT博客
机械加工编程软件机械加工编程软件
淘宝模特拍摄动作淘宝模特拍摄动作
淘宝可以参加哪些活动
visio2010软件下载
网络是否应该受管制
杭州创业软件实施
c 多文件编程问题
去痘印面膜 知乎
哪个软件找工作靠谱
wifi限制网速软件
中科院软件所 出国
网络神话逍遥
万方数据库查询
linux tty是什么
thinkphp电影网站源码
营销引流软件
淘宝买的负值轮毂断裂
战地4低配置优化补丁
mac 隐藏文件
网络管制
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 男生暗恋女生的眼神 暗恋歌曲大全 男生暗恋一个人的表现 女生暗恋你的20个动作 女生暗恋一个人的表现 暗恋一个女孩 暗恋一个女孩怎么办 暗恋一个人的表现 送给暗恋男生的礼物 女人暗恋男人的表现 暗恋一个人的句子 送暗恋的女生什么礼物好 怎么向暗恋的人表白 暗恋不敢表白 暗恋表白的句子 男生暗恋女生 暗恋一个人怎么办 暗恋这件小事 代表暗恋的花 女生暗恋男生表白 天秤男暗恋一个人的表现 暗恋的女生过生日送什么 天蝎男暗恋一个人的表现 暗恋是一颗蛀牙 暗恋那件小事 蓝淋 暗恋一个人的感觉 暗恋的男生过生日送什么好 学生暗恋老师的表现 暗恋的歌曲有哪些 好看的暗恋文 暗恋的人过生日送什么 暗恋一个人的诗句 测试男生是否暗恋你 测测在班上有没有人暗恋你 什么花的花语是暗恋 暗战 暗战2 暗战1 民国暗战 名门暗战 暗战行动

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里