Simplify matrix calculations for display adjustment (36f4b083) · Commits · e / os / android_frameworks_base

core/java/android/util/MatrixUtils.java

deleted100644 → 0

+0 −119

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2013 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.util;

	import java.util.Arrays;

	/**
	* A class that contains utility methods related to matrices.
	*
	* @hide
	*/
	public class MatrixUtils {
	private MatrixUtils() {
	// This class is non-instantiable.
	}

	/**
	* Sets a matrix to the identity matrix.
	*
	* @param out output matrix of size n*m
	* @param n number of rows in the output matrix
	* @param m number of columns in the output matrix
	*/
	public static void setIdentityM(float[] out, int n, int m) {
	final int size = n * m;
	if (out.length != size) {
	throw new IllegalArgumentException("Invalid dimensions for output matrix");
	}

	Arrays.fill(out, 0, size, 0);
	for (int i = Math.min(m,n) - 1; i >= 0; i--) {
	out[i * (m + 1)] = 1;
	}
	}

	/**
	* Add two matrices. May be used in-place by specifying the same value for
	* the out matrix and one of the input matrices.
	*
	* @param ab output matrix of size n*m
	* @param a left-hand matrix of size n*m
	* @param n number of rows in the left-hand matrix
	* @param m number of columns in the left-hand matrix
	* @param b right-hand matrix of size n*m
	*/
	public static void addMM(float[] ab, float[] a, int n, int m, float[] b) {
	final int size = n * m;
	if (a.length != size) {
	throw new IllegalArgumentException("Invalid dimensions for matrix a");
	} else if (b.length != size) {
	throw new IllegalArgumentException("Invalid dimensions for matrix b");
	} else if (ab.length != size) {
	throw new IllegalArgumentException("Invalid dimensions for matrix ab");
	}

	for (int i = 0; i < size; i++) {
	ab[i] = a[i] + b[i];
	}
	}

	/**
	* Multiply two matrices.
	*
	* @param ab output matrix of size n*p
	* @param a left-hand matrix of size n*m
	* @param n number of rows in the left-hand matrix
	* @param m number of columns in the left-hand matrix
	* @param b right-hand matrix of size m*p
	* @param p number of columns in the right-hand matrix
	*/
	public static void multiplyMM(float[] ab, float[] a, int n, int m, float[] b, int p) {
	if (a.length != n * m) {
	throw new IllegalArgumentException("Invalid dimensions for matrix a");
	} else if (b.length != m * p) {
	throw new IllegalArgumentException("Invalid dimensions for matrix b");
	} else if (ab.length != n * p) {
	throw new IllegalArgumentException("Invalid dimensions for matrix ab");
	}

	for (int i = 0; i < n; i++) {
	for (int j = 0; j < p; j++) {
	float sum = 0;
	for (int k = 0; k < m; k++) {
	sum += a[i * m + k] * b[k * p + j];
	}
	ab[i * p + j] = sum;
	}
	}
	}

	/**
	* Multiply a matrix by a scalar value. May be used in-place by specifying
	* the same value for the input and output matrices.
	*
	* @param out output matrix
	* @param in input matrix
	* @param scalar scalar value
	*/
	public static void multiplyMS(float[] out, float[] in, float scalar) {
	final int n = out.length;
	for (int i = 0; i < n; i++) {
	out[i] = in[i] * scalar;
	}
	}
	}

services/java/com/android/server/accessibility/AccessibilityManagerService.java

+44 −65

