android JNI处理图片的例子

最新推荐文章于 2022-03-18 21:01:07 发布
最新推荐文章于 2022-03-18 21:01:07 发布
阅读量1.4w 收藏 16
点赞数
分类专栏： android 文章标签： android jni image processing structure ibm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjwangliang/article/details/7065670
版权 

  
  

   
   



   
   
//下面是主程序代码

   
   



   
   
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;

public class PhotoShop extends Activity {
	private String tag = "IBMPhotoPhun";
	private Bitmap bitmapOrig = null;
	private Bitmap bitmapGray = null;
	private Bitmap bitmapWip = null;
	private ImageView ivDisplay = null;
	// NDK STUFF
	static {
		try{
		System.loadLibrary("haha");}
		catch(Exception e) {
			System.out.println("dd");
		}
	}
	public native void convertToGray(Bitmap bitmapIn, Bitmap bitmapOut);

	public native void changeBrightness(int direction, Bitmap bitmap);

	public native void findEdges(Bitmap bitmapIn, Bitmap bitmapOut);

	// END NDK STUFF
	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		Log.i(tag, "before image stuff");
		ivDisplay = (ImageView) findViewById(R.id.ivDisplay);
		// load bitmap from resources
		BitmapFactory.Options options = new BitmapFactory.Options();
		// Make sure it is 24 bit color as our image processing algorithm
		// expects this format
		options.inPreferredConfig = Config.ARGB_8888;
		bitmapOrig = BitmapFactory.decodeResource(this.getResources(),
				R.drawable.sample, options);
		if (bitmapOrig != null)
			ivDisplay.setImageBitmap(bitmapOrig);
	}

	public void onResetImage(View v) {
		Log.i(tag, "onResetImage");
		ivDisplay.setImageBitmap(bitmapOrig);
	}
	// 边缘化
	public void onFindEdges(View v) {
		Log.i(tag, "onFindEdges");
		// make sure our target bitmaps are happy
		bitmapGray = Bitmap.createBitmap(bitmapOrig.getWidth(),
				bitmapOrig.getHeight(), Config.ALPHA_8);
		bitmapWip = Bitmap.createBitmap(bitmapOrig.getWidth(),
				bitmapOrig.getHeight(), Config.ALPHA_8);
		// before finding edges, we need to convert this image to gray
		convertToGray(bitmapOrig, bitmapGray);
		// find edges in the image
		findEdges(bitmapGray, bitmapWip);
		ivDisplay.setImageBitmap(bitmapWip);
	}

	public void onConvertToGray(View v) {
		Log.i(tag, "onConvertToGray");
		//创建一个和原图宽和高相等的灰色（一个像素是一个字节）图片，内容不确定或者为空（bitmapWip != null）,就是说造好了格子只等填充数据
		bitmapWip = Bitmap.createBitmap(bitmapOrig.getWidth(),
				bitmapOrig.getHeight(), Config.ALPHA_8);
		/**
		 * java中图片的config（相当于格式）
		 *  ALPHA_8     (2),
	        RGB_565     (4),
	        ARGB_4444   (5),
	        ARGB_8888   (6);
	        与android不同：
	        ANDROID_BITMAP_FORMAT_RGBA_8888:1
			ANDROID_BITMAP_FORMAT_A_8:8
		 */
		convertToGray(bitmapOrig, bitmapWip);
		ivDisplay.setImageBitmap(bitmapWip);
	}
	//先要获得bitmapWip才能处理，否则setImageBitmap(byll)虽然不会报错，但是空白的
	public void onDimmer(View v) {
		Log.i(tag, "onDimmer");
		changeBrightness(2, bitmapWip);
		ivDisplay.setImageBitmap(bitmapWip);
	}
	//先要获得bitmapWip才能处理，否则setImageBitmap(byll)虽然不会报错，但是空白的
	public void onBrighter(View v) {
		Log.i(tag, "onBrighter");
		changeBrightness(1, bitmapWip);
		ivDisplay.setImageBitmap(bitmapWip);
	}
}


