]> Creatis software - gdcm.git/commitdiff
ENH: Fix the remaining warnings using: diff -u --strip-trailing-cr --ignore-space...
authormalaterre <malaterre>
Mon, 4 Oct 2004 03:10:59 +0000 (03:10 +0000)
committermalaterre <malaterre>
Mon, 4 Oct 2004 03:10:59 +0000 (03:10 +0000)
30 files changed:
src/jpeg/libijg/README.GDCM.txt [new file with mode: 0644]
src/jpeg/libijg/jccoefct.c
src/jpeg/libijg/jccolor.c
src/jpeg/libijg/jcmarker.c
src/jpeg/libijg/jcsample.c
src/jpeg/libijg/jctrans.c
src/jpeg/libijg/jdatasrc.c
src/jpeg/libijg/jdcoefct.c
src/jpeg/libijg/jdcolor.c
src/jpeg/libijg/jdmerge.c
src/jpeg/libijg/jdpostct.c
src/jpeg/libijg/jdsample.c
src/jpeg/libijg/jmemnobs.c
src/jpeg/libijg/jquant1.c
src/jpeg/libijg/jquant2.c
src/jpeg/libijg8/README.GDCM.txt [new file with mode: 0644]
src/jpeg/libijg8/jccoefct.c
src/jpeg/libijg8/jccolor.c
src/jpeg/libijg8/jcmarker.c
src/jpeg/libijg8/jcsample.c
src/jpeg/libijg8/jctrans.c
src/jpeg/libijg8/jdatasrc.c
src/jpeg/libijg8/jdcoefct.c
src/jpeg/libijg8/jdcolor.c
src/jpeg/libijg8/jdmerge.c
src/jpeg/libijg8/jdpostct.c
src/jpeg/libijg8/jdsample.c
src/jpeg/libijg8/jmemnobs.c
src/jpeg/libijg8/jquant1.c
src/jpeg/libijg8/jquant2.c

diff --git a/src/jpeg/libijg/README.GDCM.txt b/src/jpeg/libijg/README.GDCM.txt
new file mode 100644 (file)
index 0000000..836b344
--- /dev/null
@@ -0,0 +1,15 @@
+This directory contains a subset of the Independent JPEG Group's (IJG)
+libjpeg version 6b.  We only include enough of distribution to build
+libjpeg.  We do not include the standard executables that come with
+libjpeg (cjpeg, djpeg, etc.). Furthermore, the standard libjpeg build
+process is replaced with a CMake build process.
+
+We'd like to thank the IJG for distributing a public JPEG IO library.
+
+Modifications
+-------------
+
+jconfig.h is usually generated by the build process. For this distribution,
+we ship a version of jconfig.h.in to be used across several platforms. It's 
+purpose is also to allow generation of both 8bits and 12bits lib.
+
index 1963ddb61b15689e36e3f1774007d3583b787a26..fe7cfc3194563776340ad6388ae2c7e5668a7eab 100644 (file)
 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 */
+  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
@@ -143,7 +143,7 @@ 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 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;
@@ -154,7 +154,7 @@ compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   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++) {
+   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
@@ -166,46 +166,46 @@ compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
        */
       blkn = 0;
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-       compptr = cinfo->cur_comp_info[ci];
-       blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
-                                               : compptr->last_col_width;
-       xpos = MCU_col_num * compptr->MCU_sample_width;
-       ypos = yoffset * DCTSIZE; /* 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) {
-           (*cinfo->fdct->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. */
-             jzero_far((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. */
-           jzero_far((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 += DCTSIZE;
-       }
+  compptr = cinfo->cur_comp_info[ci];
+  blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+            : compptr->last_col_width;
+  xpos = MCU_col_num * compptr->MCU_sample_width;
+  ypos = yoffset * DCTSIZE; /* 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) {
+      (*cinfo->fdct->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. */
+        jzero_far((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. */
+      jzero_far((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 += DCTSIZE;
+  }
       }
       /* 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;
+  /* 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 */
@@ -280,17 +280,17 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
     for (block_row = 0; block_row < block_rows; block_row++) {
       thisblockrow = buffer[block_row];
       (*cinfo->fdct->forward_DCT) (cinfo, compptr,
-                                  input_buf[ci], thisblockrow,
-                                  (JDIMENSION) (block_row * DCTSIZE),
-                                  (JDIMENSION) 0, blocks_across);
+           input_buf[ci], thisblockrow,
+           (JDIMENSION) (block_row * DCTSIZE),
+           (JDIMENSION) 0, blocks_across);
       if (ndummy > 0) {
-       /* Create dummy blocks at the right edge of the image. */
-       thisblockrow += blocks_across; /* => first dummy block */
-       jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
-       lastDC = thisblockrow[-1][0];
-       for (bi = 0; bi < ndummy; bi++) {
-         thisblockrow[bi][0] = lastDC;
-       }
+  /* Create dummy blocks at the right edge of the image. */
+  thisblockrow += blocks_across; /* => first dummy block */
+  jzero_far((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.
@@ -299,22 +299,22 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      * 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 */
+      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];
-       jzero_far((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;
-       }
+     block_row++) {
+  thisblockrow = buffer[block_row];
+  lastblockrow = buffer[block_row-1];
+  jzero_far((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;
+  }
       }
     }
   }
@@ -341,13 +341,14 @@ 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 */
+  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;
 
+  input_buf = 0;
   /* 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.
@@ -364,25 +365,25 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   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++) {
+   MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
-      blkn = 0;                        /* index of current DCT block within 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++;
-         }
-       }
+  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;
+  /* 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 */
@@ -408,7 +409,7 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 
   coef = (my_coef_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_coef_controller));
+        SIZEOF(my_coef_controller));
   cinfo->coef = (struct jpeg_c_coef_controller *) coef;
   coef->pub.start_pass = start_pass_coef;
 
@@ -421,14 +422,14 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
     jpeg_component_info *compptr;
 
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-        ci++, compptr++) {
+   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);
+  ((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);
@@ -440,7 +441,7 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 
     buffer = (JBLOCKROW)
       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                                 C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+          C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
     for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
       coef->MCU_buffer[i] = buffer + i;
     }
index 0a8a4b5d13c303c4d14cd5b4333adcbb3cfcc4a2..33a80d76d57e77eccefe67a148b49d55fd1cd7b7 100644 (file)
@@ -19,7 +19,7 @@ typedef struct {
   struct jpeg_color_converter pub; /* public fields */
 
   /* Private state for RGB->YCC conversion */
-  INT32 * rgb_ycc_tab;         /* => table for RGB to YCbCr conversion */
+  INT32 * rgb_ycc_tab;    /* => table for RGB to YCbCr conversion */
 } my_color_converter;
 
 typedef my_color_converter * my_cconvert_ptr;
@@ -31,9 +31,9 @@ typedef my_color_converter * my_cconvert_ptr;
  * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
  * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
  * The conversion equations to be implemented are therefore
- *     Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
- *     Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
- *     Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
+ *  Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *  Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
+ *  Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
  * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
  * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
  * rather than CENTERJSAMPLE, for Cb and Cr.  This gave equal positive and
@@ -55,10 +55,10 @@ typedef my_color_converter * my_cconvert_ptr;
  * in the tables to save adding them separately in the inner loop.
  */
 
-#define SCALEBITS      16      /* speediest right-shift on some machines */
-#define CBCR_OFFSET    ((INT32) CENTERJSAMPLE << SCALEBITS)
-#define ONE_HALF       ((INT32) 1 << (SCALEBITS-1))
-#define FIX(x)         ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+#define SCALEBITS  16  /* speediest right-shift on some machines */
+#define CBCR_OFFSET  ((INT32) CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF  ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)    ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
 
 /* We allocate one big table and divide it up into eight parts, instead of
  * doing eight alloc_small requests.  This lets us use a single table base
@@ -66,16 +66,16 @@ typedef my_color_converter * my_cconvert_ptr;
  * machines (more than can hold all eight addresses, anyway).
  */
 
-#define R_Y_OFF                0                       /* offset to R => Y section */
-#define G_Y_OFF                (1*(MAXJSAMPLE+1))      /* offset to G => Y section */
-#define B_Y_OFF                (2*(MAXJSAMPLE+1))      /* etc. */
-#define R_CB_OFF       (3*(MAXJSAMPLE+1))
-#define G_CB_OFF       (4*(MAXJSAMPLE+1))
-#define B_CB_OFF       (5*(MAXJSAMPLE+1))
-#define R_CR_OFF       B_CB_OFF                /* B=>Cb, R=>Cr are the same */
-#define G_CR_OFF       (6*(MAXJSAMPLE+1))
-#define B_CR_OFF       (7*(MAXJSAMPLE+1))
-#define TABLE_SIZE     (8*(MAXJSAMPLE+1))
+#define R_Y_OFF    0      /* offset to R => Y section */
+#define G_Y_OFF    (1*(MAXJSAMPLE+1))  /* offset to G => Y section */
+#define B_Y_OFF    (2*(MAXJSAMPLE+1))  /* etc. */
+#define R_CB_OFF  (3*(MAXJSAMPLE+1))
+#define G_CB_OFF  (4*(MAXJSAMPLE+1))
+#define B_CB_OFF  (5*(MAXJSAMPLE+1))
+#define R_CR_OFF  B_CB_OFF    /* B=>Cb, R=>Cr are the same */
+#define G_CR_OFF  (6*(MAXJSAMPLE+1))
+#define B_CR_OFF  (7*(MAXJSAMPLE+1))
+#define TABLE_SIZE  (8*(MAXJSAMPLE+1))
 
 
 /*
@@ -92,7 +92,7 @@ rgb_ycc_start (j_compress_ptr cinfo)
   /* Allocate and fill in the conversion tables. */
   cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (TABLE_SIZE * SIZEOF(INT32)));
+        (TABLE_SIZE * SIZEOF(INT32)));
 
   for (i = 0; i <= MAXJSAMPLE; i++) {
     rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
@@ -128,8 +128,8 @@ rgb_ycc_start (j_compress_ptr cinfo)
 
 METHODDEF(void)
 rgb_ycc_convert (j_compress_ptr cinfo,
-                JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-                JDIMENSION output_row, int num_rows)
+     JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+     JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -157,16 +157,16 @@ rgb_ycc_convert (j_compress_ptr cinfo,
        */
       /* Y */
       outptr0[col] = (JSAMPLE)
-               ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+     >> SCALEBITS);
       /* Cb */
       outptr1[col] = (JSAMPLE)
-               ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+     >> SCALEBITS);
       /* Cr */
       outptr2[col] = (JSAMPLE)
-               ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+     >> SCALEBITS);
     }
   }
 }
@@ -184,8 +184,8 @@ rgb_ycc_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 rgb_gray_convert (j_compress_ptr cinfo,
-                 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-                 JDIMENSION output_row, int num_rows)
+      JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+      JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -206,8 +206,8 @@ rgb_gray_convert (j_compress_ptr cinfo,
       inptr += RGB_PIXELSIZE;
       /* Y */
       outptr[col] = (JSAMPLE)
-               ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+     >> SCALEBITS);
     }
   }
 }
@@ -223,8 +223,8 @@ rgb_gray_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 cmyk_ycck_convert (j_compress_ptr cinfo,
-                  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-                  JDIMENSION output_row, int num_rows)
+       JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+       JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -246,7 +246,7 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
       g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
       b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
       /* K passes through as-is */
-      outptr3[col] = inptr[3]; /* don't need GETJSAMPLE here */
+      outptr3[col] = inptr[3];  /* don't need GETJSAMPLE here */
       inptr += 4;
       /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
        * must be too; we do not need an explicit range-limiting operation.
@@ -255,16 +255,16 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
        */
       /* Y */
       outptr0[col] = (JSAMPLE)
-               ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+     >> SCALEBITS);
       /* Cb */
       outptr1[col] = (JSAMPLE)
-               ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+     >> SCALEBITS);
       /* Cr */
       outptr2[col] = (JSAMPLE)
-               ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+     >> SCALEBITS);
     }
   }
 }
@@ -278,8 +278,8 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 grayscale_convert (j_compress_ptr cinfo,
-                  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-                  JDIMENSION output_row, int num_rows)
+       JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+       JDIMENSION output_row, int num_rows)
 {
   register JSAMPROW inptr;
   register JSAMPROW outptr;
@@ -292,7 +292,7 @@ grayscale_convert (j_compress_ptr cinfo,
     outptr = output_buf[0][output_row];
     output_row++;
     for (col = 0; col < num_cols; col++) {
-      outptr[col] = inptr[0];  /* don't need GETJSAMPLE() here */
+      outptr[col] = inptr[0];  /* don't need GETJSAMPLE() here */
       inptr += instride;
     }
   }
@@ -307,8 +307,8 @@ grayscale_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 null_convert (j_compress_ptr cinfo,
-             JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-             JDIMENSION output_row, int num_rows)
+        JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+        JDIMENSION output_row, int num_rows)
 {
   register JSAMPROW inptr;
   register JSAMPROW outptr;
@@ -323,8 +323,8 @@ null_convert (j_compress_ptr cinfo,
       inptr = *input_buf;
       outptr = output_buf[ci][output_row];
       for (col = 0; col < num_cols; col++) {
-       outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
-       inptr += nc;
+  outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
+  inptr += nc;
       }
     }
     input_buf++;
@@ -340,6 +340,7 @@ null_convert (j_compress_ptr cinfo,
 METHODDEF(void)
 null_method (j_compress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work needed */
 }
 
@@ -355,7 +356,7 @@ jinit_color_converter (j_compress_ptr cinfo)
 
   cconvert = (my_cconvert_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_color_converter));
+        SIZEOF(my_color_converter));
   cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
   /* set start_pass to null method until we find out differently */
   cconvert->pub.start_pass = null_method;
@@ -385,7 +386,7 @@ jinit_color_converter (j_compress_ptr cinfo)
       ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
     break;
 
-  default:                     /* JCS_UNKNOWN can be anything */
+  default:      /* JCS_UNKNOWN can be anything */
     if (cinfo->input_components < 1)
       ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
     break;
@@ -449,9 +450,9 @@ jinit_color_converter (j_compress_ptr cinfo)
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     break;
 
-  default:                     /* allow null conversion of JCS_UNKNOWN */
+  default:      /* allow null conversion of JCS_UNKNOWN */
     if (cinfo->jpeg_color_space != cinfo->in_color_space ||
-       cinfo->num_components != cinfo->input_components)
+  cinfo->num_components != cinfo->input_components)
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     cconvert->pub.color_convert = null_convert;
     break;
index 3d1e6c6d524850e0d401fcec9f590d5648d13ee7..6f089d573cffec3c84319f7acd19e3bdebc5bbb5 100644 (file)
@@ -13,7 +13,7 @@
 #include "jpeglib.h"
 
 
-typedef enum {                 /* JPEG marker codes */
+typedef enum {      /* JPEG marker codes */
   M_SOF0  = 0xc0,
   M_SOF1  = 0xc1,
   M_SOF2  = 0xc2,
@@ -169,7 +169,7 @@ emit_dqt (j_compress_ptr cinfo, int index)
       /* The table entries must be emitted in zigzag order. */
       unsigned int qval = qtbl->quantval[jpeg_natural_order[i]];
       if (prec)
-       emit_byte(cinfo, (int) (qval >> 8));
+  emit_byte(cinfo, (int) (qval >> 8));
       emit_byte(cinfo, (int) (qval & 0xFF));
     }
 
@@ -189,7 +189,7 @@ emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
   
   if (is_ac) {
     htbl = cinfo->ac_huff_tbl_ptrs[index];
-    index += 0x10;             /* output index has AC bit set */
+    index += 0x10;    /* output index has AC bit set */
   } else {
     htbl = cinfo->dc_huff_tbl_ptrs[index];
   }
@@ -258,6 +258,7 @@ emit_dac (j_compress_ptr cinfo)
     }
   }
 #endif /* C_ARITH_CODING_SUPPORTED */
+  cinfo = 0;
 }
 
 
@@ -267,7 +268,7 @@ emit_dri (j_compress_ptr cinfo)
 {
   emit_marker(cinfo, M_DRI);
   
-  emit_2bytes(cinfo, 4);       /* fixed length */
+  emit_2bytes(cinfo, 4);  /* fixed length */
 
   emit_2bytes(cinfo, (int) cinfo->restart_interval);
 }
@@ -329,11 +330,11 @@ emit_sos (j_compress_ptr cinfo)
        * but does not seem to be specified in the standard.
        */
       if (cinfo->Ss == 0) {
-       ta = 0;                 /* DC scan */
-       if (cinfo->Ah != 0 && !cinfo->arith_code)
-         td = 0;               /* no DC table either */
+  ta = 0;      /* DC scan */
+  if (cinfo->Ah != 0 && !cinfo->arith_code)
+    td = 0;    /* no DC table either */
       } else {
-       td = 0;                 /* AC scan */
+  td = 0;      /* AC scan */
       }
     }
     emit_byte(cinfo, (td << 4) + ta);
@@ -350,22 +351,22 @@ emit_jfif_app0 (j_compress_ptr cinfo)
 /* Emit a JFIF-compliant APP0 marker */
 {
   /*
-   * Length of APP0 block      (2 bytes)
-   * Block ID                  (4 bytes - ASCII "JFIF")
-   * Zero byte                 (1 byte to terminate the ID string)
-   * Version Major, Minor      (2 bytes - major first)
-   * Units                     (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
-   * Xdpu                      (2 bytes - dots per unit horizontal)
-   * Ydpu                      (2 bytes - dots per unit vertical)
-   * Thumbnail X size          (1 byte)
-   * Thumbnail Y size          (1 byte)
+   * Length of APP0 block  (2 bytes)
+   * Block ID      (4 bytes - ASCII "JFIF")
+   * Zero byte      (1 byte to terminate the ID string)
+   * Version Major, Minor  (2 bytes - major first)
+   * Units      (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+   * Xdpu      (2 bytes - dots per unit horizontal)
+   * Ydpu      (2 bytes - dots per unit vertical)
+   * Thumbnail X size    (1 byte)
+   * Thumbnail Y size    (1 byte)
    */
   
   emit_marker(cinfo, M_APP0);
   
   emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
 
-  emit_byte(cinfo, 0x4A);      /* Identifier: ASCII "JFIF" */
+  emit_byte(cinfo, 0x4A);  /* Identifier: ASCII "JFIF" */
   emit_byte(cinfo, 0x46);
   emit_byte(cinfo, 0x49);
   emit_byte(cinfo, 0x46);
@@ -375,7 +376,7 @@ emit_jfif_app0 (j_compress_ptr cinfo)
   emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
   emit_2bytes(cinfo, (int) cinfo->X_density);
   emit_2bytes(cinfo, (int) cinfo->Y_density);
-  emit_byte(cinfo, 0);         /* No thumbnail image */
+  emit_byte(cinfo, 0);    /* No thumbnail image */
   emit_byte(cinfo, 0);
 }
 
@@ -385,12 +386,12 @@ emit_adobe_app14 (j_compress_ptr cinfo)
 /* Emit an Adobe APP14 marker */
 {
   /*
-   * Length of APP14 block     (2 bytes)
-   * Block ID                  (5 bytes - ASCII "Adobe")
-   * Version Number            (2 bytes - currently 100)
-   * Flags0                    (2 bytes - currently 0)
-   * Flags1                    (2 bytes - currently 0)
-   * Color transform           (1 byte)
+   * Length of APP14 block  (2 bytes)
+   * Block ID      (5 bytes - ASCII "Adobe")
+   * Version Number    (2 bytes - currently 100)
+   * Flags0      (2 bytes - currently 0)
+   * Flags1      (2 bytes - currently 0)
+   * Color transform    (1 byte)
    *
    * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
    * now in circulation seem to use Version = 100, so that's what we write.
@@ -404,23 +405,23 @@ emit_adobe_app14 (j_compress_ptr cinfo)
   
   emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
 
-  emit_byte(cinfo, 0x41);      /* Identifier: ASCII "Adobe" */
+  emit_byte(cinfo, 0x41);  /* Identifier: ASCII "Adobe" */
   emit_byte(cinfo, 0x64);
   emit_byte(cinfo, 0x6F);
   emit_byte(cinfo, 0x62);
   emit_byte(cinfo, 0x65);
-  emit_2bytes(cinfo, 100);     /* Version */
-  emit_2bytes(cinfo, 0);       /* Flags0 */
-  emit_2bytes(cinfo, 0);       /* Flags1 */
+  emit_2bytes(cinfo, 100);  /* Version */
+  emit_2bytes(cinfo, 0);  /* Flags0 */
+  emit_2bytes(cinfo, 0);  /* Flags1 */
   switch (cinfo->jpeg_color_space) {
   case JCS_YCbCr:
-    emit_byte(cinfo, 1);       /* Color transform = 1 */
+    emit_byte(cinfo, 1);  /* Color transform = 1 */
     break;
   case JCS_YCCK:
-    emit_byte(cinfo, 2);       /* Color transform = 2 */
+    emit_byte(cinfo, 2);  /* Color transform = 2 */
     break;
   default:
-    emit_byte(cinfo, 0);       /* Color transform = 0 */
+    emit_byte(cinfo, 0);  /* Color transform = 0 */
     break;
   }
 }
@@ -438,12 +439,12 @@ METHODDEF(void)
 write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
 /* Emit an arbitrary marker header */
 {
-  if (datalen > (unsigned int) 65533)          /* safety check */
+  if (datalen > (unsigned int) 65533)    /* safety check */
     ERREXIT(cinfo, JERR_BAD_LENGTH);
 
   emit_marker(cinfo, (JPEG_MARKER) marker);
 
-  emit_2bytes(cinfo, (int) (datalen + 2));     /* total length */
+  emit_2bytes(cinfo, (int) (datalen + 2));  /* total length */
 }
 
 METHODDEF(void)
@@ -470,12 +471,12 @@ write_file_header (j_compress_ptr cinfo)
 {
   my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
 
-  emit_marker(cinfo, M_SOI);   /* first the SOI */
+  emit_marker(cinfo, M_SOI);  /* first the SOI */
 
   /* SOI is defined to reset restart interval to 0 */
   marker->last_restart_interval = 0;
 
-  if (cinfo->write_JFIF_header)        /* next an optional JFIF APP0 */
+  if (cinfo->write_JFIF_header)  /* next an optional JFIF APP0 */
     emit_jfif_app0(cinfo);
   if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
     emit_adobe_app14(cinfo);
@@ -516,9 +517,9 @@ write_frame_header (j_compress_ptr cinfo)
   } else {
     is_baseline = TRUE;
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-        ci++, compptr++) {
+   ci++, compptr++) {
       if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
-       is_baseline = FALSE;
+  is_baseline = FALSE;
     }
     if (prec && is_baseline) {
       is_baseline = FALSE;
@@ -529,14 +530,14 @@ write_frame_header (j_compress_ptr cinfo)
 
   /* Emit the proper SOF marker */
   if (cinfo->arith_code) {
-    emit_sof(cinfo, M_SOF9);   /* SOF code for arithmetic coding */
+    emit_sof(cinfo, M_SOF9);  /* SOF code for arithmetic coding */
   } else {
     if (cinfo->progressive_mode)
-      emit_sof(cinfo, M_SOF2); /* SOF code for progressive Huffman */
+      emit_sof(cinfo, M_SOF2);  /* SOF code for progressive Huffman */
     else if (is_baseline)
-      emit_sof(cinfo, M_SOF0); /* SOF code for baseline implementation */
+      emit_sof(cinfo, M_SOF0);  /* SOF code for baseline implementation */
     else
-      emit_sof(cinfo, M_SOF1); /* SOF code for non-baseline Huffman file */
+      emit_sof(cinfo, M_SOF1);  /* SOF code for non-baseline Huffman file */
   }
 }
 
@@ -567,17 +568,17 @@ write_scan_header (j_compress_ptr cinfo)
     for (i = 0; i < cinfo->comps_in_scan; i++) {
       compptr = cinfo->cur_comp_info[i];
       if (cinfo->progressive_mode) {
-       /* Progressive mode: only DC or only AC tables are used in one scan */
-       if (cinfo->Ss == 0) {
-         if (cinfo->Ah == 0)   /* DC needs no table for refinement scan */
-           emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
-       } else {
-         emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
-       }
+  /* Progressive mode: only DC or only AC tables are used in one scan */
+  if (cinfo->Ss == 0) {
+    if (cinfo->Ah == 0)  /* DC needs no table for refinement scan */
+      emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+  } else {
+    emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+  }
       } else {
-       /* Sequential mode: need both DC and AC tables */
-       emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
-       emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+  /* Sequential mode: need both DC and AC tables */
+  emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+  emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
       }
     }
   }
@@ -627,9 +628,9 @@ write_tables_only (j_compress_ptr cinfo)
   if (! cinfo->arith_code) {
     for (i = 0; i < NUM_HUFF_TBLS; i++) {
       if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
-       emit_dht(cinfo, i, FALSE);
+  emit_dht(cinfo, i, FALSE);
       if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
-       emit_dht(cinfo, i, TRUE);
+  emit_dht(cinfo, i, TRUE);
     }
   }
 
@@ -649,7 +650,7 @@ jinit_marker_writer (j_compress_ptr cinfo)
   /* Create the subobject */
   marker = (my_marker_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_marker_writer));
+        SIZEOF(my_marker_writer));
   cinfo->marker = (struct jpeg_marker_writer *) marker;
   /* Initialize method pointers */
   marker->pub.write_file_header = write_file_header;
index 212ec8757c4ca865eba34a80530d42e8d371dec7..1e82aa7ba7890af39e19ba0de2e03a3312727b0f 100644 (file)
 
 /* Pointer to routine to downsample a single component */
 typedef JMETHOD(void, downsample1_ptr,
-               (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                JSAMPARRAY input_data, JSAMPARRAY output_data));
+    (j_compress_ptr cinfo, jpeg_component_info * compptr,
+     JSAMPARRAY input_data, JSAMPARRAY output_data));
 
 /* Private subobject */
 
 typedef struct {
-  struct jpeg_downsampler pub; /* public fields */
+  struct jpeg_downsampler pub;  /* public fields */
 
   /* Downsampling method pointers, one per component */
   downsample1_ptr methods[MAX_COMPONENTS];
@@ -74,6 +74,7 @@ typedef my_downsampler * my_downsample_ptr;
 METHODDEF(void)
 start_pass_downsample (j_compress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work for now */
 }
 
@@ -85,7 +86,7 @@ start_pass_downsample (j_compress_ptr cinfo)
 
 LOCAL(void)
 expand_right_edge (JSAMPARRAY image_data, int num_rows,
-                  JDIMENSION input_cols, JDIMENSION output_cols)
+       JDIMENSION input_cols, JDIMENSION output_cols)
 {
   register JSAMPROW ptr;
   register JSAMPLE pixval;
@@ -96,9 +97,9 @@ expand_right_edge (JSAMPARRAY image_data, int num_rows,
   if (numcols > 0) {
     for (row = 0; row < num_rows; row++) {
       ptr = image_data[row] + input_cols;
-      pixval = ptr[-1];                /* don't need GETJSAMPLE() here */
+      pixval = ptr[-1];    /* don't need GETJSAMPLE() here */
       for (count = numcols; count > 0; count--)
-       *ptr++ = pixval;
+  *ptr++ = pixval;
     }
   }
 }
@@ -112,8 +113,8 @@ expand_right_edge (JSAMPARRAY image_data, int num_rows,
 
 METHODDEF(void)
 sep_downsample (j_compress_ptr cinfo,
-               JSAMPIMAGE input_buf, JDIMENSION in_row_index,
-               JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
+    JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+    JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
 {
   my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
   int ci;
@@ -138,10 +139,10 @@ sep_downsample (j_compress_ptr cinfo,
 
 METHODDEF(void)
 int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-               JSAMPARRAY input_data, JSAMPARRAY output_data)
+    JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
-  JDIMENSION outcol, outcol_h; /* outcol_h == outcol*h_expand */
+  JDIMENSION outcol, outcol_h;  /* outcol_h == outcol*h_expand */
   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
   JSAMPROW inptr, outptr;
   INT32 outvalue;
@@ -156,19 +157,19 @@ int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
    * efficient.
    */
   expand_right_edge(input_data, cinfo->max_v_samp_factor,
-                   cinfo->image_width, output_cols * h_expand);
+        cinfo->image_width, output_cols * h_expand);
 
   inrow = 0;
   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
     outptr = output_data[outrow];
     for (outcol = 0, outcol_h = 0; outcol < output_cols;
-        outcol++, outcol_h += h_expand) {
+   outcol++, outcol_h += h_expand) {
       outvalue = 0;
       for (v = 0; v < v_expand; v++) {
-       inptr = input_data[inrow+v] + outcol_h;
-       for (h = 0; h < h_expand; h++) {
-         outvalue += (INT32) GETJSAMPLE(*inptr++);
-       }
+  inptr = input_data[inrow+v] + outcol_h;
+  for (h = 0; h < h_expand; h++) {
+    outvalue += (INT32) GETJSAMPLE(*inptr++);
+  }
       }
       *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
     }
@@ -185,14 +186,14 @@ int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY output_data)
+         JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   /* Copy the data */
   jcopy_sample_rows(input_data, 0, output_data, 0,
-                   cinfo->max_v_samp_factor, cinfo->image_width);
+        cinfo->max_v_samp_factor, cinfo->image_width);
   /* Edge-expand */
   expand_right_edge(output_data, cinfo->max_v_samp_factor,
-                   cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
+        cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
 }
 
 
@@ -210,7 +211,7 @@ fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                JSAMPARRAY input_data, JSAMPARRAY output_data)
+     JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int outrow;
   JDIMENSION outcol;
@@ -223,16 +224,16 @@ h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
    * efficient.
    */
   expand_right_edge(input_data, cinfo->max_v_samp_factor,
-                   cinfo->image_width, output_cols * 2);
+        cinfo->image_width, output_cols * 2);
 
   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
     outptr = output_data[outrow];
     inptr = input_data[outrow];
-    bias = 0;                  /* bias = 0,1,0,1,... for successive samples */
+    bias = 0;      /* bias = 0,1,0,1,... for successive samples */
     for (outcol = 0; outcol < output_cols; outcol++) {
       *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
-                             + bias) >> 1);
-      bias ^= 1;               /* 0=>1, 1=>0 */
+            + bias) >> 1);
+      bias ^= 1;    /* 0=>1, 1=>0 */
       inptr += 2;
     }
   }
@@ -247,7 +248,7 @@ h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                JSAMPARRAY input_data, JSAMPARRAY output_data)
+     JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int inrow, outrow;
   JDIMENSION outcol;
@@ -260,19 +261,19 @@ h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
    * efficient.
    */
   expand_right_edge(input_data, cinfo->max_v_samp_factor,
-                   cinfo->image_width, output_cols * 2);
+        cinfo->image_width, output_cols * 2);
 
   inrow = 0;
   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
     outptr = output_data[outrow];
     inptr0 = input_data[inrow];
     inptr1 = input_data[inrow+1];
-    bias = 1;                  /* bias = 1,2,1,2,... for successive samples */
+    bias = 1;      /* bias = 1,2,1,2,... for successive samples */
     for (outcol = 0; outcol < output_cols; outcol++) {
       *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
-                             GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
-                             + bias) >> 2);
-      bias ^= 3;               /* 1=>2, 2=>1 */
+            GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
+            + bias) >> 2);
+      bias ^= 3;    /* 1=>2, 2=>1 */
       inptr0 += 2; inptr1 += 2;
     }
     inrow += 2;
@@ -290,7 +291,7 @@ h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                       JSAMPARRAY input_data, JSAMPARRAY output_data)
+      JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int inrow, outrow;
   JDIMENSION colctr;
@@ -303,7 +304,7 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
    * efficient.
    */
   expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
-                   cinfo->image_width, output_cols * 2);
+        cinfo->image_width, output_cols * 2);
 
   /* We don't bother to form the individual "smoothed" input pixel values;
    * we can directly compute the output which is the average of the four
@@ -331,14 +332,14 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
     /* Special case for first column: pretend column -1 is same as column 0 */
     membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
-               GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
     neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
-              GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
-              GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
-              GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
+         GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+         GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
+         GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
     neighsum += neighsum;
     neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
-               GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
+    GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
     membersum = membersum * memberscale + neighsum * neighscale;
     *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
     inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
@@ -346,17 +347,17 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
     for (colctr = output_cols - 2; colctr > 0; colctr--) {
       /* sum of pixels directly mapped to this output element */
       membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
-                 GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+      GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
       /* sum of edge-neighbor pixels */
       neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
-                GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
-                GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
-                GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
+     GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+     GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
+     GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
       /* The edge-neighbors count twice as much as corner-neighbors */
       neighsum += neighsum;
       /* Add in the corner-neighbors */
       neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
-                 GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
+      GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
       /* form final output scaled up by 2^16 */
       membersum = membersum * memberscale + neighsum * neighscale;
       /* round, descale and output it */
@@ -366,14 +367,14 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
     /* Special case for last column */
     membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
-               GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
     neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
-              GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
-              GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
-              GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
+         GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+         GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
+         GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
     neighsum += neighsum;
     neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
-               GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
+    GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
     membersum = membersum * memberscale + neighsum * neighscale;
     *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
 
@@ -390,7 +391,7 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
-                           JSAMPARRAY input_data, JSAMPARRAY output_data)
+          JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int outrow;
   JDIMENSION colctr;
@@ -404,7 +405,7 @@ fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
    * efficient.
    */
   expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
-                   cinfo->image_width, output_cols);
+        cinfo->image_width, output_cols);
 
   /* Each of the eight neighbor pixels contributes a fraction SF to the
    * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
@@ -423,10 +424,10 @@ fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
 
     /* Special case for first column */
     colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
-            GETJSAMPLE(*inptr);
+       GETJSAMPLE(*inptr);
     membersum = GETJSAMPLE(*inptr++);
     nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
-                GETJSAMPLE(*inptr);
+     GETJSAMPLE(*inptr);
     neighsum = colsum + (colsum - membersum) + nextcolsum;
     membersum = membersum * memberscale + neighsum * neighscale;
     *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
@@ -436,7 +437,7 @@ fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
       membersum = GETJSAMPLE(*inptr++);
       above_ptr++; below_ptr++;
       nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
-                  GETJSAMPLE(*inptr);
+       GETJSAMPLE(*inptr);
       neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
       membersum = membersum * memberscale + neighsum * neighscale;
       *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
@@ -470,7 +471,7 @@ jinit_downsampler (j_compress_ptr cinfo)
 
   downsample = (my_downsample_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_downsampler));
+        SIZEOF(my_downsampler));
   cinfo->downsample = (struct jpeg_downsampler *) downsample;
   downsample->pub.start_pass = start_pass_downsample;
   downsample->pub.downsample = sep_downsample;
@@ -483,29 +484,29 @@ jinit_downsampler (j_compress_ptr cinfo)
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
     if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
-       compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+  compptr->v_samp_factor == cinfo->max_v_samp_factor) {
 #ifdef INPUT_SMOOTHING_SUPPORTED
       if (cinfo->smoothing_factor) {
-       downsample->methods[ci] = fullsize_smooth_downsample;
-       downsample->pub.need_context_rows = TRUE;
+  downsample->methods[ci] = fullsize_smooth_downsample;
+  downsample->pub.need_context_rows = TRUE;
       } else
 #endif
-       downsample->methods[ci] = fullsize_downsample;
+  downsample->methods[ci] = fullsize_downsample;
     } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
-              compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+         compptr->v_samp_factor == cinfo->max_v_samp_factor) {
       smoothok = FALSE;
       downsample->methods[ci] = h2v1_downsample;
     } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
-              compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
+         compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
 #ifdef INPUT_SMOOTHING_SUPPORTED
       if (cinfo->smoothing_factor) {
-       downsample->methods[ci] = h2v2_smooth_downsample;
-       downsample->pub.need_context_rows = TRUE;
+  downsample->methods[ci] = h2v2_smooth_downsample;
+  downsample->pub.need_context_rows = TRUE;
       } else
 #endif
-       downsample->methods[ci] = h2v2_downsample;
+  downsample->methods[ci] = h2v2_downsample;
     } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
-              (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
+         (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
       smoothok = FALSE;
       downsample->methods[ci] = int_downsample;
     } else
index 0e6d70769df543d84cd5a2bec154443648e5c61a..b84f1d8464213351984d9cee446878fca43d4a1c 100644 (file)
@@ -17,9 +17,9 @@
 
 /* Forward declarations */
 LOCAL(void) transencode_master_selection
-       JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+  JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
 LOCAL(void) transencode_coef_controller
-       JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+  JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
 
 
 /*
@@ -47,7 +47,7 @@ jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
   /* Perform master selection of active modules */
   transencode_master_selection(cinfo, coef_arrays);
   /* Wait for jpeg_finish_compress() call */
-  cinfo->next_scanline = 0;    /* so jpeg_write_marker works */
+  cinfo->next_scanline = 0;  /* so jpeg_write_marker works */
   cinfo->global_state = CSTATE_WRCOEFS;
 }
 
