/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

/*
 *	  jpeg.c --- Glue code to Independent JPEG Group decoder library
 *    $Id: jpeg.c,v 3.1 1998-03-28 03:35:03 ltabb Exp $
 */


/*
#include "xp.h"
*/

#include "if.h"

#include "xp_core.h"
#include "merrors.h"

#include "il.h"

#include <ctype.h>		/* to declare isprint() */
#ifndef XP_MAC
#	 include <sys/types.h>
#endif

#include "jinclude.h"
#include "jpeglib.h"
#include "jerror.h"

extern int MK_OUT_OF_MEMORY;

#ifdef XP_OS2_HACK
/* IBM-MAS: We removed setjmp.h from XP_core.h, now we need it here. */
/*          We need to see if we can fix hwthreads/XP_CORE correctly.. */
#include <setjmp.h>
#endif

#ifdef PROFILE
#	 pragma profile on
#endif


/* Normal JFIF markers can't have more bytes than this. */
#define MAX_JPEG_MARKER_LENGTH	(((uint32)1 << 16) - 1)

/*
 * States that the jpeg decoder might be in
 */
typedef enum {
	JPEG_HEADER,                          /* Reading JFIF headers */
    JPEG_START_DECOMPRESS,
	JPEG_DECOMPRESS_PROGRESSIVE,          /* Output progressive pixels */
	JPEG_DECOMPRESS_SEQUENTIAL,           /* Output sequential pixels */
    JPEG_FINAL_PROGRESSIVE_SCAN_OUTPUT,
	JPEG_DONE,
    JPEG_SINK_NON_JPEG_TRAILER           /* Some image files have a */
                                         /* non-JPEG trailer */
} jstate;
	
typedef struct {
	struct jpeg_error_mgr pub;	/* "public" fields for IJG library*/
	jmp_buf setjmp_buffer;		/* For handling catastropic errors */
} il_error_mgr;

/*
 * Structure used to manage the JPEG decoder stream.
 */
typedef struct jpeg_struct {
	jstate state;				/* Decoder FSM state */
    int pass_num;
    int completed_output_passes;

    int rows_per_chunk;
    void *timeout;
    
	/* One scanline's worth of post-processed sample data */
	JSAMPARRAY samples;
	JSAMPARRAY samples3;
	/* IJG JPEG library decompressor state */
	struct jpeg_decompress_struct jd;
	il_error_mgr jerr;
	il_container *ic;
} jpeg_struct;




/* Possible states for JPEG source manager */
enum data_source_state {
	dss_consuming_backtrack_buffer = 0, /* Must be zero for init purposes */
	dss_consuming_netlib_buffer
};

/*
 *	Implementation of a JPEG src object that understands our state machine
 */
typedef struct {
	/* public fields; must be first in this struct! */
	struct jpeg_source_mgr pub;

	jpeg_struct *js;              /* pointer to netlib stream object */

	int bytes_to_skip;            /* remaining bytes to skip */

	enum data_source_state state;

	JOCTET *netlib_buffer;        /* next buffer for fill_input_buffer */
	uint32 netlib_buflen;

	/*
	 * Buffer of "remaining" characters left over after a call to 
	 * fill_input_buffer(), when no additional data is available.
	 */ 
	JOCTET *backtrack_buffer;
	size_t backtrack_buffer_size; /* Allocated size of backtrack_buffer		*/
	size_t backtrack_buflen;	  /* Offset of end of active backtrack data */
	size_t backtrack_num_unread_bytes; /* Length of active backtrack data	*/
} il_source_mgr;


/* Override the standard error method in the IJG JPEG decoder code. */
void PR_CALLBACK
il_error_exit (j_common_ptr cinfo)
{
    int error_code;
	il_error_mgr *err = (il_error_mgr *) cinfo->err;

#ifdef DEBUG
    if (il_debug >= 1) {
        char buffer[JMSG_LENGTH_MAX];

        /* Create the message */
        (*cinfo->err->format_message) (cinfo, buffer);

        XP_TRACE(("%s\n", buffer));
    }
#endif

    /* Convert error to a browser error code */
    if (cinfo->err->msg_code == JERR_OUT_OF_MEMORY)
        error_code = MK_OUT_OF_MEMORY;
    else
        error_code = MK_IMAGE_LOSSAGE;
        
	/* Return control to the setjmp point. */
	longjmp(err->setjmp_buffer, error_code);
}


