/*

 * jdpred.c

 *

 * Copyright (C) 1998, Thomas G. Lane.

 * This file is part of the Independent JPEG Group's software.

 * For conditions of distribution and use, see the accompanying README file.

 *

 * This file contains sample undifferencing (reconstruction) for lossless JPEG.

 *

 * In order to avoid paying the performance penalty of having to check the

 * predictor being used and the row being processed for each call of the

 * undifferencer, and to promote optimization, we have separate undifferencing

 * functions for each case.

 *

 * We are able to avoid duplicating source code by implementing the predictors

 * and undifferencers as macros.  Each of the undifferencing functions are

 * simply wrappers around an UNDIFFERENCE macro with the appropriate PREDICTOR

 * macro passed as an argument.

 */

#define JPEG_INTERNALS

#include "jinclude16.h"

#include "jpeglib16.h"

#include "jlossls16.h"      /* Private declarations for lossless codec */

#ifdef D_LOSSLESS_SUPPORTED

/* Predictor for the first column of the first row: 2^(P-Pt-1) */

#define INITIAL_PREDICTORx  (1 << (cinfo->data_precision - cinfo->Al - 1))

/* Predictor for the first column of the remaining rows: Rb */

#define INITIAL_PREDICTOR2  GETJSAMPLE(prev_row[0])

/*

 * 1-Dimensional undifferencer routine.

 *

 * This macro implements the 1-D horizontal predictor (1).  INITIAL_PREDICTOR

 * is used as the special case predictor for the first column, which must be

 * either INITIAL_PREDICTOR2 or INITIAL_PREDICTORx.  The remaining samples

 * use PREDICTOR1.

 *

 * The reconstructed sample is supposed to be calculated modulo 2^16, so we

 * logically AND the result with 0xFFFF.

*/

#define UNDIFFERENCE_1D(INITIAL_PREDICTOR) \

    unsigned int xindex; \

    int Ra; \

 \

    Ra = (diff_buf[0] + INITIAL_PREDICTOR) & 0xFFFF; \

    undiff_buf[0] = Ra; \

 \

    for (xindex = 1; xindex < width; xindex++) { \

      Ra = (diff_buf[xindex] + PREDICTOR1) & 0xFFFF; \

      undiff_buf[xindex] = Ra; \

    }

/*

 * 2-Dimensional undifferencer routine.

 *

 * This macro implements the 2-D horizontal predictors (#2-7).  PREDICTOR2 is

 * used as the special case predictor for the first column.  The remaining

 * samples use PREDICTOR, which is a function of Ra, Rb, Rc.

 *

 * Because prev_row and output_buf may point to the same storage area (in an

 * interleaved image with Vi=1, for example), we must take care to buffer Rb/Rc

 * before writing the current reconstructed sample value into output_buf.

 *

 * The reconstructed sample is supposed to be calculated modulo 2^16, so we

 * logically AND the result with 0xFFFF.

 */

#define UNDIFFERENCE_2D(PREDICTOR) \

    unsigned int xindex; \

    int Ra, Rb, Rc; \

 \

    Rb = GETJSAMPLE(prev_row[0]); \

    Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF; \

    undiff_buf[0] = Ra; \

 \

    for (xindex = 1; xindex < width; xindex++) { \

      Rc = Rb; \

      Rb = GETJSAMPLE(prev_row[xindex]); \

      Ra = (diff_buf[xindex] + PREDICTOR) & 0xFFFF; \

      undiff_buf[xindex] = Ra; \

    }

#define JPEG_UNUSED(x) ((void)x)

/*

 * Undifferencers for the all rows but the first in a scan or restart interval.

 * The first sample in the row is undifferenced using the vertical

 * predictor (2).  The rest of the samples are undifferenced using the

 * predictor specified in the scan header.

 */

METHODDEF(void)

jpeg_undifference1(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  UNDIFFERENCE_1D(INITIAL_PREDICTOR2);

}

METHODDEF(void)