@@ -61,7 +61,7 @@ jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
 
 GLOBAL(void)
 jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
-                              j_compress_ptr dstinfo)
+             j_compress_ptr dstinfo)
 {
   JQUANT_TBL ** qtblptr;
   jpeg_component_info *incomp, *outcomp;
@@ -89,10 +89,10 @@ jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
     if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
       qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
       if (*qtblptr == NULL)
-       *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
+  *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
       MEMCOPY((*qtblptr)->quantval,
-             srcinfo->quant_tbl_ptrs[tblno]->quantval,
-             SIZEOF((*qtblptr)->quantval));
+        srcinfo->quant_tbl_ptrs[tblno]->quantval,
+        SIZEOF((*qtblptr)->quantval));
       (*qtblptr)->sent_table = FALSE;
     }
   }
@@ -102,7 +102,7 @@ jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
   dstinfo->num_components = srcinfo->num_components;
   if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
     ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
-            MAX_COMPONENTS);
+       MAX_COMPONENTS);
   for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
        ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
     outcomp->component_id = incomp->component_id;
@@ -115,14 +115,14 @@ jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
      */
     tblno = outcomp->quant_tbl_no;
     if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
-       srcinfo->quant_tbl_ptrs[tblno] == NULL)
+  srcinfo->quant_tbl_ptrs[tblno] == NULL)
       ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
     slot_quant = srcinfo->quant_tbl_ptrs[tblno];
     c_quant = incomp->quant_table;
     if (c_quant != NULL) {
       for (coefi = 0; coefi < DCTSIZE2; coefi++) {
-       if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
-         ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
+  if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
+    ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
       }
     }
     /* Note: we do not copy the source's Huffman table assignments;
@@ -156,7 +156,7 @@ jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
 
 LOCAL(void)
 transencode_master_selection (j_compress_ptr cinfo,
-                             jvirt_barray_ptr * coef_arrays)
+            jvirt_barray_ptr * coef_arrays)
 {
   /* Although we don't actually use input_components for transcoding,
    * jcmaster.c's initial_setup will complain if input_components is 0.
@@ -208,10 +208,10 @@ transencode_master_selection (j_compress_ptr cinfo,
 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 */
+  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 */
 
   /* Virtual block array for each component. */
   jvirt_barray_ptr * whole_image;
@@ -278,7 +278,7 @@ 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 */
+  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, ci, xindex, yindex, yoffset, blockcnt;
@@ -288,6 +288,8 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   JBLOCKROW buffer_ptr;
   jpeg_component_info *compptr;
 
+  input_buf = 0;
+
   /* Align the virtual buffers for the components used in this scan. */
   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
     compptr = cinfo->cur_comp_info[ci];
@@ -301,44 +303,44 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   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++) {
+   MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
-      blkn = 0;                        /* index of current DCT block within 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;
-       blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
-                                               : compptr->last_col_width;
-       for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-         if (coef->iMCU_row_num < last_iMCU_row ||
-             yindex+yoffset < compptr->last_row_height) {
-           /* Fill in pointers to real blocks in this row */
-           buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
-           for (xindex = 0; xindex < blockcnt; xindex++)
-             MCU_buffer[blkn++] = buffer_ptr++;
-         } else {
-           /* At bottom of image, need a whole row of dummy blocks */
-           xindex = 0;
-         }
-         /* Fill in any dummy blocks needed in this row.
-          * Dummy blocks are filled in the same way as in jccoefct.c:
-          * all zeroes in the AC entries, DC entries equal to previous
-          * block's DC value.  The init routine has already zeroed the
-          * AC entries, so we need only set the DC entries correctly.
-          */
-         for (; xindex < compptr->MCU_width; xindex++) {
-           MCU_buffer[blkn] = coef->dummy_buffer[blkn];
-           MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
-           blkn++;
-         }
-       }
+  compptr = cinfo->cur_comp_info[ci];
+  start_col = MCU_col_num * compptr->MCU_width;
+  blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+            : compptr->last_col_width;
+  for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+    if (coef->iMCU_row_num < last_iMCU_row ||
+        yindex+yoffset < compptr->last_row_height) {
+      /* Fill in pointers to real blocks in this row */
+      buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+      for (xindex = 0; xindex < blockcnt; xindex++)
+        MCU_buffer[blkn++] = buffer_ptr++;
+    } else {
+      /* At bottom of image, need a whole row of dummy blocks */
+      xindex = 0;
+    }
+    /* Fill in any dummy blocks needed in this row.
+     * Dummy blocks are filled in the same way as in jccoefct.c:
+     * all zeroes in the AC entries, DC entries equal to previous
+     * block's DC value.  The init routine has already zeroed the
+     * AC entries, so we need only set the DC entries correctly.
+     */
+    for (; xindex < compptr->MCU_width; xindex++) {
+      MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+      MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
+      blkn++;
+    }
+  }
       }
       /* Try to write the MCU. */
       if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
-       /* Suspension forced; update state counters and exit */
-       coef->MCU_vert_offset = yoffset;
-       coef->mcu_ctr = MCU_col_num;
-       return FALSE;
+  /* 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 */
@@ -361,7 +363,7 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 
 LOCAL(void)
 transencode_coef_controller (j_compress_ptr cinfo,
-                            jvirt_barray_ptr * coef_arrays)
+           jvirt_barray_ptr * coef_arrays)
 {
   my_coef_ptr coef;
   JBLOCKROW buffer;
@@ -369,7 +371,7 @@ transencode_coef_controller (j_compress_ptr cinfo,
 
   coef = (my_coef_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_coef_controller));
+        SIZEOF(my_coef_controller));
   cinfo->coef = (struct jpeg_c_coef_controller *) coef;
   coef->pub.start_pass = start_pass_coef;
   coef->pub.compress_data = compress_output;
@@ -380,7 +382,7 @@ transencode_coef_controller (j_compress_ptr cinfo,
   /* Allocate and pre-zero space for dummy DCT blocks. */
   buffer = (JBLOCKROW)
     (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+        C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
   jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
   for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
     coef->dummy_buffer[i] = buffer + i;
index edc752bf5d8c233a6597ba6a46d48ec7e43c65c7..f6711d9e01ce935273e40b82e7b9e6ed47dd028c 100644 (file)
 /* Expanded data source object for stdio input */
 
 typedef struct {
-  struct jpeg_source_mgr pub;  /* public fields */
+  struct jpeg_source_mgr pub;  /* public fields */
 
-  FILE * infile;               /* source stream */
-  JOCTET * buffer;             /* start of buffer */
-  boolean start_of_file;       /* have we gotten any data yet? */
+  FILE * infile;    /* source stream */
+  JOCTET * buffer;    /* start of buffer */
+  boolean start_of_file;  /* have we gotten any data yet? */
 } my_source_mgr;
 
 typedef my_source_mgr * my_src_ptr;
 
-#define INPUT_BUF_SIZE  4096   /* choose an efficiently fread'able size */
+#define INPUT_BUF_SIZE  4096  /* choose an efficiently fread'able size */
 
 
 /*
@@ -95,7 +95,7 @@ fill_input_buffer (j_decompress_ptr cinfo)
   nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);
 
   if (nbytes <= 0) {
-    if (src->start_of_file)    /* Treat empty input file as fatal error */
+    if (src->start_of_file)  /* Treat empty input file as fatal error */
       ERREXIT(cinfo, JERR_INPUT_EMPTY);
     WARNMS(cinfo, JWRN_JPEG_EOF);
     /* Insert a fake EOI marker */
@@ -168,6 +168,7 @@ skip_input_data (j_decompress_ptr cinfo, long num_bytes)
 METHODDEF(void)
 term_source (j_decompress_ptr cinfo)
 {
+  cinfo=cinfo;
   /* no work necessary here */
 }
 
@@ -190,14 +191,14 @@ jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
    * This makes it unsafe to use this manager and a different source
    * manager serially with the same JPEG object.  Caveat programmer.
    */
-  if (cinfo->src == NULL) {    /* first time for this JPEG object? */
+  if (cinfo->src == NULL) {  /* first time for this JPEG object? */
     cinfo->src = (struct jpeg_source_mgr *)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-                                 SIZEOF(my_source_mgr));
+          SIZEOF(my_source_mgr));
     src = (my_src_ptr) cinfo->src;
     src->buffer = (JOCTET *)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-                                 INPUT_BUF_SIZE * SIZEOF(JOCTET));
+          INPUT_BUF_SIZE * SIZEOF(JOCTET));
   }
 
   src = (my_src_ptr) cinfo->src;
index 4938d20fcb655632d640534ba19e73f0c8fdccbc..0016bdda97b5e15c3956b978d0bbb0ed86f76224 100644 (file)
@@ -30,9 +30,9 @@ typedef struct {
 
   /* These variables keep track of the current location of the input side. */
   /* cinfo->input_iMCU_row is also used for this. */
-  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 */
+  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 */
 
   /* The output side's location is represented by cinfo->output_iMCU_row. */
 
@@ -55,7 +55,7 @@ typedef struct {
 #ifdef BLOCK_SMOOTHING_SUPPORTED
   /* When doing block smoothing, we latch coefficient Al values here */
   int * coef_bits_latch;
-#define SAVED_COEFS  6         /* we save coef_bits[0..5] */
+#define SAVED_COEFS  6    /* we save coef_bits[0..5] */
 #endif
 } my_coef_controller;
 
@@ -63,15 +63,15 @@ typedef my_coef_controller * my_coef_ptr;
 
 /* Forward declarations */
 METHODDEF(int) decompress_onepass
-       JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+  JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
 #ifdef D_MULTISCAN_FILES_SUPPORTED
 METHODDEF(int) decompress_data
-       JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+  JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
 #endif
 #ifdef BLOCK_SMOOTHING_SUPPORTED
 LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo));
 METHODDEF(int) decompress_smooth_data
-       JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+  JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
 #endif
 
 
@@ -147,7 +147,7 @@ METHODDEF(int)
 decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 {
   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
-  JDIMENSION MCU_col_num;      /* index of current MCU within row */
+  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, ci, xindex, yindex, yoffset, useful_width;
@@ -160,49 +160,49 @@ decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
   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++) {
+   MCU_col_num++) {
       /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
       jzero_far((void FAR *) coef->MCU_buffer[0],
-               (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
+    (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
       if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
-       /* Suspension forced; update state counters and exit */
-       coef->MCU_vert_offset = yoffset;
-       coef->MCU_ctr = MCU_col_num;
-       return JPEG_SUSPENDED;
+  /* Suspension forced; update state counters and exit */
+  coef->MCU_vert_offset = yoffset;
+  coef->MCU_ctr = MCU_col_num;
+  return JPEG_SUSPENDED;
       }
       /* Determine where data should go in output_buf and do the IDCT thing.
        * We skip dummy blocks at the right and bottom edges (but blkn gets
        * incremented past them!).  Note the inner loop relies on having
        * allocated the MCU_buffer[] blocks sequentially.
        */
-      blkn = 0;                        /* index of current DCT block within 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];
-       /* Don't bother to IDCT an uninteresting component. */
-       if (! compptr->component_needed) {
-         blkn += compptr->MCU_blocks;
-         continue;
-       }
-       inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
-       useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
-                                                   : compptr->last_col_width;
-       output_ptr = output_buf[compptr->component_index] +
-         yoffset * compptr->DCT_scaled_size;
-       start_col = MCU_col_num * compptr->MCU_sample_width;
-       for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-         if (cinfo->input_iMCU_row < last_iMCU_row ||
-             yoffset+yindex < compptr->last_row_height) {
-           output_col = start_col;
-           for (xindex = 0; xindex < useful_width; xindex++) {
-             (*inverse_DCT) (cinfo, compptr,
-                             (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
-                             output_ptr, output_col);
-             output_col += compptr->DCT_scaled_size;
-           }
-         }
-         blkn += compptr->MCU_width;
-         output_ptr += compptr->DCT_scaled_size;
-       }
+  compptr = cinfo->cur_comp_info[ci];
+  /* Don't bother to IDCT an uninteresting component. */
+  if (! compptr->component_needed) {
+    blkn += compptr->MCU_blocks;
+    continue;
+  }
+  inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
+  useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+                : compptr->last_col_width;
+  output_ptr = output_buf[compptr->component_index] +
+    yoffset * compptr->DCT_scaled_size;
+  start_col = MCU_col_num * compptr->MCU_sample_width;
+  for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+    if (cinfo->input_iMCU_row < last_iMCU_row ||
+        yoffset+yindex < compptr->last_row_height) {
+      output_col = start_col;
+      for (xindex = 0; xindex < useful_width; xindex++) {
+        (*inverse_DCT) (cinfo, compptr,
+            (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
+            output_ptr, output_col);
+        output_col += compptr->DCT_scaled_size;
+      }
+    }
+    blkn += compptr->MCU_width;
+    output_ptr += compptr->DCT_scaled_size;
+  }
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
@@ -227,7 +227,8 @@ decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 METHODDEF(int)
 dummy_consume_data (j_decompress_ptr cinfo)
 {
-  return JPEG_SUSPENDED;       /* Always indicate nothing was done */
+  cinfo = 0;
+  return JPEG_SUSPENDED;  /* Always indicate nothing was done */
 }
 
 
@@ -244,7 +245,7 @@ METHODDEF(int)
 consume_data (j_decompress_ptr cinfo)
 {
   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
-  JDIMENSION MCU_col_num;      /* index of current MCU within row */
+  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];
@@ -268,25 +269,25 @@ consume_data (j_decompress_ptr cinfo)
   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++) {
+   MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
-      blkn = 0;                        /* index of current DCT block within 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++;
-         }
-       }
+  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 fetch the MCU. */
       if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
-       /* Suspension forced; update state counters and exit */
-       coef->MCU_vert_offset = yoffset;
-       coef->MCU_ctr = MCU_col_num;
-       return JPEG_SUSPENDED;
+  /* Suspension forced; update state counters and exit */
+  coef->MCU_vert_offset = yoffset;
+  coef->MCU_ctr = MCU_col_num;
+  return JPEG_SUSPENDED;
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
@@ -327,8 +328,8 @@ decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 
   /* Force some input to be done if we are getting ahead of the input. */
   while (cinfo->input_scan_number < cinfo->output_scan_number ||
-        (cinfo->input_scan_number == cinfo->output_scan_number &&
-         cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
+   (cinfo->input_scan_number == cinfo->output_scan_number &&
+    cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
     if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
       return JPEG_SUSPENDED;
   }
@@ -359,10 +360,10 @@ decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
       buffer_ptr = buffer[block_row];
       output_col = 0;
       for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
-       (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
-                       output_ptr, output_col);
-       buffer_ptr++;
-       output_col += compptr->DCT_scaled_size;
+  (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
+      output_ptr, output_col);
+  buffer_ptr++;
+  output_col += compptr->DCT_scaled_size;
       }
       output_ptr += compptr->DCT_scaled_size;
     }
@@ -419,8 +420,8 @@ smoothing_ok (j_decompress_ptr cinfo)
   if (coef->coef_bits_latch == NULL)
     coef->coef_bits_latch = (int *)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                                 cinfo->num_components *
-                                 (SAVED_COEFS * SIZEOF(int)));
+          cinfo->num_components *
+          (SAVED_COEFS * SIZEOF(int)));
   coef_bits_latch = coef->coef_bits_latch;
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
@@ -430,11 +431,11 @@ smoothing_ok (j_decompress_ptr cinfo)
       return FALSE;
     /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
     if (qtable->quantval[0] == 0 ||
-       qtable->quantval[Q01_POS] == 0 ||
-       qtable->quantval[Q10_POS] == 0 ||
-       qtable->quantval[Q20_POS] == 0 ||
-       qtable->quantval[Q11_POS] == 0 ||
-       qtable->quantval[Q02_POS] == 0)
+  qtable->quantval[Q01_POS] == 0 ||
+  qtable->quantval[Q10_POS] == 0 ||
+  qtable->quantval[Q20_POS] == 0 ||
+  qtable->quantval[Q11_POS] == 0 ||
+  qtable->quantval[Q02_POS] == 0)
       return FALSE;
     /* DC values must be at least partly known for all components. */
     coef_bits = cinfo->coef_bits[ci];
@@ -444,7 +445,7 @@ smoothing_ok (j_decompress_ptr cinfo)
     for (coefi = 1; coefi <= 5; coefi++) {
       coef_bits_latch[coefi] = coef_bits[coefi];
       if (coef_bits[coefi] != 0)
-       smoothing_useful = TRUE;
+  smoothing_useful = TRUE;
     }
     coef_bits_latch += SAVED_COEFS;
   }
@@ -480,7 +481,7 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 
   /* Force some input to be done if we are getting ahead of the input. */
   while (cinfo->input_scan_number <= cinfo->output_scan_number &&
-        ! cinfo->inputctl->eoi_reached) {
+   ! cinfo->inputctl->eoi_reached) {
     if (cinfo->input_scan_number == cinfo->output_scan_number) {
       /* If input is working on current scan, we ordinarily want it to
        * have completed the current row.  But if input scan is DC,
@@ -489,7 +490,7 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
        */
       JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
       if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
-       break;
+  break;
     }
     if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
       return JPEG_SUSPENDED;
@@ -517,15 +518,15 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
     if (cinfo->output_iMCU_row > 0) {
       access_rows += compptr->v_samp_factor; /* prior iMCU row too */
       buffer = (*cinfo->mem->access_virt_barray)
-       ((j_common_ptr) cinfo, coef->whole_image[ci],
-        (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
-        (JDIMENSION) access_rows, FALSE);
-      buffer += compptr->v_samp_factor;        /* point to current iMCU row */
+  ((j_common_ptr) cinfo, coef->whole_image[ci],
+   (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
+   (JDIMENSION) access_rows, FALSE);
+      buffer += compptr->v_samp_factor;  /* point to current iMCU row */
       first_row = FALSE;
     } else {
       buffer = (*cinfo->mem->access_virt_barray)
-       ((j_common_ptr) cinfo, coef->whole_image[ci],
-        (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
+  ((j_common_ptr) cinfo, coef->whole_image[ci],
+   (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
       first_row = TRUE;
     }
     /* Fetch component-dependent info */
@@ -543,13 +544,13 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
     for (block_row = 0; block_row < block_rows; block_row++) {
       buffer_ptr = buffer[block_row];
       if (first_row && block_row == 0)
-       prev_block_row = buffer_ptr;
+  prev_block_row = buffer_ptr;
       else
-       prev_block_row = buffer[block_row-1];
+  prev_block_row = buffer[block_row-1];
       if (last_row && block_row == block_rows-1)
-       next_block_row = buffer_ptr;
+  next_block_row = buffer_ptr;
       else
-       next_block_row = buffer[block_row+1];
+  next_block_row = buffer[block_row+1];
       /* We fetch the surrounding DC values using a sliding-register approach.
        * Initialize all nine here so as to do the right thing on narrow pics.
        */
@@ -559,102 +560,102 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
       output_col = 0;
       last_block_column = compptr->width_in_blocks - 1;
       for (block_num = 0; block_num <= last_block_column; block_num++) {
-       /* Fetch current DCT block into workspace so we can modify it. */
-       jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
-       /* Update DC values */
-       if (block_num < last_block_column) {
-         DC3 = (int) prev_block_row[1][0];
-         DC6 = (int) buffer_ptr[1][0];
-         DC9 = (int) next_block_row[1][0];
-       }
-       /* Compute coefficient estimates per K.8.
-        * An estimate is applied only if coefficient is still zero,
-        * and is not known to be fully accurate.
-        */
-       /* AC01 */
-       if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
-         num = 36 * Q00 * (DC4 - DC6);
-         if (num >= 0) {
-           pred = (int) (((Q01<<7) + num) / (Q01<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q01<<7) - num) / (Q01<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[1] = (JCOEF) pred;
-       }
-       /* AC10 */
-       if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
-         num = 36 * Q00 * (DC2 - DC8);
-         if (num >= 0) {
-           pred = (int) (((Q10<<7) + num) / (Q10<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q10<<7) - num) / (Q10<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[8] = (JCOEF) pred;
-       }
-       /* AC20 */
-       if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
-         num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
-         if (num >= 0) {
-           pred = (int) (((Q20<<7) + num) / (Q20<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q20<<7) - num) / (Q20<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[16] = (JCOEF) pred;
-       }
-       /* AC11 */
-       if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
-         num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
-         if (num >= 0) {
-           pred = (int) (((Q11<<7) + num) / (Q11<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q11<<7) - num) / (Q11<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[9] = (JCOEF) pred;
-       }
-       /* AC02 */
-       if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
-         num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
-         if (num >= 0) {
-           pred = (int) (((Q02<<7) + num) / (Q02<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q02<<7) - num) / (Q02<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[2] = (JCOEF) pred;
-       }
-       /* OK, do the IDCT */
-       (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
-                       output_ptr, output_col);
-       /* Advance for next column */
-       DC1 = DC2; DC2 = DC3;
-       DC4 = DC5; DC5 = DC6;
-       DC7 = DC8; DC8 = DC9;
-       buffer_ptr++, prev_block_row++, next_block_row++;
-       output_col += compptr->DCT_scaled_size;
+  /* Fetch current DCT block into workspace so we can modify it. */
+  jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
+  /* Update DC values */
+  if (block_num < last_block_column) {
+    DC3 = (int) prev_block_row[1][0];
+    DC6 = (int) buffer_ptr[1][0];
+    DC9 = (int) next_block_row[1][0];
+  }
+  /* Compute coefficient estimates per K.8.
+   * An estimate is applied only if coefficient is still zero,
+   * and is not known to be fully accurate.
+   */
+  /* AC01 */
+  if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
+    num = 36 * Q00 * (DC4 - DC6);
+    if (num >= 0) {
+      pred = (int) (((Q01<<7) + num) / (Q01<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q01<<7) - num) / (Q01<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[1] = (JCOEF) pred;
+  }
+  /* AC10 */
+  if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
+    num = 36 * Q00 * (DC2 - DC8);
+    if (num >= 0) {
+      pred = (int) (((Q10<<7) + num) / (Q10<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q10<<7) - num) / (Q10<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[8] = (JCOEF) pred;
+  }
+  /* AC20 */
+  if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
+    num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
+    if (num >= 0) {
+      pred = (int) (((Q20<<7) + num) / (Q20<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q20<<7) - num) / (Q20<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[16] = (JCOEF) pred;
+  }
+  /* AC11 */
+  if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
+    num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
+    if (num >= 0) {
+      pred = (int) (((Q11<<7) + num) / (Q11<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q11<<7) - num) / (Q11<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[9] = (JCOEF) pred;
+  }
+  /* AC02 */
+  if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
+    num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
+    if (num >= 0) {
+      pred = (int) (((Q02<<7) + num) / (Q02<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q02<<7) - num) / (Q02<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[2] = (JCOEF) pred;
+  }
+  /* OK, do the IDCT */
+  (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
+      output_ptr, output_col);
+  /* Advance for next column */
+  DC1 = DC2; DC2 = DC3;
+  DC4 = DC5; DC5 = DC6;
+  DC7 = DC8; DC8 = DC9;
+  buffer_ptr++, prev_block_row++, next_block_row++;
+  output_col += compptr->DCT_scaled_size;
       }
       output_ptr += compptr->DCT_scaled_size;
     }
@@ -679,7 +680,7 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 
   coef = (my_coef_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_coef_controller));
+        SIZEOF(my_coef_controller));
   cinfo->coef = (struct jpeg_d_coef_controller *) coef;
   coef->pub.start_input_pass = start_input_pass;
   coef->pub.start_output_pass = start_output_pass;
@@ -697,20 +698,20 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
     jpeg_component_info *compptr;
 
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-        ci++, compptr++) {
+   ci++, compptr++) {
       access_rows = compptr->v_samp_factor;
 #ifdef BLOCK_SMOOTHING_SUPPORTED
       /* If block smoothing could be used, need a bigger window */
       if (cinfo->progressive_mode)
-       access_rows *= 3;
+  access_rows *= 3;
 #endif
       coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
-       ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
-        (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) access_rows);
+  ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
+   (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) access_rows);
     }
     coef->pub.consume_data = consume_data;
     coef->pub.decompress_data = decompress_data;
@@ -725,7 +726,7 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 
     buffer = (JBLOCKROW)
       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                                 D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+          D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
     for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
       coef->MCU_buffer[i] = buffer + i;
     }
index 6c04dfe8aa1b36e4ab4c9909c77e9cd26b74e9d7..cb9333ae0087671de530b5a08286e0d4057f0ad2 100644 (file)
@@ -19,10 +19,10 @@ typedef struct {
   struct jpeg_color_deconverter pub; /* public fields */
 
   /* Private state for YCC->RGB conversion */
-  int * Cr_r_tab;              /* => table for Cr to R conversion */
-  int * Cb_b_tab;              /* => table for Cb to B conversion */
-  INT32 * Cr_g_tab;            /* => table for Cr to G conversion */
-  INT32 * Cb_g_tab;            /* => table for Cb to G conversion */
+  int * Cr_r_tab;    /* => table for Cr to R conversion */
+  int * Cb_b_tab;    /* => table for Cb to B conversion */
+  INT32 * Cr_g_tab;    /* => table for Cr to G conversion */
+  INT32 * Cb_g_tab;    /* => table for Cb to G conversion */
 } my_color_deconverter;
 
 typedef my_color_deconverter * my_cconvert_ptr;
@@ -34,9 +34,9 @@ typedef my_color_deconverter * my_cconvert_ptr;
  * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
  * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
  * The conversion equations to be implemented are therefore
- *     R = Y                + 1.40200 * Cr
- *     G = Y - 0.34414 * Cb - 0.71414 * Cr
- *     B = Y + 1.77200 * Cb
+ *  R = Y                + 1.40200 * Cr
+ *  G = Y - 0.34414 * Cb - 0.71414 * Cr
+ *  B = Y + 1.77200 * Cb
  * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
  * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
  *
@@ -57,9 +57,9 @@ typedef my_color_deconverter * my_cconvert_ptr;
  * together before rounding.
  */
 
-#define SCALEBITS      16      /* speediest right-shift on some machines */
-#define ONE_HALF       ((INT32) 1 << (SCALEBITS-1))
-#define FIX(x)         ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+#define SCALEBITS  16  /* speediest right-shift on some machines */
+#define ONE_HALF  ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)    ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
 
 
 /*
@@ -76,26 +76,26 @@ build_ycc_rgb_table (j_decompress_ptr cinfo)
 
   cconvert->Cr_r_tab = (int *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(int));
+        (MAXJSAMPLE+1) * SIZEOF(int));
   cconvert->Cb_b_tab = (int *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(int));
+        (MAXJSAMPLE+1) * SIZEOF(int));
   cconvert->Cr_g_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(INT32));
+        (MAXJSAMPLE+1) * SIZEOF(INT32));
   cconvert->Cb_g_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(INT32));
+        (MAXJSAMPLE+1) * SIZEOF(INT32));
 
   for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
     /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
     /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
     /* Cr=>R value is nearest int to 1.40200 * x */
     cconvert->Cr_r_tab[i] = (int)
-                   RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+        RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
     /* Cb=>B value is nearest int to 1.77200 * x */
     cconvert->Cb_b_tab[i] = (int)
-                   RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+        RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
     /* Cr=>G value is scaled-up -0.71414 * x */
     cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
     /* Cb=>G value is scaled-up -0.34414 * x */
@@ -118,8 +118,8 @@ build_ycc_rgb_table (j_decompress_ptr cinfo)
 
 METHODDEF(void)
 ycc_rgb_convert (j_decompress_ptr cinfo,
-                JSAMPIMAGE input_buf, JDIMENSION input_row,
-                JSAMPARRAY output_buf, int num_rows)
+     JSAMPIMAGE input_buf, JDIMENSION input_row,
+     JSAMPARRAY output_buf, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int y, cb, cr;
@@ -148,8 +148,8 @@ ycc_rgb_convert (j_decompress_ptr cinfo,
       /* Range-limiting is essential due to noise introduced by DCT losses. */
       outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
       outptr[RGB_GREEN] = range_limit[y +
-                             ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
-                                                SCALEBITS))];
+            ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+             SCALEBITS))];
       outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
       outptr += RGB_PIXELSIZE;
     }
@@ -167,8 +167,8 @@ ycc_rgb_convert (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 null_convert (j_decompress_ptr cinfo,
-             JSAMPIMAGE input_buf, JDIMENSION input_row,
-             JSAMPARRAY output_buf, int num_rows)
+        JSAMPIMAGE input_buf, JDIMENSION input_row,
+        JSAMPARRAY output_buf, int num_rows)
 {
   register JSAMPROW inptr, outptr;
   register JDIMENSION count;
@@ -181,8 +181,8 @@ null_convert (j_decompress_ptr cinfo,
       inptr = input_buf[ci][input_row];
       outptr = output_buf[0] + ci;
       for (count = num_cols; count > 0; count--) {
-       *outptr = *inptr++;     /* needn't bother with GETJSAMPLE() here */
-       outptr += num_components;
+  *outptr = *inptr++;  /* needn't bother with GETJSAMPLE() here */
+  outptr += num_components;
       }
     }
     input_row++;
@@ -199,11 +199,11 @@ null_convert (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 grayscale_convert (j_decompress_ptr cinfo,
-                  JSAMPIMAGE input_buf, JDIMENSION input_row,
-                  JSAMPARRAY output_buf, int num_rows)
+       JSAMPIMAGE input_buf, JDIMENSION input_row,
+       JSAMPARRAY output_buf, int num_rows)
 {
   jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
-                   num_rows, cinfo->output_width);
+        num_rows, cinfo->output_width);
 }
 
 
@@ -215,8 +215,8 @@ grayscale_convert (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 gray_rgb_convert (j_decompress_ptr cinfo,
-                 JSAMPIMAGE input_buf, JDIMENSION input_row,
-                 JSAMPARRAY output_buf, int num_rows)
+      JSAMPIMAGE input_buf, JDIMENSION input_row,
+      JSAMPARRAY output_buf, int num_rows)
 {
   register JSAMPROW inptr, outptr;
   register JDIMENSION col;
@@ -243,8 +243,8 @@ gray_rgb_convert (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 ycck_cmyk_convert (j_decompress_ptr cinfo,
-                  JSAMPIMAGE input_buf, JDIMENSION input_row,
-                  JSAMPARRAY output_buf, int num_rows)
+       JSAMPIMAGE input_buf, JDIMENSION input_row,
+       JSAMPARRAY output_buf, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int y, cb, cr;
@@ -272,13 +272,13 @@ ycck_cmyk_convert (j_decompress_ptr cinfo,
       cb = GETJSAMPLE(inptr1[col]);
       cr = GETJSAMPLE(inptr2[col]);
       /* Range-limiting is essential due to noise introduced by DCT losses. */
-      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];  /* red */
-      outptr[1] = range_limit[MAXJSAMPLE - (y +                        /* green */
-                             ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
-                                                SCALEBITS)))];
-      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];  /* blue */
+      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];  /* red */
+      outptr[1] = range_limit[MAXJSAMPLE - (y +      /* green */
+            ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+             SCALEBITS)))];
+      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];  /* blue */
       /* K passes through unchanged */
-      outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */
+      outptr[3] = inptr3[col];  /* don't need GETJSAMPLE here */
       outptr += 4;
     }
   }
@@ -292,6 +292,7 @@ ycck_cmyk_convert (j_decompress_ptr cinfo,
 METHODDEF(void)
 start_pass_dcolor (j_decompress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work needed */
 }
 
@@ -308,7 +309,7 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
 
   cconvert = (my_cconvert_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_color_deconverter));
+        SIZEOF(my_color_deconverter));
   cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
   cconvert->pub.start_pass = start_pass_dcolor;
 
@@ -331,7 +332,7 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
       ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
     break;
 
-  default:                     /* JCS_UNKNOWN can be anything */
+  default:      /* JCS_UNKNOWN can be anything */
     if (cinfo->num_components < 1)
       ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
     break;
@@ -346,11 +347,11 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
   case JCS_GRAYSCALE:
     cinfo->out_color_components = 1;
     if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
-       cinfo->jpeg_color_space == JCS_YCbCr) {
+  cinfo->jpeg_color_space == JCS_YCbCr) {
       cconvert->pub.color_convert = grayscale_convert;
       /* For color->grayscale conversion, only the Y (0) component is needed */
       for (ci = 1; ci < cinfo->num_components; ci++)
-       cinfo->comp_info[ci].component_needed = FALSE;
+  cinfo->comp_info[ci].component_needed = FALSE;
     } else
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     break;
@@ -384,7 +385,7 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
     if (cinfo->out_color_space == cinfo->jpeg_color_space) {
       cinfo->out_color_components = cinfo->num_components;
       cconvert->pub.color_convert = null_convert;
-    } else                     /* unsupported non-null conversion */
+    } else      /* unsupported non-null conversion */
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     break;
   }
index 37444468c2370a71f1317a50ddaf3287e3e04969..d5508698c135f566790fa001ef95695c1dd7ac5b 100644 (file)
  * (ie, box filtering), we can save some work in color conversion by
  * calculating all the output pixels corresponding to a pair of chroma
  * samples at one time.  In the conversion equations
- *     R = Y           + K1 * Cr
- *     G = Y + K2 * Cb + K3 * Cr
- *     B = Y + K4 * Cb
+ *  R = Y           + K1 * Cr
+ *  G = Y + K2 * Cb + K3 * Cr
+ *  B = Y + K4 * Cb
  * only the Y term varies among the group of pixels corresponding to a pair
  * of chroma samples, so the rest of the terms can be calculated just once.
  * At typical sampling ratios, this eliminates half or three-quarters of the
  * multiplications needed for color conversion.
  *
  * This file currently provides implementations for the following cases:
- *     YCbCr => RGB color conversion only.
- *     Sampling ratios of 2h1v or 2h2v.
- *     No scaling needed at upsample time.
- *     Corner-aligned (non-CCIR601) sampling alignment.
+ *  YCbCr => RGB color conversion only.
+ *  Sampling ratios of 2h1v or 2h2v.
+ *  No scaling needed at upsample time.
+ *  Corner-aligned (non-CCIR601) sampling alignment.
  * Other special cases could be added, but in most applications these are
  * the only common cases.  (For uncommon cases we fall back on the more
  * general code in jdsample.c and jdcolor.c.)
 /* Private subobject */
 
 typedef struct {
-  struct jpeg_upsampler pub;   /* public fields */
+  struct jpeg_upsampler pub;  /* public fields */
 
   /* Pointer to routine to do actual upsampling/conversion of one row group */
   JMETHOD(void, upmethod, (j_decompress_ptr cinfo,
-                          JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
-                          JSAMPARRAY output_buf));
+         JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+         JSAMPARRAY output_buf));
 
   /* Private state for YCC->RGB conversion */
-  int * Cr_r_tab;              /* => table for Cr to R conversion */
-  int * Cb_b_tab;              /* => table for Cb to B conversion */
-  INT32 * Cr_g_tab;            /* => table for Cr to G conversion */
-  INT32 * Cb_g_tab;            /* => table for Cb to G conversion */
+  int * Cr_r_tab;    /* => table for Cr to R conversion */
+  int * Cb_b_tab;    /* => table for Cb to B conversion */
+  INT32 * Cr_g_tab;    /* => table for Cr to G conversion */
+  INT32 * Cb_g_tab;    /* => table for Cb to G conversion */
 
   /* For 2:1 vertical sampling, we produce two output rows at a time.
    * We need a "spare" row buffer to hold the second output row if the
@@ -61,17 +61,17 @@ typedef struct {
    * to discard the dummy last row if the image height is odd.
    */
   JSAMPROW spare_row;
-  boolean spare_full;          /* T if spare buffer is occupied */
+  boolean spare_full;    /* T if spare buffer is occupied */
 
-  JDIMENSION out_row_width;    /* samples per output row */
-  JDIMENSION rows_to_go;       /* counts rows remaining in image */
+  JDIMENSION out_row_width;  /* samples per output row */
+  JDIMENSION rows_to_go;  /* counts rows remaining in image */
 } my_upsampler;
 
 typedef my_upsampler * my_upsample_ptr;
 
-#define SCALEBITS      16      /* speediest right-shift on some machines */
-#define ONE_HALF       ((INT32) 1 << (SCALEBITS-1))
-#define FIX(x)         ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+#define SCALEBITS  16  /* speediest right-shift on some machines */
+#define ONE_HALF  ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)    ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
 
 
 /*
@@ -89,26 +89,26 @@ build_ycc_rgb_table (j_decompress_ptr cinfo)
 
   upsample->Cr_r_tab = (int *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(int));
+        (MAXJSAMPLE+1) * SIZEOF(int));
   upsample->Cb_b_tab = (int *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(int));
+        (MAXJSAMPLE+1) * SIZEOF(int));
   upsample->Cr_g_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(INT32));
+        (MAXJSAMPLE+1) * SIZEOF(INT32));
   upsample->Cb_g_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(INT32));
+        (MAXJSAMPLE+1) * SIZEOF(INT32));
 
   for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
     /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
     /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
     /* Cr=>R value is nearest int to 1.40200 * x */
     upsample->Cr_r_tab[i] = (int)