void PR_CALLBACK
init_source (j_decompress_ptr jd)
{
}

/*-----------------------------------------------------------------------------
 * This is the callback routine from the IJG JPEG library used to supply new
 * data to the decompressor when its input buffer is exhausted.	 It juggles
 * multiple buffers in an attempt to avoid unnecessary copying of input data.
 *
 * (A simpler scheme is possible: It's much easier to use only a single
 * buffer; when fill_input_buffer() is called, move any unconsumed data
 * (beyond the current pointer/count) down to the beginning of this buffer and
 * then load new data into the remaining buffer space.	This approach requires
 * a little more data copying but is far easier to get right.)
 *
 * At any one time, the JPEG decompressor is either reading from the netlib
 * input buffer, which is volatile across top-level calls to the IJG library,
 * or the "backtrack" buffer.  The backtrack buffer contains the remaining
 * unconsumed data from the netlib buffer after parsing was suspended due
 * to insufficient data in some previous call to the IJG library.
 *
 * When suspending, the decompressor will back up to a convenient restart
 * point (typically the start of the current MCU). The variables
 * next_input_byte & bytes_in_buffer indicate where the restart point will be
 * if the current call returns FALSE.  Data beyond this point must be
 * rescanned after resumption, so it must be preserved in case the decompressor
 * decides to backtrack.
 *
 * Returns:
 *	TRUE if additional data is available, FALSE if no data present and
 *	 the JPEG library should therefore suspend processing of input stream
 *---------------------------------------------------------------------------*/
