// 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/jxl/modular/encoding/encoding.h"

#include <jxl/memory_manager.h>

#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <queue>
#include <utility>
#include <vector>

#include "lib/jxl/base/printf_macros.h"
#include "lib/jxl/base/scope_guard.h"
#include "lib/jxl/base/status.h"
#include "lib/jxl/dec_ans.h"
#include "lib/jxl/dec_bit_reader.h"
#include "lib/jxl/frame_dimensions.h"
#include "lib/jxl/image_ops.h"
#include "lib/jxl/modular/encoding/context_predict.h"
#include "lib/jxl/modular/options.h"
#include "lib/jxl/pack_signed.h"

namespace jxl {

// Removes all nodes that use a static property (i.e. channel or group ID) from
// the tree and collapses each node on even levels with its two children to
// produce a flatter tree. Also computes whether the resulting tree requires
// using the weighted predictor.
FlatTree FilterTree(const Tree &global_tree,
                    std::array<pixel_type, kNumStaticProperties> &static_props,
                    size_t *num_props, bool *use_wp, bool *wp_only,
                    bool *gradient_only) {
  *num_props = 0;
  bool has_wp = false;
  bool has_non_wp = false;
  *gradient_only = true;
  const auto mark_property = [&](int32_t p) {
    if (p == kWPProp) {
      has_wp = true;
    } else if (p >= kNumStaticProperties) {
      has_non_wp = true;
    }
    if (p >= kNumStaticProperties && p != kGradientProp) {
      *gradient_only = false;
    }
  };
  FlatTree output;
  std::queue<size_t> nodes;
  nodes.push(0);
  // Produces a trimmed and flattened tree by doing a BFS visit of the original
  // tree, ignoring branches that are known to be false and proceeding two
  // levels at a time to collapse nodes in a flatter tree; if an inner parent
  // node has a leaf as a child, the leaf is duplicated and an implicit fake
  // node is added. This allows to reduce the number of branches when traversing
  // the resulting flat tree.
  while (!nodes.empty()) {
    size_t cur = nodes.front();
    nodes.pop();
    // Skip nodes that we can decide now, by jumping directly to their children.
    while (global_tree[cur].property < kNumStaticProperties &&
           global_tree[cur].property != -1) {
      if (static_props[global_tree[cur].property] > global_tree[cur].splitval) {
        cur = global_tree[cur].lchild;
      } else {
        cur = global_tree[cur].rchild;
      }
    }
    FlatDecisionNode flat;
    if (global_tree[cur].property == -1) {
      flat.property0 = -1;
      flat.childID = global_tree[cur].lchild;
      flat.predictor = global_tree[cur].predictor;
      flat.predictor_offset = global_tree[cur].predictor_offset;
      flat.multiplier = global_tree[cur].multiplier;
      *gradient_only &= flat.predictor == Predictor::Gradient;
      has_wp |= flat.predictor == Predictor::Weighted;
      has_non_wp |= flat.predictor != Predictor::Weighted;
      output.push_back(flat);
      continue;
    }
    flat.childID = output.size() + nodes.size() + 1;

    flat.property0 = global_tree[cur].property;
    *num_props = std::max<size_t>(flat.property0 + 1, *num_props);
    flat.splitval0 = global_tree[cur].splitval;

    for (size_t i = 0; i < 2; i++) {
      size_t cur_child =
          i == 0 ? global_tree[cur].lchild : global_tree[cur].rchild;
      // Skip nodes that we can decide now.
      while (global_tree[cur_child].property < kNumStaticProperties &&
             global_tree[cur_child].property != -1) {
        if (static_props[global_tree[cur_child].property] >
            global_tree[cur_child].splitval) {
          cur_child = global_tree[cur_child].lchild;
        } else {
          cur_child = global_tree[cur_child].rchild;
        }
      }
      // We ended up in a leaf, add a placeholder decision and two copies of the
      // leaf.
      if (global_tree[cur_child].property == -1) {
        flat.properties[i] = 0;
        flat.splitvals[i] = 0;
        nodes.push(cur_child);
        nodes.push(cur_child);
      } else {
        flat.properties[i] = global_tree[cur_child].property;
        flat.splitvals[i] = global_tree[cur_child].splitval;
        nodes.push(global_tree[cur_child].lchild);
        nodes.push(global_tree[cur_child].rchild);
        *num_props = std::max<size_t>(flat.properties[i] + 1, *num_props);
      }
    }

    for (int16_t property : flat.properties) mark_property(property);
    mark_property(flat.property0);
    output.push_back(flat);
  }
  if (*num_props > kNumNonrefProperties) {
    *num_props =
        DivCeil(*num_props - kNumNonrefProperties, kExtraPropsPerChannel) *
            kExtraPropsPerChannel +
        kNumNonrefProperties;
  } else {
    *num_props = kNumNonrefProperties;
  }
  *use_wp = has_wp;
  *wp_only = has_wp && !has_non_wp;

  return output;
}

namespace detail {
template <bool uses_lz77>
Status DecodeModularChannelMAANS(BitReader *br, ANSSymbolReader *reader,
                                 const std::vector<uint8_t> &context_map,
                                 const Tree &global_tree,
                                 const weighted::Header &wp_header,
                                 pixel_type chan, size_t group_id,
                                 TreeLut<uint8_t, false, false> &tree_lut,
                                 Image *image, uint32_t &fl_run,
                                 uint32_t &fl_v) {
  JxlMemoryManager *memory_manager = image->memory_manager();
  Channel &channel = image->channel[chan];

  std::array<pixel_type, kNumStaticProperties> static_props = {
      {chan, static_cast<int>(group_id)}};
  // TODO(veluca): filter the tree according to static_props.

  // zero pixel channel? could happen
  if (channel.w == 0 || channel.h == 0) return true;

  bool tree_has_wp_prop_or_pred = false;
  bool is_wp_only = false;
  bool is_gradient_only = false;
  size_t num_props;
  FlatTree tree =
      FilterTree(global_tree, static_props, &num_props,
                 &tree_has_wp_prop_or_pred, &is_wp_only, &is_gradient_only);

  // From here on, tree lookup returns a *clustered* context ID.
  // This avoids an extra memory lookup after tree traversal.
  for (auto &node : tree) {
    if (node.property0 == -1) {
      node.childID = context_map[node.childID];
    }
  }

  JXL_DEBUG_V(3, "Decoded MA tree with %" PRIuS " nodes", tree.size());

  // MAANS decode
  const auto make_pixel = [](uint64_t v, pixel_type multiplier,
                             pixel_type_w offset) -> pixel_type {
    JXL_DASSERT((v & 0xFFFFFFFF) == v);
    pixel_type_w val = UnpackSigned(v);
    // if it overflows, it overflows, and we have a problem anyway
    return val * multiplier + offset;
  };

  if (tree.size() == 1) {
    // special optimized case: no meta-adaptation, so no need
    // to compute properties.
    Predictor predictor = tree[0].predictor;
    int64_t offset = tree[0].predictor_offset;
    int32_t multiplier = tree[0].multiplier;
    size_t ctx_id = tree[0].childID;
    if (predictor == Predictor::Zero) {
      uint32_t value;
      if (reader->IsSingleValueAndAdvance(ctx_id, &value,
                                          channel.w * channel.h)) {
        // Special-case: histogram has a single symbol, with no extra bits, and
        // we use ANS mode.
        JXL_DEBUG_V(8, "Fastest track.");
        pixel_type v = make_pixel(value, multiplier, offset);
        for (size_t y = 0; y < channel.h; y++) {
          pixel_type *JXL_RESTRICT r = channel.Row(y);
          std::fill(r, r + channel.w, v);
        }
      } else {
        JXL_DEBUG_V(8, "Fast track.");
        if (multiplier == 1 && offset == 0) {
          for (size_t y = 0; y < channel.h; y++) {
            pixel_type *JXL_RESTRICT r = channel.Row(y);
            for (size_t x = 0; x < channel.w; x++) {
              uint32_t v =
                  reader->ReadHybridUintClusteredInlined<uses_lz77>(ctx_id, br);
              r[x] = UnpackSigned(v);
            }
          }
        } else {
          for (size_t y = 0; y < channel.h; y++) {
            pixel_type *JXL_RESTRICT r = channel.Row(y);
            for (size_t x = 0; x < channel.w; x++) {
              uint32_t v =
                  reader->ReadHybridUintClusteredMaybeInlined<uses_lz77>(ctx_id,
                                                                         br);
              r[x] = make_pixel(v, multiplier, offset);
            }
          }
        }
      }
      return true;
    } else if (uses_lz77 && predictor == Predictor::Gradient && offset == 0 &&
               multiplier == 1 && reader->IsHuffRleOnly()) {
      JXL_DEBUG_V(8, "Gradient RLE (fjxl) very fast track.");
      pixel_type_w sv = UnpackSigned(fl_v);
      for (size_t y = 0; y < channel.h; y++) {
        pixel_type *JXL_RESTRICT r = channel.Row(y);
        const pixel_type *JXL_RESTRICT rtop = (y ? channel.Row(y - 1) : r - 1);
        const pixel_type *JXL_RESTRICT rtopleft =
            (y ? channel.Row(y - 1) - 1 : r - 1);
        pixel_type_w guess = (y ? rtop[0] : 0);
        if (fl_run == 0) {
          reader->ReadHybridUintClusteredHuffRleOnly(ctx_id, br, &fl_v,
                                                     &fl_run);
          sv = UnpackSigned(fl_v);
        } else {
          fl_run--;
        }
        r[0] = sv + guess;
        for (size_t x = 1; x < channel.w; x++) {
          pixel_type left = r[x - 1];
          pixel_type top = rtop[x];
          pixel_type topleft = rtopleft[x];
          pixel_type_w guess = ClampedGradient(top, left, topleft);
          if (!fl_run) {
            reader->ReadHybridUintClusteredHuffRleOnly(ctx_id, br, &fl_v,
                                                       &fl_run);
            sv = UnpackSigned(fl_v);
          } else {
            fl_run--;
          }
          r[x] = sv + guess;
        }
      }
      return true;
    } else if (predictor == Predictor::Gradient && offset == 0 &&
               multiplier == 1) {
      JXL_DEBUG_V(8, "Gradient very fast track.");
      const intptr_t onerow = channel.plane.PixelsPerRow();
      for (size_t y = 0; y < channel.h; y++) {
        pixel_type *JXL_RESTRICT r = channel.Row(y);
        for (size_t x = 0; x < channel.w; x++) {
          pixel_type left = (x ? r[x - 1] : y ? *(r + x - onerow) : 0);
          pixel_type top = (y ? *(r + x - onerow) : left);
          pixel_type topleft = (x && y ? *(r + x - 1 - onerow) : left);
          pixel_type guess = ClampedGradient(top, left, topleft);
          uint64_t v = reader->ReadHybridUintClusteredMaybeInlined<uses_lz77>(
              ctx_id, br);
          r[x] = make_pixel(v, 1, guess);
        }
      }
      return true;
    }
  }

  // Check if this tree is a WP-only tree with a small enough property value
  // range.
  if (is_wp_only) {
    is_wp_only = TreeToLookupTable(tree, tree_lut);
  }
  if (is_gradient_only) {
    is_gradient_only = TreeToLookupTable(tree, tree_lut);
  }

  if (is_gradient_only) {
    JXL_DEBUG_V(8, "Gradient fast track.");
    const intptr_t onerow = channel.plane.PixelsPerRow();
    for (size_t y = 0; y < channel.h; y++) {
      pixel_type *JXL_RESTRICT r = channel.Row(y);
      for (size_t x = 0; x < channel.w; x++) {
        pixel_type_w left = (x ? r[x - 1] : y ? *(r + x - onerow) : 0);
        pixel_type_w top = (y ? *(r + x - onerow) : left);
        pixel_type_w topleft = (x && y ? *(r + x - 1 - onerow) : left);
        int32_t guess = ClampedGradient(top, left, topleft);
        uint32_t pos =
            kPropRangeFast +
            std::min<pixel_type_w>(
                std::max<pixel_type_w>(-kPropRangeFast, top + left - topleft),
                kPropRangeFast - 1);
        uint32_t ctx_id = tree_lut.context_lookup[pos];
        uint64_t v =
            reader->ReadHybridUintClusteredMaybeInlined<uses_lz77>(ctx_id, br);
        r[x] = make_pixel(v, 1, guess);
      }
    }
  } else if (!uses_lz77 && is_wp_only && channel.w > 8) {
    JXL_DEBUG_V(8, "WP fast track.");
    weighted::State wp_state(wp_header, channel.w, channel.h);
    Properties properties(1);
    for (size_t y = 0; y < channel.h; y++) {
      pixel_type *JXL_RESTRICT r = channel.Row(y);
      const pixel_type *JXL_RESTRICT rtop = (y ? channel.Row(y - 1) : r - 1);
      const pixel_type *JXL_RESTRICT rtoptop =
          (y > 1 ? channel.Row(y - 2) : rtop);
      const pixel_type *JXL_RESTRICT rtopleft =
          (y ? channel.Row(y - 1) - 1 : r - 1);
      const pixel_type *JXL_RESTRICT rtopright =
          (y ? channel.Row(y - 1) + 1 : r - 1);
      size_t x = 0;
      {
        size_t offset = 0;
        pixel_type_w left = y ? rtop[x] : 0;
        pixel_type_w toptop = y ? rtoptop[x] : 0;
        pixel_type_w topright = (x + 1 < channel.w && y ? rtop[x + 1] : left);
        int32_t guess = wp_state.Predict</*compute_properties=*/true>(
            x, y, channel.w, left, left, topright, left, toptop, &properties,
            offset);
        uint32_t pos =
            kPropRangeFast + std::min(std::max(-kPropRangeFast, properties[0]),
                                      kPropRangeFast - 1);
        uint32_t ctx_id = tree_lut.context_lookup[pos];
        uint64_t v =
            reader->ReadHybridUintClusteredInlined<uses_lz77>(ctx_id, br);
        r[x] = make_pixel(v, 1, guess);
        wp_state.UpdateErrors(r[x], x, y, channel.w);
      }
      for (x = 1; x + 1 < channel.w; x++) {
        size_t offset = 0;
        int32_t guess = wp_state.Predict</*compute_properties=*/true>(
            x, y, channel.w, rtop[x], r[x - 1], rtopright[x], rtopleft[x],
            rtoptop[x], &properties, offset);
        uint32_t pos =
            kPropRangeFast + std::min(std::max(-kPropRangeFast, properties[0]),
                                      kPropRangeFast - 1);
        uint32_t ctx_id = tree_lut.context_lookup[pos];
        uint64_t v =
            reader->ReadHybridUintClusteredInlined<uses_lz77>(ctx_id, br);
        r[x] = make_pixel(v, 1, guess);
        wp_state.UpdateErrors(r[x], x, y, channel.w);
      }
      {
        size_t offset = 0;
        int32_t guess = wp_state.Predict</*compute_properties=*/true>(
            x, y, channel.w, rtop[x], r[x - 1], rtop[x], rtopleft[x],
            rtoptop[x], &properties, offset);
        uint32_t pos =
            kPropRangeFast + std::min(std::max(-kPropRangeFast, properties[0]),
                                      kPropRangeFast - 1);
        uint32_t ctx_id = tree_lut.context_lookup[pos];
        uint64_t v =
            reader->ReadHybridUintClusteredInlined<uses_lz77>(ctx_id, br);
        r[x] = make_pixel(v, 1, guess);
        wp_state.UpdateErrors(r[x], x, y, channel.w);
      }
    }
  } else if (!tree_has_wp_prop_or_pred) {
    // special optimized case: the weighted predictor and its properties are not
    // used, so no need to compute weights and properties.
    JXL_DEBUG_V(8, "Slow track.");
    MATreeLookup tree_lookup(tree);
    Properties properties = Properties(num_props);
    const intptr_t onerow = channel.plane.PixelsPerRow();
    JXL_ASSIGN_OR_RETURN(
        Channel references,
        Channel::Create(memory_manager,
                        properties.size() - kNumNonrefProperties, channel.w));
    for (size_t y = 0; y < channel.h; y++) {
      pixel_type *JXL_RESTRICT p = channel.Row(y);
      PrecomputeReferences(channel, y, *image, chan, &references);
      InitPropsRow(&properties, static_props, y);
      if (y > 1 && channel.w > 8 && references.w == 0) {
        for (size_t x = 0; x < 2; x++) {
          PredictionResult res =
              PredictTreeNoWP(&properties, channel.w, p + x, onerow, x, y,
                              tree_lookup, references);
          uint64_t v =
              reader->ReadHybridUintClustered<uses_lz77>(res.context, br);
          p[x] = make_pixel(v, res.multiplier, res.guess);
        }
        for (size_t x = 2; x < channel.w - 2; x++) {
          PredictionResult res =
              PredictTreeNoWPNEC(&properties, channel.w, p + x, onerow, x, y,
                                 tree_lookup, references);
          uint64_t v = reader->ReadHybridUintClusteredInlined<uses_lz77>(
              res.context, br);
          p[x] = make_pixel(v, res.multiplier, res.guess);
        }
        for (size_t x = channel.w - 2; x < channel.w; x++) {
          PredictionResult res =
              PredictTreeNoWP(&properties, channel.w, p + x, onerow, x, y,
                              tree_lookup, references);
          uint64_t v =
              reader->ReadHybridUintClustered<uses_lz77>(res.context, br);
          p[x] = make_pixel(v, res.multiplier, res.guess);
        }
      } else {
        for (size_t x = 0; x < channel.w; x++) {
          PredictionResult res =
              PredictTreeNoWP(&properties, channel.w, p + x, onerow, x, y,
                              tree_lookup, references);
          uint64_t v = reader->ReadHybridUintClusteredMaybeInlined<uses_lz77>(
              res.context, br);
          p[x] = make_pixel(v, res.multiplier, res.guess);
        }
      }
    }
  } else {
    JXL_DEBUG_V(8, "Slowest track.");
    MATreeLookup tree_lookup(tree);
    Properties properties = Properties(num_props);
    const intptr_t onerow = channel.plane.PixelsPerRow();
    JXL_ASSIGN_OR_RETURN(
        Channel references,
        Channel::Create(memory_manager,
                        properties.size() - kNumNonrefProperties, channel.w));
    weighted::State wp_state(wp_header, channel.w, channel.h);
    for (size_t y = 0; y < channel.h; y++) {
      pixel_type *JXL_RESTRICT p = channel.Row(y);
      InitPropsRow(&properties, static_props, y);
      PrecomputeReferences(channel, y, *image, chan, &references);
      if (!uses_lz77 && y > 1 && channel.w > 8 && references.w == 0) {
        for (size_t x = 0; x < 2; x++) {
          PredictionResult res =
              PredictTreeWP(&properties, channel.w, p + x, onerow, x, y,
                            tree_lookup, references, &wp_state);
          uint64_t v =
              reader->ReadHybridUintClustered<uses_lz77>(res.context, br);
          p[x] = make_pixel(v, res.multiplier, res.guess);
          wp_state.UpdateErrors(p[x], x, y, channel.w);
        }
        for (size_t x = 2; x < channel.w - 2; x++) {
          PredictionResult res =
              PredictTreeWPNEC(&properties, channel.w, p + x, onerow, x, y,
                               tree_lookup, references, &wp_state);
          uint64_t v = reader->ReadHybridUintClusteredInlined<uses_lz77>(
              res.context, br);
          p[x] = make_pixel(v, res.multiplier, res.guess);
          wp_state.UpdateErrors(p[x], x, y, channel.w);
        }
        for (size_t x = channel.w - 2; x < channel.w; x++) {
          PredictionResult res =
              PredictTreeWP(&properties, channel.w, p + x, onerow, x, y,
                            tree_lookup, references, &wp_state);
          uint64_t v =
              reader->ReadHybridUintClustered<uses_lz77>(res.context, br);
          p[x] = make_pixel(v, res.multiplier, res.guess);
          wp_state.UpdateErrors(p[x], x, y, channel.w);
        }
      } else {
        for (size_t x = 0; x < channel.w; x++) {
          PredictionResult res =
              PredictTreeWP(&properties, channel.w, p + x, onerow, x, y,
                            tree_lookup, references, &wp_state);
          uint64_t v =
              reader->ReadHybridUintClustered<uses_lz77>(res.context, br);
          p[x] = make_pixel(v, res.multiplier, res.guess);
          wp_state.UpdateErrors(p[x], x, y, channel.w);
        }
      }
    }
  }
  return true;
}
}  // namespace detail

Status DecodeModularChannelMAANS(BitReader *br, ANSSymbolReader *reader,
                                 const std::vector<uint8_t> &context_map,
                                 const Tree &global_tree,
                                 const weighted::Header &wp_header,
                                 pixel_type chan, size_t group_id,
                                 TreeLut<uint8_t, false, false> &tree_lut,
                                 Image *image, uint32_t &fl_run,
                                 uint32_t &fl_v) {
  if (reader->UsesLZ77()) {
    return detail::DecodeModularChannelMAANS</*uses_lz77=*/true>(
        br, reader, context_map, global_tree, wp_header, chan, group_id,
        tree_lut, image, fl_run, fl_v);
  } else {
    return detail::DecodeModularChannelMAANS</*uses_lz77=*/false>(
        br, reader, context_map, global_tree, wp_header, chan, group_id,
        tree_lut, image, fl_run, fl_v);
  }
}

GroupHeader::GroupHeader() { Bundle::Init(this); }

Status ValidateChannelDimensions(const Image &image,
                                 const ModularOptions &options) {
  size_t nb_channels = image.channel.size();
  for (bool is_dc : {true, false}) {
    size_t group_dim = options.group_dim * (is_dc ? kBlockDim : 1);
    size_t c = image.nb_meta_channels;
    for (; c < nb_channels; c++) {
      const Channel &ch = image.channel[c];
      if (ch.w > options.group_dim || ch.h > options.group_dim) break;
    }
    for (; c < nb_channels; c++) {
      const Channel &ch = image.channel[c];
      if (ch.w == 0 || ch.h == 0) continue;  // skip empty
      bool is_dc_channel = std::min(ch.hshift, ch.vshift) >= 3;
      if (is_dc_channel != is_dc) continue;
      size_t tile_dim = group_dim >> std::max(ch.hshift, ch.vshift);
      if (tile_dim == 0) {
        return JXL_FAILURE("Inconsistent transforms");
      }
    }
  }
  return true;
}

Status ModularDecode(BitReader *br, Image &image, GroupHeader &header,
                     size_t group_id, ModularOptions *options,
                     const Tree *global_tree, const ANSCode *global_code,
                     const std::vector<uint8_t> *global_ctx_map,
                     const bool allow_truncated_group) {
  if (image.channel.empty()) return true;
  JxlMemoryManager *memory_manager = image.memory_manager();

  // decode transforms
  Status status = Bundle::Read(br, &header);
  if (!allow_truncated_group) JXL_RETURN_IF_ERROR(status);
  if (status.IsFatalError()) return status;
  if (!br->AllReadsWithinBounds()) {
    // Don't do/undo transforms if header is incomplete.
    header.transforms.clear();
    image.transform = header.transforms;
    for (auto &ch : image.channel) {
      ZeroFillImage(&ch.plane);
    }
    return Status(StatusCode::kNotEnoughBytes);
  }

  JXL_DEBUG_V(3, "Image data underwent %" PRIuS " transformations: ",
              header.transforms.size());
  image.transform = header.transforms;
  for (Transform &transform : image.transform) {
    JXL_RETURN_IF_ERROR(transform.MetaApply(image));
  }
  if (image.error) {
    return JXL_FAILURE("Corrupt file. Aborting.");
  }
  JXL_RETURN_IF_ERROR(ValidateChannelDimensions(image, *options));

  size_t nb_channels = image.channel.size();

  size_t num_chans = 0;
  size_t distance_multiplier = 0;
  for (size_t i = 0; i < nb_channels; i++) {
    Channel &channel = image.channel[i];
    if (!channel.w || !channel.h) {
      continue;  // skip empty channels
    }
    if (i >= image.nb_meta_channels && (channel.w > options->max_chan_size ||
                                        channel.h > options->max_chan_size)) {
      break;
    }
    if (channel.w > distance_multiplier) {
      distance_multiplier = channel.w;
    }
    num_chans++;
  }
  if (num_chans == 0) return true;

  size_t next_channel = 0;
  auto scope_guard = MakeScopeGuard([&]() {
    for (size_t c = next_channel; c < image.channel.size(); c++) {
      ZeroFillImage(&image.channel[c].plane);
    }
  });
  // Do not do anything if truncated groups are not allowed.
  if (allow_truncated_group) scope_guard.Disarm();

  // Read tree.
  Tree tree_storage;
  std::vector<uint8_t> context_map_storage;
  ANSCode code_storage;
  const Tree *tree = &tree_storage;
  const ANSCode *code = &code_storage;
  const std::vector<uint8_t> *context_map = &context_map_storage;
  if (!header.use_global_tree) {
    uint64_t max_tree_size = 1024;
    for (size_t i = 0; i < nb_channels; i++) {
      Channel &channel = image.channel[i];
      if (i >= image.nb_meta_channels && (channel.w > options->max_chan_size ||
                                          channel.h > options->max_chan_size)) {
        break;
      }
      uint64_t pixels = channel.w * channel.h;
      max_tree_size += pixels;
    }
    max_tree_size = std::min(static_cast<uint64_t>(1 << 20), max_tree_size);
    JXL_RETURN_IF_ERROR(
        DecodeTree(memory_manager, br, &tree_storage, max_tree_size));
    JXL_RETURN_IF_ERROR(DecodeHistograms(memory_manager, br,
                                         (tree_storage.size() + 1) / 2,
                                         &code_storage, &context_map_storage));
  } else {
    if (!global_tree || !global_code || !global_ctx_map ||
        global_tree->empty()) {
      return JXL_FAILURE("No global tree available but one was requested");
    }
    tree = global_tree;
    code = global_code;
    context_map = global_ctx_map;
  }

  // Read channels
  JXL_ASSIGN_OR_RETURN(ANSSymbolReader reader,
                       ANSSymbolReader::Create(code, br, distance_multiplier));
  auto tree_lut = jxl::make_unique<TreeLut<uint8_t, false, false>>();
  uint32_t fl_run = 0;
  uint32_t fl_v = 0;
  for (; next_channel < nb_channels; next_channel++) {
    Channel &channel = image.channel[next_channel];
    if (!channel.w || !channel.h) {
      continue;  // skip empty channels
    }
    if (next_channel >= image.nb_meta_channels &&
        (channel.w > options->max_chan_size ||
         channel.h > options->max_chan_size)) {
      break;
    }
    JXL_RETURN_IF_ERROR(DecodeModularChannelMAANS(
        br, &reader, *context_map, *tree, header.wp_header, next_channel,
        group_id, *tree_lut, &image, fl_run, fl_v));

    // Truncated group.
    if (!br->AllReadsWithinBounds()) {
      if (!allow_truncated_group) return JXL_FAILURE("Truncated input");
      return Status(StatusCode::kNotEnoughBytes);
    }
  }

  // Make sure no zero-filling happens even if next_channel < nb_channels.
  scope_guard.Disarm();

  if (!reader.CheckANSFinalState()) {
    return JXL_FAILURE("ANS decode final state failed");
  }
  return true;
}

Status ModularGenericDecompress(BitReader *br, Image &image,
                                GroupHeader *header, size_t group_id,
                                ModularOptions *options, bool undo_transforms,
                                const Tree *tree, const ANSCode *code,
                                const std::vector<uint8_t> *ctx_map,
                                bool allow_truncated_group) {
  std::vector<std::pair<uint32_t, uint32_t>> req_sizes;
  req_sizes.reserve(image.channel.size());
  for (const auto &c : image.channel) {
    req_sizes.emplace_back(c.w, c.h);
  }
  GroupHeader local_header;
  if (header == nullptr) header = &local_header;
  size_t bit_pos = br->TotalBitsConsumed();
  auto dec_status = ModularDecode(br, image, *header, group_id, options, tree,
                                  code, ctx_map, allow_truncated_group);
  if (!allow_truncated_group) JXL_RETURN_IF_ERROR(dec_status);
  if (dec_status.IsFatalError()) return dec_status;
  if (undo_transforms) image.undo_transforms(header->wp_header);
  if (image.error) return JXL_FAILURE("Corrupt file. Aborting.");
  JXL_DEBUG_V(4,
              "Modular-decoded a %" PRIuS "x%" PRIuS " nbchans=%" PRIuS
              " image from %" PRIuS " bytes",
              image.w, image.h, image.channel.size(),
              (br->TotalBitsConsumed() - bit_pos) / 8);
  JXL_DEBUG_V(5, "Modular image: %s", image.DebugString().c_str());
  (void)bit_pos;
  // Check that after applying all transforms we are back to the requested
  // image sizes, otherwise there's a programming error with the
  // transformations.
  if (undo_transforms) {
    JXL_ENSURE(image.channel.size() == req_sizes.size());
    for (size_t c = 0; c < req_sizes.size(); c++) {
      JXL_ENSURE(req_sizes[c].first == image.channel[c].w);
      JXL_ENSURE(req_sizes[c].second == image.channel[c].h);
    }
  }
  return dec_status;
}

}  // namespace jxl