-                   RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+        RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
     /* Cb=>B value is nearest int to 1.77200 * x */
     upsample->Cb_b_tab[i] = (int)
-                   RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+        RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
     /* Cr=>G value is scaled-up -0.71414 * x */
     upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
     /* Cb=>G value is scaled-up -0.34414 * x */
@@ -142,20 +142,22 @@ start_pass_merged_upsample (j_decompress_ptr cinfo)
 
 METHODDEF(void)
 merged_2v_upsample (j_decompress_ptr cinfo,
-                   JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail,
-                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                   JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 /* 2:1 vertical sampling case: may need a spare row. */
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   JSAMPROW work_ptrs[2];
-  JDIMENSION num_rows;         /* number of rows returned to caller */
+  JDIMENSION num_rows;    /* number of rows returned to caller */
+
+  in_row_groups_avail = 0;
 
   if (upsample->spare_full) {
     /* If we have a spare row saved from a previous cycle, just return it. */
     jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
-                     1, upsample->out_row_width);
+          1, upsample->out_row_width);
     num_rows = 1;
     upsample->spare_full = FALSE;
   } else {
@@ -191,17 +193,20 @@ merged_2v_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 merged_1v_upsample (j_decompress_ptr cinfo,
-                   JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail,
-                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                   JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 /* 1:1 vertical sampling case: much easier, never need a spare row. */
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
 
+  in_row_groups_avail = 0;
+  out_rows_avail = 0;
+
   /* Just do the upsampling. */
   (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
-                        output_buf + *out_row_ctr);
+       output_buf + *out_row_ctr);
   /* Adjust counts */
   (*out_row_ctr)++;
   (*in_row_group_ctr)++;
@@ -224,8 +229,8 @@ merged_1v_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 h2v1_merged_upsample (j_decompress_ptr cinfo,
-                     JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
-                     JSAMPARRAY output_buf)
+          JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+          JSAMPARRAY output_buf)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   register int y, cred, cgreen, cblue;
@@ -286,8 +291,8 @@ h2v1_merged_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 h2v2_merged_upsample (j_decompress_ptr cinfo,
-                     JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
-                     JSAMPARRAY output_buf)
+          JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+          JSAMPARRAY output_buf)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   register int y, cred, cgreen, cblue;
@@ -373,7 +378,7 @@ jinit_merged_upsampler (j_decompress_ptr cinfo)
 
   upsample = (my_upsample_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_upsampler));
+        SIZEOF(my_upsampler));
   cinfo->upsample = (struct jpeg_upsampler *) upsample;
   upsample->pub.start_pass = start_pass_merged_upsample;
   upsample->pub.need_context_rows = FALSE;
@@ -386,7 +391,7 @@ jinit_merged_upsampler (j_decompress_ptr cinfo)
     /* Allocate a spare row buffer */
     upsample->spare_row = (JSAMPROW)
       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-               (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
+    (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
   } else {
     upsample->pub.upsample = merged_1v_upsample;
     upsample->upmethod = h2v1_merged_upsample;
index 571563d728e7135996cc982b8f8dfba3d69a9846..4226077b9ab477a15d167a708586ef691b820490 100644 (file)
@@ -31,12 +31,12 @@ typedef struct {
    * For two-pass color quantization, we need a full-image buffer;
    * for one-pass operation, a strip buffer is sufficient.
    */
-  jvirt_sarray_ptr whole_image;        /* virtual array, or NULL if one-pass */
-  JSAMPARRAY buffer;           /* strip buffer, or current strip of virtual */
-  JDIMENSION strip_height;     /* buffer size in rows */
+  jvirt_sarray_ptr whole_image;  /* virtual array, or NULL if one-pass */
+  JSAMPARRAY buffer;    /* strip buffer, or current strip of virtual */
+  JDIMENSION strip_height;  /* buffer size in rows */
   /* for two-pass mode only: */
-  JDIMENSION starting_row;     /* row # of first row in current strip */
-  JDIMENSION next_row;         /* index of next row to fill/empty in strip */
+  JDIMENSION starting_row;  /* row # of first row in current strip */
+  JDIMENSION next_row;    /* index of next row to fill/empty in strip */
 } my_post_controller;
 
 typedef my_post_controller * my_post_ptr;
@@ -44,24 +44,24 @@ typedef my_post_controller * my_post_ptr;
 
 /* Forward declarations */
 METHODDEF(void) post_process_1pass
-       JPP((j_decompress_ptr cinfo,
-            JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-            JDIMENSION in_row_groups_avail,
-            JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-            JDIMENSION out_rows_avail));
+  JPP((j_decompress_ptr cinfo,
+       JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+       JDIMENSION in_row_groups_avail,
+       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+       JDIMENSION out_rows_avail));
 #ifdef QUANT_2PASS_SUPPORTED
 METHODDEF(void) post_process_prepass
-       JPP((j_decompress_ptr cinfo,
-            JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-            JDIMENSION in_row_groups_avail,
-            JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-            JDIMENSION out_rows_avail));
+  JPP((j_decompress_ptr cinfo,
+       JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+       JDIMENSION in_row_groups_avail,
+       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+       JDIMENSION out_rows_avail));
 METHODDEF(void) post_process_2pass
-       JPP((j_decompress_ptr cinfo,
-            JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-            JDIMENSION in_row_groups_avail,
-            JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-            JDIMENSION out_rows_avail));
+  JPP((j_decompress_ptr cinfo,
+       JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+       JDIMENSION in_row_groups_avail,
+       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+       JDIMENSION out_rows_avail));
 #endif
 
 
@@ -84,9 +84,9 @@ start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
        * allocate a strip buffer.  Use the virtual-array buffer as workspace.
        */
       if (post->buffer == NULL) {
-       post->buffer = (*cinfo->mem->access_virt_sarray)
-         ((j_common_ptr) cinfo, post->whole_image,
-          (JDIMENSION) 0, post->strip_height, TRUE);
+  post->buffer = (*cinfo->mem->access_virt_sarray)
+    ((j_common_ptr) cinfo, post->whole_image,
+     (JDIMENSION) 0, post->strip_height, TRUE);
       }
     } else {
       /* For single-pass processing without color quantization,
@@ -124,10 +124,10 @@ start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
 
 METHODDEF(void)
 post_process_1pass (j_decompress_ptr cinfo,
-                   JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail,
-                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                   JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 {
   my_post_ptr post = (my_post_ptr) cinfo->post;
   JDIMENSION num_rows, max_rows;
@@ -139,11 +139,11 @@ post_process_1pass (j_decompress_ptr cinfo,
     max_rows = post->strip_height;
   num_rows = 0;
   (*cinfo->upsample->upsample) (cinfo,
-               input_buf, in_row_group_ctr, in_row_groups_avail,
-               post->buffer, &num_rows, max_rows);
+    input_buf, in_row_group_ctr, in_row_groups_avail,
+    post->buffer, &num_rows, max_rows);
   /* Quantize and emit data. */
   (*cinfo->cquantize->color_quantize) (cinfo,
-               post->buffer, output_buf + *out_row_ctr, (int) num_rows);
+    post->buffer, output_buf + *out_row_ctr, (int) num_rows);
   *out_row_ctr += num_rows;
 }
 
@@ -156,33 +156,35 @@ post_process_1pass (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 post_process_prepass (j_decompress_ptr cinfo,
-                     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                     JDIMENSION in_row_groups_avail,
-                     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                     JDIMENSION out_rows_avail)
+          JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+          JDIMENSION in_row_groups_avail,
+          JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+          JDIMENSION out_rows_avail)
 {
   my_post_ptr post = (my_post_ptr) cinfo->post;
   JDIMENSION old_next_row, num_rows;
+  output_buf = 0;
+  out_rows_avail = 0;
 
   /* Reposition virtual buffer if at start of strip. */
   if (post->next_row == 0) {
     post->buffer = (*cinfo->mem->access_virt_sarray)
-       ((j_common_ptr) cinfo, post->whole_image,
-        post->starting_row, post->strip_height, TRUE);
+  ((j_common_ptr) cinfo, post->whole_image,
+   post->starting_row, post->strip_height, TRUE);
   }
 
   /* Upsample some data (up to a strip height's worth). */
   old_next_row = post->next_row;
   (*cinfo->upsample->upsample) (cinfo,
-               input_buf, in_row_group_ctr, in_row_groups_avail,
-               post->buffer, &post->next_row, post->strip_height);
+    input_buf, in_row_group_ctr, in_row_groups_avail,
+    post->buffer, &post->next_row, post->strip_height);
 
   /* Allow quantizer to scan new data.  No data is emitted, */
   /* but we advance out_row_ctr so outer loop can tell when we're done. */
   if (post->next_row > old_next_row) {
     num_rows = post->next_row - old_next_row;
     (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
-                                        (JSAMPARRAY) NULL, (int) num_rows);
+           (JSAMPARRAY) NULL, (int) num_rows);
     *out_row_ctr += num_rows;
   }
 
@@ -200,19 +202,22 @@ post_process_prepass (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 post_process_2pass (j_decompress_ptr cinfo,
-                   JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail,
-                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                   JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 {
   my_post_ptr post = (my_post_ptr) cinfo->post;
   JDIMENSION num_rows, max_rows;
 
+  input_buf = 0;
+  in_row_group_ctr = 0;
+  in_row_groups_avail = 0;
   /* Reposition virtual buffer if at start of strip. */
   if (post->next_row == 0) {
     post->buffer = (*cinfo->mem->access_virt_sarray)
-       ((j_common_ptr) cinfo, post->whole_image,
-        post->starting_row, post->strip_height, FALSE);
+  ((j_common_ptr) cinfo, post->whole_image,
+   post->starting_row, post->strip_height, FALSE);
   }
 
   /* Determine number of rows to emit. */
@@ -227,8 +232,8 @@ post_process_2pass (j_decompress_ptr cinfo,
 
   /* Quantize and emit data. */
   (*cinfo->cquantize->color_quantize) (cinfo,
-               post->buffer + post->next_row, output_buf + *out_row_ctr,
-               (int) num_rows);
+    post->buffer + post->next_row, output_buf + *out_row_ctr,
+    (int) num_rows);
   *out_row_ctr += num_rows;
 
   /* Advance if we filled the strip. */
@@ -253,11 +258,11 @@ jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 
   post = (my_post_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_post_controller));
+        SIZEOF(my_post_controller));
   cinfo->post = (struct jpeg_d_post_controller *) post;
   post->pub.start_pass = start_pass_dpost;
-  post->whole_image = NULL;    /* flag for no virtual arrays */
-  post->buffer = NULL;         /* flag for no strip buffer */
+  post->whole_image = NULL;  /* flag for no virtual arrays */
+  post->buffer = NULL;    /* flag for no strip buffer */
 
   /* Create the quantization buffer, if needed */
   if (cinfo->quantize_colors) {
@@ -271,20 +276,20 @@ jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
       /* We round up the number of rows to a multiple of the strip height. */
 #ifdef QUANT_2PASS_SUPPORTED
       post->whole_image = (*cinfo->mem->request_virt_sarray)
-       ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
-        cinfo->output_width * cinfo->out_color_components,
-        (JDIMENSION) jround_up((long) cinfo->output_height,
-                               (long) post->strip_height),
-        post->strip_height);
+  ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+   cinfo->output_width * cinfo->out_color_components,
+   (JDIMENSION) jround_up((long) cinfo->output_height,
+        (long) post->strip_height),
+   post->strip_height);
 #else
       ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
 #endif /* QUANT_2PASS_SUPPORTED */
     } else {
       /* One-pass color quantization: just make a strip buffer. */
       post->buffer = (*cinfo->mem->alloc_sarray)
-       ((j_common_ptr) cinfo, JPOOL_IMAGE,
-        cinfo->output_width * cinfo->out_color_components,
-        post->strip_height);
+  ((j_common_ptr) cinfo, JPOOL_IMAGE,
+   cinfo->output_width * cinfo->out_color_components,
+   post->strip_height);
     }
   }
 }
index 80ffefb2a1ccf5ddc1530b921df0eef6e3e45c18..f42cc33301c02c1ca3cb0322f0dbfd216dde165e 100644 (file)
 
 /* Pointer to routine to upsample a single component */
 typedef JMETHOD(void, upsample1_ptr,
-               (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-                JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
+    (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
 
 /* Private subobject */
 
 typedef struct {
-  struct jpeg_upsampler pub;   /* public fields */
+  struct jpeg_upsampler pub;  /* public fields */
 
   /* Color conversion buffer.  When using separate upsampling and color
    * conversion steps, this buffer holds one upsampled row group until it
@@ -45,8 +45,8 @@ typedef struct {
   /* Per-component upsampling method pointers */
   upsample1_ptr methods[MAX_COMPONENTS];
 
-  int next_row_out;            /* counts rows emitted from color_buf */
-  JDIMENSION rows_to_go;       /* counts rows remaining in image */
+  int next_row_out;    /* counts rows emitted from color_buf */
+  JDIMENSION rows_to_go;  /* counts rows remaining in image */
 
   /* Height of an input row group for each component. */
   int rowgroup_height[MAX_COMPONENTS];
@@ -87,26 +87,27 @@ start_pass_upsample (j_decompress_ptr cinfo)
 
 METHODDEF(void)
 sep_upsample (j_decompress_ptr cinfo,
-             JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-             JDIMENSION in_row_groups_avail,
-             JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-             JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   int ci;
   jpeg_component_info * compptr;
   JDIMENSION num_rows;
 
+  in_row_groups_avail = 0;
   /* Fill the conversion buffer, if it's empty */
   if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-        ci++, compptr++) {
+   ci++, compptr++) {
       /* Invoke per-component upsample method.  Notice we pass a POINTER
        * to color_buf[ci], so that fullsize_upsample can change it.
        */
       (*upsample->methods[ci]) (cinfo, compptr,
-       input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
-       upsample->color_buf + ci);
+  input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
+  upsample->color_buf + ci);
     }
     upsample->next_row_out = 0;
   }
@@ -126,9 +127,9 @@ sep_upsample (j_decompress_ptr cinfo,
     num_rows = out_rows_avail;
 
   (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
-                                    (JDIMENSION) upsample->next_row_out,
-                                    output_buf + *out_row_ctr,
-                                    (int) num_rows);
+             (JDIMENSION) upsample->next_row_out,
+             output_buf + *out_row_ctr,
+             (int) num_rows);
 
   /* Adjust counts */
   *out_row_ctr += num_rows;
@@ -155,8 +156,10 @@ sep_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-                  JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
+  cinfo = 0;
+  compptr = 0;
   *output_data_ptr = input_data;
 }
 
@@ -168,9 +171,12 @@ fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-              JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
-  *output_data_ptr = NULL;     /* safety check */
+  cinfo = 0;
+  compptr = 0;
+  input_data = 0;
+  *output_data_ptr = NULL;  /* safety check */
 }
 
 
@@ -187,7 +193,7 @@ noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-             JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+        JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   JSAMPARRAY output_data = *output_data_ptr;
@@ -208,15 +214,15 @@ int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
     outptr = output_data[outrow];
     outend = outptr + cinfo->output_width;
     while (outptr < outend) {
-      invalue = *inptr++;      /* don't need GETJSAMPLE() here */
+      invalue = *inptr++;  /* don't need GETJSAMPLE() here */
       for (h = h_expand; h > 0; h--) {
-       *outptr++ = invalue;
+  *outptr++ = invalue;
       }
     }
     /* Generate any additional output rows by duplicating the first one */
     if (v_expand > 1) {
       jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
-                       v_expand-1, cinfo->output_width);
+      v_expand-1, cinfo->output_width);
     }
     inrow++;
     outrow += v_expand;
@@ -231,7 +237,7 @@ int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-              JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr, outptr;
@@ -239,12 +245,13 @@ h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
   JSAMPROW outend;
   int inrow;
 
+  compptr = 0;
   for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
     inptr = input_data[inrow];
     outptr = output_data[inrow];
     outend = outptr + cinfo->output_width;
     while (outptr < outend) {
-      invalue = *inptr++;      /* don't need GETJSAMPLE() here */
+      invalue = *inptr++;  /* don't need GETJSAMPLE() here */
       *outptr++ = invalue;
       *outptr++ = invalue;
     }
@@ -259,7 +266,7 @@ h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-              JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr, outptr;
@@ -267,18 +274,19 @@ h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
   JSAMPROW outend;
   int inrow, outrow;
 
+  compptr = 0;
   inrow = outrow = 0;
   while (outrow < cinfo->max_v_samp_factor) {
     inptr = input_data[inrow];
     outptr = output_data[outrow];
     outend = outptr + cinfo->output_width;
     while (outptr < outend) {
-      invalue = *inptr++;      /* don't need GETJSAMPLE() here */
+      invalue = *inptr++;  /* don't need GETJSAMPLE() here */
       *outptr++ = invalue;
       *outptr++ = invalue;
     }
     jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
-                     1, cinfo->output_width);
+          1, cinfo->output_width);
     inrow++;
     outrow += 2;
   }
@@ -302,7 +310,7 @@ h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr, outptr;
@@ -343,7 +351,7 @@ h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr0, inptr1, outptr;
@@ -360,10 +368,10 @@ h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
     for (v = 0; v < 2; v++) {
       /* inptr0 points to nearest input row, inptr1 points to next nearest */
       inptr0 = input_data[inrow];
-      if (v == 0)              /* next nearest is row above */
-       inptr1 = input_data[inrow-1];
-      else                     /* next nearest is row below */
-       inptr1 = input_data[inrow+1];
+      if (v == 0)    /* next nearest is row above */
+  inptr1 = input_data[inrow-1];
+      else      /* next nearest is row below */
+  inptr1 = input_data[inrow+1];
       outptr = output_data[outrow++];
 
       /* Special case for first column */
@@ -374,12 +382,12 @@ h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
       lastcolsum = thiscolsum; thiscolsum = nextcolsum;
 
       for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
-       /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
-       /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
-       nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
-       *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
-       *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
-       lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+  /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
+  /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
+  nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+  *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+  *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+  lastcolsum = thiscolsum; thiscolsum = nextcolsum;
       }
 
       /* Special case for last column */
@@ -406,13 +414,13 @@ jinit_upsampler (j_decompress_ptr cinfo)
 
   upsample = (my_upsample_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_upsampler));
+        SIZEOF(my_upsampler));
   cinfo->upsample = (struct jpeg_upsampler *) upsample;
   upsample->pub.start_pass = start_pass_upsample;
   upsample->pub.upsample = sep_upsample;
   upsample->pub.need_context_rows = FALSE; /* until we find out differently */
 
-  if (cinfo->CCIR601_sampling) /* this isn't supported */
+  if (cinfo->CCIR601_sampling)  /* this isn't supported */
     ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
 
   /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
@@ -429,9 +437,9 @@ jinit_upsampler (j_decompress_ptr cinfo)
      * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
      */
     h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
-                cinfo->min_DCT_scaled_size;
+     cinfo->min_DCT_scaled_size;
     v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
-                cinfo->min_DCT_scaled_size;
+     cinfo->min_DCT_scaled_size;
     h_out_group = cinfo->max_h_samp_factor;
     v_out_group = cinfo->max_v_samp_factor;
     upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
@@ -445,22 +453,22 @@ jinit_upsampler (j_decompress_ptr cinfo)
       upsample->methods[ci] = fullsize_upsample;
       need_buffer = FALSE;
     } else if (h_in_group * 2 == h_out_group &&
-              v_in_group == v_out_group) {
+         v_in_group == v_out_group) {
       /* Special cases for 2h1v upsampling */
       if (do_fancy && compptr->downsampled_width > 2)
-       upsample->methods[ci] = h2v1_fancy_upsample;
+  upsample->methods[ci] = h2v1_fancy_upsample;
       else
-       upsample->methods[ci] = h2v1_upsample;
+  upsample->methods[ci] = h2v1_upsample;
     } else if (h_in_group * 2 == h_out_group &&
-              v_in_group * 2 == v_out_group) {
+         v_in_group * 2 == v_out_group) {
       /* Special cases for 2h2v upsampling */
       if (do_fancy && compptr->downsampled_width > 2) {
-       upsample->methods[ci] = h2v2_fancy_upsample;
-       upsample->pub.need_context_rows = TRUE;
+  upsample->methods[ci] = h2v2_fancy_upsample;
+  upsample->pub.need_context_rows = TRUE;
       } else
-       upsample->methods[ci] = h2v2_upsample;
+  upsample->methods[ci] = h2v2_upsample;
     } else if ((h_out_group % h_in_group) == 0 &&
-              (v_out_group % v_in_group) == 0) {
+         (v_out_group % v_in_group) == 0) {
       /* Generic integral-factors upsampling method */
       upsample->methods[ci] = int_upsample;
       upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
@@ -469,10 +477,10 @@ jinit_upsampler (j_decompress_ptr cinfo)
       ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
     if (need_buffer) {
       upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
-       ((j_common_ptr) cinfo, JPOOL_IMAGE,
-        (JDIMENSION) jround_up((long) cinfo->output_width,
-                               (long) cinfo->max_h_samp_factor),
-        (JDIMENSION) cinfo->max_v_samp_factor);
+  ((j_common_ptr) cinfo, JPOOL_IMAGE,
+   (JDIMENSION) jround_up((long) cinfo->output_width,
+        (long) cinfo->max_h_samp_factor),
+   (JDIMENSION) cinfo->max_v_samp_factor);
     }
   }
 }
index eb8c337725fd85f289b04eebbea8549d90d53c77..7e53479f3d93c38b858a7ec05fd3dafcd6e01419 100644 (file)
@@ -18,9 +18,9 @@
 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
-#include "jmemsys.h"           /* import the system-dependent declarations */
+#include "jmemsys.h"    /* import the system-dependent declarations */
 
-#ifndef HAVE_STDLIB_H          /* <stdlib.h> should declare malloc(),free() */
+#ifndef HAVE_STDLIB_H    /* <stdlib.h> should declare malloc(),free() */
 extern void * malloc JPP((size_t size));
 extern void free JPP((void *ptr));
 #endif
@@ -34,12 +34,15 @@ extern void free JPP((void *ptr));
 GLOBAL(void *)
 jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
 {
+  cinfo = 0;
   return (void *) malloc(sizeofobject);
 }
 
 GLOBAL(void)
 jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
 {
+  cinfo = 0;
+  sizeofobject = 0;
   free(object);
 }
 
@@ -54,12 +57,15 @@ jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
 GLOBAL(void FAR *)
 jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
 {
+  cinfo = 0;
   return (void FAR *) malloc(sizeofobject);
 }
 
 GLOBAL(void)
 jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
 {
+  cinfo = 0;
+  sizeofobject = 0;
   free(object);
 }
 
@@ -71,8 +77,11 @@ jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
 
 GLOBAL(long)
 jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
-                   long max_bytes_needed, long already_allocated)
+        long max_bytes_needed, long already_allocated)
 {
+  cinfo = 0;
+  min_bytes_needed = 0;
+  already_allocated = 0;
   return max_bytes_needed;
 }
 
@@ -85,8 +94,10 @@ jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
 
 GLOBAL(void)
 jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
-                        long total_bytes_needed)
+       long total_bytes_needed)
 {
+  info = 0;
+  total_bytes_needed = 0;
   ERREXIT(cinfo, JERR_NO_BACKING_STORE);
 }
 
@@ -99,11 +110,13 @@ jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
 GLOBAL(long)
 jpeg_mem_init (j_common_ptr cinfo)
 {
-  return 0;                    /* just set max_memory_to_use to 0 */
+  cinfo = 0;
+  return 0;      /* just set max_memory_to_use to 0 */
 }
 
 GLOBAL(void)
 jpeg_mem_term (j_common_ptr cinfo)
 {
+  cinfo = 0;
   /* no work */
 }
index b2f96aa15d25dd722c55b955bf0e475eb3160c15..2ec9a41ed4c7c5fc81e78485098aaf5d1c9d107a 100644 (file)
@@ -68,9 +68,9 @@
  * table in both directions.
  */
 
-#define ODITHER_SIZE  16       /* dimension of dither matrix */
+#define ODITHER_SIZE  16  /* dimension of dither matrix */
 /* NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break */
-#define ODITHER_CELLS (ODITHER_SIZE*ODITHER_SIZE)      /* # cells in matrix */
+#define ODITHER_CELLS (ODITHER_SIZE*ODITHER_SIZE)  /* # cells in matrix */
 #define ODITHER_MASK  (ODITHER_SIZE-1) /* mask for wrapping around counters */
 
 typedef int ODITHER_MATRIX[ODITHER_SIZE][ODITHER_SIZE];
@@ -105,8 +105,8 @@ static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = {
  * Errors are accumulated into the array fserrors[], at a resolution of
  * 1/16th of a pixel count.  The error at a given pixel is propagated
  * to its not-yet-processed neighbors using the standard F-S fractions,
- *             ...     (here)  7/16
- *             3/16    5/16    1/16
+ *    ...  (here)  7/16
+ *    3/16  5/16  1/16
  * We work left-to-right on even rows, right-to-left on odd rows.
  *
  * We can get away with a single array (holding one row's worth of errors)
@@ -125,43 +125,43 @@ static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = {
  */
 
 #if BITS_IN_JSAMPLE == 8
-typedef INT16 FSERROR;         /* 16 bits should be enough */
-typedef int LOCFSERROR;                /* use 'int' for calculation temps */
+typedef INT16 FSERROR;    /* 16 bits should be enough */
+typedef int LOCFSERROR;    /* use 'int' for calculation temps */
 #else
-typedef INT32 FSERROR;         /* may need more than 16 bits */
-typedef INT32 LOCFSERROR;      /* be sure calculation temps are big enough */
+typedef INT32 FSERROR;    /* may need more than 16 bits */
+typedef INT32 LOCFSERROR;  /* be sure calculation temps are big enough */
 #endif
 
-typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
+typedef FSERROR FAR *FSERRPTR;  /* pointer to error array (in FAR storage!) */
 
 
 /* Private subobject */
 
-#define MAX_Q_COMPS 4          /* max components I can handle */
+#define MAX_Q_COMPS 4    /* max components I can handle */
 
 typedef struct {
   struct jpeg_color_quantizer pub; /* public fields */
 
   /* Initially allocated colormap is saved here */
-  JSAMPARRAY sv_colormap;      /* The color map as a 2-D pixel array */
-  int sv_actual;               /* number of entries in use */
+  JSAMPARRAY sv_colormap;  /* The color map as a 2-D pixel array */
+  int sv_actual;    /* number of entries in use */
 
-  JSAMPARRAY colorindex;       /* Precomputed mapping for speed */
+  JSAMPARRAY colorindex;  /* Precomputed mapping for speed */
   /* colorindex[i][j] = index of color closest to pixel value j in component i,
    * premultiplied as described above.  Since colormap indexes must fit into
    * JSAMPLEs, the entries of this array will too.
    */
-  boolean is_padded;           /* is the colorindex padded for odither? */
+  boolean is_padded;    /* is the colorindex padded for odither? */
 
-  int Ncolors[MAX_Q_COMPS];    /* # of values alloced to each component */
+  int Ncolors[MAX_Q_COMPS];  /* # of values alloced to each component */
 
   /* Variables for ordered dithering */
-  int row_index;               /* cur row's vertical index in dither matrix */
+  int row_index;    /* cur row's vertical index in dither matrix */
   ODITHER_MATRIX_PTR odither[MAX_Q_COMPS]; /* one dither array per component */
 
   /* Variables for Floyd-Steinberg dithering */
   FSERRPTR fserrors[MAX_Q_COMPS]; /* accumulated errors */
-  boolean on_odd_row;          /* flag to remember which row we are on */
+  boolean on_odd_row;    /* flag to remember which row we are on */
 } my_cquantizer;
 
 typedef my_cquantizer * my_cquantize_ptr;
@@ -200,11 +200,11 @@ select_ncolors (j_decompress_ptr cinfo, int Ncolors[])
   iroot = 1;
   do {
     iroot++;
-    temp = iroot;              /* set temp = iroot ** nc */
+    temp = iroot;    /* set temp = iroot ** nc */
     for (i = 1; i < nc; i++)
       temp *= iroot;
   } while (temp <= (long) max_colors); /* repeat till iroot exceeds root */
-  iroot--;                     /* now iroot = floor(root) */
+  iroot--;      /* now iroot = floor(root) */
 
   /* Must have at least 2 color values per component */
   if (iroot < 2)
@@ -228,10 +228,10 @@ select_ncolors (j_decompress_ptr cinfo, int Ncolors[])
       j = (cinfo->out_color_space == JCS_RGB ? RGB_order[i] : i);
       /* calculate new total_colors if Ncolors[j] is incremented */
       temp = total_colors / Ncolors[j];
-      temp *= Ncolors[j]+1;    /* done in long arith to avoid oflo */
+      temp *= Ncolors[j]+1;  /* done in long arith to avoid oflo */
       if (temp > (long) max_colors)
-       break;                  /* won't fit, done with this pass */
-      Ncolors[j]++;            /* OK, apply the increment */
+  break;      /* won't fit, done with this pass */
+      Ncolors[j]++;    /* OK, apply the increment */
       total_colors = (int) temp;
       changed = TRUE;
     }
@@ -246,6 +246,8 @@ output_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
 /* Return j'th output value, where j will range from 0 to maxj */
 /* The output values must fall in 0..MAXJSAMPLE in increasing order */
 {
+  cinfo = 0;
+  ci = 0;
   /* We always provide values 0 and MAXJSAMPLE for each component;
    * any additional values are equally spaced between these limits.
    * (Forcing the upper and lower values to the limits ensures that
@@ -260,6 +262,8 @@ largest_input_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
 /* Return largest input value that should map to j'th output value */
 /* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */
 {
+  cinfo = 0;
+  ci = 0;
   /* Breakpoints are halfway between values returned by output_value */
   return (int) (((INT32) (2*j + 1) * MAXJSAMPLE + maxj) / (2*maxj));
 }
@@ -273,8 +277,8 @@ LOCAL(void)
 create_colormap (j_decompress_ptr cinfo)
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
-  JSAMPARRAY colormap;         /* Created colormap */
-  int total_colors;            /* Number of distinct output colors */
+  JSAMPARRAY colormap;    /* Created colormap */
+  int total_colors;    /* Number of distinct output colors */
   int i,j,k, nci, blksize, blkdist, ptr, val;
 
   /* Select number of colors for each component */
@@ -283,8 +287,8 @@ create_colormap (j_decompress_ptr cinfo)
   /* Report selected color counts */
   if (cinfo->out_color_components == 3)
     TRACEMS4(cinfo, 1, JTRC_QUANT_3_NCOLORS,
-            total_colors, cquantize->Ncolors[0],
-            cquantize->Ncolors[1], cquantize->Ncolors[2]);
+       total_colors, cquantize->Ncolors[0],
+       cquantize->Ncolors[1], cquantize->Ncolors[2]);
   else
     TRACEMS1(cinfo, 1, JTRC_QUANT_NCOLORS, total_colors);
 
@@ -309,12 +313,12 @@ create_colormap (j_decompress_ptr cinfo)
       val = output_value(cinfo, i, j, nci-1);
       /* Fill in all colormap entries that have this value of this component */
       for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) {
-       /* fill in blksize entries beginning at ptr */
-       for (k = 0; k < blksize; k++)
-         colormap[i][ptr+k] = (JSAMPLE) val;
+  /* fill in blksize entries beginning at ptr */
+  for (k = 0; k < blksize; k++)
+    colormap[i][ptr+k] = (JSAMPLE) val;
       }
     }
-    blkdist = blksize;         /* blksize of this color is blkdist of next */
+    blkdist = blksize;    /* blksize of this color is blkdist of next */
   }
 
   /* Save the colormap in private storage,
@@ -372,16 +376,16 @@ create_colorindex (j_decompress_ptr cinfo)
     val = 0;
     k = largest_input_value(cinfo, i, 0, nci-1);
     for (j = 0; j <= MAXJSAMPLE; j++) {
-      while (j > k)            /* advance val if past boundary */
-       k = largest_input_value(cinfo, i, ++val, nci-1);
+      while (j > k)    /* advance val if past boundary */
+  k = largest_input_value(cinfo, i, ++val, nci-1);
       /* premultiply so that no multiplication needed in main processing */
       indexptr[j] = (JSAMPLE) (val * blksize);
     }
     /* Pad at both ends if necessary */
     if (pad)
       for (j = 1; j <= MAXJSAMPLE; j++) {
-       indexptr[-j] = indexptr[0];
-       indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE];
+  indexptr[-j] = indexptr[0];
+  indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE];
       }
   }
 }
@@ -401,7 +405,7 @@ make_odither_array (j_decompress_ptr cinfo, int ncolors)
 
   odither = (ODITHER_MATRIX_PTR)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(ODITHER_MATRIX));
+        SIZEOF(ODITHER_MATRIX));
   /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1).
    * Hence the dither value for the matrix cell with fill order f
    * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1).
@@ -411,7 +415,7 @@ make_odither_array (j_decompress_ptr cinfo, int ncolors)
   for (j = 0; j < ODITHER_SIZE; j++) {
     for (k = 0; k < ODITHER_SIZE; k++) {
       num = ((INT32) (ODITHER_CELLS-1 - 2*((int)base_dither_matrix[j][k])))
-           * MAXJSAMPLE;
+      * MAXJSAMPLE;
       /* Ensure round towards zero despite C's lack of consistency
        * about rounding negative values in integer division...
        */
@@ -437,14 +441,14 @@ create_odither_tables (j_decompress_ptr cinfo)
 
   for (i = 0; i < cinfo->out_color_components; i++) {
     nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
-    odither = NULL;            /* search for matching prior component */
+    odither = NULL;    /* search for matching prior component */
     for (j = 0; j < i; j++) {
       if (nci == cquantize->Ncolors[j]) {
-       odither = cquantize->odither[j];
-       break;
+  odither = cquantize->odither[j];
+  break;
       }
     }
-    if (odither == NULL)       /* need a new table? */
+    if (odither == NULL)  /* need a new table? */
       odither = make_odither_array(cinfo, nci);
     cquantize->odither[i] = odither;
   }
@@ -457,7 +461,7 @@ create_odither_tables (j_decompress_ptr cinfo)
 
 METHODDEF(void)
 color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-               JSAMPARRAY output_buf, int num_rows)
+    JSAMPARRAY output_buf, int num_rows)
 /* General case, no dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
@@ -475,7 +479,7 @@ color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
     for (col = width; col > 0; col--) {
       pixcode = 0;
       for (ci = 0; ci < nc; ci++) {
-       pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]);
+  pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]);
       }
       *ptrout++ = (JSAMPLE) pixcode;
     }
@@ -485,7 +489,7 @@ color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
 METHODDEF(void)
 color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                JSAMPARRAY output_buf, int num_rows)
+     JSAMPARRAY output_buf, int num_rows)
 /* Fast path for out_color_components==3, no dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
@@ -513,15 +517,15 @@ color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
 METHODDEF(void)
 quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                    JSAMPARRAY output_buf, int num_rows)
+         JSAMPARRAY output_buf, int num_rows)
 /* General case, with ordered dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
   register JSAMPROW input_ptr;
   register JSAMPROW output_ptr;
   JSAMPROW colorindex_ci;
-  int * dither;                        /* points to active row of dither matrix */
-  int row_index, col_index;    /* current indexes into dither matrix */
+  int * dither;      /* points to active row of dither matrix */
+  int row_index, col_index;  /* current indexes into dither matrix */
   int nc = cinfo->out_color_components;
   int ci;
   int row;
@@ -531,7 +535,7 @@ quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
   for (row = 0; row < num_rows; row++) {
     /* Initialize output values to 0 so can process components separately */
     jzero_far((void FAR *) output_buf[row],
-             (size_t) (width * SIZEOF(JSAMPLE)));
+        (size_t) (width * SIZEOF(JSAMPLE)));
     row_index = cquantize->row_index;
     for (ci = 0; ci < nc; ci++) {
       input_ptr = input_buf[row] + ci;
@@ -541,17 +545,17 @@ quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
       col_index = 0;
 
       for (col = width; col > 0; col--) {
-       /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE,
-        * select output value, accumulate into output code for this pixel.
-        * Range-limiting need not be done explicitly, as we have extended
-        * the colorindex table to produce the right answers for out-of-range
-        * inputs.  The maximum dither is +- MAXJSAMPLE; this sets the
-        * required amount of padding.
-        */
-       *output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]];
-       input_ptr += nc;
-       output_ptr++;
-       col_index = (col_index + 1) & ODITHER_MASK;
+  /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE,
+   * select output value, accumulate into output code for this pixel.
+   * Range-limiting need not be done explicitly, as we have extended
+   * the colorindex table to produce the right answers for out-of-range
+   * inputs.  The maximum dither is +- MAXJSAMPLE; this sets the
+   * required amount of padding.
+   */
+  *output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]];
+  input_ptr += nc;
+  output_ptr++;
+  col_index = (col_index + 1) & ODITHER_MASK;
       }
     }
     /* Advance row index for next row */
