kc3-lang/libjpeg-turbo/jfdctfst.c

• Show log

  Commit

• Hash : e8b40f3c
  Author :
  Date : 2022-11-01T21:45:39
  

  Vastly improve 12-bit JPEG integration
  
  The Gordian knot that 7fec5074f962b20ed00b4f5da4533e1e8d4ed8ac attempted
  to unravel was caused by the fact that there are several
  data-precision-dependent (JSAMPLE-dependent) fields and methods in the
  exposed libjpeg API structures, and if you change the exposed libjpeg
  API structures, then you have to change the whole API.  If you change
  the whole API, then you have to provide a whole new library to support
  the new API, and that makes it difficult to support multiple data
  precisions in the same application.  (It is not impossible, as example.c
  demonstrated, but using data-precision-dependent libjpeg API structures
  would have made the cjpeg, djpeg, and jpegtran source code hard to read,
  so it made more sense to build, install, and package 12-bit-specific
  versions of those applications.)
  
  Unfortunately, the result of that initial integration effort was an
  unreadable and unmaintainable mess, which is a problem for a library
  that is an ISO/ITU-T reference implementation.  Also, as I dug into the
  problem of lossless JPEG support, I realized that 16-bit lossless JPEG
  images are a thing, and supporting yet another version of the libjpeg
  API just for those images is untenable.
  
  In fact, however, the touch points for JSAMPLE in the exposed libjpeg
  API structures are minimal:
  
    - The colormap and sample_range_limit fields in jpeg_decompress_struct
    - The alloc_sarray() and access_virt_sarray() methods in
      jpeg_memory_mgr
    - jpeg_write_scanlines() and jpeg_write_raw_data()
    - jpeg_read_scanlines() and jpeg_read_raw_data()
    - jpeg_skip_scanlines() and jpeg_crop_scanline()
      (This is subtle, but both of those functions use JSAMPLE-dependent
      opaque structures behind the scenes.)
  
  It is much more readable and maintainable to provide 12-bit-specific
  versions of those six top-level API functions and to document that the
  aforementioned methods and fields must be type-cast when using 12-bit
  samples.  Since that eliminates the need to provide a 12-bit-specific
  version of the exposed libjpeg API structures, we can:
  
    - Compile only the precision-dependent libjpeg modules (the
      coefficient buffer controllers, the colorspace converters, the
      DCT/IDCT managers, the main buffer controllers, the preprocessing
      and postprocessing controller, the downsampler and upsamplers, the
      quantizers, the integer DCT methods, and the IDCT methods) for
      multiple data precisions.
    - Introduce 12-bit-specific methods into the various internal
      structures defined in jpegint.h.
    - Create precision-independent data type, macro, method, field, and
      function names that are prefixed by an underscore, and use an
      internal header to convert those into precision-dependent data
      type, macro, method, field, and function names, based on the value
      of BITS_IN_JSAMPLE, when compiling the precision-dependent libjpeg
      modules.
    - Expose precision-dependent jinit*() functions for each of the
      precision-dependent libjpeg modules.
    - Abstract the precision-dependent libjpeg modules by calling the
      appropriate precision-dependent jinit*() function, based on the
      value of cinfo->data_precision, from top-level libjpeg API
      functions.
  

Download

• jfdctfst.c