boolean PR_CALLBACK
fill_input_buffer (j_decompress_ptr jd)
{
	il_source_mgr *src = (il_source_mgr *)jd->src;
	enum data_source_state data_source_state = src->state;
    uint32 bytesToSkip, new_backtrack_buflen, new_buflen, roundup_buflen;
	unsigned char *new_buffer;

	ILTRACE(5,("il:jpeg: fill, state=%d, nib=0x%x, bib=%d", data_source_state,
               src->pub.next_input_byte, src->pub.bytes_in_buffer));

	switch (data_source_state) {

	/* Decompressor reached end of backtrack buffer. Return netlib buffer.*/
	case dss_consuming_backtrack_buffer:
		new_buffer = (unsigned char *)src->netlib_buffer;
		new_buflen = src->netlib_buflen;
        if ((new_buffer == NULL) || (new_buflen == 0))
            goto suspend;

        /*
         * Clear, so that repeated calls to fill_input_buffer() do not
         * deliver the same netlib buffer more than once.
         */
        src->netlib_buflen = 0;
        
		/* Discard data if asked by skip_input_data(). */
		bytesToSkip = src->bytes_to_skip;
		if (bytesToSkip) {
			if (bytesToSkip < new_buflen) {
				/* All done skipping bytes; Return what's left. */
				new_buffer += bytesToSkip;
				new_buflen -= bytesToSkip;
				src->bytes_to_skip = 0;
			} else {
				/* Still need to skip some more data in the future */
				src->bytes_to_skip -= (size_t)new_buflen;
                goto suspend;
			}
		}

		/* Save old backtrack buffer parameters, in case the decompressor
		 * backtracks and we're forced to restore its contents.
		 */
		src->backtrack_num_unread_bytes = src->pub.bytes_in_buffer;

		src->pub.next_input_byte = new_buffer;
		src->pub.bytes_in_buffer = (size_t)new_buflen;
		src->state = dss_consuming_netlib_buffer;
		return TRUE;

	/* Reached end of netlib buffer. Suspend */
	case dss_consuming_netlib_buffer:
		if (src->pub.next_input_byte != src->netlib_buffer) {
			/* Backtrack data has been permanently consumed. */
			src->backtrack_num_unread_bytes = 0;
			src->backtrack_buflen = 0;
		}

		/* Save remainder of netlib buffer in backtrack buffer */
		new_backtrack_buflen = src->pub.bytes_in_buffer + src->backtrack_buflen;
				
		/* Make sure backtrack buffer is big enough to hold new data. */
		if (src->backtrack_buffer_size < new_backtrack_buflen) {

			/* Round up to multiple of 16 bytes. */
			roundup_buflen = ((new_backtrack_buflen + 15) >> 4) << 4;
			if (src->backtrack_buffer_size) {
				src->backtrack_buffer =
					(JOCTET *)XP_REALLOC(src->backtrack_buffer, roundup_buflen);
			} else {
				src->backtrack_buffer = (JOCTET*)XP_ALLOC(roundup_buflen);
			}

            /* Check for OOM */
            if (! src->backtrack_buffer) {
                j_common_ptr cinfo = (j_common_ptr)(&src->js->jd);
                cinfo->err->msg_code = JERR_OUT_OF_MEMORY;
				il_error_exit(cinfo);
            }
                
			src->backtrack_buffer_size = (size_t)roundup_buflen;

			/* Check for malformed MARKER segment lengths. */
			if (new_backtrack_buflen > MAX_JPEG_MARKER_LENGTH)
				il_error_exit((j_common_ptr)(&src->js->jd));
		}

		/* Copy remainder of netlib buffer into backtrack buffer. */
		XP_BCOPY (src->pub.next_input_byte,
				  src->backtrack_buffer + src->backtrack_buflen,
				  src->pub.bytes_in_buffer);

		/* Point to start of data to be rescanned. */
		src->pub.next_input_byte = src->backtrack_buffer +
			src->backtrack_buflen - src->backtrack_num_unread_bytes;
		src->pub.bytes_in_buffer += src->backtrack_num_unread_bytes;
		src->backtrack_buflen = (size_t)new_backtrack_buflen;
		
		src->state = dss_consuming_backtrack_buffer;
        goto suspend;
			
	default:
		XP_ASSERT(0);
        return FALSE;
	}

  suspend:
    ILTRACE(5,("         Suspending, bib=%d", src->pub.bytes_in_buffer));
    return FALSE;
}

void PR_CALLBACK
skip_input_data (j_decompress_ptr jd, long num_bytes)
{
	il_source_mgr *src = (il_source_mgr *)jd->src;

#ifdef DEBUG
    ILTRACE(5, ("il:jpeg: skip_input_data js->buf=0x%x js->buflen=%d skip=%d",
                src->netlib_buffer, src->netlib_buflen,
                num_bytes));
#endif

	if (num_bytes > (long)src->pub.bytes_in_buffer) {
		/*
		 * Can't skip it all right now until we get more data from
		 * network stream. Set things up so that fill_input_buffer
		 * will skip remaining amount.
		 */
		src->bytes_to_skip = (size_t)num_bytes - src->pub.bytes_in_buffer;
		src->pub.next_input_byte += src->pub.bytes_in_buffer;
		src->pub.bytes_in_buffer = 0;
	} else {
		/* Simple case. Just advance buffer pointer */
		src->pub.bytes_in_buffer -= (size_t)num_bytes;
		src->pub.next_input_byte += num_bytes;
	}
}


/*
 * Terminate source --- called by jpeg_finish_decompress() after all
 * data has been read to clean up JPEG source manager.
 */
void PR_CALLBACK
term_source (j_decompress_ptr jd)
{
	/* No work necessary here */
}


/*-----------------------------------------------------------------------------
 * Setup a JPEG source object for streaming data in a demand-driven
 * fashion into the IJG JPEG decompression library.	 A JPEG source
 * object consists of a set of callback functions which the
 * decompressor library calls when it needs more data or to seek ahead
 * in the input stream.
 *
 * Returns:
 *	TRUE if setup succeeds, FALSE otherwise.
 *---------------------------------------------------------------------------*/
