1874 lines
42 KiB
C++
1874 lines
42 KiB
C++
#include <tataki/api__tataki.h>
|
|
|
|
//#define NO_SIMPLEFASTMODE
|
|
#include <api/imgldr/api_imgldr.h>
|
|
#include <tataki/blending/blending.h>
|
|
|
|
#include "bitmap.h"
|
|
|
|
#include <bfc/wasabi_std.h>
|
|
#include <tataki/canvas/bltcanvas.h>
|
|
|
|
#include <api/memmgr/api_memmgr.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
|
|
#if 0
|
|
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;
|
|
}
|
|
}
|
|
#endif
|
|
static __inline int shc(int offset, int offset16, int pos, int delta)
|
|
{
|
|
__int64 num = (Int32x32To64(pos, delta) + (__int64)offset16)/65536LL;
|
|
return (int)(num+offset);
|
|
}
|
|
|
|
static __inline void *ROUNDUP16(void *ptr)
|
|
{
|
|
return (void *)(((size_t)ptr+15) & ~15);
|
|
}
|
|
|
|
static void Shrink(SkinBitmap *src_, int ys, int ye, int xe, int xs, int xstart, int yv, void *dst_, int dstpitch, int dxv, int dyv, int alpha)
|
|
{
|
|
// to scale an image
|
|
// where the destination image is both smaller on X *and* Y.
|
|
|
|
// inputs:
|
|
int srcpitch = src_->getFullWidth();
|
|
int bitmap_x = src_->getX();
|
|
int bitmap_height = src_->getHeight();
|
|
int bitmap_fullheight = src_->getFullHeight();
|
|
int bitmap_y = src_->getY();
|
|
|
|
uint8_t *src=(uint8_t *)src_->getBits();;
|
|
ARGB32 *dst= (ARGB32 *)dst_;
|
|
|
|
//#define NEW_X(x__) ((srcxs+bitmap_x)+MulDiv(x__, dxv, 65536))
|
|
#define NEW_X(x__) shc(bitmap_x, xstart,(x__), dxv)
|
|
#define NEW_Y(y__) shc(bitmap_y, yv, (y__)-ys, dyv)
|
|
|
|
int dstw = xe-xs;
|
|
// make sure we have enough room. I don't think anyone is going to have destination bitmaps this big, but might as well play it safe
|
|
ASSERT(dstw <= 4096);
|
|
if (dstw > 4096) return;
|
|
|
|
// all this weird stuff is to align on 16 byte boundary
|
|
char *_new_x[4096*sizeof(int)+15] = {0};
|
|
char *new_x_aligned = (char *)_new_x;
|
|
ROUNDUP16(new_x_aligned);
|
|
int *new_x = (int *)new_x_aligned;
|
|
for (int x=0; x<=dstw; x++)
|
|
new_x[x] = NEW_X(x);
|
|
|
|
// FOR EACH DEST PIXEL
|
|
for (int y=ys; y<ye; y++)
|
|
{
|
|
int sy1 = NEW_Y(y);
|
|
int sy2 = NEW_Y(y+1);
|
|
for (int x=0; x<dstw; x++)
|
|
{
|
|
uint32_t sum[4] = { 0, 0, 0, 0 };
|
|
int sx1 = new_x[x];
|
|
int sx2 = new_x[x+1];
|
|
// FOR EACH CONTRIBUTING SOURCE PIXEL: in a block [sx1..sx2) x [sy1..sy2)
|
|
for (int b=sy1; b<sy2; b++)
|
|
for (int a=sx1; a<sx2; a++)
|
|
{
|
|
uint8_t *ps = &src[(b*srcpitch + a)*4];
|
|
sum[0] += (uint32_t)ps[0];
|
|
sum[1] += (uint32_t)ps[1];
|
|
sum[2] += (uint32_t)ps[2];
|
|
sum[3] += (uint32_t)ps[3];
|
|
}
|
|
// write downsampled pixel:
|
|
ARGB32 &dstpix = dst[(y*dstpitch + x+xs)];
|
|
uint32_t out;
|
|
uint8_t *pd = (uint8_t *)&out;
|
|
int pixels_covered = (sy2-sy1)*(sx2-sx1);
|
|
pd[0] = (uint32_t)(sum[0] / pixels_covered);
|
|
pd[1] = (uint32_t)(sum[1] / pixels_covered);
|
|
pd[2] = (uint32_t)(sum[2] / pixels_covered);
|
|
pd[3] = (uint32_t)(sum[3] / pixels_covered);
|
|
#ifdef NO_MMX
|
|
dstpix = Blenders::BLEND_ADJ3(dstpix, out, alpha);
|
|
#else
|
|
dstpix = Blenders::BLEND_ADJ3_MMX(dstpix, out, alpha);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
static wchar_t skinBitmapBlankName[] = L"";
|
|
SkinBitmap::SkinBitmap(HINSTANCE hInstance, int id, const wchar_t *forcegroup)
|
|
{
|
|
high_quality_resampling = false;
|
|
references = 1;
|
|
bitmapname = skinBitmapBlankName;
|
|
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;
|
|
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);
|
|
}
|
|
if (bits == NULL)
|
|
{
|
|
last_failed = 1;
|
|
bits = WASABI_API_IMGLDR->imgldr_makeBmp(HARDERRORBMP, &has_alpha, &fullimage_w, &fullimage_h);
|
|
}
|
|
}
|
|
|
|
SkinBitmap::SkinBitmap(ARGB32 *_bits, int w, int h, bool own)
|
|
{
|
|
high_quality_resampling = false;
|
|
references = 1;
|
|
subimage_w = -1;
|
|
subimage_h = -1;
|
|
x_offset = -1;
|
|
y_offset = -1;
|
|
bitmapname = skinBitmapBlankName;
|
|
fullimage_w = w;
|
|
fullimage_h = h;
|
|
has_alpha = 1;
|
|
if (own)
|
|
ownbits = OWNBITS_USECFREE;
|
|
else
|
|
ownbits = OWNBITS_NOTOURS;
|
|
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
|
|
}
|
|
|
|
SkinBitmap::SkinBitmap(const wchar_t *elementname, int _cached)
|
|
{
|
|
ASSERT(elementname!= NULL);
|
|
|
|
high_quality_resampling=false;
|
|
references=1;
|
|
bitmapname = _wcsdup(elementname);
|
|
x_offset = -1;
|
|
y_offset = -1;
|
|
subimage_w = -1;
|
|
subimage_h = -1;
|
|
fullimage_w = fullimage_h = 0;
|
|
ownbits = OWNBITS_USEIMGLDR;
|
|
bits = NULL;
|
|
fromskin = 0;
|
|
last_failed = 0;
|
|
|
|
if (WASABI_API_IMGLDR) // someone might be using us in Classic Skin so explicitly check this
|
|
{
|
|
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);
|
|
|
|
if (bits == NULL)
|
|
bits = WASABI_API_IMGLDR->imgldr_makeBmp(elementname, &has_alpha, &fullimage_w, &fullimage_h);
|
|
|
|
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;
|
|
}
|
|
|
|
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)
|
|
{
|
|
DebugStringW(L"element not found ! %s\n", elementname);
|
|
int n = 10*10;
|
|
bits = (ARGB32 *)WASABI_API_MEMMGR->sysMalloc(n * sizeof(ARGB32));
|
|
fromskin = OWNBITS_USESYSFREE;
|
|
ARGB32 *p = bits;
|
|
while (n--)
|
|
*p++ = 0xFFFF00FF;
|
|
}
|
|
}
|
|
else
|
|
last_failed = 1;
|
|
}
|
|
|
|
SkinBitmap::SkinBitmap(HBITMAP bitmap)
|
|
{
|
|
#ifdef WIN32
|
|
ASSERT(bitmap != NULL);
|
|
#endif
|
|
high_quality_resampling = false;
|
|
references = 1;
|
|
subimage_w = -1;
|
|
subimage_h = -1;
|
|
x_offset = -1;
|
|
y_offset = -1;
|
|
bitmapname = skinBitmapBlankName;
|
|
fullimage_w = fullimage_h = 0;
|
|
has_alpha = 0;
|
|
ownbits = OWNBITS_USESTDFREE;
|
|
bits = NULL;
|
|
fromskin = 0;
|
|
last_failed = 0;
|
|
bmpToBits(bitmap,NULL);
|
|
}
|
|
|
|
SkinBitmap::SkinBitmap(HBITMAP bitmap, HDC dc, int _has_alpha, void *_bits)
|
|
{
|
|
high_quality_resampling=false;
|
|
references=1;
|
|
subimage_w=-1;
|
|
subimage_h=-1;
|
|
x_offset=-1;
|
|
y_offset=-1;
|
|
fromskin = 0;
|
|
last_failed = 0;
|
|
bitmapname = skinBitmapBlankName;
|
|
fullimage_w=fullimage_h=0;
|
|
#ifdef WIN32
|
|
ASSERT(bitmap != NULL);
|
|
#endif
|
|
has_alpha = _has_alpha;
|
|
bits = (ARGB32*)_bits;
|
|
if (!_bits)
|
|
{
|
|
ownbits = OWNBITS_USESTDFREE;
|
|
bmpToBits(bitmap,dc);
|
|
}
|
|
else
|
|
{
|
|
#ifdef WIN32
|
|
BITMAP bm;
|
|
ownbits = OWNBITS_NOTOURS;
|
|
int r = GetObject(bitmap, sizeof(BITMAP), &bm);
|
|
ASSERT(r != 0);
|
|
fullimage_w = bm.bmWidth;
|
|
fullimage_h = ABS(bm.bmHeight);
|
|
#endif
|
|
#ifdef LINUX
|
|
ownbits = OWNBITS_NOTOURS;
|
|
fullimage_w = bitmap.bmWidth;
|
|
fullimage_h = ABS(bitmap.bmHeight);
|
|
#endif
|
|
//port me
|
|
}
|
|
}
|
|
|
|
SkinBitmap::SkinBitmap(ifc_canvas *canvas)
|
|
{
|
|
high_quality_resampling=false;
|
|
references=1;
|
|
subimage_w=-1;
|
|
subimage_h=-1;
|
|
x_offset=-1;
|
|
y_offset=-1;
|
|
bits = NULL;
|
|
|
|
void *canvas_bits = canvas->getBits();
|
|
if (canvas_bits)
|
|
{
|
|
canvas->getDim(&subimage_w, &fullimage_h, &fullimage_w);
|
|
fullimage_w/=4;
|
|
canvas->getOffsets(&x_offset, &y_offset);
|
|
size_t copylen = fullimage_h*fullimage_w*sizeof(ARGB32);
|
|
bits =(ARGB32 *)MALLOC(copylen);
|
|
memcpy(bits, canvas_bits, copylen);
|
|
last_failed = 0;
|
|
ownbits = OWNBITS_USESTDFREE;
|
|
}
|
|
else
|
|
{
|
|
last_failed = 1;
|
|
ownbits = OWNBITS_NOTOURS;
|
|
}
|
|
subimage_h=-1;
|
|
bitmapname = skinBitmapBlankName;
|
|
has_alpha = 1;
|
|
fromskin = 0;
|
|
}
|
|
|
|
SkinBitmap::SkinBitmap(int w, int h, ARGB32 bgcolor)
|
|
{
|
|
high_quality_resampling=false;
|
|
references=1;
|
|
subimage_w=-1;
|
|
subimage_h=-1;
|
|
x_offset=-1;
|
|
y_offset=-1;
|
|
fullimage_w=w;
|
|
bitmapname = skinBitmapBlankName;
|
|
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 = OWNBITS_USESTDFREE; // 2 specifies should be FREE()'d
|
|
}
|
|
|
|
SkinBitmap::~SkinBitmap()
|
|
{
|
|
if (bits)
|
|
{
|
|
switch(ownbits)
|
|
{
|
|
case OWNBITS_USESTDFREE:
|
|
FREE(bits);
|
|
break;
|
|
case OWNBITS_USECFREE:
|
|
free(bits);
|
|
break;
|
|
case OWNBITS_USESYSFREE:
|
|
WASABI_API_MEMMGR->sysFree(bits);
|
|
break;
|
|
case OWNBITS_USEIMGLDR:
|
|
{
|
|
if (WASABI_API_IMGLDR)
|
|
{
|
|
if (fromskin)
|
|
WASABI_API_IMGLDR->imgldr_releaseSkinBitmap(bits);
|
|
else
|
|
#ifndef _WASABIRUNTIME
|
|
WASABI_API_IMGLDR->imgldr_releaseBmp(bits);
|
|
#else
|
|
WASABI_API_IMGLDR->imgldr_releaseSkinBitmap(bits);
|
|
#endif
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
bits = NULL;
|
|
|
|
if (bitmapname && bitmapname != skinBitmapBlankName)
|
|
free(bitmapname);
|
|
}
|
|
|
|
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
|
|
|
|
extern DWORD bitmap_cache_tls;
|
|
|
|
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;
|
|
|
|
BltCanvas *blitToRectCanvas=0;
|
|
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;
|
|
|
|
/* create cached canvas for this thread if it doesn't exist */
|
|
blitToRectCanvas = (BltCanvas *)TlsGetValue(bitmap_cache_tls);
|
|
if (!blitToRectCanvas)
|
|
{
|
|
blitToRectCanvas = new BltCanvas(cwidth, cheight);
|
|
TlsSetValue(bitmap_cache_tls, (LPVOID)blitToRectCanvas);
|
|
}
|
|
int cacheWidth, cacheHeight;
|
|
blitToRectCanvas->getDim(&cacheWidth, &cacheHeight, NULL);
|
|
|
|
/* resize cache if necessary */
|
|
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;
|
|
|
|
BltCanvas *blitToRectCanvas=0;
|
|
void *dib=canvas->getBits();
|
|
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;
|
|
|
|
/* create cached canvas for this thread if it doesn't exist */
|
|
blitToRectCanvas = (BltCanvas *)TlsGetValue(bitmap_cache_tls);
|
|
if (!blitToRectCanvas)
|
|
{
|
|
blitToRectCanvas = new BltCanvas(cwidth, cheight);
|
|
TlsSetValue(bitmap_cache_tls, (LPVOID)blitToRectCanvas);
|
|
}
|
|
int cacheWidth, cacheHeight;
|
|
blitToRectCanvas->getDim(&cacheWidth, &cacheHeight, NULL);
|
|
|
|
/* resize cache, if necessary */
|
|
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;
|
|
|
|
// Martin> TODO
|
|
// we should separate the stretching from this function and move it to the Shrink() function (avoiding breaks from this fragile class)
|
|
// HQSkinBitmap will then override the Shrink funtion in order to apply it's own resizing stuff.
|
|
// and if we ever want a new algorithm we can just create a new UltraFastAndCoolSkinBitmap class overriding the function again
|
|
|
|
if (xs<xe)
|
|
{
|
|
if (!has_alpha) // doesn't have alpha channel
|
|
{
|
|
if (!high_quality_resampling || dxv<65536 || dyv<65536)
|
|
{
|
|
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
|
|
{
|
|
Shrink(this, ys,ye,xe,xs, xstart,yv, (ARGB32 *)dib, pitch, dxv, dyv, alpha);
|
|
}
|
|
}
|
|
else // has alpha channel
|
|
{
|
|
// FUCKO: JF> BRENNAN FIX THESE BITCHES :)
|
|
if (alpha == 255) // no global alpha
|
|
{
|
|
if (!high_quality_resampling || dxv<65536 || dyv<65536)
|
|
{
|
|
#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
|
|
{
|
|
Shrink(this, ys,ye,xe,xs, xstart,yv, (ARGB32 *)dib, pitch, dxv, dyv, alpha);
|
|
}
|
|
}
|
|
else // has global alpha
|
|
{
|
|
if (!high_quality_resampling || dxv<65536 || dyv<65536)
|
|
{
|
|
#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);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Shrink(this, ys, ye, xe, xs, xstart, yv, (ARGB32 *)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;
|
|
}
|
|
|
|
void SkinBitmap::AddRef()
|
|
{
|
|
references++;
|
|
}
|
|
|
|
void SkinBitmap::Release()
|
|
{
|
|
if (--references == 0)
|
|
delete this;
|
|
} |