/* Copyright (C) 2001-2006 Artifex Software, Inc.
   All Rights Reserved.
  
   This software is provided AS-IS with no warranty, either express or
   implied.

   This software is distributed under license and may not be copied, modified
   or distributed except as expressly authorized under the terms of that
   license.  Refer to licensing information at http://www.artifex.com/
   or contact Artifex Software, Inc.,  7 Mt. Lassen Drive - Suite A-134,
   San Rafael, CA  94903, U.S.A., +1(415)492-9861, for further information.
*/

/* $Id: gxidata.c 8803 2008-06-24 14:16:29Z leonardo $ */
/* Generic image enumeration and cleanup */
#include "gx.h"
#include "memory_.h"
#include "gserrors.h"
#include "gxdevice.h"
#include "gxcpath.h"
#include "gximage.h"

/* Forward declarations */
static void update_strip(gx_image_enum *penum);
static void repack_bit_planes(const gx_image_plane_t *src_planes,
			       const ulong *offsets, int num_planes,
			       byte *buffer, int width,
			       const sample_lookup_t * ptab, int spread);
static gx_device *setup_image_device(const gx_image_enum *penum);

/* Process the next piece of an ImageType 1 image. */
int
gx_image1_plane_data(gx_image_enum_common_t * info,
		     const gx_image_plane_t * planes, int height,
		     int *rows_used)
{
    gx_image_enum *penum = (gx_image_enum *) info;
    gx_device *dev;
    const int y = penum->y;
    int y_end = min(y + height, penum->rect.h);
    int width_spp = penum->rect.w * penum->spp;
    int num_planes = penum->num_planes;
    int num_components_per_plane = 1;

#define BCOUNT(plane)		/* bytes per data row */\
  (((penum->rect.w + (plane).data_x) * penum->spp * penum->bps / num_planes\
    + 7) >> 3)

    fixed adjust = penum->adjust;
    ulong offsets[GS_IMAGE_MAX_COMPONENTS];
    int ignore_data_x;
    bool bit_planar = penum->num_planes > penum->spp;
    int code;

    if (height == 0) {
	*rows_used = 0;
	return 0;
    }
    dev = setup_image_device(penum);

    /* Now render complete rows. */

    if (penum->used.y) {
	/*
	 * Processing was interrupted by an error.  Skip over rows
	 * already processed.
	 */
	int px;

	for (px = 0; px < num_planes; ++px)
	    offsets[px] = planes[px].raster * penum->used.y;
	penum->used.y = 0;
    } else
	memset(offsets, 0, num_planes * sizeof(offsets[0]));
    if (num_planes == 1 && penum->plane_depths[0] != penum->bps) {
	/* A single plane with multiple components. */
	num_components_per_plane = penum->plane_depths[0] / penum->bps;
    }
    for (; penum->y < y_end; penum->y++) {
	int px;
	const byte *buffer;
	int sourcex;
	int x_used = penum->used.x;

	if (bit_planar) {
	    /* Repack the bit planes into byte-wide samples. */
	    
	    buffer = penum->buffer;
	    sourcex = 0;
	    for (px = 0; px < num_planes; px += penum->bps)
		repack_bit_planes(planes, offsets, penum->bps, penum->buffer,
				  penum->rect.w, &penum->map[px].table,
				  penum->spread);
	    for (px = 0; px < num_planes; ++px)
		offsets[px] += planes[px].raster;
	} else {
	    /*
	     * Normally, we unpack the data into the buffer, but if
	     * there is only one plane and we don't need to expand the
	     * input samples, we may use the data directly.
	     */
	    sourcex = planes[0].data_x;
	    buffer =
		(*penum->unpack)(penum->buffer, &sourcex,
				 planes[0].data + offsets[0],
				 planes[0].data_x, BCOUNT(planes[0]),
				 &penum->map[0], penum->spread, num_components_per_plane);

	    offsets[0] += planes[0].raster;
	    for (px = 1; px < num_planes; ++px) {
		(*penum->unpack)(penum->buffer + (px << penum->log2_xbytes),
				 &ignore_data_x,
				 planes[px].data + offsets[px],
				 planes[px].data_x, BCOUNT(planes[px]),
				 &penum->map[px], penum->spread, 1);
		offsets[px] += planes[px].raster;
	    }
	}
#ifdef DEBUG
	if (gs_debug_c('b'))
	    dprintf1("[b]image1 y=%d\n", y);
	if (gs_debug_c('B')) {
	    int i, n = width_spp;

	    if (penum->bps > 8)
		n *= 2;
	    else if (penum->bps == 1 && penum->unpack_bps == 8)
		n = (n + 7) / 8;
	    dlputs("[B]row:");
	    for (i = 0; i < n; i++)
		dprintf1(" %02x", buffer[i]);
	    dputs("\n");
	}
#endif
	penum->cur.x = dda_current(penum->dda.row.x);
	dda_next(penum->dda.row.x);
	penum->cur.y = dda_current(penum->dda.row.y);
	dda_next(penum->dda.row.y);
	if (!penum->interpolate)
	    switch (penum->posture) {
		case image_portrait:
		    {		/* Precompute integer y and height, */
			/* and check for clipping. */
			fixed yc = penum->cur.y,
			    yn = dda_current(penum->dda.row.y);

			if (yn < yc) {
			    fixed temp = yn;

			    yn = yc;
			    yc = temp;
			}
			yc -= adjust;
			if (yc >= penum->clip_outer.q.y)
			    goto mt;
			yn += adjust;
			if (yn <= penum->clip_outer.p.y)
			    goto mt;
			penum->yci = fixed2int_pixround_perfect(yc);
			penum->hci = fixed2int_pixround_perfect(yn) - penum->yci;
			if (penum->hci == 0)
			    goto mt;
			if_debug2('b', "[b]yci=%d, hci=%d\n",
				  penum->yci, penum->hci);
		    }
		    break;
		case image_landscape:
		    {		/* Check for no pixel centers in x. */
			fixed xc = penum->cur.x,
			    xn = dda_current(penum->dda.row.x);

			if (xn < xc) {
			    fixed temp = xn;

			    xn = xc;
			    xc = temp;
			}
			xc -= adjust;
			if (xc >= penum->clip_outer.q.x)
			    goto mt;
			xn += adjust;
			if (xn <= penum->clip_outer.p.x)
			    goto mt;
			penum->xci = fixed2int_pixround_perfect(xc);
			penum->wci = fixed2int_pixround_perfect(xn) - penum->xci;
			if (penum->wci == 0)
			    goto mt;
			if_debug2('b', "[b]xci=%d, wci=%d\n",
				  penum->xci, penum->wci);
		    }
		    break;
		case image_skewed:
		    ;
	    }
	update_strip(penum);
	if (x_used) {
	    /*
	     * Processing was interrupted by an error.  Skip over pixels
	     * already processed.
	     */
	    dda_advance(penum->dda.pixel0.x, x_used);
	    dda_advance(penum->dda.pixel0.y, x_used);
	    penum->used.x = 0;
	}
	if_debug2('b', "[b]pixel0 x=%g, y=%g\n",
		  fixed2float(dda_current(penum->dda.pixel0.x)),
		  fixed2float(dda_current(penum->dda.pixel0.y)));
	code = (*penum->render)(penum, buffer, sourcex + x_used,
				width_spp - x_used * penum->spp, 1, dev);
	if (code < 0) {
	    /* Error or interrupt, restore original state. */
	    penum->used.x += x_used;
	    if (!penum->used.y) {
		dda_previous(penum->dda.row.x);
		dda_previous(penum->dda.row.y);
		dda_translate(penum->dda.strip.x,
			      penum->prev.x - penum->cur.x);
		dda_translate(penum->dda.strip.y,
			      penum->prev.y - penum->cur.y);
	    }
	    goto out;
	}
	penum->prev = penum->cur;
      mt:;
    }
    if (penum->y < penum->rect.h) {
	code = 0;
    } else {
	/* End of input data.  Render any left-over buffered data. */
	code = gx_image1_flush(info);
	if (code >= 0)
	    code = 1;
    }
out:
    /* Note that caller must call end_image */
    /* for both error and normal termination. */
    *rows_used = penum->y - y;
    return code;
}