• /*
   * jfdctfst.c
   *
   * This file was part of the Independent JPEG Group's software:
   * Copyright (C) 1994-1996, Thomas G. Lane.
   * libjpeg-turbo Modifications:
   * Copyright (C) 2015, D. R. Commander.
   * For conditions of distribution and use, see the accompanying README.ijg
   * file.
   *
   * This file contains a fast, not so accurate integer implementation of the
   * forward DCT (Discrete Cosine Transform).
   *
   * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
   * on each column.  Direct algorithms are also available, but they are
   * much more complex and seem not to be any faster when reduced to code.
   *
   * This implementation is based on Arai, Agui, and Nakajima's algorithm for
   * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
   * Japanese, but the algorithm is described in the Pennebaker & Mitchell
   * JPEG textbook (see REFERENCES section in file README.ijg).  The following
   * code is based directly on figure 4-8 in P&M.
   * While an 8-point DCT cannot be done in less than 11 multiplies, it is
   * possible to arrange the computation so that many of the multiplies are
   * simple scalings of the final outputs.  These multiplies can then be
   * folded into the multiplications or divisions by the JPEG quantization
   * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
   * to be done in the DCT itself.
   * The primary disadvantage of this method is that with fixed-point math,
   * accuracy is lost due to imprecise representation of the scaled
   * quantization values.  The smaller the quantization table entry, the less
   * precise the scaled value, so this implementation does worse with high-
   * quality-setting files than with low-quality ones.
   */
  
  #define JPEG_INTERNALS
  #include "jinclude.h"
  #include "jpeglib.h"
  #include "jdct.h"               /* Private declarations for DCT subsystem */
  
  #ifdef DCT_IFAST_SUPPORTED
  
  
  /*
   * This module is specialized to the case DCTSIZE = 8.
   */
  
  #if DCTSIZE != 8
    Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
  #endif
  
  
  /* Scaling decisions are generally the same as in the LL&M algorithm;
   * see jfdctint.c for more details.  However, we choose to descale
   * (right shift) multiplication products as soon as they are formed,
   * rather than carrying additional fractional bits into subsequent additions.
   * This compromises accuracy slightly, but it lets us save a few shifts.
   * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
   * everywhere except in the multiplications proper; this saves a good deal
   * of work on 16-bit-int machines.
   *
   * Again to save a few shifts, the intermediate results between pass 1 and
   * pass 2 are not upscaled, but are represented only to integral precision.
   *
   * A final compromise is to represent the multiplicative constants to only
   * 8 fractional bits, rather than 13.  This saves some shifting work on some
   * machines, and may also reduce the cost of multiplication (since there
   * are fewer one-bits in the constants).
   */
  
  #define CONST_BITS  8
  
  
  /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
   * causing a lot of useless floating-point operations at run time.
   * To get around this we use the following pre-calculated constants.
   * If you change CONST_BITS you may want to add appropriate values.
   * (With a reasonable C compiler, you can just rely on the FIX() macro...)
   */
  
  #if CONST_BITS == 8
  #define FIX_0_382683433  ((JLONG)98)            /* FIX(0.382683433) */
  #define FIX_0_541196100  ((JLONG)139)           /* FIX(0.541196100) */
  #define FIX_0_707106781  ((JLONG)181)           /* FIX(0.707106781) */
  #define FIX_1_306562965  ((JLONG)334)           /* FIX(1.306562965) */
  #else
  #define FIX_0_382683433  FIX(0.382683433)
  #define FIX_0_541196100  FIX(0.541196100)
  #define FIX_0_707106781  FIX(0.707106781)
  #define FIX_1_306562965  FIX(1.306562965)
  #endif
  
  
  /* We can gain a little more speed, with a further compromise in accuracy,
   * by omitting the addition in a descaling shift.  This yields an incorrectly
   * rounded result half the time...
   */
  
  #ifndef USE_ACCURATE_ROUNDING
  #undef DESCALE
  #define DESCALE(x, n)  RIGHT_SHIFT(x, n)
  #endif
  
  
  /* Multiply a DCTELEM variable by an JLONG constant, and immediately
   * descale to yield a DCTELEM result.
   */
  
  #define MULTIPLY(var, const)  ((DCTELEM)DESCALE((var) * (const), CONST_BITS))
  
  
  /*
   * Perform the forward DCT on one block of samples.
   */
  
  GLOBAL(void)
  _jpeg_fdct_ifast(DCTELEM *data)
  {
    DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
    DCTELEM tmp10, tmp11, tmp12, tmp13;
    DCTELEM z1, z2, z3, z4, z5, z11, z13;
    DCTELEM *dataptr;
    int ctr;
    SHIFT_TEMPS
  
    /* Pass 1: process rows. */
  
    dataptr = data;
    for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
      tmp0 = dataptr[0] + dataptr[7];
      tmp7 = dataptr[0] - dataptr[7];
      tmp1 = dataptr[1] + dataptr[6];
      tmp6 = dataptr[1] - dataptr[6];
      tmp2 = dataptr[2] + dataptr[5];
      tmp5 = dataptr[2] - dataptr[5];
      tmp3 = dataptr[3] + dataptr[4];
      tmp4 = dataptr[3] - dataptr[4];
  
      /* Even part */
  
      tmp10 = tmp0 + tmp3;        /* phase 2 */
      tmp13 = tmp0 - tmp3;
      tmp11 = tmp1 + tmp2;
      tmp12 = tmp1 - tmp2;
  
      dataptr[0] = tmp10 + tmp11; /* phase 3 */
      dataptr[4] = tmp10 - tmp11;
  
      z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
      dataptr[2] = tmp13 + z1;    /* phase 5 */
      dataptr[6] = tmp13 - z1;
  
      /* Odd part */
  
      tmp10 = tmp4 + tmp5;        /* phase 2 */
      tmp11 = tmp5 + tmp6;
      tmp12 = tmp6 + tmp7;
  
      /* The rotator is modified from fig 4-8 to avoid extra negations. */
      z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
      z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
      z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
      z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
  
      z11 = tmp7 + z3;            /* phase 5 */
      z13 = tmp7 - z3;
  
      dataptr[5] = z13 + z2;      /* phase 6 */
      dataptr[3] = z13 - z2;
      dataptr[1] = z11 + z4;
      dataptr[7] = z11 - z4;
  
      dataptr += DCTSIZE;         /* advance pointer to next row */
    }
  
    /* Pass 2: process columns. */
  
    dataptr = data;
    for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
      tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];
      tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];
      tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];
      tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];
      tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];
      tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];
      tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];
      tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];
  
      /* Even part */
  
      tmp10 = tmp0 + tmp3;        /* phase 2 */
      tmp13 = tmp0 - tmp3;
      tmp11 = tmp1 + tmp2;
      tmp12 = tmp1 - tmp2;
  
      dataptr[DCTSIZE * 0] = tmp10 + tmp11; /* phase 3 */
      dataptr[DCTSIZE * 4] = tmp10 - tmp11;
  
      z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
      dataptr[DCTSIZE * 2] = tmp13 + z1; /* phase 5 */
      dataptr[DCTSIZE * 6] = tmp13 - z1;
  
      /* Odd part */
  
      tmp10 = tmp4 + tmp5;        /* phase 2 */
      tmp11 = tmp5 + tmp6;
      tmp12 = tmp6 + tmp7;
  
      /* The rotator is modified from fig 4-8 to avoid extra negations. */
      z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
      z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
      z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
      z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
  
      z11 = tmp7 + z3;            /* phase 5 */
      z13 = tmp7 - z3;
  
      dataptr[DCTSIZE * 5] = z13 + z2; /* phase 6 */
      dataptr[DCTSIZE * 3] = z13 - z2;
      dataptr[DCTSIZE * 1] = z11 + z4;
      dataptr[DCTSIZE * 7] = z11 - z4;
  
      dataptr++;                  /* advance pointer to next column */
    }
  }
  
  #endif /* DCT_IFAST_SUPPORTED */
  

Download