NEON shortcut for flat colour blending into 16-bit (f9e8ab03) · Commits · e / os / android_system_core

libpixelflinger/Android.mk

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -40,7 +40,13 @@ PIXELFLINGER_SRC_FILES:= \
	buffer.cpp		buffer.cpp

	ifeq ($(TARGET_ARCH),arm)		ifeq ($(TARGET_ARCH),arm)
			ifeq ($(TARGET_ARCH_VERSION),armv7-a)
			PIXELFLINGER_SRC_FILES += col32cb16blend_neon.S
			PIXELFLINGER_SRC_FILES += col32cb16blend.S
			else
	PIXELFLINGER_SRC_FILES += t32cb16blend.S		PIXELFLINGER_SRC_FILES += t32cb16blend.S
			PIXELFLINGER_SRC_FILES += col32cb16blend.S
			endif
	endif		endif

	ifeq ($(TARGET_ARCH),arm)		ifeq ($(TARGET_ARCH),arm)

libpixelflinger/col32cb16blend.S

0 → 100644

+78 −0

Original line number	Original line	Diff line number	Diff line
			/* libs/pixelflinger/col32cb16blend.S
			**
			** (C) COPYRIGHT 2009 ARM Limited.
			**
			** 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.
			**
			*/

			.text
			.align

			.global scanline_col32cb16blend_arm

			//
			// This function alpha blends a fixed color into a destination scanline, using
			// the formula:
			//
			// d = s + (((a + (a >> 7)) * d) >> 8)
			//
			// where d is the destination pixel,
			// s is the source color,
			// a is the alpha channel of the source color.
			//

			// r0 = destination buffer pointer
			// r1 = color value
			// r2 = count


			scanline_col32cb16blend_arm:
			push {r4-r10, lr} // stack ARM regs

			mov r5, r1, lsr #24 // shift down alpha
			mov r9, #0xff // create mask
			add r5, r5, r5, lsr #7 // add in top bit
			rsb r5, r5, #256 // invert alpha
			and r10, r1, #0xff // extract red
			and r12, r9, r1, lsr #8 // extract green
			and r4, r9, r1, lsr #16 // extract blue
			mov r10, r10, lsl #5 // prescale red
			mov r12, r12, lsl #6 // prescale green
			mov r4, r4, lsl #5 // prescale blue
			mov r9, r9, lsr #2 // create dest green mask

			1:
			ldrh r8, [r0] // load dest pixel
			subs r2, r2, #1 // decrement loop counter
			mov r6, r8, lsr #11 // extract dest red
			and r7, r9, r8, lsr #5 // extract dest green
			and r8, r8, #0x1f // extract dest blue

			smlabb r6, r6, r5, r10 // dest red * alpha + src red
			smlabb r7, r7, r5, r12 // dest green * alpha + src green
			smlabb r8, r8, r5, r4 // dest blue * alpha + src blue

			mov r6, r6, lsr #8 // shift down red
			mov r7, r7, lsr #8 // shift down green
			mov r6, r6, lsl #11 // shift red into 565
			orr r6, r7, lsl #5 // shift green into 565
			orr r6, r8, lsr #8 // shift blue into 565

			strh r6, [r0], #2 // store pixel to dest, update ptr
			bne 1b // if count != 0, loop

			pop {r4-r10, pc} // return

libpixelflinger/col32cb16blend_neon.S

0 → 100644

+153 −0

