Remove extra float<>int conversions in ImageProcessing. (43c31421) · Commits · e / os / android_frameworks_base

libs/rs/java/Fountain/res/drawable/gadgets_clock_mp3.png

deleted100755 → 0

−102 KiB

Loading image diff...

libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java

+23 −19

Original line number	Diff line number	Diff line
		@@ -44,7 +44,6 @@ public class ImageProcessingActivity extends Activity
		private ScriptC_Threshold mScript;
		private ScriptC_Vertical_blur mScriptVBlur;
		private ScriptC_Horizontal_blur mScriptHBlur;
		private ScriptC_Levels mScriptLevels;
		private int mRadius = 0;
		private SeekBar mRadiusSeekBar;

		@@ -73,7 +72,8 @@ public class ImageProcessingActivity extends Activity
		@SuppressWarnings({"FieldCanBeLocal"})
		private Allocation mOutPixelsAllocation;
		@SuppressWarnings({"FieldCanBeLocal"})
		private Allocation mScratchPixelsAllocation;
		private Allocation mScratchPixelsAllocation1;
		private Allocation mScratchPixelsAllocation2;

		private SurfaceView mSurfaceView;
		private ImageView mDisplayView;
		@@ -261,29 +261,29 @@ public class ImageProcessingActivity extends Activity
		}
		else if(seekBar == mInBlackSeekBar) {
		mInBlack = (float)progress;
		mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		}
		else if(seekBar == mOutBlackSeekBar) {
		mOutBlack = (float)progress;
		mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		}
		else if(seekBar == mInWhiteSeekBar) {
		mInWhite = (float)progress + 127.0f;
		mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		}
		else if(seekBar == mOutWhiteSeekBar) {
		mOutWhite = (float)progress + 127.0f;
		mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		}
		else if(seekBar == mGammaSeekBar) {
		mGamma = (float)progress/100.0f;
		mGamma = Math.max(mGamma, 0.1f);
		mGamma = 1.0f / mGamma;
		mScriptLevels.invoke_setGamma(mGamma);
		mScriptVBlur.invoke_setGamma(mGamma);
		}
		else if(seekBar == mSaturationSeekBar) {
		mSaturation = (float)progress / 50.0f;
		mScriptLevels.invoke_setSaturation(mSaturation);
		mScriptVBlur.invoke_setSaturation(mSaturation);
		}

		long t = java.lang.System.currentTimeMillis();
		@@ -373,28 +373,32 @@ public class ImageProcessingActivity extends Activity

		mInPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapIn);
		mOutPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapOut);
		mScratchPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapScratch);

		Type.Builder tb = new Type.Builder(mRS, Element.F32_4(mRS));
		tb.add(android.renderscript.Dimension.X, mBitmapIn.getWidth());
		tb.add(android.renderscript.Dimension.Y, mBitmapIn.getHeight());
		mScratchPixelsAllocation1 = Allocation.createTyped(mRS, tb.create());
		mScratchPixelsAllocation2 = Allocation.createTyped(mRS, tb.create());

		mScriptVBlur = new ScriptC_Vertical_blur(mRS, getResources(), R.raw.vertical_blur, false);
		mScriptHBlur = new ScriptC_Horizontal_blur(mRS, getResources(), R.raw.horizontal_blur, false);
		mScriptLevels = new ScriptC_Levels(mRS, getResources(), R.raw.levels, false);

		mScript = new ScriptC_Threshold(mRS, getResources(), R.raw.threshold, false);
		mScript.set_width(mBitmapIn.getWidth());
		mScript.set_height(mBitmapIn.getHeight());
		mScript.set_radius(mRadius);

		mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		mScriptLevels.invoke_setGamma(mGamma);
		mScriptLevels.invoke_setSaturation(mSaturation);
		mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
		mScriptVBlur.invoke_setGamma(mGamma);
		mScriptVBlur.invoke_setSaturation(mSaturation);

		mScript.bind_InPixel(mInPixelsAllocation);
		mScript.bind_OutPixel(mOutPixelsAllocation);
		mScript.bind_ScratchPixel(mScratchPixelsAllocation);
		mScript.bind_ScratchPixel1(mScratchPixelsAllocation1);
		mScript.bind_ScratchPixel2(mScratchPixelsAllocation2);

		mScript.set_vBlurScript(mScriptVBlur);
		mScript.set_hBlurScript(mScriptHBlur);
		mScript.set_levelsScript(mScriptLevels);
		}

		private Bitmap loadBitmap(int resource) {
		@@ -420,15 +424,15 @@ public class ImageProcessingActivity extends Activity

		long t = java.lang.System.currentTimeMillis();

		mScript.invoke_filterBenchmark();
		mScript.invoke_filter();
		mRS.finish();

		t = java.lang.System.currentTimeMillis() - t;
		android.util.Log.v("Img", "Renderscript frame time core ms " + t);

		long javaTime = javaFilter();
		mBenchmarkResult.setText("RS: " + t + " ms Java: " + javaTime + " ms");
		//mBenchmarkResult.setText("RS: " + t + " ms");
		//long javaTime = javaFilter();
		//mBenchmarkResult.setText("RS: " + t + " ms Java: " + javaTime + " ms");
		mBenchmarkResult.setText("RS: " + t + " ms");

		mRadius = oldRadius;
		mScript.set_radius(mRadius);

libs/rs/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs

+6 −6

Original line number	Diff line number	Diff line
		@@ -3,16 +3,16 @@
		#include "ip.rsh"

		void root(const void v_in, void v_out, const void *usrData, uint32_t x, uint32_t y) {
		uchar4 output = (uchar4 )v_out;
		float4 output = (float4 )v_out;
		const FilterStruct fs = (const FilterStruct )usrData;
		const uchar4 input = (const uchar4 )rsGetElementAt(fs->ain, 0, y);
		const float4 input = (const float4 )rsGetElementAt(fs->ain, 0, y);

		float3 blurredPixel = 0;
		const float *gPtr = fs->gaussian;
		if ((x > fs->radius) && (x < (fs->width - fs->radius))) {
		const uchar4 *i = input + (x - fs->radius);
		const float4 *i = input + (x - fs->radius);
		for(int r = -fs->radius; r <= fs->radius; r ++) {
		blurredPixel += convert_float3(i->xyz) * gPtr[0];
		blurredPixel += i->xyz * gPtr[0];
		gPtr++;
		i++;
		}
		@@ -20,11 +20,11 @@ void root(const void v_in, void v_out, const void *usrData, uint32_t x, uint32
		for(int r = -fs->radius; r <= fs->radius; r ++) {
		// Stepping left and right away from the pixel
		int validW = rsClamp(x + r, (uint)0, (uint)(fs->width - 1));
		blurredPixel += convert_float3(input[validW].xyz) * gPtr[0];
		blurredPixel += input[validW].xyz * gPtr[0];
		gPtr++;
		}
		}

		output->xyz = convert_uchar3(blurredPixel);
		output->xyz = blurredPixel;
		}

libs/rs/java/ImageProcessing/src/com/android/rs/image/levels.rs

deleted100644 → 0

+0 −86

Original line number	Diff line number	Diff line
		#pragma version(1)

		#include "ip.rsh"


		static float inBlack;
		static float outBlack;
		static float inWhite;
		static float outWhite;
		static float3 gamma;
		static float saturation;

		static float inWMinInB;
		static float outWMinOutB;
		static float overInWMinInB;
		static rs_matrix3x3 colorMat;

		//#pragma rs export_var(height, width, radius, InPixel, OutPixel, ScratchPixel, inBlack, outBlack, inWhite, outWhite, gamma, saturation, InPixel, OutPixel, ScratchPixel, vBlurScript, hBlurScript)
		#pragma rs export_func(setLevels, setSaturation, setGamma);

		void setLevels(float iBlk, float oBlk, float iWht, float oWht) {
		inBlack = iBlk;
		outBlack = oBlk;
		inWhite = iWht;
		outWhite = oWht;

		inWMinInB = inWhite - inBlack;
		outWMinOutB = outWhite - outBlack;
		overInWMinInB = 1.f / inWMinInB;
		}

		void setSaturation(float sat) {
		saturation = sat;

		// Saturation
		// Linear weights
		//float rWeight = 0.3086f;
		//float gWeight = 0.6094f;
		//float bWeight = 0.0820f;

		// Gamma 2.2 weights (we haven't converted our image to linear space yet for perf reasons)
		float rWeight = 0.299f;
		float gWeight = 0.587f;
		float bWeight = 0.114f;

		float oneMinusS = 1.0f - saturation;
		rsMatrixSet(&colorMat, 0, 0, oneMinusS * rWeight + saturation);
		rsMatrixSet(&colorMat, 0, 1, oneMinusS * rWeight);
		rsMatrixSet(&colorMat, 0, 2, oneMinusS * rWeight);
		rsMatrixSet(&colorMat, 1, 0, oneMinusS * gWeight);
		rsMatrixSet(&colorMat, 1, 1, oneMinusS * gWeight + saturation);
		rsMatrixSet(&colorMat, 1, 2, oneMinusS * gWeight);
		rsMatrixSet(&colorMat, 2, 0, oneMinusS * bWeight);
		rsMatrixSet(&colorMat, 2, 1, oneMinusS * bWeight);
		rsMatrixSet(&colorMat, 2, 2, oneMinusS * bWeight + saturation);
		}

		void setGamma(float g) {
		gamma = (float3)g;
		}


		void root(const void v_in, void v_out, const void *usrData, uint32_t x, uint32_t y) {
		const uchar4 *input = v_in;
		uchar4 *output = v_out;

		float3 currentPixel = 0;

		//currentPixel.xyz = convert_float3(input.xyz);
		currentPixel.x = (float)(input->x);
		currentPixel.y = (float)(input->y);
		currentPixel.z = (float)(input->z);

		float3 temp = rsMatrixMultiply(&colorMat, currentPixel);
		temp = (clamp(temp, 0.f, 255.f) - inBlack) * overInWMinInB;
		if (gamma.x != 1.0f)
		temp = pow(temp, (float3)gamma);
		currentPixel = clamp(temp * outWMinOutB + outBlack, 0.f, 255.f);

		//output.xyz = convert_uchar3(currentPixel.xyz);
		output->x = (uint8_t)currentPixel.x;
		output->y = (uint8_t)currentPixel.y;
		output->z = (uint8_t)currentPixel.z;
		output->w = input->w;
		}

libs/rs/java/ImageProcessing/src/com/android/rs/image/threshold.rs

+22 −25

Original line number	Diff line number	Diff line
		@@ -8,14 +8,14 @@ int radius;

		uchar4 * InPixel;
		uchar4 * OutPixel;
		uchar4 * ScratchPixel;
		float4 * ScratchPixel1;
		float4 * ScratchPixel2;

		#pragma rs export_var(height, width, radius, InPixel, OutPixel, ScratchPixel, vBlurScript, hBlurScript, levelsScript)
		#pragma rs export_func(filter, filterBenchmark);
		#pragma rs export_var(height, width, radius, InPixel, OutPixel, ScratchPixel1, ScratchPixel2, vBlurScript, hBlurScript)
		#pragma rs export_func(filter);

		rs_script vBlurScript;
		rs_script hBlurScript;
		rs_script levelsScript;

		const int CMD_FINISHED = 1;

		@@ -64,7 +64,21 @@ static void computeGaussianWeights() {
		}


		static void blur() {
		static void copyInput() {
		RS_DEBUG_MARKER;
		rs_allocation ain = rsGetAllocation(InPixel);
		uint32_t dimx = rsAllocationGetDimX(ain);
		uint32_t dimy = rsAllocationGetDimY(ain);
		for(uint32_t y = 0; y < dimy; y++) {
		for(uint32_t x = 0; x < dimx; x++) {
		ScratchPixel1[x + y * dimx] = convert_float4(InPixel[x + y * dimx]);
		}
		}
		RS_DEBUG_MARKER;
		}

		void filter() {
		copyInput();
		computeGaussianWeights();

		FilterStruct fs;
		@@ -73,28 +87,11 @@ static void blur() {
		fs.height = height;
		fs.radius = radius;

		fs.ain = rsGetAllocation(InPixel);
		rsForEach(hBlurScript, fs.ain, rsGetAllocation(ScratchPixel), &fs);
		fs.ain = rsGetAllocation(ScratchPixel1);
		rsForEach(hBlurScript, fs.ain, rsGetAllocation(ScratchPixel2), &fs);

		fs.ain = rsGetAllocation(ScratchPixel);
		fs.ain = rsGetAllocation(ScratchPixel2);
		rsForEach(vBlurScript, fs.ain, rsGetAllocation(OutPixel), &fs);
		}

		void filter() {
		//RS_DEBUG(radius);

		if(radius > 0) {
		blur();
		rsForEach(levelsScript, rsGetAllocation(OutPixel), rsGetAllocation(OutPixel), 0);
		} else {
		rsForEach(levelsScript, rsGetAllocation(InPixel), rsGetAllocation(OutPixel), 0);
		}

		rsSendToClientBlocking(CMD_FINISHED);
		}

		void filterBenchmark() {
		blur();
		rsSendToClientBlocking(CMD_FINISHED);
		}