Original line number	Original line	Diff line number	Diff line
	@@ -44,6 +44,7 @@ import android.graphics.Rect;
	import android.hardware.display.DisplayManager;		import android.hardware.display.DisplayManager;
	import android.hardware.input.InputManager;		import android.hardware.input.InputManager;
	import android.net.Uri;		import android.net.Uri;
			import android.opengl.Matrix;
	import android.os.Binder;		import android.os.Binder;
	import android.os.Build;		import android.os.Build;
	import android.os.Bundle;		import android.os.Bundle;
	@@ -62,7 +63,6 @@ import android.os.UserManager;
	import android.provider.Settings;		import android.provider.Settings;
	import android.text.TextUtils;		import android.text.TextUtils;
	import android.text.TextUtils.SimpleStringSplitter;		import android.text.TextUtils.SimpleStringSplitter;
	import android.util.MatrixUtils;
	import android.util.Pools.Pool;		import android.util.Pools.Pool;
	import android.util.Pools.SimplePool;		import android.util.Pools.SimplePool;
	import android.util.Slog;		import android.util.Slog;
	@@ -141,43 +141,38 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub {

	private static final int MAX_POOL_SIZE = 10;		private static final int MAX_POOL_SIZE = 10;

	/** Matrix used for converting color to grayscale. */		/** Matrix and offset used for converting color to grayscale. */
	private static final float[] GRAYSCALE_MATRIX = new float[] {		private static final float[] GRAYSCALE_MATRIX = new float[] {
	.2126f, .2126f, .2126f,		.2126f, .2126f, .2126f, 0,
	.7152f, .7152f, .7152f,		.7152f, .7152f, .7152f, 0,
	.0722f, .0722f, .0722f		.0722f, .0722f, .0722f, 0,
			0, 0, 0, 1
	};		};

	/** Matrix used for standard display inversion. */		/** Matrix and offset used for standard display inversion. */
	private static final float[] INVERSION_MATRIX_STANDARD = new float[] {		private static final float[] INVERSION_MATRIX_STANDARD = new float[] {
	-1, 0, 0,		-1, 0, 0, 0,
	0, -1, 0,		0, -1, 0, 0,
	0, 0, -1		0, 0, -1, 0,
			1, 1, 1, 1
	};		};

	/** Offset used for standard display inversion. */
	private static final float INVERSION_OFFSET_STANDARD = 1;

	/** Matrix and offset used for hue-only display inversion. */		/** Matrix and offset used for hue-only display inversion. */
	private static final float[] INVERSION_MATRIX_HUE_ONLY = new float[] {		private static final float[] INVERSION_MATRIX_HUE_ONLY = new float[] {
	0, .5f, .5f,		0, .5f, .5f, 0,
	.5f, 0, .5f,		.5f, 0, .5f, 0,
	.5f, .5f, 0		.5f, .5f, 0, 0,
			0, 0, 0, 1
	};		};

	/** Offset used for hue-only display inversion. */
	private static final float INVERSION_OFFSET_HUE_ONLY = 0;

	/** Matrix and offset used for value-only display inversion. */		/** Matrix and offset used for value-only display inversion. */
	private static final float[] INVERSION_MATRIX_VALUE_ONLY = new float[] {		private static final float[] INVERSION_MATRIX_VALUE_ONLY = new float[] {
	0, -.5f, -.5f,		0, -.5f, -.5f, 0,
	-.5f, 0, -.5f,		-.5f, 0, -.5f, 0,
	-.5f, -.5f, 0		-.5f, -.5f, 0, 0,
			1, 1, 1, 1
	};		};

	/** Offset used for value-only display inversion. */
	private static final float INVERSION_OFFSET_VALUE_ONLY = 1;

	/** Default contrast for display contrast enhancement. */		/** Default contrast for display contrast enhancement. */
	private static final float DEFAULT_DISPLAY_CONTRAST = 2;		private static final float DEFAULT_DISPLAY_CONTRAST = 2;

	@@ -1486,14 +1481,11 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub {
	private void updateDisplayColorAdjustmentSettingsLocked(UserState userState) {		private void updateDisplayColorAdjustmentSettingsLocked(UserState userState) {
	final ContentResolver cr = mContext.getContentResolver();		final ContentResolver cr = mContext.getContentResolver();
	final int userId = userState.mUserId;		final int userId = userState.mUserId;
	final float[] offsetVector = new float[3];		float[] colorMatrix = new float[16];
	float[] colorOffset = new float[3];		float[] outputMatrix = new float[16];
	float[] outputOffset = new float[3];
	float[] colorMatrix = new float[9];
	float[] outputMatrix = new float[9];
	boolean hasColorTransform = false;		boolean hasColorTransform = false;

	MatrixUtils.setIdentityM(colorMatrix, 3, 3);		Matrix.setIdentityM(colorMatrix, 0);

	final boolean inversionEnabled = Settings.Secure.getIntForUser(		final boolean inversionEnabled = Settings.Secure.getIntForUser(
	cr, Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION_ENABLED, 0, userId) == 1;		cr, Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION_ENABLED, 0, userId) == 1;
	@@ -1502,30 +1494,22 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub {
	Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION, DEFAULT_DISPLAY_INVERSION,		Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION, DEFAULT_DISPLAY_INVERSION,
	userId);		userId);
	final float[] inversionMatrix;		final float[] inversionMatrix;
	final float inversionOffset;
	switch (inversionMode) {		switch (inversionMode) {
	case AccessibilityManager.INVERSION_HUE_ONLY:		case AccessibilityManager.INVERSION_HUE_ONLY:
	inversionMatrix = INVERSION_MATRIX_HUE_ONLY;		inversionMatrix = INVERSION_MATRIX_HUE_ONLY;
	inversionOffset = INVERSION_OFFSET_HUE_ONLY;
	break;		break;
	case AccessibilityManager.INVERSION_VALUE_ONLY:		case AccessibilityManager.INVERSION_VALUE_ONLY:
	inversionMatrix = INVERSION_MATRIX_VALUE_ONLY;		inversionMatrix = INVERSION_MATRIX_VALUE_ONLY;
	inversionOffset = INVERSION_OFFSET_VALUE_ONLY;
	break;		break;
	default:		default:
	inversionMatrix = INVERSION_MATRIX_STANDARD;		inversionMatrix = INVERSION_MATRIX_STANDARD;
	inversionOffset = INVERSION_OFFSET_STANDARD;
	}		}

	Arrays.fill(offsetVector, inversionOffset);		Matrix.multiplyMM(outputMatrix, 0, colorMatrix, 0, inversionMatrix, 0);

	MatrixUtils.multiplyMM(outputMatrix, colorMatrix, 3, 3, inversionMatrix, 3);
	MatrixUtils.multiplyMM(outputOffset, colorOffset, 1, 3, inversionMatrix, 3);
	MatrixUtils.addMM(colorOffset, outputOffset, 1, 3, offsetVector);

	final float[] temp = colorMatrix;		final float[] temp = colorMatrix;
	colorMatrix = outputMatrix;		colorMatrix = outputMatrix;
	outputMatrix = temp;		outputMatrix = colorMatrix;

	hasColorTransform = true;		hasColorTransform = true;
	}		}
	@@ -1539,16 +1523,19 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub {
	final float brightness = Settings.Secure.getFloatForUser(cr,		final float brightness = Settings.Secure.getFloatForUser(cr,
	Settings.Secure.ACCESSIBILITY_DISPLAY_BRIGHTNESS, DEFAULT_DISPLAY_BRIGHTNESS,		Settings.Secure.ACCESSIBILITY_DISPLAY_BRIGHTNESS, DEFAULT_DISPLAY_BRIGHTNESS,
	userId);		userId);
	final float offset = brightness * contrast - 0.5f * contrast + 0.5f;		final float off = brightness * contrast - 0.5f * contrast + 0.5f;
	Arrays.fill(offsetVector, offset);		final float[] contrastMatrix = {
			contrast, 0, 0, 0,
			0, contrast, 0, 0,
			0, 0, contrast, 0,
			off, off, off, 1
			};

	MatrixUtils.multiplyMS(outputMatrix, colorMatrix, contrast);		Matrix.multiplyMM(outputMatrix, 0, colorMatrix, 0, contrastMatrix, 0);
	MatrixUtils.multiplyMS(outputOffset, colorOffset, contrast);
	MatrixUtils.addMM(colorOffset, outputOffset, 1, 3, offsetVector);

	final float[] temp = colorMatrix;		final float[] temp = colorMatrix;
	colorMatrix = outputMatrix;		colorMatrix = outputMatrix;
	outputMatrix = temp;		outputMatrix = colorMatrix;

	hasColorTransform = true;		hasColorTransform = true;
	}		}
	@@ -1561,17 +1548,12 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub {
	userId);		userId);
	// Monochromacy isn't supported by the native Daltonizer.		// Monochromacy isn't supported by the native Daltonizer.
	if (daltonizerMode == AccessibilityManager.DALTONIZER_SIMULATE_MONOCHROMACY) {		if (daltonizerMode == AccessibilityManager.DALTONIZER_SIMULATE_MONOCHROMACY) {
	MatrixUtils.multiplyMM(outputMatrix, colorMatrix, 3, 3, GRAYSCALE_MATRIX, 3);		Matrix.multiplyMM(outputMatrix, 0, colorMatrix, 0, GRAYSCALE_MATRIX, 0);
	MatrixUtils.multiplyMM(outputOffset, colorOffset, 1, 3, GRAYSCALE_MATRIX, 3);

	final float[] temp = colorMatrix;		final float[] temp = colorMatrix;
	colorMatrix = outputMatrix;		colorMatrix = outputMatrix;
	outputMatrix = temp;		outputMatrix = temp;

	final float[] tempVec = colorOffset;
	colorOffset = outputOffset;
	outputOffset = temp;

	hasColorTransform = true;		hasColorTransform = true;
	nativeSetDaltonizerMode(AccessibilityManager.DALTONIZER_DISABLED);		nativeSetDaltonizerMode(AccessibilityManager.DALTONIZER_DISABLED);
	} else {		} else {
	@@ -1582,9 +1564,9 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub {
	}		}

	if (hasColorTransform) {		if (hasColorTransform) {
	nativeSetColorTransform(colorMatrix, colorOffset);		nativeSetColorTransform(colorMatrix);
	} else {		} else {
	nativeSetColorTransform(null, null);		nativeSetColorTransform(null);
	}		}
	}		}

	@@ -1731,25 +1713,22 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub {
	}		}

	/**		/**
	* Sets the surface flinger's color transformation matrix and offset. If		* Sets the surface flinger's color transformation as a 4x4 matrix. If the
	* either value is null, color transformations are disabled.		* matrix is null, color transformations are disabled.
	*		*
	* @param matrix new color transformation matrix, or null to disable		* @param m the float array that holds the transformation matrix, or null to
	* @param offset new color transformation offset, or null to disable		* disable transformation
	*/		*/
	private static void nativeSetColorTransform(float[] matrix, float[] offset) {		private static void nativeSetColorTransform(float[] m) {
	try {		try {
	final IBinder flinger = ServiceManager.getService("SurfaceFlinger");		final IBinder flinger = ServiceManager.getService("SurfaceFlinger");
	if (flinger != null) {		if (flinger != null) {
	final Parcel data = Parcel.obtain();		final Parcel data = Parcel.obtain();
	data.writeInterfaceToken("android.ui.ISurfaceComposer");		data.writeInterfaceToken("android.ui.ISurfaceComposer");
	if (matrix != null && offset != null) {		if (m != null) {
	data.writeInt(1);		data.writeInt(1);
	for (int i = 0; i < 9; i++) {		for (int i = 0; i < 16; i++) {
	data.writeFloat(matrix[i]);		data.writeFloat(m[i]);
	}
	for (int i = 0; i < 3; i++) {
	data.writeFloat(offset[i]);
	}		}
	} else {		} else {
	data.writeInt(0);		data.writeInt(0);