@@ -563,7 +567,7 @@ quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
 METHODDEF(void)
 quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                     JSAMPARRAY output_buf, int num_rows)
+          JSAMPARRAY output_buf, int num_rows)
 /* Fast path for out_color_components==3, with ordered dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
@@ -573,10 +577,10 @@ quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
   JSAMPROW colorindex0 = cquantize->colorindex[0];
   JSAMPROW colorindex1 = cquantize->colorindex[1];
   JSAMPROW colorindex2 = cquantize->colorindex[2];
-  int * dither0;               /* points to active row of dither matrix */
+  int * dither0;    /* points to active row of dither matrix */
   int * dither1;
   int * dither2;
-  int row_index, col_index;    /* current indexes into dither matrix */
+  int row_index, col_index;  /* current indexes into dither matrix */
   int row;
   JDIMENSION col;
   JDIMENSION width = cinfo->output_width;
@@ -592,11 +596,11 @@ quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
     for (col = width; col > 0; col--) {
       pixcode  = GETJSAMPLE(colorindex0[GETJSAMPLE(*input_ptr++) +
-                                       dither0[col_index]]);
+          dither0[col_index]]);
       pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*input_ptr++) +
-                                       dither1[col_index]]);
+          dither1[col_index]]);
       pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*input_ptr++) +
-                                       dither2[col_index]]);
+          dither2[col_index]]);
       *output_ptr++ = (JSAMPLE) pixcode;
       col_index = (col_index + 1) & ODITHER_MASK;
     }
@@ -608,24 +612,24 @@ quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
 METHODDEF(void)
 quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                   JSAMPARRAY output_buf, int num_rows)
+        JSAMPARRAY output_buf, int num_rows)
 /* General case, with Floyd-Steinberg dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
-  register LOCFSERROR cur;     /* current error or pixel value */
-  LOCFSERROR belowerr;         /* error for pixel below cur */
-  LOCFSERROR bpreverr;         /* error for below/prev col */
-  LOCFSERROR bnexterr;         /* error for below/next col */
+  register LOCFSERROR cur;  /* current error or pixel value */
+  LOCFSERROR belowerr;    /* error for pixel below cur */
+  LOCFSERROR bpreverr;    /* error for below/prev col */
+  LOCFSERROR bnexterr;    /* error for below/next col */
   LOCFSERROR delta;
-  register FSERRPTR errorptr;  /* => fserrors[] at column before current */
+  register FSERRPTR errorptr;  /* => fserrors[] at column before current */
   register JSAMPROW input_ptr;
   register JSAMPROW output_ptr;
   JSAMPROW colorindex_ci;
   JSAMPROW colormap_ci;
   int pixcode;
   int nc = cinfo->out_color_components;
-  int dir;                     /* 1 for left-to-right, -1 for right-to-left */
-  int dirnc;                   /* dir * nc */
+  int dir;      /* 1 for left-to-right, -1 for right-to-left */
+  int dirnc;      /* dir * nc */
   int ci;
   int row;
   JDIMENSION col;
@@ -636,22 +640,22 @@ quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
   for (row = 0; row < num_rows; row++) {
     /* Initialize output values to 0 so can process components separately */
     jzero_far((void FAR *) output_buf[row],
-             (size_t) (width * SIZEOF(JSAMPLE)));
+        (size_t) (width * SIZEOF(JSAMPLE)));
     for (ci = 0; ci < nc; ci++) {
       input_ptr = input_buf[row] + ci;
       output_ptr = output_buf[row];
       if (cquantize->on_odd_row) {
-       /* work right to left in this row */
-       input_ptr += (width-1) * nc; /* so point to rightmost pixel */
-       output_ptr += width-1;
-       dir = -1;
-       dirnc = -nc;
-       errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */
+  /* work right to left in this row */
+  input_ptr += (width-1) * nc; /* so point to rightmost pixel */
+  output_ptr += width-1;
+  dir = -1;
+  dirnc = -nc;
+  errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */
       } else {
-       /* work left to right in this row */
-       dir = 1;
-       dirnc = nc;
-       errorptr = cquantize->fserrors[ci]; /* => entry before first column */
+  /* work left to right in this row */
+  dir = 1;
+  dirnc = nc;
+  errorptr = cquantize->fserrors[ci]; /* => entry before first column */
       }
       colorindex_ci = cquantize->colorindex[ci];
       colormap_ci = cquantize->sv_colormap[ci];
@@ -661,47 +665,47 @@ quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
       belowerr = bpreverr = 0;
 
       for (col = width; col > 0; col--) {
-       /* cur holds the error propagated from the previous pixel on the
-        * current line.  Add the error propagated from the previous line
-        * to form the complete error correction term for this pixel, and
-        * round the error term (which is expressed * 16) to an integer.
-        * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
-        * for either sign of the error value.
-        * Note: errorptr points to *previous* column's array entry.
-        */
-       cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4);
-       /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
-        * The maximum error is +- MAXJSAMPLE; this sets the required size
-        * of the range_limit array.
-        */
-       cur += GETJSAMPLE(*input_ptr);
-       cur = GETJSAMPLE(range_limit[cur]);
-       /* Select output value, accumulate into output code for this pixel */
-       pixcode = GETJSAMPLE(colorindex_ci[cur]);
-       *output_ptr += (JSAMPLE) pixcode;
-       /* Compute actual representation error at this pixel */
-       /* Note: we can do this even though we don't have the final */
-       /* pixel code, because the colormap is orthogonal. */
-       cur -= GETJSAMPLE(colormap_ci[pixcode]);
-       /* Compute error fractions to be propagated to adjacent pixels.
-        * Add these into the running sums, and simultaneously shift the
-        * next-line error sums left by 1 column.
-        */
-       bnexterr = cur;
-       delta = cur * 2;
-       cur += delta;           /* form error * 3 */
-       errorptr[0] = (FSERROR) (bpreverr + cur);
-       cur += delta;           /* form error * 5 */
-       bpreverr = belowerr + cur;
-       belowerr = bnexterr;
-       cur += delta;           /* form error * 7 */
-       /* At this point cur contains the 7/16 error value to be propagated
-        * to the next pixel on the current line, and all the errors for the
-        * next line have been shifted over. We are therefore ready to move on.
-        */
-       input_ptr += dirnc;     /* advance input ptr to next column */
-       output_ptr += dir;      /* advance output ptr to next column */
-       errorptr += dir;        /* advance errorptr to current column */
+  /* cur holds the error propagated from the previous pixel on the
+   * current line.  Add the error propagated from the previous line
+   * to form the complete error correction term for this pixel, and
+   * round the error term (which is expressed * 16) to an integer.
+   * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+   * for either sign of the error value.
+   * Note: errorptr points to *previous* column's array entry.
+   */
+  cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4);
+  /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+   * The maximum error is +- MAXJSAMPLE; this sets the required size
+   * of the range_limit array.
+   */
+  cur += GETJSAMPLE(*input_ptr);
+  cur = GETJSAMPLE(range_limit[cur]);
+  /* Select output value, accumulate into output code for this pixel */
+  pixcode = GETJSAMPLE(colorindex_ci[cur]);
+  *output_ptr += (JSAMPLE) pixcode;
+  /* Compute actual representation error at this pixel */
+  /* Note: we can do this even though we don't have the final */
+  /* pixel code, because the colormap is orthogonal. */
+  cur -= GETJSAMPLE(colormap_ci[pixcode]);
+  /* Compute error fractions to be propagated to adjacent pixels.
+   * Add these into the running sums, and simultaneously shift the
+   * next-line error sums left by 1 column.
+   */
+  bnexterr = cur;
+  delta = cur * 2;
+  cur += delta;    /* form error * 3 */
+  errorptr[0] = (FSERROR) (bpreverr + cur);
+  cur += delta;    /* form error * 5 */
+  bpreverr = belowerr + cur;
+  belowerr = bnexterr;
+  cur += delta;    /* form error * 7 */
+  /* At this point cur contains the 7/16 error value to be propagated
+   * to the next pixel on the current line, and all the errors for the
+   * next line have been shifted over. We are therefore ready to move on.
+   */
+  input_ptr += dirnc;  /* advance input ptr to next column */
+  output_ptr += dir;  /* advance output ptr to next column */
+  errorptr += dir;  /* advance errorptr to current column */
       }
       /* Post-loop cleanup: we must unload the final error value into the
        * final fserrors[] entry.  Note we need not unload belowerr because
@@ -744,6 +748,7 @@ start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
   size_t arraysize;
   int i;
 
+  is_pre_scan = 0;
   /* Install my colormap. */
   cinfo->colormap = cquantize->sv_colormap;
   cinfo->actual_number_of_colors = cquantize->sv_actual;
@@ -761,7 +766,7 @@ start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
       cquantize->pub.color_quantize = quantize3_ord_dither;
     else
       cquantize->pub.color_quantize = quantize_ord_dither;
-    cquantize->row_index = 0;  /* initialize state for ordered dither */
+    cquantize->row_index = 0;  /* initialize state for ordered dither */
     /* If user changed to ordered dither from another mode,
      * we must recreate the color index table with padding.
      * This will cost extra space, but probably isn't very likely.
@@ -797,6 +802,7 @@ start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
 METHODDEF(void)
 finish_pass_1_quant (j_decompress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work in 1-pass case */
 }
 
@@ -824,13 +830,13 @@ jinit_1pass_quantizer (j_decompress_ptr cinfo)
 
   cquantize = (my_cquantize_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_cquantizer));
+        SIZEOF(my_cquantizer));
   cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
   cquantize->pub.start_pass = start_pass_1_quant;
   cquantize->pub.finish_pass = finish_pass_1_quant;
   cquantize->pub.new_color_map = new_color_map_1_quant;
   cquantize->fserrors[0] = NULL; /* Flag FS workspace not allocated */
-  cquantize->odither[0] = NULL;        /* Also flag odither arrays not allocated */
+  cquantize->odither[0] = NULL;  /* Also flag odither arrays not allocated */
 
   /* Make sure my internal arrays won't overflow */
   if (cinfo->out_color_components > MAX_Q_COMPS)
index af601e334b244f0a356e78826463b71e0848fe57..9355f01167b6346ee6c1cf30f67068e764e4c025 100644 (file)
@@ -70,9 +70,9 @@
  * probably need to change these scale factors.
  */
 
-#define R_SCALE 2              /* scale R distances by this much */
-#define G_SCALE 3              /* scale G distances by this much */
-#define B_SCALE 1              /* and B by this much */
+#define R_SCALE 2    /* scale R distances by this much */
+#define G_SCALE 3    /* scale G distances by this much */
+#define B_SCALE 1    /* and B by this much */
 
 /* Relabel R/G/B as components 0/1/2, respecting the RGB ordering defined
  * in jmorecfg.h.  As the code stands, it will do the right thing for R,G,B
 /* These will do the right thing for either R,G,B or B,G,R color order,
  * but you may not like the results for other color orders.
  */
-#define HIST_C0_BITS  5                /* bits of precision in R/B histogram */
-#define HIST_C1_BITS  6                /* bits of precision in G histogram */
-#define HIST_C2_BITS  5                /* bits of precision in B/R histogram */
+#define HIST_C0_BITS  5    /* bits of precision in R/B histogram */
+#define HIST_C1_BITS  6    /* bits of precision in G histogram */
+#define HIST_C2_BITS  5    /* bits of precision in B/R histogram */
 
 /* Number of elements along histogram axes. */
 #define HIST_C0_ELEMS  (1<<HIST_C0_BITS)
 #define C2_SHIFT  (BITS_IN_JSAMPLE-HIST_C2_BITS)
 
 
-typedef UINT16 histcell;       /* histogram cell; prefer an unsigned type */
+typedef UINT16 histcell;  /* histogram cell; prefer an unsigned type */
 
-typedef histcell FAR * histptr;        /* for pointers to histogram cells */
+typedef histcell FAR * histptr;  /* for pointers to histogram cells */
 
 typedef histcell hist1d[HIST_C2_ELEMS]; /* typedefs for the array */
-typedef hist1d FAR * hist2d;   /* type for the 2nd-level pointers */
-typedef hist2d * hist3d;       /* type for top-level pointer */
+typedef hist1d FAR * hist2d;  /* type for the 2nd-level pointers */
+typedef hist2d * hist3d;  /* type for top-level pointer */
 
 
 /* Declarations for Floyd-Steinberg dithering.
@@ -158,8 +158,8 @@ typedef hist2d * hist3d;    /* type for top-level pointer */
  * Errors are accumulated into the array fserrors[], at a resolution of
  * 1/16th of a pixel count.  The error at a given pixel is propagated
  * to its not-yet-processed neighbors using the standard F-S fractions,
- *             ...     (here)  7/16
- *             3/16    5/16    1/16
+ *    ...  (here)  7/16
+ *    3/16  5/16  1/16
  * We work left-to-right on even rows, right-to-left on odd rows.
  *
  * We can get away with a single array (holding one row's worth of errors)
@@ -178,14 +178,14 @@ typedef hist2d * hist3d;  /* type for top-level pointer */
  */
 
 #if BITS_IN_JSAMPLE == 8
-typedef INT16 FSERROR;         /* 16 bits should be enough */
-typedef int LOCFSERROR;                /* use 'int' for calculation temps */
+typedef INT16 FSERROR;    /* 16 bits should be enough */
+typedef int LOCFSERROR;    /* use 'int' for calculation temps */
 #else
-typedef INT32 FSERROR;         /* may need more than 16 bits */
-typedef INT32 LOCFSERROR;      /* be sure calculation temps are big enough */
+typedef INT32 FSERROR;    /* may need more than 16 bits */
+typedef INT32 LOCFSERROR;  /* be sure calculation temps are big enough */
 #endif
 
-typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
+typedef FSERROR FAR *FSERRPTR;  /* pointer to error array (in FAR storage!) */
 
 
 /* Private subobject */
@@ -194,18 +194,18 @@ typedef struct {
   struct jpeg_color_quantizer pub; /* public fields */
 
   /* Space for the eventually created colormap is stashed here */
-  JSAMPARRAY sv_colormap;      /* colormap allocated at init time */
-  int desired;                 /* desired # of colors = size of colormap */
+  JSAMPARRAY sv_colormap;  /* colormap allocated at init time */
+  int desired;      /* desired # of colors = size of colormap */
 
   /* Variables for accumulating image statistics */
-  hist3d histogram;            /* pointer to the histogram */
+  hist3d histogram;    /* pointer to the histogram */
 
-  boolean needs_zeroed;                /* TRUE if next pass must zero histogram */
+  boolean needs_zeroed;    /* TRUE if next pass must zero histogram */
 
   /* Variables for Floyd-Steinberg dithering */
-  FSERRPTR fserrors;           /* accumulated errors */
-  boolean on_odd_row;          /* flag to remember which row we are on */
-  int * error_limiter;         /* table for clamping the applied error */
+  FSERRPTR fserrors;    /* accumulated errors */
+  boolean on_odd_row;    /* flag to remember which row we are on */
+  int * error_limiter;    /* table for clamping the applied error */
 } my_cquantizer;
 
 typedef my_cquantizer * my_cquantize_ptr;
@@ -222,7 +222,7 @@ typedef my_cquantizer * my_cquantize_ptr;
 
 METHODDEF(void)
 prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                 JSAMPARRAY output_buf, int num_rows)
+      JSAMPARRAY output_buf, int num_rows)
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
   register JSAMPROW ptr;
@@ -232,16 +232,17 @@ prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
   JDIMENSION col;
   JDIMENSION width = cinfo->output_width;
 
+  output_buf = 0;
   for (row = 0; row < num_rows; row++) {
     ptr = input_buf[row];
     for (col = width; col > 0; col--) {
       /* get pixel value and index into the histogram */
       histp = & histogram[GETJSAMPLE(ptr[0]) >> C0_SHIFT]
-                        [GETJSAMPLE(ptr[1]) >> C1_SHIFT]
-                        [GETJSAMPLE(ptr[2]) >> C2_SHIFT];
+       [GETJSAMPLE(ptr[1]) >> C1_SHIFT]
+       [GETJSAMPLE(ptr[2]) >> C2_SHIFT];
       /* increment, check for overflow and undo increment if so. */
       if (++(*histp) <= 0)
-       (*histp)--;
+  (*histp)--;
       ptr += 3;
     }
   }
@@ -329,67 +330,67 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)
   if (c0max > c0min)
     for (c0 = c0min; c0 <= c0max; c0++)
       for (c1 = c1min; c1 <= c1max; c1++) {
-       histp = & histogram[c0][c1][c2min];
-       for (c2 = c2min; c2 <= c2max; c2++)
-         if (*histp++ != 0) {
-           boxp->c0min = c0min = c0;
-           goto have_c0min;
-         }
+  histp = & histogram[c0][c1][c2min];
+  for (c2 = c2min; c2 <= c2max; c2++)
+    if (*histp++ != 0) {
+      boxp->c0min = c0min = c0;
+      goto have_c0min;
+    }
       }
  have_c0min:
   if (c0max > c0min)
     for (c0 = c0max; c0 >= c0min; c0--)
       for (c1 = c1min; c1 <= c1max; c1++) {
-       histp = & histogram[c0][c1][c2min];
-       for (c2 = c2min; c2 <= c2max; c2++)
-         if (*histp++ != 0) {
-           boxp->c0max = c0max = c0;
-           goto have_c0max;
-         }
+  histp = & histogram[c0][c1][c2min];
+  for (c2 = c2min; c2 <= c2max; c2++)
+    if (*histp++ != 0) {
+      boxp->c0max = c0max = c0;
+      goto have_c0max;
+    }
       }
  have_c0max:
   if (c1max > c1min)
     for (c1 = c1min; c1 <= c1max; c1++)
       for (c0 = c0min; c0 <= c0max; c0++) {
-       histp = & histogram[c0][c1][c2min];
-       for (c2 = c2min; c2 <= c2max; c2++)
-         if (*histp++ != 0) {
-           boxp->c1min = c1min = c1;
-           goto have_c1min;
-         }
+  histp = & histogram[c0][c1][c2min];
+  for (c2 = c2min; c2 <= c2max; c2++)
+    if (*histp++ != 0) {
+      boxp->c1min = c1min = c1;
+      goto have_c1min;
+    }
       }
  have_c1min:
   if (c1max > c1min)
     for (c1 = c1max; c1 >= c1min; c1--)
       for (c0 = c0min; c0 <= c0max; c0++) {
-       histp = & histogram[c0][c1][c2min];
-       for (c2 = c2min; c2 <= c2max; c2++)
-         if (*histp++ != 0) {
-           boxp->c1max = c1max = c1;
-           goto have_c1max;
-         }
+  histp = & histogram[c0][c1][c2min];
+  for (c2 = c2min; c2 <= c2max; c2++)
+    if (*histp++ != 0) {
+      boxp->c1max = c1max = c1;
+      goto have_c1max;
+    }
       }
  have_c1max:
   if (c2max > c2min)
     for (c2 = c2min; c2 <= c2max; c2++)
       for (c0 = c0min; c0 <= c0max; c0++) {
-       histp = & histogram[c0][c1min][c2];
-       for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
-         if (*histp != 0) {
-           boxp->c2min = c2min = c2;
-           goto have_c2min;
-         }
+  histp = & histogram[c0][c1min][c2];
+  for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+    if (*histp != 0) {
+      boxp->c2min = c2min = c2;
+      goto have_c2min;
+    }
       }
  have_c2min:
   if (c2max > c2min)
     for (c2 = c2max; c2 >= c2min; c2--)
       for (c0 = c0min; c0 <= c0max; c0++) {
-       histp = & histogram[c0][c1min][c2];
-       for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
-         if (*histp != 0) {
-           boxp->c2max = c2max = c2;
-           goto have_c2max;
-         }
+  histp = & histogram[c0][c1min][c2];
+  for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+    if (*histp != 0) {
+      boxp->c2max = c2max = c2;
+      goto have_c2max;
+    }
       }
  have_c2max:
 
@@ -412,9 +413,9 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)
     for (c1 = c1min; c1 <= c1max; c1++) {
       histp = & histogram[c0][c1][c2min];
       for (c2 = c2min; c2 <= c2max; c2++, histp++)
-       if (*histp != 0) {
-         ccount++;
-       }
+  if (*histp != 0) {
+    ccount++;
+  }
     }
   boxp->colorcount = ccount;
 }
@@ -422,7 +423,7 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)
 
 LOCAL(int)
 median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes,
-           int desired_colors)
+      int desired_colors)
 /* Repeatedly select and split the largest box until we have enough boxes */
 {
   int n,lb;
@@ -438,9 +439,9 @@ median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes,
     } else {
       b1 = find_biggest_volume(boxlist, numboxes);
     }
-    if (b1 == NULL)            /* no splittable boxes left! */
+    if (b1 == NULL)    /* no splittable boxes left! */
       break;
-    b2 = &boxlist[numboxes];   /* where new box will go */
+    b2 = &boxlist[numboxes];  /* where new box will go */
     /* Copy the color bounds to the new box. */
     b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max;
     b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min;
@@ -520,12 +521,12 @@ compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor)
     for (c1 = c1min; c1 <= c1max; c1++) {
       histp = & histogram[c0][c1][c2min];
       for (c2 = c2min; c2 <= c2max; c2++) {
-       if ((count = *histp++) != 0) {
-         total += count;
-         c0total += ((c0 << C0_SHIFT) + ((1<<C0_SHIFT)>>1)) * count;
-         c1total += ((c1 << C1_SHIFT) + ((1<<C1_SHIFT)>>1)) * count;
-         c2total += ((c2 << C2_SHIFT) + ((1<<C2_SHIFT)>>1)) * count;
-       }
+  if ((count = *histp++) != 0) {
+    total += count;
+    c0total += ((c0 << C0_SHIFT) + ((1<<C0_SHIFT)>>1)) * count;
+    c1total += ((c1 << C1_SHIFT) + ((1<<C1_SHIFT)>>1)) * count;
+    c2total += ((c2 << C2_SHIFT) + ((1<<C2_SHIFT)>>1)) * count;
+  }
       }
     }
   
@@ -644,7 +645,7 @@ select_colors (j_decompress_ptr cinfo, int desired_colors)
 
 LOCAL(int)
 find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
-                   JSAMPLE colorlist[])
+        JSAMPLE colorlist[])
 /* Locate the colormap entries close enough to an update box to be candidates
  * for the nearest entry to some cell(s) in the update box.  The update box
  * is specified by the center coordinates of its first cell.  The number of
@@ -659,7 +660,7 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
   int centerc0, centerc1, centerc2;
   int i, x, ncolors;
   INT32 minmaxdist, min_dist, max_dist, tdist;
-  INT32 mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */
+  INT32 mindist[MAXNUMCOLORS];  /* min distance to colormap entry i */
 
   /* Compute true coordinates of update box's upper corner and center.
    * Actually we compute the coordinates of the center of the upper-corner
@@ -701,11 +702,11 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
       /* within cell range so no contribution to min_dist */
       min_dist = 0;
       if (x <= centerc0) {
-       tdist = (x - maxc0) * C0_SCALE;
-       max_dist = tdist*tdist;
+  tdist = (x - maxc0) * C0_SCALE;
+  max_dist = tdist*tdist;
       } else {
-       tdist = (x - minc0) * C0_SCALE;
-       max_dist = tdist*tdist;
+  tdist = (x - minc0) * C0_SCALE;
+  max_dist = tdist*tdist;
       }
     }
 
@@ -723,11 +724,11 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
     } else {
       /* within cell range so no contribution to min_dist */
       if (x <= centerc1) {
-       tdist = (x - maxc1) * C1_SCALE;
-       max_dist += tdist*tdist;
+  tdist = (x - maxc1) * C1_SCALE;
+  max_dist += tdist*tdist;
       } else {
-       tdist = (x - minc1) * C1_SCALE;
-       max_dist += tdist*tdist;
+  tdist = (x - minc1) * C1_SCALE;
+  max_dist += tdist*tdist;
       }
     }
 
@@ -745,15 +746,15 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
     } else {
       /* within cell range so no contribution to min_dist */
       if (x <= centerc2) {
-       tdist = (x - maxc2) * C2_SCALE;
-       max_dist += tdist*tdist;
+  tdist = (x - maxc2) * C2_SCALE;
+  max_dist += tdist*tdist;
       } else {
-       tdist = (x - minc2) * C2_SCALE;
-       max_dist += tdist*tdist;
+  tdist = (x - minc2) * C2_SCALE;
+  max_dist += tdist*tdist;
       }
     }
 
-    mindist[i] = min_dist;     /* save away the results */
+    mindist[i] = min_dist;  /* save away the results */
     if (max_dist < minmaxdist)
       minmaxdist = max_dist;
   }
@@ -773,7 +774,7 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
 
 LOCAL(void)
 find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
-                 int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])
+      int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])
 /* Find the closest colormap entry for each cell in the update box,
  * given the list of candidate colors prepared by find_nearby_colors.
  * Return the indexes of the closest entries in the bestcolor[] array.
@@ -783,13 +784,13 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
 {
   int ic0, ic1, ic2;
   int i, icolor;
-  register INT32 * bptr;       /* pointer into bestdist[] array */
-  JSAMPLE * cptr;              /* pointer into bestcolor[] array */
-  INT32 dist0, dist1;          /* initial distance values */
-  register INT32 dist2;                /* current distance in inner loop */
-  INT32 xx0, xx1;              /* distance increments */
+  register INT32 * bptr;  /* pointer into bestdist[] array */
+  JSAMPLE * cptr;    /* pointer into bestcolor[] array */
+  INT32 dist0, dist1;    /* initial distance values */
+  register INT32 dist2;    /* current distance in inner loop */
+  INT32 xx0, xx1;    /* distance increments */
   register INT32 xx2;
-  INT32 inc0, inc1, inc2;      /* initial values for increments */
+  INT32 inc0, inc1, inc2;  /* initial values for increments */
   /* This array holds the distance to the nearest-so-far color for each cell */
   INT32 bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
 
@@ -829,20 +830,20 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
       dist1 = dist0;
       xx1 = inc1;
       for (ic1 = BOX_C1_ELEMS-1; ic1 >= 0; ic1--) {
-       dist2 = dist1;
-       xx2 = inc2;
-       for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) {
-         if (dist2 < *bptr) {
-           *bptr = dist2;
-           *cptr = (JSAMPLE) icolor;
-         }
-         dist2 += xx2;
-         xx2 += 2 * STEP_C2 * STEP_C2;
-         bptr++;
-         cptr++;
-       }
-       dist1 += xx1;
-       xx1 += 2 * STEP_C1 * STEP_C1;
+  dist2 = dist1;
+  xx2 = inc2;
+  for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) {
+    if (dist2 < *bptr) {
+      *bptr = dist2;
+      *cptr = (JSAMPLE) icolor;
+    }
+    dist2 += xx2;
+    xx2 += 2 * STEP_C2 * STEP_C2;
+    bptr++;
+    cptr++;
+  }
+  dist1 += xx1;
+  xx1 += 2 * STEP_C1 * STEP_C1;
       }
       dist0 += xx0;
       xx0 += 2 * STEP_C0 * STEP_C0;
@@ -859,13 +860,13 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
   hist3d histogram = cquantize->histogram;
-  int minc0, minc1, minc2;     /* lower left corner of update box */
+  int minc0, minc1, minc2;  /* lower left corner of update box */
   int ic0, ic1, ic2;
-  register JSAMPLE * cptr;     /* pointer into bestcolor[] array */
-  register histptr cachep;     /* pointer into main cache array */
+  register JSAMPLE * cptr;  /* pointer into bestcolor[] array */
+  register histptr cachep;  /* pointer into main cache array */
   /* This array lists the candidate colormap indexes. */
   JSAMPLE colorlist[MAXNUMCOLORS];
-  int numcolors;               /* number of candidate colors */
+  int numcolors;    /* number of candidate colors */
   /* This array holds the actually closest colormap index for each cell. */
   JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
 
@@ -889,10 +890,10 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
 
   /* Determine the actually nearest colors. */
   find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist,
-                  bestcolor);
+       bestcolor);
 
   /* Save the best color numbers (plus 1) in the main cache array */
-  c0 <<= BOX_C0_LOG;           /* convert ID back to base cell indexes */
+  c0 <<= BOX_C0_LOG;    /* convert ID back to base cell indexes */
   c1 <<= BOX_C1_LOG;
   c2 <<= BOX_C2_LOG;
   cptr = bestcolor;
@@ -900,7 +901,7 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
     for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) {
       cachep = & histogram[c0+ic0][c1+ic1][c2];
       for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) {
-       *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1);
+  *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1);
       }
     }
   }
@@ -913,7 +914,7 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
 
 METHODDEF(void)
 pass2_no_dither (j_decompress_ptr cinfo,
-                JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
+     JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
 /* This version performs no dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
@@ -937,7 +938,7 @@ pass2_no_dither (j_decompress_ptr cinfo,
       /* If we have not seen this color before, find nearest colormap entry */
       /* and update the cache */
       if (*cachep == 0)
-       fill_inverse_cmap(cinfo, c0,c1,c2);
+  fill_inverse_cmap(cinfo, c0,c1,c2);
       /* Now emit the colormap index for this cell */
       *outptr++ = (JSAMPLE) (*cachep - 1);
     }
@@ -947,20 +948,20 @@ pass2_no_dither (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 pass2_fs_dither (j_decompress_ptr cinfo,
-                JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
+     JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
 /* This version performs Floyd-Steinberg dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
   hist3d histogram = cquantize->histogram;
-  register LOCFSERROR cur0, cur1, cur2;        /* current error or pixel value */
+  register LOCFSERROR cur0, cur1, cur2;  /* current error or pixel value */
   LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */
   LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */
-  register FSERRPTR errorptr;  /* => fserrors[] at column before current */
-  JSAMPROW inptr;              /* => current input pixel */
-  JSAMPROW outptr;             /* => current output pixel */
+  register FSERRPTR errorptr;  /* => fserrors[] at column before current */
+  JSAMPROW inptr;    /* => current input pixel */
+  JSAMPROW outptr;    /* => current output pixel */
   histptr cachep;
-  int dir;                     /* +1 or -1 depending on direction */
-  int dir3;                    /* 3*dir, for advancing inptr & errorptr */
+  int dir;      /* +1 or -1 depending on direction */
+  int dir3;      /* 3*dir, for advancing inptr & errorptr */
   int row;
   JDIMENSION col;
   JDIMENSION width = cinfo->output_width;
@@ -976,7 +977,7 @@ pass2_fs_dither (j_decompress_ptr cinfo,
     outptr = output_buf[row];
     if (cquantize->on_odd_row) {
       /* work right to left in this row */
-      inptr += (width-1) * 3;  /* so point to rightmost pixel */
+      inptr += (width-1) * 3;  /* so point to rightmost pixel */
       outptr += width-1;
       dir = -1;
       dir3 = -3;
@@ -1028,14 +1029,14 @@ pass2_fs_dither (j_decompress_ptr cinfo,
       /* If we have not seen this color before, find nearest colormap */
       /* entry and update the cache */
       if (*cachep == 0)
-       fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT);
+  fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT);
       /* Now emit the colormap index for this cell */
       { register int pixcode = *cachep - 1;
-       *outptr = (JSAMPLE) pixcode;
-       /* Compute representation error for this pixel */
-       cur0 -= GETJSAMPLE(colormap0[pixcode]);
-       cur1 -= GETJSAMPLE(colormap1[pixcode]);
-       cur2 -= GETJSAMPLE(colormap2[pixcode]);
+  *outptr = (JSAMPLE) pixcode;
+  /* Compute representation error for this pixel */
+  cur0 -= GETJSAMPLE(colormap0[pixcode]);
+  cur1 -= GETJSAMPLE(colormap1[pixcode]);
+  cur2 -= GETJSAMPLE(colormap2[pixcode]);
       }
       /* Compute error fractions to be propagated to adjacent pixels.
        * Add these into the running sums, and simultaneously shift the
@@ -1043,38 +1044,38 @@ pass2_fs_dither (j_decompress_ptr cinfo,
        */
       { register LOCFSERROR bnexterr, delta;
 
-       bnexterr = cur0;        /* Process component 0 */
-       delta = cur0 * 2;
-       cur0 += delta;          /* form error * 3 */
-       errorptr[0] = (FSERROR) (bpreverr0 + cur0);
-       cur0 += delta;          /* form error * 5 */
-       bpreverr0 = belowerr0 + cur0;
-       belowerr0 = bnexterr;
-       cur0 += delta;          /* form error * 7 */
-       bnexterr = cur1;        /* Process component 1 */
-       delta = cur1 * 2;
-       cur1 += delta;          /* form error * 3 */
-       errorptr[1] = (FSERROR) (bpreverr1 + cur1);
-       cur1 += delta;          /* form error * 5 */
-       bpreverr1 = belowerr1 + cur1;
-       belowerr1 = bnexterr;
-       cur1 += delta;          /* form error * 7 */
-       bnexterr = cur2;        /* Process component 2 */
-       delta = cur2 * 2;
-       cur2 += delta;          /* form error * 3 */
-       errorptr[2] = (FSERROR) (bpreverr2 + cur2);
-       cur2 += delta;          /* form error * 5 */
-       bpreverr2 = belowerr2 + cur2;
-       belowerr2 = bnexterr;
-       cur2 += delta;          /* form error * 7 */
+  bnexterr = cur0;  /* Process component 0 */
+  delta = cur0 * 2;
+  cur0 += delta;    /* form error * 3 */
+  errorptr[0] = (FSERROR) (bpreverr0 + cur0);
+  cur0 += delta;    /* form error * 5 */
+  bpreverr0 = belowerr0 + cur0;
+  belowerr0 = bnexterr;
+  cur0 += delta;    /* form error * 7 */
+  bnexterr = cur1;  /* Process component 1 */
+  delta = cur1 * 2;
+  cur1 += delta;    /* form error * 3 */
+  errorptr[1] = (FSERROR) (bpreverr1 + cur1);
+  cur1 += delta;    /* form error * 5 */
+  bpreverr1 = belowerr1 + cur1;
+  belowerr1 = bnexterr;
+  cur1 += delta;    /* form error * 7 */
+  bnexterr = cur2;  /* Process component 2 */
+  delta = cur2 * 2;
+  cur2 += delta;    /* form error * 3 */
+  errorptr[2] = (FSERROR) (bpreverr2 + cur2);
+  cur2 += delta;    /* form error * 5 */
+  bpreverr2 = belowerr2 + cur2;
+  belowerr2 = bnexterr;
+  cur2 += delta;    /* form error * 7 */
       }
       /* At this point curN contains the 7/16 error value to be propagated
        * to the next pixel on the current line, and all the errors for the
        * next line have been shifted over.  We are therefore ready to move on.
        */
-      inptr += dir3;           /* Advance pixel pointers to next column */
+      inptr += dir3;    /* Advance pixel pointers to next column */
       outptr += dir;
-      errorptr += dir3;                /* advance errorptr to current column */
+      errorptr += dir3;    /* advance errorptr to current column */
     }
     /* Post-loop cleanup: we must unload the final error values into the
      * final fserrors[] entry.  Note we need not unload belowerrN because
@@ -1114,7 +1115,7 @@ init_error_limit (j_decompress_ptr cinfo)
 
   table = (int *) (*cinfo->mem->alloc_small)
     ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE*2+1) * SIZEOF(int));
-  table += MAXJSAMPLE;         /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */
+  table += MAXJSAMPLE;    /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */
   cquantize->error_limiter = table;
 
 #define STEPSIZE ((MAXJSAMPLE+1)/16)
@@ -1155,6 +1156,7 @@ finish_pass1 (j_decompress_ptr cinfo)
 METHODDEF(void)
 finish_pass2 (j_decompress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work */
 }
 
@@ -1197,16 +1199,16 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
 
     if (cinfo->dither_mode == JDITHER_FS) {
       size_t arraysize = (size_t) ((cinfo->output_width + 2) *
-                                  (3 * SIZEOF(FSERROR)));
+           (3 * SIZEOF(FSERROR)));
       /* Allocate Floyd-Steinberg workspace if we didn't already. */
       if (cquantize->fserrors == NULL)
-       cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
-         ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
+  cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
       /* Initialize the propagated errors to zero. */
       jzero_far((void FAR *) cquantize->fserrors, arraysize);
       /* Make the error-limit table if we didn't already. */
       if (cquantize->error_limiter == NULL)
-       init_error_limit(cinfo);
+  init_error_limit(cinfo);
       cquantize->on_odd_row = FALSE;
     }
 
@@ -1215,7 +1217,7 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
   if (cquantize->needs_zeroed) {
     for (i = 0; i < HIST_C0_ELEMS; i++) {
       jzero_far((void FAR *) histogram[i],
-               HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));
+    HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));
     }
     cquantize->needs_zeroed = FALSE;
   }
@@ -1248,11 +1250,11 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo)
 
   cquantize = (my_cquantize_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_cquantizer));