//下面是JNI层的代码
//====================================================
include <jni.h>
#include <android/log.h>
#include <android/bitmap.h>//【导入】
#define LOG_TAG "libibmphotophun"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
typedef struct//彩色图片数据
{
	uint8_t alpha;
	uint8_t red;
	uint8_t green;
	uint8_t blue;
} argb;
/*
convertToGray
Pixel operation
bitmapcolor：24位（实际是32）彩色图片；格式：ANDROID_BITMAP_FORMAT_RGBA_8888：
bitmapgray灰色图片（8位）；格式：ANDROID_BITMAP_FORMAT_A_8
根据彩色图片填充灰色图片数据
*/
JNIEXPORT void JNICALL Java_com_msi_ibm_ndk_IBMPhotoPhun_convertToGray(JNIEnv
* env, jobject obj, jobject bitmapcolor,jobject bitmapgray)
{
	AndroidBitmapInfo	infocolor;//AndroidBitmapInfo图片信息
	void*				pixelscolor;//图片地址
	AndroidBitmapInfo	infogray;
	void*				pixelsgray;
	int					ret;
	int					y;
	int					x;
	LOGI("convertToGray");
	
	//AndroidBitmap_getInfo(env, bitmapcolor, &infocolor)得到图片信息
	//AndroidBitmap_lockPixels(env, bitmapcolor, &pixelscolor)得到图片地址

	if ((ret = AndroidBitmap_getInfo(env, bitmapcolor, &infocolor)) < 0) {//【AndroidBitmap_getInfo】没有图片信息（宽高等等）
		LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
		return;
	}
	if ((ret = AndroidBitmap_getInfo(env, bitmapgray, &infogray)) < 0) {
		LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
		return;
	}
	LOGI("color image :: width is %d; height is %d; stride is %d; format is %d;flags is%d",
	infocolor.width,infocolor.height,infocolor.stride,infocolor.format,infocolor.flags);//【获得图片的宽和高、格式】

	if (infocolor.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {//不是24位图片
		LOGE("Bitmap format is not RGBA_8888 !");
		return;
	}
	LOGI("gray image :: width is %d; height is %d; stride is %d; format is %d;flags is
	%d",infogray.width,infogray.height,infogray.stride,infogray.format,infogray.flags);

	if (infogray.format != ANDROID_BITMAP_FORMAT_A_8) {//不是8位图片
		LOGE("Bitmap format is not A_8 !");
		return;	
	}
	if ((ret = AndroidBitmap_lockPixels(env, bitmapcolor, &pixelscolor)) < 0) {//【锁定AndroidBitmap_lockPixels】
		//锁定之后，pixelscolor指向图片的首地址　
		LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
	}
	if ((ret = AndroidBitmap_lockPixels(env, bitmapgray, &pixelsgray)) < 0) {
		//锁定之后，pixelscolor指向图片的首地址
		LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
	}
	// modify pixels with image processing algorithm
	for (y=0;y<infocolor.height;y++) {//infocolor.height获得图片的高度
		//这是首次使用argb
		argb * line = (argb *) pixelscolor;//每一行的首地址（刚开始是图片的首地址，即第一行的首地址，下面会换行）

		uint8_t * grayline = (uint8_t *) pixelsgray;//每一行的首地址（数据类型为一个无符号字节）

		for (x=0;x<infocolor.width;x++) {
			grayline[x] = 0.3 * line[x].red + 0.59 * line[x].green + 0.11*line[x].blue;
		}
		pixelscolor = (char *)pixelscolor + infocolor.stride;	//换行：每行的首地址 + 每行的跨度 = 下一行的首地址
		pixelsgray = (char *) pixelsgray + infogray.stride;		//换行：每行的首地址 + 每行的跨度 = 下一行的首地址
	}
	LOGI("unlocking pixels");
	AndroidBitmap_unlockPixels(env, bitmapcolor);
	AndroidBitmap_unlockPixels(env, bitmapgray);
}
/**
The AndroidBitmapInfo structure, defined in bitmap.h, is helpful for
learning about a Bitmap object.

The AndroidBitmap_getInfo function, found in the jnigraphics library,
obtains information about a specific Bitmap object.

a char represents a signed 8-bit value, so a char pointer (char *) allows you to reference an 8-bit
value and perform operations through that pointer. The image data is represented as uint8_t, which 
means an unsigned 8-bit value, where each byte holds a value ranging from 0 to 255. A collection of 
three 8-bit unsigned values represents a pixel of image data for a 24-bit image.
图象数据使用unit8_t(8位无符号，0-255)，24-bit的图象就是3个8比特无符号数。

Working through an image involves working on the individual rows of data and
moving across the columns. The Bitmap structure contains a member known as the
stride. The stride represents the width, in bytes, of a row of image data. For
example, a 24-bit color plus alpha channel image has 32 bits, or 4 bytes, per pixel.
So an image with a width of 320 pixels has a stride of 320*4 or 1,280 bytes. An 8-bit
grayscale image has 8 bits, or 1 byte, per pixel. A grayscale bitmap with a width of
320 pixels has a stride of 320*1 or simply 320 bytes. With this information in mind,
let's look at the image processing algorithm for converting a color image to a
grayscale image:
Bitmap结构有一个属性stride（跨度）：表示一行数据的长度。例如，24比特的图象每个像素有包含32位数据
（红绿蓝三种颜色，再加上alpha属性），所以宽度为320像素的图片的跨度（stride）为320*4字节。而rayscale 
image每个像素只有8比特，就是一个字节，如果320像素，那么stride为320字节。

下面是原作者解释：
1. When the image data is "locked," the base address of the image data is
referenced by a pointer named pixelscolor for the input color image
and pixelsgray for the output grayscale image.

2. Two for-next loops allow you to iterate over the entire image.

	1. First, you iterate over the height of the image, one pass per "row."
	Use the infocolor.height value to get the count of the rows.

	2. On each pass through the rows a pointer is set up to the memory
	location corresponding to the first "column" of image data for the
	row.

	3. As you iterate over the columns for a particular row, you convert
	each pixel of color data to a single value representing the
	grayscale value.

	4. When the complete row is converted you need to advance the
	pointers to the next row. This is done by jumping forward in
	memory by the stride value.

*/
/*
changeBrightness
Pixel Operation
改变亮度：direction=1表示增加亮度，direction=2减少亮度
bitmap只接受一个灰色图片（一个像素一个字节，格式ANDROID_BITMAP_FORMAT_A_8）
将灰色图片的像素值改变
*/
JNIEXPORT void JNICALL Java_com_msi_ibm_ndk_IBMPhotoPhun_changeBrightness(JNIEnv
* env, jobject obj, int direction,jobject bitmap)
{
	AndroidBitmapInfo	infogray;
	void*				pixelsgray;
	int					ret;
	int					y;
	int					x;
	uint8_t			save;//好像没有用到

	//=======================
	if ((ret = AndroidBitmap_getInfo(env, bitmap, &infogray)) < 0) {
		LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
		return;
	}

	LOGI("gray image :: width is %d; height is %d; stride is %d; format is %d;flags is
	%d",infogray.width,infogray.height,infogray.stride,infogray.format,infogray.flags);
	
	if (infogray.format != ANDROID_BITMAP_FORMAT_A_8) {
		LOGE("Bitmap format is not A_8 !");
		return;
	}
	if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixelsgray)) < 0) {
		LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
	}
	// modify pixels with image processing algorithm
	LOGI("time to modify pixels....");

	for (y=0;y<infogray.height;y++) {//每个像素
		uint8_t * grayline = (uint8_t *) pixelsgray;
		int v;
		for (x=0;x<infogray.width;x++) {
			v = (int) grayline[x];
			if (direction == 1)//与上面不同，灰色图片每个像素是一个字节，所以只需要改变一个字节
			    v -=5;
			else
			    v += 5;

			if (v >= 255) {
				grayline[x] = 255;
			} else if (v <= 0) {
				grayline[x] = 0;
			} else {
				grayline[x] = (uint8_t) v;
			}
		}
		pixelsgray = (char *) pixelsgray + infogray.stride;
	}
	AndroidBitmap_unlockPixels(env, bitmap);
}

