kc3-lang/libjpeg-turbo/jdmerge.h

• 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

• jdmerge.h

• /*
   * jdmerge.h
   *
   * This file was part of the Independent JPEG Group's software:
   * Copyright (C) 1994-1996, Thomas G. Lane.
   * libjpeg-turbo Modifications:
   * Copyright (C) 2020, 2022, D. R. Commander.
   * For conditions of distribution and use, see the accompanying README.ijg
   * file.
   */
  
  #define JPEG_INTERNALS
  #include "jpeglib.h"
  #include "jsamplecomp.h"
  
  #ifdef UPSAMPLE_MERGING_SUPPORTED
  
  
  /* Private subobject */
  
  typedef struct {
    struct jpeg_upsampler pub;    /* public fields */
  
    /* Pointer to routine to do actual upsampling/conversion of one row group */
    void (*upmethod) (j_decompress_ptr cinfo, _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 */
    JLONG *Cr_g_tab;              /* => table for Cr to G conversion */
    JLONG *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
     * application provides just a one-row buffer; we also use the spare
     * to discard the dummy last row if the image height is odd.
     */
    _JSAMPROW spare_row;
    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 */
  } my_merged_upsampler;
  
  typedef my_merged_upsampler *my_merged_upsample_ptr;
  
  #endif /* UPSAMPLE_MERGING_SUPPORTED */
  

Download