+        SIZEOF(my_cquantizer));
   cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
   cquantize->pub.start_pass = start_pass_2_quant;
   cquantize->pub.new_color_map = new_color_map_2_quant;
-  cquantize->fserrors = NULL;  /* flag optional arrays not allocated */
+  cquantize->fserrors = NULL;  /* flag optional arrays not allocated */
   cquantize->error_limiter = NULL;
 
   /* Make sure jdmaster didn't give me a case I can't handle */
diff --git a/src/jpeg/libijg8/README.GDCM.txt b/src/jpeg/libijg8/README.GDCM.txt
new file mode 100644 (file)
index 0000000..836b344
--- /dev/null
@@ -0,0 +1,15 @@
+This directory contains a subset of the Independent JPEG Group's (IJG)
+libjpeg version 6b.  We only include enough of distribution to build
+libjpeg.  We do not include the standard executables that come with
+libjpeg (cjpeg, djpeg, etc.). Furthermore, the standard libjpeg build
+process is replaced with a CMake build process.
+
+We'd like to thank the IJG for distributing a public JPEG IO library.
+
+Modifications
+-------------
+
+jconfig.h is usually generated by the build process. For this distribution,
+we ship a version of jconfig.h.in to be used across several platforms. It's 
+purpose is also to allow generation of both 8bits and 12bits lib.
+
index 1963ddb61b15689e36e3f1774007d3583b787a26..fe7cfc3194563776340ad6388ae2c7e5668a7eab 100644 (file)
 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 */
+  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
@@ -143,7 +143,7 @@ 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 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;
@@ -154,7 +154,7 @@ compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   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++) {
+   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
@@ -166,46 +166,46 @@ compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
        */
       blkn = 0;
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-       compptr = cinfo->cur_comp_info[ci];
-       blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
-                                               : compptr->last_col_width;
-       xpos = MCU_col_num * compptr->MCU_sample_width;
-       ypos = yoffset * DCTSIZE; /* 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) {
-           (*cinfo->fdct->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. */
-             jzero_far((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. */
-           jzero_far((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 += DCTSIZE;
-       }
+  compptr = cinfo->cur_comp_info[ci];
+  blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+            : compptr->last_col_width;
+  xpos = MCU_col_num * compptr->MCU_sample_width;
+  ypos = yoffset * DCTSIZE; /* 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) {
+      (*cinfo->fdct->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. */
+        jzero_far((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. */
+      jzero_far((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 += DCTSIZE;
+  }
       }
       /* 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;
+  /* 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 */
@@ -280,17 +280,17 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
     for (block_row = 0; block_row < block_rows; block_row++) {
       thisblockrow = buffer[block_row];
       (*cinfo->fdct->forward_DCT) (cinfo, compptr,
-                                  input_buf[ci], thisblockrow,
-                                  (JDIMENSION) (block_row * DCTSIZE),
-                                  (JDIMENSION) 0, blocks_across);
+           input_buf[ci], thisblockrow,
+           (JDIMENSION) (block_row * DCTSIZE),
+           (JDIMENSION) 0, blocks_across);
       if (ndummy > 0) {
-       /* Create dummy blocks at the right edge of the image. */
-       thisblockrow += blocks_across; /* => first dummy block */
-       jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
-       lastDC = thisblockrow[-1][0];
-       for (bi = 0; bi < ndummy; bi++) {
-         thisblockrow[bi][0] = lastDC;
-       }
+  /* Create dummy blocks at the right edge of the image. */
+  thisblockrow += blocks_across; /* => first dummy block */
+  jzero_far((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.
@@ -299,22 +299,22 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      * 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 */
+      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];
-       jzero_far((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;
-       }
+     block_row++) {
+  thisblockrow = buffer[block_row];
+  lastblockrow = buffer[block_row-1];
+  jzero_far((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;
+  }
       }
     }
   }
@@ -341,13 +341,14 @@ 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 */
+  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;
 
+  input_buf = 0;
   /* 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.
@@ -364,25 +365,25 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   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++) {
+   MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
-      blkn = 0;                        /* index of current DCT block within 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++;
-         }
-       }
+  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;
+  /* 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 */
@@ -408,7 +409,7 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 
   coef = (my_coef_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_coef_controller));
+        SIZEOF(my_coef_controller));
   cinfo->coef = (struct jpeg_c_coef_controller *) coef;
   coef->pub.start_pass = start_pass_coef;
 
@@ -421,14 +422,14 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
     jpeg_component_info *compptr;
 
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-        ci++, compptr++) {
+   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);
+  ((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);
@@ -440,7 +441,7 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 
     buffer = (JBLOCKROW)
       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                                 C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+          C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
     for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
       coef->MCU_buffer[i] = buffer + i;
     }
index 0a8a4b5d13c303c4d14cd5b4333adcbb3cfcc4a2..33a80d76d57e77eccefe67a148b49d55fd1cd7b7 100644 (file)
@@ -19,7 +19,7 @@ typedef struct {
   struct jpeg_color_converter pub; /* public fields */
 
   /* Private state for RGB->YCC conversion */
-  INT32 * rgb_ycc_tab;         /* => table for RGB to YCbCr conversion */
+  INT32 * rgb_ycc_tab;    /* => table for RGB to YCbCr conversion */
 } my_color_converter;
 
 typedef my_color_converter * my_cconvert_ptr;
@@ -31,9 +31,9 @@ typedef my_color_converter * my_cconvert_ptr;
  * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
  * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
  * The conversion equations to be implemented are therefore
- *     Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
- *     Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
- *     Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
+ *  Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *  Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
+ *  Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
  * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
  * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
  * rather than CENTERJSAMPLE, for Cb and Cr.  This gave equal positive and
@@ -55,10 +55,10 @@ typedef my_color_converter * my_cconvert_ptr;
  * in the tables to save adding them separately in the inner loop.
  */
 
-#define SCALEBITS      16      /* speediest right-shift on some machines */
-#define CBCR_OFFSET    ((INT32) CENTERJSAMPLE << SCALEBITS)
-#define ONE_HALF       ((INT32) 1 << (SCALEBITS-1))
-#define FIX(x)         ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+#define SCALEBITS  16  /* speediest right-shift on some machines */
+#define CBCR_OFFSET  ((INT32) CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF  ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)    ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
 
 /* We allocate one big table and divide it up into eight parts, instead of
  * doing eight alloc_small requests.  This lets us use a single table base
@@ -66,16 +66,16 @@ typedef my_color_converter * my_cconvert_ptr;
  * machines (more than can hold all eight addresses, anyway).
  */
 
-#define R_Y_OFF                0                       /* offset to R => Y section */
-#define G_Y_OFF                (1*(MAXJSAMPLE+1))      /* offset to G => Y section */
-#define B_Y_OFF                (2*(MAXJSAMPLE+1))      /* etc. */
-#define R_CB_OFF       (3*(MAXJSAMPLE+1))
-#define G_CB_OFF       (4*(MAXJSAMPLE+1))
-#define B_CB_OFF       (5*(MAXJSAMPLE+1))
-#define R_CR_OFF       B_CB_OFF                /* B=>Cb, R=>Cr are the same */
-#define G_CR_OFF       (6*(MAXJSAMPLE+1))
-#define B_CR_OFF       (7*(MAXJSAMPLE+1))
-#define TABLE_SIZE     (8*(MAXJSAMPLE+1))
+#define R_Y_OFF    0      /* offset to R => Y section */
+#define G_Y_OFF    (1*(MAXJSAMPLE+1))  /* offset to G => Y section */
+#define B_Y_OFF    (2*(MAXJSAMPLE+1))  /* etc. */
+#define R_CB_OFF  (3*(MAXJSAMPLE+1))
+#define G_CB_OFF  (4*(MAXJSAMPLE+1))
+#define B_CB_OFF  (5*(MAXJSAMPLE+1))
+#define R_CR_OFF  B_CB_OFF    /* B=>Cb, R=>Cr are the same */
+#define G_CR_OFF  (6*(MAXJSAMPLE+1))
+#define B_CR_OFF  (7*(MAXJSAMPLE+1))
+#define TABLE_SIZE  (8*(MAXJSAMPLE+1))
 
 
 /*
@@ -92,7 +92,7 @@ rgb_ycc_start (j_compress_ptr cinfo)
   /* Allocate and fill in the conversion tables. */
   cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (TABLE_SIZE * SIZEOF(INT32)));
+        (TABLE_SIZE * SIZEOF(INT32)));
 
   for (i = 0; i <= MAXJSAMPLE; i++) {
     rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
@@ -128,8 +128,8 @@ rgb_ycc_start (j_compress_ptr cinfo)
 
 METHODDEF(void)
 rgb_ycc_convert (j_compress_ptr cinfo,
-                JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-                JDIMENSION output_row, int num_rows)
+     JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+     JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -157,16 +157,16 @@ rgb_ycc_convert (j_compress_ptr cinfo,
        */
       /* Y */
       outptr0[col] = (JSAMPLE)
-               ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+     >> SCALEBITS);
       /* Cb */
       outptr1[col] = (JSAMPLE)
-               ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+     >> SCALEBITS);
       /* Cr */
       outptr2[col] = (JSAMPLE)
-               ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+     >> SCALEBITS);
     }
   }
 }
@@ -184,8 +184,8 @@ rgb_ycc_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 rgb_gray_convert (j_compress_ptr cinfo,
-                 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-                 JDIMENSION output_row, int num_rows)
+      JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+      JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -206,8 +206,8 @@ rgb_gray_convert (j_compress_ptr cinfo,
       inptr += RGB_PIXELSIZE;
       /* Y */
       outptr[col] = (JSAMPLE)
-               ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+     >> SCALEBITS);
     }
   }
 }
@@ -223,8 +223,8 @@ rgb_gray_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 cmyk_ycck_convert (j_compress_ptr cinfo,
-                  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-                  JDIMENSION output_row, int num_rows)
+       JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+       JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
@@ -246,7 +246,7 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
       g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
       b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
       /* K passes through as-is */
-      outptr3[col] = inptr[3]; /* don't need GETJSAMPLE here */
+      outptr3[col] = inptr[3];  /* don't need GETJSAMPLE here */
       inptr += 4;
       /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
        * must be too; we do not need an explicit range-limiting operation.
@@ -255,16 +255,16 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
        */
       /* Y */
       outptr0[col] = (JSAMPLE)
-               ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+     >> SCALEBITS);
       /* Cb */
       outptr1[col] = (JSAMPLE)
-               ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+     >> SCALEBITS);
       /* Cr */
       outptr2[col] = (JSAMPLE)
-               ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
-                >> SCALEBITS);
+    ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+     >> SCALEBITS);
     }
   }
 }
@@ -278,8 +278,8 @@ cmyk_ycck_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 grayscale_convert (j_compress_ptr cinfo,
-                  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-                  JDIMENSION output_row, int num_rows)
+       JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+       JDIMENSION output_row, int num_rows)
 {
   register JSAMPROW inptr;
   register JSAMPROW outptr;
@@ -292,7 +292,7 @@ grayscale_convert (j_compress_ptr cinfo,
     outptr = output_buf[0][output_row];
     output_row++;
     for (col = 0; col < num_cols; col++) {
-      outptr[col] = inptr[0];  /* don't need GETJSAMPLE() here */
+      outptr[col] = inptr[0];  /* don't need GETJSAMPLE() here */
       inptr += instride;
     }
   }
@@ -307,8 +307,8 @@ grayscale_convert (j_compress_ptr cinfo,
 
 METHODDEF(void)
 null_convert (j_compress_ptr cinfo,
-             JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
-             JDIMENSION output_row, int num_rows)
+        JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+        JDIMENSION output_row, int num_rows)
 {
   register JSAMPROW inptr;
   register JSAMPROW outptr;
@@ -323,8 +323,8 @@ null_convert (j_compress_ptr cinfo,
       inptr = *input_buf;
       outptr = output_buf[ci][output_row];
       for (col = 0; col < num_cols; col++) {
-       outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
-       inptr += nc;
+  outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
+  inptr += nc;
       }
     }
     input_buf++;
@@ -340,6 +340,7 @@ null_convert (j_compress_ptr cinfo,
 METHODDEF(void)
 null_method (j_compress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work needed */
 }
 
@@ -355,7 +356,7 @@ jinit_color_converter (j_compress_ptr cinfo)
 
   cconvert = (my_cconvert_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_color_converter));
+        SIZEOF(my_color_converter));
   cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
   /* set start_pass to null method until we find out differently */
   cconvert->pub.start_pass = null_method;
@@ -385,7 +386,7 @@ jinit_color_converter (j_compress_ptr cinfo)
       ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
     break;
 
-  default:                     /* JCS_UNKNOWN can be anything */
+  default:      /* JCS_UNKNOWN can be anything */
     if (cinfo->input_components < 1)
       ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
     break;
@@ -449,9 +450,9 @@ jinit_color_converter (j_compress_ptr cinfo)
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     break;
 
-  default:                     /* allow null conversion of JCS_UNKNOWN */
+  default:      /* allow null conversion of JCS_UNKNOWN */
     if (cinfo->jpeg_color_space != cinfo->in_color_space ||
-       cinfo->num_components != cinfo->input_components)
+  cinfo->num_components != cinfo->input_components)
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     cconvert->pub.color_convert = null_convert;
     break;
index 3d1e6c6d524850e0d401fcec9f590d5648d13ee7..6f089d573cffec3c84319f7acd19e3bdebc5bbb5 100644 (file)
@@ -13,7 +13,7 @@
 #include "jpeglib.h"
 
 
-typedef enum {                 /* JPEG marker codes */
+typedef enum {      /* JPEG marker codes */
   M_SOF0  = 0xc0,
   M_SOF1  = 0xc1,
   M_SOF2  = 0xc2,
@@ -169,7 +169,7 @@ emit_dqt (j_compress_ptr cinfo, int index)
       /* The table entries must be emitted in zigzag order. */
       unsigned int qval = qtbl->quantval[jpeg_natural_order[i]];
       if (prec)
-       emit_byte(cinfo, (int) (qval >> 8));
+  emit_byte(cinfo, (int) (qval >> 8));
       emit_byte(cinfo, (int) (qval & 0xFF));
     }
 
@@ -189,7 +189,7 @@ emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
   
   if (is_ac) {
     htbl = cinfo->ac_huff_tbl_ptrs[index];
-    index += 0x10;             /* output index has AC bit set */
+    index += 0x10;    /* output index has AC bit set */
   } else {
     htbl = cinfo->dc_huff_tbl_ptrs[index];
   }
@@ -258,6 +258,7 @@ emit_dac (j_compress_ptr cinfo)
     }
   }
 #endif /* C_ARITH_CODING_SUPPORTED */
+  cinfo = 0;
 }
 
 
@@ -267,7 +268,7 @@ emit_dri (j_compress_ptr cinfo)
 {
   emit_marker(cinfo, M_DRI);
   
-  emit_2bytes(cinfo, 4);       /* fixed length */
+  emit_2bytes(cinfo, 4);  /* fixed length */
 
   emit_2bytes(cinfo, (int) cinfo->restart_interval);
 }
@@ -329,11 +330,11 @@ emit_sos (j_compress_ptr cinfo)
        * but does not seem to be specified in the standard.
        */
       if (cinfo->Ss == 0) {
-       ta = 0;                 /* DC scan */
-       if (cinfo->Ah != 0 && !cinfo->arith_code)
-         td = 0;               /* no DC table either */
+  ta = 0;      /* DC scan */
+  if (cinfo->Ah != 0 && !cinfo->arith_code)
+    td = 0;    /* no DC table either */
       } else {
-       td = 0;                 /* AC scan */
+  td = 0;      /* AC scan */
       }
     }
     emit_byte(cinfo, (td << 4) + ta);
@@ -350,22 +351,22 @@ emit_jfif_app0 (j_compress_ptr cinfo)
 /* Emit a JFIF-compliant APP0 marker */
 {
   /*
-   * Length of APP0 block      (2 bytes)
-   * Block ID                  (4 bytes - ASCII "JFIF")
-   * Zero byte                 (1 byte to terminate the ID string)
-   * Version Major, Minor      (2 bytes - major first)
-   * Units                     (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
-   * Xdpu                      (2 bytes - dots per unit horizontal)
-   * Ydpu                      (2 bytes - dots per unit vertical)
-   * Thumbnail X size          (1 byte)
-   * Thumbnail Y size          (1 byte)
+   * Length of APP0 block  (2 bytes)
+   * Block ID      (4 bytes - ASCII "JFIF")
+   * Zero byte      (1 byte to terminate the ID string)
+   * Version Major, Minor  (2 bytes - major first)
+   * Units      (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+   * Xdpu      (2 bytes - dots per unit horizontal)
+   * Ydpu      (2 bytes - dots per unit vertical)
+   * Thumbnail X size    (1 byte)
+   * Thumbnail Y size    (1 byte)
    */
   
   emit_marker(cinfo, M_APP0);
   
   emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
 
-  emit_byte(cinfo, 0x4A);      /* Identifier: ASCII "JFIF" */
+  emit_byte(cinfo, 0x4A);  /* Identifier: ASCII "JFIF" */
   emit_byte(cinfo, 0x46);
   emit_byte(cinfo, 0x49);
   emit_byte(cinfo, 0x46);
@@ -375,7 +376,7 @@ emit_jfif_app0 (j_compress_ptr cinfo)
   emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
   emit_2bytes(cinfo, (int) cinfo->X_density);
   emit_2bytes(cinfo, (int) cinfo->Y_density);
-  emit_byte(cinfo, 0);         /* No thumbnail image */
+  emit_byte(cinfo, 0);    /* No thumbnail image */
   emit_byte(cinfo, 0);
 }
 
@@ -385,12 +386,12 @@ emit_adobe_app14 (j_compress_ptr cinfo)
 /* Emit an Adobe APP14 marker */
 {
   /*
-   * Length of APP14 block     (2 bytes)
-   * Block ID                  (5 bytes - ASCII "Adobe")
-   * Version Number            (2 bytes - currently 100)
-   * Flags0                    (2 bytes - currently 0)
-   * Flags1                    (2 bytes - currently 0)
-   * Color transform           (1 byte)
+   * Length of APP14 block  (2 bytes)
+   * Block ID      (5 bytes - ASCII "Adobe")
+   * Version Number    (2 bytes - currently 100)
+   * Flags0      (2 bytes - currently 0)
+   * Flags1      (2 bytes - currently 0)
+   * Color transform    (1 byte)
    *
    * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
    * now in circulation seem to use Version = 100, so that's what we write.
@@ -404,23 +405,23 @@ emit_adobe_app14 (j_compress_ptr cinfo)
   
   emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
 
-  emit_byte(cinfo, 0x41);      /* Identifier: ASCII "Adobe" */
+  emit_byte(cinfo, 0x41);  /* Identifier: ASCII "Adobe" */
   emit_byte(cinfo, 0x64);
   emit_byte(cinfo, 0x6F);
   emit_byte(cinfo, 0x62);
   emit_byte(cinfo, 0x65);
-  emit_2bytes(cinfo, 100);     /* Version */
-  emit_2bytes(cinfo, 0);       /* Flags0 */
-  emit_2bytes(cinfo, 0);       /* Flags1 */
+  emit_2bytes(cinfo, 100);  /* Version */
+  emit_2bytes(cinfo, 0);  /* Flags0 */
+  emit_2bytes(cinfo, 0);  /* Flags1 */
   switch (cinfo->jpeg_color_space) {
   case JCS_YCbCr:
-    emit_byte(cinfo, 1);       /* Color transform = 1 */
+    emit_byte(cinfo, 1);  /* Color transform = 1 */
     break;
   case JCS_YCCK:
-    emit_byte(cinfo, 2);       /* Color transform = 2 */
+    emit_byte(cinfo, 2);  /* Color transform = 2 */
     break;
   default:
-    emit_byte(cinfo, 0);       /* Color transform = 0 */
+    emit_byte(cinfo, 0);  /* Color transform = 0 */
     break;
   }
 }
@@ -438,12 +439,12 @@ METHODDEF(void)
 write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
 /* Emit an arbitrary marker header */
 {
-  if (datalen > (unsigned int) 65533)          /* safety check */
+  if (datalen > (unsigned int) 65533)    /* safety check */
     ERREXIT(cinfo, JERR_BAD_LENGTH);
 
   emit_marker(cinfo, (JPEG_MARKER) marker);
 
-  emit_2bytes(cinfo, (int) (datalen + 2));     /* total length */
+  emit_2bytes(cinfo, (int) (datalen + 2));  /* total length */
 }
 
 METHODDEF(void)
@@ -470,12 +471,12 @@ write_file_header (j_compress_ptr cinfo)
 {
   my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
 
-  emit_marker(cinfo, M_SOI);   /* first the SOI */
+  emit_marker(cinfo, M_SOI);  /* first the SOI */
 
   /* SOI is defined to reset restart interval to 0 */
   marker->last_restart_interval = 0;
 
-  if (cinfo->write_JFIF_header)        /* next an optional JFIF APP0 */
+  if (cinfo->write_JFIF_header)  /* next an optional JFIF APP0 */
     emit_jfif_app0(cinfo);
   if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
     emit_adobe_app14(cinfo);
@@ -516,9 +517,9 @@ write_frame_header (j_compress_ptr cinfo)
   } else {
     is_baseline = TRUE;
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-        ci++, compptr++) {
+   ci++, compptr++) {
       if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
-       is_baseline = FALSE;
+  is_baseline = FALSE;
     }
     if (prec && is_baseline) {
       is_baseline = FALSE;
@@ -529,14 +530,14 @@ write_frame_header (j_compress_ptr cinfo)
 
   /* Emit the proper SOF marker */
   if (cinfo->arith_code) {
-    emit_sof(cinfo, M_SOF9);   /* SOF code for arithmetic coding */
+    emit_sof(cinfo, M_SOF9);  /* SOF code for arithmetic coding */
   } else {
     if (cinfo->progressive_mode)
-      emit_sof(cinfo, M_SOF2); /* SOF code for progressive Huffman */
+      emit_sof(cinfo, M_SOF2);  /* SOF code for progressive Huffman */
     else if (is_baseline)
-      emit_sof(cinfo, M_SOF0); /* SOF code for baseline implementation */
+      emit_sof(cinfo, M_SOF0);  /* SOF code for baseline implementation */
     else
-      emit_sof(cinfo, M_SOF1); /* SOF code for non-baseline Huffman file */
+      emit_sof(cinfo, M_SOF1);  /* SOF code for non-baseline Huffman file */
   }
 }
 
@@ -567,17 +568,17 @@ write_scan_header (j_compress_ptr cinfo)
     for (i = 0; i < cinfo->comps_in_scan; i++) {
       compptr = cinfo->cur_comp_info[i];
       if (cinfo->progressive_mode) {
-       /* Progressive mode: only DC or only AC tables are used in one scan */
-       if (cinfo->Ss == 0) {
-         if (cinfo->Ah == 0)   /* DC needs no table for refinement scan */
-           emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
-       } else {
-         emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
-       }
+  /* Progressive mode: only DC or only AC tables are used in one scan */
+  if (cinfo->Ss == 0) {
+    if (cinfo->Ah == 0)  /* DC needs no table for refinement scan */
+      emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+  } else {
+    emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+  }
       } else {
-       /* Sequential mode: need both DC and AC tables */
-       emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
-       emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+  /* Sequential mode: need both DC and AC tables */
+  emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+  emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
       }
     }
   }
@@ -627,9 +628,9 @@ write_tables_only (j_compress_ptr cinfo)
   if (! cinfo->arith_code) {
     for (i = 0; i < NUM_HUFF_TBLS; i++) {
       if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
-       emit_dht(cinfo, i, FALSE);
+  emit_dht(cinfo, i, FALSE);
       if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
-       emit_dht(cinfo, i, TRUE);
+  emit_dht(cinfo, i, TRUE);
     }
   }
 
@@ -649,7 +650,7 @@ jinit_marker_writer (j_compress_ptr cinfo)
   /* Create the subobject */
   marker = (my_marker_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_marker_writer));
+        SIZEOF(my_marker_writer));
   cinfo->marker = (struct jpeg_marker_writer *) marker;
   /* Initialize method pointers */
   marker->pub.write_file_header = write_file_header;
index 212ec8757c4ca865eba34a80530d42e8d371dec7..1e82aa7ba7890af39e19ba0de2e03a3312727b0f 100644 (file)
 
 /* Pointer to routine to downsample a single component */
 typedef JMETHOD(void, downsample1_ptr,
-               (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                JSAMPARRAY input_data, JSAMPARRAY output_data));
+    (j_compress_ptr cinfo, jpeg_component_info * compptr,
+     JSAMPARRAY input_data, JSAMPARRAY output_data));
 
 /* Private subobject */
 
 typedef struct {
-  struct jpeg_downsampler pub; /* public fields */
+  struct jpeg_downsampler pub;  /* public fields */
 
   /* Downsampling method pointers, one per component */
   downsample1_ptr methods[MAX_COMPONENTS];
@@ -74,6 +74,7 @@ typedef my_downsampler * my_downsample_ptr;
 METHODDEF(void)
 start_pass_downsample (j_compress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work for now */
 }
 
@@ -85,7 +86,7 @@ start_pass_downsample (j_compress_ptr cinfo)
 
 LOCAL(void)
 expand_right_edge (JSAMPARRAY image_data, int num_rows,
-                  JDIMENSION input_cols, JDIMENSION output_cols)
+       JDIMENSION input_cols, JDIMENSION output_cols)
 {
   register JSAMPROW ptr;
   register JSAMPLE pixval;
@@ -96,9 +97,9 @@ expand_right_edge (JSAMPARRAY image_data, int num_rows,
   if (numcols > 0) {
     for (row = 0; row < num_rows; row++) {
       ptr = image_data[row] + input_cols;
-      pixval = ptr[-1];                /* don't need GETJSAMPLE() here */
+      pixval = ptr[-1];    /* don't need GETJSAMPLE() here */
       for (count = numcols; count > 0; count--)
-       *ptr++ = pixval;
+  *ptr++ = pixval;
     }
   }
 }
@@ -112,8 +113,8 @@ expand_right_edge (JSAMPARRAY image_data, int num_rows,
 
 METHODDEF(void)
 sep_downsample (j_compress_ptr cinfo,
-               JSAMPIMAGE input_buf, JDIMENSION in_row_index,
-               JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
+    JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+    JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
 {
   my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
   int ci;
@@ -138,10 +139,10 @@ sep_downsample (j_compress_ptr cinfo,
 
 METHODDEF(void)
 int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-               JSAMPARRAY input_data, JSAMPARRAY output_data)
+    JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
-  JDIMENSION outcol, outcol_h; /* outcol_h == outcol*h_expand */
+  JDIMENSION outcol, outcol_h;  /* outcol_h == outcol*h_expand */
   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
   JSAMPROW inptr, outptr;
   INT32 outvalue;
@@ -156,19 +157,19 @@ int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
    * efficient.
    */
   expand_right_edge(input_data, cinfo->max_v_samp_factor,
-                   cinfo->image_width, output_cols * h_expand);
+        cinfo->image_width, output_cols * h_expand);
 
   inrow = 0;
   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
     outptr = output_data[outrow];
     for (outcol = 0, outcol_h = 0; outcol < output_cols;
-        outcol++, outcol_h += h_expand) {
+   outcol++, outcol_h += h_expand) {
       outvalue = 0;
       for (v = 0; v < v_expand; v++) {
-       inptr = input_data[inrow+v] + outcol_h;
-       for (h = 0; h < h_expand; h++) {
-         outvalue += (INT32) GETJSAMPLE(*inptr++);
-       }
+  inptr = input_data[inrow+v] + outcol_h;
+  for (h = 0; h < h_expand; h++) {
+    outvalue += (INT32) GETJSAMPLE(*inptr++);
+  }
       }
       *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
     }
@@ -185,14 +186,14 @@ int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY output_data)
+         JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   /* Copy the data */
   jcopy_sample_rows(input_data, 0, output_data, 0,
-                   cinfo->max_v_samp_factor, cinfo->image_width);
+        cinfo->max_v_samp_factor, cinfo->image_width);
   /* Edge-expand */
   expand_right_edge(output_data, cinfo->max_v_samp_factor,
-                   cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
+        cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
 }
 
 
@@ -210,7 +211,7 @@ fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                JSAMPARRAY input_data, JSAMPARRAY output_data)
+     JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int outrow;
   JDIMENSION outcol;
@@ -223,16 +224,16 @@ h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
    * efficient.
    */
   expand_right_edge(input_data, cinfo->max_v_samp_factor,
-                   cinfo->image_width, output_cols * 2);
+        cinfo->image_width, output_cols * 2);
 
   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
     outptr = output_data[outrow];
     inptr = input_data[outrow];
-    bias = 0;                  /* bias = 0,1,0,1,... for successive samples */
+    bias = 0;      /* bias = 0,1,0,1,... for successive samples */
     for (outcol = 0; outcol < output_cols; outcol++) {
       *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
-                             + bias) >> 1);
-      bias ^= 1;               /* 0=>1, 1=>0 */
+            + bias) >> 1);
+      bias ^= 1;    /* 0=>1, 1=>0 */
       inptr += 2;
     }
   }
@@ -247,7 +248,7 @@ h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                JSAMPARRAY input_data, JSAMPARRAY output_data)
+     JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int inrow, outrow;
   JDIMENSION outcol;
@@ -260,19 +261,19 @@ h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
    * efficient.
    */
   expand_right_edge(input_data, cinfo->max_v_samp_factor,
-                   cinfo->image_width, output_cols * 2);
+        cinfo->image_width, output_cols * 2);
 
   inrow = 0;
   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
     outptr = output_data[outrow];
     inptr0 = input_data[inrow];
     inptr1 = input_data[inrow+1];
-    bias = 1;                  /* bias = 1,2,1,2,... for successive samples */
+    bias = 1;      /* bias = 1,2,1,2,... for successive samples */
     for (outcol = 0; outcol < output_cols; outcol++) {
       *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
-                             GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
-                             + bias) >> 2);
-      bias ^= 3;               /* 1=>2, 2=>1 */
+            GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
+            + bias) >> 2);
+      bias ^= 3;    /* 1=>2, 2=>1 */
       inptr0 += 2; inptr1 += 2;
     }
     inrow += 2;
@@ -290,7 +291,7 @@ h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
-                       JSAMPARRAY input_data, JSAMPARRAY output_data)
+      JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int inrow, outrow;
   JDIMENSION colctr;
@@ -303,7 +304,7 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
    * efficient.
    */
   expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
-                   cinfo->image_width, output_cols * 2);
+        cinfo->image_width, output_cols * 2);
 
   /* We don't bother to form the individual "smoothed" input pixel values;
    * we can directly compute the output which is the average of the four
@@ -331,14 +332,14 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
     /* Special case for first column: pretend column -1 is same as column 0 */
     membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
-               GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
     neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
-              GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
-              GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
-              GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
+         GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+         GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
+         GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
     neighsum += neighsum;
     neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
-               GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
+    GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
     membersum = membersum * memberscale + neighsum * neighscale;
     *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
     inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
@@ -346,17 +347,17 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
     for (colctr = output_cols - 2; colctr > 0; colctr--) {
       /* sum of pixels directly mapped to this output element */
       membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
-                 GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+      GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
       /* sum of edge-neighbor pixels */
       neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
-                GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
-                GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
-                GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
+     GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+     GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
+     GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
       /* The edge-neighbors count twice as much as corner-neighbors */
       neighsum += neighsum;
       /* Add in the corner-neighbors */
       neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
-                 GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
+      GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
       /* form final output scaled up by 2^16 */
       membersum = membersum * memberscale + neighsum * neighscale;
       /* round, descale and output it */
@@ -366,14 +367,14 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
     /* Special case for last column */
     membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
-               GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
     neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
-              GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
-              GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
-              GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
+         GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+         GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
+         GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
     neighsum += neighsum;
     neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
-               GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
+    GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
     membersum = membersum * memberscale + neighsum * neighscale;
     *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
 
@@ -390,7 +391,7 @@ h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
-                           JSAMPARRAY input_data, JSAMPARRAY output_data)
+          JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   int outrow;
   JDIMENSION colctr;
@@ -404,7 +405,7 @@ fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
    * efficient.
    */
   expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
-                   cinfo->image_width, output_cols);
+        cinfo->image_width, output_cols);
 
   /* Each of the eight neighbor pixels contributes a fraction SF to the
    * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
@@ -423,10 +424,10 @@ fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
 
     /* Special case for first column */
     colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
-            GETJSAMPLE(*inptr);
+       GETJSAMPLE(*inptr);
     membersum = GETJSAMPLE(*inptr++);
     nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
-                GETJSAMPLE(*inptr);
+     GETJSAMPLE(*inptr);
     neighsum = colsum + (colsum - membersum) + nextcolsum;
     membersum = membersum * memberscale + neighsum * neighscale;
     *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
@@ -436,7 +437,7 @@ fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
       membersum = GETJSAMPLE(*inptr++);
       above_ptr++; below_ptr++;
       nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
-                  GETJSAMPLE(*inptr);
+       GETJSAMPLE(*inptr);
       neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
       membersum = membersum * memberscale + neighsum * neighscale;
       *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
@@ -470,7 +471,7 @@ jinit_downsampler (j_compress_ptr cinfo)
 
   downsample = (my_downsample_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_downsampler));
+        SIZEOF(my_downsampler));
   cinfo->downsample = (struct jpeg_downsampler *) downsample;
   downsample->pub.start_pass = start_pass_downsample;
   downsample->pub.downsample = sep_downsample;
@@ -483,29 +484,29 @@ jinit_downsampler (j_compress_ptr cinfo)
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
     if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
-       compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+  compptr->v_samp_factor == cinfo->max_v_samp_factor) {
 #ifdef INPUT_SMOOTHING_SUPPORTED
       if (cinfo->smoothing_factor) {
-       downsample->methods[ci] = fullsize_smooth_downsample;
-       downsample->pub.need_context_rows = TRUE;
+  downsample->methods[ci] = fullsize_smooth_downsample;
+  downsample->pub.need_context_rows = TRUE;
       } else
 #endif
-       downsample->methods[ci] = fullsize_downsample;
+  downsample->methods[ci] = fullsize_downsample;
     } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
-              compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+         compptr->v_samp_factor == cinfo->max_v_samp_factor) {
       smoothok = FALSE;
       downsample->methods[ci] = h2v1_downsample;
     } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
-              compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
+         compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
 #ifdef INPUT_SMOOTHING_SUPPORTED
       if (cinfo->smoothing_factor) {
-       downsample->methods[ci] = h2v2_smooth_downsample;
-       downsample->pub.need_context_rows = TRUE;
+  downsample->methods[ci] = h2v2_smooth_downsample;
+  downsample->pub.need_context_rows = TRUE;
       } else
 #endif
-       downsample->methods[ci] = h2v2_downsample;
+  downsample->methods[ci] = h2v2_downsample;
     } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
-              (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
+         (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
       smoothok = FALSE;
       downsample->methods[ci] = int_downsample;
     } else
index 0e6d70769df543d84cd5a2bec154443648e5c61a..b84f1d8464213351984d9cee446878fca43d4a1c 100644 (file)
@@ -17,9 +17,9 @@
 
 /* Forward declarations */
 LOCAL(void) transencode_master_selection
-       JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+  JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
 LOCAL(void) transencode_coef_controller
-       JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+  JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
 
 
 /*
@@ -47,7 +47,7 @@ jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
   /* Perform master selection of active modules */
   transencode_master_selection(cinfo, coef_arrays);
   /* Wait for jpeg_finish_compress() call */
-  cinfo->next_scanline = 0;    /* so jpeg_write_marker works */
+  cinfo->next_scanline = 0;  /* so jpeg_write_marker works */
   cinfo->global_state = CSTATE_WRCOEFS;
 }
 
@@ -61,7 +61,7 @@ jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
 
 GLOBAL(void)
 jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
-                              j_compress_ptr dstinfo)
+             j_compress_ptr dstinfo)
 {
   JQUANT_TBL ** qtblptr;
   jpeg_component_info *incomp, *outcomp;
@@ -89,10 +89,10 @@ jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
     if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
       qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
       if (*qtblptr == NULL)
-       *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
+  *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
       MEMCOPY((*qtblptr)->quantval,
-             srcinfo->quant_tbl_ptrs[tblno]->quantval,
-             SIZEOF((*qtblptr)->quantval));
+        srcinfo->quant_tbl_ptrs[tblno]->quantval,
+        SIZEOF((*qtblptr)->quantval));
       (*qtblptr)->sent_table = FALSE;
     }
   }
@@ -102,7 +102,7 @@ jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
   dstinfo->num_components = srcinfo->num_components;
   if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
     ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
-            MAX_COMPONENTS);
+       MAX_COMPONENTS);
   for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
        ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
     outcomp->component_id = incomp->component_id;
@@ -115,14 +115,14 @@ jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
      */
     tblno = outcomp->quant_tbl_no;
     if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