/*
 

/*
findEdges
Matrix operation
利用bitmapgray填充bitmapedges
*/
JNIEXPORT void JNICALL Java_com_msi_ibm_ndk_IBMPhotoPhun_findEdges(JNIEnv
* env, jobject obj, jobject bitmapgray,jobject bitmapedges)
{
	AndroidBitmapInfo	infogray;
	void*				    pixelsgray;
	AndroidBitmapInfo	infoedges;
	void*				    pixelsedge;
	int					ret;
	int					y;
	int					x;
	int					sumX,sumY,sum;
	int					i,j;
	int					Gx[3][3];
	int					Gy[3][3];
	uint8_t *graydata;
	uint8_t *edgedata;


	LOGI("findEdges running");

	/**
		[  -1    0    1  ]
	Gx:	[  -2	 0    2   ]
		[  -1    0    1  ]
	
		[   1    2    1  ]
	Gy:	[   0	 0    0   ]
		[  -1   -2   -1  ]
	*/
	Gx[0][0] = -1;Gx[0][1] = 0;Gx[0][2] = 1;
	Gx[1][0] = -2;Gx[1][1] = 0;Gx[1][2] = 2;
	Gx[2][0] = -1;Gx[2][1] = 0;Gx[2][2] = 1;
	Gy[0][0] = 1;Gy[0][1] = 2;Gy[0][2] = 1;
	Gy[1][0] = 0;Gy[1][1] = 0;Gy[1][2] = 0;
	Gy[2][0] = -1;Gy[2][1] = -2;Gy[2][2] = -1;
	
	
	if ((ret = AndroidBitmap_getInfo(env, bitmapgray, &infogray)) < 0) {
		LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
		return;
	}
	if ((ret = AndroidBitmap_getInfo(env, bitmapedges, &infoedges)) < 0) {
		LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
		return;
	}
	LOGI("gray image :: width is %d; height is %d; stride is %d; format is %d;flags is
	%d",infogray.width,infogray.height,infogray.stride,infogray.format,infogray.flags);
	if (infogray.format != ANDROID_BITMAP_FORMAT_A_8) {
		LOGE("Bitmap format is not A_8 !");
		return;
	}
	LOGI("color image :: width is %d; height is %d; stride is %d; format is %d;flags is
	%d",infoedges.width,infoedges.height,infoedges.stride,infoedges.format,infoedges.flags);
	if (infoedges.format != ANDROID_BITMAP_FORMAT_A_8) {
		LOGE("Bitmap format is not A_8 !");
		return;
	}
	if ((ret = AndroidBitmap_lockPixels(env, bitmapgray, &pixelsgray)) < 0) {
		LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
	}
	if ((ret = AndroidBitmap_lockPixels(env, bitmapedges, &pixelsedge)) < 0) {
		LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
	}
	// modify pixels with image processing algorithm
	LOGI("time to modify pixels....");
	
	graydata = (uint8_t *) pixelsgray;
	edgedata = (uint8_t *) pixelsedge;

	for (y=0;y<=infogray.height - 1;y++) {
		for (x=0;x<infogray.width -1;x++) {
		sumX = 0;
		sumY = 0;
		// check boundaries
		if (y==0 || y == infogray.height-1) {
			sum = 0;
		} else if (x == 0 || x == infogray.width -1) {
			sum = 0;
		} else {
		// calc X gradient
			for (i=-1;i<=1;i++) {
				for (j=-1;j<=1;j++) {
					sumX += (int) ( (*(graydata + x + i + (y + j)* infogray.stride)) * Gx[i+1][j+1]);
				}
			}
			// calc Y gradient
			for (i=-1;i<=1;i++) {
				for (j=-1;j<=1;j++) {
					sumY += (int) ( (*(graydata + x + i + (y + j)* infogray.stride)) * Gy[i+1][j+1]);
				}
			}
			sum = abs(sumX) + abs(sumY);
		}
		if (sum>255) sum = 255;
		if (sum<0) sum = 0;
		*(edgedata + x + y*infogray.width) = 255 - (uint8_t) sum;//给边界图片bitmapedges填充数据
		}
	}
	AndroidBitmap_unlockPixels(env, bitmapgray);
	AndroidBitmap_unlockPixels(env, bitmapedges);

}//结束



  
  
 

 

 

 

 

 

 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  我是北上君
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Android底层jni中保存RGB565图片

				
			

			

				

					qingxing123的专栏
				

				

					06-24
					
					3270
					
				

			

		

		

			
				
Android上层保存图片需要大量的内存空间，所以在此用C++底层

			
		

	



                

              
                



	

		

			

				
					
Android C++系列：JNI操作Bitmap

					
最新发布

				
			

			

				

					轻口味的专栏
				

				

					07-01
					
					1514
					
				

			

		

		

			
				
本文介绍了Android Bitmap相关知识，以及在JNI层操纵Bitmap：检索Bitmap对象信息、访问原生像素缓存等，并介绍了JNI层旋转、镜像Bitmap的操作实战。

			
		

	



                


  
              

                


	

		

			

				
					
通过jni实现图像处理的demo

				
			

			

				

					07-02
				

			

		

		

			
				
通过jni实现图像处理的demo：调用jni接口实现了图像的灰度化。
例程中也包含了支持多目录的Android.mk，支持汉字的传递，类的传递。更详细介绍，参见相关博客。

			
		

	





	

		

			

				
					
Android JNI 图片处理（水印）

				
			

			

				

					三须鳗鱼
				

				

					08-12
					
					619
					
				

			

		

		

			
				
Android 使用jni处理图片：图片拼接和添加水印

			
		

	



		

			
		



	

		

			

				
					
Android平台上的JNI技术介绍

				
			

			

				

					weixin_34403693的博客
				

				

					10-01
					
					159
					
				

			

		

		

			
				
2019独角兽企业重金招聘Python工程师标准>>>   
                                        
         ...

			
		

	





	

		

			

				
					
Android JNI图像处理经典例子

				
			

			

				

					03-10
				

			

		

		

			
				
通过JNI试用C语言对图像进行处理，灰度化，二值化，求边缘等。对Android开发人员很有帮助，值得参考。

			
		

	





	

		

			

				
					
Android JNI处理图片实现黑白滤镜的方法

				
			

			

				

					01-20
				

			

		

		

			
				
前言
在Android的开发中，我们有时会遇到对性能要求比较高的模块。所幸Android通过NDK为我们提供了c++开发的方式。我们可以通过c++完成核心的耗时的计算，然后通过JNI的方式将处理完成的数据传给Java层。
今天，我们就从一个很小的角度（Bitmap）的处理，来实践NDK开发的方式。开发一个小小的图片滤镜。
准备
新版本的Android Studio在新建工程时，就可以选择Include C++ support

当我们勾上这个选择后，Android Studio就会帮我们自动完成，c++开发目录的创建。

我们先看一下CMakeLists.txt：

# For more in

			
		

	





	

		

			

				
					
Android JNI串口通讯【实战例子】

				
			

			

				

					07-02
				

			

		

		

			
				
Android JNI串口通讯【实战例子】 学习NDK开发很好的例子，也可以直接用在项目中

			
		

	





	

		

			

				
					
android JNI简单例子

				
			

			

				

					02-02
				

			

		

		

			
				
这个"android JNI简单例子"就是一个很好的学习平台，通过它，开发者可以了解并实践上述所有步骤，从而掌握在Android应用中使用JNI的基本流程。对于初学者来说，这将有助于理解Java和C/C++代码如何协同工作，提升应用...

			
		

	





	

		

			

				
					
AndroidJNI.rar_Android jni_android

				
			

			

				

					09-23
				

			

		

		

			
				
本资料"AndroidJNI.rar_Android jni_android"可能包含一个简单的示例项目——HelloWorld，用于教学如何在Android应用中使用JNI。  首先，我们来理解JNI的基本概念。JNI是一套接口，使得Java虚拟机（JVM）能够调用...

			
		

	





	

		

			

				
					
Callback_Androidjni_AndoidJNI层到Java层的调用_android_android回调_

				
			

			

				

					10-01
				

			

		

		

			
				
在AndroidJNI层到Java层的回调中，我们需要做以下几步：  1. **定义本地方法签名**：在Java类中声明 native 方法，但不提供实现。例如：  ```java  public class MyJavaClass {  static {  System.loadLibrary(...

			
		

	





	

		

			

				
					
jnigraphics

				
			

			

				

					weixin_30898109的博客
				

				

					12-10
					
					497
					
				

			

		

		

			
				
一、'jnigraphics'库： 　
这是一个很小的库，展示一个稳定的，基于C语言的，接口，使本机代码安全地访问Java对象的像素缓冲区的位图. 　　
使用它，在你的源代码中包含<android/bitmap.h>，并链接库jnigraphics：LOCAL_LDLIBS + = -ljnigraphics 　　
详细信息，请阅读bitmap.h：build/platforms...

			
		

	





	

		

			

				
					
Android studio用C++，jni接口，opencv实现图像处理

				
			

			

				

					Lumos_somuL的博客
				

				

					03-18
					
					6339
					
				

			

		

		

			
				
一，jni的配置以及初步实现在此篇（https://blog.csdn.net/Lumos_somuL/article/details/123486353?spm=1001.2014.3001.5501）内容中，本文接上篇（https://blog.csdn.net/Lumos_somuL/article/details/123486353?spm=1001.2014.3001.5501）内容
一、

...

			
		

	





	

		

			

				
					
Android NDK方向,android  – 使用JNI和NDK旋转位图

				
			

			

				

					weixin_42306812的博客
				

				

					05-25
					
					174
					
				

			

		

		

			
				
背景：我已经决定,由于位图会占用大量内存,而这些内存很容易导致内存不足错误,因此我会对C/C++代码进行大量内存消耗.我用来旋转位图的步骤是：>读取位图信息(宽度,高度)>将位图像素存储到数组中.>回收位图.>创建一个相反大小的新位图.>将像素放入新位图.>释放像素并返回位图.问题：即使一切似乎都没有任何错误,输出图像也不是原始的旋转.事实上,它完全毁了它.旋转...

			
		

	





	

		

			

				
					
Android 保存 JNI 层 opencv cvMat 图片

				
			

			

				

					描绘自己的王国……
				

				

					07-12
					
					2019
					
				

			

		

		

			
				
Android 保存 JNI 层 opencv cvMat 图片

必须在 APP 层申请读写权限。
然后引入如下代码即可保存 cv::Mat 图片。

cv::imwrite 会分析图片格式
            {
                // write to SD
                char p_str[128] = "/storage/emulated/0/DCI...

			
		

	





	

		

			

				
					
Android 加载图片 JNI 读取使用图片

				
			

			

				

					psklf的博客
				

				

					07-05
					
					6078
					
				

			

		

		

			
				
最近在学习ndk加载纹理的例子时，有些收获，写出来与大家共同探讨！ 
在用ndk开发游戏时，最常见的就是显示图片，在c语言下用opengl贴图，经过实践，已知有4种方法可行！ 
备注：以下部分内容参考网上代码，具体是哪，忘记了。如有冒犯，敬请谅解！1. java层生成好纹理，通过jni传递给c层private Bitmap getBitmap(Context context, int resId)

			
		

	





	

		

			

				
					
android jni示例_单击照片或从图库中选择图像的Android示例

				
			

			

				

					
				

				

					07-01
					
					195
					
				

			

		

		

			
				
android jni示例 用于从图库中选择照片 (For selecting photo from gallery)
1) XML code
 1)XML代码 
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://sc...

			
		

	





	

		

			

				
					
手机游戏截图并通过JNI保存到手机内存特定文件夹下。

				
			

			

				

					流离年少，林夕十里
				

				

					02-19
					
					1627
					
				

			

		

		

			
				
在做游戏界面截图经常使用，截图也是。
代码
	CCSize size = CCDirector::sharedDirector()->getWinSize();    
  
	CCRenderTexture* pScreen = CCRenderTexture::create(size.width,size.height, kCCTexture2DPixelFormat_RGBA8888);

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 4

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值