;****************************************************************************

;**

;** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

;** All rights reserved.

;** Contact: Nokia Corporation (qt-info@nokia.com)

;**

;** This file is part of the QtGui module of the Qt Toolkit.

;**

;** $QT_BEGIN_LICENSE:LGPL$

;** No Commercial Usage

;** This file contains pre-release code and may not be distributed.

;** You may use this file in accordance with the terms and conditions

;** contained in the Technology Preview License Agreement accompanying

;** this package.

;**

;** GNU Lesser General Public License Usage

;** Alternatively, this file may be used under the terms of the GNU Lesser

;** General Public License version 2.1 as published by the Free Software

;** Foundation and appearing in the file LICENSE.LGPL included in the

;** packaging of this file.  Please review the following information to

;** ensure the GNU Lesser General Public License version 2.1 requirements

;** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

;**

;** In addition, as a special exception, Nokia gives you certain additional

;** rights.  These rights are described in the Nokia Qt LGPL Exception

;** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

;**

;** If you have questions regarding the use of this file, please contact

;** Nokia at qt-info@nokia.com.

;**

;**

;**

;**

;**

;**

;**

;**

;** $QT_END_LICENSE$

;**

;****************************************************************************

;

;  W A R N I N G

;  -------------

;

; This file is not part of the Qt API.  It exists purely as an

; implementation detail.  This header file may change from version to

; version without notice, or even be removed.

;

; We mean it.

;

;-----------------------------------------------------------------------------

; Globals.

; Earch marcro expects that caller has loaded 0x800080 to r14.

;-----------------------------------------------------------------------------

ComponentHalf	EQU	0x800080

;-----------------------------------------------------------------------------

; ARM assembly implementations of accelerated graphics operations.

;

; Conventions:

;

; 	- r0 = Target buffer pointer

;	- r1 = Source buffer pointer

; 	- r2 = Length of the buffer to blend

;	- r3 = Constant alpha for source buffer

;

;-----------------------------------------------------------------------------

; A macro for transparently defining ARM functions

		MACRO

$func	Function

		AREA Function_$func, CODE

		GLOBAL $func

		ALIGN 4

		CODE32

$func

		MEND

;-----------------------------------------------------------------------------

; Armv6 boosted implementation of BYTE_MUL(...) function found in qdrawhelper_p.h.

;

;  @param dst	Destination register where to store the result

;  @param x     Value to multiply

;  @param a     Multiplicator byte

;  @param r14   Component half 0x800080

;

;  @note Trashes x, r8

;-----------------------------------------------------------------------------

		MACRO

		ByteMul $dst, $x, $a

		; static inline uint BYTE_MUL(uint x, uint a)

		; uint r8 = (x & 0xff00ff) * a + 0x800080

		uxtb16	r8, $x	; r8 = r8 & 0x00FF00FF

		mla		r8, r8, $a, r14

		; x = ((r >> 8) & 0xff00ff) * a + 0x800080

		uxtb16	$x, $x, ror #8

		mla		$x, $x, $a, r14

		; r8 = (r8 + ((r8 >> 8) & 0xff00ff) ) >> 8

		; r8 &= 0xff00ff

		uxtab16	r8, r8, r8, ror #8

		uxtb16	r8, r8, ror #8

		; x = x + ((x >>8) & 0xff00ff)

		uxtab16	$x, $x, $x, ror #8

		; x &= 0xff00ff00

		; x |= r8

		uxtb16	$x, $x, ror #8

		orr		$dst, r8, $x, lsl #8

		MEND

;-----------------------------------------------------------------------------

; Armv6 boosted implementation of INTERPOLATE_PIXEL_255(...) function found in

; qdrawhelper_p.h.

;

;  @param dst	Destination register where to store the result

;  @param x     First value to multiply

;  @param a		Multiplicator byte for first value

;  @param y     Second value to multiply

;  @param b     Multiplicator byte for second value

;  @param r14   Component half 0x800080

;

;

;  @note Trashes x, r8, r14

;-----------------------------------------------------------------------------

		MACRO

		InterpolatePixel255 $dst, $x, $a, $y, $b

		; static inline uint INTERPOLATE_PIXEL_255(uint x, uint a, uint y, uint b)

		; First calculate the parts where we need 0x800080

		; uint r8 = (((x & 0xff00ff) * a) + 0x800080)

		uxtb16	r8, $x	; r8 = r8 & 0x00FF00FF

		mla		r8, r8, $a, r14

		; x = ((((x >> 8) & 0xff00ff) * a) + 0x800080)

		uxtb16	$x, $x, ror #8

		mla		$x, $x, $a, r14

		; Now we are trashing r14 to free it for other purposes

		; uint r14 = (y & 0xff00ff) * b

		uxtb16	r14, $y	; r14 = y & 0x00FF00FF

		mul		r14, r14, $b

		; r8 = r8 + r14

		add		r8, r8, r14

		; r8 = (r8 + ((r8 >> 8) & 0xff00ff) ) >> 8

		; r8 &= 0xff00ff

		uxtab16	r8, r8, r8, ror #8

		uxtb16	r8, r8, ror #8

		; r14 = ((y >> 8) & 0xff00ff) * b

		uxtb16	r14, $y, ror #8	; r14 = ((y >> 8) & 0xFF00FF)

		mul		r14, r14, $b

		; x = x + r14

		add		$x, $x, r14

		; x = x + ((x >>8) & 0xff00ff)

		uxtab16	$x, $x, $x, ror #8

		; x &= 0xff00ff00

		; x |= r8

		uxtb16	$x, $x, ror #8

		orr		$dst, r8, $x, lsl #8

		MEND