-       srcinfo->quant_tbl_ptrs[tblno] == NULL)
+  srcinfo->quant_tbl_ptrs[tblno] == NULL)
       ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
     slot_quant = srcinfo->quant_tbl_ptrs[tblno];
     c_quant = incomp->quant_table;
     if (c_quant != NULL) {
       for (coefi = 0; coefi < DCTSIZE2; coefi++) {
-       if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
-         ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
+  if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
+    ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
       }
     }
     /* Note: we do not copy the source's Huffman table assignments;
@@ -156,7 +156,7 @@ jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
 
 LOCAL(void)
 transencode_master_selection (j_compress_ptr cinfo,
-                             jvirt_barray_ptr * coef_arrays)
+            jvirt_barray_ptr * coef_arrays)
 {
   /* Although we don't actually use input_components for transcoding,
    * jcmaster.c's initial_setup will complain if input_components is 0.
@@ -208,10 +208,10 @@ transencode_master_selection (j_compress_ptr cinfo,
 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 */
+  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 */
 
   /* Virtual block array for each component. */
   jvirt_barray_ptr * whole_image;
@@ -278,7 +278,7 @@ 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 */
+  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, ci, xindex, yindex, yoffset, blockcnt;
@@ -288,6 +288,8 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   JBLOCKROW buffer_ptr;
   jpeg_component_info *compptr;
 
+  input_buf = 0;
+
   /* Align the virtual buffers for the components used in this scan. */
   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
     compptr = cinfo->cur_comp_info[ci];
@@ -301,44 +303,44 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   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++) {
+   MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
-      blkn = 0;                        /* index of current DCT block within 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;
-       blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
-                                               : compptr->last_col_width;
-       for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-         if (coef->iMCU_row_num < last_iMCU_row ||
-             yindex+yoffset < compptr->last_row_height) {
-           /* Fill in pointers to real blocks in this row */
-           buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
-           for (xindex = 0; xindex < blockcnt; xindex++)
-             MCU_buffer[blkn++] = buffer_ptr++;
-         } else {
-           /* At bottom of image, need a whole row of dummy blocks */
-           xindex = 0;
-         }
-         /* Fill in any dummy blocks needed in this row.
-          * Dummy blocks are filled in the same way as in jccoefct.c:
-          * all zeroes in the AC entries, DC entries equal to previous
-          * block's DC value.  The init routine has already zeroed the
-          * AC entries, so we need only set the DC entries correctly.
-          */
-         for (; xindex < compptr->MCU_width; xindex++) {
-           MCU_buffer[blkn] = coef->dummy_buffer[blkn];
-           MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
-           blkn++;
-         }
-       }
+  compptr = cinfo->cur_comp_info[ci];
+  start_col = MCU_col_num * compptr->MCU_width;
+  blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+            : compptr->last_col_width;
+  for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+    if (coef->iMCU_row_num < last_iMCU_row ||
+        yindex+yoffset < compptr->last_row_height) {
+      /* Fill in pointers to real blocks in this row */
+      buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+      for (xindex = 0; xindex < blockcnt; xindex++)
+        MCU_buffer[blkn++] = buffer_ptr++;
+    } else {
+      /* At bottom of image, need a whole row of dummy blocks */
+      xindex = 0;
+    }
+    /* Fill in any dummy blocks needed in this row.
+     * Dummy blocks are filled in the same way as in jccoefct.c:
+     * all zeroes in the AC entries, DC entries equal to previous
+     * block's DC value.  The init routine has already zeroed the
+     * AC entries, so we need only set the DC entries correctly.
+     */
+    for (; xindex < compptr->MCU_width; xindex++) {
+      MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+      MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
+      blkn++;
+    }
+  }
       }
       /* Try to write the MCU. */
       if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
-       /* Suspension forced; update state counters and exit */
-       coef->MCU_vert_offset = yoffset;
-       coef->mcu_ctr = MCU_col_num;
-       return FALSE;
+  /* 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 */
@@ -361,7 +363,7 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 
 LOCAL(void)
 transencode_coef_controller (j_compress_ptr cinfo,
-                            jvirt_barray_ptr * coef_arrays)
+           jvirt_barray_ptr * coef_arrays)
 {
   my_coef_ptr coef;
   JBLOCKROW buffer;
@@ -369,7 +371,7 @@ transencode_coef_controller (j_compress_ptr cinfo,
 
   coef = (my_coef_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_coef_controller));
+        SIZEOF(my_coef_controller));
   cinfo->coef = (struct jpeg_c_coef_controller *) coef;
   coef->pub.start_pass = start_pass_coef;
   coef->pub.compress_data = compress_output;
@@ -380,7 +382,7 @@ transencode_coef_controller (j_compress_ptr cinfo,
   /* Allocate and pre-zero space for dummy DCT blocks. */
   buffer = (JBLOCKROW)
     (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+        C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
   jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
   for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
     coef->dummy_buffer[i] = buffer + i;
index edc752bf5d8c233a6597ba6a46d48ec7e43c65c7..f6711d9e01ce935273e40b82e7b9e6ed47dd028c 100644 (file)
 /* Expanded data source object for stdio input */
 
 typedef struct {
-  struct jpeg_source_mgr pub;  /* public fields */
+  struct jpeg_source_mgr pub;  /* public fields */
 
-  FILE * infile;               /* source stream */
-  JOCTET * buffer;             /* start of buffer */
-  boolean start_of_file;       /* have we gotten any data yet? */
+  FILE * infile;    /* source stream */
+  JOCTET * buffer;    /* start of buffer */
+  boolean start_of_file;  /* have we gotten any data yet? */
 } my_source_mgr;
 
 typedef my_source_mgr * my_src_ptr;
 
-#define INPUT_BUF_SIZE  4096   /* choose an efficiently fread'able size */
+#define INPUT_BUF_SIZE  4096  /* choose an efficiently fread'able size */
 
 
 /*
@@ -95,7 +95,7 @@ fill_input_buffer (j_decompress_ptr cinfo)
   nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);
 
   if (nbytes <= 0) {
-    if (src->start_of_file)    /* Treat empty input file as fatal error */
+    if (src->start_of_file)  /* Treat empty input file as fatal error */
       ERREXIT(cinfo, JERR_INPUT_EMPTY);
     WARNMS(cinfo, JWRN_JPEG_EOF);
     /* Insert a fake EOI marker */
@@ -168,6 +168,7 @@ skip_input_data (j_decompress_ptr cinfo, long num_bytes)
 METHODDEF(void)
 term_source (j_decompress_ptr cinfo)
 {
+  cinfo=cinfo;
   /* no work necessary here */
 }
 
@@ -190,14 +191,14 @@ jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
    * This makes it unsafe to use this manager and a different source
    * manager serially with the same JPEG object.  Caveat programmer.
    */
-  if (cinfo->src == NULL) {    /* first time for this JPEG object? */
+  if (cinfo->src == NULL) {  /* first time for this JPEG object? */
     cinfo->src = (struct jpeg_source_mgr *)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-                                 SIZEOF(my_source_mgr));
+          SIZEOF(my_source_mgr));
     src = (my_src_ptr) cinfo->src;
     src->buffer = (JOCTET *)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-                                 INPUT_BUF_SIZE * SIZEOF(JOCTET));
+          INPUT_BUF_SIZE * SIZEOF(JOCTET));
   }
 
   src = (my_src_ptr) cinfo->src;
index 4938d20fcb655632d640534ba19e73f0c8fdccbc..0016bdda97b5e15c3956b978d0bbb0ed86f76224 100644 (file)
@@ -30,9 +30,9 @@ typedef struct {
 
   /* These variables keep track of the current location of the input side. */
   /* cinfo->input_iMCU_row is also used for this. */
-  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 */
+  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 */
 
   /* The output side's location is represented by cinfo->output_iMCU_row. */
 
@@ -55,7 +55,7 @@ typedef struct {
 #ifdef BLOCK_SMOOTHING_SUPPORTED
   /* When doing block smoothing, we latch coefficient Al values here */
   int * coef_bits_latch;
-#define SAVED_COEFS  6         /* we save coef_bits[0..5] */
+#define SAVED_COEFS  6    /* we save coef_bits[0..5] */
 #endif
 } my_coef_controller;
 
@@ -63,15 +63,15 @@ typedef my_coef_controller * my_coef_ptr;
 
 /* Forward declarations */
 METHODDEF(int) decompress_onepass
-       JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+  JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
 #ifdef D_MULTISCAN_FILES_SUPPORTED
 METHODDEF(int) decompress_data
-       JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+  JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
 #endif
 #ifdef BLOCK_SMOOTHING_SUPPORTED
 LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo));
 METHODDEF(int) decompress_smooth_data
-       JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+  JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
 #endif
 
 
@@ -147,7 +147,7 @@ METHODDEF(int)
 decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 {
   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
-  JDIMENSION MCU_col_num;      /* index of current MCU within row */
+  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, ci, xindex, yindex, yoffset, useful_width;
@@ -160,49 +160,49 @@ decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
   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++) {
+   MCU_col_num++) {
       /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
       jzero_far((void FAR *) coef->MCU_buffer[0],
-               (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
+    (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
       if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
-       /* Suspension forced; update state counters and exit */
-       coef->MCU_vert_offset = yoffset;
-       coef->MCU_ctr = MCU_col_num;
-       return JPEG_SUSPENDED;
+  /* Suspension forced; update state counters and exit */
+  coef->MCU_vert_offset = yoffset;
+  coef->MCU_ctr = MCU_col_num;
+  return JPEG_SUSPENDED;
       }
       /* Determine where data should go in output_buf and do the IDCT thing.
        * We skip dummy blocks at the right and bottom edges (but blkn gets
        * incremented past them!).  Note the inner loop relies on having
        * allocated the MCU_buffer[] blocks sequentially.
        */
-      blkn = 0;                        /* index of current DCT block within 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];
-       /* Don't bother to IDCT an uninteresting component. */
-       if (! compptr->component_needed) {
-         blkn += compptr->MCU_blocks;
-         continue;
-       }
-       inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
-       useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
-                                                   : compptr->last_col_width;
-       output_ptr = output_buf[compptr->component_index] +
-         yoffset * compptr->DCT_scaled_size;
-       start_col = MCU_col_num * compptr->MCU_sample_width;
-       for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-         if (cinfo->input_iMCU_row < last_iMCU_row ||
-             yoffset+yindex < compptr->last_row_height) {
-           output_col = start_col;
-           for (xindex = 0; xindex < useful_width; xindex++) {
-             (*inverse_DCT) (cinfo, compptr,
-                             (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
-                             output_ptr, output_col);
-             output_col += compptr->DCT_scaled_size;
-           }
-         }
-         blkn += compptr->MCU_width;
-         output_ptr += compptr->DCT_scaled_size;
-       }
+  compptr = cinfo->cur_comp_info[ci];
+  /* Don't bother to IDCT an uninteresting component. */
+  if (! compptr->component_needed) {
+    blkn += compptr->MCU_blocks;
+    continue;
+  }
+  inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
+  useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+                : compptr->last_col_width;
+  output_ptr = output_buf[compptr->component_index] +
+    yoffset * compptr->DCT_scaled_size;
+  start_col = MCU_col_num * compptr->MCU_sample_width;
+  for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+    if (cinfo->input_iMCU_row < last_iMCU_row ||
+        yoffset+yindex < compptr->last_row_height) {
+      output_col = start_col;
+      for (xindex = 0; xindex < useful_width; xindex++) {
+        (*inverse_DCT) (cinfo, compptr,
+            (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
+            output_ptr, output_col);
+        output_col += compptr->DCT_scaled_size;
+      }
+    }
+    blkn += compptr->MCU_width;
+    output_ptr += compptr->DCT_scaled_size;
+  }
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
@@ -227,7 +227,8 @@ decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 METHODDEF(int)
 dummy_consume_data (j_decompress_ptr cinfo)
 {
-  return JPEG_SUSPENDED;       /* Always indicate nothing was done */
+  cinfo = 0;
+  return JPEG_SUSPENDED;  /* Always indicate nothing was done */
 }
 
 
@@ -244,7 +245,7 @@ METHODDEF(int)
 consume_data (j_decompress_ptr cinfo)
 {
   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
-  JDIMENSION MCU_col_num;      /* index of current MCU within row */
+  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];
@@ -268,25 +269,25 @@ consume_data (j_decompress_ptr cinfo)
   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++) {
+   MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
-      blkn = 0;                        /* index of current DCT block within 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++;
-         }
-       }
+  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 fetch the MCU. */
       if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
-       /* Suspension forced; update state counters and exit */
-       coef->MCU_vert_offset = yoffset;
-       coef->MCU_ctr = MCU_col_num;
-       return JPEG_SUSPENDED;
+  /* Suspension forced; update state counters and exit */
+  coef->MCU_vert_offset = yoffset;
+  coef->MCU_ctr = MCU_col_num;
+  return JPEG_SUSPENDED;
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
@@ -327,8 +328,8 @@ decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 
   /* Force some input to be done if we are getting ahead of the input. */
   while (cinfo->input_scan_number < cinfo->output_scan_number ||
-        (cinfo->input_scan_number == cinfo->output_scan_number &&
-         cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
+   (cinfo->input_scan_number == cinfo->output_scan_number &&
+    cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
     if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
       return JPEG_SUSPENDED;
   }
@@ -359,10 +360,10 @@ decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
       buffer_ptr = buffer[block_row];
       output_col = 0;
       for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
-       (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
-                       output_ptr, output_col);
-       buffer_ptr++;
-       output_col += compptr->DCT_scaled_size;
+  (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
+      output_ptr, output_col);
+  buffer_ptr++;
+  output_col += compptr->DCT_scaled_size;
       }
       output_ptr += compptr->DCT_scaled_size;
     }
@@ -419,8 +420,8 @@ smoothing_ok (j_decompress_ptr cinfo)
   if (coef->coef_bits_latch == NULL)
     coef->coef_bits_latch = (int *)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                                 cinfo->num_components *
-                                 (SAVED_COEFS * SIZEOF(int)));
+          cinfo->num_components *
+          (SAVED_COEFS * SIZEOF(int)));
   coef_bits_latch = coef->coef_bits_latch;
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
@@ -430,11 +431,11 @@ smoothing_ok (j_decompress_ptr cinfo)
       return FALSE;
     /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
     if (qtable->quantval[0] == 0 ||
-       qtable->quantval[Q01_POS] == 0 ||
-       qtable->quantval[Q10_POS] == 0 ||
-       qtable->quantval[Q20_POS] == 0 ||
-       qtable->quantval[Q11_POS] == 0 ||
-       qtable->quantval[Q02_POS] == 0)
+  qtable->quantval[Q01_POS] == 0 ||
+  qtable->quantval[Q10_POS] == 0 ||
+  qtable->quantval[Q20_POS] == 0 ||
+  qtable->quantval[Q11_POS] == 0 ||
+  qtable->quantval[Q02_POS] == 0)
       return FALSE;
     /* DC values must be at least partly known for all components. */
     coef_bits = cinfo->coef_bits[ci];
@@ -444,7 +445,7 @@ smoothing_ok (j_decompress_ptr cinfo)
     for (coefi = 1; coefi <= 5; coefi++) {
       coef_bits_latch[coefi] = coef_bits[coefi];
       if (coef_bits[coefi] != 0)
-       smoothing_useful = TRUE;
+  smoothing_useful = TRUE;
     }
     coef_bits_latch += SAVED_COEFS;
   }
@@ -480,7 +481,7 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 
   /* Force some input to be done if we are getting ahead of the input. */
   while (cinfo->input_scan_number <= cinfo->output_scan_number &&
-        ! cinfo->inputctl->eoi_reached) {
+   ! cinfo->inputctl->eoi_reached) {
     if (cinfo->input_scan_number == cinfo->output_scan_number) {
       /* If input is working on current scan, we ordinarily want it to
        * have completed the current row.  But if input scan is DC,
@@ -489,7 +490,7 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
        */
       JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
       if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
-       break;
+  break;
     }
     if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
       return JPEG_SUSPENDED;
@@ -517,15 +518,15 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
     if (cinfo->output_iMCU_row > 0) {
       access_rows += compptr->v_samp_factor; /* prior iMCU row too */
       buffer = (*cinfo->mem->access_virt_barray)
-       ((j_common_ptr) cinfo, coef->whole_image[ci],
-        (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
-        (JDIMENSION) access_rows, FALSE);
-      buffer += compptr->v_samp_factor;        /* point to current iMCU row */
+  ((j_common_ptr) cinfo, coef->whole_image[ci],
+   (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
+   (JDIMENSION) access_rows, FALSE);
+      buffer += compptr->v_samp_factor;  /* point to current iMCU row */
       first_row = FALSE;
     } else {
       buffer = (*cinfo->mem->access_virt_barray)
-       ((j_common_ptr) cinfo, coef->whole_image[ci],
-        (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
+  ((j_common_ptr) cinfo, coef->whole_image[ci],
+   (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
       first_row = TRUE;
     }
     /* Fetch component-dependent info */
@@ -543,13 +544,13 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
     for (block_row = 0; block_row < block_rows; block_row++) {
       buffer_ptr = buffer[block_row];
       if (first_row && block_row == 0)
-       prev_block_row = buffer_ptr;
+  prev_block_row = buffer_ptr;
       else
-       prev_block_row = buffer[block_row-1];
+  prev_block_row = buffer[block_row-1];
       if (last_row && block_row == block_rows-1)
-       next_block_row = buffer_ptr;
+  next_block_row = buffer_ptr;
       else
-       next_block_row = buffer[block_row+1];
+  next_block_row = buffer[block_row+1];
       /* We fetch the surrounding DC values using a sliding-register approach.
        * Initialize all nine here so as to do the right thing on narrow pics.
        */
@@ -559,102 +560,102 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
       output_col = 0;
       last_block_column = compptr->width_in_blocks - 1;
       for (block_num = 0; block_num <= last_block_column; block_num++) {
-       /* Fetch current DCT block into workspace so we can modify it. */
-       jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
-       /* Update DC values */
-       if (block_num < last_block_column) {
-         DC3 = (int) prev_block_row[1][0];
-         DC6 = (int) buffer_ptr[1][0];
-         DC9 = (int) next_block_row[1][0];
-       }
-       /* Compute coefficient estimates per K.8.
-        * An estimate is applied only if coefficient is still zero,
-        * and is not known to be fully accurate.
-        */
-       /* AC01 */
-       if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
-         num = 36 * Q00 * (DC4 - DC6);
-         if (num >= 0) {
-           pred = (int) (((Q01<<7) + num) / (Q01<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q01<<7) - num) / (Q01<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[1] = (JCOEF) pred;
-       }
-       /* AC10 */
-       if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
-         num = 36 * Q00 * (DC2 - DC8);
-         if (num >= 0) {
-           pred = (int) (((Q10<<7) + num) / (Q10<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q10<<7) - num) / (Q10<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[8] = (JCOEF) pred;
-       }
-       /* AC20 */
-       if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
-         num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
-         if (num >= 0) {
-           pred = (int) (((Q20<<7) + num) / (Q20<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q20<<7) - num) / (Q20<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[16] = (JCOEF) pred;
-       }
-       /* AC11 */
-       if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
-         num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
-         if (num >= 0) {
-           pred = (int) (((Q11<<7) + num) / (Q11<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q11<<7) - num) / (Q11<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[9] = (JCOEF) pred;
-       }
-       /* AC02 */
-       if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
-         num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
-         if (num >= 0) {
-           pred = (int) (((Q02<<7) + num) / (Q02<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-         } else {
-           pred = (int) (((Q02<<7) - num) / (Q02<<8));
-           if (Al > 0 && pred >= (1<<Al))
-             pred = (1<<Al)-1;
-           pred = -pred;
-         }
-         workspace[2] = (JCOEF) pred;
-       }
-       /* OK, do the IDCT */
-       (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
-                       output_ptr, output_col);
-       /* Advance for next column */
-       DC1 = DC2; DC2 = DC3;
-       DC4 = DC5; DC5 = DC6;
-       DC7 = DC8; DC8 = DC9;
-       buffer_ptr++, prev_block_row++, next_block_row++;
-       output_col += compptr->DCT_scaled_size;
+  /* Fetch current DCT block into workspace so we can modify it. */
+  jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
+  /* Update DC values */
+  if (block_num < last_block_column) {
+    DC3 = (int) prev_block_row[1][0];
+    DC6 = (int) buffer_ptr[1][0];
+    DC9 = (int) next_block_row[1][0];
+  }
+  /* Compute coefficient estimates per K.8.
+   * An estimate is applied only if coefficient is still zero,
+   * and is not known to be fully accurate.
+   */
+  /* AC01 */
+  if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
+    num = 36 * Q00 * (DC4 - DC6);
+    if (num >= 0) {
+      pred = (int) (((Q01<<7) + num) / (Q01<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q01<<7) - num) / (Q01<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[1] = (JCOEF) pred;
+  }
+  /* AC10 */
+  if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
+    num = 36 * Q00 * (DC2 - DC8);
+    if (num >= 0) {
+      pred = (int) (((Q10<<7) + num) / (Q10<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q10<<7) - num) / (Q10<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[8] = (JCOEF) pred;
+  }
+  /* AC20 */
+  if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
+    num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
+    if (num >= 0) {
+      pred = (int) (((Q20<<7) + num) / (Q20<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q20<<7) - num) / (Q20<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[16] = (JCOEF) pred;
+  }
+  /* AC11 */
+  if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
+    num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
+    if (num >= 0) {
+      pred = (int) (((Q11<<7) + num) / (Q11<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q11<<7) - num) / (Q11<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[9] = (JCOEF) pred;
+  }
+  /* AC02 */
+  if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
+    num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
+    if (num >= 0) {
+      pred = (int) (((Q02<<7) + num) / (Q02<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+    } else {
+      pred = (int) (((Q02<<7) - num) / (Q02<<8));
+      if (Al > 0 && pred >= (1<<Al))
+        pred = (1<<Al)-1;
+      pred = -pred;
+    }
+    workspace[2] = (JCOEF) pred;
+  }
+  /* OK, do the IDCT */
+  (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
+      output_ptr, output_col);
+  /* Advance for next column */
+  DC1 = DC2; DC2 = DC3;
+  DC4 = DC5; DC5 = DC6;
+  DC7 = DC8; DC8 = DC9;
+  buffer_ptr++, prev_block_row++, next_block_row++;
+  output_col += compptr->DCT_scaled_size;
       }
       output_ptr += compptr->DCT_scaled_size;
     }
@@ -679,7 +680,7 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 
   coef = (my_coef_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_coef_controller));
+        SIZEOF(my_coef_controller));
   cinfo->coef = (struct jpeg_d_coef_controller *) coef;
   coef->pub.start_input_pass = start_input_pass;
   coef->pub.start_output_pass = start_output_pass;
@@ -697,20 +698,20 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
     jpeg_component_info *compptr;
 
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-        ci++, compptr++) {
+   ci++, compptr++) {
       access_rows = compptr->v_samp_factor;
 #ifdef BLOCK_SMOOTHING_SUPPORTED
       /* If block smoothing could be used, need a bigger window */
       if (cinfo->progressive_mode)
-       access_rows *= 3;
+  access_rows *= 3;
 #endif
       coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
-       ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
-        (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) access_rows);
+  ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
+   (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) access_rows);
     }
     coef->pub.consume_data = consume_data;
     coef->pub.decompress_data = decompress_data;
@@ -725,7 +726,7 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 
     buffer = (JBLOCKROW)
       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                                 D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+          D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
     for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
       coef->MCU_buffer[i] = buffer + i;
     }
index 6c04dfe8aa1b36e4ab4c9909c77e9cd26b74e9d7..cb9333ae0087671de530b5a08286e0d4057f0ad2 100644 (file)
@@ -19,10 +19,10 @@ typedef struct {
   struct jpeg_color_deconverter pub; /* public fields */
 
   /* Private state for YCC->RGB conversion */
-  int * Cr_r_tab;              /* => table for Cr to R conversion */
-  int * Cb_b_tab;              /* => table for Cb to B conversion */
-  INT32 * Cr_g_tab;            /* => table for Cr to G conversion */
-  INT32 * Cb_g_tab;            /* => table for Cb to G conversion */
+  int * Cr_r_tab;    /* => table for Cr to R conversion */
+  int * Cb_b_tab;    /* => table for Cb to B conversion */
+  INT32 * Cr_g_tab;    /* => table for Cr to G conversion */
+  INT32 * Cb_g_tab;    /* => table for Cb to G conversion */
 } my_color_deconverter;
 
 typedef my_color_deconverter * my_cconvert_ptr;
@@ -34,9 +34,9 @@ typedef my_color_deconverter * my_cconvert_ptr;
  * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
  * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
  * The conversion equations to be implemented are therefore
- *     R = Y                + 1.40200 * Cr
- *     G = Y - 0.34414 * Cb - 0.71414 * Cr
- *     B = Y + 1.77200 * Cb
+ *  R = Y                + 1.40200 * Cr
+ *  G = Y - 0.34414 * Cb - 0.71414 * Cr
+ *  B = Y + 1.77200 * Cb
  * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
  * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
  *
@@ -57,9 +57,9 @@ typedef my_color_deconverter * my_cconvert_ptr;
  * together before rounding.
  */
 
-#define SCALEBITS      16      /* speediest right-shift on some machines */
-#define ONE_HALF       ((INT32) 1 << (SCALEBITS-1))
-#define FIX(x)         ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+#define SCALEBITS  16  /* speediest right-shift on some machines */
+#define ONE_HALF  ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)    ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
 
 
 /*
@@ -76,26 +76,26 @@ build_ycc_rgb_table (j_decompress_ptr cinfo)
 
   cconvert->Cr_r_tab = (int *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(int));
+        (MAXJSAMPLE+1) * SIZEOF(int));
   cconvert->Cb_b_tab = (int *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(int));
+        (MAXJSAMPLE+1) * SIZEOF(int));
   cconvert->Cr_g_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(INT32));
+        (MAXJSAMPLE+1) * SIZEOF(INT32));
   cconvert->Cb_g_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(INT32));
+        (MAXJSAMPLE+1) * SIZEOF(INT32));
 
   for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
     /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
     /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
     /* Cr=>R value is nearest int to 1.40200 * x */
     cconvert->Cr_r_tab[i] = (int)
-                   RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+        RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
     /* Cb=>B value is nearest int to 1.77200 * x */
     cconvert->Cb_b_tab[i] = (int)
-                   RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+        RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
     /* Cr=>G value is scaled-up -0.71414 * x */
     cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
     /* Cb=>G value is scaled-up -0.34414 * x */
@@ -118,8 +118,8 @@ build_ycc_rgb_table (j_decompress_ptr cinfo)
 
 METHODDEF(void)
 ycc_rgb_convert (j_decompress_ptr cinfo,
-                JSAMPIMAGE input_buf, JDIMENSION input_row,
-                JSAMPARRAY output_buf, int num_rows)
+     JSAMPIMAGE input_buf, JDIMENSION input_row,
+     JSAMPARRAY output_buf, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int y, cb, cr;
@@ -148,8 +148,8 @@ ycc_rgb_convert (j_decompress_ptr cinfo,
       /* Range-limiting is essential due to noise introduced by DCT losses. */
       outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
       outptr[RGB_GREEN] = range_limit[y +
-                             ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
-                                                SCALEBITS))];
+            ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+             SCALEBITS))];
       outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
       outptr += RGB_PIXELSIZE;
     }
@@ -167,8 +167,8 @@ ycc_rgb_convert (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 null_convert (j_decompress_ptr cinfo,
-             JSAMPIMAGE input_buf, JDIMENSION input_row,
-             JSAMPARRAY output_buf, int num_rows)
+        JSAMPIMAGE input_buf, JDIMENSION input_row,
+        JSAMPARRAY output_buf, int num_rows)
 {
   register JSAMPROW inptr, outptr;
   register JDIMENSION count;
@@ -181,8 +181,8 @@ null_convert (j_decompress_ptr cinfo,
       inptr = input_buf[ci][input_row];
       outptr = output_buf[0] + ci;
       for (count = num_cols; count > 0; count--) {
-       *outptr = *inptr++;     /* needn't bother with GETJSAMPLE() here */
-       outptr += num_components;
+  *outptr = *inptr++;  /* needn't bother with GETJSAMPLE() here */
+  outptr += num_components;
       }
     }
     input_row++;
@@ -199,11 +199,11 @@ null_convert (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 grayscale_convert (j_decompress_ptr cinfo,
-                  JSAMPIMAGE input_buf, JDIMENSION input_row,
-                  JSAMPARRAY output_buf, int num_rows)
+       JSAMPIMAGE input_buf, JDIMENSION input_row,
+       JSAMPARRAY output_buf, int num_rows)
 {
   jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
-                   num_rows, cinfo->output_width);
+        num_rows, cinfo->output_width);
 }
 
 
@@ -215,8 +215,8 @@ grayscale_convert (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 gray_rgb_convert (j_decompress_ptr cinfo,
-                 JSAMPIMAGE input_buf, JDIMENSION input_row,
-                 JSAMPARRAY output_buf, int num_rows)
+      JSAMPIMAGE input_buf, JDIMENSION input_row,
+      JSAMPARRAY output_buf, int num_rows)
 {
   register JSAMPROW inptr, outptr;
   register JDIMENSION col;
@@ -243,8 +243,8 @@ gray_rgb_convert (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 ycck_cmyk_convert (j_decompress_ptr cinfo,
-                  JSAMPIMAGE input_buf, JDIMENSION input_row,
-                  JSAMPARRAY output_buf, int num_rows)
+       JSAMPIMAGE input_buf, JDIMENSION input_row,
+       JSAMPARRAY output_buf, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int y, cb, cr;
@@ -272,13 +272,13 @@ ycck_cmyk_convert (j_decompress_ptr cinfo,
       cb = GETJSAMPLE(inptr1[col]);
       cr = GETJSAMPLE(inptr2[col]);
       /* Range-limiting is essential due to noise introduced by DCT losses. */
-      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];  /* red */
-      outptr[1] = range_limit[MAXJSAMPLE - (y +                        /* green */
-                             ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
-                                                SCALEBITS)))];
-      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];  /* blue */
+      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];  /* red */
+      outptr[1] = range_limit[MAXJSAMPLE - (y +      /* green */
+            ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+             SCALEBITS)))];
+      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];  /* blue */
       /* K passes through unchanged */
-      outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */
+      outptr[3] = inptr3[col];  /* don't need GETJSAMPLE here */
       outptr += 4;
     }
   }
@@ -292,6 +292,7 @@ ycck_cmyk_convert (j_decompress_ptr cinfo,
 METHODDEF(void)
 start_pass_dcolor (j_decompress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work needed */
 }
 
@@ -308,7 +309,7 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
 
   cconvert = (my_cconvert_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_color_deconverter));
+        SIZEOF(my_color_deconverter));
   cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
   cconvert->pub.start_pass = start_pass_dcolor;
 
@@ -331,7 +332,7 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
       ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
     break;
 
-  default:                     /* JCS_UNKNOWN can be anything */
+  default:      /* JCS_UNKNOWN can be anything */
     if (cinfo->num_components < 1)
       ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
     break;
@@ -346,11 +347,11 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
   case JCS_GRAYSCALE:
     cinfo->out_color_components = 1;
     if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
-       cinfo->jpeg_color_space == JCS_YCbCr) {
+  cinfo->jpeg_color_space == JCS_YCbCr) {
       cconvert->pub.color_convert = grayscale_convert;
       /* For color->grayscale conversion, only the Y (0) component is needed */
       for (ci = 1; ci < cinfo->num_components; ci++)
-       cinfo->comp_info[ci].component_needed = FALSE;
+  cinfo->comp_info[ci].component_needed = FALSE;
     } else
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     break;
@@ -384,7 +385,7 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
     if (cinfo->out_color_space == cinfo->jpeg_color_space) {
       cinfo->out_color_components = cinfo->num_components;
       cconvert->pub.color_convert = null_convert;
-    } else                     /* unsupported non-null conversion */
+    } else      /* unsupported non-null conversion */
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
     break;
   }
index 37444468c2370a71f1317a50ddaf3287e3e04969..d5508698c135f566790fa001ef95695c1dd7ac5b 100644 (file)
  * (ie, box filtering), we can save some work in color conversion by
  * calculating all the output pixels corresponding to a pair of chroma
  * samples at one time.  In the conversion equations
- *     R = Y           + K1 * Cr
- *     G = Y + K2 * Cb + K3 * Cr
- *     B = Y + K4 * Cb
+ *  R = Y           + K1 * Cr
+ *  G = Y + K2 * Cb + K3 * Cr
+ *  B = Y + K4 * Cb
  * only the Y term varies among the group of pixels corresponding to a pair
  * of chroma samples, so the rest of the terms can be calculated just once.
  * At typical sampling ratios, this eliminates half or three-quarters of the
  * multiplications needed for color conversion.
  *
  * This file currently provides implementations for the following cases:
- *     YCbCr => RGB color conversion only.
- *     Sampling ratios of 2h1v or 2h2v.
- *     No scaling needed at upsample time.
- *     Corner-aligned (non-CCIR601) sampling alignment.
+ *  YCbCr => RGB color conversion only.
+ *  Sampling ratios of 2h1v or 2h2v.
+ *  No scaling needed at upsample time.
+ *  Corner-aligned (non-CCIR601) sampling alignment.
  * Other special cases could be added, but in most applications these are
  * the only common cases.  (For uncommon cases we fall back on the more
  * general code in jdsample.c and jdcolor.c.)
 /* Private subobject */
 
 typedef struct {
-  struct jpeg_upsampler pub;   /* public fields */
+  struct jpeg_upsampler pub;  /* public fields */
 
   /* Pointer to routine to do actual upsampling/conversion of one row group */
   JMETHOD(void, upmethod, (j_decompress_ptr cinfo,
-                          JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
-                          JSAMPARRAY output_buf));
+         JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+         JSAMPARRAY output_buf));
 
   /* Private state for YCC->RGB conversion */
-  int * Cr_r_tab;              /* => table for Cr to R conversion */
-  int * Cb_b_tab;              /* => table for Cb to B conversion */
-  INT32 * Cr_g_tab;            /* => table for Cr to G conversion */
-  INT32 * Cb_g_tab;            /* => table for Cb to G conversion */
+  int * Cr_r_tab;    /* => table for Cr to R conversion */
+  int * Cb_b_tab;    /* => table for Cb to B conversion */
+  INT32 * Cr_g_tab;    /* => table for Cr to G conversion */
+  INT32 * Cb_g_tab;    /* => table for Cb to G conversion */
 
   /* For 2:1 vertical sampling, we produce two output rows at a time.
    * We need a "spare" row buffer to hold the second output row if the
@@ -61,17 +61,17 @@ typedef struct {
    * to discard the dummy last row if the image height is odd.
    */
   JSAMPROW spare_row;
-  boolean spare_full;          /* T if spare buffer is occupied */
+  boolean spare_full;    /* T if spare buffer is occupied */
 
-  JDIMENSION out_row_width;    /* samples per output row */
-  JDIMENSION rows_to_go;       /* counts rows remaining in image */
+  JDIMENSION out_row_width;  /* samples per output row */
+  JDIMENSION rows_to_go;  /* counts rows remaining in image */
 } my_upsampler;
 
 typedef my_upsampler * my_upsample_ptr;
 
-#define SCALEBITS      16      /* speediest right-shift on some machines */
-#define ONE_HALF       ((INT32) 1 << (SCALEBITS-1))
-#define FIX(x)         ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+#define SCALEBITS  16  /* speediest right-shift on some machines */
+#define ONE_HALF  ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)    ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
 
 
 /*
@@ -89,26 +89,26 @@ build_ycc_rgb_table (j_decompress_ptr cinfo)
 
   upsample->Cr_r_tab = (int *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(int));
+        (MAXJSAMPLE+1) * SIZEOF(int));
   upsample->Cb_b_tab = (int *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(int));
+        (MAXJSAMPLE+1) * SIZEOF(int));
   upsample->Cr_g_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(INT32));
+        (MAXJSAMPLE+1) * SIZEOF(INT32));
   upsample->Cb_g_tab = (INT32 *)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               (MAXJSAMPLE+1) * SIZEOF(INT32));
+        (MAXJSAMPLE+1) * SIZEOF(INT32));
 
   for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
     /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
     /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
     /* Cr=>R value is nearest int to 1.40200 * x */
     upsample->Cr_r_tab[i] = (int)
-                   RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+        RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
     /* Cb=>B value is nearest int to 1.77200 * x */
     upsample->Cb_b_tab[i] = (int)
-                   RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+        RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
     /* Cr=>G value is scaled-up -0.71414 * x */
     upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
     /* Cb=>G value is scaled-up -0.34414 * x */