static int
setup_jpeg_src (j_decompress_ptr jd, jpeg_struct *js)
{
	il_source_mgr *src;

	if (jd->src == NULL) {
		src = XP_NEW_ZAP(il_source_mgr);
		if (!src) {
			XP_TRACE(("il:jpeg: src manager memory lossage"));
			return FALSE;
		}
		jd->src = (struct jpeg_source_mgr *) src;
	}

	src = (il_source_mgr *)jd->src;
	src->js = js;

	/* Setup callback functions. */
	src->pub.init_source = init_source;
	src->pub.fill_input_buffer = fill_input_buffer;
	src->pub.skip_input_data = skip_input_data;
	src->pub.resync_to_restart = jpeg_resync_to_restart;
	src->pub.term_source = term_source;

	return TRUE;
}



/*
 * Macros for fetching data from the data source module.
 *
 * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
 * the current restart point; we update them only when we have reached a
 * suitable place to restart if a suspension occurs.
 */

/* Declare and initialize local copies of input pointer/count */
#define INPUT_VARS(cinfo)  \
	struct jpeg_source_mgr * datasrc = (cinfo)->src;  \
	const JOCTET * next_input_byte = datasrc->next_input_byte;  \
	size_t bytes_in_buffer = datasrc->bytes_in_buffer

/* Unload the local copies --- do this only at a restart boundary */
#define INPUT_SYNC(cinfo)  \
	( datasrc->next_input_byte = next_input_byte,  \
	  datasrc->bytes_in_buffer = bytes_in_buffer )

/* Reload the local copies --- seldom used except in MAKE_BYTE_AVAIL */
#define INPUT_RELOAD(cinfo)  \
	( next_input_byte = datasrc->next_input_byte,  \
	  bytes_in_buffer = datasrc->bytes_in_buffer )

/* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
 * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
 * but we must reload the local copies after a successful fill.
 */
#define MAKE_BYTE_AVAIL(cinfo,action)  \
	if (bytes_in_buffer == 0) {  \
	  if (! (*datasrc->fill_input_buffer) (cinfo))  \
	    { action; }  \
	  INPUT_RELOAD(cinfo);  \
	}  \
	bytes_in_buffer--

/* Read a byte into variable V.
 * If must suspend, take the specified action (typically "return FALSE").
 */
#define INPUT_BYTE(cinfo,V,action)  \
	MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
		  V = GETJOCTET(*next_input_byte++); )

/* As above, but read two bytes interpreted as an unsigned 16-bit integer.
 * V should be declared unsigned int or perhaps INT32.
 */
#define INPUT_2BYTES(cinfo,V,action)  \
	MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
		  V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
		  MAKE_BYTE_AVAIL(cinfo,action); \
		  V += GETJOCTET(*next_input_byte++); )


/* Process the COM marker segment, which contains human-readable comments. */
boolean PR_CALLBACK
il_jpeg_COM_handler (j_decompress_ptr cinfo)
{
    uint length;
    char *comment;
    unsigned int ch;

    il_source_mgr *src = (il_source_mgr*) cinfo->src;
    il_container *ic = src->js->ic;
    static unsigned int lastch = 0;

    INPUT_VARS(cinfo);

    /* Get 16-bit comment length word. */
    INPUT_2BYTES(cinfo, length, return FALSE);
    length -= 2;			/* discount the length word itself */
  
    if (ic->comment)
        XP_FREE(ic->comment);
    comment = ic->comment = (char *)XP_ALLOC(length + 1);
    ic->comment_length = length;
    
    if (!ic->comment) {
        skip_input_data(cinfo, length + 2);
        return TRUE;
    }

    /* Emit the character in a readable form.
     * Newlines in CR, CR/LF, or LF form will be printed as one newline.
     */
    while (length-- > 0) {
        INPUT_BYTE(cinfo, ch, return FALSE);

        if (ch == '\r') {
            *comment++ = '\n';
        } else if (ch == '\n') {
            if (lastch != '\r')
                *comment++ = '\n';
        } else if (isprint(ch) || !ch) {
            *comment++ = ch;
        }
        lastch = ch;
    }

    *comment = 0;

    INPUT_SYNC(cinfo);

    return TRUE;
}

