// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// -----------------------------------------------------------------------------
//
// WP2 lossy encoding.
//

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <memory>

#include "src/common/lossy/transforms.h"
#include "src/enc/analysis.h"
#include "src/enc/wp2_enc_i.h"
#include "src/utils/utils.h"
#include "src/wp2/format_constants.h"

namespace WP2 {

WP2Status SyntaxWriter::Init(ANSDictionaries* const dicts,
                             const EncoderConfig& config,
                             const GlobalParams& gparams, const YUVPlane& yuv,
                             ChromaSubsampling chroma_subsampling,
                             const Rectangle& tile_rect, uint32_t num_blocks,
                             bool use_aom_coeffs, bool use_splits,
                             const ProgressRange& alpha_progress) {
  config_ = &config;
  dicts_ = dicts;
  recorded_blocks_ = 0;
  tile_rect_ = tile_rect;
  gparams_ = &gparams;
  assert(gparams_->IsOk());
  chroma_subsampling_ = chroma_subsampling;
  use_splits_ = use_splits;

  num_blocks_ = num_blocks;
  // Number of transforms is unknown yet, use a higher bound.
  num_transforms_ = std::min(
      num_blocks * 4, SizeBlocks(yuv.GetWidth()) * SizeBlocks(yuv.GetHeight()));
  // Deal with context.
  WP2_CHECK_STATUS(context_.Init(use_aom_coeffs, gparams_->segments_.size(),
                                 gparams_->explicit_segment_ids_,
                                 tile_rect.width));

  WP2_CHECK_STATUS(residual_writer_.Init(context_.use_aom(),
                                         gparams_->maybe_use_lossy_alpha_));


  if (gparams_->has_alpha_) {
    WP2_CHECK_STATUS(alpha_writer_.Init(*config_, gparams, context_, yuv,
                                        tile_rect, alpha_progress));
  } else {
    WP2_CHECK_STATUS(alpha_progress.AdvanceBy(1.));
  }

  if (kDebugPrintRate) {
    WP2_CHECK_ALLOC_OK(residual_rate_.resize(num_blocks));
  }

  return WP2_STATUS_OK;
}

WP2Status SyntaxWriter::CopyFrom(const SyntaxWriter& other,
                                 ANSDictionaries* const dicts) {
  config_ = other.config_;

  WP2_CHECK_OK(dicts != nullptr, WP2_STATUS_NULL_PARAMETER);
  WP2_CHECK_OK(dicts != other.dicts_, WP2_STATUS_INVALID_PARAMETER);
  dicts_ = dicts;

  WP2_CHECK_STATUS(context_.CopyFrom(other.context_));
  if (other.gparams_->has_alpha_) {
    WP2_CHECK_STATUS(alpha_writer_.CopyFrom(other.alpha_writer_, context_));
  }

  num_blocks_ = other.num_blocks_;
  num_transforms_ = other.num_transforms_;
  recorded_blocks_ = other.recorded_blocks_;
  tile_rect_ = other.tile_rect_;
  chroma_subsampling_ = other.chroma_subsampling_;
  gparams_ = other.gparams_;
  use_splits_ = other.use_splits_;

  WP2_CHECK_STATUS(
      symbol_writer_.CopyFrom(other.symbol_writer_, *dicts_, *other.dicts_));
  WP2_CHECK_STATUS(symbol_recorder_.CopyFrom(other.symbol_recorder_));
  WP2_CHECK_STATUS(counters_.CopyFrom(other.counters_, symbol_recorder_));
  residual_writer_.CopyFrom(other.residual_writer_);

  WP2_CHECK_ALLOC_OK(residual_rate_.copy_from(other.residual_rate_));
  return WP2_STATUS_OK;
}

WP2Status SyntaxWriter::InitPass() {
  SymbolsInfo symbols_info;
  WP2_CHECK_STATUS(symbols_info.InitLossy(
      gparams_->segments_.size(), gparams_->partition_set_,
      gparams_->maybe_use_lossy_alpha_, context_.use_aom(), use_splits_));
  symbols_info.SetMinMax(kSymbolModeY, /*min=*/0,
                         /*max=*/gparams_->y_preds_.GetMaxMode());
  if (gparams_->maybe_use_lossy_alpha_) {
    symbols_info.SetMinMax(kSymbolModeA, /*min=*/0,
                           /*max=*/gparams_->a_preds_.GetMaxMode());
  }
  symbols_info.SetMinMax(kSymbolModeUV, /*min=*/0,
                         /*max=*/gparams_->uv_preds_.GetMaxMode());
  const uint32_t num_channels = (gparams_->maybe_use_lossy_alpha_ ? 4 : 3);
  for (Channel c : {kYChannel, kUChannel, kVChannel, kAChannel}) {
    if (c == kAChannel && !gparams_->maybe_use_lossy_alpha_) continue;
    WP2_CHECK_STATUS(symbols_info.SetMinMax(
        kSymbolDC, ResidualIO::GetCluster(c, num_channels), /*min=*/0,
        /*max=*/gparams_->GetMaxDCRange(c)));
  }
  symbols_info.SetClusters(kSymbolDC, symbols_info.NumClusters(kSymbolDC));

  WP2_CHECK_STATUS(symbol_writer_.Init(symbols_info, config_->effort));
  WP2_CHECK_STATUS(symbol_writer_.Allocate());
  if (pass_number_ == 0) {
    WP2_CHECK_STATUS(symbol_recorder_.Allocate(
        symbols_info, /*num_records=*/num_blocks_ * kMaxBlockSize2));
  } else {
    WP2_CHECK_STATUS(symbol_recorder_.MakeBackup());
  }
  ++pass_number_;
  WP2_CHECK_STATUS(
      counters_.Init(config_->effort, context_.use_aom(), symbol_recorder_));
  context_.Reset();
  if (recorded_blocks_ > 0) WP2_CHECK_STATUS(ResetRecord());
  return WP2_STATUS_OK;
}

WP2Status SyntaxWriter::WriteHeader(ANSEncBase* const enc) {
  const uint32_t max_num_blocks =
      SizeBlocks(tile_rect_.width) * SizeBlocks(tile_rect_.height);
  // The minimum number of blocks is not accurate but it is not worth it to have
  // a more complex solution (neglictible pessimization).
  const uint32_t min_num_blocks = std::max(1u, max_num_blocks / kMaxBlockSize2);
  // This is also used for partitioning with an upper bound of 'num_blocks_'.
  assert((num_blocks_ == max_num_blocks) || (recorded_blocks_ == num_blocks_));
  ANSDebugPrefix prefix(enc, "GlobalHeader");

  // TODO(skal): differential-write of gparams_

  enc->PutBool(context_.use_aom(), "use_aom_coeffs");
  if (gparams_->partition_snapping_) {
    enc->PutBool(use_splits_, "use_splits");
  } else {
    assert(!use_splits_);
  }

  // Write dictionaries.
  PutLargeRange(num_blocks_, min_num_blocks, max_num_blocks, enc, "num_blocks");

  // If there's only one block, we don't need this global value, we'll signal
  // the subsampling mode for that block later.
  if (chroma_subsampling_ != ChromaSubsampling::kSingleBlock) {
    enc->PutRValue((int)chroma_subsampling_,
                   (int)ChromaSubsampling::kSingleBlock, "chroma_subsampling");
  }

  if (gparams_->explicit_segment_ids_) {
    WP2_CHECK_STATUS(symbol_writer_.WriteHeader(kSymbolSegmentId, num_blocks_,
                                                symbol_recorder_, "segment_id",
                                                enc, dicts_));
  }

  if (gparams_->use_rnd_mtx_) {
    WP2_CHECK_STATUS(symbol_writer_.WriteHeader(
        kSymbolRndMtx0, num_blocks_, symbol_recorder_, "rnd_mtx", enc, dicts_));
    WP2_CHECK_STATUS(symbol_writer_.WriteHeader(
        kSymbolUseRandomMatrix, num_blocks_, symbol_recorder_, "use_rnd_mtx",
        enc, dicts_));
  }
  WP2_CHECK_STATUS(
      symbol_writer_.WriteHeader(kSymbolSplitTransform, num_blocks_,
                                 symbol_recorder_, "split_tf", enc, dicts_));
  if (chroma_subsampling_ == ChromaSubsampling::kSingleBlock ||
      chroma_subsampling_ == ChromaSubsampling::kAdaptive) {
    WP2_CHECK_STATUS(symbol_writer_.WriteHeader(
        kSymbolYuv420, num_blocks_, symbol_recorder_, "yuv420", enc, dicts_));
  }
  WP2_CHECK_STATUS(symbol_writer_.WriteHeader(kSymbolTransform, num_blocks_,
                                              symbol_recorder_, "transform",
                                              enc, dicts_));

  WP2_CHECK_STATUS(symbol_writer_.WriteHeader(
      kSymbolModeY, num_blocks_, symbol_recorder_, "mode", enc, dicts_));
  WP2_CHECK_STATUS(symbol_writer_.WriteHeader(
      kSymbolModeUV, num_blocks_, symbol_recorder_, "mode", enc, dicts_));

  // TODO(maryla): not necessary if the SignalingCflPredictor isn't used.
  const uint32_t num_channels_using_cfl =
      gparams_->maybe_use_lossy_alpha_ ? 3 : 2;
  WP2_CHECK_STATUS(symbol_writer_.WriteHeader(
      kSymbolCflSlope, num_channels_using_cfl * num_blocks_, symbol_recorder_,
      "cfl", enc, dicts_));

  WP2_CHECK_STATUS(symbol_writer_.WriteHeader(kSymbolBlockSize, num_blocks_,
                                              symbol_recorder_, "block_size",
                                              enc, dicts_));

  const uint32_t num_coeffs_max =
      max_num_blocks * kMinBlockSizePix * kMinBlockSizePix;
  const uint32_t num_coeffs_max_uv =
      (chroma_subsampling_ == ChromaSubsampling::k420) ? num_coeffs_max / 4
                                                       : num_coeffs_max;
  // We should always have a UV block.
  assert(num_coeffs_max_uv > 0);

  WP2_CHECK_STATUS(context_.segment_id_predictor().WriteHeader(enc));

  if (gparams_->has_alpha_) {
    WP2_CHECK_STATUS(alpha_writer_.WriteHeader(num_coeffs_max, enc));

    if (alpha_writer_.GetAlphaMode() == kAlphaModeLossy) {
      WP2_CHECK_STATUS(symbol_writer_.WriteHeader(
          kSymbolBlockAlphaMode, num_blocks_, symbol_recorder_,
          "block_alpha_mode", enc, dicts_));
    }
    if (alpha_writer_.GetAlphaMode() != kAlphaModeLossless) {
      WP2_CHECK_STATUS(symbol_writer_.WriteHeader(
          kSymbolModeA, num_blocks_, symbol_recorder_, "mode", enc, dicts_));
    }
  }

  WP2_CHECK_STATUS(residual_writer_.WriteHeader(
      num_coeffs_max, num_coeffs_max_uv, num_transforms_,
      gparams_->has_alpha_ &&
          (alpha_writer_.GetAlphaMode() != kAlphaModeLossless),
      symbol_recorder_, dicts_, enc, &symbol_writer_));

  return enc->GetStatus();
}

void SyntaxWriter::WriteBlockBeforeCoeffs(const CodedBlock& cb,
                                          SymbolManager* const sm,
                                          ANSEncBase* const enc) {
  context_.segment_id_predictor().WriteId(cb, sm, enc);
  context_.segment_id_predictor().RecordId(cb);

  if (gparams_->has_alpha_) {
    alpha_writer_.WriteBlockBeforeCoeffs(cb, sm, enc);
  } else if (!gparams_->maybe_use_lossy_alpha_) {
    assert(!cb.HasLossyAlpha());
  }

  for (Channel channel : {kYChannel, kAChannel, kUChannel, kVChannel}) {
    if (channel == kAChannel && !cb.HasLossyAlpha()) continue;
    WritePredictors(cb, channel, sm, enc);
  }

  if (chroma_subsampling_ == ChromaSubsampling::kSingleBlock ||
      chroma_subsampling_ == ChromaSubsampling::kAdaptive) {
    sm->Process(kSymbolYuv420, cb.is420_, "yuv420", enc);
  }

  for (Channel channel : {kYChannel, kUChannel, kVChannel, kAChannel}) {
    if (channel == kAChannel && !cb.HasLossyAlpha()) continue;
    WriteSplitTransform(cb, channel, sm, enc);
    WriteHasCoeffs(cb, channel, sm, enc);
    WriteTransform(cb, channel, sm, enc);
  }

  if (!context_.use_aom()) {
    ANSDebugPrefix prefix(enc, "coeff_method");
    gparams_->segments_[cb.id_].StoreEncodingMethods(cb, sm, enc);
  }

  if (cb.mtx_set_ != nullptr) {
#if defined(ENABLE_RND_MTX)
    const bool can_use =
        gparams_->mtx_set_.IsOk(cb.mtx_[kYChannel], cb.tdim(kYChannel));
    if (can_use) {
      sm->Process(kSymbolUseRandomMatrix, cb.use_mtx_, "use_rnd_mtx", enc);
      if (cb.use_mtx_) {
        sm->Process(kSymbolRndMtx0, cb.mtx_[kYChannel], "rnd_mtx_y", enc);
      }
    } else {
      assert(!cb.use_mtx_);
    }
#endif
  }
}

void SyntaxWriter::WritePredictors(const CodedBlock& cb, Channel channel,
                                   SymbolManager* const sm,
                                   ANSEncBase* const enc) {
  ANSDebugPrefix prefix(enc, "pred_modes");
  const CodedBlock::CodingParams& params = cb.GetCodingParams(channel);
  if (channel == kYChannel) {
    if (cb.y_context_is_constant_) return;
    sm->Process(kSymbolModeY, params.pred->mode(), "y", enc);
  } else if (channel == kUChannel) {
    sm->Process(kSymbolModeUV, params.pred->mode(), "uv", enc);
  } else if (channel == kVChannel) {
    // kVChannel is not written as it is the same as kUChannel.
  } else {
    sm->Process(kSymbolModeA, params.pred->mode(), "a", enc);
  }
  /* sub_mode = */params.pred->WriteParams(cb, channel, sm, enc);
}

void SyntaxWriter::WriteSplitTransform(const CodedBlock& cb, Channel channel,
                                       SymbolManager* const sm,
                                       ANSEncBase* const enc) {
  if (channel == kYChannel &&
      GetSplitSize(cb.dim(), /*split=*/true) != cb.dim()) {
    sm->Process(kSymbolSplitTransform, cb.GetCodingParams(channel).split_tf,
                "split_tf", enc);
  } else {
    assert(!cb.GetCodingParams(channel).split_tf);
  }
}

void SyntaxWriter::WriteHasCoeffs(const CodedBlock& cb, Channel channel,
                                  SymbolManager* const sm,
                                  ANSEncBase* const enc) {
  for (uint32_t tf_i = 0; tf_i < cb.GetNumTransforms(channel); ++tf_i) {
    const bool tf_has_coeffs = (cb.num_coeffs_[channel][tf_i] != 0);
    const uint32_t cluster = (uint32_t)channel;
    sm->Process(kSymbolHasCoeffs, cluster, tf_has_coeffs ? 1 : 0, "has_coeffs",
                enc);
  }
}

void SyntaxWriter::WriteTransform(const CodedBlock& cb, Channel channel,
                                  SymbolManager* const sm,
                                  ANSEncBase* const enc) {
  const CodedBlock::CodingParams& params = cb.GetCodingParams(channel);
  if (channel == kUChannel || channel == kVChannel || channel == kAChannel) {
    assert(params.tf == kDctDct);
  } else if (cb.HasCoeffs(channel)) {
    // TODO(maryla): try more ways to signal the transform which might be
    //               correlated to block size.
    sm->Process(kSymbolTransform, params.tf, "transform", enc);
  } else {
    // No need to signal the transform as there is no coeff.
  }
}

void SyntaxWriter::RecordBlockHeader(const CodedBlock& cb) {
  ANSEncNoop enc;
  WriteBlockBeforeCoeffs(cb, &symbol_recorder_, &enc);
}

WP2Status SyntaxWriter::WriteBlocks(const Vector<CodedBlock>& cblocks,
                                    const Vector_u16& size_order_indices,
                                    FrontMgrDoubleOrderBase* const mgr,
                                    ANSEnc* const enc) {
  assert(cblocks.size() == num_blocks_);
  assert(cblocks.size() == size_order_indices.size());
  // Note: we could call segment_ids_.InitMap(bw, bh) again here.
  WP2_CHECK_STATUS(residual_writer_.Init(context_.use_aom(),
                                         gparams_->maybe_use_lossy_alpha_));
  context_.Reset();
  assert(size_order_indices.size() == num_blocks_);
  mgr->Clear();
  uint32_t block_idx = 0;
  for (uint16_t ind : size_order_indices) {
    {
      ANSDebugPrefix prefix(enc, "BlockHeader");
      const CodedBlock& cb = cblocks[ind];
      WriteBlockSize(*mgr, cb.dim(), &symbol_writer_, enc);
      Block block_tmp;
      WP2_CHECK_ALLOC_OK(mgr->UseSize(cb.dim(), &block_tmp));
      assert(block_tmp == cb.blk());
    }
    while (true) {
      Block block;
      if (!mgr->UseReady(&block)) break;
      const CodedBlock& cb = cblocks[block_idx];
      assert(cb.blk() == block);
      WP2_CHECK_STATUS(WriteBlock(cb, block_idx, enc));
      ++block_idx;
    }
  }

  if (kDebugPrintRate) {
    float total_estimated = 0.f;
    float total_actual = 0.f;
    float total_difference = 0.f;
    float max_difference = 0.f;
    uint32_t num_non_zero = 0;
    for (uint32_t i = 0; i < cblocks.size(); ++i) {
      const CodedBlock& cb = cblocks[i];
      for (Channel c : {kYChannel, kUChannel, kVChannel, kAChannel}) {
        if (c == kAChannel && !cb.HasLossyAlpha()) continue;

        const float estimated_rate = residual_rate_[i][c];
        const float actual_rate = residual_rate_[i][4 + c];
        total_estimated += estimated_rate;
        total_actual += actual_rate;

        if (actual_rate == 0 && estimated_rate == 0) continue;

        fprintf(stderr,
                "block (%3d %3d) channel %d rate: estimated %6.2f vs real "
                "%6.2f, %+4.2f",
                cb.x(), cb.y(), c, estimated_rate, actual_rate,
                actual_rate - estimated_rate);

        if (estimated_rate != 0) {
          ++num_non_zero;
          const float relative_difference = actual_rate / estimated_rate - 1.f;
          const float abs_difference = std::abs(relative_difference);
          total_difference += abs_difference;
          if (abs_difference > max_difference) max_difference = abs_difference;
          fprintf(stderr, "  %+.2f%%\n", relative_difference * 100.f);
        } else {
          fprintf(stderr, "\n");
        }
      }
    }
    fprintf(
        stderr,
        "Total residual rate estimated %.2f vs real %.2f, "
        "%+.2f%%, average difference (for non zero rates) %.2f%% max %.2f%%\n",
        total_estimated, total_actual,
        (total_estimated / total_actual - 1.f) * 100.f,
        total_difference / num_non_zero * 100, max_difference * 100);
  }

  return enc->GetStatus();
}

WP2Status SyntaxWriter::WriteBlocksUseSplits(const Vector<CodedBlock>& cblocks,
                                             const Vector_u32& splits,
                                             ANSEnc* const enc) {
  assert(cblocks.size() == num_blocks_);
  // Note: we could call segment_ids_.InitMap(bw, bh) again here.
  WP2_CHECK_STATUS(residual_writer_.Init(context_.use_aom(),
                                         gparams_->maybe_use_lossy_alpha_));
  context_.Reset();

  SplitIteratorDefault it;
  WP2_CHECK_STATUS(
      it.Init(gparams_->partition_set_, tile_rect_.width, tile_rect_.height));

  uint32_t block_idx = 0;
  uint32_t split_idx = 0;
  while (!it.Done()) {
    if (it.CurrentBlock().splittable) {
      ANSDebugPrefix prefix(enc, "BlockHeader");
      const uint32_t split = splits[split_idx];
      WriteBlockSplit(it, split, &symbol_writer_, enc);
      it.SplitCurrentBlock(split);
      ++split_idx;
    } else {
      const CodedBlock& cb = cblocks[block_idx];
      assert(cb.blk() == it.CurrentBlock().block);
      WP2_CHECK_STATUS(WriteBlock(cb, block_idx, enc));
      it.NextBlock();
      ++block_idx;
    }
  }
  return enc->GetStatus();
}

//------------------------------------------------------------------------------

void SyntaxWriter::FindBestEncodingMethods(CodedBlock* const cb) {
  const uint32_t num_channels = (gparams_->maybe_use_lossy_alpha_ ? 4 : 3);
  for (auto c : {kYChannel, kUChannel, kVChannel, kAChannel}) {
    if (c == kAChannel && !cb->HasLossyAlpha()) continue;
    for (uint32_t tf_i = 0; tf_i < cb->GetNumTransforms(c); ++tf_i) {
      if (context_.use_aom()) {
        ResidualWriter::SetGeometry(cb->num_coeffs_[c][tf_i],
                                    &cb->method_[c][tf_i]);
      } else {
        residual_writer_.FindBestEncodingMethod(
            cb->tdim(c), cb->coeffs_[c][tf_i], cb->num_coeffs_[c][tf_i],
            cb->IsFirstCoeffDC(c), c, num_channels, counters_.residuals(),
            &cb->method_[c][tf_i]);
      }
    }
  }
}

WP2Status SyntaxWriter::DecideAlpha(CodedBlock* const cb,
                                    const BlockModes& modes,
                                    BlockScorer* const scorer) {
  return alpha_writer_.DecideAlpha(cb, modes, residual_writer_, &counters_,
                                   scorer);
}

WP2Status SyntaxWriter::RecordAlpha(const CodedBlock& cb) {
  return alpha_writer_.Record(cb);
}

WP2Status SyntaxWriter::SetInitialSegmentIds() {
  const Rectangle padded_tile_rect = {tile_rect_.x, tile_rect_.y,
                                      Pad(tile_rect_.width, kPredWidth),
                                      Pad(tile_rect_.height, kPredWidth)};
  CodedBlock cb;
  cb.SetDimDefault(Block(0, 0, BLK_4x4));
  FrontMgr4x4 mgr;
  WP2_CHECK_STATUS(
      mgr.InitBase(padded_tile_rect.width, padded_tile_rect.height));
  for (uint32_t y = 0; y < SizeBlocks(padded_tile_rect.height); ++y) {
    for (uint32_t x = 0; x < SizeBlocks(padded_tile_rect.width); ++x) {
      cb.SetXY(mgr, x, y);
      cb.id_ = AssignSegmentId(*config_, *gparams_, padded_tile_rect, cb.blk());
      context_.segment_id_predictor().InitInitialSegmentId(cb, cb.id_);
      mgr.Use4x4();
    }
  }
  return WP2_STATUS_OK;
}

//------------------------------------------------------------------------------

void SyntaxWriter::Record(const CodedBlock& cb) {
  assert(recorded_blocks_ < num_blocks_);

  RecordBlockHeader(cb);
  const uint32_t num_channels = (gparams_->maybe_use_lossy_alpha_ ? 4 : 3);
  for (Channel channel : {kYChannel, kUChannel, kVChannel, kAChannel}) {
    if (channel == kAChannel && !cb.HasLossyAlpha()) continue;

    if (kDebugPrintRate) {
      residual_rate_[recorded_blocks_][channel] = cb.ResidualRate(
          context_, channel, num_channels, counters_.residuals());
    }

    residual_writer_.RecordCoeffs(cb, channel, &symbol_recorder_);
  }

  ++recorded_blocks_;
}

void SyntaxWriter::RecordSize(const FrontMgrDoubleOrderBase& mgr,
                              BlockSize dim) {
  RecordSize(dim, mgr.GetMaxPossibleBlock().dim(), mgr.GetPartitionSet());
}

void SyntaxWriter::RecordSize(BlockSize dim, BlockSize max_possible_size,
                              PartitionSet partition_set) {
  assert(!use_splits_);
  ANSEncNoop enc;
  WriteBlockSize(dim, max_possible_size, partition_set, &symbol_recorder_,
                 &enc);
}

WP2Status SyntaxWriter::RecordSplit(const SplitIteratorBase& mgr,
                                    uint32_t split_idx) {
  assert(use_splits_);
  ANSEncNoop enc;
  WriteBlockSplit(mgr, split_idx, &symbol_recorder_, &enc);
  return WP2_STATUS_OK;
}

WP2Status SyntaxWriter::ResetRecord() {
  recorded_blocks_ = 0;
  WP2_CHECK_STATUS(symbol_recorder_.ResetRecord(/*reset_backup=*/false));
  if (gparams_->has_alpha_) {
    WP2_CHECK_STATUS(alpha_writer_.ResetRecord());
  }
  return WP2_STATUS_OK;
}

WP2Status SyntaxWriter::WriteBlock(const CodedBlock& cb, uint32_t block_index,
                                   ANSEnc* const enc) {
  {
    ANSDebugPrefix prefix(enc, "BlockHeader");
    WriteBlockBeforeCoeffs(cb, &symbol_writer_, enc);
  }

  float previous_cost;
  if (kDebugPrintRate) {
    previous_cost = enc->GetCost();
  }

  for (Channel c : {kYChannel, kUChannel, kVChannel, kAChannel}) {
    if (c == kAChannel && !cb.HasLossyAlpha()) continue;

    residual_writer_.WriteCoeffs(cb, c, enc, &symbol_writer_);
    if (kDebugPrintRate) {
      const float cost = enc->GetCost();
      const float actual_rate = cost - previous_cost;
      residual_rate_[block_index][4 + c] = actual_rate;
      previous_cost = cost;
    }
  }

  if (gparams_->has_alpha_) {
    WP2_CHECK_STATUS(alpha_writer_.Write(cb, enc));
  }
  if (cb.HasLossyAlpha()) assert(gparams_->has_alpha_);

#if defined(WP2_ENC_DEC_DEEP_MATCH)
  PutRawPixels(cb, cb.out_, enc);  // Debug
#endif
  return WP2_STATUS_OK;
}

}  // namespace WP2