kc3-lang/libjpeg-turbo/src/jdcoefct.h

• Show log

  Commit

• Hash : e69dd40c
  Author :
  Date : 2024-01-23T13:26:41
  

  Reorganize source to make things easier to find
  
  - Move all libjpeg documentation, except for README.ijg, into the doc/
    subdirectory.
  
  - Move the TurboJPEG C API documentation from doc/html/ into
    doc/turbojpeg/.
  
  - Move all C source code and headers into a src/ subdirectory.
  
  - Move turbojpeg-jni.c into the java/ subdirectory.
  
  Referring to #226, there is no ideal solution to this problem.  A
  semantically ideal solution would have involved placing all source code,
  including the SIMD and Java source code, under src/ (or perhaps placing
  C library source code under lib/ and C test program source code under
  test/), all header files under include/, and all documentation under
  doc/.  However:
  
  - To me it makes more sense to have separate top-level directories for
    each language, since the SIMD extensions and the Java API are
    technically optional features.  src/ now contains only the code that
    is relevant to the core C API libraries and associated programs.
  - I didn't want to bury the java/ and simd/ directories or add a level
    of depth to them, since both directories already contain source code
    that is 3-4 levels deep.
  - I would prefer not to separate the header files from the C source
    code, because:
    1. It would be disruptive.  libjpeg and libjpeg-turbo have
       historically placed C source code and headers in the same
       directory, and people who are familiar with both projects (self
       included) are used to looking for the headers in the same directory
       as the C source code.
    2. In terms of how the headers are used internally in libjpeg-turbo,
       the distinction between public and private headers is a bit fuzzy.
  - It didn't make sense to separate the test source code from the library
    source code, since there is not a clear distinction in some cases.
    (For instance, the IJG image I/O functions are used by cjpeg and djpeg
    as well as by the TurboJPEG API.)
  
  This solution is minimally disruptive, since it keeps all C source code
  and headers together and keeps java/ and simd/ as top-level directories.
  It is a bit awkward, because java/ and simd/ technically contain source
  code, even though they are not under src/.  However, other solutions
  would have been more awkward for different reasons.
  
  Closes #226
  

Download

• src/jdcoefct.h

• /*
   * jdcoefct.h
   *
   * This file was part of the Independent JPEG Group's software:
   * Copyright (C) 1994-1997, Thomas G. Lane.
   * libjpeg-turbo Modifications:
   * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
   * Copyright (C) 2020, Google, Inc.
   * Copyright (C) 2022, D. R. Commander.
   * For conditions of distribution and use, see the accompanying README.ijg
   * file.
   */
  
  #define JPEG_INTERNALS
  #include "jpeglib.h"
  
  
  #if BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED)
  
  /* Block smoothing is only applicable for progressive JPEG, so: */
  #ifndef D_PROGRESSIVE_SUPPORTED
  #undef BLOCK_SMOOTHING_SUPPORTED
  #endif
  
  
  /* Private buffer controller object */
  
  typedef struct {
    struct jpeg_d_coef_controller pub; /* public fields */
  
    /* These variables keep track of the current location of the input side. */
    /* cinfo->input_iMCU_row is also used for this. */
    JDIMENSION MCU_ctr;           /* counts MCUs processed in current row */
    int MCU_vert_offset;          /* counts MCU rows within iMCU row */
    int MCU_rows_per_iMCU_row;    /* number of such rows needed */
  
    /* The output side's location is represented by cinfo->output_iMCU_row. */
  
    /* In single-pass modes, it's sufficient to buffer just one MCU.
     * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
     * and let the entropy decoder write into that workspace each time.
     * In multi-pass modes, this array points to the current MCU's blocks
     * within the virtual arrays; it is used only by the input side.
     */
    JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
  
    /* Temporary workspace for one MCU */
    JCOEF *workspace;
  
  #ifdef D_MULTISCAN_FILES_SUPPORTED
    /* In multi-pass modes, we need a virtual block array for each component. */
    jvirt_barray_ptr whole_image[MAX_COMPONENTS];
  #endif
  
  #ifdef BLOCK_SMOOTHING_SUPPORTED
    /* When doing block smoothing, we latch coefficient Al values here */
    int *coef_bits_latch;
  #define SAVED_COEFS  10         /* we save coef_bits[0..9] */
  #endif
  } my_coef_controller;
  
  typedef my_coef_controller *my_coef_ptr;
  
  
  LOCAL(void)
  start_iMCU_row(j_decompress_ptr cinfo)
  /* Reset within-iMCU-row counters for a new row (input side) */
  {
    my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
  
    /* In an interleaved scan, an MCU row is the same as an iMCU row.
     * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
     * But at the bottom of the image, process only what's left.
     */
    if (cinfo->comps_in_scan > 1) {
      coef->MCU_rows_per_iMCU_row = 1;
    } else {
      if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows - 1))
        coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
      else
        coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
    }
  
    coef->MCU_ctr = 0;
    coef->MCU_vert_offset = 0;
  }
  
  #endif /* BITS_IN_JSAMPLE != 16 || defined(D_LOSSLESS_SUPPORTED) */
  

Download