Chinaunix首页 | 论坛 | 博客

北雨南萍hkyan.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

andersonyan

  • 博客访问： 7918817
  • 博文数量： 701
  • 博客积分： 2150
  • 博客等级： 上尉
  • 技术积分： 13233
  • 用 户 组： 普通用户
  • 注册时间： 2011-06-29 16:28
个人简介

天行健，君子以自强不息！

文章分类

全部博文（701）

文章存档

2019年（2）

2018年（12）

2017年（76）

2016年（120）

2015年（178）

2014年（129）

2013年（123）

2012年（61）

我的朋友
最近访客
推荐博文
相关博文
Ubuntu下为AndroidStudio编译并使用x264(二)AndroidStudio部分

分类： Android平台

2015-12-25 16:51:33

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 <= /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工程方式，编译运行；

阅读(3499) | 评论(0) | 转发(0) |
0

上一篇：Ubuntu下为AndroidStudio编译并使用x264(一)ndk部分

下一篇：glib g_main_loop理解

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6