int il_jpeg_init(il_container *ic)
{
	jpeg_struct *js;
	j_decompress_ptr jd;
    NI_ColorSpace *src_color_space = ic->src_header->color_space;
    NI_RGBBits *rgb = &src_color_space->bit_alloc.rgb;

	js = XP_NEW_ZAP(jpeg_struct);
	if (!js) {
		XP_TRACE(("il:jpeg: jpeg_struct memory lossage"));
		return FALSE;
	}

	/* Init jpeg_struct */
	ic->ds = js;
	js->state = JPEG_HEADER;
	js->samples = NULL;
	js->samples3 = NULL;
	js->ic = ic;

	jd = &js->jd;

	/* Install our error handler because the default is to exit(). */
	jd->err = jpeg_std_error(&js->jerr.pub);
	js->jerr.pub.error_exit = il_error_exit;

	/* Control returns here if an error occurs before setup completes. */
	if(setjmp(js->jerr.setjmp_buffer)) {
        /* Free up all the data structures */
        il_jpeg_abort(ic);
		return FALSE;
	}

#ifdef DEBUG
	if (il_debug > 20) {
		jd->err->trace_level = 99;
	}
#endif

	
	jpeg_create_decompress(jd);

	/* Setup jpeg data source object */
	if (!setup_jpeg_src(jd, js)) {
		XP_TRACE(("il:jpeg: jpeg source memory lossage"));
        /* Free up all the data structures */
        il_jpeg_abort(ic);
		return FALSE;
	}

    /* Insert custom COM comment marker processor. */
    jpeg_set_marker_processor(jd, JPEG_COM, il_jpeg_COM_handler);


    /* Initialize the container's source image header. */
    src_color_space->type = NI_TrueColor;
    src_color_space->pixmap_depth = 24;
    rgb->red_bits = 8;
    rgb->red_shift = 16;
    rgb->green_bits = 8;
    rgb->green_shift = 8;
    rgb->blue_bits = 8;
    rgb->blue_shift = 0;

	return TRUE;
}


/*-----------------------------------------------------------------------------
 * Calling this routine sends scanlines to the front-end for display.
 * Scanlines will be emitted until the entire scan has been displayed or
 * until insufficient input data is available to continue output.
 *
 * The maximum number of scanlines to be output is controlled by the
 * `num_scanlines' parameter.  Set num_scanlines to -1 to output scanlines
 * until input data is exhausted.
 *
 * Returns:
 *	TRUE if output was discontinued due to lack of input data
 *  FALSE, otherwise
 *---------------------------------------------------------------------------*/
