Cool_Tools/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-19 19:25:52 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
09cb3a54ed
winamp/Src/Wasabi/api/wnd/bitmap.cpp

1585 lines
38 KiB
C++
Raw Normal View History

Initial community commit
2024-09-24 14:54:57 +02:00
#include <precomp.h>
//#define NO_SIMPLEFASTMODE
#include <api/imgldr/api_imgldr.h>
#include <api/wnd/blending.h>
#include "bitmap.h"
#ifndef _NOSTUDIO
#include <api/api.h>
#endif
#include <bfc/std.h>
#include <api/wnd/bltcanvas.h>
#include <api/memmgr/memmgrapi.h>
#if !defined(WIN32) && !defined(LINUX)
#error port me!
#endif
#define ERRORBMP L"wasabi.bitmapnotfound"
#define HARDERRORBMP L"xml/wasabi/window/error.png"
// do not define NO_MMX in this file. :)
#ifndef NO_MMX
#ifdef WIN32
#define MMX_CONST const
#else
#define MMX_CONST
#endif
static unsigned int MMX_CONST SkinBitmap_mmx_revn2[2]={0x01000100,0x01000100};
static unsigned int MMX_CONST SkinBitmap_mmx_zero[2];
static unsigned int MMX_CONST SkinBitmap_mmx_one[2]={1,0};
#define HAS_MMX Blenders::MMX_AVAILABLE()
#else
//NO_MMX defined
#define HAS_MMX 0
#endif
#ifndef _NOSTUDIO
#ifdef WASABI_COMPILE_IMGLDR
SkinBitmap::SkinBitmap(HINSTANCE hInstance, int id, const wchar_t *forcegroup)
{
bitmapname = L"";
subimage_w=-1;
subimage_h=-1;
x_offset=-1;
y_offset=-1;
fullimage_w=fullimage_h=0;
has_alpha = 0;
ASSERT(hInstance != NULL);
ownbits=1;
fromskin = 0;
bits=WASABI_API_IMGLDR->imgldr_makeBmp(hInstance, id,&has_alpha,&fullimage_w,&fullimage_h, forcegroup);
last_failed = 0;
#ifdef WASABI_COMPILE_SKIN
if (bits == NULL)
{
//last_failed = 1;
//TODO: bits = WASABI_API_IMGLDR->imgldr_requestSkinBitmap(ERRORBMP, &has_alpha, &x_offset, &y_offset, &subimage_w, &subimage_h, &fullimage_w, &fullimage_h,_cached);
}
#endif
if (bits == NULL)
{
last_failed = 1;
bits = WASABI_API_IMGLDR->imgldr_makeBmp(HARDERRORBMP, &has_alpha, &fullimage_w, &fullimage_h);
}
}
#endif
#endif
// TODO: benski> make sure this works :)
SkinBitmap::SkinBitmap(ARGB32 *_bits, int w, int h)
{
subimage_w=-1;
subimage_h=-1;
x_offset=-1;
y_offset=-1;
bitmapname = L"";
fullimage_w=fullimage_h=0;
has_alpha = 1;
ownbits=0;
bits = _bits;
fromskin = 0;
last_failed = 0;
}
// TODO: benski> could we be using GetDIBits here?
void SkinBitmap::bmpToBits(HBITMAP hbmp, HDC defaultDC)
{
#ifdef WIN32
if (hbmp && !bits)
{
BITMAPINFO srcbmi={0,};
HDC hMemDC, hMemDC2;
HBITMAP hprev,hprev2=0;
HBITMAP hsrcdib;
void *srcdib;
BITMAP bm;
int r = GetObject(hbmp, sizeof(BITMAP), &bm);
ASSERT(r != 0);
fullimage_w=bm.bmWidth;
fullimage_h=ABS(bm.bmHeight);
int bmw=getWidth();
int bmh=getHeight();
int xo=getX();
int yo=getY();
srcbmi.bmiHeader.biSize=sizeof(srcbmi.bmiHeader);
srcbmi.bmiHeader.biWidth=bmw;
srcbmi.bmiHeader.biHeight=-bmh;
srcbmi.bmiHeader.biPlanes=1;
srcbmi.bmiHeader.biBitCount=32;
srcbmi.bmiHeader.biCompression=BI_RGB;
hMemDC = CreateCompatibleDC(NULL);
hsrcdib=CreateDIBSection(hMemDC,&srcbmi,DIB_RGB_COLORS,&srcdib,NULL,0);
ASSERTPR(hsrcdib != 0, "CreateDIBSection() failed #6");
if (defaultDC)
hMemDC2 = defaultDC;
else {
hMemDC2 = CreateCompatibleDC(NULL);
hprev2 = (HBITMAP) SelectObject(hMemDC2, hbmp);
}
hprev = (HBITMAP) SelectObject(hMemDC, hsrcdib);
BitBlt(hMemDC,0,0,bmw,bmh,hMemDC2,xo,yo,SRCCOPY);
SelectObject(hMemDC, hprev);
if (!defaultDC) {
SelectObject(hMemDC2, hprev2);
DeleteDC(hMemDC2);
}
DeleteDC(hMemDC);
bits=(ARGB32*)MALLOC_(bmw*bmh*4);
if (getHeight()+getY() > bm.bmHeight || getWidth()+getX() > bm.bmWidth) {
ASSERTALWAYS(StringPrintf("Subbitmap coordinates outside master bitmap [%d,%d,%d,%d in 0,0,%d,%d]", getX(), getY(), getWidth(), getHeight(), bm.bmWidth, bm.bmHeight));
}
MEMCPY32(bits,srcdib,bmw*bmh/**sizeof(ARGB32)*/);
DeleteObject(hsrcdib);
x_offset=-1;
y_offset=-1;
subimage_w=-1;
subimage_h=-1;
fullimage_w=bmw;
fullimage_h=bmh;
}
#endif
#ifdef LINUX
if ( ! bits ) {
fullimage_w=hbmp.bmWidth;
fullimage_h=ABS(hbmp.bmHeight);
bits=(ARGB32*)MALLOC_( fullimage_w * fullimage_h * 4 );
MEMCPY32( bits, hbmp.shmseginfo->shmaddr, fullimage_w * fullimage_h );
x_offset=-1;
y_offset=-1;
subimage_w=-1;
subimage_h=-1;
}
#endif
}
#ifndef _NOSTUDIO
#ifdef WASABI_COMPILE_IMGLDR
SkinBitmap::SkinBitmap(const wchar_t *elementname, int _cached)
{
ASSERT(elementname!= NULL);
bitmapname = elementname;
x_offset = -1;
y_offset = -1;
subimage_w = -1;
subimage_h = -1;
fullimage_w=fullimage_h=0;
ownbits=1;
bits = NULL;
fromskin = 0;
last_failed = 0;
#ifdef WASABI_COMPILE_SKIN
bits = WASABI_API_IMGLDR->imgldr_requestSkinBitmap(elementname, &has_alpha, &x_offset, &y_offset, &subimage_w, &subimage_h, &fullimage_w, &fullimage_h,_cached);
fromskin = (bits != NULL);
#endif
if (bits == NULL)
bits = WASABI_API_IMGLDR->imgldr_makeBmp(elementname, &has_alpha, &fullimage_w, &fullimage_h);
#ifdef WASABI_COMPILE_SKIN
if (bits == NULL)
{
bits = WASABI_API_IMGLDR->imgldr_requestSkinBitmap(ERRORBMP, &has_alpha, &x_offset, &y_offset, &subimage_w, &subimage_h, &fullimage_w, &fullimage_h,_cached);
last_failed = 1;
}
#endif
if (bits == NULL)
{
bits = WASABI_API_IMGLDR->imgldr_makeBmp(HARDERRORBMP, &has_alpha, &fullimage_w, &fullimage_h);
last_failed = 1;
}
// check that coordinates are correct
if(x_offset!=-1 && x_offset>fullimage_w) x_offset=fullimage_w-1;
if(y_offset!=-1 && y_offset>fullimage_h) y_offset=fullimage_h-1;
if(subimage_w!=-1 && (x_offset+subimage_w)>fullimage_w) subimage_w=fullimage_w-x_offset;
if(subimage_h!=-1 && (y_offset+subimage_h)>fullimage_h) subimage_h=fullimage_h-y_offset;
// ASSERTPR(bits != NULL, elementname);
if (bits == NULL) {
DebugString("element not found ! %s\n", elementname);
int n = 10*10;
bits = (ARGB32 *)WASABI_API_MEMMGR->sysMalloc(n * 4);
ARGB32 *p = bits;
while (n--)
*p++ = 0xFFFF00FF;
}
}
#endif
#endif
SkinBitmap::SkinBitmap(HBITMAP bitmap)
{
#ifdef WIN32
ASSERT(bitmap != NULL);
#endif
subimage_w=-1;
subimage_h=-1;
x_offset=-1;
y_offset=-1;
bitmapname = L"";
fullimage_w=fullimage_h=0;
has_alpha = 0;
ownbits=1;
bits = NULL;
fromskin = 0;
last_failed = 0;
bmpToBits(bitmap,NULL);
}
SkinBitmap::SkinBitmap(HBITMAP bitmap, HDC dc, int _has_alpha, void *_bits)
{
subimage_w=-1;
subimage_h=-1;
x_offset=-1;
y_offset=-1;
fromskin = 0;
last_failed = 0;
bitmapname = L"";
fullimage_w=fullimage_h=0;
#ifdef WIN32
ASSERT(bitmap != NULL);
#endif
has_alpha = _has_alpha;
bits = (ARGB32*)_bits;
if (!_bits)
{
ownbits=1;
bmpToBits(bitmap,dc);
}
else
{
#ifdef WIN32
BITMAP bm;
ownbits=0;
int r = GetObject(bitmap, sizeof(BITMAP), &bm);
ASSERT(r != 0);
fullimage_w=bm.bmWidth;
fullimage_h=ABS(bm.bmHeight);
#endif
#ifdef LINUX
ownbits=0;
fullimage_w=bitmap.bmWidth;
fullimage_h=ABS(bitmap.bmHeight);
#endif
//port me
}
}
SkinBitmap::SkinBitmap(int w, int h, DWORD bgcolor) {
subimage_w=-1;
subimage_h=-1;
x_offset=-1;
y_offset=-1;
fullimage_w=w;
bitmapname = L"";
fullimage_h=h;
fromskin = 0;
last_failed = 0;
int memsize = w*h*sizeof(ARGB32);
if (memsize == 0) memsize++; // +1 so no failure when 0x0
bits = (ARGB32*)MALLOC_(memsize);
DWORD *dw = (DWORD *)bits;
MEMFILL<DWORD>(dw, bgcolor, w*h);
has_alpha = TRUE;
ownbits=2; // 2 specifies should be FREE()'d
}
SkinBitmap::~SkinBitmap() {
if (bits) {
if (ownbits==2) FREE(bits);
#ifndef _NOSTUDIO
#ifdef WASABI_COMPILE_IMGLDR
else if (ownbits) {
#ifdef WASABI_COMPILE_SKIN
if (fromskin)
WASABI_API_IMGLDR->imgldr_releaseSkinBitmap(bits);
else
#endif
#ifndef _WASABIRUNTIME
WASABI_API_IMGLDR->imgldr_releaseBmp(bits);
#else
WASABI_API_IMGLDR->imgldr_releaseSkinBitmap(bits);
#endif
}
#endif
#endif
}
bits=NULL;
}
void SkinBitmap::blit(ifc_canvas *canvas, int x, int y) {
RECT src, dst;
src.left=0;
src.top=0;
src.bottom=getHeight();
src.right=getWidth();
dst.left=x;
dst.right=x+getWidth();
dst.top=y;
dst.bottom=y+getHeight();
blitToRect(canvas,&src,&dst,255);
}
void SkinBitmap::blitRectToTile(ifc_canvas *canvas, RECT *dest, RECT *src, int xoffs, int yoffs, int alpha) {
int startx,starty;
int w,h;
w = src->right-src->left;
h = src->bottom-src->top;
if (w <= 0 || h <= 0) return; //wtfmf
RECT c;
if (canvas->getClipBox(&c) == NULLREGION) {
c = *dest;
} else {
if (dest->left > c.left) c.left = dest->left;
if (dest->top > c.top) c.top = dest->top;
if (dest->right < c.right) c.right = dest->right;
if (dest->bottom < c.bottom) c.bottom = dest->bottom;
}
starty = c.top-((c.top - dest->top) % h)- yoffs;
startx = c.left-((c.left - dest->left) % w) - xoffs;
for (int j=starty;j<c.bottom;j+=h)
for (int i=startx;i<c.right;i+=w) {
int xp=i;
int yp=j;
int xo=0;
int yo=0;
int _w=getWidth();
int _h=getHeight();
if (xp < c.left) {
xo=c.left-xp;
_w+=xo;
xp=c.left;
}
if (yp < c.top) {
yo=c.top-yp;
_h+=yo;
yp=c.top;
}
if (xp + _w >= c.right) _w=c.right-xp;
if (yp + _h >= c.bottom) _h=c.bottom-yp;
RECT _s={xo, yo, xo+_w, yo+_h};
RECT _d={xp, yp, xp+_w, yp+_h};
blitToRect(canvas, &_s, &_d, alpha);
}
}
void SkinBitmap::blitTile(ifc_canvas *canvas, RECT *dest, int xoffs, int yoffs, int alpha) {
RECT r={0,0,getWidth(),getHeight()};
blitRectToTile(canvas, dest, &r, xoffs, yoffs, alpha);
}
#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4799)
#endif
#define DEFAULT_CACHE_WIDTH 64
#define DEFAULT_CACHE_HEIGHT 64
int cacheWidth = DEFAULT_CACHE_WIDTH;
int cacheHeight = DEFAULT_CACHE_HEIGHT;
BltCanvas blitToRectCanvas(DEFAULT_CACHE_WIDTH,DEFAULT_CACHE_HEIGHT);
void SkinBitmap::blitToRect(ifc_canvas *canvas, RECT *src, RECT *dst, int alpha) { // only dst(top,left) are used
if (alpha <= 0) return;
if (alpha > 255) alpha = 255;
HDC hdc = canvas->getHDC();
if (hdc == NULL) return;
void *dib=canvas->getBits();
int cwidth,cheight, pitch;
BaseCloneCanvas clone(canvas);
bool usingBlitCanvas = false;
RECT destrect=*dst;
destrect.bottom=destrect.top+(src->bottom-src->top);
destrect.right=destrect.left+(src->right-src->left);
RECT c;
int ctype=canvas->getClipBox(&c);
if (c.top > destrect.top) destrect.top=c.top;
if (c.left > destrect.left) destrect.left=c.left;
if (c.bottom < destrect.bottom) destrect.bottom=c.bottom;
if (c.right < destrect.right) destrect.right=c.right;
#ifdef NO_SIMPLEFASTMODE
dib=NULL;
#endif
if (destrect.right <= destrect.left || destrect.bottom <= destrect.top) return;
int xs,yp,xe,ye;
if (!dib || canvas->getDim(NULL,&cheight,&cwidth) || !cwidth || cheight < 1 || ctype == COMPLEXREGION)
{
cwidth=destrect.right-destrect.left;
cheight=destrect.bottom-destrect.top;
if (cwidth > cacheWidth || cheight > cacheHeight)
{
cacheWidth=MAX(cacheWidth, cwidth);
cacheHeight=MAX(cacheHeight, cheight);
blitToRectCanvas.DestructiveResize(cacheWidth, cacheHeight);
}
dib = blitToRectCanvas.getBits();
if (has_alpha || alpha < 255)
clone.blit(destrect.left, destrect.top, &blitToRectCanvas, 0, 0, cwidth, cheight);
xs=0;
yp=0;
xe=cwidth;
ye=cheight;
pitch=cacheWidth;
usingBlitCanvas = true;
}
else
{
xs=destrect.left;
xe=destrect.right;
yp=destrect.top;
ye=destrect.bottom;
cwidth/=4;
pitch=cwidth;
}
int xpo=(dst->left-destrect.left+xs)-(getX()+src->left);
int ypo=(dst->top-destrect.top+yp)-(getY()+src->top);
if (yp < 0) yp=0;
if (xs < 0) xs=0;
if (yp<getY()+ypo) yp=ypo+getY();
if (xs<getX()+xpo) xs=xpo+getX();
if (xe > getWidth()+getX()+xpo) xe=getWidth()+getX()+xpo;
if (ye > getHeight()+getY()+ypo) ye=getHeight()+getY()+ypo;
// blend bitmap to dib
if (xs<xe) for (; yp < ye; yp ++) {
int xp=xe-xs;
unsigned int *dest=((unsigned int*)dib) + pitch*yp + xs;
unsigned int *src=((unsigned int*)bits) + (yp-ypo)*fullimage_w + (xs-xpo);
if (!has_alpha && alpha==255) // simple copy
{
MEMCPY32(dest,src,xp);
}
else if (!has_alpha) { // no alpha channel info, but just a simple blend
if (!HAS_MMX)
while (xp--) *dest++ = Blenders::BLEND_ADJ1(*src++, *dest, alpha);
#ifndef NO_MMX
else
{
#ifdef WIN32
if (xp>1) __asm
{
movd mm3, [alpha]
mov ecx, xp
movq mm4, [SkinBitmap_mmx_revn2]
packuswb mm3, mm3 // 0000HHVV
paddusw mm3, [SkinBitmap_mmx_one]
mov edi, dest
punpcklwd mm3, mm3 // HHVVHHVV
mov esi, src
punpckldq mm3, mm3 // HHVVHHVV HHVVHHVV
shr ecx, 1
psubw mm4, mm3
align 16
_blitAlpha_Loop1:
movd mm0, [edi]
movd mm1, [esi]
punpcklbw mm0, [SkinBitmap_mmx_zero]
movd mm7, [edi+4]
punpcklbw mm1, [SkinBitmap_mmx_zero]
pmullw mm0, mm4
pmullw mm1, mm3
movd mm6, [esi+4]
punpcklbw mm7, [SkinBitmap_mmx_zero]
punpcklbw mm6, [SkinBitmap_mmx_zero]
pmullw mm7, mm4
pmullw mm6, mm3
paddw mm0, mm1
psrlw mm0, 8
packuswb mm0, mm0
add esi, 8
movd [edi], mm0
paddw mm7, mm6
psrlw mm7, 8
packuswb mm7, mm7
movd [edi+4], mm7
add edi, 8
dec ecx
jnz _blitAlpha_Loop1
mov src, esi
mov dest, edi
#else
if ( xp > 1 ) {
__asm__ volatile (
"movd %6, %%mm3\n"
"mov %2, %%ecx\n"
"movq (SkinBitmap_mmx_revn2), %%mm4\n"
"packuswb %%mm3, %%mm3\n"
"paddusw (SkinBitmap_mmx_one), %%mm3\n"
"mov %0, %%edi\n"
"punpcklwd %%mm3, %%mm3\n"
"mov %1, %%esi\n"
"punpckldq %%mm3, %%mm3\n"
"shr $1, %%ecx\n"
"psubw %%mm3, %%mm4\n"
".align 16\n"
"_blitAlpha_Loop1:\n"
"movd (%%edi), %%mm0\n"
"movd (%%esi), %%mm1\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
"movd 4(%%edi), %%mm7\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
"pmullw %%mm3, %%mm0\n"
"pmullw %%mm4, %%mm1\n"
"movd 4(%%esi), %%mm6\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
"pmullw %%mm4, %%mm6\n"
"pmullw %%mm3, %%mm7\n"
"paddw %%mm1, %%mm0\n"
"psrlw $8, %%mm0\n"
"packuswb %%mm0, %%mm0\n"
"add $8, %%esi\n"
"movd %%mm0, (%%edi)\n"
"paddw %%mm6, %%mm7\n"
"psrlw $8, %%mm7\n"
"packuswb %%mm7, %%mm7\n"
"movd %%mm7, 4(%%edi)\n"
"add $8, %%edi\n"
"dec %%ecx\n"
"jnz _blitAlpha_Loop1\n"
"mov %%esi, %1\n"
"mov %%edi, %0\n"
: "=m" (dest), "=m" (src), "=m" (xp)
: "0" (dest), "1" (src), "2" (xp), "m" (alpha)
: "%eax", "%ecx", "%esi", "%edi" );
#endif
}
if (xp & 1) *dest++ = Blenders::BLEND_ADJ1_MMX(*src++, *dest, alpha);
} // mmx available
#endif // !NO_MMX
}
else if (alpha == 255) { // no global alpha, just alpha channel
if (!HAS_MMX)
while (xp--) *dest++ = Blenders::BLEND_ADJ2(*dest, *src++);
#ifndef NO_MMX
else
{
#ifdef WIN32
if (xp > 1) __asm
{
mov ecx, xp
shr ecx, 1
mov edi, dest
mov esi, src
align 16
_blitAlpha_Loop2:
movd mm3, [esi]
movd mm5, [esi+4]
movq mm2, [SkinBitmap_mmx_revn2]
psrld mm3, 24
movq mm4, [SkinBitmap_mmx_revn2]
psrld mm5, 24
movd mm0, [edi]
packuswb mm3, mm3 // 0000HHVV
movd mm1, [esi]
packuswb mm5, mm5 // 0000HHVV
movd mm6, [esi+4]
paddusw mm3, [SkinBitmap_mmx_one]
punpcklwd mm3, mm3 // HHVVHHVV
paddusw mm5, [SkinBitmap_mmx_one]
movd mm7, [edi+4]
punpcklwd mm5, mm5 // HHVVHHVV
punpckldq mm3, mm3 // HHVVHHVV HHVVHHVV
punpckldq mm5, mm5 // HHVVHHVV HHVVHHVV
punpcklbw mm6, [SkinBitmap_mmx_zero]
psubw mm4, mm5
punpcklbw mm0, [SkinBitmap_mmx_zero]
psubw mm2, mm3
punpcklbw mm7, [SkinBitmap_mmx_zero]
pmullw mm0, mm2
pmullw mm7, mm4
punpcklbw mm1, [SkinBitmap_mmx_zero]
psubw mm2, mm3
psrlw mm0, 8
psrlw mm7, 8
paddw mm0, mm1
paddw mm7, mm6
packuswb mm0, mm0
movd [edi], mm0
packuswb mm7, mm7
movd [edi+4], mm7
add esi, 8
add edi, 8
dec ecx
jnz _blitAlpha_Loop2
mov src, esi
mov dest, edi
#else
if( xp > 1 ) {
__asm__ volatile (
"mov %4, %%ecx\n"
"shr $1, %%ecx\n"
"mov %0, %%edi\n"
"mov %1, %%esi\n"
".align 16\n"
"_blitAlpha_Loop2:\n"
"movd (%%esi), %%mm3\n"
"movd 4(%%esi), %%mm5\n"
"movq (SkinBitmap_mmx_revn2), %%mm2\n"
"psrld $24, %%mm3\n"
"movq (SkinBitmap_mmx_revn2), %%mm4\n"
"psrld $24, %%mm5\n"
"movd (%%edi), %%mm0\n"
"packuswb %%mm3, %%mm3\n"
"movd (%%esi), %%mm1\n"
"packuswb %%mm5, %%mm5\n"
"movd 4(%%esi), %%mm6\n"
"paddusw (SkinBitmap_mmx_one), %%mm3\n"
"punpcklwd %%mm3, %%mm3\n"
"paddusw (SkinBitmap_mmx_one), %%mm5\n"
"movd 4(%%edi), %%mm7\n"
"punpcklwd %%mm5, %%mm5\n"
"punpckldq %%mm3, %%mm3\n"
"punpckldq %%mm5, %%mm5\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
"psubw %%mm5, %%mm4\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
"psubw %%mm3, %%mm2\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
"pmullw %%mm2, %%mm0\n"
"pmullw %%mm4, %%mm7\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
"psubw %%mm3, %%mm2\n"
"psrlw $8, %%mm0\n"
"psrlw $8, %%mm7\n"
"paddw %%mm1, %%mm0\n"
"paddw %%mm6, %%mm7\n"
"packuswb %%mm0, %%mm0\n"
"movd %%mm0, (%%edi)\n"
"packuswb %%mm7, %%mm7\n"
"movd %%mm7, 4(%%edi)\n"
"add $8, %%esi\n"
"add $8, %%edi\n"
"dec %%ecx\n"
"jnz _blitAlpha_Loop2\n"
"mov %%esi, %1\n"
"mov %%edi, %0\n"
: "=m" (dest), "=m" (src)
: "0" (dest), "1" (src), "m" (xp)
: "%eax", "%ecx", "%esi", "%edi" );
#endif
}
if (xp&1) *dest++ = Blenders::BLEND_ADJ2_MMX(*dest, *src++);
} // HAS_MMX
#endif // ifndef NO_MMX
}
else { // both
if (!HAS_MMX)
while (xp--) *dest++ = Blenders::BLEND_ADJ3(*dest, *src++, alpha);
#ifndef NO_MMX
else
{
#ifdef WIN32
if (xp > 1) __asm
{
movd mm5, [alpha]
mov ecx, xp
packuswb mm5, mm5
shr ecx, 1
paddusw mm5, [SkinBitmap_mmx_one]
punpcklwd mm5, mm5
mov edi, dest
punpckldq mm5, mm5
mov esi, src
align 16
_blitAlpha_Loop3:
movd mm3, [esi] // VVVVVVVV
movd mm4, [esi+4] // VVVVVVVV
movd mm0, [edi]
psrld mm3, 24
movd mm1, [esi]
psrld mm4, 24
paddusw mm3, [SkinBitmap_mmx_one]
paddusw mm4, [SkinBitmap_mmx_one]
movd mm7, [edi+4]
punpcklwd mm3, mm3
movd mm6, [esi+4]
punpcklwd mm4, mm4
punpckldq mm3, mm3
punpckldq mm4, mm4
pmullw mm3, mm5
pmullw mm4, mm5
punpcklbw mm7, [SkinBitmap_mmx_zero]
punpcklbw mm6, [SkinBitmap_mmx_zero]
movq mm2, [SkinBitmap_mmx_revn2]
psrlw mm3, 8
psrlw mm4, 8
punpcklbw mm0, [SkinBitmap_mmx_zero]
punpcklbw mm1, [SkinBitmap_mmx_zero]
psubw mm2, mm3
pmullw mm0, mm2
pmullw mm1, mm5
add esi, 8
movq mm2, [SkinBitmap_mmx_revn2]
pmullw mm6, mm5
paddusw mm0, mm1
psubw mm2, mm4
pmullw mm7, mm2
psrlw mm0, 8
packuswb mm0, mm0
paddusw mm7, mm6
movd [edi], mm0
psrlw mm7, 8
packuswb mm7, mm7
movd [edi+4], mm7
add edi, 8
dec ecx
jnz _blitAlpha_Loop3
mov src, esi
mov dest, edi
#else
if ( xp > 1 ) {
__asm__ volatile (
"movd %5, %%mm5\n"
"mov %4, %%ecx\n"
"packuswb %%mm5, %%mm5 \n"
"shr $1, %%ecx\n"
"paddusw (SkinBitmap_mmx_one), %%mm5\n"
"punpcklwd %%mm5, %%mm5\n"
"mov %0, %%edi\n"
"punpckldq %%mm5, %%mm5\n"
"mov %1, %%esi\n"
".align 16\n"
"_blitAlpha_Loop3:\n"
"movd (%%esi), %%mm3\n"
"movd 4(%%esi), %%mm4\n"
"movd (%%edi), %%mm0\n"
"psrld $24, %%mm3\n"
"movd (%%esi), %%mm1\n"
"psrld $24, %%mm4\n"
"paddusw (SkinBitmap_mmx_one), %%mm3\n"
"paddusw (SkinBitmap_mmx_one), %%mm4\n"
"movd 4(%%edi), %%mm7\n"
"punpcklwd %%mm3, %%mm3\n"
"movd 4(%%esi), %%mm6\n"
"punpcklwd %%mm4, %%mm4\n"
"punpckldq %%mm3, %%mm3\n"
"punpckldq %%mm4, %%mm4\n"
"pmullw %%mm5, %%mm3\n"
"pmullw %%mm5, %%mm4\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
"movq (SkinBitmap_mmx_revn2), %%mm2\n"
"psrlw $8, %%mm3\n"
"psrlw $8, %%mm4\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
"psubw %%mm3, %%mm2\n"
"pmullw %%mm2, %%mm0\n"
"pmullw %%mm5, %%mm1\n"
"add $8, %%esi\n"
"movq (SkinBitmap_mmx_revn2), %%mm2\n"
"pmullw %%mm5, %%mm6\n"
"paddusw %%mm1, %%mm0\n"
"psubw %%mm4, %%mm2\n"
"pmullw %%mm2, %%mm7\n"
"psrlw $8, %%mm0\n"
"packuswb %%mm0, %%mm0\n"
"paddusw %%mm6, %%mm7\n"
"movd %%mm0, (%%edi)\n"
"psrlw $8, %%mm7\n"
"packuswb %%mm7, %%mm7\n"
"movd %%mm7, 4(%%edi)\n"
"add $8, %%edi\n"
"dec %%ecx\n"
"jnz _blitAlpha_Loop3\n"
"mov %%esi, %1\n"
"mov %%edi, %0\n"
: "=m" (dest), "=m" (src)
: "0" (dest), "1" (src), "m" (xp), "m" (alpha)
: "%eax", "%ecx", "%esi", "%edi" );
#endif
}
if (xp&1) *dest++ = Blenders::BLEND_ADJ3_MMX(*dest, *src++, alpha);
} // HAS_MMX
#endif // ifndef NO_MMX
}
}
#ifndef NO_MMX
Blenders::BLEND_MMX_END();
#endif
// write bits back to dib.
if (usingBlitCanvas) {
blitToRectCanvas.blit(0, 0, &clone, destrect.left, destrect.top, cwidth, cheight);
}
}
#ifdef WIN32
#pragma warning(pop)
#endif
void SkinBitmap::stretch(ifc_canvas *canvas, int x, int y, int w, int h) {
RECT src, dst;
src.left=0;
src.top=0;
src.right=getWidth();
src.bottom=getHeight();
dst.left=x;
dst.right=x+w;
dst.top=y;
dst.bottom=y+h;
stretchToRectAlpha(canvas,&src,&dst,255);
}
void SkinBitmap::stretchToRect(ifc_canvas *canvas, RECT *r) {
stretch(canvas, r->left, r->top, r->right - r->left, r->bottom - r->top);
}
void SkinBitmap::stretchRectToRect(ifc_canvas *canvas, RECT *src, RECT *dst) {
stretchToRectAlpha(canvas,src,dst,255);
}
void SkinBitmap::stretchToRectAlpha(ifc_canvas *canvas, RECT *r, int alpha) {
RECT re;
re.left=0; re.top=0;
re.right=getWidth(); re.bottom=getHeight();
stretchToRectAlpha(canvas,&re,r,alpha);
}
void SkinBitmap::blitAlpha(ifc_canvas *canvas, int x, int y, int alpha)
{
RECT dst,src;
dst.left=x;
dst.top=y;
src.left=0;
src.top=0;
src.bottom=getHeight();
src.right=getWidth();
blitToRect(canvas,&src,&dst,alpha);
}
#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4799)
#endif
template <class C>
class Stretcher {
public:
static void _stretchToRectAlpha(SkinBitmap *bitmap, int ys, int ye, int xe, int xs, int xstart, int yv, void *dib, int pitch, int dxv, int dyv, int alpha) {
int bitmap_x = bitmap->getX();
int bitmap_y = bitmap->getY();
int bmpheight = bitmap->getHeight();
int fullimage_w = bitmap->getFullWidth();
void *bits = bitmap->getBits();
int xp=xe-xs;
for (int yp = ys; yp < ye; yp ++) {
int t=yv>>16;
if (t < 0) t=0;
if (t >= bmpheight) t=bmpheight-1;
int *psrc=((int*)bits) + (t+bitmap_y)*fullimage_w + bitmap_x;
int *dest=((int*)dib) + pitch*yp + xs;
C::stretch(xp, psrc, dest, xstart, dxv, alpha);
yv+=dyv;
}
}
};
// no alpha, just stretch
class Stretch {
public:
static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha) {
while (xp--) { //JFtodo: assembly optimize - these first two modes aren't used that much anyway
*dest++ = psrc[xv>>16];
xv+=dxv;
}
}
};
// no alpha channel, just a global alpha val
class StretchGlobal {
public:
static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha) {
while (xp--) { //JFTODO: make MMX optimized version
*dest++ = Blenders::BLEND_ADJ1(psrc[xv>>16], *dest, alpha);
xv+=dxv;
}
}
};
// alpha channel, no global alpha val
class StretchChannel {
public:
static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha) {
while (xp--) {
*dest++ = Blenders::BLEND_ADJ2(*dest, psrc[xv>>16]);
xv+=dxv;
}
}
};
class StretchGlobalChannel {
public:
static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha) {
while (xp--) {
*dest++ = Blenders::BLEND_ADJ3(*dest, psrc[xv>>16], alpha);
xv+=dxv;
}
}
};
#ifndef NO_MMX
// no alpha channel, just a global alpha val
class StretchGlobalMMX {
public:
static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha) {
while (xp--) { //JFTODO: make MMX optimized version
*dest++ = Blenders::BLEND_ADJ1_MMX(psrc[xv>>16], *dest, alpha);
xv+=dxv;
}
}
};
// alpha channel, no global alpha val
class StretchChannelMMX {
public:
static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha) {
#ifdef WIN32
if (xp>1) __asm
{
mov ecx, xp
mov edi, dest
shr ecx, 1
mov esi, psrc
mov edx, xv
mov ebx, dxv
align 16
_stretchAlpha_Loop2:
mov eax, edx
movd mm0, [edi]
movq mm4, [SkinBitmap_mmx_revn2]
shr eax, 16
movq mm2, [SkinBitmap_mmx_revn2]
punpcklbw mm0, [SkinBitmap_mmx_zero]
movd mm3, [esi+eax*4]
movd mm1, [esi+eax*4]
lea eax, [edx+ebx]
shr eax, 16
movd mm7, [edi+4]
psrld mm3, 24
packuswb mm3, mm3 // 0000HHVV
movd mm5, [esi+eax*4]
movd mm6, [esi+eax*4]
psrld mm5, 24
paddusw mm3, [SkinBitmap_mmx_one]
punpcklbw mm6, [SkinBitmap_mmx_zero]
packuswb mm5, mm5 // 0000HHVV
lea edx, [edx+ebx*2]
paddusw mm5, [SkinBitmap_mmx_one]
punpcklwd mm3, mm3 // HHVVHHVV
punpcklwd mm5, mm5 // HHVVHHVV
add edi, 8
punpckldq mm3, mm3 // HHVVHHVV HHVVHHVV
punpckldq mm5, mm5 // HHVVHHVV HHVVHHVV
psubw mm4, mm5
psubw mm2, mm3
punpcklbw mm7, [SkinBitmap_mmx_zero]
pmullw mm0, mm2
pmullw mm7, mm4
punpcklbw mm1, [SkinBitmap_mmx_zero]
psubw mm2, mm3
psrlw mm0, 8
psrlw mm7, 8
paddw mm0, mm1
paddw mm7, mm6
packuswb mm0, mm0
movd [edi-8], mm0
packuswb mm7, mm7
movd [edi-4], mm7
dec ecx
jnz _stretchAlpha_Loop2
mov dest, edi
mov xv, edx
}
#else
if (xp>1)
{
__asm__ volatile (
"mov %5, %%ecx\n"
"mov %0, %%edi\n"
"shr $1, %%ecx\n"
"mov %1, %%esi\n"
"mov %2, %%edx\n"
"mov %7, %%ebx\n"
".align 16\n"
"_stretchAlpha_Loop2:\n"
"mov %%edx, %%eax\n"
"movd (%%edi), %%mm0\n"
"movq (SkinBitmap_mmx_revn2), %%mm4\n"
"shr $16, %%eax\n"
"movq (SkinBitmap_mmx_revn2), %%mm2\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
"movd (%%esi,%%eax,4), %%mm3\n"
"movd (%%esi,%%eax,4), %%mm1\n"
"lea (%%edx,%%ebx), %%eax\n"
"shr $16, %%eax\n"
"movd 4(%%edi), %%mm7\n"
"psrld $24, %%mm3\n"
"packuswb %%mm3, %%mm3\n"
"movd (%%esi,%%eax,4), %%mm5\n"
"movd (%%esi,%%eax,4), %%mm6\n"
"psrld $24, %%mm5\n"
"paddusw (SkinBitmap_mmx_one), %%mm3\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
"packuswb %%mm5, %%mm5\n"
"lea (%%edx,%%ebx,2), %%edx\n"
"paddusw (SkinBitmap_mmx_one), %%mm5\n"
"punpcklwd %%mm3, %%mm3\n"
"punpcklwd %%mm5, %%mm5\n"
"add $8, %%edi\n"
"punpckldq %%mm3, %%mm3\n"
"punpckldq %%mm5, %%mm5\n"
"psubw %%mm5, %%mm4\n"
"psubw %%mm3, %%mm2\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
"pmullw %%mm2, %%mm0\n"
"pmullw %%mm4, %%mm7\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
"psubw %%mm3, %%mm2\n"
"psrlw $8, %%mm0\n"
"psrlw $8, %%mm7\n"
"paddw %%mm1, %%mm0\n"
"paddw %%mm6, %%mm7\n"
"packuswb %%mm0, %%mm0\n"
"movd %%mm0, -8(%%edi)\n"
"packuswb %%mm7, %%mm7\n"
"movd %%mm7, -4(%%edi)\n"
"dec %%ecx\n"
"jnz _stretchAlpha_Loop2\n"
"mov %%edi, %0\n"
"mov %%edx, %2\n"
: "=m" (dest), "=m" (psrc), "=m" (xv)
: "0" (dest), "1" (psrc), "m" (xp),
"2" (xv), "m" (dxv), "m" (alpha)
: "%eax", "%ebx", "%ecx", "%edx",
"%esi", "%edi" );
}
#endif
if (xp&1) *dest++ = Blenders::BLEND_ADJ2_MMX(*dest, psrc[xv>>16]);
}
};
class StretchGlobalChannelMMX {
public:
static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha) {
#ifdef WIN32
if (xp>1) __asm
{
movd mm5, [alpha]
mov ecx, xp
packuswb mm5, mm5
shr ecx, 1
paddusw mm5, [SkinBitmap_mmx_one]
punpcklwd mm5, mm5
mov edi, dest
punpckldq mm5, mm5
mov esi, psrc
mov edx, xv
mov ebx, dxv
align 16
_stretchAlpha_Loop3:
movd mm0, [edi]
mov eax, edx
movd mm7, [edi+4]
shr eax, 16
movd mm1, [esi+eax*4]
movd mm3, [esi+eax*4] // VVVVVVVV
lea eax, [edx+ebx]
psrld mm3, 24
paddusw mm3, [SkinBitmap_mmx_one]
punpcklwd mm3, mm3
shr eax, 16
punpckldq mm3, mm3
pmullw mm3, mm5
movd mm4, [esi+eax*4] // VVVVVVVV
movd mm6, [esi+eax*4]
movq mm2, [SkinBitmap_mmx_revn2]
psrld mm4, 24
paddusw mm4, [SkinBitmap_mmx_one]
punpcklbw mm7, [SkinBitmap_mmx_zero]
punpcklwd mm4, mm4
lea edx, [edx+ebx*2]
punpckldq mm4, mm4
add edi, 8
punpcklbw mm6, [SkinBitmap_mmx_zero]
pmullw mm4, mm5
psrlw mm3, 8
punpcklbw mm0, [SkinBitmap_mmx_zero]
punpcklbw mm1, [SkinBitmap_mmx_zero]
psubw mm2, mm3
pmullw mm0, mm2
pmullw mm1, mm5
pmullw mm6, mm5
psrlw mm4, 8
movq mm2, [SkinBitmap_mmx_revn2]
paddusw mm0, mm1
psubw mm2, mm4
pmullw mm7, mm2
psrlw mm0, 8
packuswb mm0, mm0
paddusw mm7, mm6
movd [edi-8], mm0
psrlw mm7, 8
packuswb mm7, mm7
movd [edi-4], mm7
dec ecx
jnz _stretchAlpha_Loop3
mov xv, edx
mov dest, edi
}
#else
if (xp>1)
{
__asm__ volatile (
"movd %8, %%mm5\n"
"mov %5, %%ecx\n"
"packuswb %%mm5, %%mm5 \n"
"shr $1, %%ecx\n"
"paddusw (SkinBitmap_mmx_one), %%mm5\n"
"punpcklwd %%mm5, %%mm5\n"
"mov %0, %%edi\n"
"punpckldq %%mm5, %%mm5\n"
"mov %1, %%esi\n"
"mov %6, %%edx\n"
"mov %7, %%ebx\n"
".align 16\n"
"_stretchAlpha_Loop3:\n"
"movd (%%edi), %%mm0\n"
"mov %%edx, %%eax\n"
"movd 4(%%edi), %%mm7\n"
"shr $16, %%eax\n"
"movd (%%esi,%%eax,4), %%mm1\n"
"movd (%%esi,%%eax,4), %%mm3\n"
"lea (%%edx,%%ebx), %%eax\n"
"psrld $24, %%mm3\n"
"paddusw (SkinBitmap_mmx_one), %%mm3\n"
"punpcklwd %%mm3, %%mm3\n"
"shr $16, %%eax\n"
"punpckldq %%mm3, %%mm3\n"
"pmullw %%mm5, %%mm3\n"
"movd (%%esi,%%eax,4), %%mm4\n"
"movd (%%esi,%%eax,4), %%mm6\n"
"movq (SkinBitmap_mmx_revn2), %%mm2\n"
"psrld $24, %%mm4\n"
"paddusw (SkinBitmap_mmx_one), %%mm4\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
"punpcklwd %%mm4, %%mm4\n"
"lea (%%edx,%%ebx,2), %%edx\n"
"punpckldq %%mm4, %%mm4\n"
"add $8, %%edi\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
"pmullw %%mm5, %%mm4\n"
"psrlw $8, %%mm3\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
"punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
"psubw %%mm3, %%mm2\n"
"pmullw %%mm2, %%mm0\n"
"pmullw %%mm5, %%mm1\n"
"pmullw %%mm5, %%mm6\n"
"psrlw $8, %%mm4\n"
"movq (SkinBitmap_mmx_revn2), %%mm2\n"
"paddusw %%mm1, %%mm0\n"
"psubw %%mm4, %%mm2\n"
"pmullw %%mm2, %%mm7\n"
"psrlw $8, %%mm0\n"
"packuswb %%mm0, %%mm0\n"
"paddusw %%mm6, %%mm7\n"
"movd %%mm0, -8(%%edi)\n"
"psrlw $8, %%mm7\n"
"packuswb %%mm7, %%mm7\n"
"movd %%mm7, -4(%%edi)\n"
"dec %%ecx\n"
"jnz _stretchAlpha_Loop3\n"
"mov %%edi, %0\n"
"mov %%edx, %2\n"
: "=m" (dest), "=m" (psrc), "=m" (xv)
: "0" (dest), "1" (psrc), "m" (xp),
"m" (xv), "m" (dxv), "m" (alpha)
: "%eax", "%ebx", "%ecx", "%edx",
"%esi", "%edi" );
}
#endif
if (xp&1) *dest++ = Blenders::BLEND_ADJ3_MMX(*dest, psrc[xv>>16], alpha);
}
};
#endif
class __Stretch : public Stretcher<Stretch> {};
class __StretchGlobal : public Stretcher<StretchGlobal> {};
class __StretchChannel : public Stretcher<StretchChannel> {};
class __StretchGlobalChannel : public Stretcher<StretchGlobalChannel> {};
#ifndef NO_MMX
class __StretchGlobalMMX : public Stretcher<StretchGlobalMMX> {};
class __StretchChannelMMX : public Stretcher<StretchChannelMMX> {};
class __StretchGlobalChannelMMX : public Stretcher<StretchGlobalChannelMMX> {};
#endif
#ifdef WIN32
#pragma warning(pop)
#endif
void SkinBitmap::stretchToRectAlpha(ifc_canvas *canvas, RECT *_src, RECT *_dst, int alpha)
{
if (alpha <= 0) return;
if (alpha > 255) alpha = 255;
RECT src=*_src;
RECT dst=*_dst;
if ((src.right-src.left) == (dst.right-dst.left) &&
(src.bottom-src.top) == (dst.bottom-dst.top))
{
blitToRect(canvas,_src,_dst,alpha);
return;
}
//FG> this is a hack, we should support subpixels instead
if (src.left == src.right) {
if (src.right < getWidth())
src.right++;
else
src.left--;
}
if (src.top== src.bottom) {
if (src.bottom < getHeight())
src.bottom++;
else
src.top--;
}
if (src.left >= src.right || src.top >= src.bottom) return;
if (dst.left >= dst.right || dst.top >= dst.bottom) return;
void *dib=canvas->getBits();
HDC hdc=canvas->getHDC();
bool usingBlitCanvas = false;
BaseCloneCanvas clone(canvas);
int cwidth, cheight, pitch;
int dyv=((src.bottom-src.top)<<16)/(dst.bottom-dst.top);
int dxv=((src.right-src.left)<<16)/(dst.right-dst.left);
int yv=(src.top<<16);
int xstart=(src.left<<16);
RECT c;
int ctype=canvas->getClipBox(&c);
if (c.top > dst.top)
{
yv+=(c.top-dst.top)*dyv;
dst.top=c.top;
}
if (c.left > dst.left)
{
xstart+=(c.left-dst.left)*dxv;
dst.left=c.left;
}
if (c.bottom < dst.bottom) dst.bottom=c.bottom;
if (c.right < dst.right) dst.right=c.right;
if (dst.right <= dst.left || dst.bottom <= dst.top) return;
int xs,xe,ys,ye;
#ifdef NO_SIMPLEFASTMODE
dib=NULL;
#endif
if (!dib || canvas->getDim(NULL,&cheight,&cwidth) || !cwidth || cheight < 1 || ctype == COMPLEXREGION)
{
cwidth=dst.right-dst.left;
cheight=dst.bottom-dst.top;
if (cwidth > cacheWidth || cheight > cacheHeight)
{
cacheWidth=MAX(cacheWidth, cwidth);
cacheHeight=MAX(cacheHeight, cheight);
blitToRectCanvas.DestructiveResize(cacheWidth, cacheHeight);
}
dib = blitToRectCanvas.getBits();
if ( has_alpha || alpha < 255 )
clone.blit( dst.left, dst.top, &blitToRectCanvas, 0, 0, cwidth, cheight );
xs=0;
ys=0;
xe=cwidth;
ye=cheight;
pitch=cacheWidth;
usingBlitCanvas=true;
}
else
{
xs=dst.left;
xe=dst.right;
ys=dst.top;
ye=dst.bottom;
cwidth/=4;
pitch=cwidth;
}
// stretch and blend bitmap to dib
if (xstart < 0) xstart=0;
if (xs<xe) {
if (!has_alpha) { // doesn't have alpha channel
if (alpha == 255) { // no global alpha
__Stretch::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
} else { // has global alpha
#ifndef NO_MMX
if (HAS_MMX) {
__StretchGlobalMMX::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
} else
#endif
{
__StretchGlobal::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
}
}
} else { // has alpha channel
// FUCKO: JF> BRENNAN FIX THESE BITCHES :)
if (alpha == 255) { // no global alpha
#ifndef NO_MMX
if (HAS_MMX) {
__StretchChannelMMX::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
} else
#endif
{
__StretchChannel::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
}
} else { // has global alpha
#ifndef NO_MMX
if (HAS_MMX) {
__StretchGlobalChannelMMX::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
} else
#endif
{
__StretchGlobalChannel::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
}
}
}
}
#ifndef NO_MMX
Blenders::BLEND_MMX_END();
#endif
// write bits back to dib.
if (usingBlitCanvas) {
blitToRectCanvas.blit(0, 0, &clone, dst.left, dst.top, cwidth, cheight);
}
}
COLORREF SkinBitmap::getPixel(int x, int y) {
ASSERT(bits != NULL);
if (x < 0 || y < 0 || x >= getFullWidth()-getX() || y>= getFullHeight()-getY()) return (COLORREF)0;
return (COLORREF)(((int*)bits)[x+getX()+(y+getY())*getFullWidth()]);
}
void *SkinBitmap::getBits() {
return bits;
}
int SkinBitmap::isInvalid() {
return last_failed;
}
void SkinBitmap::setHasAlpha(int ha) {
has_alpha=ha;
}
const wchar_t *SkinBitmap::getBitmapName() {
return bitmapname;
}
Reference in New Issue Copy Permalink