Quelle  encode_streaming.cc

// 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.

#include "lib/jpegli/encode_streaming.h"

#include <cmath>

#include "lib/jpegli/bit_writer.h"
#include "lib/jpegli/bitstream.h"
#include "lib/jpegli/entropy_coding.h"
#include "lib/jpegli/error.h"
#include "lib/jpegli/memory_manager.h"
#include "lib/jxl/base/bits.h"

#undef HWY_TARGET_INCLUDE
#define HWY_TARGET_INCLUDE "lib/jpegli/encode_streaming.cc"
#include <hwy/foreach_target.h>
#include <hwy/highway.h>

#include "lib/jpegli/dct-inl.h"
#include "lib/jpegli/entropy_coding-inl.h"

HWY_BEFORE_NAMESPACE();
namespace jpegli {
namespace HWY_NAMESPACE {

static const int kStreamingModeCoefficients = 0;
static const int kStreamingModeTokens = 1;
static const int kStreamingModeBits = 2;

namespace {
void ZigZagShuffle(int32_t* JXL_RESTRICT block) {
  // TODO(szabadka) SIMDify this.
  int32_t tmp[DCTSIZE2];
  tmp[0] = block[0];
  tmp[1] = block[1];
  tmp[2] = block[8];
  tmp[3] = block[16];
  tmp[4] = block[9];
  tmp[5] = block[2];
  tmp[6] = block[3];
  tmp[7] = block[10];
  tmp[8] = block[17];
  tmp[9] = block[24];
  tmp[10] = block[32];
  tmp[11] = block[25];
  tmp[12] = block[18];
  tmp[13] = block[11];
  tmp[14] = block[4];
  tmp[15] = block[5];
  tmp[16] = block[12];
  tmp[17] = block[19];
  tmp[18] = block[26];
  tmp[19] = block[33];
  tmp[20] = block[40];
  tmp[21] = block[48];
  tmp[22] = block[41];
  tmp[23] = block[34];
  tmp[24] = block[27];
  tmp[25] = block[20];
  tmp[26] = block[13];
  tmp[27] = block[6];
  tmp[28] = block[7];
  tmp[29] = block[14];
  tmp[30] = block[21];
  tmp[31] = block[28];
  tmp[32] = block[35];
  tmp[33] = block[42];
  tmp[34] = block[49];
  tmp[35] = block[56];
  tmp[36] = block[57];
  tmp[37] = block[50];
  tmp[38] = block[43];
  tmp[39] = block[36];
  tmp[40] = block[29];
  tmp[41] = block[22];
  tmp[42] = block[15];
  tmp[43] = block[23];
  tmp[44] = block[30];
  tmp[45] = block[37];
  tmp[46] = block[44];
  tmp[47] = block[51];
  tmp[48] = block[58];
  tmp[49] = block[59];
  tmp[50] = block[52];
  tmp[51] = block[45];
  tmp[52] = block[38];
  tmp[53] = block[31];
  tmp[54] = block[39];
  tmp[55] = block[46];
  tmp[56] = block[53];
  tmp[57] = block[60];
  tmp[58] = block[61];
  tmp[59] = block[54];
  tmp[60] = block[47];
  tmp[61] = block[55];
  tmp[62] = block[62];
  tmp[63] = block[63];
  memcpy(block, tmp, DCTSIZE2 * sizeof(tmp[0]));
}
}  // namespace

template <int kMode>
void ProcessiMCURow(j_compress_ptr cinfo) {
  jpeg_comp_master* m = cinfo->master;
  JpegBitWriter* bw = &m->bw;
  int xsize_mcus = DivCeil(cinfo->image_width, 8 * cinfo->max_h_samp_factor);
  int ysize_mcus = DivCeil(cinfo->image_height, 8 * cinfo->max_v_samp_factor);
  int mcu_y = m->next_iMCU_row;
  int32_t* block = m->block_tmp;
  int32_t* symbols = m->block_tmp + DCTSIZE2;
  int32_t* nonzero_idx = m->block_tmp + 3 * DCTSIZE2;
  coeff_t* JXL_RESTRICT last_dc_coeff = m->last_dc_coeff;
  bool adaptive_quant = m->use_adaptive_quantization && m->psnr_target == 0;
  JBLOCKARRAY blocks[kMaxComponents];
  if (kMode == kStreamingModeCoefficients) {
    for (int c = 0; c < cinfo->num_components; ++c) {
      jpeg_component_info* comp = &cinfo->comp_info[c];
      int by0 = mcu_y * comp->v_samp_factor;
      int block_rows_left = comp->height_in_blocks - by0;
      int max_block_rows = std::min(comp->v_samp_factor, block_rows_left);
      blocks[c] = (*cinfo->mem->access_virt_barray)(
          reinterpret_cast<j_common_ptr>(cinfo), m->coeff_buffers[c], by0,
          max_block_rows, true);
    }
  }
  if (kMode == kStreamingModeTokens) {
    TokenArray* ta = &m->token_arrays[m->cur_token_array];
    int max_tokens_per_mcu_row = MaxNumTokensPerMCURow(cinfo);
    if (ta->num_tokens + max_tokens_per_mcu_row > m->num_tokens) {
      if (ta->tokens) {
        m->total_num_tokens += ta->num_tokens;
        ++m->cur_token_array;
        ta = &m->token_arrays[m->cur_token_array];
      }
      m->num_tokens =
          EstimateNumTokens(cinfo, mcu_y, ysize_mcus, m->total_num_tokens,
                            max_tokens_per_mcu_row);
      ta->tokens = Allocate<Token>(cinfo, m->num_tokens, JPOOL_IMAGE);
      m->next_token = ta->tokens;
    }
  }
  const float* imcu_start[kMaxComponents];
  for (int c = 0; c < cinfo->num_components; ++c) {
    jpeg_component_info* comp = &cinfo->comp_info[c];
    imcu_start[c] = m->raw_data[c]->Row(mcu_y * comp->v_samp_factor * DCTSIZE);
  }
  const float* qf = nullptr;
  if (adaptive_quant) {
    qf = m->quant_field.Row(0);
  }
  HuffmanCodeTable* dc_code = nullptr;
  HuffmanCodeTable* ac_code = nullptr;
  const size_t qf_stride = m->quant_field.stride();
  for (int mcu_x = 0; mcu_x < xsize_mcus; ++mcu_x) {
    for (int c = 0; c < cinfo->num_components; ++c) {
      jpeg_component_info* comp = &cinfo->comp_info[c];
      if (kMode == kStreamingModeBits) {
        dc_code = &m->coding_tables[m->context_map[c]];
        ac_code = &m->coding_tables[m->context_map[c + 4]];
      }
      float* JXL_RESTRICT qmc = m->quant_mul[c];
      const size_t stride = m->raw_data[c]->stride();
      const int h_factor = m->h_factor[c];
      const float* zero_bias_offset = m->zero_bias_offset[c];
      const float* zero_bias_mul = m->zero_bias_mul[c];
      float aq_strength = 0.0f;
      for (int iy = 0; iy < comp->v_samp_factor; ++iy) {
        for (int ix = 0; ix < comp->h_samp_factor; ++ix) {
          size_t by = mcu_y * comp->v_samp_factor + iy;
          size_t bx = mcu_x * comp->h_samp_factor + ix;
          if (bx >= comp->width_in_blocks || by >= comp->height_in_blocks) {
            if (kMode == kStreamingModeTokens) {
              *m->next_token++ = Token(c, 0, 0);
              *m->next_token++ = Token(c + 4, 0, 0);
            } else if (kMode == kStreamingModeBits) {
              WriteBits(bw, dc_code->depth[0], dc_code->code[0]);
              WriteBits(bw, ac_code->depth[0], ac_code->code[0]);
            }
            continue;
          }
          if (adaptive_quant) {
            aq_strength = qf[iy * qf_stride + bx * h_factor];
          }
          const float* pixels = imcu_start[c] + (iy * stride + bx) * DCTSIZE;
          ComputeCoefficientBlock(pixels, stride, qmc, last_dc_coeff[c],
                                  aq_strength, zero_bias_offset, zero_bias_mul,
                                  m->dct_buffer, block);
          if (kMode == kStreamingModeCoefficients) {
            JCOEF* cblock = &blocks[c][iy][bx][0];
            for (int k = 0; k < DCTSIZE2; ++k) {
              cblock[k] = block[kJPEGNaturalOrder[k]];
            }
          }
          block[0] -= last_dc_coeff[c];
          last_dc_coeff[c] += block[0];
          if (kMode == kStreamingModeTokens) {
            ComputeTokensForBlock<int32_t, false>(block, 0, c, c + 4,
                                                  &m->next_token);
          } else if (kMode == kStreamingModeBits) {
            ZigZagShuffle(block);
            const int num_nonzeros = CompactBlock(block, nonzero_idx);
            const bool emit_eob = nonzero_idx[num_nonzeros - 1] < 1008;
            ComputeSymbols(num_nonzeros, nonzero_idx, block, symbols);
            WriteBlock(symbols, block, num_nonzeros, emit_eob, dc_code, ac_code,
                       bw);
          }
        }
      }
    }
  }
  if (kMode == kStreamingModeTokens) {
    TokenArray* ta = &m->token_arrays[m->cur_token_array];
    ta->num_tokens = m->next_token - ta->tokens;
    ScanTokenInfo* sti = &m->scan_token_info[0];
    sti->num_tokens = m->total_num_tokens + ta->num_tokens;
    sti->restarts[0] = sti->num_tokens;
  }
}

void ComputeCoefficientsForiMCURow(j_compress_ptr cinfo) {
  ProcessiMCURow<kStreamingModeCoefficients>(cinfo);
}

void ComputeTokensForiMCURow(j_compress_ptr cinfo) {
  ProcessiMCURow<kStreamingModeTokens>(cinfo);
}

void WriteiMCURow(j_compress_ptr cinfo) {
  ProcessiMCURow<kStreamingModeBits>(cinfo);
}

// NOLINTNEXTLINE(google-readability-namespace-comments)
}  // namespace HWY_NAMESPACE
}  // namespace jpegli
HWY_AFTER_NAMESPACE();

#if HWY_ONCE
namespace jpegli {
HWY_EXPORT(ComputeCoefficientsForiMCURow);
HWY_EXPORT(ComputeTokensForiMCURow);
HWY_EXPORT(WriteiMCURow);

void ComputeCoefficientsForiMCURow(j_compress_ptr cinfo) {
  HWY_DYNAMIC_DISPATCH(ComputeCoefficientsForiMCURow)(cinfo);
}

void ComputeTokensForiMCURow(j_compress_ptr cinfo) {
  HWY_DYNAMIC_DISPATCH(ComputeTokensForiMCURow)(cinfo);
}

void WriteiMCURow(j_compress_ptr cinfo) {
  HWY_DYNAMIC_DISPATCH(WriteiMCURow)(cinfo);
}

}  // namespace jpegli
#endif  // HWY_ONCE