1 files changed, 454 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jccoefct.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jccoefct.c
new file mode 100644
index 0000000..b64b46e
--- /dev/null
+++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jccoefct.c
@@ -0,0 +1,454 @@
+/*
+ * jccoefct.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 2003-2011 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for compression.
+ * This controller is the top level of the JPEG compressor proper.
+ * The coefficient buffer lies between forward-DCT and entropy encoding steps.
+ */
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+/* We use a full-image coefficient buffer when doing Huffman optimization,
+ * and also for writing multiple-scan JPEG files.  In all cases, the DCT
+ * step is run during the first pass, and subsequent passes need only read
+ * the buffered coefficients.
+ */
+#ifdef ENTROPY_OPT_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#else
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#endif
+#endif
+/* Private buffer controller object */
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+  JDIMENSION iMCU_row_num;      /* iMCU row # within image */
+  JDIMENSION mcu_ctr;           /* counts MCUs processed in current row */
+  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
+  /* For single-pass compression, it's sufficient to buffer just one MCU
+   * (although this may prove a bit slow in practice).  We allocate a
+   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
+   * MCU constructed and sent.  (On 80x86, the workspace is FAR even though
+   * it's not really very big; this is to keep the module interfaces unchanged
+   * when a large coefficient buffer is necessary.)
+   * In multi-pass modes, this array points to the current MCU's blocks
+   * within the virtual arrays.
+   */
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+} my_coef_controller;
+typedef my_coef_controller * my_coef_ptr;
+/* Forward declarations */
+METHODDEF(boolean) compress_data
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+METHODDEF(boolean) compress_first_pass
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+METHODDEF(boolean) compress_output
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#endif
+LOCAL(void)
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+/*
+ * Initialize for a processing pass.
+ */
+METHODDEF(void)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (coef->whole_image[0] != NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_data;
+    break;
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+  case JBUF_SAVE_AND_PASS:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_first_pass;
+    break;
+  case JBUF_CRANK_DEST:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_output;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+/*
+ * Process some data in the single-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+METHODDEF(boolean)
+compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;       /* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, bi, ci, yindex, yoffset, blockcnt;
+  JDIMENSION ypos, xpos;
+  jpeg_component_info *compptr;
+  forward_DCT_ptr forward_DCT;
+  /* Loop to write as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
+         MCU_col_num++) {
+      /* Determine where data comes from in input_buf and do the DCT thing.
+       * Each call on forward_DCT processes a horizontal row of DCT blocks
+       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
+       * sequentially.  Dummy blocks at the right or bottom edge are filled in
+       * specially.  The data in them does not matter for image reconstruction,
+       * so we fill them with values that will encode to the smallest amount of
+       * data, viz: all zeroes in the AC entries, DC entries equal to previous
+       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
+       */
+      blkn = 0;
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+        compptr = cinfo->cur_comp_info[ci];
+        forward_DCT = cinfo->fdct->forward_DCT[compptr->component_index];
+        blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+                                                : compptr->last_col_width;
+        xpos = MCU_col_num * compptr->MCU_sample_width;
+        ypos = yoffset * compptr->DCT_v_scaled_size;
+        /* ypos == (yoffset+yindex) * DCTSIZE */
+        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+          if (coef->iMCU_row_num < last_iMCU_row ||
+              yoffset+yindex < compptr->last_row_height) {
+            (*forward_DCT) (cinfo, compptr,
+                            input_buf[compptr->component_index],
+                            coef->MCU_buffer[blkn],
+                            ypos, xpos, (JDIMENSION) blockcnt);
+            if (blockcnt < compptr->MCU_width) {
+              /* Create some dummy blocks at the right edge of the image. */
+              FMEMZERO((void FAR *) coef->MCU_buffer[blkn + blockcnt],
+                       (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
+              for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
+                coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
+              }
+            }
+          } else {
+            /* Create a row of dummy blocks at the bottom of the image. */
+            FMEMZERO((void FAR *) coef->MCU_buffer[blkn],
+                     compptr->MCU_width * SIZEOF(JBLOCK));
+            for (bi = 0; bi < compptr->MCU_width; bi++) {
+              coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
+            }
+          }
+          blkn += compptr->MCU_width;
+          ypos += compptr->DCT_v_scaled_size;
+        }
+      }
+      /* Try to write the MCU.  In event of a suspension failure, we will
+       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
+       */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+        /* Suspension forced; update state counters and exit */
+        coef->MCU_vert_offset = yoffset;
+        coef->mcu_ctr = MCU_col_num;
+        return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+/*
+ * Process some data in the first pass of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * This amount of data is read from the source buffer, DCT'd and quantized,
+ * and saved into the virtual arrays.  We also generate suitable dummy blocks
+ * as needed at the right and lower edges.  (The dummy blocks are constructed
+ * in the virtual arrays, which have been padded appropriately.)  This makes
+ * it possible for subsequent passes not to worry about real vs. dummy blocks.
+ *
+ * We must also emit the data to the entropy encoder.  This is conveniently
+ * done by calling compress_output() after we've loaded the current strip
+ * of the virtual arrays.
+ *
+ * NB: input_buf contains a plane for each component in image.  All
+ * components are DCT'd and loaded into the virtual arrays in this pass.
+ * However, it may be that only a subset of the components are emitted to
+ * the entropy encoder during this first pass; be careful about looking
+ * at the scan-dependent variables (MCU dimensions, etc).
+ */
+METHODDEF(boolean)
+compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION blocks_across, MCUs_across, MCUindex;
+  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
+  JCOEF lastDC;
+  jpeg_component_info *compptr;
+  JBLOCKARRAY buffer;
+  JBLOCKROW thisblockrow, lastblockrow;
+  forward_DCT_ptr forward_DCT;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (coef->iMCU_row_num < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here, since may not be set! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    blocks_across = compptr->width_in_blocks;
+    h_samp_factor = compptr->h_samp_factor;
+    /* Count number of dummy blocks to be added at the right margin. */
+    ndummy = (int) (blocks_across % h_samp_factor);
+    if (ndummy > 0)
+      ndummy = h_samp_factor - ndummy;
+    forward_DCT = cinfo->fdct->forward_DCT[ci];
+    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
+     * on forward_DCT processes a complete horizontal row of DCT blocks.
+     */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      thisblockrow = buffer[block_row];
+      (*forward_DCT) (cinfo, compptr, input_buf[ci], thisblockrow,
+                      (JDIMENSION) (block_row * compptr->DCT_v_scaled_size),
+                      (JDIMENSION) 0, blocks_across);
+      if (ndummy > 0) {
+        /* Create dummy blocks at the right edge of the image. */
+        thisblockrow += blocks_across; /* => first dummy block */
+        FMEMZERO((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
+        lastDC = thisblockrow[-1][0];
+        for (bi = 0; bi < ndummy; bi++) {
+          thisblockrow[bi][0] = lastDC;
+        }
+      }
+    }
+    /* If at end of image, create dummy block rows as needed.
+     * The tricky part here is that within each MCU, we want the DC values
+     * of the dummy blocks to match the last real block's DC value.
+     * This squeezes a few more bytes out of the resulting file...
+     */
+    if (coef->iMCU_row_num == last_iMCU_row) {
+      blocks_across += ndummy;  /* include lower right corner */
+      MCUs_across = blocks_across / h_samp_factor;
+      for (block_row = block_rows; block_row < compptr->v_samp_factor;
+           block_row++) {
+        thisblockrow = buffer[block_row];
+        lastblockrow = buffer[block_row-1];
+        FMEMZERO((void FAR *) thisblockrow,
+                 (size_t) (blocks_across * SIZEOF(JBLOCK)));
+        for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
+          lastDC = lastblockrow[h_samp_factor-1][0];
+          for (bi = 0; bi < h_samp_factor; bi++) {
+            thisblockrow[bi][0] = lastDC;
+          }
+          thisblockrow += h_samp_factor; /* advance to next MCU in row */
+          lastblockrow += h_samp_factor;
+        }
+      }
+    }
+  }
+  /* NB: compress_output will increment iMCU_row_num if successful.
+   * A suspension return will result in redoing all the work above next time.
+   */
+  /* Emit data to the entropy encoder, sharing code with subsequent passes */
+  return compress_output(cinfo, input_buf);
+}
+/*
+ * Process some data in subsequent passes of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+METHODDEF(boolean)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;       /* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+  /* Align the virtual buffers for the components used in this scan.
+   * NB: during first pass, this is safe only because the buffers will
+   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+  }
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+         MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;                 /* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+        compptr = cinfo->cur_comp_info[ci];
+        start_col = MCU_col_num * compptr->MCU_width;
+        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+          buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+          for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+            coef->MCU_buffer[blkn++] = buffer_ptr++;
+          }
+        }
+      }
+      /* Try to write the MCU. */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+        /* Suspension forced; update state counters and exit */
+        coef->MCU_vert_offset = yoffset;
+        coef->mcu_ctr = MCU_col_num;
+        return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+#endif /* FULL_COEF_BUFFER_SUPPORTED */
+/*
+ * Initialize coefficient buffer controller.
+ */
+GLOBAL(void)
+jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+  coef->pub.start_pass = start_pass_coef;
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    int ci;
+    jpeg_component_info *compptr;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+         ci++, compptr++) {
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+        ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+         (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+                                (long) compptr->h_samp_factor),
+         (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+                                (long) compptr->v_samp_factor),
+         (JDIMENSION) compptr->v_samp_factor);
+    }
+#else
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
+  }
+}

diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jccoefct.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jccoefct.c new file mode 100644 index 0000000..b64b46e --- /dev/null +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jccoefct.c
@@ -0,0 +1,454 @@
	1	/*
	2	* jccoefct.c
	3	*
	4	* Copyright (C) 1994-1997, Thomas G. Lane.
	5	* Modified 2003-2011 by Guido Vollbeding.
	6	* This file is part of the Independent JPEG Group's software.
	7	* For conditions of distribution and use, see the accompanying README file.
	8	*
	9	* This file contains the coefficient buffer controller for compression.
	10	* This controller is the top level of the JPEG compressor proper.
	11	* The coefficient buffer lies between forward-DCT and entropy encoding steps.
	12	*/
	13
	14	#define JPEG_INTERNALS
	15	#include "jinclude.h"
	16	#include "jpeglib.h"
	17
	18
	19	/* We use a full-image coefficient buffer when doing Huffman optimization,
	20	* and also for writing multiple-scan JPEG files. In all cases, the DCT
	21	* step is run during the first pass, and subsequent passes need only read
	22	* the buffered coefficients.
	23	*/
	24	#ifdef ENTROPY_OPT_SUPPORTED
	25	#define FULL_COEF_BUFFER_SUPPORTED
	26	#else
	27	#ifdef C_MULTISCAN_FILES_SUPPORTED
	28	#define FULL_COEF_BUFFER_SUPPORTED
	29	#endif
	30	#endif
	31
	32
	33	/* Private buffer controller object */
	34
	35	typedef struct {
	36	struct jpeg_c_coef_controller pub; /* public fields */
	37
	38	JDIMENSION iMCU_row_num; /* iMCU row # within image */
	39	JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
	40	int MCU_vert_offset; /* counts MCU rows within iMCU row */
	41	int MCU_rows_per_iMCU_row; /* number of such rows needed */
	42
	43	/* For single-pass compression, it's sufficient to buffer just one MCU
	44	* (although this may prove a bit slow in practice). We allocate a
	45	* workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
	46	* MCU constructed and sent. (On 80x86, the workspace is FAR even though
	47	* it's not really very big; this is to keep the module interfaces unchanged
	48	* when a large coefficient buffer is necessary.)
	49	* In multi-pass modes, this array points to the current MCU's blocks
	50	* within the virtual arrays.
	51	*/
	52	JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
	53
	54	/* In multi-pass modes, we need a virtual block array for each component. */
	55	jvirt_barray_ptr whole_image[MAX_COMPONENTS];
	56	} my_coef_controller;
	57
	58	typedef my_coef_controller * my_coef_ptr;
	59
	60
	61	/* Forward declarations */
	62	METHODDEF(boolean) compress_data
	63	JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
	64	#ifdef FULL_COEF_BUFFER_SUPPORTED
	65	METHODDEF(boolean) compress_first_pass
	66	JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
	67	METHODDEF(boolean) compress_output
	68	JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
	69	#endif
	70
	71
	72	LOCAL(void)
	73	start_iMCU_row (j_compress_ptr cinfo)
	74	/* Reset within-iMCU-row counters for a new row */
	75	{
	76	my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
	77
	78	/* In an interleaved scan, an MCU row is the same as an iMCU row.
	79	* In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
	80	* But at the bottom of the image, process only what's left.
	81	*/
	82	if (cinfo->comps_in_scan > 1) {
	83	coef->MCU_rows_per_iMCU_row = 1;
	84	} else {
	85	if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
	86	coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
	87	else
	88	coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
	89	}
	90
	91	coef->mcu_ctr = 0;
	92	coef->MCU_vert_offset = 0;
	93	}
	94
	95
	96	/*
	97	* Initialize for a processing pass.
	98	*/
	99
	100	METHODDEF(void)
	101	start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
	102	{
	103	my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
	104
	105	coef->iMCU_row_num = 0;
	106	start_iMCU_row(cinfo);
	107
	108	switch (pass_mode) {
	109	case JBUF_PASS_THRU:
	110	if (coef->whole_image[0] != NULL)
	111	ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
	112	coef->pub.compress_data = compress_data;
	113	break;
	114	#ifdef FULL_COEF_BUFFER_SUPPORTED
	115	case JBUF_SAVE_AND_PASS:
	116	if (coef->whole_image[0] == NULL)
	117	ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
	118	coef->pub.compress_data = compress_first_pass;
	119	break;
	120	case JBUF_CRANK_DEST:
	121	if (coef->whole_image[0] == NULL)
	122	ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
	123	coef->pub.compress_data = compress_output;
	124	break;
	125	#endif
	126	default:
	127	ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
	128	break;
	129	}
	130	}
	131
	132
	133	/*
	134	* Process some data in the single-pass case.
	135	* We process the equivalent of one fully interleaved MCU row ("iMCU" row)
	136	* per call, ie, v_samp_factor block rows for each component in the image.
	137	* Returns TRUE if the iMCU row is completed, FALSE if suspended.
	138	*
	139	* NB: input_buf contains a plane for each component in image,
	140	* which we index according to the component's SOF position.
	141	*/
	142
	143	METHODDEF(boolean)
	144	compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
	145	{
	146	my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
	147	JDIMENSION MCU_col_num; /* index of current MCU within row */
	148	JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
	149	JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
	150	int blkn, bi, ci, yindex, yoffset, blockcnt;
	151	JDIMENSION ypos, xpos;
	152	jpeg_component_info *compptr;
	153	forward_DCT_ptr forward_DCT;
	154
	155	/* Loop to write as much as one whole iMCU row */
	156	for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
	157	yoffset++) {
	158	for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
	159	MCU_col_num++) {
	160	/* Determine where data comes from in input_buf and do the DCT thing.
	161	* Each call on forward_DCT processes a horizontal row of DCT blocks
	162	* as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
	163	* sequentially. Dummy blocks at the right or bottom edge are filled in
	164	* specially. The data in them does not matter for image reconstruction,
	165	* so we fill them with values that will encode to the smallest amount of
	166	* data, viz: all zeroes in the AC entries, DC entries equal to previous
	167	* block's DC value. (Thanks to Thomas Kinsman for this idea.)
	168	*/
	169	blkn = 0;
	170	for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
	171	compptr = cinfo->cur_comp_info[ci];
	172	forward_DCT = cinfo->fdct->forward_DCT[compptr->component_index];
	173	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
	174	: compptr->last_col_width;
	175	xpos = MCU_col_num * compptr->MCU_sample_width;
	176	ypos = yoffset * compptr->DCT_v_scaled_size;
	177	/* ypos == (yoffset+yindex) * DCTSIZE */
	178	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
	179	if (coef->iMCU_row_num < last_iMCU_row \|\|
	180	yoffset+yindex < compptr->last_row_height) {
	181	(*forward_DCT) (cinfo, compptr,
	182	input_buf[compptr->component_index],
	183	coef->MCU_buffer[blkn],
	184	ypos, xpos, (JDIMENSION) blockcnt);
	185	if (blockcnt < compptr->MCU_width) {
	186	/* Create some dummy blocks at the right edge of the image. */
	187	FMEMZERO((void FAR *) coef->MCU_buffer[blkn + blockcnt],
	188	(compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
	189	for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
	190	coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
	191	}
	192	}
	193	} else {
	194	/* Create a row of dummy blocks at the bottom of the image. */
	195	FMEMZERO((void FAR *) coef->MCU_buffer[blkn],
	196	compptr->MCU_width * SIZEOF(JBLOCK));
	197	for (bi = 0; bi < compptr->MCU_width; bi++) {
	198	coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
	199	}
	200	}
	201	blkn += compptr->MCU_width;
	202	ypos += compptr->DCT_v_scaled_size;
	203	}
	204	}
	205	/* Try to write the MCU. In event of a suspension failure, we will
	206	* re-DCT the MCU on restart (a bit inefficient, could be fixed...)
	207	*/
	208	if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
	209	/* Suspension forced; update state counters and exit */
	210	coef->MCU_vert_offset = yoffset;
	211	coef->mcu_ctr = MCU_col_num;
	212	return FALSE;
	213	}
	214	}
	215	/* Completed an MCU row, but perhaps not an iMCU row */
	216	coef->mcu_ctr = 0;
	217	}
	218	/* Completed the iMCU row, advance counters for next one */
	219	coef->iMCU_row_num++;
	220	start_iMCU_row(cinfo);
	221	return TRUE;
	222	}
	223
	224
	225	#ifdef FULL_COEF_BUFFER_SUPPORTED
	226
	227	/*
	228	* Process some data in the first pass of a multi-pass case.
	229	* We process the equivalent of one fully interleaved MCU row ("iMCU" row)
	230	* per call, ie, v_samp_factor block rows for each component in the image.
	231	* This amount of data is read from the source buffer, DCT'd and quantized,
	232	* and saved into the virtual arrays. We also generate suitable dummy blocks
	233	* as needed at the right and lower edges. (The dummy blocks are constructed
	234	* in the virtual arrays, which have been padded appropriately.) This makes
	235	* it possible for subsequent passes not to worry about real vs. dummy blocks.
	236	*
	237	* We must also emit the data to the entropy encoder. This is conveniently
	238	* done by calling compress_output() after we've loaded the current strip
	239	* of the virtual arrays.
	240	*
	241	* NB: input_buf contains a plane for each component in image. All
	242	* components are DCT'd and loaded into the virtual arrays in this pass.
	243	* However, it may be that only a subset of the components are emitted to
	244	* the entropy encoder during this first pass; be careful about looking
	245	* at the scan-dependent variables (MCU dimensions, etc).
	246	*/
	247
	248	METHODDEF(boolean)
	249	compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
	250	{
	251	my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
	252	JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
	253	JDIMENSION blocks_across, MCUs_across, MCUindex;
	254	int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
	255	JCOEF lastDC;
	256	jpeg_component_info *compptr;
	257	JBLOCKARRAY buffer;
	258	JBLOCKROW thisblockrow, lastblockrow;
	259	forward_DCT_ptr forward_DCT;
	260
	261	for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
	262	ci++, compptr++) {
	263	/* Align the virtual buffer for this component. */
	264	buffer = (*cinfo->mem->access_virt_barray)
	265	((j_common_ptr) cinfo, coef->whole_image[ci],
	266	coef->iMCU_row_num * compptr->v_samp_factor,
	267	(JDIMENSION) compptr->v_samp_factor, TRUE);
	268	/* Count non-dummy DCT block rows in this iMCU row. */
	269	if (coef->iMCU_row_num < last_iMCU_row)
	270	block_rows = compptr->v_samp_factor;
	271	else {
	272	/* NB: can't use last_row_height here, since may not be set! */
	273	block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
	274	if (block_rows == 0) block_rows = compptr->v_samp_factor;
	275	}
	276	blocks_across = compptr->width_in_blocks;
	277	h_samp_factor = compptr->h_samp_factor;
	278	/* Count number of dummy blocks to be added at the right margin. */
	279	ndummy = (int) (blocks_across % h_samp_factor);
	280	if (ndummy > 0)
	281	ndummy = h_samp_factor - ndummy;
	282	forward_DCT = cinfo->fdct->forward_DCT[ci];
	283	/* Perform DCT for all non-dummy blocks in this iMCU row. Each call
	284	* on forward_DCT processes a complete horizontal row of DCT blocks.
	285	*/
	286	for (block_row = 0; block_row < block_rows; block_row++) {
	287	thisblockrow = buffer[block_row];
	288	(*forward_DCT) (cinfo, compptr, input_buf[ci], thisblockrow,
	289	(JDIMENSION) (block_row * compptr->DCT_v_scaled_size),
	290	(JDIMENSION) 0, blocks_across);
	291	if (ndummy > 0) {
	292	/* Create dummy blocks at the right edge of the image. */
	293	thisblockrow += blocks_across; /* => first dummy block */
	294	FMEMZERO((void FAR ) thisblockrow, ndummy SIZEOF(JBLOCK));
	295	lastDC = thisblockrow[-1][0];
	296	for (bi = 0; bi < ndummy; bi++) {
	297	thisblockrow[bi][0] = lastDC;
	298	}
	299	}
	300	}
	301	/* If at end of image, create dummy block rows as needed.
	302	* The tricky part here is that within each MCU, we want the DC values
	303	* of the dummy blocks to match the last real block's DC value.
	304	* This squeezes a few more bytes out of the resulting file...
	305	*/
	306	if (coef->iMCU_row_num == last_iMCU_row) {
	307	blocks_across += ndummy; /* include lower right corner */
	308	MCUs_across = blocks_across / h_samp_factor;
	309	for (block_row = block_rows; block_row < compptr->v_samp_factor;
	310	block_row++) {
	311	thisblockrow = buffer[block_row];
	312	lastblockrow = buffer[block_row-1];
	313	FMEMZERO((void FAR *) thisblockrow,
	314	(size_t) (blocks_across * SIZEOF(JBLOCK)));
	315	for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
	316	lastDC = lastblockrow[h_samp_factor-1][0];
	317	for (bi = 0; bi < h_samp_factor; bi++) {
	318	thisblockrow[bi][0] = lastDC;
	319	}
	320	thisblockrow += h_samp_factor; /* advance to next MCU in row */
	321	lastblockrow += h_samp_factor;
	322	}
	323	}
	324	}
	325	}
	326	/* NB: compress_output will increment iMCU_row_num if successful.
	327	* A suspension return will result in redoing all the work above next time.
	328	*/
	329
	330	/* Emit data to the entropy encoder, sharing code with subsequent passes */
	331	return compress_output(cinfo, input_buf);
	332	}
	333
	334
	335	/*
	336	* Process some data in subsequent passes of a multi-pass case.
	337	* We process the equivalent of one fully interleaved MCU row ("iMCU" row)
	338	* per call, ie, v_samp_factor block rows for each component in the scan.
	339	* The data is obtained from the virtual arrays and fed to the entropy coder.
	340	* Returns TRUE if the iMCU row is completed, FALSE if suspended.
	341	*
	342	* NB: input_buf is ignored; it is likely to be a NULL pointer.
	343	*/
	344
	345	METHODDEF(boolean)
	346	compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
	347	{
	348	my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
	349	JDIMENSION MCU_col_num; /* index of current MCU within row */
	350	int blkn, ci, xindex, yindex, yoffset;
	351	JDIMENSION start_col;
	352	JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
	353	JBLOCKROW buffer_ptr;
	354	jpeg_component_info *compptr;
	355
	356	/* Align the virtual buffers for the components used in this scan.
	357	* NB: during first pass, this is safe only because the buffers will
	358	* already be aligned properly, so jmemmgr.c won't need to do any I/O.
	359	*/
	360	for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
	361	compptr = cinfo->cur_comp_info[ci];
	362	buffer[ci] = (*cinfo->mem->access_virt_barray)
	363	((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
	364	coef->iMCU_row_num * compptr->v_samp_factor,
	365	(JDIMENSION) compptr->v_samp_factor, FALSE);
	366	}
	367
	368	/* Loop to process one whole iMCU row */
	369	for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
	370	yoffset++) {
	371	for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
	372	MCU_col_num++) {
	373	/* Construct list of pointers to DCT blocks belonging to this MCU */
	374	blkn = 0; /* index of current DCT block within MCU */
	375	for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
	376	compptr = cinfo->cur_comp_info[ci];
	377	start_col = MCU_col_num * compptr->MCU_width;
	378	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
	379	buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
	380	for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
	381	coef->MCU_buffer[blkn++] = buffer_ptr++;
	382	}
	383	}
	384	}
	385	/* Try to write the MCU. */
	386	if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
	387	/* Suspension forced; update state counters and exit */
	388	coef->MCU_vert_offset = yoffset;
	389	coef->mcu_ctr = MCU_col_num;
	390	return FALSE;
	391	}
	392	}
	393	/* Completed an MCU row, but perhaps not an iMCU row */
	394	coef->mcu_ctr = 0;
	395	}
	396	/* Completed the iMCU row, advance counters for next one */
	397	coef->iMCU_row_num++;
	398	start_iMCU_row(cinfo);
	399	return TRUE;
	400	}
	401
	402	#endif /* FULL_COEF_BUFFER_SUPPORTED */
	403
	404
	405	/*
	406	* Initialize coefficient buffer controller.
	407	*/
	408
	409	GLOBAL(void)
	410	jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
	411	{
	412	my_coef_ptr coef;
	413
	414	coef = (my_coef_ptr)
	415	(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
	416	SIZEOF(my_coef_controller));
	417	cinfo->coef = (struct jpeg_c_coef_controller *) coef;
	418	coef->pub.start_pass = start_pass_coef;
	419
	420	/* Create the coefficient buffer. */
	421	if (need_full_buffer) {
	422	#ifdef FULL_COEF_BUFFER_SUPPORTED
	423	/* Allocate a full-image virtual array for each component, */
	424	/* padded to a multiple of samp_factor DCT blocks in each direction. */
	425	int ci;
	426	jpeg_component_info *compptr;
	427
	428	for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
	429	ci++, compptr++) {
	430	coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
	431	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
	432	(JDIMENSION) jround_up((long) compptr->width_in_blocks,
	433	(long) compptr->h_samp_factor),
	434	(JDIMENSION) jround_up((long) compptr->height_in_blocks,
	435	(long) compptr->v_samp_factor),
	436	(JDIMENSION) compptr->v_samp_factor);
	437	}
	438	#else
	439	ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
	440	#endif
	441	} else {
	442	/* We only need a single-MCU buffer. */
	443	JBLOCKROW buffer;
	444	int i;
	445
	446	buffer = (JBLOCKROW)
	447	(*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
	448	C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
	449	for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
	450	coef->MCU_buffer[i] = buffer + i;
	451	}
	452	coef->whole_image[0] = NULL; /* flag for no virtual arrays */
	453	}
	454	}