int
output_jpeg_scanlines(il_container *ic, int num_scanlines)
{
	jpeg_struct *js = (jpeg_struct *)ic->ds;
	j_decompress_ptr jd = &js->jd;
    int input_exhausted;
    int pass;
    
#ifdef DEBUG
    uint start_scanline = jd->output_scanline;
#endif

    if (js->state == JPEG_FINAL_PROGRESSIVE_SCAN_OUTPUT)
        pass = IL_FINAL_PASS;
    else
        pass = js->completed_output_passes + 1;

    while ((jd->output_scanline < jd->output_height) && num_scanlines--) {
        JSAMPROW samples;
        
        /* Request one scanline.  Returns 0 or 1 scanlines. */
        int ns = jpeg_read_scanlines(jd, js->samples, 1);
        ILTRACE(15,("il:jpeg: scanline %d, ns = %d",
                    jd->output_scanline, ns));
        if (ns != 1) {
            ILTRACE(5,("il:jpeg: suspending scanline"));
            input_exhausted = TRUE;
            goto done;
        }

        /* If grayscale image ... */
        if (jd->output_components == 1) {
            JSAMPLE j, *j1, *j1end, *j3;

            /* Convert from grayscale to RGB. */
            j1 = js->samples[0];
            j1end = j1 + jd->output_width;
            j3 = js->samples3[0];
            while (j1 < j1end) {
                j = *j1++;
                j3[0] = j;
                j3[1] = j;
                j3[2] = j;
                j3 += 3;
            }
            samples = js->samples3[0];
        } else {		/* 24-bit color image */
            samples = js->samples[0];
        }

        il_emit_row(ic, 0, samples, 0, jd->output_width, jd->output_scanline-1,
                    1, ilErase, pass);
    }

    input_exhausted = FALSE;

  done:

#ifdef DEBUG
    if (start_scanline != jd->output_scanline)
        ILTRACE(4, ("il: jpeg: Input pass=%2d, next input scanline=%3d,"
                    " emitted %3d - %3d\n",
                    jd->input_scan_number, jd->input_iMCU_row * 16,
                    start_scanline, jd->output_scanline - 1));

#endif
    
    return input_exhausted;
}

#define JPEG_OUTPUT_CHUNK_SIZE     50000

/* Timeout durations, in milliseconds */

/* Delay between displaying chunks of pixels for the first scan. */
#define JPEG_TIMEOUT_INITIAL_DELAY   100

/* Delay between displaying chunks of pixels for subsequent scans */
#define JPEG_TIMEOUT_DELAY           200

static void
jpeg_timeout_callback(void *closure)
{
    uint32 delay;
	jpeg_struct *js = (jpeg_struct *)closure;
	j_decompress_ptr jd = &js->jd;

    if (jd->input_scan_number == 1)
        delay = JPEG_TIMEOUT_INITIAL_DELAY;
    else
        delay = JPEG_TIMEOUT_DELAY;

    /*
     * Perform incremental display of progressive scans,
     * except don't display unless enough time has elapsed
     * since the previous scan was displayed.
     */

    if (js->pass_num != js->completed_output_passes + 1) {
        if (! jpeg_start_output(jd, jd->input_scan_number)) {
            ILTRACE(1, ("il: jpeg: jpeg_start_output returned"
                        "FALSE!\n"));
            goto done;
        }
        js->pass_num = js->completed_output_passes + 1;
    }
    
    js->timeout = NULL;

    /* If there's no more data to process for this scan,
       wait until jpeg_write() wakes us up by scheduling a
       new timeout */
    if (output_jpeg_scanlines(js->ic, js->rows_per_chunk))
        return;
    
    /* If we're at the end of this progressive scan ... */
    if (jd->output_scanline == jd->output_height) {
        if (jpeg_finish_output(jd))
            js->completed_output_passes++;
    }

  done:
    js->timeout = FE_SetTimeout(jpeg_timeout_callback, js, delay);
}

/*
 * Force the display of scans, even if no data has entered the netlib
 * buffer since jpeg_timeout_callback() was run.  This will flush
 * pixels to the screen during a long pause in a bursty data source.
 */
#if 0
static void
jpeg_idle_callback(void *closure)
{
    il_container *ic = (il_container *)closure;
    il_jpeg_write(ic, NULL, 0);
}
#endif

