Snap for 4756844 from af0c783042eb89b58abb28bda87e4dd298af725f to pi-release (32e42acb) · Commits · e / os / android_frameworks_native-old

libs/dumputils/dump_utils.cpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -42,6 +42,7 @@ static const char* native_processes_to_dump[] = {
		/* list of hal interface to dump containing process during native dumps */
		static const char* hal_interfaces_to_dump[] {
		"android.hardware.audio@2.0::IDevicesFactory",
		"android.hardware.audio@4.0::IDevicesFactory",
		"android.hardware.bluetooth@1.0::IBluetoothHci",
		"android.hardware.camera.provider@2.4::ICameraProvider",
		"android.hardware.drm@1.0::IDrmFactory",

services/surfaceflinger/RenderEngine/ProgramCache.cpp

+224 −215

Original line number	Diff line number	Diff line
		@@ -168,72 +168,10 @@ ProgramCache::Key ProgramCache::computeKey(const Description& description) {
		return needs;
		}

		String8 ProgramCache::generateVertexShader(const Key& needs) {
		Formatter vs;
		if (needs.isTexturing()) {
		vs << "attribute vec4 texCoords;"
		<< "varying vec2 outTexCoords;";
		}
		vs << "attribute vec4 position;"
		<< "uniform mat4 projection;"
		<< "uniform mat4 texture;"
		<< "void main(void) {" << indent << "gl_Position = projection * position;";
		if (needs.isTexturing()) {
		vs << "outTexCoords = (texture * texCoords).st;";
		}
		vs << dedent << "}";
		return vs.getString();
		}

		String8 ProgramCache::generateFragmentShader(const Key& needs) {
		Formatter fs;
		if (needs.getTextureTarget() == Key::TEXTURE_EXT) {
		fs << "#extension GL_OES_EGL_image_external : require";
		}

		// default precision is required-ish in fragment shaders
		fs << "precision mediump float;";

		if (needs.getTextureTarget() == Key::TEXTURE_EXT) {
		fs << "uniform samplerExternalOES sampler;"
		<< "varying vec2 outTexCoords;";
		} else if (needs.getTextureTarget() == Key::TEXTURE_2D) {
		fs << "uniform sampler2D sampler;"
		<< "varying vec2 outTexCoords;";
		}

		if (needs.getTextureTarget() == Key::TEXTURE_OFF \|\| needs.hasAlpha()) {
		fs << "uniform vec4 color;";
		}

		if (needs.isY410BT2020()) {
		fs << R"__SHADER__(
		vec3 convertY410BT2020(const vec3 color) {
		const vec3 offset = vec3(0.0625, 0.5, 0.5);
		const mat3 transform = mat3(
		vec3(1.1678, 1.1678, 1.1678),
		vec3( 0.0, -0.1878, 2.1481),
		vec3(1.6836, -0.6523, 0.0));
		// Y is in G, U is in R, and V is in B
		return clamp(transform * (color.grb - offset), 0.0, 1.0);
		}
		)__SHADER__";
		}

		if (needs.hasColorMatrix()) {
		fs << "uniform mat4 colorMatrix;";

		// Generate EOTF that converts signal values to relative display light,
		// both normalized to [0, 1].
		void ProgramCache::generateEOTF(Formatter& fs, const Key& needs) {
		switch (needs.getInputTF()) {
		case Key::INPUT_TF_LINEAR:
		default:
		fs << R"__SHADER__(
		vec3 EOTF(const vec3 linear) {
		return linear;
		}
		)__SHADER__";
		break;
		case Key::INPUT_TF_SRGB:
		fs << R"__SHADER__(
		float EOTF_sRGB(float srgb) {
		@@ -280,14 +218,23 @@ String8 ProgramCache::generateFragmentShader(const Key& needs) {
		}
		)__SHADER__";
		break;
		default:
		fs << R"__SHADER__(
		vec3 EOTF(const vec3 linear) {
		return linear;
		}
		)__SHADER__";
		break;
		}
		}

		// Generate OOTF that modifies the relative scence light to relative display light.
		void ProgramCache::generateOOTF(Formatter& fs, const Key& needs) {
		fs << R"__SHADER__(
		highp float CalculateY(const highp vec3 color) {
		// BT2020 standard uses the unadjusted KR = 0.2627,
		// KB = 0.0593 luminance interpretation for RGB conversion.
		return color.r * 0.262700 + color.g * 0.677998 +
		color.b * 0.059302;
		return color.r * 0.262700 + color.g * 0.677998 + color.b * 0.059302;
		}
		)__SHADER__";

		@@ -377,19 +324,14 @@ String8 ProgramCache::generateFragmentShader(const Key& needs) {
		return color;
		}
		)__SHADER__";
		break;
		}
		}

		// Generate OETF that converts relative display light to signal values,
		// both normalized to [0, 1]
		void ProgramCache::generateOETF(Formatter& fs, const Key& needs) {
		switch (needs.getOutputTF()) {
		case Key::OUTPUT_TF_LINEAR:
		default:
		fs << R"__SHADER__(
		vec3 OETF(const vec3 linear) {
		return linear;
		}
		)__SHADER__";
		break;
		case Key::OUTPUT_TF_SRGB:
		fs << R"__SHADER__(
		float OETF_sRGB(const float linear) {
		@@ -437,7 +379,74 @@ String8 ProgramCache::generateFragmentShader(const Key& needs) {
		}
		)__SHADER__";
		break;
		default:
		fs << R"__SHADER__(
		vec3 OETF(const vec3 linear) {
		return linear;
		}
		)__SHADER__";
		break;
		}
		}

		String8 ProgramCache::generateVertexShader(const Key& needs) {
		Formatter vs;
		if (needs.isTexturing()) {
		vs << "attribute vec4 texCoords;"
		<< "varying vec2 outTexCoords;";
		}
		vs << "attribute vec4 position;"
		<< "uniform mat4 projection;"
		<< "uniform mat4 texture;"
		<< "void main(void) {" << indent << "gl_Position = projection * position;";
		if (needs.isTexturing()) {
		vs << "outTexCoords = (texture * texCoords).st;";
		}
		vs << dedent << "}";
		return vs.getString();
		}

		String8 ProgramCache::generateFragmentShader(const Key& needs) {
		Formatter fs;
		if (needs.getTextureTarget() == Key::TEXTURE_EXT) {
		fs << "#extension GL_OES_EGL_image_external : require";
		}

		// default precision is required-ish in fragment shaders
		fs << "precision mediump float;";

		if (needs.getTextureTarget() == Key::TEXTURE_EXT) {
		fs << "uniform samplerExternalOES sampler;"
		<< "varying vec2 outTexCoords;";
		} else if (needs.getTextureTarget() == Key::TEXTURE_2D) {
		fs << "uniform sampler2D sampler;"
		<< "varying vec2 outTexCoords;";
		}

		if (needs.getTextureTarget() == Key::TEXTURE_OFF \|\| needs.hasAlpha()) {
		fs << "uniform vec4 color;";
		}

		if (needs.isY410BT2020()) {
		fs << R"__SHADER__(
		vec3 convertY410BT2020(const vec3 color) {
		const vec3 offset = vec3(0.0625, 0.5, 0.5);
		const mat3 transform = mat3(
		vec3(1.1678, 1.1678, 1.1678),
		vec3( 0.0, -0.1878, 2.1481),
		vec3(1.6836, -0.6523, 0.0));
		// Y is in G, U is in R, and V is in B
		return clamp(transform * (color.grb - offset), 0.0, 1.0);
		}
		)__SHADER__";
		}

		if (needs.hasColorMatrix()) {
		fs << "uniform mat4 colorMatrix;";

		generateEOTF(fs, needs);
		generateOOTF(fs, needs);
		generateOETF(fs, needs);
		}

		fs << "void main(void) {" << indent;