/* Flush any buffered data. */
int
gx_image1_flush(gx_image_enum_common_t * info)
{
    gx_image_enum *penum = (gx_image_enum *)info;
    int width_spp = penum->rect.w * penum->spp;
    fixed adjust = penum->adjust;

    penum->cur.x = dda_current(penum->dda.row.x);
    penum->cur.y = dda_current(penum->dda.row.y);
    switch (penum->posture) {
	case image_portrait:
	    {
		fixed yc = penum->cur.y;

		penum->yci = fixed2int_rounded(yc - adjust);
		penum->hci = fixed2int_rounded(yc + adjust) - penum->yci;
	    }
	    break;
	case image_landscape:
	    {
		fixed xc = penum->cur.x;

		penum->xci = fixed2int_rounded(xc - adjust);
		penum->wci = fixed2int_rounded(xc + adjust) - penum->xci;
	    }
	    break;
	case image_skewed:	/* pacify compilers */
	    ;
    }
    update_strip(penum);
    penum->prev = penum->cur;
    return (*penum->render)(penum, NULL, 0, width_spp, 0,
			    setup_image_device(penum));
}

/* Update the strip DDA when moving to a new row. */
static void
update_strip(gx_image_enum *penum)
{

#if 1 
    /* Old code. */
    dda_translate(penum->dda.strip.x, penum->cur.x - penum->prev.x);
    dda_translate(penum->dda.strip.y, penum->cur.y - penum->prev.y);
    penum->dda.pixel0 = penum->dda.strip;
#else
    /* A better precision with stromng dda_advance -
       doesn't work becauae gx_image1_plane_data
       doesn't call it at each step. */
    gx_dda_fixed_point temp;

    temp.x.state = penum->dda.strip.x.state;
    temp.y.state = penum->dda.strip.y.state;
    temp.x.step = penum->dda.row.x.step;
    temp.y.step = penum->dda.row.y.step;
    dda_next(temp.x);
    dda_next(temp.y);
    penum->dda.strip.x.state = temp.x.state;
    penum->dda.strip.y.state = temp.y.state;
    penum->dda.pixel0 = penum->dda.strip;
#endif
}

