diff options
8 files changed, 556 insertions, 60 deletions
diff --git a/graphics/java/android/renderscript/ScriptIntrinsicBlur.java b/graphics/java/android/renderscript/ScriptIntrinsicBlur.java new file mode 100644 index 0000000..56c5426 --- /dev/null +++ b/graphics/java/android/renderscript/ScriptIntrinsicBlur.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.renderscript; + +import android.content.Context; +import android.content.res.Resources; +import android.util.Log; + +/** + * @hide + **/ +public class ScriptIntrinsicBlur extends ScriptIntrinsic { + private float[] mValues = new float[9]; + private Allocation mInput; + + ScriptIntrinsicBlur(int id, RenderScript rs) { + super(id, rs); + } + + /** + * Supported elements types are float, float4, uchar, uchar4 + * + * + * @param rs + * @param e + * + * @return ScriptIntrinsicConvolve3x3 + */ + public static ScriptIntrinsicBlur create(RenderScript rs, Element e) { + int id = rs.nScriptIntrinsicCreate(5, e.getID(rs)); + return new ScriptIntrinsicBlur(id, rs); + + } + + public void setInput(Allocation ain) { + mInput = ain; + bindAllocation(ain, 1); + } + + public void setRadius(float v) { + if (v < 0 || v > 25) { + throw new RSIllegalArgumentException("Radius out of range (0-25)."); + } + setVar(0, v); + } + + public void forEach(Allocation aout) { + forEach(0, null, aout, null); + } + +} + diff --git a/graphics/java/android/renderscript/ScriptIntrinsicConvolve5x5.java b/graphics/java/android/renderscript/ScriptIntrinsicConvolve5x5.java new file mode 100644 index 0000000..242623b --- /dev/null +++ b/graphics/java/android/renderscript/ScriptIntrinsicConvolve5x5.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.renderscript; + +import android.util.Log; + +/** + * @hide + **/ +public class ScriptIntrinsicConvolve5x5 extends ScriptIntrinsic { + private float[] mValues = new float[25]; + private Allocation mInput; + + ScriptIntrinsicConvolve5x5(int id, RenderScript rs) { + super(id, rs); + } + + /** + * Supported elements types are float, float4, uchar, uchar4 + * + * + * @param rs + * @param e + * + * @return ScriptIntrinsicConvolve5x5 + */ + public static ScriptIntrinsicConvolve5x5 create(RenderScript rs, Element e) { + int id = rs.nScriptIntrinsicCreate(4, e.getID(rs)); + return new ScriptIntrinsicConvolve5x5(id, rs); + + } + + public void setInput(Allocation ain) { + mInput = ain; + bindAllocation(ain, 1); + } + + public void setCoefficients(float v[]) { + FieldPacker fp = new FieldPacker(25*4); + for (int ct=0; ct < mValues.length; ct++) { + mValues[ct] = v[ct]; + fp.addF32(mValues[ct]); + } + setVar(0, fp); + } + + public void forEach(Allocation aout) { + forEach(0, null, aout, null); + } + +} + diff --git a/graphics/java/android/renderscript/ScriptIntrinsicLUT.java b/graphics/java/android/renderscript/ScriptIntrinsicLUT.java new file mode 100644 index 0000000..e7d8d34 --- /dev/null +++ b/graphics/java/android/renderscript/ScriptIntrinsicLUT.java @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.renderscript; + +import android.content.Context; +import android.content.res.Resources; +import android.util.Log; + + +/** + * @hide + **/ +public class ScriptIntrinsicLUT extends ScriptIntrinsic { + private Matrix4f mMatrix = new Matrix4f(); + private Allocation mTables; + private byte mCache[] = new byte[1024]; + private boolean mDirty = true; + + ScriptIntrinsicLUT(int id, RenderScript rs) { + super(id, rs); + mTables = Allocation.createSized(rs, Element.U8(rs), 1024); + for (int ct=0; ct < 256; ct++) { + mCache[ct] = (byte)ct; + mCache[ct + 256] = (byte)ct; + mCache[ct + 512] = (byte)ct; + mCache[ct + 768] = (byte)ct; + } + bindAllocation(mTables, 0); + } + + /** + * Supported elements types are uchar4 + * + * @param rs + * @param e + * + * @return ScriptIntrinsicColorMatrix + */ + public static ScriptIntrinsicLUT create(RenderScript rs, Element e) { + int id = rs.nScriptIntrinsicCreate(3, e.getID(rs)); + return new ScriptIntrinsicLUT(id, rs); + + } + + + private void validate(int index, int value) { + if (index < 0 || index > 255) { + throw new RSIllegalArgumentException("Index out of range (0-255)."); + } + if (value < 0 || value > 255) { + throw new RSIllegalArgumentException("Value out of range (0-255)."); + } + } + + public void setRed(int index, int value) { + validate(index, value); + mCache[index] = (byte)value; + mDirty = true; + } + + public void setGreen(int index, int value) { + validate(index, value); + mCache[index+256] = (byte)value; + mDirty = true; + } + + public void setBlue(int index, int value) { + validate(index, value); + mCache[index+512] = (byte)value; + mDirty = true; + } + + public void setAlpha(int index, int value) { + validate(index, value); + mCache[index+768] = (byte)value; + mDirty = true; + } + + + /** + * Invoke the kernel and apply the matrix to each cell of ain and copy to + * aout. + * + * @param ain Input allocation + * @param aout Output allocation + */ + public void forEach(Allocation ain, Allocation aout) { + if (mDirty) { + mDirty = false; + mTables.copyFromUnchecked(mCache); + } + forEach(0, ain, aout, null); + } + +} + diff --git a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/Blur25.java b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/Blur25.java index 697bbb1..9728c12 100644 --- a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/Blur25.java +++ b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/Blur25.java @@ -21,14 +21,16 @@ import java.lang.Math; import android.renderscript.Allocation; import android.renderscript.Element; import android.renderscript.RenderScript; -import android.renderscript.Script; -import android.renderscript.ScriptC; +import android.renderscript.ScriptIntrinsicBlur; import android.renderscript.Type; import android.util.Log; import android.widget.SeekBar; import android.widget.TextView; public class Blur25 extends TestBase { + private boolean mUseIntrinsic = false; + private ScriptIntrinsicBlur mIntrinsic; + private int MAX_RADIUS = 25; private ScriptC_threshold mScript; private ScriptC_vertical_blur mScriptVBlur; @@ -39,6 +41,10 @@ public class Blur25 extends TestBase { private Allocation mScratchPixelsAllocation2; + public Blur25(boolean useIntrinsic) { + mUseIntrinsic = useIntrinsic; + } + public boolean onBar1Setup(SeekBar b, TextView t) { t.setText("Radius"); b.setProgress(100); @@ -67,40 +73,59 @@ public class Blur25 extends TestBase { int width = mInPixelsAllocation.getType().getX(); int height = mInPixelsAllocation.getType().getY(); - Type.Builder tb = new Type.Builder(mRS, Element.F32_4(mRS)); - tb.setX(width); - tb.setY(height); - mScratchPixelsAllocation1 = Allocation.createTyped(mRS, tb.create()); - mScratchPixelsAllocation2 = Allocation.createTyped(mRS, tb.create()); + if (mUseIntrinsic) { + mIntrinsic = ScriptIntrinsicBlur.create(mRS, Element.U8_4(mRS)); + mIntrinsic.setRadius(25.f); + mIntrinsic.setInput(mInPixelsAllocation); + } else { - mScriptVBlur = new ScriptC_vertical_blur(mRS, res, R.raw.vertical_blur); - mScriptHBlur = new ScriptC_horizontal_blur(mRS, res, R.raw.horizontal_blur); + Type.Builder tb = new Type.Builder(mRS, Element.F32_4(mRS)); + tb.setX(width); + tb.setY(height); + mScratchPixelsAllocation1 = Allocation.createTyped(mRS, tb.create()); + mScratchPixelsAllocation2 = Allocation.createTyped(mRS, tb.create()); - mScript = new ScriptC_threshold(mRS, res, R.raw.threshold); - mScript.set_width(width); - mScript.set_height(height); - mScript.set_radius(mRadius); + mScriptVBlur = new ScriptC_vertical_blur(mRS, res, R.raw.vertical_blur); + mScriptHBlur = new ScriptC_horizontal_blur(mRS, res, R.raw.horizontal_blur); - mScriptVBlur.invoke_setSaturation(mSaturation); + mScript = new ScriptC_threshold(mRS, res, R.raw.threshold); + mScript.set_width(width); + mScript.set_height(height); + mScript.set_radius(mRadius); + + mScriptVBlur.invoke_setSaturation(mSaturation); - mScript.bind_InPixel(mInPixelsAllocation); - mScript.bind_OutPixel(mOutPixelsAllocation); - mScript.bind_ScratchPixel1(mScratchPixelsAllocation1); - mScript.bind_ScratchPixel2(mScratchPixelsAllocation2); + mScript.bind_InPixel(mInPixelsAllocation); + mScript.bind_OutPixel(mOutPixelsAllocation); + mScript.bind_ScratchPixel1(mScratchPixelsAllocation1); + mScript.bind_ScratchPixel2(mScratchPixelsAllocation2); - mScript.set_vBlurScript(mScriptVBlur); - mScript.set_hBlurScript(mScriptHBlur); + mScript.set_vBlurScript(mScriptVBlur); + mScript.set_hBlurScript(mScriptHBlur); + } } public void runTest() { - mScript.invoke_filter(); + if (mUseIntrinsic) { + mIntrinsic.forEach(mOutPixelsAllocation); + } else { + mScript.invoke_filter(); + } } public void setupBenchmark() { - mScript.set_radius(MAX_RADIUS); + if (mUseIntrinsic) { + mIntrinsic.setRadius(MAX_RADIUS); + } else { + mScript.set_radius(MAX_RADIUS); + } } public void exitBenchmark() { - mScript.set_radius(mRadius); + if (mUseIntrinsic) { + mIntrinsic.setRadius(mRadius); + } else { + mScript.set_radius(mRadius); + } } } diff --git a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/Convolve5x5.java b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/Convolve5x5.java new file mode 100644 index 0000000..b3914d1 --- /dev/null +++ b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/Convolve5x5.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.image; + +import java.lang.Math; + +import android.renderscript.Allocation; +import android.renderscript.Element; +import android.renderscript.Matrix4f; +import android.renderscript.RenderScript; +import android.renderscript.Script; +import android.renderscript.ScriptC; +import android.renderscript.ScriptGroup; +import android.renderscript.ScriptIntrinsicConvolve5x5; +import android.renderscript.Type; +import android.util.Log; + +public class Convolve5x5 extends TestBase { + private ScriptC_convolve5x5 mScript; + private ScriptIntrinsicConvolve5x5 mIntrinsic; + + private int mWidth; + private int mHeight; + private boolean mUseIntrinsic; + + public Convolve5x5(boolean useIntrinsic) { + mUseIntrinsic = useIntrinsic; + } + + public void createTest(android.content.res.Resources res) { + mWidth = mInPixelsAllocation.getType().getX(); + mHeight = mInPixelsAllocation.getType().getY(); + + float f[] = new float[25]; + f[0] = 0.012f; f[1] = 0.025f; f[2] = 0.031f; f[3] = 0.025f; f[4] = 0.012f; + f[5] = 0.025f; f[6] = 0.057f; f[7] = 0.075f; f[8] = 0.057f; f[9] = 0.025f; + f[10]= 0.031f; f[11]= 0.075f; f[12]= 0.095f; f[13]= 0.075f; f[14]= 0.031f; + f[15]= 0.025f; f[16]= 0.057f; f[17]= 0.075f; f[18]= 0.057f; f[19]= 0.025f; + f[20]= 0.012f; f[21]= 0.025f; f[22]= 0.031f; f[23]= 0.025f; f[24]= 0.012f; + + if (mUseIntrinsic) { + mIntrinsic = ScriptIntrinsicConvolve5x5.create(mRS, Element.U8_4(mRS)); + mIntrinsic.setCoefficients(f); + mIntrinsic.setInput(mInPixelsAllocation); + } else { + mScript = new ScriptC_convolve5x5(mRS, res, R.raw.convolve5x5); + mScript.set_gCoeffs(f); + mScript.set_gIn(mInPixelsAllocation); + mScript.set_gWidth(mWidth); + mScript.set_gHeight(mHeight); + } + } + + public void runTest() { + if (mUseIntrinsic) { + mIntrinsic.forEach(mOutPixelsAllocation); + } else { + mScript.forEach_root(mOutPixelsAllocation); + } + } + +} diff --git a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/CrossProcess.java b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/CrossProcess.java new file mode 100644 index 0000000..b9e3524 --- /dev/null +++ b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/CrossProcess.java @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.image; + +import java.lang.Math; + +import android.renderscript.Allocation; +import android.renderscript.Element; +import android.renderscript.RenderScript; +import android.renderscript.ScriptIntrinsicLUT; +import android.util.Log; + +public class CrossProcess extends TestBase { + private ScriptIntrinsicLUT mIntrinsic; + + public void createTest(android.content.res.Resources res) { + mIntrinsic = ScriptIntrinsicLUT.create(mRS, Element.U8_4(mRS)); + for (int ct=0; ct < 256; ct++) { + float f = ((float)ct) / 255.f; + + float r = f; + if (r < 0.5f) { + r = 4.0f * r * r * r; + } else { + r = 1.0f - r; + r = 1.0f - (4.0f * r * r * r); + } + mIntrinsic.setRed(ct, (int)(r * 255.f + 0.5f)); + + float g = f; + if (g < 0.5f) { + g = 2.0f * g * g; + } else { + g = 1.0f - g; + g = 1.0f - (2.0f * g * g); + } + mIntrinsic.setGreen(ct, (int)(g * 255.f + 0.5f)); + + float b = f * 0.5f + 0.25f; + mIntrinsic.setBlue(ct, (int)(b * 255.f + 0.5f)); + } + + } + + public void runTest() { + mIntrinsic.forEach(mInPixelsAllocation, mOutPixelsAllocation); + } + +} diff --git a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java index 37577eb..7b84355 100644 --- a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java +++ b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java @@ -135,62 +135,74 @@ public class ImageProcessingActivity extends Activity mTest = new LevelsV4(true, true); break; case 4: - mTest = new Blur25(); + mTest = new Blur25(false); break; case 5: - mTest = new Greyscale(); + mTest = new Blur25(true); break; case 6: - mTest = new Grain(); + mTest = new Greyscale(); break; case 7: - mTest = new Fisheye(false, false); + mTest = new Grain(); break; case 8: - mTest = new Fisheye(false, true); + mTest = new Fisheye(false, false); break; case 9: - mTest = new Fisheye(true, false); + mTest = new Fisheye(false, true); break; case 10: - mTest = new Fisheye(true, true); + mTest = new Fisheye(true, false); break; case 11: - mTest = new Vignette(false, false); + mTest = new Fisheye(true, true); break; case 12: - mTest = new Vignette(false, true); + mTest = new Vignette(false, false); break; case 13: - mTest = new Vignette(true, false); + mTest = new Vignette(false, true); break; case 14: - mTest = new Vignette(true, true); + mTest = new Vignette(true, false); break; case 15: - mTest = new GroupTest(false); + mTest = new Vignette(true, true); break; case 16: - mTest = new GroupTest(true); + mTest = new GroupTest(false); break; case 17: - mTest = new Convolve3x3(false); + mTest = new GroupTest(true); break; case 18: - mTest = new Convolve3x3(true); + mTest = new Convolve3x3(false); break; case 19: - mTest = new ColorMatrix(false, false); + mTest = new Convolve3x3(true); break; case 20: - mTest = new ColorMatrix(true, false); + mTest = new ColorMatrix(false, false); break; case 21: - mTest = new ColorMatrix(true, true); + mTest = new ColorMatrix(true, false); break; case 22: + mTest = new ColorMatrix(true, true); + break; + case 23: mTest = new Copy(); break; + case 24: + mTest = new CrossProcess(); + break; + case 25: + mTest = new Convolve5x5(false); + break; + case 26: + mTest = new Convolve5x5(true); + break; } mTest.createBaseTest(this, mBitmapIn); @@ -203,30 +215,34 @@ public class ImageProcessingActivity extends Activity } void setupTests() { - mTestNames = new String[23]; + mTestNames = new String[27]; mTestNames[0] = "Levels Vec3 Relaxed"; mTestNames[1] = "Levels Vec4 Relaxed"; mTestNames[2] = "Levels Vec3 Full"; mTestNames[3] = "Levels Vec4 Full"; mTestNames[4] = "Blur radius 25"; - mTestNames[5] = "Greyscale"; - mTestNames[6] = "Grain"; - mTestNames[7] = "Fisheye Full"; - mTestNames[8] = "Fisheye Relaxed"; - mTestNames[9] = "Fisheye Approximate Full"; - mTestNames[10] = "Fisheye Approximate Relaxed"; - mTestNames[11] = "Vignette Full"; - mTestNames[12] = "Vignette Relaxed"; - mTestNames[13] = "Vignette Approximate Full"; - mTestNames[14] = "Vignette Approximate Relaxed"; - mTestNames[15] = "Group Test (emulated)"; - mTestNames[16] = "Group Test (native)"; - mTestNames[17] = "Convolve 3x3"; - mTestNames[18] = "Intrinsics Convolve 3x3"; - mTestNames[19] = "ColorMatrix"; - mTestNames[20] = "Intrinsics ColorMatrix"; - mTestNames[21] = "Intrinsics ColorMatrix Grey"; - mTestNames[22] = "Copy"; + mTestNames[5] = "Intrinsic Blur radius 25"; + mTestNames[6] = "Greyscale"; + mTestNames[7] = "Grain"; + mTestNames[8] = "Fisheye Full"; + mTestNames[9] = "Fisheye Relaxed"; + mTestNames[10] = "Fisheye Approximate Full"; + mTestNames[11] = "Fisheye Approximate Relaxed"; + mTestNames[12] = "Vignette Full"; + mTestNames[13] = "Vignette Relaxed"; + mTestNames[14] = "Vignette Approximate Full"; + mTestNames[15] = "Vignette Approximate Relaxed"; + mTestNames[16] = "Group Test (emulated)"; + mTestNames[17] = "Group Test (native)"; + mTestNames[18] = "Convolve 3x3"; + mTestNames[19] = "Intrinsics Convolve 3x3"; + mTestNames[20] = "ColorMatrix"; + mTestNames[21] = "Intrinsics ColorMatrix"; + mTestNames[22] = "Intrinsics ColorMatrix Grey"; + mTestNames[23] = "Copy"; + mTestNames[24] = "CrossProcess (using LUT)"; + mTestNames[25] = "Convolve 5x5"; + mTestNames[26] = "Intrinsics Convolve 5x5"; mTestSpinner.setAdapter(new ArrayAdapter<String>( this, R.layout.spinner_layout, mTestNames)); } diff --git a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/convolve5x5.rs b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/convolve5x5.rs new file mode 100644 index 0000000..fe6cf31 --- /dev/null +++ b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/convolve5x5.rs @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma version(1) +#pragma rs java_package_name(com.android.rs.image) +#pragma rs_fp_relaxed + +int32_t gWidth; +int32_t gHeight; +rs_allocation gIn; + +float gCoeffs[25]; + +void root(uchar4 *out, uint32_t x, uint32_t y) { + uint32_t x0 = max((int32_t)x-2, 0); + uint32_t x1 = max((int32_t)x-1, 0); + uint32_t x2 = x; + uint32_t x3 = min((int32_t)x+1, gWidth-1); + uint32_t x4 = min((int32_t)x+2, gWidth-1); + + uint32_t y0 = max((int32_t)y-2, 0); + uint32_t y1 = max((int32_t)y-1, 0); + uint32_t y2 = y; + uint32_t y3 = min((int32_t)y+1, gHeight-1); + uint32_t y4 = min((int32_t)y+2, gHeight-1); + + float4 p0 = convert_float4(((uchar4 *)rsGetElementAt(gIn, x0, y0))[0]) * gCoeffs[0] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x1, y0))[0]) * gCoeffs[1] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x2, y0))[0]) * gCoeffs[2] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x3, y0))[0]) * gCoeffs[3] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x4, y0))[0]) * gCoeffs[4]; + + float4 p1 = convert_float4(((uchar4 *)rsGetElementAt(gIn, x0, y1))[0]) * gCoeffs[5] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x1, y1))[0]) * gCoeffs[6] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x2, y1))[0]) * gCoeffs[7] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x3, y1))[0]) * gCoeffs[8] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x4, y1))[0]) * gCoeffs[9]; + + float4 p2 = convert_float4(((uchar4 *)rsGetElementAt(gIn, x0, y2))[0]) * gCoeffs[10] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x1, y2))[0]) * gCoeffs[11] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x2, y2))[0]) * gCoeffs[12] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x3, y2))[0]) * gCoeffs[13] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x4, y2))[0]) * gCoeffs[14]; + + float4 p3 = convert_float4(((uchar4 *)rsGetElementAt(gIn, x0, y3))[0]) * gCoeffs[15] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x1, y3))[0]) * gCoeffs[16] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x2, y3))[0]) * gCoeffs[17] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x3, y3))[0]) * gCoeffs[18] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x4, y3))[0]) * gCoeffs[19]; + + float4 p4 = convert_float4(((uchar4 *)rsGetElementAt(gIn, x0, y4))[0]) * gCoeffs[20] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x1, y4))[0]) * gCoeffs[21] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x2, y4))[0]) * gCoeffs[22] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x3, y4))[0]) * gCoeffs[23] + + convert_float4(((uchar4 *)rsGetElementAt(gIn, x4, y4))[0]) * gCoeffs[24]; + + p0 = clamp(p0 + p1 + p2 + p3 + p4, 0.f, 255.f); + *out = convert_uchar4(p0); +} + + |