;-----------------------------------------------------------------------------

;

;-----------------------------------------------------------------------------

		MACRO

$label	Blend4Pixels $BlendPixel

		; Blend first 4 pixels

		ldmia	r1!, {r4-r7}

		ldm		r0, {r9-r12}

b4p1_$label	$BlendPixel r9, r4, r3

b4p2_$label	$BlendPixel r10, r5, r3

b4p3_$label	$BlendPixel r11, r6, r3

b4p4_$label	$BlendPixel r12, r7, r3

		stmia 	r0!, {r9-r12}

		MEND

;-----------------------------------------------------------------------------

;

;-----------------------------------------------------------------------------

		MACRO

$label	Blend8Pixels $BlendPixel

b8p1_$label Blend4Pixels $BlendPixel

b8p2_$label Blend4Pixels $BlendPixel

		MEND

;-----------------------------------------------------------------------------

;

;-----------------------------------------------------------------------------

		MACRO

$label	Blend16Pixels $BlendPixel

b16p1_$label Blend8Pixels $BlendPixel

b16p2_$label Blend8Pixels $BlendPixel

		MEND

;-----------------------------------------------------------------------------

;

;-----------------------------------------------------------------------------

		MACRO

$label	Blend32Pixels $BlendPixel

b32p1_$label Blend16Pixels $BlendPixel

b32p2_$label Blend16Pixels $BlendPixel

		MEND

;-----------------------------------------------------------------------------

; A macro for source over compositing one row of pixels and saving the results

; to destination buffer.

;

; @param dest			Destination	buffer						(r0)

; @param src			Source buffer							(r1)

; @param length			Length									(r2)

; @param const_alpha	Constant alpha					  		(r3)

; @param r14 			Component Half (0x800080)		  		(r14)

;

;  @note Advances r0, r1

;  @note Trashes r2, r4-r12

;-----------------------------------------------------------------------------

		MACRO

$label	BlendRow $BlendPixel

		pld		[r1]

bloop_$label

		; Blend 32 pixels per loop iteration

		subs	r2, r2, #32

		bmi		b_remaining_$label

brp1_$label	Blend32Pixels $BlendPixel

		b		bloop_$label

b_remaining_$label

		; Remaining 31 pixels

		addmi	r2, r2, #32

		; Blend 16 pixels

		tst		r2, #16

		beq		b_remaining8_$label

brp2_$label Blend16Pixels $BlendPixel

b_remaining8_$label

		; Blend 8 pixels

		tst		r2, #8

		beq		b_remaining4_$label

brp3_$label Blend8Pixels $BlendPixel

b_remaining4_$label

		; Blend 4 pixels

		tst		r2, #4

		beq		b_remaining3_$label

brp4_$label Blend4Pixels $BlendPixel

b_remaining3_$label

		; Remaining 3 pixels

		tst		r2, #2

		beq		b_last_$label

		ldmia 	r1!, {r4-r5}

		ldm	  	r0,  {r9-r10}

brp5_$label	$BlendPixel r9, r4, r3

brp6_$label	$BlendPixel r10, r5, r3

		stmia 	r0!, {r9-r10}

b_last_$label

		tst		r2, #1

		beq		bexit_$label

		ldr		r4, [r1]

		ldr		r9, [r0]

bpl_$label	$BlendPixel r9, r4, r3

		str 	r9, [r0]

bexit_$label

		MEND

;-----------------------------------------------------------------------------

; A macro for source over compositing one row of pixels and saving the results

; to destination buffer. Restores all registers.

;

; @param dest			Destination	buffer						(r0)

; @param src			Source buffer							(r1)

; @param length			Length									(r2)

; @param const_alpha	Constant alpha					  		(r3)

; @param r14 			Component Half (0x800080)		  		(r14)

;

;  @note Advances r0, r1

;  @note Trashes r2, r4-r12

;-----------------------------------------------------------------------------

		MACRO

$label	BlendRowSafe $BlendPixel

		stmfd	sp!, {r0-r6} ; Preserves registers only up to r6