/*
 * Repack 1 to 8 individual bit planes into 8-bit samples.
 * buffer is aligned, and includes padding to an 8-byte boundary.
 * This procedure repacks one row, so the only relevant members of
 * src_planes are data and data_x (not raster).
 */
static void
repack_bit_planes(const gx_image_plane_t *src_planes, const ulong *offsets,
		  int num_planes, byte *buffer, int width,
		  const sample_lookup_t * ptab, int spread)
{
    gx_image_plane_t planes[8];
    byte *zeros = 0;
    byte *dest = buffer;
    int any_data_x = 0;
    bool direct = (spread == 1 && ptab->lookup8[0] == 0 &&
		   ptab->lookup8[255] == 255);
    int pi, x;
    gx_image_plane_t *pp;

    /*
     * Set up the row pointers, taking data_x and null planes into account.
     * If there are any null rows, we need to create a block of zeros in
     * order to avoid tests in the loop.
     */
    for (pi = 0, pp = planes; pi < num_planes; ++pi, ++pp)
	if (src_planes[pi].data == 0) {
	    if (!zeros) {
		zeros = buffer + width - ((width + 7) >> 3);
	    }
	    pp->data = zeros;
	    pp->data_x = 0;
	} else {
	    int dx = src_planes[pi].data_x;

	    pp->data = src_planes[pi].data + (dx >> 3) + offsets[pi];
	    any_data_x |= (pp->data_x = dx & 7);
	}
    if (zeros)
	memset(zeros, 0, buffer + width - zeros);

    /*
     * Now process the data, in blocks of one input byte column
     * (8 output bytes).
     */
    for (x = 0; x < width; x += 8) {
	bits32 w0 = 0, w1 = 0;
#if arch_is_big_endian
	static const bits32 expand[16] = {
	    0x00000000, 0x00000001, 0x00000100, 0x00000101,
	    0x00010000, 0x00010001, 0x00010100, 0x00010101,
	    0x01000000, 0x01000001, 0x01000100, 0x01000101,
	    0x01010000, 0x01010001, 0x01010100, 0x01010101
	};
#else
	static const bits32 expand[16] = {
	    0x00000000, 0x01000000, 0x00010000, 0x01010000,
	    0x00000100, 0x01000100, 0x00010100, 0x01010100,
	    0x00000001, 0x01000001, 0x00010001, 0x01010001,
	    0x00000101, 0x01000101, 0x00010101, 0x01010101
	};
#endif

	if (any_data_x) {
	    for (pi = 0, pp = planes; pi < num_planes; ++pi, ++pp) {
		uint b = *(pp->data++);
		int dx = pp->data_x;

		if (dx) {
		    b <<= dx;
		    if (x + 8 - dx < width)
			b += *pp->data >> (8 - dx);
		}
		w0 = (w0 << 1) | expand[b >> 4];
		w1 = (w1 << 1) | expand[b & 0xf];
	    }
	} else {
	    for (pi = 0, pp = planes; pi < num_planes; ++pi, ++pp) {
		uint b = *(pp->data++);

		w0 = (w0 << 1) | expand[b >> 4];
		w1 = (w1 << 1) | expand[b & 0xf];
	    }
	}
	/*
	 * We optimize spread == 1 and identity ptab together, although
	 * we could subdivide these 2 cases into 4 if we wanted.
	 */
	if (direct) {
	    ((bits32 *)dest)[0] = w0;
	    ((bits32 *)dest)[1] = w1;
	    dest += 8;
	} else {
#define MAP_BYTE(v) (ptab->lookup8[(byte)(v)])
	    dest[0] = MAP_BYTE(w0 >> 24); dest += spread;
	    dest[1] = MAP_BYTE(w0 >> 16); dest += spread;
	    dest[2] = MAP_BYTE(w0 >> 8); dest += spread;
	    dest[3] = MAP_BYTE(w0); dest += spread;
	    dest[4] = MAP_BYTE(w1 >> 24); dest += spread;
	    dest[5] = MAP_BYTE(w1 >> 16); dest += spread;
	    dest[6] = MAP_BYTE(w1 >> 8); dest += spread;
	    dest[7] = MAP_BYTE(w1); dest += spread;
#undef MAP_BYTE
	}
    }
}