Original line number	Original line	Diff line number	Diff line
			/* libs/pixelflinger/col32cb16blend_neon.S
			**
			** (C) COPYRIGHT 2009 ARM Limited.
			**
			** 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.
			**
			*/

			.text
			.align

			.global scanline_col32cb16blend_neon

			//
			// This function alpha blends a fixed color into a destination scanline, using
			// the formula:
			//
			// d = s + (((a + (a >> 7)) * d) >> 8)
			//
			// where d is the destination pixel,
			// s is the source color,
			// a is the alpha channel of the source color.
			//
			// The NEON implementation processes 16 pixels per iteration. The remaining 0 - 15
			// pixels are processed in ARM code.
			//

			// r0 = destination buffer pointer
			// r1 = color pointer
			// r2 = count


			scanline_col32cb16blend_neon:
			push {r4-r11, lr} // stack ARM regs

			vmov.u16 q15, #256 // create alpha constant
			movs r3, r2, lsr #4 // calc. sixteens iterations
			vmov.u16 q14, #0x1f // create blue mask

			beq 2f // if r3 == 0, branch to singles

			vld4.8 {d0[], d2[], d4[], d6[]}, [r1] // load color into four registers
			// split and duplicate them, such that
			// d0 = 8 equal red values
			// d2 = 8 equal green values
			// d4 = 8 equal blue values
			// d6 = 8 equal alpha values
			vshll.u8 q0, d0, #5 // shift up red and widen
			vshll.u8 q1, d2, #6 // shift up green and widen
			vshll.u8 q2, d4, #5 // shift up blue and widen

			vshr.u8 d7, d6, #7 // extract top bit of alpha
			vaddl.u8 q3, d6, d7 // add top bit into alpha
			vsub.u16 q3, q15, q3 // invert alpha

			1:
			// This loop processes 16 pixels per iteration. In the comments, references to
			// the first eight pixels are suffixed with "0" (red0, green0, blue0),
			// the second eight are suffixed "1".
			// q8 = dst red0
			// q9 = dst green0
			// q10 = dst blue0
			// q13 = dst red1
			// q12 = dst green1
			// q11 = dst blue1

			vld1.16 {d20, d21, d22, d23}, [r0] // load 16 dest pixels
			vshr.u16 q8, q10, #11 // shift dst red0 to low 5 bits
			pld [r0, #63] // preload next dest pixels
			vshl.u16 q9, q10, #5 // shift dst green0 to top 6 bits
			vand q10, q10, q14 // extract dst blue0
			vshr.u16 q9, q9, #10 // shift dst green0 to low 6 bits
			vmul.u16 q8, q8, q3 // multiply dst red0 by src alpha
			vshl.u16 q12, q11, #5 // shift dst green1 to top 6 bits
			vmul.u16 q9, q9, q3 // multiply dst green0 by src alpha
			vshr.u16 q13, q11, #11 // shift dst red1 to low 5 bits
			vmul.u16 q10, q10, q3 // multiply dst blue0 by src alpha
			vshr.u16 q12, q12, #10 // shift dst green1 to low 6 bits
			vand q11, q11, q14 // extract dst blue1
			vadd.u16 q8, q8, q0 // add src red to dst red0
			vmul.u16 q13, q13, q3 // multiply dst red1 by src alpha
			vadd.u16 q9, q9, q1 // add src green to dst green0
			vmul.u16 q12, q12, q3 // multiply dst green1 by src alpha
			vadd.u16 q10, q10, q2 // add src blue to dst blue0
			vmul.u16 q11, q11, q3 // multiply dst blue1 by src alpha
			vshr.u16 q8, q8, #8 // shift down red0
			vadd.u16 q13, q13, q0 // add src red to dst red1
			vshr.u16 q9, q9, #8 // shift down green0
			vadd.u16 q12, q12, q1 // add src green to dst green1
			vshr.u16 q10, q10, #8 // shift down blue0
			vadd.u16 q11, q11, q2 // add src blue to dst blue1
			vsli.u16 q10, q9, #5 // shift & insert green0 into blue0
			vshr.u16 q13, q13, #8 // shift down red1
			vsli.u16 q10, q8, #11 // shift & insert red0 into blue0
			vshr.u16 q12, q12, #8 // shift down green1
			vshr.u16 q11, q11, #8 // shift down blue1
			subs r3, r3, #1 // decrement loop counter
			vsli.u16 q11, q12, #5 // shift & insert green1 into blue1
			vsli.u16 q11, q13, #11 // shift & insert red1 into blue1

			vst1.16 {d20, d21, d22, d23}, [r0]! // write 16 pixels back to dst
			bne 1b // if count != 0, loop

			2:
			ands r3, r2, #15 // calc. single iterations
			beq 4f // if r3 == 0, exit

			ldr r4, [r1] // load source color
			mov r5, r4, lsr #24 // shift down alpha
			add r5, r5, r5, lsr #7 // add in top bit
			rsb r5, r5, #256 // invert alpha
			and r11, r4, #0xff // extract red
			ubfx r12, r4, #8, #8 // extract green
			ubfx r4, r4, #16, #8 // extract blue
			mov r11, r11, lsl #5 // prescale red
			mov r12, r12, lsl #6 // prescale green
			mov r4, r4, lsl #5 // prescale blue

			3:
			ldrh r8, [r0] // load dest pixel
			subs r3, r3, #1 // decrement loop counter
			mov r6, r8, lsr #11 // extract dest red
			ubfx r7, r8, #5, #6 // extract dest green
			and r8, r8, #0x1f // extract dest blue

			smlabb r6, r6, r5, r11 // dest red * alpha + src red
			smlabb r7, r7, r5, r12 // dest green * alpha + src green
			smlabb r8, r8, r5, r4 // dest blue * alpha + src blue

			mov r6, r6, lsr #8 // shift down red
			mov r7, r7, lsr #8 // shift down green
			mov r6, r6, lsl #11 // shift red into 565
			orr r6, r7, lsl #5 // shift green into 565
			orr r6, r8, lsr #8 // shift blue into 565

			strh r6, [r0], #2 // store pixel to dest, update ptr
			bne 3b // if count != 0, loop
			4:

			pop {r4-r11, pc} // return

libpixelflinger/scanline.cpp

+47 −0

Original line number	Original line	Diff line number	Diff line
	@@ -80,6 +80,7 @@ static void scanline_perspective(context_t* c);
	static void scanline_perspective_single(context_t* c);		static void scanline_perspective_single(context_t* c);
	static void scanline_t32cb16blend(context_t* c);		static void scanline_t32cb16blend(context_t* c);
	static void scanline_t32cb16(context_t* c);		static void scanline_t32cb16(context_t* c);
			static void scanline_col32cb16blend(context_t* c);
	static void scanline_memcpy(context_t* c);		static void scanline_memcpy(context_t* c);
	static void scanline_memset8(context_t* c);		static void scanline_memset8(context_t* c);
	static void scanline_memset16(context_t* c);		static void scanline_memset16(context_t* c);
	@@ -93,6 +94,8 @@ static void rect_memcpy(context_t* c, size_t yc);

	extern "C" void scanline_t32cb16blend_arm(uint16_t, uint32_t, size_t);		extern "C" void scanline_t32cb16blend_arm(uint16_t, uint32_t, size_t);
	extern "C" void scanline_t32cb16_arm(uint16_t dst, uint32_t src, size_t ct);		extern "C" void scanline_t32cb16_arm(uint16_t dst, uint32_t src, size_t ct);
			extern "C" void scanline_col32cb16blend_neon(uint16_t dst, uint32_t col, size_t ct);
			extern "C" void scanline_col32cb16blend_arm(uint16_t *dst, uint32_t col, size_t ct);

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	@@ -111,6 +114,9 @@ static shortcut_t shortcuts[] = {
	{ { { 0x03010104, 0x00000077, { 0x00000A01, 0x00000000 } },		{ { { 0x03010104, 0x00000077, { 0x00000A01, 0x00000000 } },
	{ 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } },		{ 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0x0000003F } } },
	"565 fb, 8888 tx", scanline_t32cb16, init_y_noop },		"565 fb, 8888 tx", scanline_t32cb16, init_y_noop },
			{ { { 0x03515104, 0x00000077, { 0x00000000, 0x00000000 } },
			{ 0xFFFFFFFF, 0xFFFFFFFF, { 0xFFFFFFFF, 0xFFFFFFFF } } },
			"565 fb, 8888 fixed color", scanline_col32cb16blend, init_y_packed },
	{ { { 0x00000000, 0x00000000, { 0x00000000, 0x00000000 } },		{ { { 0x00000000, 0x00000000, { 0x00000000, 0x00000000 } },
	{ 0x00000000, 0x00000007, { 0x00000000, 0x00000000 } } },		{ 0x00000000, 0x00000007, { 0x00000000, 0x00000000 } } },
	"(nop) alpha test", scanline_noop, init_y_noop },		"(nop) alpha test", scanline_noop, init_y_noop },
	@@ -943,6 +949,8 @@ void init_y_packed(context_t* c, int32_t y0)
	uint8_t f = c->state.buffers.color.format;		uint8_t f = c->state.buffers.color.format;
	c->packed = ggl_pack_color(c, f,		c->packed = ggl_pack_color(c, f,
	c->shade.r0, c->shade.g0, c->shade.b0, c->shade.a0);		c->shade.r0, c->shade.g0, c->shade.b0, c->shade.a0);
			c->packed8888 = ggl_pack_color(c, GGL_PIXEL_FORMAT_RGBA_8888,
			c->shade.r0, c->shade.g0, c->shade.b0, c->shade.a0);
	c->iterators.y = y0;		c->iterators.y = y0;
	c->step_y = step_y__nop;		c->step_y = step_y__nop;
	// choose the rectangle blitter		// choose the rectangle blitter
	@@ -1253,6 +1261,45 @@ finish:

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

			void scanline_col32cb16blend(context_t* c)
			{
			int32_t x = c->iterators.xl;
			size_t ct = c->iterators.xr - x;
			int32_t y = c->iterators.y;
			surface_t* cb = &(c->state.buffers.color);
			union {
			uint16_t* dst;
			uint32_t* dst32;
			};
			dst = reinterpret_cast<uint16_t>(cb->data) + (x+(cb->stridey));

			#if ((ANDROID_CODEGEN >= ANDROID_CODEGEN_ASM) && defined(__arm__))
			#if defined(__ARM_HAVE_NEON) && BYTE_ORDER == LITTLE_ENDIAN
			scanline_col32cb16blend_neon(dst, &(c->packed8888), ct);
			#else // defined(__ARM_HAVE_NEON) && BYTE_ORDER == LITTLE_ENDIAN
			scanline_col32cb16blend_arm(dst, GGL_RGBA_TO_HOST(c->packed8888), ct);
			#endif // defined(__ARM_HAVE_NEON) && BYTE_ORDER == LITTLE_ENDIAN
			#else
			uint32_t s = GGL_RGBA_TO_HOST(c->packed8888);
			int sA = (s>>24);
			int f = 0x100 - (sA + (sA>>7));
			while (ct--) {
			uint16_t d = *dst;
			int dR = (d>>11)&0x1f;
			int dG = (d>>5)&0x3f;
			int dB = (d)&0x1f;
			int sR = (s >> ( 3))&0x1F;
			int sG = (s >> ( 8+2))&0x3F;
			int sB = (s >> (16+3))&0x1F;
			sR += (f*dR)>>8;
			sG += (f*dG)>>8;
			sB += (f*dB)>>8;
			*dst++ = uint16_t((sR<<11)\|(sG<<5)\|sB);
			}
			#endif

			}

	void scanline_t32cb16(context_t* c)		void scanline_t32cb16(context_t* c)
	{		{
	int32_t x = c->iterators.xl;		int32_t x = c->iterators.xl;