int
il_jpeg_write(il_container *ic, const unsigned char *buf, int32 len)
{
	int row_stride, status;
	int input_exhausted;
    int error_code;

	jpeg_struct *js = (jpeg_struct *)ic->ds;
	j_decompress_ptr jd = &js->jd;
    il_source_mgr *src = (il_source_mgr*) js->jd.src;
    NI_PixmapHeader *img_header = &ic->image->header;
#ifndef M12N                    /* XXXM12N Get rid of this */
    NI_PixmapHeader *src_header = ic->src_header;
    NI_ColorMap *cmap = &src_header->color_space->cmap;
#endif /* M12N */

    /* If this assert fires, chances are the netlib 
       continued to send data after the image stream was closed. */
    XP_ASSERT(js);
    if (!js) {
#ifdef DEBUG
        XP_TRACE(("Netlib sent data after the image stream was closed\n"));
#endif
        return MK_IMAGE_LOSSAGE;
    }
    
	/* Return here if there is a fatal error. */
	if ((error_code = setjmp(js->jerr.setjmp_buffer))) {
        /* Free up all the data structures */
        il_jpeg_abort(ic);
		return error_code;
	}

	/* Register new buffer contents with data source manager. */
	src->netlib_buffer = (JOCTET*)buf;
	src->netlib_buflen = (uint32)len;

    input_exhausted = 0;
	while (! input_exhausted) {
		ILTRACE(5,("il:jpeg: write, state=%d, buf=0x%x, len=%d",
				   js->state, buf, len));

		switch (js->state) {
		case JPEG_HEADER:
			if (jpeg_read_header(jd, TRUE) != JPEG_SUSPENDED) {
#ifndef M12N                    /* XXXM12N Get rid of this */
				cmap->map = 0;
				cmap->num_colors = ic->cs->default_map_size;
#endif /* M12N */
                ic->src_header->width = jd->image_width;
                ic->src_header->height = jd->image_height;
				if ((status = il_size(ic))) {
					XP_TRACE(("il:jpeg: MEM il_size"));
					return status;
				}

                il_setup_color_space_converter(ic); /* XXXM12N Should check
                                                       return code. */

                js->rows_per_chunk =
                    JPEG_OUTPUT_CHUNK_SIZE / img_header->widthBytes;

				/* FIXME -- Should reset dct_method and dither mode
				 * for final pass of progressive JPEG
				 */
				jd->dct_method = JDCT_FASTEST;
				jd->dither_mode = JDITHER_ORDERED;
				jd->do_fancy_upsampling = FALSE;
				jd->enable_2pass_quant = FALSE;
				jd->do_block_smoothing = TRUE;
				
				/*
				 * Don't allocate a giant and superfluous memory buffer
				 * when the image is a sequential JPEG.
				 */
				jd->buffered_image = jpeg_has_multiple_scans(jd);

				/* Used to set up image size so arrays can be allocated */
				jpeg_calc_output_dimensions(jd);

				/*
				 * Make a one-row-high sample array that will go away
				 * when done with image. Always make it big enough to
				 * hold an RGB row.	 Since this uses the IJG memory
				 * manager, it must be allocated before the call to
				 * jpeg_start_compress().
				 */
				row_stride = jd->output_width * jd->output_components;
				js->samples = (*jd->mem->alloc_sarray)((j_common_ptr) jd,
													   JPOOL_IMAGE,
													   row_stride, 1);

				/* Allocate RGB buffer for conversion from greyscale. */
				if (jd->output_components != 3) {
					row_stride = jd->output_width * 3;
					js->samples3 = (*jd->mem->alloc_sarray)((j_common_ptr) jd,
															JPOOL_IMAGE,
															row_stride, 1);
				}
                js->state = JPEG_START_DECOMPRESS;

			} else {
				ILTRACE(5,("il:jpeg: suspending header"));
				input_exhausted = TRUE;
			}
			break;

        case JPEG_START_DECOMPRESS:
            if (jpeg_start_decompress(jd)) {

                /* If this is a progressive JPEG ... */
                if (jd->buffered_image) {
                    js->state = JPEG_DECOMPRESS_PROGRESSIVE;
                } else {
                    js->state = JPEG_DECOMPRESS_SEQUENTIAL;
                }
            }
                   
            break;

        case JPEG_DECOMPRESS_SEQUENTIAL:
            input_exhausted = output_jpeg_scanlines(ic, -1);

			/* If we've completed image output ... */
			if (jd->output_scanline == jd->output_height)
                js->state = JPEG_DONE;

            break;
            
		case JPEG_DECOMPRESS_PROGRESSIVE:

            /*
             * Set a timeout to trigger display of the next progressive scan.
             * Any scans which arrive in the intervening time will be displayed
             * instead.  Thus, the decoder adapts to the data arrival rate.
             */
            if (js->timeout == NULL) {
                uint32 delay;

                /*
                 * First time around, display the scan a little
                 * quicker than in subsequent scans.
                 */
                if (jd->input_scan_number == 1)
                    delay = JPEG_TIMEOUT_INITIAL_DELAY;
                else {
                    delay = JPEG_TIMEOUT_DELAY;
                }
                
                js->timeout = FE_SetTimeout(jpeg_timeout_callback, js, delay);
            
            }

            /* Eat all the available input data in the netlib buffer. */
            do {
                status = jpeg_consume_input(jd);
            } while (!((status == JPEG_SUSPENDED) ||
                       (status == JPEG_REACHED_EOI)));

            /* If we've parsed the whole input, do final display immediately. */
            if (status == JPEG_REACHED_EOI) {
                js->state = JPEG_FINAL_PROGRESSIVE_SCAN_OUTPUT;
                break;
            }
            
            input_exhausted = TRUE;
            
			break;

		case JPEG_FINAL_PROGRESSIVE_SCAN_OUTPUT:

            if ((jd->input_scan_number == jd->output_scan_number) &&
                (js->pass_num == js->completed_output_passes + 1)) {
                output_jpeg_scanlines(ic, -1);
                jpeg_finish_output(jd);
            } else {

                /* Abort the last output scan.
                 * We need to redraw the whole image.
                 */
                if (js->pass_num == js->completed_output_passes + 1)
                    jpeg_finish_output(jd);

                jpeg_start_output(jd, jd->input_scan_number);
                output_jpeg_scanlines(ic, -1);
                jpeg_finish_output(jd);
            }

            js->state = JPEG_DONE;

            /* Fall through ... */

        case JPEG_DONE:
			status = jpeg_finish_decompress(jd);
            
            /* Clear any pending timeouts */
            if (js->timeout) {
                FE_ClearTimeout(js->timeout);
                js->timeout = NULL;
            }

			input_exhausted = TRUE;
            js->state = JPEG_SINK_NON_JPEG_TRAILER;  /* Be prepared for     */
                                                     /* non-JPEG data after */
                                                     /* EOI marker.         */
            break;

        case JPEG_SINK_NON_JPEG_TRAILER: /* Ignore non-JPEG trailer, if any */
            input_exhausted = TRUE;
            break;

		default:
			XP_ASSERT(0);
			break;
		}
	}

	return 0;
}

