diff -r 000000000000 -r 05e9090e2422 skins/AknSkins/rlpluginsrc/asm_versions/asm_contrast.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/skins/AknSkins/rlpluginsrc/asm_versions/asm_contrast.cpp Thu Dec 17 09:14:12 2009 +0200 @@ -0,0 +1,393 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ +/* +* ============================================================================ +* Name : WOW Testbench, assembler version of make convolution bitmaps +* ============================================================================ +*/ + +// INCLUDE FILES +#include +#include + +#include "fx_asm_versions.h" + + +void AProcessContrast( const CFbsBitmap& aTarget, + const CFbsBitmap& aSource, + const TInt aAdjustment, + const TDisplayMode aMode ) + { + // ScanLineLength returns bytes, but width must match the displaymode + TInt width = CFbsBitmap::ScanLineLength( aSource.SizeInPixels().iWidth, + aSource.DisplayMode() ); + if (aMode == EColor16MU) + { + width = width / 4; + } + else + { + width = width / 2; + } + TInt height = aSource.SizeInPixels().iHeight; + + TInt pixelCount = width * height; + + aTarget.LockHeap( ETrue ); // Lock the global bitmap buffer + TUint* targetAddr = reinterpret_cast( aTarget.DataAddress() ); + TUint* sourceAddr = reinterpret_cast( aSource.DataAddress() ); + + if (aMode == EColor16MU) + { + ADoContrast16MU(targetAddr, sourceAddr, pixelCount, aAdjustment); + } + else + { + ADoContrast64K(targetAddr, sourceAddr, pixelCount, aAdjustment); + } + + aTarget.UnlockHeap( ETrue ); // Unlock the global bitmap heap + } + + +#pragma warning(disable : 4100) +#ifndef ARM_VERSION +__NAKED__ void ADoContrast64K( TUint*, TUint*, TInt, TInt ) + { +// return; +#else +__NAKED__ void ADoContrast64K( TUint* aBaseT, + TUint* aBaseS, + TInt aPixelCount, + TInt aAdjustment) + { +// Parameters: +// r0 = target, +// r1 = source, +// r2 = pixelcount, +// r3 = contrast adjustment parameter +// pixel format rrrrrggggggbbbbb (565) + + PUSH {r0-r12,lr} + + SUB r12, r3, r3, LSL #7 // r12 = -(127 * aAdjustment) + ADD r11, r3, #0xff // r11 = 255 + aAdjustment + + MOV r3, #0x1f // used in saturation for red and blue + MOV r4, #0x3f // for green + + AND r10, r2, #0x3 // save last pixels + PUSH {r10} // r10 used in loop + LSRS r2, r2, #2 // we process 4 pixel at time, so divide counter by 4 + BEQ processlastpixels64k // less than 4 pixels to process + +processloop64k + + LDMIA r1!, {r5-r6} // load 4 pixels to r5-r6 + + // first process upper 16 bits of r5 + AND r7, r3, r5, LSR #27 // r7 = red? + LSL r7, r7, #3 // convert to 8 bits + MLA r7, r11, r7, r12 // r7 = r7 * r11 + r12 + AND lr, r4, r5, LSR #21 // lr = green? + LSL lr, lr, #2 // convert to 8 bits + MLA lr, r11, lr, r12 // r8 = r8 * r11 + r12 + AND r9, r3, r5, LSR #16 // r9 = blue? + LSL r9, r9, #3 // convert to 8 bits + MLA r9, r11, r9, r12 // r9 = r9 * r11 + r12 + LSR r10, r7, #11 // r10 = r7 >> 8+3 + CMP r10, #0x1f // if r10 > 0x1f (max red) + BICGT r10, r3, r7, ASR #31 // then r10 = 0x1f and not sign bit of r7 + LSR r7, lr, #10 // r7 = lr >> 8+2 + CMP r7, #0x3f // if r7 > 0x3f + BICGT r7, r4, lr, ASR #31 // then r7 = 0x3f and not sign bit of r8 + LSR lr, r9, #11 // lr = r9 >> 8+3 + CMP lr, #0x1f // if lr > 0x1f + BICGT lr, r3, r9, ASR #31 // then lr = 0x1f and not sign bit of r9 + ORR lr, lr, r7, LSL #5 // lr now has green and blue + ORR lr, lr, r10, LSL #11 // and red + + // second process lower 16 bits of r5 + AND r7, r3, r5, LSR #11 // r7 = red? + LSL r7, r7, #3 // convert to 8 bits + MLA r7, r11, r7, r12 // r7 = r7 * r11 + r12 + AND r8, r4, r5, LSR #5 // r8 = green? + LSL r8, r8, #2 // convert to 8 bits + MLA r8, r11, r8, r12 // r8 = r8 * r11 + r12 + AND r9, r3, r5 // r9 = blue? + LSL r9, r9, #3 // convert to 8 bits + MLA r9, r11, r9, r12 // r9 = r9 * r11 + r12 + LSR r10, r7, #11 // r10 = r7 >> 8+3 + CMP r10, #0x1f // if r10 > 0x1f (max red) + BICGT r10, r3, r7, ASR #31 // then r10 = 0x1f and not sign bit of r7 + LSR r7, r8, #10 // r7 = r8 >> 8+2 + CMP r7, #0x3f // if r7 > 0x3f + BICGT r7, r4, r8, ASR #31 // then r7 = 0x3f and not sign bit of r8 + LSR r5, r9, #11 // r5 = r9 >> 8+3 + CMP r5, #0x1f // if r5 > 0x1f + BICGT r5, r3, r9, ASR #31 // then r5 = 0x1f and not sign bit of r9 + ORR r5, r5, r7, LSL #5 // r5 now has green and blue + ORR r5, r5, r10, LSL #11 // and red + ORR r5, r5, lr, LSL #16 // combine r5 with lr (upper pixel) + + // third process upper 16 bits of r6 + AND r7, r3, r6, LSR #27 // r7 = red? + LSL r7, r7, #3 // convert to 8 bits + MLA r7, r11, r7, r12 // r7 = r7 * r11 + r12 + AND lr, r4, r6, LSR #21 // lr = green? + LSL lr, lr, #2 // convert to 8 bits + MLA lr, r11, lr, r12 // r8 = r8 * r11 + r12 + AND r9, r3, r6, LSR #16 // r9 = blue? + LSL r9, r9, #3 // convert to 8 bits + MLA r9, r11, r9, r12 // r9 = r9 * r11 + r12 + LSR r10, r7, #11 // r10 = r7 >> 8+3 + CMP r10, #0x1f // if r10 > 0x1f (max red) + BICGT r10, r3, r7, ASR #31 // then r10 = 0x1f and not sign bit of r7 + LSR r7, lr, #10 // r7 = lr >> 8+2 + CMP r7, #0x3f // if r7 > 0x3f + BICGT r7, r4, lr, ASR #31 // then r7 = 0x3f and not sign bit of r8 + LSR lr, r9, #11 // lr = r9 >> 8+3 + CMP lr, #0x1f // if lr > 0x1f + BICGT lr, r3, r9, ASR #31 // then lr = 0x1f and not sign bit of r9 + ORR lr, lr, r7, LSL #5 // lr now has green and blue + ORR lr, lr, r10, LSL #11 // and red + + // last process lower 16 bits of r6 + AND r7, r3, r6, LSR #11 // r7 = red? + LSL r7, r7, #3 // convert to 8 bits + MLA r7, r11, r7, r12 // r7 = r7 * r11 + r12 + AND r8, r4, r6, LSR #5 // r8 = green? + LSL r8, r8, #2 // convert to 8 bits + MLA r8, r11, r8, r12 // r8 = r8 * r11 + r12 + AND r9, r3, r6 // r9 = blue? + LSL r9, r9, #3 // convert to 8 bits + MLA r9, r11, r9, r12 // r9 = r9 * r11 + r12 + LSR r10, r7, #11 // r10 = r7 >> 8+3 + CMP r10, #0x1f // if r10 > 0x1f (max red) + BICGT r10, r3, r7, ASR #31 // then r10 = 0x1f and not sign bit of r7 + LSR r7, r8, #10 // r7 = r8 >> 8+2 + CMP r7, #0x3f // if r7 > 0x3f + BICGT r7, r4, r8, ASR #31 // then r7 = 0x3f and not sign bit of r8 + LSR r6, r9, #11 // r6 = r9 >> 8+3 + CMP r6, #0x1f // if r6 > 0x1f + BICGT r6, r3, r9, ASR #31 // then r6 = 0x1f and not sign bit of r9 + ORR r6, r6, r7, LSL #5 // r6 now has green and blue + ORR r6, r6, r10, LSL #11 // and red + ORR r6, r6, lr, LSL #16 // combine r6 with lr (upper pixel) + + STMIA r0!, {r5-r6} // store 4 pixels from r5-r6 + + SUBS r2, r2, #1 + BNE processloop64k + +processlastpixels64k + + POP {r10} + CMP r10, #0 + BEQ processend64k // no more pixels to process + +processlastloop64k + + LDRH r5, [r1], #2 // load pixel to r5 + AND r7, r3, r5, LSR #11 // r7 = red? + LSL r7, r7, #3 // convert to 8 bits + MLA r7, r11, r7, r12 // r7 = r7 * r11 + r12 + AND r8, r4, r5, LSR #5 // r8 = green? + LSL r8, r8, #2 // convert to 8 bits + MLA r8, r11, r8, r12 // r8 = r8 * r11 + r12 + AND r9, r3, r5 // r9 = blue? + LSL r9, r9, #3 // convert to 8 bits + MLA r9, r11, r9, r12 // r9 = r9 * r11 + r12 + LSR r6, r7, #11 // r6 = r7 >> 8+3 + CMP r6, #0x1f // if r6 > 0x1f (max red) + BICGT r6, r3, r7, ASR #31 // then r6 = 0x1f and not sign bit of r7 + LSR r7, r8, #10 // r7 = r8 >> 8+2 + CMP r7, #0x3f // if r7 > 0x3f + BICGT r7, r4, r8, ASR #31 // then r7 = 0x3f and not sign bit of r8 + LSR r5, r9, #11 // r5 = r9 >> 8+3 + CMP r5, #0x1f // if r5 > 0x1f + BICGT r5, r3, r9, ASR #31 // then r5 = 0x1f and not sign bit of r9 + ORR r5, r5, r7, LSL #5 // r5 now has green and blue + ORR r5, r5, r6, LSL #11 // and red + STRH r5, [r0], #2 // write pixel to target + + SUBS r10, r10, #1 + BNE processlastloop64k + +processend64k + + POP {r0-r12,pc} + //BX lr +#endif // ARM_VERSION + } + + +#ifndef ARM_VERSION +__NAKED__ void ADoContrast16MU( TUint*, TUint*, TInt, TInt ) + { + +// return; +#else +__NAKED__ void ADoContrast16MU( TUint* aBaseT, + TUint* aBaseS, + TInt aPixelCount, + TInt aAdjustment) + { +// Parameters: +// r0 = target, +// r1 = source, +// r2 = pixelcount, +// r3 = contrast adjustment parameter + + PUSH {r0-r12,lr} + + SUB r12, r3, r3, LSL #7 // r12 = -(127 * aAdjustment) + ADD r11, r3, #0xff // r11 = 255 + aAdjustment + + MOV lr, #0xff // used in saturation + + AND r10, r2, #0x3 // save last pixels + LSRS r2, r2, #2 // we process 4 pixel at time, so divide counter by 4 + BEQ processlastpixels // less than 4 pixels to process + +processloop + + LDMIA r1!, {r4-r7} // load 4 pixels to r4-r7 + + AND r8, lr, r4, LSR #16 + MLA r8, r11, r8, r12 // r8 = r8 * r11 + r12 + AND r9, lr, r4, LSR #8 + MLA r9, r11, r9, r12 + AND r4, r4, #0xff // r4 = blue? + MLA r4, r11, r4, r12 + MOV r3, r8, LSR #8 // r3 = r8 >> 8 + CMP r3, #0xff // if r8 was negative or shifted r8 > 255 + BICGT r3, lr, r8, ASR #31 // then r3 is either 0 or 255 + LSR r8, r9, #8 + CMP r8, #0xff + BICGT r8, lr, r9, ASR #31 + LSR r9, r4, #8 + CMP r9, #0xff + BICGT r9, lr, r4, ASR #31 + ORR r4, r9, #0xff000000 // set blue and alpha + ORR r4, r4, r3, LSL #16 // combine blue with red + ORR r4, r4, r8, LSL #8 // combine blue+red with green + + AND r8, lr, r5, LSR #16 + MLA r8, r11, r8, r12 // r8 = r8 * r11 + r12 + AND r9, lr, r5, LSR #8 // r9 = green? + MLA r9, r11, r9, r12 + AND r5, r5, #0xff // r5 = blue? + MLA r5, r11, r5, r12 + MOV r3, r8, LSR #8 // r3 = r8 >> 8 + CMP r3, #0xff // if r8 was negative or shifted r8 > 255 + BICGT r3, lr, r8, ASR #31 // then r3 is either 0 or 255 + LSR r8, r9, #8 + CMP r8, #0xff + BICGT r8, lr, r9, ASR #31 + LSR r9, r5, #8 + CMP r9, #0xff + BICGT r9, lr, r5, ASR #31 + ORR r5, r9, #0xff000000 // set blue and alpha + ORR r5, r5, r3, LSL #16 // combine blue with red + ORR r5, r5, r8, LSL #8 // combine blue+red with green + + AND r8, lr, r6, LSR #16 + MLA r8, r11, r8, r12 // r8 = r8 * r11 + r12 + AND r9, lr, r6, LSR #8 // r9 = green? + MLA r9, r11, r9, r12 + AND r6, r6, #0xff // r6 = blue? + MLA r6, r11, r6, r12 + MOV r3, r8, LSR #8 // r3 = r8 >> 8 + CMP r3, #0xff // if r8 was negative or shifted r8 > 255 + BICGT r3, lr, r8, ASR #31 // then r3 is either 0 or 255 + LSR r8, r9, #8 + CMP r8, #0xff + BICGT r8, lr, r9, ASR #31 + LSR r9, r6, #8 + CMP r9, #0xff + BICGT r9, lr, r6, ASR #31 + ORR r6, r9, #0xff000000 // set blue and alpha + ORR r6, r6, r3, LSL #16 // combine blue with red + ORR r6, r6, r8, LSL #8 // combine blue+red with green + + AND r8, lr, r7, LSR #16 + MLA r8, r11, r8, r12 // r8 = r8 * r11 + r12 + AND r9, lr, r7, LSR #8 // r9 = green? + MLA r9, r11, r9, r12 + AND r7, r7, #0xff // r7 = blue? + MLA r7, r11, r7, r12 + MOV r3, r8, LSR #8 // r3 = r8 >> 8 + CMP r3, #0xff // if r8 was negative or shifted r8 > 255 + BICGT r3, lr, r8, ASR #31 // then r3 is either 0 or 255 + LSR r8, r9, #8 + CMP r8, #0xff + BICGT r8, lr, r9, ASR #31 + LSR r9, r7, #8 + CMP r9, #0xff + BICGT r9, lr, r7, ASR #31 + ORR r7, r9, #0xff000000 // set blue and alpha + ORR r7, r7, r3, LSL #16 // combine blue with red + ORR r7, r7, r8, LSL #8 // combine blue+red with green + + STMIA r0!, {r4-r7} // store 4 pixels from r4-r7 + + SUBS r2, r2, #1 + BNE processloop + +processlastpixels + + CMP r10, #0 + BEQ processend // no more pixels to process + +processlastloop + + LDR r4, [r1], #4 + + AND r8, lr, r4, LSR #16 + MLA r8, r11, r8, r12 // r8 = r8 * r11 + r12 + AND r9, lr, r4, LSR #8 + MLA r9, r11, r9, r12 + AND r4, r4, #0xff // r4 = blue? + MLA r4, r11, r4, r12 + MOV r3, r8, LSR #8 // r3 = r8 >> 8 + CMP r3, #0xff // if r8 was negative or shifted r8 > 255 + BICGT r3, lr, r8, ASR #31 // then r3 is either 0 or 255 + LSR r8, r9, #8 + CMP r8, #0xff + BICGT r8, lr, r9, ASR #31 + LSR r9, r4, #8 + CMP r9, #0xff + BICGT r9, lr, r4, ASR #31 + ORR r4, r9, #0xff000000 // set blue and alpha + ORR r4, r4, r3, LSL #16 // combine blue with red + ORR r4, r4, r8, LSL #8 // combine blue+red with green + + STR r4, [r0], #4 + SUBS r10, r10, #1 + BNE processlastloop + +processend + + POP {r0-r12,pc} + //BX lr +#endif // ARM_VERSION + } + +#pragma warning(default : 4100) + +// End of File