# include "Ximage.h"

# define MY_SWAP_INT(A,B) { int tmp; tmp = A; A = B; B = tmp; }

# define MY_SWAP_WORD(W) { \
  char tmp, *X; \
  X = (char *) &W; \
  tmp = X[0]; X[0] = X[3]; X[3] = tmp; \
  tmp = X[1]; X[1] = X[2]; X[2] = tmp; }

void Remap32 (Graphic *graphic, KapaImageWidget *image, Picture *picture, Matrix *matrix) {

  int i, j, ii, jj;
  int i_start, i_end, j_start, j_end;
  int dropback, inDX, inDY;
  int dx, dy, DX, DY;
  double expand, Ix, Iy;
  int expand_in, expand_out;
  unsigned int *out_pix, *out_pix2;
  unsigned short *in_pix, *in_pix2;
  unsigned long *pixel, pixvalue;
  unsigned long back;
  int swap_client, swap_server, swap_bytes;

  ALLOCATE (pixel, unsigned long, graphic[0].Npixels);

# ifdef BYTE_SWAP
  swap_client = 1;
# else 
  swap_client = 0;
# endif  

  swap_server = ImageByteOrder (graphic[0].display);
  swap_bytes = !(swap_client ^ swap_server);

  // local array for pixel values
  for (i = 0; i < graphic[0].Npixels; i++) { 
    pixel[i] = graphic[0].cmap[i].pixel;
    if (swap_bytes) MY_SWAP_WORD(pixel[i]);
  }
  back = graphic[0].back;
  if (swap_bytes) MY_SWAP_WORD(back);

  // set up expansions
  assert ((picture[0].expand >= 1) || (picture[0].expand <= -1));
  expand = expand_in = expand_out = 1.0;
  if (picture[0].expand > 0) {
    expand = 1 / (1.0*picture[0].expand);
    expand_out = picture[0].expand;
    expand_in  = 1;
  }
  if (picture[0].expand < 0) {
    expand = fabs((double)picture[0].expand);
    expand_out = 1;
    expand_in  = -picture[0].expand;
  }

  // define the image sizes
  dx = picture[0].dx;
  dy = picture[0].dy;
  DX = matrix[0].Naxis[0];
  DY = matrix[0].Naxis[1];

  // x, y are the closest lit screen pixel to 0,0
  Picture_Lower (&i_start, &j_start, matrix, picture);

  // x, y are the closest lit screen pixel to dx, dy
  Picture_Upper (&i_end, &j_end, matrix, picture);

  if (i_end < i_start) MY_SWAP_INT (i_start, i_end);
  if (j_end < j_start) MY_SWAP_INT (j_start, j_end);

  // Ix,Iy are the first displayed image pixel
  Picture_to_Image (&Ix, &Iy, i_start, j_start, picture);
  Ix = MIN (MAX (0, Ix), DX - 1);
  Iy = MIN (MAX (0, Iy), DY - 1);
  // XXX not completely consistent with the i_start, i_end range...

  // we need to offset because i_start points to the bottom edge of Ix
  // if (picture[0].flipx) Ix -= 1.0;
  // if (picture[0].flipy) Iy -= 1.0;

  inDX = picture[0].flipx ? -1 : +1;
  inDY = picture[0].flipy ? -1 : +1;

  dropback = expand_out - (i_end - i_start) % expand_out;
  if ((i_end - i_start) % expand_out == 0) dropback = 0;

  out_pix = (unsigned int *) picture[0].data;
  in_pix  = &image[0].pixmap[DX*(int)MAX(Iy,0) + (int)MAX(Ix,0)];

  /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/

  /**** fill in bottom area ****/
  for (j = 0; j < dx*j_start; j++, out_pix++) {
    *out_pix = back;
  }
  
  for (j = j_start; j < j_end; j+= expand_out, out_pix+=(expand_out-1)*dx, in_pix += inDY*expand_in*DX) {

    /**** fill in area to the left of the picture ****/
    for (jj = 0; (i_start > 0) && (jj < expand_out); jj++) { 
      out_pix2 = out_pix + jj*dx;
      for (i = 0; i < i_start; i++, out_pix2++) {
	*out_pix2 = back;
      }
    }
    out_pix += i_start;
    
    /*** fill in the picture region ***/
    in_pix2 = in_pix;
    if (expand_out == 1) {
      for (i = i_start; i < i_end; i++, in_pix2 += inDX*expand_in, out_pix++) {
	*out_pix = pixel[*in_pix2];
      }
    } else {
      for (i = i_start; i < i_end; i+= expand_out, in_pix2 += inDX, out_pix+= expand_out) { 
	pixvalue = pixel[*in_pix2];
	out_pix2 = out_pix;
	for (jj = 0; jj < expand_out; jj++, out_pix2+=(dx-expand_out)) {
	  for (ii = 0; ii < expand_out; ii++, out_pix2++) {
	    *out_pix2 = pixvalue;
	  }
	}
      }
    }
    out_pix -= dropback;
    
    // assert (in_pix2 - image[0].pixmap <= DX*DY);
    // assert (in_pix2 - image[0].pixmap >= 0);
    // assert (in_pix - image[0].pixmap <= DX*DY);
    // assert (in_pix - image[0].pixmap >= 0);

    /**** fill in area to the right of the picture ****/
    for (jj = 0; jj < expand_out; jj++) {
      out_pix2 = out_pix + jj*dx;
      for (i = i_end; i < dx; i++, out_pix2++) {
	*out_pix2 = back;
      }
    }
    out_pix += (dx - i_end);
    // assert (out_pix - (unsigned int *)picture[0].data <= dx*dy);
    // assert (out_pix - (unsigned int *)picture[0].data >= 0);
  } 
  
  if ((j_end - j_start) % expand_out > 0)
    out_pix -= expand_out - (j_end - j_start) % expand_out;
  
  // assert (out_pix - (unsigned int *)picture[0].data <= dx*dy);
  // assert (out_pix - (unsigned int *)picture[0].data >= 0);

  /**** fill in top area ****/
  for (j = 0; (j < dx*(dy - j_end)) && (out_pix - (unsigned int *)picture[0].data < dx*dy); j++, out_pix++) { 
    *out_pix = back;
  }

  picture[0].pix = XCreateImage (graphic[0].display, graphic[0].visual, graphic[0].depth, ZPixmap, 0, 
					picture[0].data, picture[0].dx, picture[0].dy, 32, 0);

  free (pixel);
}