brs_$label  BlendRow $BlendPixel

		ldmfd	sp!, {r0-r6}

		MEND

;-----------------------------------------------------------------------------

; Pix Copy.

; NOTE! Cache line size of ARM1136JF-S and ARM1136J-S is 32 bytes (8 pixels).

;

; @param dst			Destination	pixels						(r0)

; @param src			Source pixels							(r1)

; @param len			Length									(r2)

;

;  @note Trashes r3-r10

;-----------------------------------------------------------------------------

		MACRO

$label	PixCpy $dst, $src, $len

		pld		[$src]

pcpy_loop_$label

		; Copy 8 pixels per loop iteration

		pld		[$src, #96]

		subs	$len, $len, #8

		ldmgeia	$src!, {r3-r10}

		stmgeia	$dst!, {r3-r10}

		bgt		pcpy_loop_$label

pcpy_remaining_$label

		; Copy up to 7 remaining pixels

		; Copy 4 pixels

		tst		$len, #4

		ldmneia	$src!, {r3-r6}

		stmneia	$dst!, {r3-r6}

		tst		$len, #2

		ldmneia	$src!, {r3-r4}

		stmneia	$dst!, {r3-r4}

		tst		$len, #1

		ldrne	r3, [$src]

		strne 	r3, [$dst]

		MEND

;-----------------------------------------------------------------------------

; General Pix Copy. Maximum 8 pixels at time. Restores all registers.

;

; @param dst			Destination	pixels						(r0)

; @param src			Source pixels							(r1)

; @param len			Length									(r2)

;

;  @note Trashes r3-r10

;-----------------------------------------------------------------------------

		MACRO

$label	PixCpySafe $dst, $src, $len

		stmfd	sp!, {r0-r6} ; Preserves registers only up to r6

pcs_$label  PixCpy $dst, $src, $len

		ldmfd	sp!, {r0-r6}		; pop

		MEND

;-----------------------------------------------------------------------------

; A macro for source over compositing one pixel and saving the result to

; dst register.

;

;  @param dst      Destination register, must contain destination pixel upon entry

;  @param src 	   Source register, must contain source pixel upon entry

;  @param const_alpha Constant source alpha

;  @param r14	   Component half 0x800080

;

;  @note Trashes const_alpha, r8

;-----------------------------------------------------------------------------

		MACRO

$label	PixelSourceOver $dst, $src, $const_alpha

		; Negate src and extract alpha

		mvn		$const_alpha, $src ; bitwise not

		uxtb	$const_alpha, $const_alpha, ror #24	; r3 = ((r3 & 0xFF000000) >> 24);

		;cmp		$const_alpha, #255	; test for full transparency ( negated )

		;beq		exit_$label

		cmp     $const_alpha, #0	            ; test for full opacity ( negated )

		moveq	$dst, $src

		beq		exit_$label

		ByteMul	$dst, $dst, $const_alpha

		add		$dst, $src, $dst

exit_$label

		MEND

;-----------------------------------------------------------------------------

; A macro for source over compositing one pixel and saving the result to

; dst register.

;

;  @param dst      Destination register, must contain destination pixel upon entry

;  @param src 	   Source register, must contain source pixel upon entry

;  @param const_alpha Constant source alpha

;  @param r14	   Component half 0x800080

;

;  @note Trashes src, const_alpha, r8

;-----------------------------------------------------------------------------

		MACRO

$label	PixelSourceOverConstAlpha $dst, $src, $const_alpha

		; store alpha because we are going to trash it

		stmfd	sp!, {$const_alpha}

		ByteMul	$src, $src, $const_alpha

		; Negate src and extract alpha

		mvn		$const_alpha, $src ; bitwise not

		uxtb	$const_alpha, $const_alpha, ror #24	; r3 = ((r3 & 0xFF000000) >> 24);

		ByteMul	$dst, $dst, $const_alpha

		add		$dst, $src, $dst

		; recover alpha

		ldmfd	sp!, {$const_alpha}

		MEND

;-----------------------------------------------------------------------------

; A macro for source over compositing one pixel and saving the result to

; a register.

;

;  @param dst      Destination register, must contain destination pixel upon entry

;  @param src 	   Source register, must contain source pixel upon entry

;  @param const_alpha Constant source alpha

;  @param r14	   Component half 0x800080

;

;  @note Trashes src, r8

;-----------------------------------------------------------------------------

		MACRO

$label	PixelSourceConstAlpha $dst, $src, $const_alpha

		; store r2 and r14 because we are going to trash them

		stmfd	sp!, {r2, r14}

		rsb		r2, $const_alpha, #255

		InterpolatePixel255 $dst, $src, $const_alpha, $dst, r2

		; recover r2 and r14

		ldmfd	sp!, {r2, r14}

		MEND

		END ; File end