kc3-lang/libjpeg-turbo/src/jclossls.c

• Show log

  Commit

• Hash : 6ec8e41f
  Author :
  Date : 2024-06-13T11:52:13
  

  Handle lossless JPEG images w/2-15 bits per sample
  
  Closes #768
  Closes #769
  

Download

• src/jclossls.c

• /*
   * jclossls.c
   *
   * This file was part of the Independent JPEG Group's software:
   * Copyright (C) 1998, Thomas G. Lane.
   * Lossless JPEG Modifications:
   * Copyright (C) 1999, Ken Murchison.
   * libjpeg-turbo Modifications:
   * Copyright (C) 2022, 2024, D. R. Commander.
   * For conditions of distribution and use, see the accompanying README.ijg
   * file.
   *
   * This file contains prediction, sample differencing, and point transform
   * routines for the lossless JPEG compressor.
   */
  
  #define JPEG_INTERNALS
  #include "jinclude.h"
  #include "jpeglib.h"
  #include "jlossls.h"
  
  #ifdef C_LOSSLESS_SUPPORTED
  
  
  /************************** Sample differencing **************************/
  
  /*
   * In order to avoid a performance penalty for checking which predictor is
   * being used and which row is being processed for each call of the
   * undifferencer, and to promote optimization, we have separate differencing
   * functions for each predictor selection value.
   *
   * We are able to avoid duplicating source code by implementing the predictors
   * and differencers as macros.  Each of the differencing functions is simply a
   * wrapper around a DIFFERENCE macro with the appropriate PREDICTOR macro
   * passed as an argument.
   */
  
  /* Forward declarations */
  LOCAL(void) reset_predictor(j_compress_ptr cinfo, int ci);
  
  
  /* 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  prev_row[0]
  
  
  /*
   * 1-Dimensional differencer 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.
   */
  
  #define DIFFERENCE_1D(INITIAL_PREDICTOR) \
    lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct; \
    boolean restart = FALSE; \
    int samp, Ra; \
    \
    samp = *input_buf++; \
    *diff_buf++ = samp - INITIAL_PREDICTOR; \
    \
    while (--width) { \
      Ra = samp; \
      samp = *input_buf++; \
      *diff_buf++ = samp - PREDICTOR1; \
    } \
    \
    /* Account for restart interval (no-op if not using restarts) */ \
    if (cinfo->restart_interval) { \
      if (--(losslessc->restart_rows_to_go[ci]) == 0) { \
        reset_predictor(cinfo, ci); \
        restart = TRUE; \
      } \
    }
  
  
  /*
   * 2-Dimensional differencer 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, and 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.
   */
  
  #define DIFFERENCE_2D(PREDICTOR) \
    lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct; \
    int samp, Ra, Rb, Rc; \
    \
    Rb = *prev_row++; \
    samp = *input_buf++; \
    *diff_buf++ = samp - PREDICTOR2; \
    \
    while (--width) { \
      Rc = Rb; \
      Rb = *prev_row++; \
      Ra = samp; \
      samp = *input_buf++; \
      *diff_buf++ = samp - PREDICTOR; \
    } \
    \
    /* Account for restart interval (no-op if not using restarts) */ \
    if (cinfo->restart_interval) { \
      if (--losslessc->restart_rows_to_go[ci] == 0) \
        reset_predictor(cinfo, ci); \
    }
  
  
  /*
   * Differencers for the second and subsequent rows in a scan or restart
   * interval.  The first sample in the row is differenced using the vertical
   * predictor (2).  The rest of the samples are differenced using the predictor
   * specified in the scan header.
   */
  
  METHODDEF(void)
  jpeg_difference1(j_compress_ptr cinfo, int ci,
                   _JSAMPROW input_buf, _JSAMPROW prev_row,
                   JDIFFROW diff_buf, JDIMENSION width)
  {
    DIFFERENCE_1D(INITIAL_PREDICTOR2);
    (void)(restart);
  }
  
  METHODDEF(void)
  jpeg_difference2(j_compress_ptr cinfo, int ci,
                   _JSAMPROW input_buf, _JSAMPROW prev_row,
                   JDIFFROW diff_buf, JDIMENSION width)
  {
    DIFFERENCE_2D(PREDICTOR2);
    (void)(Ra);
    (void)(Rc);
  }
  
  METHODDEF(void)
  jpeg_difference3(j_compress_ptr cinfo, int ci,
                   _JSAMPROW input_buf, _JSAMPROW prev_row,
                   JDIFFROW diff_buf, JDIMENSION width)
  {
    DIFFERENCE_2D(PREDICTOR3);
    (void)(Ra);
  }
  
  METHODDEF(void)
  jpeg_difference4(j_compress_ptr cinfo, int ci,
                   _JSAMPROW input_buf, _JSAMPROW prev_row,
                   JDIFFROW diff_buf, JDIMENSION width)
  {
    DIFFERENCE_2D(PREDICTOR4);
  }
  
  METHODDEF(void)
  jpeg_difference5(j_compress_ptr cinfo, int ci,
                   _JSAMPROW input_buf, _JSAMPROW prev_row,
                   JDIFFROW diff_buf, JDIMENSION width)
  {
    DIFFERENCE_2D(PREDICTOR5);
  }
  
  METHODDEF(void)
  jpeg_difference6(j_compress_ptr cinfo, int ci,
                   _JSAMPROW input_buf, _JSAMPROW prev_row,
                   JDIFFROW diff_buf, JDIMENSION width)
  {
    DIFFERENCE_2D(PREDICTOR6);
  }
  
  METHODDEF(void)
  jpeg_difference7(j_compress_ptr cinfo, int ci,
                   _JSAMPROW input_buf, _JSAMPROW prev_row,
                   JDIFFROW diff_buf, JDIMENSION width)
  {
    DIFFERENCE_2D(PREDICTOR7);
    (void)(Rc);
  }
  
  
  /*
   * Differencer for the first row in a scan or restart interval.  The first
   * sample in the row is differenced using the special predictor constant
   * x = 2 ^ (P-Pt-1).  The rest of the samples are differenced using the
   * 1-D horizontal predictor (1).
   */
  
  METHODDEF(void)
  jpeg_difference_first_row(j_compress_ptr cinfo, int ci,
                            _JSAMPROW input_buf, _JSAMPROW prev_row,
                            JDIFFROW diff_buf, JDIMENSION width)
  {
    DIFFERENCE_1D(INITIAL_PREDICTORx);
  
    /*
     * Now that we have differenced the first row, we want to use the
     * differencer that corresponds to the predictor specified in the
     * scan header.
     *
     * Note that we don't do this if we have just reset the predictor
     * for a new restart interval.
     */
    if (!restart) {
      switch (cinfo->Ss) {
      case 1:
        losslessc->predict_difference[ci] = jpeg_difference1;
        break;
      case 2:
        losslessc->predict_difference[ci] = jpeg_difference2;
        break;
      case 3:
        losslessc->predict_difference[ci] = jpeg_difference3;
        break;
      case 4:
        losslessc->predict_difference[ci] = jpeg_difference4;
        break;
      case 5:
        losslessc->predict_difference[ci] = jpeg_difference5;
        break;
      case 6:
        losslessc->predict_difference[ci] = jpeg_difference6;
        break;
      case 7:
        losslessc->predict_difference[ci] = jpeg_difference7;
        break;
      }
    }
  }
  
  /*
   * Reset predictor at the start of a pass or restart interval.
   */
  
  LOCAL(void)
  reset_predictor(j_compress_ptr cinfo, int ci)
  {
    lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct;
  
    /* Initialize restart counter */
    losslessc->restart_rows_to_go[ci] =
      cinfo->restart_interval / cinfo->MCUs_per_row;
  
    /* Set difference function to first row function */
    losslessc->predict_difference[ci] = jpeg_difference_first_row;
  }
  
  
  /********************** Sample downscaling by 2^Pt ***********************/
  
  METHODDEF(void)
  simple_downscale(j_compress_ptr cinfo,
                   _JSAMPROW input_buf, _JSAMPROW output_buf, JDIMENSION width)
  {
    do {
      *output_buf++ = (_JSAMPLE)RIGHT_SHIFT(*input_buf++, cinfo->Al);
    } while (--width);
  }
  
  
  METHODDEF(void)
  noscale(j_compress_ptr cinfo,
          _JSAMPROW input_buf, _JSAMPROW output_buf, JDIMENSION width)
  {
    memcpy(output_buf, input_buf, width * sizeof(_JSAMPLE));
  }
  
  
  /*
   * Initialize for a processing pass.
   */
  
  METHODDEF(void)
  start_pass_lossless(j_compress_ptr cinfo)
  {
    lossless_comp_ptr losslessc = (lossless_comp_ptr)cinfo->fdct;
    int ci;
  
    /* Set scaler function based on Pt */
    if (cinfo->Al)
      losslessc->scaler_scale = simple_downscale;
    else
      losslessc->scaler_scale = noscale;
  
    /* Check that the restart interval is an integer multiple of the number
     * of MCUs in an MCU row.
     */
    if (cinfo->restart_interval % cinfo->MCUs_per_row != 0)
      ERREXIT2(cinfo, JERR_BAD_RESTART,
               cinfo->restart_interval, cinfo->MCUs_per_row);
  
    /* Set predictors for start of pass */
    for (ci = 0; ci < cinfo->num_components; ci++)
      reset_predictor(cinfo, ci);
  }
  
  
  /*
   * Initialize the lossless compressor.
   */
  
  GLOBAL(void)
  _jinit_lossless_compressor(j_compress_ptr cinfo)
  {
    lossless_comp_ptr losslessc;
  
  #if BITS_IN_JSAMPLE == 8
    if (cinfo->data_precision > BITS_IN_JSAMPLE || cinfo->data_precision < 2)
  #else
    if (cinfo->data_precision > BITS_IN_JSAMPLE ||
        cinfo->data_precision < BITS_IN_JSAMPLE - 3)
  #endif
      ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
  
    /* Create subobject in permanent pool */
    losslessc = (lossless_comp_ptr)
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
                                  sizeof(jpeg_lossless_compressor));
    cinfo->fdct = (struct jpeg_forward_dct *)losslessc;
    losslessc->pub.start_pass = start_pass_lossless;
  }
  
  #endif /* C_LOSSLESS_SUPPORTED */
  

Download