compiler/libjpeg/main/jdpred.c

   1 /*
   2     $Id$
   3 */
   4
   5 /*
   6  * jdpred.c
   7  *
   8  * Copyright (C) 1998, Thomas G. Lane.
   9  * This file is part of the Independent JPEG Group's software.
  10  * For conditions of distribution and use, see the accompanying README file.
  11  *
  12  * This file contains sample undifferencing (reconstruction) for lossless JPEG.
  13  *
  14  * In order to avoid paying the performance penalty of having to check the
  15  * predictor being used and the row being processed for each call of the
  16  * undifferencer, and to promote optimization, we have separate undifferencing
  17  * functions for each case.
  18  *
  19  * We are able to avoid duplicating source code by implementing the predictors
  20  * and undifferencers as macros.  Each of the undifferencing functions are
  21  * simply wrappers around an UNDIFFERENCE macro with the appropriate PREDICTOR
  22  * macro passed as an argument.
  23  */
  24
  25 #define JPEG_INTERNALS
  26 #include "jinclude.h"
  27 #include "jpeglib.h"
  28 #include "jlossls.h"            /* Private declarations for lossless codec */
  29
  30
  31 #ifdef D_LOSSLESS_SUPPORTED
  32
  33 /* Predictor for the first column of the first row: 2^(P-Pt-1) */
  34 #define INITIAL_PREDICTORx      (1 << (cinfo->data_precision - cinfo->Al - 1))
  35
  36 /* Predictor for the first column of the remaining rows: Rb */
  37 #define INITIAL_PREDICTOR2      GETJSAMPLE(prev_row[0])
  38
  39
  40 /*
  41  * 1-Dimensional undifferencer routine.
  42  *
  43  * This macro implements the 1-D horizontal predictor (1).  INITIAL_PREDICTOR
  44  * is used as the special case predictor for the first column, which must be
  45  * either INITIAL_PREDICTOR2 or INITIAL_PREDICTORx.  The remaining samples
  46  * use PREDICTOR1.
  47  *
  48  * The reconstructed sample is supposed to be calculated modulo 2^16, so we
  49  * logically AND the result with 0xFFFF.
  50 */
  51
  52 #define UNDIFFERENCE_1D(INITIAL_PREDICTOR) \
  53         int xindex; \
  54         int Ra; \
  55  \
  56         Ra = (diff_buf[0] + INITIAL_PREDICTOR) & 0xFFFF; \
  57         undiff_buf[0] = Ra; \
  58  \
  59         for (xindex = 1; xindex < width; xindex++) { \
  60           Ra = (diff_buf[xindex] + PREDICTOR1) & 0xFFFF; \
  61           undiff_buf[xindex] = Ra; \
  62         }
  63
  64 /*
  65  * 2-Dimensional undifferencer routine.
  66  *
  67  * This macro implements the 2-D horizontal predictors (#2-7).  PREDICTOR2 is
  68  * used as the special case predictor for the first column.  The remaining
  69  * samples use PREDICTOR, which is a function of Ra, Rb, Rc.
  70  *
  71  * Because prev_row and output_buf may point to the same storage area (in an
  72  * interleaved image with Vi=1, for example), we must take care to buffer Rb/Rc
  73  * before writing the current reconstructed sample value into output_buf.
  74  *
  75  * The reconstructed sample is supposed to be calculated modulo 2^16, so we
  76  * logically AND the result with 0xFFFF.
  77  */
  78
  79 #define UNDIFFERENCE_2D(PREDICTOR) \
  80         int xindex; \
  81         int Ra, Rb, Rc; \
  82  \
  83         Rb = GETJSAMPLE(prev_row[0]); \
  84         Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF; \
  85         undiff_buf[0] = Ra; \
  86  \
  87         for (xindex = 1; xindex < width; xindex++) { \
  88           Rc = Rb; \
  89           Rb = GETJSAMPLE(prev_row[xindex]); \
  90           Ra = (diff_buf[xindex] + PREDICTOR) & 0xFFFF; \
  91           undiff_buf[xindex] = Ra; \
  92         }
  93
  94
  95 /*
  96  * Undifferencers for the all rows but the first in a scan or restart interval.
  97  * The first sample in the row is undifferenced using the vertical
  98  * predictor (2).  The rest of the samples are undifferenced using the
  99  * predictor specified in the scan header.
 100  */
 101
 102 METHODDEF(void)
 103 jpeg_undifference1(j_decompress_ptr cinfo, int comp_index,
 104                    JDIFFROW diff_buf, JDIFFROW prev_row,
 105                    JDIFFROW undiff_buf, JDIMENSION width)
 106 {
 107   UNDIFFERENCE_1D(INITIAL_PREDICTOR2);
 108 }
 109
 110 METHODDEF(void)
 111 jpeg_undifference2(j_decompress_ptr cinfo, int comp_index,
 112                    JDIFFROW diff_buf, JDIFFROW prev_row,
 113                    JDIFFROW undiff_buf, JDIMENSION width)
 114 {
 115   UNDIFFERENCE_2D(PREDICTOR2);
 116 }
 117
 118 METHODDEF(void)
 119 jpeg_undifference3(j_decompress_ptr cinfo, int comp_index,
 120                    JDIFFROW diff_buf, JDIFFROW prev_row,
 121                    JDIFFROW undiff_buf, JDIMENSION width)
 122 {
 123   UNDIFFERENCE_2D(PREDICTOR3);
 124 }
 125
 126 METHODDEF(void)
 127 jpeg_undifference4(j_decompress_ptr cinfo, int comp_index,
 128                    JDIFFROW diff_buf, JDIFFROW prev_row,
 129                    JDIFFROW undiff_buf, JDIMENSION width)
 130 {
 131   UNDIFFERENCE_2D(PREDICTOR4);
 132 }
 133
 134 METHODDEF(void)
 135 jpeg_undifference5(j_decompress_ptr cinfo, int comp_index,
 136                    JDIFFROW diff_buf, JDIFFROW prev_row,
 137                    JDIFFROW undiff_buf, JDIMENSION width)
 138 {
 139   UNDIFFERENCE_2D(PREDICTOR5);
 140 }
 141
 142 METHODDEF(void)
 143 jpeg_undifference6(j_decompress_ptr cinfo, int comp_index,
 144                    JDIFFROW diff_buf, JDIFFROW prev_row,
 145                    JDIFFROW undiff_buf, JDIMENSION width)
 146 {
 147   UNDIFFERENCE_2D(PREDICTOR6);
 148 }
 149
 150 METHODDEF(void)
 151 jpeg_undifference7(j_decompress_ptr cinfo, int comp_index,
 152                    JDIFFROW diff_buf, JDIFFROW prev_row,
 153                    JDIFFROW undiff_buf, JDIMENSION width)
 154 {
 155   UNDIFFERENCE_2D(PREDICTOR7);
 156 }
 157
 158
 159 /*
 160  * Undifferencer for the first row in a scan or restart interval.  The first
 161  * sample in the row is undifferenced using the special predictor constant
 162  * x=2^(P-Pt-1).  The rest of the samples are undifferenced using the
 163  * 1-D horizontal predictor (1).
 164  */
 165
 166 METHODDEF(void)
 167 jpeg_undifference_first_row(j_decompress_ptr cinfo, int comp_index,
 168                             JDIFFROW diff_buf, JDIFFROW prev_row,
 169                             JDIFFROW undiff_buf, JDIMENSION width)
 170 {
 171   j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;
 172
 173   UNDIFFERENCE_1D(INITIAL_PREDICTORx);
 174
 175   /*
 176    * Now that we have undifferenced the first row, we want to use the
 177    * undifferencer which corresponds to the predictor specified in the
 178    * scan header.
 179    */
 180   switch (cinfo->Ss) {
 181   case 1:
 182     losslsd->predict_undifference[comp_index] = jpeg_undifference1;
 183     break;
 184   case 2:
 185     losslsd->predict_undifference[comp_index] = jpeg_undifference2;
 186     break;
 187   case 3:
 188     losslsd->predict_undifference[comp_index] = jpeg_undifference3;
 189     break;
 190   case 4:
 191     losslsd->predict_undifference[comp_index] = jpeg_undifference4;
 192     break;
 193   case 5:
 194     losslsd->predict_undifference[comp_index] = jpeg_undifference5;
 195     break;
 196   case 6:
 197     losslsd->predict_undifference[comp_index] = jpeg_undifference6;
 198     break;
 199   case 7:
 200     losslsd->predict_undifference[comp_index] = jpeg_undifference7;
 201     break;
 202   }
 203 }
 204
 205
 206 /*
 207  * Initialize for an input processing pass.
 208  */
 209
 210 METHODDEF(void)
 211 predict_start_pass (j_decompress_ptr cinfo)
 212 {
 213   j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;
 214   int ci;
 215
 216   /* Check that the scan parameters Ss, Se, Ah, Al are OK for lossless JPEG.
 217    *
 218    * Ss is the predictor selection value (psv).  Legal values for sequential
 219    * lossless JPEG are: 1 <= psv <= 7.
 220    *
 221    * Se and Ah are not used and should be zero.
 222    *
 223    * Al specifies the point transform (Pt).  Legal values are: 0 <= Pt <= 15.
 224    */
 225   if (cinfo->Ss < 1 || cinfo->Ss > 7 ||
 226       cinfo->Se != 0 || cinfo->Ah != 0 ||
 227       cinfo->Al > 15)                           /* need not check for < 0 */
 228     ERREXIT4(cinfo, JERR_BAD_LOSSLESS,
 229              cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
 230
 231   /* Set undifference functions to first row function */
 232   for (ci = 0; ci < cinfo->num_components; ci++)
 233     losslsd->predict_undifference[ci] = jpeg_undifference_first_row;
 234 }
 235
 236
 237 /*
 238  * Module initialization routine for the undifferencer.
 239  */
 240
 241 JGLOBAL(void)
 242 jinit_undifferencer (j_decompress_ptr cinfo)
 243 {
 244   j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;
 245
 246   losslsd->predict_start_pass = predict_start_pass;
 247   losslsd->predict_process_restart = predict_start_pass;
 248 }
 249
 250 #endif /* D_LOSSLESS_SUPPORTED */
 251