@@ -142,20 +142,22 @@ start_pass_merged_upsample (j_decompress_ptr cinfo)
 
 METHODDEF(void)
 merged_2v_upsample (j_decompress_ptr cinfo,
-                   JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail,
-                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                   JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 /* 2:1 vertical sampling case: may need a spare row. */
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   JSAMPROW work_ptrs[2];
-  JDIMENSION num_rows;         /* number of rows returned to caller */
+  JDIMENSION num_rows;    /* number of rows returned to caller */
+
+  in_row_groups_avail = 0;
 
   if (upsample->spare_full) {
     /* If we have a spare row saved from a previous cycle, just return it. */
     jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
-                     1, upsample->out_row_width);
+          1, upsample->out_row_width);
     num_rows = 1;
     upsample->spare_full = FALSE;
   } else {
@@ -191,17 +193,20 @@ merged_2v_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 merged_1v_upsample (j_decompress_ptr cinfo,
-                   JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail,
-                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                   JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 /* 1:1 vertical sampling case: much easier, never need a spare row. */
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
 
+  in_row_groups_avail = 0;
+  out_rows_avail = 0;
+
   /* Just do the upsampling. */
   (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
-                        output_buf + *out_row_ctr);
+       output_buf + *out_row_ctr);
   /* Adjust counts */
   (*out_row_ctr)++;
   (*in_row_group_ctr)++;
@@ -224,8 +229,8 @@ merged_1v_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 h2v1_merged_upsample (j_decompress_ptr cinfo,
-                     JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
-                     JSAMPARRAY output_buf)
+          JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+          JSAMPARRAY output_buf)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   register int y, cred, cgreen, cblue;
@@ -286,8 +291,8 @@ h2v1_merged_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 h2v2_merged_upsample (j_decompress_ptr cinfo,
-                     JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
-                     JSAMPARRAY output_buf)
+          JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+          JSAMPARRAY output_buf)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   register int y, cred, cgreen, cblue;
@@ -373,7 +378,7 @@ jinit_merged_upsampler (j_decompress_ptr cinfo)
 
   upsample = (my_upsample_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_upsampler));
+        SIZEOF(my_upsampler));
   cinfo->upsample = (struct jpeg_upsampler *) upsample;
   upsample->pub.start_pass = start_pass_merged_upsample;
   upsample->pub.need_context_rows = FALSE;
@@ -386,7 +391,7 @@ jinit_merged_upsampler (j_decompress_ptr cinfo)
     /* Allocate a spare row buffer */
     upsample->spare_row = (JSAMPROW)
       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-               (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
+    (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
   } else {
     upsample->pub.upsample = merged_1v_upsample;
     upsample->upmethod = h2v1_merged_upsample;
index 571563d728e7135996cc982b8f8dfba3d69a9846..4226077b9ab477a15d167a708586ef691b820490 100644 (file)
@@ -31,12 +31,12 @@ typedef struct {
    * For two-pass color quantization, we need a full-image buffer;
    * for one-pass operation, a strip buffer is sufficient.
    */
-  jvirt_sarray_ptr whole_image;        /* virtual array, or NULL if one-pass */
-  JSAMPARRAY buffer;           /* strip buffer, or current strip of virtual */
-  JDIMENSION strip_height;     /* buffer size in rows */
+  jvirt_sarray_ptr whole_image;  /* virtual array, or NULL if one-pass */
+  JSAMPARRAY buffer;    /* strip buffer, or current strip of virtual */
+  JDIMENSION strip_height;  /* buffer size in rows */
   /* for two-pass mode only: */
-  JDIMENSION starting_row;     /* row # of first row in current strip */
-  JDIMENSION next_row;         /* index of next row to fill/empty in strip */
+  JDIMENSION starting_row;  /* row # of first row in current strip */
+  JDIMENSION next_row;    /* index of next row to fill/empty in strip */
 } my_post_controller;
 
 typedef my_post_controller * my_post_ptr;
@@ -44,24 +44,24 @@ typedef my_post_controller * my_post_ptr;
 
 /* Forward declarations */
 METHODDEF(void) post_process_1pass
-       JPP((j_decompress_ptr cinfo,
-            JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-            JDIMENSION in_row_groups_avail,
-            JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-            JDIMENSION out_rows_avail));
+  JPP((j_decompress_ptr cinfo,
+       JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+       JDIMENSION in_row_groups_avail,
+       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+       JDIMENSION out_rows_avail));
 #ifdef QUANT_2PASS_SUPPORTED
 METHODDEF(void) post_process_prepass
-       JPP((j_decompress_ptr cinfo,
-            JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-            JDIMENSION in_row_groups_avail,
-            JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-            JDIMENSION out_rows_avail));
+  JPP((j_decompress_ptr cinfo,
+       JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+       JDIMENSION in_row_groups_avail,
+       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+       JDIMENSION out_rows_avail));
 METHODDEF(void) post_process_2pass
-       JPP((j_decompress_ptr cinfo,
-            JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-            JDIMENSION in_row_groups_avail,
-            JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-            JDIMENSION out_rows_avail));
+  JPP((j_decompress_ptr cinfo,
+       JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+       JDIMENSION in_row_groups_avail,
+       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+       JDIMENSION out_rows_avail));
 #endif
 
 
@@ -84,9 +84,9 @@ start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
        * allocate a strip buffer.  Use the virtual-array buffer as workspace.
        */
       if (post->buffer == NULL) {
-       post->buffer = (*cinfo->mem->access_virt_sarray)
-         ((j_common_ptr) cinfo, post->whole_image,
-          (JDIMENSION) 0, post->strip_height, TRUE);
+  post->buffer = (*cinfo->mem->access_virt_sarray)
+    ((j_common_ptr) cinfo, post->whole_image,
+     (JDIMENSION) 0, post->strip_height, TRUE);
       }
     } else {
       /* For single-pass processing without color quantization,
@@ -124,10 +124,10 @@ start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
 
 METHODDEF(void)
 post_process_1pass (j_decompress_ptr cinfo,
-                   JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail,
-                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                   JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 {
   my_post_ptr post = (my_post_ptr) cinfo->post;
   JDIMENSION num_rows, max_rows;
@@ -139,11 +139,11 @@ post_process_1pass (j_decompress_ptr cinfo,
     max_rows = post->strip_height;
   num_rows = 0;
   (*cinfo->upsample->upsample) (cinfo,
-               input_buf, in_row_group_ctr, in_row_groups_avail,
-               post->buffer, &num_rows, max_rows);
+    input_buf, in_row_group_ctr, in_row_groups_avail,
+    post->buffer, &num_rows, max_rows);
   /* Quantize and emit data. */
   (*cinfo->cquantize->color_quantize) (cinfo,
-               post->buffer, output_buf + *out_row_ctr, (int) num_rows);
+    post->buffer, output_buf + *out_row_ctr, (int) num_rows);
   *out_row_ctr += num_rows;
 }
 
@@ -156,33 +156,35 @@ post_process_1pass (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 post_process_prepass (j_decompress_ptr cinfo,
-                     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                     JDIMENSION in_row_groups_avail,
-                     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                     JDIMENSION out_rows_avail)
+          JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+          JDIMENSION in_row_groups_avail,
+          JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+          JDIMENSION out_rows_avail)
 {
   my_post_ptr post = (my_post_ptr) cinfo->post;
   JDIMENSION old_next_row, num_rows;
+  output_buf = 0;
+  out_rows_avail = 0;
 
   /* Reposition virtual buffer if at start of strip. */
   if (post->next_row == 0) {
     post->buffer = (*cinfo->mem->access_virt_sarray)
-       ((j_common_ptr) cinfo, post->whole_image,
-        post->starting_row, post->strip_height, TRUE);
+  ((j_common_ptr) cinfo, post->whole_image,
+   post->starting_row, post->strip_height, TRUE);
   }
 
   /* Upsample some data (up to a strip height's worth). */
   old_next_row = post->next_row;
   (*cinfo->upsample->upsample) (cinfo,
-               input_buf, in_row_group_ctr, in_row_groups_avail,
-               post->buffer, &post->next_row, post->strip_height);
+    input_buf, in_row_group_ctr, in_row_groups_avail,
+    post->buffer, &post->next_row, post->strip_height);
 
   /* Allow quantizer to scan new data.  No data is emitted, */
   /* but we advance out_row_ctr so outer loop can tell when we're done. */
   if (post->next_row > old_next_row) {
     num_rows = post->next_row - old_next_row;
     (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
-                                        (JSAMPARRAY) NULL, (int) num_rows);
+           (JSAMPARRAY) NULL, (int) num_rows);
     *out_row_ctr += num_rows;
   }
 
@@ -200,19 +202,22 @@ post_process_prepass (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 post_process_2pass (j_decompress_ptr cinfo,
-                   JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-                   JDIMENSION in_row_groups_avail,
-                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-                   JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 {
   my_post_ptr post = (my_post_ptr) cinfo->post;
   JDIMENSION num_rows, max_rows;
 
+  input_buf = 0;
+  in_row_group_ctr = 0;
+  in_row_groups_avail = 0;
   /* Reposition virtual buffer if at start of strip. */
   if (post->next_row == 0) {
     post->buffer = (*cinfo->mem->access_virt_sarray)
-       ((j_common_ptr) cinfo, post->whole_image,
-        post->starting_row, post->strip_height, FALSE);
+  ((j_common_ptr) cinfo, post->whole_image,
+   post->starting_row, post->strip_height, FALSE);
   }
 
   /* Determine number of rows to emit. */
@@ -227,8 +232,8 @@ post_process_2pass (j_decompress_ptr cinfo,
 
   /* Quantize and emit data. */
   (*cinfo->cquantize->color_quantize) (cinfo,
-               post->buffer + post->next_row, output_buf + *out_row_ctr,
-               (int) num_rows);
+    post->buffer + post->next_row, output_buf + *out_row_ctr,
+    (int) num_rows);
   *out_row_ctr += num_rows;
 
   /* Advance if we filled the strip. */
@@ -253,11 +258,11 @@ jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 
   post = (my_post_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_post_controller));
+        SIZEOF(my_post_controller));
   cinfo->post = (struct jpeg_d_post_controller *) post;
   post->pub.start_pass = start_pass_dpost;
-  post->whole_image = NULL;    /* flag for no virtual arrays */
-  post->buffer = NULL;         /* flag for no strip buffer */
+  post->whole_image = NULL;  /* flag for no virtual arrays */
+  post->buffer = NULL;    /* flag for no strip buffer */
 
   /* Create the quantization buffer, if needed */
   if (cinfo->quantize_colors) {
@@ -271,20 +276,20 @@ jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
       /* We round up the number of rows to a multiple of the strip height. */
 #ifdef QUANT_2PASS_SUPPORTED
       post->whole_image = (*cinfo->mem->request_virt_sarray)
-       ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
-        cinfo->output_width * cinfo->out_color_components,
-        (JDIMENSION) jround_up((long) cinfo->output_height,
-                               (long) post->strip_height),
-        post->strip_height);
+  ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+   cinfo->output_width * cinfo->out_color_components,
+   (JDIMENSION) jround_up((long) cinfo->output_height,
+        (long) post->strip_height),
+   post->strip_height);
 #else
       ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
 #endif /* QUANT_2PASS_SUPPORTED */
     } else {
       /* One-pass color quantization: just make a strip buffer. */
       post->buffer = (*cinfo->mem->alloc_sarray)
-       ((j_common_ptr) cinfo, JPOOL_IMAGE,
-        cinfo->output_width * cinfo->out_color_components,
-        post->strip_height);
+  ((j_common_ptr) cinfo, JPOOL_IMAGE,
+   cinfo->output_width * cinfo->out_color_components,
+   post->strip_height);
     }
   }
 }
index 80ffefb2a1ccf5ddc1530b921df0eef6e3e45c18..f42cc33301c02c1ca3cb0322f0dbfd216dde165e 100644 (file)
 
 /* Pointer to routine to upsample a single component */
 typedef JMETHOD(void, upsample1_ptr,
-               (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-                JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
+    (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
 
 /* Private subobject */
 
 typedef struct {
-  struct jpeg_upsampler pub;   /* public fields */
+  struct jpeg_upsampler pub;  /* public fields */
 
   /* Color conversion buffer.  When using separate upsampling and color
    * conversion steps, this buffer holds one upsampled row group until it
@@ -45,8 +45,8 @@ typedef struct {
   /* Per-component upsampling method pointers */
   upsample1_ptr methods[MAX_COMPONENTS];
 
-  int next_row_out;            /* counts rows emitted from color_buf */
-  JDIMENSION rows_to_go;       /* counts rows remaining in image */
+  int next_row_out;    /* counts rows emitted from color_buf */
+  JDIMENSION rows_to_go;  /* counts rows remaining in image */
 
   /* Height of an input row group for each component. */
   int rowgroup_height[MAX_COMPONENTS];
@@ -87,26 +87,27 @@ start_pass_upsample (j_decompress_ptr cinfo)
 
 METHODDEF(void)
 sep_upsample (j_decompress_ptr cinfo,
-             JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
-             JDIMENSION in_row_groups_avail,
-             JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
-             JDIMENSION out_rows_avail)
+        JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+        JDIMENSION in_row_groups_avail,
+        JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+        JDIMENSION out_rows_avail)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   int ci;
   jpeg_component_info * compptr;
   JDIMENSION num_rows;
 
+  in_row_groups_avail = 0;
   /* Fill the conversion buffer, if it's empty */
   if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-        ci++, compptr++) {
+   ci++, compptr++) {
       /* Invoke per-component upsample method.  Notice we pass a POINTER
        * to color_buf[ci], so that fullsize_upsample can change it.
        */
       (*upsample->methods[ci]) (cinfo, compptr,
-       input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
-       upsample->color_buf + ci);
+  input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
+  upsample->color_buf + ci);
     }
     upsample->next_row_out = 0;
   }
@@ -126,9 +127,9 @@ sep_upsample (j_decompress_ptr cinfo,
     num_rows = out_rows_avail;
 
   (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
-                                    (JDIMENSION) upsample->next_row_out,
-                                    output_buf + *out_row_ctr,
-                                    (int) num_rows);
+             (JDIMENSION) upsample->next_row_out,
+             output_buf + *out_row_ctr,
+             (int) num_rows);
 
   /* Adjust counts */
   *out_row_ctr += num_rows;
@@ -155,8 +156,10 @@ sep_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-                  JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
+  cinfo = 0;
+  compptr = 0;
   *output_data_ptr = input_data;
 }
 
@@ -168,9 +171,12 @@ fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-              JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
-  *output_data_ptr = NULL;     /* safety check */
+  cinfo = 0;
+  compptr = 0;
+  input_data = 0;
+  *output_data_ptr = NULL;  /* safety check */
 }
 
 
@@ -187,7 +193,7 @@ noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-             JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+        JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
   JSAMPARRAY output_data = *output_data_ptr;
@@ -208,15 +214,15 @@ int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
     outptr = output_data[outrow];
     outend = outptr + cinfo->output_width;
     while (outptr < outend) {
-      invalue = *inptr++;      /* don't need GETJSAMPLE() here */
+      invalue = *inptr++;  /* don't need GETJSAMPLE() here */
       for (h = h_expand; h > 0; h--) {
-       *outptr++ = invalue;
+  *outptr++ = invalue;
       }
     }
     /* Generate any additional output rows by duplicating the first one */
     if (v_expand > 1) {
       jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
-                       v_expand-1, cinfo->output_width);
+      v_expand-1, cinfo->output_width);
     }
     inrow++;
     outrow += v_expand;
@@ -231,7 +237,7 @@ int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-              JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr, outptr;
@@ -239,12 +245,13 @@ h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
   JSAMPROW outend;
   int inrow;
 
+  compptr = 0;
   for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
     inptr = input_data[inrow];
     outptr = output_data[inrow];
     outend = outptr + cinfo->output_width;
     while (outptr < outend) {
-      invalue = *inptr++;      /* don't need GETJSAMPLE() here */
+      invalue = *inptr++;  /* don't need GETJSAMPLE() here */
       *outptr++ = invalue;
       *outptr++ = invalue;
     }
@@ -259,7 +266,7 @@ h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-              JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr, outptr;
@@ -267,18 +274,19 @@ h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
   JSAMPROW outend;
   int inrow, outrow;
 
+  compptr = 0;
   inrow = outrow = 0;
   while (outrow < cinfo->max_v_samp_factor) {
     inptr = input_data[inrow];
     outptr = output_data[outrow];
     outend = outptr + cinfo->output_width;
     while (outptr < outend) {
-      invalue = *inptr++;      /* don't need GETJSAMPLE() here */
+      invalue = *inptr++;  /* don't need GETJSAMPLE() here */
       *outptr++ = invalue;
       *outptr++ = invalue;
     }
     jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
-                     1, cinfo->output_width);
+          1, cinfo->output_width);
     inrow++;
     outrow += 2;
   }
@@ -302,7 +310,7 @@ h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr, outptr;
@@ -343,7 +351,7 @@ h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-                    JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+         JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr0, inptr1, outptr;
@@ -360,10 +368,10 @@ h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
     for (v = 0; v < 2; v++) {
       /* inptr0 points to nearest input row, inptr1 points to next nearest */
       inptr0 = input_data[inrow];
-      if (v == 0)              /* next nearest is row above */
-       inptr1 = input_data[inrow-1];
-      else                     /* next nearest is row below */
-       inptr1 = input_data[inrow+1];
+      if (v == 0)    /* next nearest is row above */
+  inptr1 = input_data[inrow-1];
+      else      /* next nearest is row below */
+  inptr1 = input_data[inrow+1];
       outptr = output_data[outrow++];
 
       /* Special case for first column */
@@ -374,12 +382,12 @@ h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
       lastcolsum = thiscolsum; thiscolsum = nextcolsum;
 
       for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
-       /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
-       /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
-       nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
-       *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
-       *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
-       lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+  /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
+  /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
+  nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+  *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+  *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+  lastcolsum = thiscolsum; thiscolsum = nextcolsum;
       }
 
       /* Special case for last column */
@@ -406,13 +414,13 @@ jinit_upsampler (j_decompress_ptr cinfo)
 
   upsample = (my_upsample_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_upsampler));
+        SIZEOF(my_upsampler));
   cinfo->upsample = (struct jpeg_upsampler *) upsample;
   upsample->pub.start_pass = start_pass_upsample;
   upsample->pub.upsample = sep_upsample;
   upsample->pub.need_context_rows = FALSE; /* until we find out differently */
 
-  if (cinfo->CCIR601_sampling) /* this isn't supported */
+  if (cinfo->CCIR601_sampling)  /* this isn't supported */
     ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
 
   /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
@@ -429,9 +437,9 @@ jinit_upsampler (j_decompress_ptr cinfo)
      * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
      */
     h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
-                cinfo->min_DCT_scaled_size;
+     cinfo->min_DCT_scaled_size;
     v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
-                cinfo->min_DCT_scaled_size;
+     cinfo->min_DCT_scaled_size;
     h_out_group = cinfo->max_h_samp_factor;
     v_out_group = cinfo->max_v_samp_factor;
     upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
@@ -445,22 +453,22 @@ jinit_upsampler (j_decompress_ptr cinfo)
       upsample->methods[ci] = fullsize_upsample;
       need_buffer = FALSE;
     } else if (h_in_group * 2 == h_out_group &&
-              v_in_group == v_out_group) {
+         v_in_group == v_out_group) {
       /* Special cases for 2h1v upsampling */
       if (do_fancy && compptr->downsampled_width > 2)
-       upsample->methods[ci] = h2v1_fancy_upsample;
+  upsample->methods[ci] = h2v1_fancy_upsample;
       else
-       upsample->methods[ci] = h2v1_upsample;
+  upsample->methods[ci] = h2v1_upsample;
     } else if (h_in_group * 2 == h_out_group &&
-              v_in_group * 2 == v_out_group) {
+         v_in_group * 2 == v_out_group) {
       /* Special cases for 2h2v upsampling */
       if (do_fancy && compptr->downsampled_width > 2) {
-       upsample->methods[ci] = h2v2_fancy_upsample;
-       upsample->pub.need_context_rows = TRUE;
+  upsample->methods[ci] = h2v2_fancy_upsample;
+  upsample->pub.need_context_rows = TRUE;
       } else
-       upsample->methods[ci] = h2v2_upsample;
+  upsample->methods[ci] = h2v2_upsample;
     } else if ((h_out_group % h_in_group) == 0 &&
-              (v_out_group % v_in_group) == 0) {
+         (v_out_group % v_in_group) == 0) {
       /* Generic integral-factors upsampling method */
       upsample->methods[ci] = int_upsample;
       upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
@@ -469,10 +477,10 @@ jinit_upsampler (j_decompress_ptr cinfo)
       ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
     if (need_buffer) {
       upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
-       ((j_common_ptr) cinfo, JPOOL_IMAGE,
-        (JDIMENSION) jround_up((long) cinfo->output_width,
-                               (long) cinfo->max_h_samp_factor),
-        (JDIMENSION) cinfo->max_v_samp_factor);
+  ((j_common_ptr) cinfo, JPOOL_IMAGE,
+   (JDIMENSION) jround_up((long) cinfo->output_width,
+        (long) cinfo->max_h_samp_factor),
+   (JDIMENSION) cinfo->max_v_samp_factor);
     }
   }
 }
index eb8c337725fd85f289b04eebbea8549d90d53c77..7e53479f3d93c38b858a7ec05fd3dafcd6e01419 100644 (file)
@@ -18,9 +18,9 @@
 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
-#include "jmemsys.h"           /* import the system-dependent declarations */
+#include "jmemsys.h"    /* import the system-dependent declarations */
 
-#ifndef HAVE_STDLIB_H          /* <stdlib.h> should declare malloc(),free() */
+#ifndef HAVE_STDLIB_H    /* <stdlib.h> should declare malloc(),free() */
 extern void * malloc JPP((size_t size));
 extern void free JPP((void *ptr));
 #endif
@@ -34,12 +34,15 @@ extern void free JPP((void *ptr));
 GLOBAL(void *)
 jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
 {
+  cinfo = 0;
   return (void *) malloc(sizeofobject);
 }
 
 GLOBAL(void)
 jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
 {
+  cinfo = 0;
+  sizeofobject = 0;
   free(object);
 }
 
@@ -54,12 +57,15 @@ jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
 GLOBAL(void FAR *)
 jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
 {
+  cinfo = 0;
   return (void FAR *) malloc(sizeofobject);
 }
 
 GLOBAL(void)
 jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
 {
+  cinfo = 0;
+  sizeofobject = 0;
   free(object);
 }
 
@@ -71,8 +77,11 @@ jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
 
 GLOBAL(long)
 jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
-                   long max_bytes_needed, long already_allocated)
+        long max_bytes_needed, long already_allocated)
 {
+  cinfo = 0;
+  min_bytes_needed = 0;
+  already_allocated = 0;
   return max_bytes_needed;
 }
 
@@ -85,8 +94,10 @@ jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
 
 GLOBAL(void)
 jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
-                        long total_bytes_needed)
+       long total_bytes_needed)
 {
+  info = 0;
+  total_bytes_needed = 0;
   ERREXIT(cinfo, JERR_NO_BACKING_STORE);
 }
 
@@ -99,11 +110,13 @@ jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
 GLOBAL(long)
 jpeg_mem_init (j_common_ptr cinfo)
 {
-  return 0;                    /* just set max_memory_to_use to 0 */
+  cinfo = 0;
+  return 0;      /* just set max_memory_to_use to 0 */
 }
 
 GLOBAL(void)
 jpeg_mem_term (j_common_ptr cinfo)
 {
+  cinfo = 0;
   /* no work */
 }
index b2f96aa15d25dd722c55b955bf0e475eb3160c15..2ec9a41ed4c7c5fc81e78485098aaf5d1c9d107a 100644 (file)
@@ -68,9 +68,9 @@
  * table in both directions.
  */
 
-#define ODITHER_SIZE  16       /* dimension of dither matrix */
+#define ODITHER_SIZE  16  /* dimension of dither matrix */
 /* NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break */
-#define ODITHER_CELLS (ODITHER_SIZE*ODITHER_SIZE)      /* # cells in matrix */
+#define ODITHER_CELLS (ODITHER_SIZE*ODITHER_SIZE)  /* # cells in matrix */
 #define ODITHER_MASK  (ODITHER_SIZE-1) /* mask for wrapping around counters */
 
 typedef int ODITHER_MATRIX[ODITHER_SIZE][ODITHER_SIZE];
@@ -105,8 +105,8 @@ static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = {
  * Errors are accumulated into the array fserrors[], at a resolution of
  * 1/16th of a pixel count.  The error at a given pixel is propagated
  * to its not-yet-processed neighbors using the standard F-S fractions,
- *             ...     (here)  7/16
- *             3/16    5/16    1/16
+ *    ...  (here)  7/16
+ *    3/16  5/16  1/16
  * We work left-to-right on even rows, right-to-left on odd rows.
  *
  * We can get away with a single array (holding one row's worth of errors)
@@ -125,43 +125,43 @@ static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = {
  */
 
 #if BITS_IN_JSAMPLE == 8
-typedef INT16 FSERROR;         /* 16 bits should be enough */
-typedef int LOCFSERROR;                /* use 'int' for calculation temps */
+typedef INT16 FSERROR;    /* 16 bits should be enough */
+typedef int LOCFSERROR;    /* use 'int' for calculation temps */
 #else
-typedef INT32 FSERROR;         /* may need more than 16 bits */
-typedef INT32 LOCFSERROR;      /* be sure calculation temps are big enough */
+typedef INT32 FSERROR;    /* may need more than 16 bits */
+typedef INT32 LOCFSERROR;  /* be sure calculation temps are big enough */
 #endif
 
-typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
+typedef FSERROR FAR *FSERRPTR;  /* pointer to error array (in FAR storage!) */
 
 
 /* Private subobject */
 
-#define MAX_Q_COMPS 4          /* max components I can handle */
+#define MAX_Q_COMPS 4    /* max components I can handle */
 
 typedef struct {
   struct jpeg_color_quantizer pub; /* public fields */
 
   /* Initially allocated colormap is saved here */
-  JSAMPARRAY sv_colormap;      /* The color map as a 2-D pixel array */
-  int sv_actual;               /* number of entries in use */
+  JSAMPARRAY sv_colormap;  /* The color map as a 2-D pixel array */
+  int sv_actual;    /* number of entries in use */
 
-  JSAMPARRAY colorindex;       /* Precomputed mapping for speed */
+  JSAMPARRAY colorindex;  /* Precomputed mapping for speed */
   /* colorindex[i][j] = index of color closest to pixel value j in component i,
    * premultiplied as described above.  Since colormap indexes must fit into
    * JSAMPLEs, the entries of this array will too.
    */
-  boolean is_padded;           /* is the colorindex padded for odither? */
+  boolean is_padded;    /* is the colorindex padded for odither? */
 
-  int Ncolors[MAX_Q_COMPS];    /* # of values alloced to each component */
+  int Ncolors[MAX_Q_COMPS];  /* # of values alloced to each component */
 
   /* Variables for ordered dithering */
-  int row_index;               /* cur row's vertical index in dither matrix */
+  int row_index;    /* cur row's vertical index in dither matrix */
   ODITHER_MATRIX_PTR odither[MAX_Q_COMPS]; /* one dither array per component */
 
   /* Variables for Floyd-Steinberg dithering */
   FSERRPTR fserrors[MAX_Q_COMPS]; /* accumulated errors */
-  boolean on_odd_row;          /* flag to remember which row we are on */
+  boolean on_odd_row;    /* flag to remember which row we are on */
 } my_cquantizer;
 
 typedef my_cquantizer * my_cquantize_ptr;
@@ -200,11 +200,11 @@ select_ncolors (j_decompress_ptr cinfo, int Ncolors[])
   iroot = 1;
   do {
     iroot++;
-    temp = iroot;              /* set temp = iroot ** nc */
+    temp = iroot;    /* set temp = iroot ** nc */
     for (i = 1; i < nc; i++)
       temp *= iroot;
   } while (temp <= (long) max_colors); /* repeat till iroot exceeds root */
-  iroot--;                     /* now iroot = floor(root) */
+  iroot--;      /* now iroot = floor(root) */
 
   /* Must have at least 2 color values per component */
   if (iroot < 2)
@@ -228,10 +228,10 @@ select_ncolors (j_decompress_ptr cinfo, int Ncolors[])
       j = (cinfo->out_color_space == JCS_RGB ? RGB_order[i] : i);
       /* calculate new total_colors if Ncolors[j] is incremented */
       temp = total_colors / Ncolors[j];
-      temp *= Ncolors[j]+1;    /* done in long arith to avoid oflo */
+      temp *= Ncolors[j]+1;  /* done in long arith to avoid oflo */
       if (temp > (long) max_colors)
-       break;                  /* won't fit, done with this pass */
-      Ncolors[j]++;            /* OK, apply the increment */
+  break;      /* won't fit, done with this pass */
+      Ncolors[j]++;    /* OK, apply the increment */
       total_colors = (int) temp;
       changed = TRUE;
     }
@@ -246,6 +246,8 @@ output_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
 /* Return j'th output value, where j will range from 0 to maxj */
 /* The output values must fall in 0..MAXJSAMPLE in increasing order */
 {
+  cinfo = 0;
+  ci = 0;
   /* We always provide values 0 and MAXJSAMPLE for each component;
    * any additional values are equally spaced between these limits.
    * (Forcing the upper and lower values to the limits ensures that
@@ -260,6 +262,8 @@ largest_input_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
 /* Return largest input value that should map to j'th output value */
 /* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */
 {
+  cinfo = 0;
+  ci = 0;
   /* Breakpoints are halfway between values returned by output_value */
   return (int) (((INT32) (2*j + 1) * MAXJSAMPLE + maxj) / (2*maxj));
 }
@@ -273,8 +277,8 @@ LOCAL(void)
 create_colormap (j_decompress_ptr cinfo)
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
-  JSAMPARRAY colormap;         /* Created colormap */
-  int total_colors;            /* Number of distinct output colors */
+  JSAMPARRAY colormap;    /* Created colormap */
+  int total_colors;    /* Number of distinct output colors */
   int i,j,k, nci, blksize, blkdist, ptr, val;
 
   /* Select number of colors for each component */
@@ -283,8 +287,8 @@ create_colormap (j_decompress_ptr cinfo)
   /* Report selected color counts */
   if (cinfo->out_color_components == 3)
     TRACEMS4(cinfo, 1, JTRC_QUANT_3_NCOLORS,
-            total_colors, cquantize->Ncolors[0],
-            cquantize->Ncolors[1], cquantize->Ncolors[2]);
+       total_colors, cquantize->Ncolors[0],
+       cquantize->Ncolors[1], cquantize->Ncolors[2]);
   else
     TRACEMS1(cinfo, 1, JTRC_QUANT_NCOLORS, total_colors);
 
@@ -309,12 +313,12 @@ create_colormap (j_decompress_ptr cinfo)
       val = output_value(cinfo, i, j, nci-1);
       /* Fill in all colormap entries that have this value of this component */
       for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) {
-       /* fill in blksize entries beginning at ptr */
-       for (k = 0; k < blksize; k++)
-         colormap[i][ptr+k] = (JSAMPLE) val;
+  /* fill in blksize entries beginning at ptr */
+  for (k = 0; k < blksize; k++)
+    colormap[i][ptr+k] = (JSAMPLE) val;
       }
     }
-    blkdist = blksize;         /* blksize of this color is blkdist of next */
+    blkdist = blksize;    /* blksize of this color is blkdist of next */
   }
 
   /* Save the colormap in private storage,
@@ -372,16 +376,16 @@ create_colorindex (j_decompress_ptr cinfo)
     val = 0;
     k = largest_input_value(cinfo, i, 0, nci-1);
     for (j = 0; j <= MAXJSAMPLE; j++) {
-      while (j > k)            /* advance val if past boundary */
-       k = largest_input_value(cinfo, i, ++val, nci-1);
+      while (j > k)    /* advance val if past boundary */
+  k = largest_input_value(cinfo, i, ++val, nci-1);
       /* premultiply so that no multiplication needed in main processing */
       indexptr[j] = (JSAMPLE) (val * blksize);
     }
     /* Pad at both ends if necessary */
     if (pad)
       for (j = 1; j <= MAXJSAMPLE; j++) {
-       indexptr[-j] = indexptr[0];
-       indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE];
+  indexptr[-j] = indexptr[0];
+  indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE];
       }
   }
 }
@@ -401,7 +405,7 @@ make_odither_array (j_decompress_ptr cinfo, int ncolors)
 
   odither = (ODITHER_MATRIX_PTR)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(ODITHER_MATRIX));
+        SIZEOF(ODITHER_MATRIX));
   /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1).
    * Hence the dither value for the matrix cell with fill order f
    * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1).
@@ -411,7 +415,7 @@ make_odither_array (j_decompress_ptr cinfo, int ncolors)
   for (j = 0; j < ODITHER_SIZE; j++) {
     for (k = 0; k < ODITHER_SIZE; k++) {
       num = ((INT32) (ODITHER_CELLS-1 - 2*((int)base_dither_matrix[j][k])))
-           * MAXJSAMPLE;
+      * MAXJSAMPLE;
       /* Ensure round towards zero despite C's lack of consistency
        * about rounding negative values in integer division...
        */
@@ -437,14 +441,14 @@ create_odither_tables (j_decompress_ptr cinfo)
 
   for (i = 0; i < cinfo->out_color_components; i++) {
     nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
-    odither = NULL;            /* search for matching prior component */
+    odither = NULL;    /* search for matching prior component */
     for (j = 0; j < i; j++) {
       if (nci == cquantize->Ncolors[j]) {
-       odither = cquantize->odither[j];
-       break;
+  odither = cquantize->odither[j];
+  break;
       }
     }
-    if (odither == NULL)       /* need a new table? */
+    if (odither == NULL)  /* need a new table? */
       odither = make_odither_array(cinfo, nci);
     cquantize->odither[i] = odither;
   }
@@ -457,7 +461,7 @@ create_odither_tables (j_decompress_ptr cinfo)
 
 METHODDEF(void)
 color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-               JSAMPARRAY output_buf, int num_rows)
+    JSAMPARRAY output_buf, int num_rows)
 /* General case, no dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
@@ -475,7 +479,7 @@ color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
     for (col = width; col > 0; col--) {
       pixcode = 0;
       for (ci = 0; ci < nc; ci++) {
-       pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]);
+  pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]);
       }
       *ptrout++ = (JSAMPLE) pixcode;
     }
@@ -485,7 +489,7 @@ color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
 METHODDEF(void)
 color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                JSAMPARRAY output_buf, int num_rows)
+     JSAMPARRAY output_buf, int num_rows)
 /* Fast path for out_color_components==3, no dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
@@ -513,15 +517,15 @@ color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
 METHODDEF(void)
 quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                    JSAMPARRAY output_buf, int num_rows)
+         JSAMPARRAY output_buf, int num_rows)
 /* General case, with ordered dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
   register JSAMPROW input_ptr;
   register JSAMPROW output_ptr;
   JSAMPROW colorindex_ci;
-  int * dither;                        /* points to active row of dither matrix */
-  int row_index, col_index;    /* current indexes into dither matrix */
+  int * dither;      /* points to active row of dither matrix */
+  int row_index, col_index;  /* current indexes into dither matrix */
   int nc = cinfo->out_color_components;
   int ci;
   int row;
@@ -531,7 +535,7 @@ quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
   for (row = 0; row < num_rows; row++) {
     /* Initialize output values to 0 so can process components separately */
     jzero_far((void FAR *) output_buf[row],
-             (size_t) (width * SIZEOF(JSAMPLE)));
+        (size_t) (width * SIZEOF(JSAMPLE)));
     row_index = cquantize->row_index;
     for (ci = 0; ci < nc; ci++) {
       input_ptr = input_buf[row] + ci;
@@ -541,17 +545,17 @@ quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
       col_index = 0;
 
       for (col = width; col > 0; col--) {
-       /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE,
-        * select output value, accumulate into output code for this pixel.
-        * Range-limiting need not be done explicitly, as we have extended
-        * the colorindex table to produce the right answers for out-of-range
-        * inputs.  The maximum dither is +- MAXJSAMPLE; this sets the
-        * required amount of padding.
-        */
-       *output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]];
-       input_ptr += nc;
-       output_ptr++;
-       col_index = (col_index + 1) & ODITHER_MASK;
+  /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE,
+   * select output value, accumulate into output code for this pixel.
+   * Range-limiting need not be done explicitly, as we have extended
+   * the colorindex table to produce the right answers for out-of-range
+   * inputs.  The maximum dither is +- MAXJSAMPLE; this sets the
+   * required amount of padding.
+   */
+  *output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]];
+  input_ptr += nc;
+  output_ptr++;
+  col_index = (col_index + 1) & ODITHER_MASK;
       }
     }
     /* Advance row index for next row */
@@ -563,7 +567,7 @@ quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
 METHODDEF(void)
 quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                     JSAMPARRAY output_buf, int num_rows)
+          JSAMPARRAY output_buf, int num_rows)
 /* Fast path for out_color_components==3, with ordered dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
@@ -573,10 +577,10 @@ quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
   JSAMPROW colorindex0 = cquantize->colorindex[0];
   JSAMPROW colorindex1 = cquantize->colorindex[1];
   JSAMPROW colorindex2 = cquantize->colorindex[2];
-  int * dither0;               /* points to active row of dither matrix */
+  int * dither0;    /* points to active row of dither matrix */
   int * dither1;
   int * dither2;
