libtthimage/Lib/bitblt.c

251 lines
4.9 KiB
C

/*
bitblt.c
--------
Dans ce module, il y a énormement d'optimisations de vitesse
à faire. Je le sais. Mais mon neurone est en surcharge...
-------------------------------------------------------
voir aussi: insert.c
*/
#include <stdio.h>
#include <stdlib.h>
#include "../tthimage.h"
/*::------------------------------------------------------------------::*/
/*
* la structure 'z' decrit les pixels sources (dimensions et position)
* et les parametres x et y disent ou recopier les pixels dans l'image
* de destination.
*/
int
Image_get_rect(Image_Desc *s, Image_Rect *z, Image_Desc *d, int x, int y)
{
int xfoo, yfoo; /* oh! des 'foo' 2D :-) */
int xs, ys;
#if DEBUG_LEVEL > 1
fprintf(stderr, "GET RECT src %p %4d, %4d, %4d, %4d\n",
s, z->x, z->y, z->w, z->h);
fprintf(stderr, " dst %p %4d, %4d\n", d, x, y);
#endif
if ( (z->w > d->width) || (z->h > d->height) )
{
return 666;
}
for (yfoo=0; yfoo<z->h; yfoo++)
{
ys = yfoo + z->y;
if (ys<0 || ys>s->height-1)
continue;
for (xfoo=0; xfoo<z->w; xfoo++)
{
xs = xfoo + z->x;
if (xs<0 || xs>s->width-1)
continue;
Image_pixel_copy(s, xs, ys, d, x+xfoo, y+yfoo);
}
}
return 0;
}
/*::------------------------------------------------------------------::*/
/*
* recopie d'un rectangle d'une image source par dessus
* une image destination.
*/
int
Image_put_rect(Image_Desc *s, Image_Rect *z, Image_Desc *d, int x, int y)
{
int xfoo, yfoo;
int xs, ys, xd, yd;
#if DEBUG_LEVEL > 1
fprintf(stderr, "PUT RECT src %p %4d, %4d, %4d, %4d\n",
s, z->x, z->y, z->w, z->h);
fprintf(stderr, " dst %p %4d, %4d\n", d, x, y);
#endif
for (yfoo=0; yfoo<z->h; yfoo++)
{
ys = yfoo + z->y;
if (ys<0 || ys>s->height-1)
continue;
yd = yfoo + y;
if (yd<0 || yd>d->height-1)
continue;
for (xfoo=0; xfoo<z->w; xfoo++)
{
xs = xfoo + z->x;
if (xs<0 || xs>s->width-1)
continue;
xd = xfoo + x;
if (xd<0 || xd>d->width-1)
continue;
Image_pixel_copy(s, xs, ys, d, xd, yd);
}
}
return FUNC_IS_ALPHA;
}
/*::------------------------------------------------------------------::*/
/*
* coredumper dlmkt !
*/
int
Image_copy_rect(Image_Desc *s, Image_Rect *z, Image_Desc *d, int x, int y)
{
int xs, ys, xd, yd, xx, yy;
int foo;
#if DEBUG_LEVEL > 1
fprintf(stderr, "%s s=%p z=%p d=%p x,y=%d,%d\n", __func__,
s, z, d, x, y);
#endif
if (d->magic != MAGIC_OF_IMAGE)
{
fprintf(stderr, "%s: need Dead Beef\n", __func__);
return NOT_AN_IMAGE_DESC;
}
foo = 0;
for (yy=0; yy<z->h; yy++)
{
ys = yy + z->y;
if (ys<0 || ys>=s->height)
continue;
yd = y + yy;
if (yd<0 || yd>=d->height)
continue;
for (xx=0; xx<z->w; xx++)
{
xs = xx + z->x;
if (xs<0 || xs>=s->width)
continue;
xd = x + xx;
if (xd<0 || xd>=d->width)
continue;
Image_pixel_copy(s, xs, ys, d, xd, yd);
foo++;
}
}
return FUNC_IS_BETA;
}
/*::------------------------------------------------------------------::*/
/*
* nouveau 11 jan 00 cree a la rache pour extraitre des images
* 256x256 afin de tester FFTW :-)
*
* 23 dec 01 found a coredump if src image is too small
*
*/
Image_Desc *
Image_create_subimg(Image_Desc *src, Image_Rect *r, int gray)
{
Image_Desc *clone;
int x,y,xs, ys;
/*
* sanities controls...
*/
if (src->type != IMAGE_RGB)
{
fprintf(stderr, "'%s' work only on RGB images\n", __func__);
exit(5);
}
if ( (r->x<0) || (r->y<0) )
{
fprintf(stderr, "create_subimg, rect(%d,%d,%d,%d) iznotgoud\n",
r->x, r->y, r->w, r->h);
exit(5);
}
/* MUST CHECK THAT SOURCE IMAGE IS BIG ENOUGH ! */
/*
* now, we allocate the new image...
*/
clone = Image_alloc(r->w, r->h, src->type);
if (clone == NULL)
{
fprintf(stderr, "CreateSubImage: can't alloc memory...\n");
exit(5);
}
for (x=0; x<r->w; x++)
{
xs = x + r->x;
for (y=0; y<r->h; y++)
{
ys = y + r->y;
/*printf("dst %4d %4d ", x, y); */
/*printf("src %4d %4d ", xs, ys); */
if (ys<0 || ys>src->width)
{
Image_plotRGB(clone, x, y, gray, gray, gray);
}
else
{
/* XXX calling this func is a nasty cpu sucker,
* so we have to go to a nasty optimize trick */
/* XXX Image_pixel_copy(src, xs, ys, clone, x, y); */
(clone->Rpix[y])[x] = (src->Rpix[ys])[xs];
(clone->Gpix[y])[x] = (src->Gpix[ys])[xs];
(clone->Bpix[y])[x] = (src->Bpix[ys])[xs];
}
}
}
return clone;
}
/*::------------------------------------------------------------------::*/
/*
http://highwire.atari-users.net/cgi-bin/cvsweb/~checkout~lib/gemlib/rc_intersect.c?rev=1.2
*/
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
int
rc_intersect (const Image_Rect * r1, Image_Rect * r2)
{
int tx, ty, tw, th, ret;
tx = max (r2->x, r1->x);
tw = min (r2->x + r2->w, r1->x + r1->w) - tx;
ret = (0 < tw);
if (ret)
{
ty = max (r2->y, r1->y);
th = min (r2->y + r2->h, r1->y + r1->h) - ty;
ret = (0 < th);
if (ret)
{
r2->x = tx;
r2->y = ty;
r2->w = tw;
r2->h = th;
}
}
return ret;
}
/*::------------------------------------------------------------------::*/