jpeg_undifference2(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

   (void)cinfo;

  (void)comp_index;

 UNDIFFERENCE_2D(PREDICTOR2);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference3(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  UNDIFFERENCE_2D(PREDICTOR3);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference4a(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  UNDIFFERENCE_2D(PREDICTOR4A);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference4(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  UNDIFFERENCE_2D(PREDICTOR4);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference5(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  SHIFT_TEMPS

  UNDIFFERENCE_2D(PREDICTOR5);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference5a(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  SHIFT_TEMPS

  UNDIFFERENCE_2D(PREDICTOR5A);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference6(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  SHIFT_TEMPS

  UNDIFFERENCE_2D(PREDICTOR6);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference6a(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  SHIFT_TEMPS

  UNDIFFERENCE_2D(PREDICTOR6A);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference7(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  SHIFT_TEMPS

  UNDIFFERENCE_2D(PREDICTOR7);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

METHODDEF(void)

jpeg_undifference7a(j_decompress_ptr cinfo, int comp_index,

           const JDIFFROW diff_buf, const JDIFFROW prev_row,

           JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)cinfo;

  (void)comp_index;

  SHIFT_TEMPS

  UNDIFFERENCE_2D(PREDICTOR7A);

  JPEG_UNUSED(Rc);

  JPEG_UNUSED(Rb);

}

/*

 * Undifferencer for the first row in a scan or restart interval.  The first

 * sample in the row is undifferenced using the special predictor constant

 * x=2^(P-Pt-1).  The rest of the samples are undifferenced using the

 * 1-D horizontal predictor (1).

 */

METHODDEF(void)

jpeg_undifference_first_row(j_decompress_ptr cinfo, int comp_index,

                const JDIFFROW diff_buf, JDIFFROW prev_row,

                JDIFFROW undiff_buf, JDIMENSION width)

{

  (void)prev_row;

  j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;

  UNDIFFERENCE_1D(INITIAL_PREDICTORx);

  /*

   * Now that we have undifferenced the first row, we want to use the

   * undifferencer which corresponds to the predictor specified in the

   * scan header.

   */

  switch (cinfo->Ss) {

  case 1:

    losslsd->predict_undifference[comp_index] = jpeg_undifference1;

    break;

  case 2:

    losslsd->predict_undifference[comp_index] = jpeg_undifference2;

    break;

  case 3:

    losslsd->predict_undifference[comp_index] = jpeg_undifference3;

    break;

  case 4:

    /* DCMTK specific code that is only needed in the 16-bit library.

     * Enables workaround for faulty images with integer overflow in predictor 6.

     */

    if (cinfo->workaround_options & WORKAROUND_PREDICTOR6OVERFLOW)

      losslsd->predict_undifference[comp_index] = jpeg_undifference4a;

      else losslsd->predict_undifference[comp_index] = jpeg_undifference4;

    break;

  case 5:

    /* DCMTK specific code that is only needed in the 16-bit library.

     * Enables workaround for faulty images with integer overflow in predictor 6.

     */

    if (cinfo->workaround_options & WORKAROUND_PREDICTOR6OVERFLOW)

      losslsd->predict_undifference[comp_index] = jpeg_undifference5a;

      else losslsd->predict_undifference[comp_index] = jpeg_undifference5;

    break;

  case 6:

    /* DCMTK specific code that is only needed in the 16-bit library.

     * Enables workaround for faulty images with integer overflow in predictor 6.

     */

    if (cinfo->workaround_options & WORKAROUND_PREDICTOR6OVERFLOW)

      losslsd->predict_undifference[comp_index] = jpeg_undifference6a;

      else losslsd->predict_undifference[comp_index] = jpeg_undifference6;

    break;

  case 7:

    /* DCMTK specific code that is only needed in the 16-bit library.

     * Enables workaround for faulty images with integer overflow in predictor 6.

     */

    if (cinfo->workaround_options & WORKAROUND_PREDICTOR6OVERFLOW)

      losslsd->predict_undifference[comp_index] = jpeg_undifference7a;

      else losslsd->predict_undifference[comp_index] = jpeg_undifference7;

    break;

  }

}

/*

 * Initialize for an input processing pass.

 */

METHODDEF(void)

predict_start_pass (j_decompress_ptr cinfo)

{

  j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;

  int ci;

  /* Check that the scan parameters Ss, Se, Ah, Al are OK for lossless JPEG.

   *

   * Ss is the predictor selection value (psv).  Legal values for sequential

   * lossless JPEG are: 1 <= psv <= 7.

   *

   * Se and Ah are not used and should be zero.

   *

   * Al specifies the point transform (Pt).  Legal values are: 0 <= Pt <= 15.

   */

  if (cinfo->Ss < 1 || cinfo->Ss > 7 ||

      cinfo->Se != 0 || cinfo->Ah != 0 ||

      cinfo->Al > 15)               /* need not check for < 0 */

    ERREXIT4(cinfo, JERR_BAD_LOSSLESS,

         cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);

  /* Set undifference functions to first row function */

  for (ci = 0; ci < cinfo->num_components; ci++)

    losslsd->predict_undifference[ci] = jpeg_undifference_first_row;

}

/*

 * Module initialization routine for the undifferencer.

 */

GLOBAL(void)

jinit_undifferencer (j_decompress_ptr cinfo)

{

  j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;

  losslsd->predict_start_pass = predict_start_pass;

  losslsd->predict_process_restart = predict_start_pass;

}

#endif /* D_LOSSLESS_SUPPORTED */