-  int row_index, col_index;    /* current indexes into dither matrix */
+  int row_index, col_index;  /* current indexes into dither matrix */
   int row;
   JDIMENSION col;
   JDIMENSION width = cinfo->output_width;
@@ -592,11 +596,11 @@ quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
     for (col = width; col > 0; col--) {
       pixcode  = GETJSAMPLE(colorindex0[GETJSAMPLE(*input_ptr++) +
-                                       dither0[col_index]]);
+          dither0[col_index]]);
       pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*input_ptr++) +
-                                       dither1[col_index]]);
+          dither1[col_index]]);
       pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*input_ptr++) +
-                                       dither2[col_index]]);
+          dither2[col_index]]);
       *output_ptr++ = (JSAMPLE) pixcode;
       col_index = (col_index + 1) & ODITHER_MASK;
     }
@@ -608,24 +612,24 @@ quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
 METHODDEF(void)
 quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                   JSAMPARRAY output_buf, int num_rows)
+        JSAMPARRAY output_buf, int num_rows)
 /* General case, with Floyd-Steinberg dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
-  register LOCFSERROR cur;     /* current error or pixel value */
-  LOCFSERROR belowerr;         /* error for pixel below cur */
-  LOCFSERROR bpreverr;         /* error for below/prev col */
-  LOCFSERROR bnexterr;         /* error for below/next col */
+  register LOCFSERROR cur;  /* current error or pixel value */
+  LOCFSERROR belowerr;    /* error for pixel below cur */
+  LOCFSERROR bpreverr;    /* error for below/prev col */
+  LOCFSERROR bnexterr;    /* error for below/next col */
   LOCFSERROR delta;
-  register FSERRPTR errorptr;  /* => fserrors[] at column before current */
+  register FSERRPTR errorptr;  /* => fserrors[] at column before current */
   register JSAMPROW input_ptr;
   register JSAMPROW output_ptr;
   JSAMPROW colorindex_ci;
   JSAMPROW colormap_ci;
   int pixcode;
   int nc = cinfo->out_color_components;
-  int dir;                     /* 1 for left-to-right, -1 for right-to-left */
-  int dirnc;                   /* dir * nc */
+  int dir;      /* 1 for left-to-right, -1 for right-to-left */
+  int dirnc;      /* dir * nc */
   int ci;
   int row;
   JDIMENSION col;
@@ -636,22 +640,22 @@ quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
   for (row = 0; row < num_rows; row++) {
     /* Initialize output values to 0 so can process components separately */
     jzero_far((void FAR *) output_buf[row],
-             (size_t) (width * SIZEOF(JSAMPLE)));
+        (size_t) (width * SIZEOF(JSAMPLE)));
     for (ci = 0; ci < nc; ci++) {
       input_ptr = input_buf[row] + ci;
       output_ptr = output_buf[row];
       if (cquantize->on_odd_row) {
-       /* work right to left in this row */
-       input_ptr += (width-1) * nc; /* so point to rightmost pixel */
-       output_ptr += width-1;
-       dir = -1;
-       dirnc = -nc;
-       errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */
+  /* work right to left in this row */
+  input_ptr += (width-1) * nc; /* so point to rightmost pixel */
+  output_ptr += width-1;
+  dir = -1;
+  dirnc = -nc;
+  errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */
       } else {
-       /* work left to right in this row */
-       dir = 1;
-       dirnc = nc;
-       errorptr = cquantize->fserrors[ci]; /* => entry before first column */
+  /* work left to right in this row */
+  dir = 1;
+  dirnc = nc;
+  errorptr = cquantize->fserrors[ci]; /* => entry before first column */
       }
       colorindex_ci = cquantize->colorindex[ci];
       colormap_ci = cquantize->sv_colormap[ci];
@@ -661,47 +665,47 @@ quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
       belowerr = bpreverr = 0;
 
       for (col = width; col > 0; col--) {
-       /* cur holds the error propagated from the previous pixel on the
-        * current line.  Add the error propagated from the previous line
-        * to form the complete error correction term for this pixel, and
-        * round the error term (which is expressed * 16) to an integer.
-        * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
-        * for either sign of the error value.
-        * Note: errorptr points to *previous* column's array entry.
-        */
-       cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4);
-       /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
-        * The maximum error is +- MAXJSAMPLE; this sets the required size
-        * of the range_limit array.
-        */
-       cur += GETJSAMPLE(*input_ptr);
-       cur = GETJSAMPLE(range_limit[cur]);
-       /* Select output value, accumulate into output code for this pixel */
-       pixcode = GETJSAMPLE(colorindex_ci[cur]);
-       *output_ptr += (JSAMPLE) pixcode;
-       /* Compute actual representation error at this pixel */
-       /* Note: we can do this even though we don't have the final */
-       /* pixel code, because the colormap is orthogonal. */
-       cur -= GETJSAMPLE(colormap_ci[pixcode]);
-       /* Compute error fractions to be propagated to adjacent pixels.
-        * Add these into the running sums, and simultaneously shift the
-        * next-line error sums left by 1 column.
-        */
-       bnexterr = cur;
-       delta = cur * 2;
-       cur += delta;           /* form error * 3 */
-       errorptr[0] = (FSERROR) (bpreverr + cur);
-       cur += delta;           /* form error * 5 */
-       bpreverr = belowerr + cur;
-       belowerr = bnexterr;
-       cur += delta;           /* form error * 7 */
-       /* At this point cur contains the 7/16 error value to be propagated
-        * to the next pixel on the current line, and all the errors for the
-        * next line have been shifted over. We are therefore ready to move on.
-        */
-       input_ptr += dirnc;     /* advance input ptr to next column */
-       output_ptr += dir;      /* advance output ptr to next column */
-       errorptr += dir;        /* advance errorptr to current column */
+  /* cur holds the error propagated from the previous pixel on the
+   * current line.  Add the error propagated from the previous line
+   * to form the complete error correction term for this pixel, and
+   * round the error term (which is expressed * 16) to an integer.
+   * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+   * for either sign of the error value.
+   * Note: errorptr points to *previous* column's array entry.
+   */
+  cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4);
+  /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+   * The maximum error is +- MAXJSAMPLE; this sets the required size
+   * of the range_limit array.
+   */
+  cur += GETJSAMPLE(*input_ptr);
+  cur = GETJSAMPLE(range_limit[cur]);
+  /* Select output value, accumulate into output code for this pixel */
+  pixcode = GETJSAMPLE(colorindex_ci[cur]);
+  *output_ptr += (JSAMPLE) pixcode;
+  /* Compute actual representation error at this pixel */
+  /* Note: we can do this even though we don't have the final */
+  /* pixel code, because the colormap is orthogonal. */
+  cur -= GETJSAMPLE(colormap_ci[pixcode]);
+  /* Compute error fractions to be propagated to adjacent pixels.
+   * Add these into the running sums, and simultaneously shift the
+   * next-line error sums left by 1 column.
+   */
+  bnexterr = cur;
+  delta = cur * 2;
+  cur += delta;    /* form error * 3 */
+  errorptr[0] = (FSERROR) (bpreverr + cur);
+  cur += delta;    /* form error * 5 */
+  bpreverr = belowerr + cur;
+  belowerr = bnexterr;
+  cur += delta;    /* form error * 7 */
+  /* At this point cur contains the 7/16 error value to be propagated
+   * to the next pixel on the current line, and all the errors for the
+   * next line have been shifted over. We are therefore ready to move on.
+   */
+  input_ptr += dirnc;  /* advance input ptr to next column */
+  output_ptr += dir;  /* advance output ptr to next column */
+  errorptr += dir;  /* advance errorptr to current column */
       }
       /* Post-loop cleanup: we must unload the final error value into the
        * final fserrors[] entry.  Note we need not unload belowerr because
@@ -744,6 +748,7 @@ start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
   size_t arraysize;
   int i;
 
+  is_pre_scan = 0;
   /* Install my colormap. */
   cinfo->colormap = cquantize->sv_colormap;
   cinfo->actual_number_of_colors = cquantize->sv_actual;
@@ -761,7 +766,7 @@ start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
       cquantize->pub.color_quantize = quantize3_ord_dither;
     else
       cquantize->pub.color_quantize = quantize_ord_dither;
-    cquantize->row_index = 0;  /* initialize state for ordered dither */
+    cquantize->row_index = 0;  /* initialize state for ordered dither */
     /* If user changed to ordered dither from another mode,
      * we must recreate the color index table with padding.
      * This will cost extra space, but probably isn't very likely.
@@ -797,6 +802,7 @@ start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
 METHODDEF(void)
 finish_pass_1_quant (j_decompress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work in 1-pass case */
 }
 
@@ -824,13 +830,13 @@ jinit_1pass_quantizer (j_decompress_ptr cinfo)
 
   cquantize = (my_cquantize_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_cquantizer));
+        SIZEOF(my_cquantizer));
   cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
   cquantize->pub.start_pass = start_pass_1_quant;
   cquantize->pub.finish_pass = finish_pass_1_quant;
   cquantize->pub.new_color_map = new_color_map_1_quant;
   cquantize->fserrors[0] = NULL; /* Flag FS workspace not allocated */
-  cquantize->odither[0] = NULL;        /* Also flag odither arrays not allocated */
+  cquantize->odither[0] = NULL;  /* Also flag odither arrays not allocated */
 
   /* Make sure my internal arrays won't overflow */
   if (cinfo->out_color_components > MAX_Q_COMPS)
index af601e334b244f0a356e78826463b71e0848fe57..9355f01167b6346ee6c1cf30f67068e764e4c025 100644 (file)
@@ -70,9 +70,9 @@
  * probably need to change these scale factors.
  */
 
-#define R_SCALE 2              /* scale R distances by this much */
-#define G_SCALE 3              /* scale G distances by this much */
-#define B_SCALE 1              /* and B by this much */
+#define R_SCALE 2    /* scale R distances by this much */
+#define G_SCALE 3    /* scale G distances by this much */
+#define B_SCALE 1    /* and B by this much */
 
 /* Relabel R/G/B as components 0/1/2, respecting the RGB ordering defined
  * in jmorecfg.h.  As the code stands, it will do the right thing for R,G,B
 /* These will do the right thing for either R,G,B or B,G,R color order,
  * but you may not like the results for other color orders.
  */
-#define HIST_C0_BITS  5                /* bits of precision in R/B histogram */
-#define HIST_C1_BITS  6                /* bits of precision in G histogram */
-#define HIST_C2_BITS  5                /* bits of precision in B/R histogram */
+#define HIST_C0_BITS  5    /* bits of precision in R/B histogram */
+#define HIST_C1_BITS  6    /* bits of precision in G histogram */
+#define HIST_C2_BITS  5    /* bits of precision in B/R histogram */
 
 /* Number of elements along histogram axes. */
 #define HIST_C0_ELEMS  (1<<HIST_C0_BITS)
 #define C2_SHIFT  (BITS_IN_JSAMPLE-HIST_C2_BITS)
 
 
-typedef UINT16 histcell;       /* histogram cell; prefer an unsigned type */
+typedef UINT16 histcell;  /* histogram cell; prefer an unsigned type */
 
-typedef histcell FAR * histptr;        /* for pointers to histogram cells */
+typedef histcell FAR * histptr;  /* for pointers to histogram cells */
 
 typedef histcell hist1d[HIST_C2_ELEMS]; /* typedefs for the array */
-typedef hist1d FAR * hist2d;   /* type for the 2nd-level pointers */
-typedef hist2d * hist3d;       /* type for top-level pointer */
+typedef hist1d FAR * hist2d;  /* type for the 2nd-level pointers */
+typedef hist2d * hist3d;  /* type for top-level pointer */
 
 
 /* Declarations for Floyd-Steinberg dithering.
@@ -158,8 +158,8 @@ typedef hist2d * hist3d;    /* type for top-level pointer */
  * Errors are accumulated into the array fserrors[], at a resolution of
  * 1/16th of a pixel count.  The error at a given pixel is propagated
  * to its not-yet-processed neighbors using the standard F-S fractions,
- *             ...     (here)  7/16
- *             3/16    5/16    1/16
+ *    ...  (here)  7/16
+ *    3/16  5/16  1/16
  * We work left-to-right on even rows, right-to-left on odd rows.
  *
  * We can get away with a single array (holding one row's worth of errors)
@@ -178,14 +178,14 @@ typedef hist2d * hist3d;  /* type for top-level pointer */
  */
 
 #if BITS_IN_JSAMPLE == 8
-typedef INT16 FSERROR;         /* 16 bits should be enough */
-typedef int LOCFSERROR;                /* use 'int' for calculation temps */
+typedef INT16 FSERROR;    /* 16 bits should be enough */
+typedef int LOCFSERROR;    /* use 'int' for calculation temps */
 #else
-typedef INT32 FSERROR;         /* may need more than 16 bits */
-typedef INT32 LOCFSERROR;      /* be sure calculation temps are big enough */
+typedef INT32 FSERROR;    /* may need more than 16 bits */
+typedef INT32 LOCFSERROR;  /* be sure calculation temps are big enough */
 #endif
 
-typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
+typedef FSERROR FAR *FSERRPTR;  /* pointer to error array (in FAR storage!) */
 
 
 /* Private subobject */
@@ -194,18 +194,18 @@ typedef struct {
   struct jpeg_color_quantizer pub; /* public fields */
 
   /* Space for the eventually created colormap is stashed here */
-  JSAMPARRAY sv_colormap;      /* colormap allocated at init time */
-  int desired;                 /* desired # of colors = size of colormap */
+  JSAMPARRAY sv_colormap;  /* colormap allocated at init time */
+  int desired;      /* desired # of colors = size of colormap */
 
   /* Variables for accumulating image statistics */
-  hist3d histogram;            /* pointer to the histogram */
+  hist3d histogram;    /* pointer to the histogram */
 
-  boolean needs_zeroed;                /* TRUE if next pass must zero histogram */
+  boolean needs_zeroed;    /* TRUE if next pass must zero histogram */
 
   /* Variables for Floyd-Steinberg dithering */
-  FSERRPTR fserrors;           /* accumulated errors */
-  boolean on_odd_row;          /* flag to remember which row we are on */
-  int * error_limiter;         /* table for clamping the applied error */
+  FSERRPTR fserrors;    /* accumulated errors */
+  boolean on_odd_row;    /* flag to remember which row we are on */
+  int * error_limiter;    /* table for clamping the applied error */
 } my_cquantizer;
 
 typedef my_cquantizer * my_cquantize_ptr;
@@ -222,7 +222,7 @@ typedef my_cquantizer * my_cquantize_ptr;
 
 METHODDEF(void)
 prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
-                 JSAMPARRAY output_buf, int num_rows)
+      JSAMPARRAY output_buf, int num_rows)
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
   register JSAMPROW ptr;
@@ -232,16 +232,17 @@ prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
   JDIMENSION col;
   JDIMENSION width = cinfo->output_width;
 
+  output_buf = 0;
   for (row = 0; row < num_rows; row++) {
     ptr = input_buf[row];
     for (col = width; col > 0; col--) {
       /* get pixel value and index into the histogram */
       histp = & histogram[GETJSAMPLE(ptr[0]) >> C0_SHIFT]
-                        [GETJSAMPLE(ptr[1]) >> C1_SHIFT]
-                        [GETJSAMPLE(ptr[2]) >> C2_SHIFT];
+       [GETJSAMPLE(ptr[1]) >> C1_SHIFT]
+       [GETJSAMPLE(ptr[2]) >> C2_SHIFT];
       /* increment, check for overflow and undo increment if so. */
       if (++(*histp) <= 0)
-       (*histp)--;
+  (*histp)--;
       ptr += 3;
     }
   }
@@ -329,67 +330,67 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)
   if (c0max > c0min)
     for (c0 = c0min; c0 <= c0max; c0++)
       for (c1 = c1min; c1 <= c1max; c1++) {
-       histp = & histogram[c0][c1][c2min];
-       for (c2 = c2min; c2 <= c2max; c2++)
-         if (*histp++ != 0) {
-           boxp->c0min = c0min = c0;
-           goto have_c0min;
-         }
+  histp = & histogram[c0][c1][c2min];
+  for (c2 = c2min; c2 <= c2max; c2++)
+    if (*histp++ != 0) {
+      boxp->c0min = c0min = c0;
+      goto have_c0min;
+    }
       }
  have_c0min:
   if (c0max > c0min)
     for (c0 = c0max; c0 >= c0min; c0--)
       for (c1 = c1min; c1 <= c1max; c1++) {
-       histp = & histogram[c0][c1][c2min];
-       for (c2 = c2min; c2 <= c2max; c2++)
-         if (*histp++ != 0) {
-           boxp->c0max = c0max = c0;
-           goto have_c0max;
-         }
+  histp = & histogram[c0][c1][c2min];
+  for (c2 = c2min; c2 <= c2max; c2++)
+    if (*histp++ != 0) {
+      boxp->c0max = c0max = c0;
+      goto have_c0max;
+    }
       }
  have_c0max:
   if (c1max > c1min)
     for (c1 = c1min; c1 <= c1max; c1++)
       for (c0 = c0min; c0 <= c0max; c0++) {
-       histp = & histogram[c0][c1][c2min];
-       for (c2 = c2min; c2 <= c2max; c2++)
-         if (*histp++ != 0) {
-           boxp->c1min = c1min = c1;
-           goto have_c1min;
-         }
+  histp = & histogram[c0][c1][c2min];
+  for (c2 = c2min; c2 <= c2max; c2++)
+    if (*histp++ != 0) {
+      boxp->c1min = c1min = c1;
+      goto have_c1min;
+    }
       }
  have_c1min:
   if (c1max > c1min)
     for (c1 = c1max; c1 >= c1min; c1--)
       for (c0 = c0min; c0 <= c0max; c0++) {
-       histp = & histogram[c0][c1][c2min];
-       for (c2 = c2min; c2 <= c2max; c2++)
-         if (*histp++ != 0) {
-           boxp->c1max = c1max = c1;
-           goto have_c1max;
-         }
+  histp = & histogram[c0][c1][c2min];
+  for (c2 = c2min; c2 <= c2max; c2++)
+    if (*histp++ != 0) {
+      boxp->c1max = c1max = c1;
+      goto have_c1max;
+    }
       }
  have_c1max:
   if (c2max > c2min)
     for (c2 = c2min; c2 <= c2max; c2++)
       for (c0 = c0min; c0 <= c0max; c0++) {
-       histp = & histogram[c0][c1min][c2];
-       for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
-         if (*histp != 0) {
-           boxp->c2min = c2min = c2;
-           goto have_c2min;
-         }
+  histp = & histogram[c0][c1min][c2];
+  for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+    if (*histp != 0) {
+      boxp->c2min = c2min = c2;
+      goto have_c2min;
+    }
       }
  have_c2min:
   if (c2max > c2min)
     for (c2 = c2max; c2 >= c2min; c2--)
       for (c0 = c0min; c0 <= c0max; c0++) {
-       histp = & histogram[c0][c1min][c2];
-       for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
-         if (*histp != 0) {
-           boxp->c2max = c2max = c2;
-           goto have_c2max;
-         }
+  histp = & histogram[c0][c1min][c2];
+  for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+    if (*histp != 0) {
+      boxp->c2max = c2max = c2;
+      goto have_c2max;
+    }
       }
  have_c2max:
 
@@ -412,9 +413,9 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)
     for (c1 = c1min; c1 <= c1max; c1++) {
       histp = & histogram[c0][c1][c2min];
       for (c2 = c2min; c2 <= c2max; c2++, histp++)
-       if (*histp != 0) {
-         ccount++;
-       }
+  if (*histp != 0) {
+    ccount++;
+  }
     }
   boxp->colorcount = ccount;
 }
@@ -422,7 +423,7 @@ update_box (j_decompress_ptr cinfo, boxptr boxp)
 
 LOCAL(int)
 median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes,
-           int desired_colors)
+      int desired_colors)
 /* Repeatedly select and split the largest box until we have enough boxes */
 {
   int n,lb;
@@ -438,9 +439,9 @@ median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes,
     } else {
       b1 = find_biggest_volume(boxlist, numboxes);
     }
-    if (b1 == NULL)            /* no splittable boxes left! */
+    if (b1 == NULL)    /* no splittable boxes left! */
       break;
-    b2 = &boxlist[numboxes];   /* where new box will go */
+    b2 = &boxlist[numboxes];  /* where new box will go */
     /* Copy the color bounds to the new box. */
     b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max;
     b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min;
@@ -520,12 +521,12 @@ compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor)
     for (c1 = c1min; c1 <= c1max; c1++) {
       histp = & histogram[c0][c1][c2min];
       for (c2 = c2min; c2 <= c2max; c2++) {
-       if ((count = *histp++) != 0) {
-         total += count;
-         c0total += ((c0 << C0_SHIFT) + ((1<<C0_SHIFT)>>1)) * count;
-         c1total += ((c1 << C1_SHIFT) + ((1<<C1_SHIFT)>>1)) * count;
-         c2total += ((c2 << C2_SHIFT) + ((1<<C2_SHIFT)>>1)) * count;
-       }
+  if ((count = *histp++) != 0) {
+    total += count;
+    c0total += ((c0 << C0_SHIFT) + ((1<<C0_SHIFT)>>1)) * count;
+    c1total += ((c1 << C1_SHIFT) + ((1<<C1_SHIFT)>>1)) * count;
+    c2total += ((c2 << C2_SHIFT) + ((1<<C2_SHIFT)>>1)) * count;
+  }
       }
     }
   
@@ -644,7 +645,7 @@ select_colors (j_decompress_ptr cinfo, int desired_colors)
 
 LOCAL(int)
 find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
-                   JSAMPLE colorlist[])
+        JSAMPLE colorlist[])
 /* Locate the colormap entries close enough to an update box to be candidates
  * for the nearest entry to some cell(s) in the update box.  The update box
  * is specified by the center coordinates of its first cell.  The number of
@@ -659,7 +660,7 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
   int centerc0, centerc1, centerc2;
   int i, x, ncolors;
   INT32 minmaxdist, min_dist, max_dist, tdist;
-  INT32 mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */
+  INT32 mindist[MAXNUMCOLORS];  /* min distance to colormap entry i */
 
   /* Compute true coordinates of update box's upper corner and center.
    * Actually we compute the coordinates of the center of the upper-corner
@@ -701,11 +702,11 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
       /* within cell range so no contribution to min_dist */
       min_dist = 0;
       if (x <= centerc0) {
-       tdist = (x - maxc0) * C0_SCALE;
-       max_dist = tdist*tdist;
+  tdist = (x - maxc0) * C0_SCALE;
+  max_dist = tdist*tdist;
       } else {
-       tdist = (x - minc0) * C0_SCALE;
-       max_dist = tdist*tdist;
+  tdist = (x - minc0) * C0_SCALE;
+  max_dist = tdist*tdist;
       }
     }
 
@@ -723,11 +724,11 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
     } else {
       /* within cell range so no contribution to min_dist */
       if (x <= centerc1) {
-       tdist = (x - maxc1) * C1_SCALE;
-       max_dist += tdist*tdist;
+  tdist = (x - maxc1) * C1_SCALE;
+  max_dist += tdist*tdist;
       } else {
-       tdist = (x - minc1) * C1_SCALE;
-       max_dist += tdist*tdist;
+  tdist = (x - minc1) * C1_SCALE;
+  max_dist += tdist*tdist;
       }
     }
 
@@ -745,15 +746,15 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
     } else {
       /* within cell range so no contribution to min_dist */
       if (x <= centerc2) {
-       tdist = (x - maxc2) * C2_SCALE;
-       max_dist += tdist*tdist;
+  tdist = (x - maxc2) * C2_SCALE;
+  max_dist += tdist*tdist;
       } else {
-       tdist = (x - minc2) * C2_SCALE;
-       max_dist += tdist*tdist;
+  tdist = (x - minc2) * C2_SCALE;
+  max_dist += tdist*tdist;
       }
     }
 
-    mindist[i] = min_dist;     /* save away the results */
+    mindist[i] = min_dist;  /* save away the results */
     if (max_dist < minmaxdist)
       minmaxdist = max_dist;
   }
@@ -773,7 +774,7 @@ find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
 
 LOCAL(void)
 find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
-                 int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])
+      int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])
 /* Find the closest colormap entry for each cell in the update box,
  * given the list of candidate colors prepared by find_nearby_colors.
  * Return the indexes of the closest entries in the bestcolor[] array.
@@ -783,13 +784,13 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
 {
   int ic0, ic1, ic2;
   int i, icolor;
-  register INT32 * bptr;       /* pointer into bestdist[] array */
-  JSAMPLE * cptr;              /* pointer into bestcolor[] array */
-  INT32 dist0, dist1;          /* initial distance values */
-  register INT32 dist2;                /* current distance in inner loop */
-  INT32 xx0, xx1;              /* distance increments */
+  register INT32 * bptr;  /* pointer into bestdist[] array */
+  JSAMPLE * cptr;    /* pointer into bestcolor[] array */
+  INT32 dist0, dist1;    /* initial distance values */
+  register INT32 dist2;    /* current distance in inner loop */
+  INT32 xx0, xx1;    /* distance increments */
   register INT32 xx2;
-  INT32 inc0, inc1, inc2;      /* initial values for increments */
+  INT32 inc0, inc1, inc2;  /* initial values for increments */
   /* This array holds the distance to the nearest-so-far color for each cell */
   INT32 bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
 
@@ -829,20 +830,20 @@ find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
       dist1 = dist0;
       xx1 = inc1;
       for (ic1 = BOX_C1_ELEMS-1; ic1 >= 0; ic1--) {
-       dist2 = dist1;
-       xx2 = inc2;
-       for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) {
-         if (dist2 < *bptr) {
-           *bptr = dist2;
-           *cptr = (JSAMPLE) icolor;
-         }
-         dist2 += xx2;
-         xx2 += 2 * STEP_C2 * STEP_C2;
-         bptr++;
-         cptr++;
-       }
-       dist1 += xx1;
-       xx1 += 2 * STEP_C1 * STEP_C1;
+  dist2 = dist1;
+  xx2 = inc2;
+  for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) {
+    if (dist2 < *bptr) {
+      *bptr = dist2;
+      *cptr = (JSAMPLE) icolor;
+    }
+    dist2 += xx2;
+    xx2 += 2 * STEP_C2 * STEP_C2;
+    bptr++;
+    cptr++;
+  }
+  dist1 += xx1;
+  xx1 += 2 * STEP_C1 * STEP_C1;
       }
       dist0 += xx0;
       xx0 += 2 * STEP_C0 * STEP_C0;
@@ -859,13 +860,13 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
   hist3d histogram = cquantize->histogram;
-  int minc0, minc1, minc2;     /* lower left corner of update box */
+  int minc0, minc1, minc2;  /* lower left corner of update box */
   int ic0, ic1, ic2;
-  register JSAMPLE * cptr;     /* pointer into bestcolor[] array */
-  register histptr cachep;     /* pointer into main cache array */
+  register JSAMPLE * cptr;  /* pointer into bestcolor[] array */
+  register histptr cachep;  /* pointer into main cache array */
   /* This array lists the candidate colormap indexes. */
   JSAMPLE colorlist[MAXNUMCOLORS];
-  int numcolors;               /* number of candidate colors */
+  int numcolors;    /* number of candidate colors */
   /* This array holds the actually closest colormap index for each cell. */
   JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
 
@@ -889,10 +890,10 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
 
   /* Determine the actually nearest colors. */
   find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist,
-                  bestcolor);
+       bestcolor);
 
   /* Save the best color numbers (plus 1) in the main cache array */
-  c0 <<= BOX_C0_LOG;           /* convert ID back to base cell indexes */
+  c0 <<= BOX_C0_LOG;    /* convert ID back to base cell indexes */
   c1 <<= BOX_C1_LOG;
   c2 <<= BOX_C2_LOG;
   cptr = bestcolor;
@@ -900,7 +901,7 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
     for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) {
       cachep = & histogram[c0+ic0][c1+ic1][c2];
       for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) {
-       *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1);
+  *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1);
       }
     }
   }
@@ -913,7 +914,7 @@ fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
 
 METHODDEF(void)
 pass2_no_dither (j_decompress_ptr cinfo,
-                JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
+     JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
 /* This version performs no dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
@@ -937,7 +938,7 @@ pass2_no_dither (j_decompress_ptr cinfo,
       /* If we have not seen this color before, find nearest colormap entry */
       /* and update the cache */
       if (*cachep == 0)
-       fill_inverse_cmap(cinfo, c0,c1,c2);
+  fill_inverse_cmap(cinfo, c0,c1,c2);
       /* Now emit the colormap index for this cell */
       *outptr++ = (JSAMPLE) (*cachep - 1);
     }
@@ -947,20 +948,20 @@ pass2_no_dither (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 pass2_fs_dither (j_decompress_ptr cinfo,
-                JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
+     JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
 /* This version performs Floyd-Steinberg dithering */
 {
   my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
   hist3d histogram = cquantize->histogram;
-  register LOCFSERROR cur0, cur1, cur2;        /* current error or pixel value */
+  register LOCFSERROR cur0, cur1, cur2;  /* current error or pixel value */
   LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */
   LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */
-  register FSERRPTR errorptr;  /* => fserrors[] at column before current */
-  JSAMPROW inptr;              /* => current input pixel */
-  JSAMPROW outptr;             /* => current output pixel */
+  register FSERRPTR errorptr;  /* => fserrors[] at column before current */
+  JSAMPROW inptr;    /* => current input pixel */
+  JSAMPROW outptr;    /* => current output pixel */
   histptr cachep;
-  int dir;                     /* +1 or -1 depending on direction */
-  int dir3;                    /* 3*dir, for advancing inptr & errorptr */
+  int dir;      /* +1 or -1 depending on direction */
+  int dir3;      /* 3*dir, for advancing inptr & errorptr */
   int row;
   JDIMENSION col;
   JDIMENSION width = cinfo->output_width;
@@ -976,7 +977,7 @@ pass2_fs_dither (j_decompress_ptr cinfo,
     outptr = output_buf[row];
     if (cquantize->on_odd_row) {
       /* work right to left in this row */
-      inptr += (width-1) * 3;  /* so point to rightmost pixel */
+      inptr += (width-1) * 3;  /* so point to rightmost pixel */
       outptr += width-1;
       dir = -1;
       dir3 = -3;
@@ -1028,14 +1029,14 @@ pass2_fs_dither (j_decompress_ptr cinfo,
       /* If we have not seen this color before, find nearest colormap */
       /* entry and update the cache */
       if (*cachep == 0)
-       fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT);
+  fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT);
       /* Now emit the colormap index for this cell */
       { register int pixcode = *cachep - 1;
-       *outptr = (JSAMPLE) pixcode;
-       /* Compute representation error for this pixel */
-       cur0 -= GETJSAMPLE(colormap0[pixcode]);
-       cur1 -= GETJSAMPLE(colormap1[pixcode]);
-       cur2 -= GETJSAMPLE(colormap2[pixcode]);
+  *outptr = (JSAMPLE) pixcode;
+  /* Compute representation error for this pixel */
+  cur0 -= GETJSAMPLE(colormap0[pixcode]);
+  cur1 -= GETJSAMPLE(colormap1[pixcode]);
+  cur2 -= GETJSAMPLE(colormap2[pixcode]);
       }
       /* Compute error fractions to be propagated to adjacent pixels.
        * Add these into the running sums, and simultaneously shift the
@@ -1043,38 +1044,38 @@ pass2_fs_dither (j_decompress_ptr cinfo,
        */
       { register LOCFSERROR bnexterr, delta;
 
-       bnexterr = cur0;        /* Process component 0 */
-       delta = cur0 * 2;
-       cur0 += delta;          /* form error * 3 */
-       errorptr[0] = (FSERROR) (bpreverr0 + cur0);
-       cur0 += delta;          /* form error * 5 */
-       bpreverr0 = belowerr0 + cur0;
-       belowerr0 = bnexterr;
-       cur0 += delta;          /* form error * 7 */
-       bnexterr = cur1;        /* Process component 1 */
-       delta = cur1 * 2;
-       cur1 += delta;          /* form error * 3 */
-       errorptr[1] = (FSERROR) (bpreverr1 + cur1);
-       cur1 += delta;          /* form error * 5 */
-       bpreverr1 = belowerr1 + cur1;
-       belowerr1 = bnexterr;
-       cur1 += delta;          /* form error * 7 */
-       bnexterr = cur2;        /* Process component 2 */
-       delta = cur2 * 2;
-       cur2 += delta;          /* form error * 3 */
-       errorptr[2] = (FSERROR) (bpreverr2 + cur2);
-       cur2 += delta;          /* form error * 5 */
-       bpreverr2 = belowerr2 + cur2;
-       belowerr2 = bnexterr;
-       cur2 += delta;          /* form error * 7 */
+  bnexterr = cur0;  /* Process component 0 */
+  delta = cur0 * 2;
+  cur0 += delta;    /* form error * 3 */
+  errorptr[0] = (FSERROR) (bpreverr0 + cur0);
+  cur0 += delta;    /* form error * 5 */
+  bpreverr0 = belowerr0 + cur0;
+  belowerr0 = bnexterr;
+  cur0 += delta;    /* form error * 7 */
+  bnexterr = cur1;  /* Process component 1 */
+  delta = cur1 * 2;
+  cur1 += delta;    /* form error * 3 */
+  errorptr[1] = (FSERROR) (bpreverr1 + cur1);
+  cur1 += delta;    /* form error * 5 */
+  bpreverr1 = belowerr1 + cur1;
+  belowerr1 = bnexterr;
+  cur1 += delta;    /* form error * 7 */
+  bnexterr = cur2;  /* Process component 2 */
+  delta = cur2 * 2;
+  cur2 += delta;    /* form error * 3 */
+  errorptr[2] = (FSERROR) (bpreverr2 + cur2);
+  cur2 += delta;    /* form error * 5 */
+  bpreverr2 = belowerr2 + cur2;
+  belowerr2 = bnexterr;
+  cur2 += delta;    /* form error * 7 */
       }
       /* At this point curN contains the 7/16 error value to be propagated
        * to the next pixel on the current line, and all the errors for the
        * next line have been shifted over.  We are therefore ready to move on.
        */
-      inptr += dir3;           /* Advance pixel pointers to next column */
+      inptr += dir3;    /* Advance pixel pointers to next column */
       outptr += dir;
-      errorptr += dir3;                /* advance errorptr to current column */
+      errorptr += dir3;    /* advance errorptr to current column */
     }
     /* Post-loop cleanup: we must unload the final error values into the
      * final fserrors[] entry.  Note we need not unload belowerrN because
@@ -1114,7 +1115,7 @@ init_error_limit (j_decompress_ptr cinfo)
 
   table = (int *) (*cinfo->mem->alloc_small)
     ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE*2+1) * SIZEOF(int));
-  table += MAXJSAMPLE;         /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */
+  table += MAXJSAMPLE;    /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */
   cquantize->error_limiter = table;
 
 #define STEPSIZE ((MAXJSAMPLE+1)/16)
@@ -1155,6 +1156,7 @@ finish_pass1 (j_decompress_ptr cinfo)
 METHODDEF(void)
 finish_pass2 (j_decompress_ptr cinfo)
 {
+  cinfo = 0;
   /* no work */
 }
 
@@ -1197,16 +1199,16 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
 
     if (cinfo->dither_mode == JDITHER_FS) {
       size_t arraysize = (size_t) ((cinfo->output_width + 2) *
-                                  (3 * SIZEOF(FSERROR)));
+           (3 * SIZEOF(FSERROR)));
       /* Allocate Floyd-Steinberg workspace if we didn't already. */
       if (cquantize->fserrors == NULL)
-       cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
-         ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
+  cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
       /* Initialize the propagated errors to zero. */
       jzero_far((void FAR *) cquantize->fserrors, arraysize);
       /* Make the error-limit table if we didn't already. */
       if (cquantize->error_limiter == NULL)
-       init_error_limit(cinfo);
+  init_error_limit(cinfo);
       cquantize->on_odd_row = FALSE;
     }
 
@@ -1215,7 +1217,7 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
   if (cquantize->needs_zeroed) {
     for (i = 0; i < HIST_C0_ELEMS; i++) {
       jzero_far((void FAR *) histogram[i],
-               HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));
+    HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));
     }
     cquantize->needs_zeroed = FALSE;
   }
@@ -1248,11 +1250,11 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo)
 
   cquantize = (my_cquantize_ptr)
     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                               SIZEOF(my_cquantizer));
+        SIZEOF(my_cquantizer));
   cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
   cquantize->pub.start_pass = start_pass_2_quant;
   cquantize->pub.new_color_map = new_color_map_2_quant;
-  cquantize->fserrors = NULL;  /* flag optional arrays not allocated */
+  cquantize->fserrors = NULL;  /* flag optional arrays not allocated */
   cquantize->error_limiter = NULL;
 
   /* Make sure jdmaster didn't give me a case I can't handle */