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
   
9. 
   
10. 
    
11. extern"C"
    
12. {
    
13. #include"stdint.h"
    
14. #include"x264.h"
    
15. 
    
16. 
    
17. enum bitrate_level
    
18. {
    
19. HIGH_LEVEL=0,
    
20. STANDARD_LEVEL=1,
    
21. MEDIUM_LEVEL=2,
    
22. LOW_LEVEL=3,
    
23. };
    
24. 
    
25. 
    
26. classX264Encoder
    
27. {
    
28. public:
    
29. X264Encoder();
    
30. ~X264Encoder();
    
31. 
    
32. 
    
33. bool openX264Encoder();
    
34. //long x264EncoderProcess(uint8_t*pSrcData,intsrcDataSize,x264_nal_t**nals,int&nalsCount);
    
35. 
    
36. 
    
37. long x264EncoderProcess(x264_picture_t*pPicture,x264_nal_t**nals,int&nalsCount);
    
38. 
    
39. 
    
40. bool closeX264Encoder();
    
41. 
    
42. 
    
43. void setSourceFormat(unsignedintsourcformat);
    
44. void setResolution(unsignedintw,unsignedinth);
    
45. void setBitrate(unsignedinti_bitrate);
    
46. void setFps(unsignedintfps);
    
47. void setI_KeyInt_Max(unsignedinti_frame_max);
    
48. void setQp_Max(unsignedintqp_max);
    
49. void setQp_Min(unsignedintqp_min);
    
50. 
    
51. 
    
52. void forceIDRFrame();
    
53. 
    
54. 
    
55. void upgradeBitrateLevel();
    
56. void declineBitrateLevel();
    
57. void setLeastBitrateLevel();
    
58. 
    
59. 
    
60. 
    
61. 
    
62. private:
    
63. x264_param_t*pParameter;
    
64. x264_t*x264EncoderHandle;
    
65. //x264_picture_t*pPicture;
    
66. x264_picture_t*pOutput;
    
67. 
    
68. 
    
69. unsignedintsourceFormat;
    
70. //unsignedinti_bitrate;
    
71. unsignedintbitratelevel;
    
72. unsignedinti_fps;
    
73. unsignedinti_keyint_max;
    
74. unsignedintwidth;
    
75. unsignedintheight;
    
76. unsignedintqp_max;
    
77. unsignedintqp_min;
    
78. 
    
79. 
    
80. unsignedintcurrent_f_rf_constant;
    
81. unsignedintuserSetting_f_rf_constant;
    
82. 
    
83. 
    
84. int64_t frameNo;
    
85. 
    
86. 
    
87. bool isForceIDRFrameEnabled;
    
88. };
    
89. }
    
90. #endif

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

1. #include<stdlib.h>
   
2. #include<string.h>
   
3. #include"x264encoder.h"
   
4. 
   
5. 
   
6. //new versionforx264 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;
    
16. 
    
17. 
    
18. frameNo=0;
    
19. isForceIDRFrameEnabled=false;
    
20. 
    
21. 
    
22. pParameter=NULL;
    
23. x264EncoderHandle=NULL;
    
24. //pPicture=NULL;
    
25. pOutput=NULL;
    
26. }
    
27. 
    
28. 
    
29. X264Encoder::~X264Encoder()
    
30. {
    
31. this->closeX264Encoder();
    
32. }
    
33. 
    
34. 
    
35. void X264Encoder::setSourceFormat(unsignedintsourcformat)
    
36. {
    
37. this->sourceFormat=sourcformat;
    
38. }
    
39. 
    
40. 
    
41. void X264Encoder::setResolution(unsignedintw,unsignedinth)
    
42. {
    
43. width=w;
    
44. height=h;
    
45. }
    
46. 
    
47. 
    
48. void X264Encoder::setBitrate(unsignedinti_bitrate)
    
49. {
    
50. if(i_bitrate>0&&i_bitrate<=64){
    
51. this->bitratelevel=LOW_LEVEL;
    
52. }elseif(i_bitrate>64&&i_bitrate<=128){
    
53. this->bitratelevel=MEDIUM_LEVEL;
    
54. }elseif(i_bitrate>128&&i_bitrate<=256){
    
55. this->bitratelevel=STANDARD_LEVEL;
    
56. }elseif(i_bitrate>256&&i_bitrate<=384){
    
57. this->bitratelevel=HIGH_LEVEL;
    
58. }elseif(i_bitrate>384&&i_bitrate<=512){
    
59. this->bitratelevel=HIGH_LEVEL;
    
60. }else{
    
61. this->bitratelevel=STANDARD_LEVEL;
    
62. }
    
63. }
    