void
il_jpeg_abort(il_container *ic)
{
    jpeg_struct *js = (jpeg_struct *)ic->ds;
    
	if (js) {
		il_source_mgr *src = (il_source_mgr*) js->jd.src;

		/*
		 * Free up the memory that we allocated ourselves (not memory we
		 * allocated using the IJG memory manager - it will be freed in
		 * a moment.)
		 */
		if (src) {
			if (src->backtrack_buffer) {
				XP_FREE(src->backtrack_buffer);
				src->backtrack_buffer = NULL;
			}
			XP_FREE(src);
			js->jd.src = NULL;
		}

        /* Clear any pending timeouts */
        if (js->timeout) {
            FE_ClearTimeout(js->timeout);
            js->timeout = NULL;
        }
        
		/*
		 * Free all the ancillary memory used during JPEG decoding by the
		 * IJG JPEG library. This has the side effect of freeing up js->samples
         * and js->samples3 which were allocated using the IJG memory manager.
		 */
        jpeg_destroy_decompress(&js->jd);
		js->samples = NULL;
		js->samples3 = NULL;

		/* Finally, free up our private decoder structure. */
		XP_FREE(js);
		ic->ds = NULL;
	}
}

void
il_jpeg_complete(il_container *ic)
{
    il_jpeg_abort(ic);
    il_image_complete(ic);
    il_frame_complete_notify(ic);
}

#ifdef PROFILE
#	 pragma profile off
#endif

