decode_internal.h - mozsearch

Enable keyboard shortcuts

// Copyright (c) the JPEG XL Project Authors. All rights reserved.

//

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

#ifndef LIB_JPEGLI_DECODE_INTERNAL_H_

#define LIB_JPEGLI_DECODE_INTERNAL_H_

#include <sys/types.h>

#include <cstdint>

#include <vector>

#include "lib/jpegli/common.h"

#include "lib/jpegli/common_internal.h"

#include "lib/jpegli/huffman.h"

#include "lib/jpegli/types.h"

namespace jpegli {

static constexpr int kNeedMoreInput = 100;

static constexpr int kHandleRestart = 101;

static constexpr int kHandleMarkerProcessor = 102;

static constexpr int kProcessNextMarker = 103;

static constexpr size_t kAllHuffLutSize = NUM_HUFF_TBLS * kJpegHuffmanLutSize;

typedef int16_t coeff_t;

// State of the decoder that has to be saved before decoding one MCU in case

// we run out of the bitstream.

struct MCUCodingState {

  coeff_t last_dc_coeff[kMaxComponents];

  int eobrun;

  coeff_t coeffs[D_MAX_BLOCKS_IN_MCU * DCTSIZE2];

};

}  // namespace jpegli

// Use this forward-declared libjpeg struct to hold all our private variables.

// TODO(szabadka) Remove variables that have a corresponding version in cinfo.

struct jpeg_decomp_master {

//

  // Input handling state.

//

  std::vector<uint8_t> input_buffer_;

  size_t input_buffer_pos_;

  // Number of bits after codestream_pos_ that were already processed.

  size_t codestream_bits_ahead_;

  // Coefficient buffers

  jvirt_barray_ptr* coef_arrays;

  JBLOCKARRAY coeff_rows[jpegli::kMaxComponents];

  bool streaming_mode_;

//

  // Marker data processing state.

//

  bool found_soi_;

  bool found_dri_;

  bool found_sof_;

  bool found_sos_;

  bool found_eoi_;

  // Whether this jpeg has multiple scans (progressive or non-interleaved

  // sequential).

  bool is_multiscan_;

  size_t icc_index_;

  size_t icc_total_;

  std::vector<uint8_t> icc_profile_;

  jpegli::HuffmanTableEntry dc_huff_lut_[jpegli::kAllHuffLutSize];

  jpegli::HuffmanTableEntry ac_huff_lut_[jpegli::kAllHuffLutSize];

  uint8_t markers_to_save_[32];

  jpeg_marker_parser_method app_marker_parsers[16];

  jpeg_marker_parser_method com_marker_parser;

  // Fields defined by SOF marker.

  size_t iMCU_cols_;

  int h_factor[jpegli::kMaxComponents];

  int v_factor[jpegli::kMaxComponents];

  // Initialized at start of frame.

  uint16_t scan_progression_[jpegli::kMaxComponents][DCTSIZE2];

//

  // Per scan state.

//

  size_t scan_mcu_row_;

  size_t scan_mcu_col_;

  size_t mcu_rows_per_iMCU_row_;

  jpegli::coeff_t last_dc_coeff_[jpegli::kMaxComponents];

  int eobrun_;

  int restarts_to_go_;

  int next_restart_marker_;

  jpegli::MCUCodingState mcu_;

//

  // Rendering state.

//

  int output_passes_done_;

  JpegliDataType output_data_type_ = JPEGLI_TYPE_UINT8;

  size_t xoffset_;

  bool swap_endianness_ = false;

  bool need_context_rows_;

  bool regenerate_inverse_colormap_;

  bool apply_smoothing;

  int min_scaled_dct_size;

  int scaled_dct_size[jpegli::kMaxComponents];

  size_t raw_height_[jpegli::kMaxComponents];

  jpegli::RowBuffer<float> raw_output_[jpegli::kMaxComponents];

  jpegli::RowBuffer<float> render_output_[jpegli::kMaxComponents];

  void (*inverse_transform[jpegli::kMaxComponents])(

      const int16_t* JXL_RESTRICT qblock, const float* JXL_RESTRICT dequant,

      const float* JXL_RESTRICT biases, float* JXL_RESTRICT scratch_space,

      float* JXL_RESTRICT output, size_t output_stride, size_t dctsize);

  void (*color_transform)(float* row[jpegli::kMaxComponents], size_t len);

  float* idct_scratch_;

  float* upsample_scratch_;

  uint8_t* output_scratch_;

  int16_t* smoothing_scratch_;

  float* dequant_;

  // 1 = 1pass, 2 = 2pass, 3 = external

  int quant_mode_;

  int quant_pass_;

  int num_colors_[jpegli::kMaxComponents];

  uint8_t* colormap_lut_;

  uint8_t* pixels_;

  JSAMPARRAY scanlines_;

  std::vector<std::vector<uint8_t>> candidate_lists_;

  float* dither_[jpegli::kMaxComponents];

  float* error_row_[2 * jpegli::kMaxComponents];

  size_t dither_size_;

  size_t dither_mask_;

  // Per channel and per frequency statistics about the number of nonzeros and

  // the sum of coefficient absolute values, used in dequantization bias

  // computation.

  int* nonzeros_;

  int* sumabs_;

  size_t num_processed_blocks_[jpegli::kMaxComponents];

  float* biases_;

#define SAVED_COEFS 10

  // This holds the coef_bits of the scan before the current scan,

  // i.e. the bottom half when rendering incomplete scans.

  int (*coef_bits_latch)[SAVED_COEFS];

  int (*prev_coef_bits_latch)[SAVED_COEFS];

};

#endif  // LIB_JPEGLI_DECODE_INTERNAL_H_