#include <stdlib.h>
#include <strings.h>

#include <rop.h>

#include "rop-generic.h"

ROP_AREA *rop_create(unsigned int w, unsigned int h)
{
 ROP_AREA *r;
 int rb;

 rb = (w + 7) >> 3;
 r = malloc(sizeof(*r)+(rb*h));
 if (r)
  { r->bits = (void *)(r+1);
    r->rowbytes = rb;
    r->w = w;
    r->h = h;
  }
 return(r);
}

void rop_free(ROP_AREA *r)
{
 free(r);
}

unsigned int rop_w(const ROP_AREA *r)
{
 return(r->w);
}

unsigned int rop_h(const ROP_AREA *r)
{
 return(r->h);
}

void rop_loadrow(ROP_AREA *r, unsigned int y, const unsigned char *data)
{
 if (y >= r->h) return;
 bcopy(data,r->bits+(y*r->rowbytes),r->rowbytes);
}

void rop_fetchrow(const ROP_AREA *r, unsigned int y, unsigned char *data)
{
 if (y >= r->h) return;
 bcopy(r->bits+(y*r->rowbytes),data,r->rowbytes);
}

void rop_rop(
	const ROP_AREA *s,
	unsigned int sx, unsigned int sy, unsigned int w, unsigned int h,
	ROP_AREA *d,
	unsigned int dx, unsigned int dy,
	unsigned int rop)
{
 unsigned int x;
 unsigned int y;
 unsigned int srb;
 unsigned int drb;

 rop &= ROP_MASK;
 if (rop == ROP_DST) return;
 if ((dx >= d->w) || (dy >= d->h)) return;
 if (dx+w > d->w) w = d->w - dx;
 if (dy+h > d->h) h = d->h - dy;
 if (s)
  { if ((sx >= s->w) || (sy >= s->h)) return;
    if (sx+w > s->w) w = s->w - sx;
    if (sy+h > s->h) h = s->h - sy;
  }
 if ((w < 1) || (h < 1)) return;
 drb = d->rowbytes;
newrop:;
 switch (rop)
  { case ROP_CLR:
       if ((dx == 0) && (w == d->w))
	{ bzero(d->bits+(dy*drb),drb*h);
	}
       else
	{ unsigned char m;
	  unsigned char *p;
	  if ((dx & ~7) == ((dx+w-1) & ~7))
	   { m = (~((~0U)<<w)) << (7 - ((dx+w-1)&7));
	     p = d->bits + (dy*drb) + (dx >> 3);
	     if (m == 0xff) for (y=0;y<h;y++,p+=drb) *p = 0;
	     else           for (y=0;y<h;y++,p+=drb) *p &= ~m;
	   }
	  else
	   { if (dx & 7)
	      { m = ~ ((~0U) << (dx&7));
		p = d->bits + (dy*drb) + (dx >> 3);
		for (y=0;y<h;y++,p+=drb) *p &= ~m;
		w -= dx & 7;
		dx = (dx + 8) & ~7;
	      }
	     if (w & 7)
	      { m = ((~0U) << ((-w)&7));
		p = d->bits + (dy*drb) + ((dx+w) >> 3);
		for (y=0;y<h;y++,p+=drb) *p &= ~m;
		w &= ~7;
	      }
	     w >>= 3;
	     p = d->bits + (dy*drb) + (dx >> 3);
	     if (w > BZERO_MIN) for (y=0;y<h;y++,p+=drb) bzero(p,w);
	     else               for (y=0;y<h;y++,p+=drb) inline_fill(p,w,0);
	   }
	}
       return;
       break;
    case ROP_SET:
       if ((dx == 0) && (w == d->w))
	{ memset(d->bits+(dy*drb),0xff,drb*h);
	}
       else
	{ unsigned char m;
	  unsigned char *p;
	  if ((dx & ~7) == ((dx+w-1) & ~7))
	   { m = (~((~0U)<<w)) << (7 - ((dx+w-1)&7));
	     p = d->bits + (dy*drb) + (dx >> 3);
	     if (m == 0xff) for (y=0;y<h;y++,p+=drb) *p = 0xff;
	     else           for (y=0;y<h;y++,p+=drb) *p |= m;
	   }
	  else
	   { if (dx & 7)
	      { m = ~ ((~0U) << (dx&7));
		p = d->bits + (dy*drb) + (dx >> 3);
		for (y=0;y<h;y++,p+=drb) *p |= m;
		w -= dx & 7;
		dx = (dx + 8) & ~7;
	      }
	     if (w & 7)
	      { m = ((~0U) << ((-w)&7));
		p = d->bits + (dy*drb) + ((dx+w) >> 3);
		for (y=0;y<h;y++,p+=drb) *p |= m;
		w &= ~7;
	      }
	     w >>= 3;
	     p = d->bits + (dy*drb) + (dx >> 3);
	     if (w > MEMSET_MIN) for (y=0;y<h;y++,p+=drb) memset(p,0xff,w);
	     else                for (y=0;y<h;y++,p+=drb) inline_fill(p,w,0xff);
	   }
	}
       return;
       break;
    case ROP_NDST:
	{ unsigned char m;
	  unsigned char *p;
	  if ((dx & ~7) == ((dx+w-1) & ~7))
	   { m = (~((~0U)<<w)) << (7 - ((dx+w-1)&7));
	     p = d->bits + (dy*drb) + (dx >> 3);
	     for (y=0;y<h;y++,p+=drb) *p ^= m;
	   }
	  else
	   { if (dx & 7)
	      { m = ~ ((~0U) << (dx&7));
		p = d->bits + (dy*drb) + (dx >> 3);
		for (y=0;y<h;y++,p+=drb) *p ^= m;
		w -= dx & 7;
		dx = (dx + 8) & ~7;
	      }
	     if (w & 7)
	      { m = ((~0U) << ((-w)&7));
		p = d->bits + (dy*drb) + ((dx+w) >> 3);
		for (y=0;y<h;y++,p+=drb) *p ^= m;
		w &= ~7;
	      }
	     w >>= 3;
	     p = d->bits + (dy*drb) + (dx >> 3);
	     for (y=0;y<h;y++,p+=drb-w) for (x=0;x<w;x++) *p++ ^= 0xff;
	   }
	}
       return;
       break;
  }
 srb = s->rowbytes;
 if ((s != d) || (sy > dy) || ((sy == dy) && (sx > dx)))
  { unsigned int srow;
    unsigned int drow;
    unsigned char *sp;
    unsigned char *dp;
    unsigned char schar;
    unsigned char dchar;
    int sshift;
    int dshift;
    unsigned char m;
    srow = (sy*srb) + (sx >> 3);
    drow = (dy*drb) + (dx >> 3);
    for (y=0;y<h;y++,srow+=srb,drow+=drb)
     { sp = s->bits + srow;
       dp = d->bits + drow;
       schar = *sp;
       dchar = *dp;
       sshift = 7 - (sx & 7);
       dshift = 7 - (dx & 7);
       m = 1 << dshift;
       x = 0;
       while (1)
	{ if (ROP((schar>>sshift)&1,(dchar>>dshift)&1,rop)) dchar |= m;
	  else                                              dchar &= ~m;
	  x ++;
	  m >>= 1;
	  if (x >= w) break;
	  if (sshift-- == 0)
	   { sshift = 7;
	     schar = *++sp;
	   }
	  if (dshift-- == 0)
	   { *dp = dchar;
	     dshift = 7;
	     m = 0x80;
	     dchar = *++dp;
	   }
	}
       *dp = dchar;
     }
  }
 else if ((sy < dy) || ((sy == dy) && (sx < dx)))
  { unsigned int srow;
    unsigned int drow;
    unsigned char *sp;
    unsigned char *dp;
    unsigned char schar;
    unsigned char dchar;
    int sshift;
    int dshift;
    unsigned char m;
    srow = ((sy+h-1)*srb) + ((sx+w-1) >> 3);
    drow = ((dy+h-1)*drb) + ((dx+w-1) >> 3);
    for (y=0;y<h;y++,srow-=srb,drow-=drb)
     { sp = s->bits + srow;
       dp = d->bits + drow;
       schar = *sp;
       dchar = *dp;
       sshift = 7 - ((sx+w-1) & 7);
       dshift = 7 - ((dx+w-1) & 7);
       m = 1 << dshift;
       x = 0;
       while (1)
	{ if (ROP((schar>>sshift)&1,(dchar>>dshift)&1,rop)) dchar |= m;
	  else                                              dchar &= ~m;
	  x ++;
	  m <<= 1;
	  if (x >= w) break;
	  if (sshift++ == 7)
	   { sshift = 0;
	     schar = *--sp;
	   }
	  if (dshift++ == 7)
	   { *dp = dchar;
	     dshift = 0;
	     m = 1;
	     dchar = *--dp;
	   }
	}
       *dp = dchar;
     }
  }
 else
  { switch (rop & ROP_SRC_NXOR_DST)
     { case ROP_CLR: case ROP_SRC_NXOR_DST:
	  rop = (rop & 1) ? ROP_SET : ROP_CLR;
	  break;
       case ROP_SRC_NOR_DST:
	  rop = ROP_NDST;
	  break;
       case ROP_SRC_AND_DST:
	  return;
	  break;
     }
    goto newrop;
  }
}

int rop_getpixel(const ROP_AREA *r, unsigned int x, unsigned int y)
{
 if ((x >= r->w) || (y >= r->h)) return(0);
 return((r->bits[(y*r->rowbytes)+(x>>3)]>>(7-(x&7)))&1);
}

void rop_putpixel(ROP_AREA *r, unsigned int x, unsigned int y, unsigned int v)
{
 if ((x >= r->w) || (y >= r->h)) return;
 if (v)
  { r->bits[(y*r->rowbytes)+(x>>3)] |= 0x80 >> (x&7);
  }
 else
  { r->bits[(y*r->rowbytes)+(x>>3)] &= ~ (0x80 >> (x&7));
  }
}

unsigned int rop_ropbit(unsigned int rop, unsigned int src, unsigned int dst)
{
 return(ROP(src,dst,rop));
}