64. 
    
65. 
    
66. void X264Encoder::setFps(unsignedintfps)
    
67. {
    
68. i_fps=fps;
    
69. }
    
70. 
    
71. 
    
72. void X264Encoder::setI_KeyInt_Max(unsignedinti_frame_max)
    
73. {
    
74. i_keyint_max=i_frame_max;
    
75. }
    
76. 
    
77. 
    
78. void X264Encoder::setQp_Max(unsignedintqp_max)
    
79. {
    
80. this->qp_max=qp_max;
    
81. }
    
82. 
    
83. 
    
84. void X264Encoder::setQp_Min(unsignedintqp_min)
    
85. {
    
86. this->qp_min=qp_min;
    
87. }
    
88. 
    
89. 
    
90. bool X264Encoder::openX264Encoder(){
    
91. this->closeX264Encoder();
    
92. 
    
93. 
    
94. if(!pParameter)
    
95. {
    
96. pParameter=(x264_param_t*)malloc(sizeof(x264_param_t));
    
97. 
    
98. 
    
99. if(!pParameter){
    
100. this->closeX264Encoder();
     
101. returnfalse;
     
102. }
     
103. memset(pParameter,0,sizeof(x264_param_t));
     
104. }
     
105. 
     
106. 
     
107. intret=x264_param_default_preset(pParameter,"ultrafast","zerolatency");
     
108. if(ret!=0){
     
109. this->closeX264Encoder();
     
110. returnfalse;
     
111. }
     
112. 
     
113. 
     
114. pParameter->i_level_idc=30;
     
115. 
     
116. 
     
117. pParameter->i_width=width;
     
118. pParameter->i_height=height;
     
119. 
     
120. 
     
121. pParameter->b_deterministic=1;
     
122. //pParameter->b_sliced_threads=1;
     
123. pParameter->i_threads=1;
     
124. 
     
125. 
     
126. pParameter->i_csp=X264_CSP_I420;//X264_CSP_NV12;//X264_CSP_I420;
     
127. 
     
128. 
     
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. }elseif(this->bitratelevel==MEDIUM_LEVEL){
     
143. pParameter->rc.f_rf_constant=29;
     
144. }elseif(this->bitratelevel==STANDARD_LEVEL){
     
145. pParameter->rc.f_rf_constant=26;
     
146. }elseif(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. returnfalse;
     
188. }
     
189. 
     
190. if(!x264EncoderHandle){
     
191. x264EncoderHandle=x264_encoder_open(pParameter);
     
192. 
     
193. if(!x264EncoderHandle){
     
194. this->closeX264Encoder();
     
195. 
     
196. returnfalse;
     
197. }
     
198. }
     
199. 
     
200. 
     
201. if(!pOutput){
     
202. pOutput=(x264_picture_t*)malloc(sizeof(x264_picture_t));
     
203. 
     
204. if(!pOutput){
     
205. this->closeX264Encoder();
     
206. returnfalse;
     
207. }
     
208. 
     
209. memset(pOutput,0,sizeof(x264_picture_t));
     
210. }
     
211. 
     
212. returntrue;
     
213. }
     
214. 
     
215. 
     
216. void X264Encoder::forceIDRFrame()
     
217. {
     
218. isForceIDRFrameEnabled=true;
     
219. }
     
220. 
     
221. 
     
222. void X264Encoder::upgradeBitrateLevel()
     
