Branch

  • Show log

    Commit

  • Hash : e8b40f3c
    Author : DRC
    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.
    

  • Properties

  • Git HTTP https://git.kmx.io/kc3-lang/libjpeg-turbo.git
    Git SSH git@git.kmx.io:kc3-lang/libjpeg-turbo.git
    Public access ? public
    Description

    Fork of libjpeg with SIMD

    Users
    thodg_m kc3_lang_org thodg_w www_kmx_io thodg_l thodg
    Tags