diff options
| -rw-r--r-- | graphics/scaler.cpp | 57 | ||||
| -rw-r--r-- | graphics/scaler/hq2x_i386.asm | 253 | ||||
| -rw-r--r-- | graphics/scaler/hq3x_i386.asm | 132 |
3 files changed, 288 insertions, 154 deletions
diff --git a/graphics/scaler.cpp b/graphics/scaler.cpp index 0c7345f8a6..afee8be92d 100644 --- a/graphics/scaler.cpp +++ b/graphics/scaler.cpp @@ -53,17 +53,26 @@ extern "C" { #if !defined(_WIN32) && !defined(MACOSX) && !defined(__OS2__) #define RGBtoYUV _RGBtoYUV -#define LUT16to32 _LUT16to32 #define hqx_highbits _hqx_highbits #define hqx_lowbits _hqx_lowbits +#define hqx_low2bits _hqx_low2bits +#define hqx_low3bits _hqx_low3bits +#define hqx_greenMask _hqx_greenMask +#define hqx_redBlueMask _hqx_redBlueMask +#define hqx_green_redBlue_Mask _hqx_green_redBlue_Mask #endif #endif uint32 hqx_highbits = 0xF7DEF7DE; uint32 hqx_lowbits = 0x0821; +uint32 hqx_low2bits = 0x0C63; +uint32 hqx_low3bits = 0x1CE7; +uint32 hqx_greenMask = 0; +uint32 hqx_redBlueMask = 0; +uint32 hqx_green_redBlue_Mask = 0; -// FIXME/TODO: The following two tables suck up 512 KB. This is bad. +// FIXME/TODO: The RGBtoYUV table sucks up 256 KB. This is bad. // In addition we never free them... // // Note: a memory lookup table is *not* necessarily faster than computing @@ -72,14 +81,7 @@ uint32 hqx_lowbits = 0x0821; // systems, so main memory has to be accessed, which is about the worst thing // that can happen to code which tries to be fast... // -// So we should think about ways to get these smaller / removed. The LUT16to32 -// is only used by the HQX asm right now; maybe somebody can modify the code -// there to work w/o it (and do some benchmarking, too?). To do that, just -// do the conversion on the fly, or even do w/o it (as the C++ code manages to), -// by making different versions of the code based on gBitFormat (or by writing -// bit masks into registers which are computed based on gBitFormat). -// -// RGBtoYUV is also used by the C(++) version of the HQX code. Maybe we can +// So we should think about ways to get these smaller / removed. Maybe we can // use the same technique which is employed by our MPEG code to reduce the // size of the lookup tables at the cost of some additional computations? That // might actually result in a speedup, too, if done right (and the code code @@ -89,7 +91,6 @@ uint32 hqx_lowbits = 0x0821; // differences are likely to vary a lot between different architectures and // CPUs. uint32 *RGBtoYUV = 0; -uint32 *LUT16to32 = 0; } void InitLUT(Graphics::PixelFormat format) { @@ -101,18 +102,29 @@ void InitLUT(Graphics::PixelFormat format) { // Allocate the YUV/LUT buffers on the fly if needed. if (RGBtoYUV == 0) RGBtoYUV = (uint32 *)malloc(65536 * sizeof(uint32)); - if (LUT16to32 == 0) - LUT16to32 = (uint32 *)malloc(65536 * sizeof(uint32)); for (int color = 0; color < 65536; ++color) { format.colorToRGB(color, r, g, b); - LUT16to32[color] = (r << 16) | (g << 8) | b; - Y = (r + g + b) >> 2; u = 128 + ((r - b) >> 2); v = 128 + ((-r + 2 * g - b) >> 3); RGBtoYUV[color] = (Y << 16) | (u << 8) | v; } + +#ifdef USE_NASM + hqx_lowbits = (1 << format.rShift) | (1 << format.gShift) | (1 << format.bShift), + hqx_low2bits = (3 << format.rShift) | (3 << format.gShift) | (3 << format.bShift), + hqx_low3bits = (7 << format.rShift) | (7 << format.gShift) | (7 << format.bShift), + + hqx_highbits = format.RGBToColor(255,255,255) ^ hqx_lowbits; + + // FIXME: The following code only does the right thing + // if the color order is RGB or BGR, i.e., green is in the middle. + hqx_greenMask = format.RGBToColor(0,255,0); + hqx_redBlueMask = format.RGBToColor(255,0,255); + + hqx_green_redBlue_Mask = (hqx_greenMask << 16) | hqx_redBlueMask; +#endif } #endif @@ -121,24 +133,11 @@ void InitScalers(uint32 BitFormat) { gBitFormat = BitFormat; #ifndef DISABLE_HQ_SCALERS - #undef kHighBitsMask - #undef kLowBitsMask - if (gBitFormat == 555) { InitLUT(Graphics::createPixelFormat<555>()); -#ifdef USE_NASM - hqx_highbits = Graphics::ColorMasks<555>::kHighBitsMask; - hqx_lowbits = Graphics::ColorMasks<555>::kLowBitsMask & 0xFFFF; -#endif } if (gBitFormat == 565) { InitLUT(Graphics::createPixelFormat<565>()); -#ifdef USE_NASM - // The uint32 cast here is needed to silence an MSVC warning - // (warning C4245: '=': conversion from '' to 'uint32', signed/unsigned mismatch - hqx_highbits = (uint32)Graphics::ColorMasks<565>::kHighBitsMask; - hqx_lowbits = Graphics::ColorMasks<565>::kLowBitsMask & 0xFFFF; -#endif } #endif } @@ -146,9 +145,7 @@ void InitScalers(uint32 BitFormat) { void DestroyScalers(){ #ifndef DISABLE_HQ_SCALERS free(RGBtoYUV); - free(LUT16to32); RGBtoYUV = 0; - LUT16to32 = 0; #endif } diff --git a/graphics/scaler/hq2x_i386.asm b/graphics/scaler/hq2x_i386.asm index 5c826401ca..6dd97ed763 100644 --- a/graphics/scaler/hq2x_i386.asm +++ b/graphics/scaler/hq2x_i386.asm @@ -20,10 +20,14 @@ GLOBAL _hq2x_16 -EXTERN _LUT16to32 EXTERN _RGBtoYUV EXTERN _hqx_highbits EXTERN _hqx_lowbits +EXTERN _hqx_low2bits +EXTERN _hqx_low3bits +EXTERN _hqx_greenMask +EXTERN _hqx_redBlueMask +EXTERN _hqx_green_redBlue_Mask SECTION .bss linesleft resd 1 @@ -165,103 +169,186 @@ SECTION .text ; interpolate16_3<bitFormat,5,2,1> ; Mix three pixels with weight 5, 2, and 1, respectively: (c1*5+c2*2+c3)/8; %macro Interp6 3 - mov ecx, [_LUT16to32] - movd mm1, [ecx+eax*4] - mov edx, %2 - movd mm2, [ecx+edx*4] - mov edx, %3 - movd mm3, [ecx+edx*4] - punpcklbw mm1, [reg_blank] - punpcklbw mm2, [reg_blank] - punpcklbw mm3, [reg_blank] - pmullw mm1, [const5] - psllw mm2, 1 - paddw mm1, mm3 - paddw mm1, mm2 - psrlw mm1, 5 - packuswb mm1, [reg_blank] - movd edx, mm1 - shl dl, 2 - shr edx, 1 - shl dx, 3 - shr edx, 5 - mov %1, dx + ; Unpack eax to ecx and multiply by 5 + mov eax, [w5] + mov ecx, eax + shl ecx, 16 + or ecx, eax + and ecx, [_hqx_green_redBlue_Mask] + ; multiply c1 by 5 + ;imul ecx, 5 ; imul works, too, but might be slower on older systems? + mov edx, ecx + shl ecx, 2 + add ecx, edx + + ; unpack c2 to edx + mov eax, %2 + mov edx, eax + shl edx, 16 + or edx, eax + and edx, [_hqx_green_redBlue_Mask] + + ; add 2*c2 to c1*5 + add ecx, edx + add ecx, edx + + ; unpack c3 to edx + mov eax, %3 + mov edx, eax + shl edx, 16 + or edx, eax + and edx, [_hqx_green_redBlue_Mask] + + ; add c3 and 2*c2+c1*5, divide by 8, mask the result + add edx, ecx + shr edx, 3 + and edx, [_hqx_green_redBlue_Mask] + + ; finally, repack the mixed pixel + mov ecx, edx + shr ecx, 16 + or edx, ecx + + mov %1, dx %endmacro ; interpolate16_3<bitFormat,6,1,1> ; Mix three pixels with weight 6, 1, and 1, respectively: (c1*6+c2+c3)/8; %macro Interp7 3 - mov ecx, [_LUT16to32] - movd mm1, [ecx+eax*4] - mov edx, %2 - movd mm2, [ecx+edx*4] - mov edx, %3 - movd mm3, [ecx+edx*4] - punpcklbw mm1, [reg_blank] - punpcklbw mm2, [reg_blank] - punpcklbw mm3, [reg_blank] - pmullw mm1, [const6] - paddw mm2, mm3 - paddw mm1, mm2 - psrlw mm1, 5 - packuswb mm1, [reg_blank] - movd edx, mm1 - shl dl, 2 - shr edx, 1 - shl dx, 3 - shr edx, 5 - mov %1, dx + ; Unpack eax to ecx and multiply by 6 + mov eax, [w5] + mov ecx, eax + shl ecx, 16 + or ecx, eax + and ecx, [_hqx_green_redBlue_Mask] + ; multiply c1 by 6 + ;imul ecx, 6 ; imul works, too, but might be slower on older systems? + mov edx, ecx + add ecx, ecx + add ecx, edx + add ecx, ecx + + ; unpack c2 to edx + mov eax, %2 + mov edx, eax + shl edx, 16 + or edx, eax + and edx, [_hqx_green_redBlue_Mask] + + ; add c2 to c1*3 + add ecx, edx + + ; unpack c3 to edx + mov eax, %3 + mov edx, eax + shl edx, 16 + or edx, eax + and edx, [_hqx_green_redBlue_Mask] + + ; add c3 and c2+c1*3, divide by 8, mask the result + add edx, ecx + shr edx, 3 + and edx, [_hqx_green_redBlue_Mask] + + ; finally, repack the mixed pixel + mov ecx, edx + shr ecx, 16 + or edx, ecx + + mov %1, dx %endmacro ; interpolate16_3<bitFormat,2,3,3> ; Mix three pixels with weight 2, 3, and 3, respectively: (c1*2+(c2+c3)*3)/8; %macro Interp9 3 - mov ecx, [_LUT16to32] - movd mm1, [ecx+eax*4] - mov edx, %2 - movd mm2, [ecx+edx*4] - mov edx, %3 - movd mm3, [ecx+edx*4] - punpcklbw mm1, [reg_blank] - punpcklbw mm2, [reg_blank] - punpcklbw mm3, [reg_blank] - psllw mm1, 1 - paddw mm2, mm3 - pmullw mm2, [const3] - paddw mm1, mm2 - psrlw mm1, 5 - packuswb mm1, [reg_blank] - movd edx, mm1 - shl dl, 2 - shr edx, 1 - shl dx, 3 - shr edx, 5 - mov %1, dx + ; unpack c2 + mov eax, %2 + mov edx, eax + shl edx, 16 + or edx, eax + and edx, [_hqx_green_redBlue_Mask] + + ; unpack c3 + mov eax, %3 + mov ecx, eax + shl ecx, 16 + or ecx, eax + and ecx, [_hqx_green_redBlue_Mask] + + ; sum c2 and c3 + add edx, ecx + + ; multiply (c2+c3) by 3 + ;imul edx, 3 ; imul works, too, but might be slower on older systems? + mov ecx, edx + add edx, edx + add edx, ecx + + ; Restore eax, unpack it and multiply by 2 + mov eax, [w5] + mov ecx, eax + shl ecx, 16 + or ecx, eax + and ecx, [_hqx_green_redBlue_Mask] + add ecx, ecx ; multiply by 2 + + ; sum 2*eax + 3*(c2+c3), divide by 8, mask the result + add edx, ecx + shr edx, 3 + and edx, [_hqx_green_redBlue_Mask] + + ; finally, repack the mixed pixel + mov ecx, edx + shr ecx, 16 + or edx, ecx + + mov %1, dx %endmacro ; interpolate16_3<bitFormat,14,1,1> ; Mix three pixels with weight 14, 1, and 1, respectively: (c1*14+c2+c3)/16; %macro Interp10 3 - mov ecx, [_LUT16to32] - movd mm1, [ecx+eax*4] - mov edx, %2 - movd mm2, [ecx+edx*4] - mov edx, %3 - movd mm3, [ecx+edx*4] - punpcklbw mm1, [reg_blank] - punpcklbw mm2, [reg_blank] - punpcklbw mm3, [reg_blank] - pmullw mm1, [const14] - paddw mm2, mm3 - paddw mm1, mm2 - psrlw mm1, 6 - packuswb mm1, [reg_blank] - movd edx, mm1 - shl dl, 2 - shr edx, 1 - shl dx, 3 - shr edx, 5 - mov %1, dx + ; Unpack eax to ecx and multiply by 14 + mov eax, [w5] + mov ecx, eax + shl ecx, 16 + or ecx, eax + and ecx, [_hqx_green_redBlue_Mask] + ; multiply c1 by 14 + ;imul ecx, 14 ; imul works, too, but might be slower on older systems? + mov edx, ecx + shl ecx, 3 + sub ecx, edx + add ecx, ecx + + ; unpack c2 to edx + mov eax, %2 + mov edx, eax + shl edx, 16 + or edx, eax + and edx, [_hqx_green_redBlue_Mask] + + ; add c2 to c1*14 + add ecx, edx + + ; unpack c3 to edx + mov eax, %3 + mov edx, eax + shl edx, 16 + or edx, eax + and edx, [_hqx_green_redBlue_Mask] + + ; add c3 and c2+c1*14, divide by 16, mask the result + add edx, ecx + shr edx, 4 + and edx, [_hqx_green_redBlue_Mask] + + ; finally, repack the mixed pixel + mov ecx, edx + shr ecx, 16 + or edx, ecx + + mov %1, dx %endmacro %macro PIXEL00_0 0 diff --git a/graphics/scaler/hq3x_i386.asm b/graphics/scaler/hq3x_i386.asm index b13fc10f0d..1b470f5663 100644 --- a/graphics/scaler/hq3x_i386.asm +++ b/graphics/scaler/hq3x_i386.asm @@ -20,10 +20,14 @@ GLOBAL _hq3x_16 -EXTERN _LUT16to32 EXTERN _RGBtoYUV EXTERN _hqx_highbits EXTERN _hqx_lowbits +EXTERN _hqx_low2bits +EXTERN _hqx_low3bits +EXTERN _hqx_greenMask +EXTERN _hqx_redBlueMask +EXTERN _hqx_green_redBlue_Mask SECTION .bss linesleft resd 1 @@ -41,6 +45,8 @@ w7 resd 1 w8 resd 1 w9 resd 1 +tmpData resd 1 + SECTION .data reg_blank dd 0,0 @@ -162,48 +168,87 @@ SECTION .text ; interpolate16_2<bitFormat,7,1> ; Mix two pixels with weight 7 and 1, respectively: (c1*7+c2)/8; %macro Interp3 2 - mov ecx, [_LUT16to32] - movd mm1, [ecx+eax*4] - mov edx, %2 - movd mm2, [ecx+edx*4] - punpcklbw mm1, [reg_blank] - punpcklbw mm2, [reg_blank] - pmullw mm1, [const7] - paddw mm1, mm2 - psrlw mm1, 5 - packuswb mm1, [reg_blank] - movd edx, mm1 - shl dl, 2 - shr edx, 1 - shl dx, 3 - shr edx, 5 - mov %1, dx + ; ((p1&kLowBitsMask)<<2) + mov ecx,eax + and ecx,[_hqx_lowbits] + shl ecx,2 + + ; + ((p1&kLow2Bits)<<1) + mov edx,eax + and edx,[_hqx_low2bits] + shl edx,1 + add ecx,edx + + ; + (p1&kLow3Bits) + mov edx,eax + and edx,[_hqx_low3bits] + add ecx,edx + + ; + (p2&kLow3Bits) + mov edx,%2 + and edx,[_hqx_low3bits] + add ecx,edx + + ; & kLow3Bits -> ecx + and ecx,[_hqx_low3bits] + + ; compute ((p1*7+p2) - ecx) >> 3; + mov edx,eax + shl edx,3 + sub edx,eax + sub edx,ecx + mov ecx,%2 + add edx,ecx + shr edx,3 + + mov %1,dx %endmacro ; interpolate16_3<bitFormat,2,7,7> ; Mix three pixels with weight 2, 7, and 7, respectively: (c1*2+(c2+c3)*7)/16; %macro Interp4 3 - mov ecx, [_LUT16to32] - movd mm1, [ecx+eax*4] - mov edx, %2 - movd mm2, [ecx+edx*4] - mov edx, %3 - movd mm3, [ecx+edx*4] - punpcklbw mm1, [reg_blank] - punpcklbw mm2, [reg_blank] - punpcklbw mm3, [reg_blank] - psllw mm1, 1 - paddw mm2, mm3 - pmullw mm2, [const7] - paddw mm1, mm2 - psrlw mm1, 6 - packuswb mm1, [reg_blank] - movd edx, mm1 - shl dl, 2 - shr edx, 1 - shl dx, 3 - shr edx, 5 - mov %1, dx + ; unpack c2 + mov eax, %2 + mov edx, eax + shl edx, 16 + or edx, eax + and edx, [_hqx_green_redBlue_Mask] + + ; unpack c3 + mov eax, %3 + mov ecx, eax + shl ecx, 16 + or ecx, eax + and ecx, [_hqx_green_redBlue_Mask] + + ; sum c2 and c3 + add edx, ecx + + ; multiply (c2+c3) by 7 + ;imul edx, 7 ; imul works, too, but might be slower on older systems? + mov ecx, edx + shl edx, 3 + sub edx, ecx + + ; Restore eax, unpack it and multiply by 2 + mov eax, [w5] + mov ecx, eax + shl ecx, 16 + or ecx, eax + and ecx, [_hqx_green_redBlue_Mask] + add ecx, ecx ; multiply by 2 + + ; sum 2*eax + 7*(c2+c3), divide by 16, mask the result + add edx, ecx + shr edx, 4 + and edx, [_hqx_green_redBlue_Mask] + + ; finally, repack the mixed pixel + mov ecx, edx + shr ecx, 16 + or edx, ecx + + mov %1, dx %endmacro ; interpolate16_2<bitFormat,1,1> @@ -211,9 +256,14 @@ SECTION .text %macro Interp5 3 mov edx,%2 mov ecx,%3 - and edx,[_hqx_highbits] - and ecx,[_hqx_highbits] - add edx,ecx + + xor edx,ecx ; xor pixels + mov [tmpData],edx ; store tmp result + xor edx,ecx ; restore original value of edx (avoids a reload) + add edx,ecx ; sum pixels + mov ecx,[tmpData] + and ecx,[_hqx_lowbits] + sub edx,ecx shr edx,1 mov %1,dx %endmacro |