223. {
     
224. /*
     
225. if(this->bitratelevel==HIGH_LEVEL){
     
226. return;
     
227. }
     
228. 
     
229. 
     
230. this->bitratelevel++;
     
231. 
     
232. 
     
233. if(this->bitratelevel==LOW_LEVEL){
     
234. pParameter->rc.f_rf_constant=30;
     
235. }elseif(this->bitratelevel==MEDIUM_LEVEL){
     
236. pParameter->rc.f_rf_constant=27;
     
237. }elseif(this->bitratelevel==STANDARD_LEVEL){
     
238. pParameter->rc.f_rf_constant=24;
     
239. }elseif(this->bitratelevel==HIGH_LEVEL){
     
240. pParameter->rc.f_rf_constant=22;
     
241. }else{
     
242. pParameter->rc.f_rf_constant=23;
     
243. }
     
244. */
     
245. 
     
246. 
     
247. if(userSetting_f_rf_constant>=current_f_rf_constant){
     
248. return;
     
249. }
     
250. 
     
251. 
     
252. pParameter->rc.f_rf_constant--;
     
253. current_f_rf_constant=pParameter->rc.f_rf_constant;
     
254. 
     
255. 
     
256. x264_encoder_reconfig(x264EncoderHandle,pParameter);
     
257. }
     
258. 
     
259. 
     
260. void X264Encoder::setLeastBitrateLevel()
     
261. {
     
262. pParameter->rc.f_rf_constant=32;
     
263. current_f_rf_constant=pParameter->rc.f_rf_constant;
     
264. 
     
265. 
     
266. x264_encoder_reconfig(x264EncoderHandle,pParameter);
     
267. }
     
268. 
     
269. 
     
270. void X264Encoder::declineBitrateLevel()
     
271. {
     
272. 
     
273. 
     
274. if(32<=current_f_rf_constant){
     
275. return;
     
276. }
     
277. 
     
278. 
     
279. pParameter->rc.f_rf_constant++;
     
280. current_f_rf_constant=pParameter->rc.f_rf_constant;
     
281. 
     
282. 
     
283. x264_encoder_reconfig(x264EncoderHandle,pParameter);
     
284. }
     
285. 
     
286. 
     
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. }
     
310. 
     
311. 
     
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. returntrue;
     
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>
   
7. 
   
8. 
   
9. #include<jni.h>
   
10. 
    
11. 
    
12. /*forandroid logs*/
    
13. #include<android/log.h>
    
14. 
    
15. 
    
16. #include"x264.h"
    
17. #include"x264_config.h"
    
18. #include"x264encoder.h"
    
19. 
    
20. 
    
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__);
    
24. 
    
25. 
    
26. 
    
27. 
    
28. 
    
29. 
    
30. jint naMain(JNIEnv*pEnv,jobject pObj,jobject pMainAct,
    
31. jstring pFileName,jint pNumOfFrames,
    
32. jint picWidth,jint picHeight){
    
33. /*Preset*/
    
34. intnumOfFrames=pNumOfFrames;
    
35. intpictureWidth=picWidth;
    
36. intpictureHeight=picHeight;
    
37. intpresetBitrate=512;
    
38. intpresetFps=25;
    
39. intpictureSize=pictureWidth*pictureHeight;
    
40. intencodeTime=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. //GetCstringfrom 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. intnalsCount=0;
    
77. intret=0;
    
78. intj=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 thetimeof 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(inti=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 thetimeof 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. }
     
159. 
     
160. 
     
161. 
     
162. 
     
163. staticconstJNINativeMethod gMethods[]={
     
164. {"naMain",
     
165. "(Lroman10/tutorial/android_ffmpeg_tutorial01/MainActivity;Ljava/lang/String;III)I",
     
166. (void*)naMain
     
167. },
     
168. };
     
169. 
     
170. 
     
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;staticconstchar*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. c/c++ android 平台交叉编译 {ERROR: Failed to create toolchai
2. ubutun下NDK编译环境配置
3. Android(安卓)编译错误总结及收集
4. Android(安卓)Studio的各种冷知识，黑科技
5. Android(安卓)Studio修改项目编译版本
6. android ffmpeg4.0.2编译过程记录
7. Android(安卓)2.3 CTS测试修改测试结果和调试方法
8. Android(安卓)CPU, Compilers, D8 & R8
9. Android多窗口的实现 - 开源

随机推荐

1. android技术要点梳理
2. Android启动脚本init.rc
3. andorid padding margin
4. Android性能调优工具TraceView介绍
5. android中Layoutopt的使用
6. Android之Wifi学习(1)
7. 使用User Agent分辨出Android设备类型的
8. 在 Android(安卓)模拟器中启用摄像头支持
9. Android之UI学习篇二：TextVeiw显示表情和
10. Android(安卓)基础总结：（十）ContentResolver