/* Set up the device for drawing an image. */
static gx_device *
setup_image_device(const gx_image_enum *penum)
{
    gx_device *dev = penum->dev;

    if (penum->clip_dev) {
	gx_device_clip *cdev = penum->clip_dev;

	gx_device_set_target((gx_device_forward *)cdev, dev);
	dev = (gx_device *) cdev;
    }
    if (penum->rop_dev) {
	gx_device_rop_texture *rtdev = penum->rop_dev;

	gx_device_set_target((gx_device_forward *)rtdev, dev);
	dev = (gx_device *) rtdev;
    }
    return dev;
}

/* Clean up by releasing the buffers. */
/* Currently we ignore draw_last. */
int
gx_image1_end_image(gx_image_enum_common_t * info, bool draw_last)
{
    gx_image_enum *penum = (gx_image_enum *) info;
    gs_memory_t *mem = penum->memory;
    stream_image_scale_state *scaler = penum->scaler;

    if_debug2('b', "[b]%send_image, y=%d\n",
	      (penum->y < penum->rect.h ? "premature " : ""), penum->y);
    if (draw_last) {
	int code = gx_image_flush(info);

	if (code < 0)
	    return code;
    }

   /* release the reference to the target */
    if ( penum->rop_dev )
        gx_device_set_target((gx_device_forward *)penum->rop_dev, NULL);
    if ( penum->clip_dev )
        gx_device_set_target((gx_device_forward *)penum->clip_dev, NULL);
    /* it is not clear (to me) why these are freed explicitly instead
       of using reference counting */
    gs_free_object(mem, penum->rop_dev, "image RasterOp");
    gs_free_object(mem, penum->clip_dev, "image clipper");

    if (scaler != 0) {
	(*scaler->template->release) ((stream_state *) scaler);
	gs_free_object(mem, scaler, "image scaler state");
    }
    gs_free_object(mem, penum->line, "image line");
    gs_free_object(mem, penum->buffer, "image buffer");
    gx_image_free_enum(&info);
    return 0;
}