services/surfaceflinger/RenderEngine/ProgramCache.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@
		namespace android {

		class Description;
		class Formatter;
		class Program;
		class String8;

		@@ -132,6 +133,12 @@ private:
		void primeCache();
		// compute a cache Key from a Description
		static Key computeKey(const Description& description);
		// Generate EOTF based from Key.
		static void generateEOTF(Formatter& fs, const Key& needs);
		// Generate OOTF based from Key.
		static void generateOOTF(Formatter& fs, const Key& needs);
		// Generate OETF based from Key.
		static void generateOETF(Formatter& fs, const Key& needs);
		// generates a program from the Key
		static Program* generateProgram(const Key& needs);
		// generates the vertex shader from the Key

services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp

+585 −4

File changed.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+22 −1

Original line number	Diff line number	Diff line
		@@ -85,6 +85,17 @@ public:
		return mFlinger->onHotplugReceived(sequenceId, display, connection);
		}

		auto setDisplayStateLocked(const DisplayState& s) { return mFlinger->setDisplayStateLocked(s); }

		auto onInitializeDisplays() { return mFlinger->onInitializeDisplays(); }

		/* ------------------------------------------------------------------------
		* Read-only access to private data to assert post-conditions.
		*/

		const auto& getAnimFrameTracker() const { return mFlinger->mAnimFrameTracker; }
		const auto& getCompositorTiming() const { return mFlinger->getBE().mCompositorTiming; }

		/* ------------------------------------------------------------------------
		* Read-write access to private data to set up preconditions and assert
		* post-conditions.
		@@ -247,6 +258,16 @@ public:
		return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
		}

		const auto& getDrawingDisplayState() {
		return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
		}

		const auto& getCurrentDisplayState() {
		return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
		}

		auto& mutableDisplayDevice() { return mFlinger.mutableDisplays().valueFor(mDisplayToken); }

		auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
		mNativeWindow = nativeWindow;
		return *this;
		@@ -278,7 +299,7 @@ public:
		mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
		mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);

		if (mType < DisplayDevice::DISPLAY_VIRTUAL) {
		if (mType >= DisplayDevice::DISPLAY_PRIMARY && mType < DisplayDevice::DISPLAY_VIRTUAL) {
		mFlinger.mutableBuiltinDisplays()[mType] = mDisplayToken;
		}