typedef void (*BlendFunc)(double *dst, double *src, double val);

void bfuncCopy(double *dst, double *src, double val)

  { memcpy(dst, src, 4*sizeof(double)); }

void bfuncMix(double *dst, double *src, double val) {

  double iv = 1 - val;

  dst[0] = dst[0]*iv + src[0]*val;

  dst[1] = dst[1]*iv + src[1]*val;

  dst[2] = dst[2]*iv + src[2]*val;

  dst[3] = dst[3]*iv + src[3]*val;

}

void bfuncComposite(double *dst, double *src, double val) {

  val *= src[3];

  double iv = 1 - val;

  dst[0] = dst[0]*iv + src[0]*val;

  dst[1] = dst[1]*iv + src[1]*val;

  dst[2] = dst[2]*iv + src[2]*val;

  dst[3] = 1 - (1 - dst[3])*val;

}

void bfuncSum(double *dst, double *src, double val) {

  val *= src[3];

  dst[0] = dst[0] + src[0]*val;

  dst[1] = dst[1] + src[1]*val;

  dst[2] = dst[2] + src[2]*val;

}

void bfuncMul(double *dst, double *src, double val) {

  val *= src[3];

  double iv = 1 - val;

  dst[0] = dst[0]*iv + dst[0]*src[0]*val;

  dst[1] = dst[1]*iv + dst[1]*src[1]*val;

  dst[2] = dst[2]*iv + dst[2]*src[2]*val;

}

void filterBlendEx(Img *img, Img *src, BlendFunc func, double val, int dx, int dy, int sx, int sy, int w, int h) {

  if (!img->data || !src->data || !func) return;

  if (sx < 0) { dx -= sx; w += sx; sx = 0; }

  if (sy < 0) { dy -= sy; h += sy; sy = 0; }

  if (dx < 0) { sx -= dx; w += dx; dx = 0; }

  if (dy < 0) { sy -= dy; h += dy; dy = 0; }

  if (w > img->w - dx) w = img->w - dx;

  if (h > img->h - dy) h = img->h - dy;

  if (w > src->w - sx) w = src->w - sx;

  if (h > src->h - sy) h = src->h - sy;

  if (w <= 0 || h <= 0) return;

  int dr = 4*(img->w - w);

  int sr = 4*(src->w - w);

  if (img == src) {

    int offset = ((sy - dy)*img->w + sx - dx)*4;

    if (offset > 0) {

      for(double *pd = imgPixel(img, dx, dy), *e = pd + 4*h*img->w; pd < e; pd += dr)

        for(double *re = pd + 4*w; pd < re; pd += 4)

          func(pd, pd + offset, val);

    } else

    if (offset < 0) {

      for(double *pd = imgPixel(img, dx+w-1, dy+h-1), *e = pd - 4*h*img->w; pd > e; pd -= dr)

        for(double *re = pd - 4*w; pd > re; pd -= 4)

          func(pd, pd + offset, val);

    } else {

      double ps[4];

      for(double *pd = imgPixel(img, dx, dy), *e = pd + 4*h*img->w; pd < e; pd += dr)

        for(double *re = pd + 4*w; pd < re; pd += 4)

          { memcpy(ps, pd, sizeof(ps)); func(pd, ps, val); }

    }

  } else {

    for(double *pd = imgPixel(img, dx, dy), *ps = imgPixel(src, sx, sy), *e = pd + 4*h*img->w; pd < e; pd += dr, ps += sr)

      for(double *re = pd + 4*w; pd < re; pd += 4, ps += 4)

        func(pd, ps, val);

  }

}

void filterBlend(Img *img, Img *src, BlendFunc func, double val)

  { filterBlendEx(img, src, func, val, 0, 0, 0, 0, src->w, src->h); }

void imgCopyTo(Img *img, Img *src, int dx, int dy, int sx, int sy, int w, int h)

  { filterBlendEx(img, src, bfuncCopy, 1, dx, dy, sx, sy, w, h); }

void imgCropTo(Img *img, Img *src, int x, int y, int w, int h) {

  imgInit(img, w, h);

  imgCopyTo(img, src, 0, 0, x, y, w, h);

}

void imgCrop(Img *img, int x, int y, int w, int h) {

  Img imgC = {};

  imgSwap(img, &imgC);

  imgCropTo(img, &imgC, x, y, w, h);

  imgDestroy(&imgC);

}

void imgCopy(Img *img, Img *src)

  { imgCropTo(img, src, 0, 0, src->w, src->h); }