/src/libjxl/lib/jxl/frame_header.cc

Source
// 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/frame_header.h"

#include <cstddef>
#include <cstdint>
#include <vector>

#include "lib/jxl/base/compiler_specific.h"
#include "lib/jxl/dec_bit_reader.h"
#include "lib/jxl/field_encodings.h"
#include "lib/jxl/image_metadata.h"

#if JXL_DEBUG_V_LEVEL >= 1
#include <sstream>
#include <string>
#endif

#include "lib/jxl/base/printf_macros.h"
#include "lib/jxl/base/status.h"
#include "lib/jxl/common.h"  // kMaxNumPasses
#include "lib/jxl/fields.h"
#include "lib/jxl/pack_signed.h"

namespace jxl {

constexpr uint8_t YCbCrChromaSubsampling::kHShift[] = {0, 1, 1, 0};
constexpr uint8_t YCbCrChromaSubsampling::kVShift[] = {0, 1, 0, 1};

static Status VisitBlendMode(Visitor* JXL_RESTRICT visitor,
                             BlendMode default_value, BlendMode* blend_mode) {
  uint32_t encoded = static_cast<uint32_t>(*blend_mode);

  JXL_QUIET_RETURN_IF_ERROR(visitor->U32(
      Val(static_cast<uint32_t>(BlendMode::kReplace)),
      Val(static_cast<uint32_t>(BlendMode::kAdd)),
      Val(static_cast<uint32_t>(BlendMode::kBlend)), BitsOffset(2, 3),
      static_cast<uint32_t>(default_value), &encoded));
  if (encoded > static_cast<uint32_t>(BlendMode::kMul)) {
    return JXL_FAILURE("Invalid blend_mode");
  }
  *blend_mode = static_cast<BlendMode>(encoded);
  return true;
}

static Status VisitFrameType(Visitor* JXL_RESTRICT visitor,
                             FrameType default_value, FrameType* frame_type) {
  uint32_t encoded = static_cast<uint32_t>(*frame_type);

  JXL_QUIET_RETURN_IF_ERROR(
      visitor->U32(Val(static_cast<uint32_t>(FrameType::kRegularFrame)),
                   Val(static_cast<uint32_t>(FrameType::kDCFrame)),
                   Val(static_cast<uint32_t>(FrameType::kReferenceOnly)),
                   Val(static_cast<uint32_t>(FrameType::kSkipProgressive)),
                   static_cast<uint32_t>(default_value), &encoded));
  *frame_type = static_cast<FrameType>(encoded);
  return true;
}

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

Status BlendingInfo::VisitFields(Visitor* JXL_RESTRICT visitor) {
  JXL_QUIET_RETURN_IF_ERROR(
      VisitBlendMode(visitor, BlendMode::kReplace, &mode));
  if (visitor->Conditional(nonserialized_num_extra_channels > 0 &&
                           (mode == BlendMode::kBlend ||
                            mode == BlendMode::kAlphaWeightedAdd))) {
    // Up to 11 alpha channels for blending.
    JXL_QUIET_RETURN_IF_ERROR(visitor->U32(
        Val(0), Val(1), Val(2), BitsOffset(3, 3), 0, &alpha_channel));
    if (visitor->IsReading() &&
        alpha_channel >= nonserialized_num_extra_channels) {
      return JXL_FAILURE("Invalid alpha channel for blending");
    }
  }
  if (visitor->Conditional((nonserialized_num_extra_channels > 0 &&
                            (mode == BlendMode::kBlend ||
                             mode == BlendMode::kAlphaWeightedAdd)) ||
                           mode == BlendMode::kMul)) {
    JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(false, &clamp));
  }
  // 'old' frame for blending. Only necessary if this is not a full frame, or
  // blending is not kReplace.
  if (visitor->Conditional(mode != BlendMode::kReplace ||
                           nonserialized_is_partial_frame)) {
    JXL_QUIET_RETURN_IF_ERROR(
        visitor->U32(Val(0), Val(1), Val(2), Val(3), 0, &source));
  }
  return true;
}

#if JXL_DEBUG_V_LEVEL >= 1
std::string BlendingInfo::DebugString() const {
  std::ostringstream os;
  os << (mode == BlendMode::kReplace            ? "Replace"
         : mode == BlendMode::kAdd              ? "Add"
         : mode == BlendMode::kBlend            ? "Blend"
         : mode == BlendMode::kAlphaWeightedAdd ? "AlphaWeightedAdd"
                                                : "Mul");
  if (nonserialized_num_extra_channels > 0 &&
      (mode == BlendMode::kBlend || mode == BlendMode::kAlphaWeightedAdd)) {
    os << ",alpha=" << alpha_channel << ",clamp=" << clamp;
  } else if (mode == BlendMode::kMul) {
    os << ",clamp=" << clamp;
  }
  if (mode != BlendMode::kReplace || nonserialized_is_partial_frame) {
    os << ",source=" << source;
  }
  return os.str();
}
#endif

AnimationFrame::AnimationFrame(const CodecMetadata* metadata)
    : nonserialized_metadata(metadata) {
  Bundle::Init(this);
}
Status AnimationFrame::VisitFields(Visitor* JXL_RESTRICT visitor) {
  if (visitor->Conditional(nonserialized_metadata != nullptr &&
                           nonserialized_metadata->m.have_animation)) {
    JXL_QUIET_RETURN_IF_ERROR(
        visitor->U32(Val(0), Val(1), Bits(8), Bits(32), 0, &duration));
  }

  if (visitor->Conditional(
          nonserialized_metadata != nullptr &&
          nonserialized_metadata->m.animation.have_timecodes)) {
    JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(32, 0, &timecode));
  }
  return true;
}

YCbCrChromaSubsampling::YCbCrChromaSubsampling() { Bundle::Init(this); }
Passes::Passes() { Bundle::Init(this); }
Status Passes::VisitFields(Visitor* JXL_RESTRICT visitor) {
  JXL_QUIET_RETURN_IF_ERROR(
      visitor->U32(Val(1), Val(2), Val(3), BitsOffset(3, 4), 1, &num_passes));
  JXL_ENSURE(num_passes <= kMaxNumPasses);  // Cannot happen when reading

  if (visitor->Conditional(num_passes != 1)) {
    JXL_QUIET_RETURN_IF_ERROR(visitor->U32(
        Val(0), Val(1), Val(2), BitsOffset(1, 3), 0, &num_downsample));
    JXL_ENSURE(num_downsample <= 4);  // 1,2,4,8
    if (num_downsample > num_passes) {
      return JXL_FAILURE("num_downsample %u > num_passes %u", num_downsample,
                         num_passes);
    }

    for (uint32_t i = 0; i < num_passes - 1; i++) {
      JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(2, 0, &shift[i]));
    }
    shift[num_passes - 1] = 0;

    for (uint32_t i = 0; i < num_downsample; ++i) {
      JXL_QUIET_RETURN_IF_ERROR(
          visitor->U32(Val(1), Val(2), Val(4), Val(8), 1, &downsample[i]));
      if (i > 0 && downsample[i] >= downsample[i - 1]) {
        return JXL_FAILURE("downsample sequence should be decreasing");
      }
    }
    for (uint32_t i = 0; i < num_downsample; ++i) {
      JXL_QUIET_RETURN_IF_ERROR(
          visitor->U32(Val(0), Val(1), Val(2), Bits(3), 0, &last_pass[i]));
      if (i > 0 && last_pass[i] <= last_pass[i - 1]) {
        return JXL_FAILURE("last_pass sequence should be increasing");
      }
      if (last_pass[i] >= num_passes) {
        return JXL_FAILURE("last_pass %u >= num_passes %u", last_pass[i],
                           num_passes);
      }
    }
  }

  return true;
}

#if JXL_DEBUG_V_LEVEL >= 1
std::string Passes::DebugString() const {
  std::ostringstream os;
  os << "p=" << num_passes;
  if (num_downsample) {
    os << ",ds=";
    for (uint32_t i = 0; i < num_downsample; ++i) {
      os << last_pass[i] << ":" << downsample[i];
      if (i + 1 < num_downsample) os << ";";
    }
  }
  bool have_shifts = false;
  for (uint32_t i = 0; i < num_passes; ++i) {
    if (shift[i]) have_shifts = true;
  }
  if (have_shifts) {
    os << ",shifts=";
    for (uint32_t i = 0; i < num_passes; ++i) {
      os << shift[i];
      if (i + 1 < num_passes) os << ";";
    }
  }
  return os.str();
}
#endif

FrameHeader::FrameHeader(const CodecMetadata* metadata)
    : animation_frame(metadata), nonserialized_metadata(metadata) {
  Bundle::Init(this);
}

Status ReadFrameHeader(BitReader* JXL_RESTRICT reader,
                       FrameHeader* JXL_RESTRICT frame) {
  return Bundle::Read(reader, frame);
}

Status FrameHeader::VisitFields(Visitor* JXL_RESTRICT visitor) {
  if (visitor->AllDefault(*this, &all_default)) {
    // Overwrite all serialized fields, but not any nonserialized_*.
    visitor->SetDefault(this);
    return true;
  }

  JXL_QUIET_RETURN_IF_ERROR(
      VisitFrameType(visitor, FrameType::kRegularFrame, &frame_type));
  if (visitor->IsReading() && nonserialized_is_preview &&
      frame_type != kRegularFrame) {
    return JXL_FAILURE("Only regular frame could be a preview");
  }

  // FrameEncoding.
  bool is_modular = (encoding == FrameEncoding::kModular);
  JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(false, &is_modular));
  encoding = (is_modular ? FrameEncoding::kModular : FrameEncoding::kVarDCT);

  // Flags
  JXL_QUIET_RETURN_IF_ERROR(visitor->U64(0, &flags));

  // Color transform
  bool xyb_encoded = nonserialized_metadata == nullptr ||
                     nonserialized_metadata->m.xyb_encoded;

  if (xyb_encoded) {
    color_transform = ColorTransform::kXYB;
  } else {
    // Alternate if kYCbCr.
    bool alternate = color_transform == ColorTransform::kYCbCr;
    JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(false, &alternate));
    color_transform =
        (alternate ? ColorTransform::kYCbCr : ColorTransform::kNone);
  }

  // Chroma subsampling for YCbCr, if no DC frame is used.
  if (visitor->Conditional(color_transform == ColorTransform::kYCbCr &&
                           ((flags & kUseDcFrame) == 0))) {
    JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&chroma_subsampling));
  }

  size_t num_extra_channels =
      nonserialized_metadata != nullptr
          ? nonserialized_metadata->m.extra_channel_info.size()
          : 0;

  // Upsampling
  if (visitor->Conditional((flags & kUseDcFrame) == 0)) {
    JXL_QUIET_RETURN_IF_ERROR(
        visitor->U32(Val(1), Val(2), Val(4), Val(8), 1, &upsampling));
    if (nonserialized_metadata != nullptr &&
        visitor->Conditional(num_extra_channels != 0)) {
      const std::vector<ExtraChannelInfo>& extra_channels =
          nonserialized_metadata->m.extra_channel_info;
      extra_channel_upsampling.resize(extra_channels.size(), 1);
      for (size_t i = 0; i < extra_channels.size(); ++i) {
        uint32_t dim_shift =
            nonserialized_metadata->m.extra_channel_info[i].dim_shift;
        uint32_t& ec_upsampling = extra_channel_upsampling[i];
        ec_upsampling >>= dim_shift;
        JXL_QUIET_RETURN_IF_ERROR(
            visitor->U32(Val(1), Val(2), Val(4), Val(8), 1, &ec_upsampling));
        ec_upsampling <<= dim_shift;
        if (ec_upsampling < upsampling) {
          return JXL_FAILURE(
              "EC upsampling (%u) < color upsampling (%u), which is invalid.",
              ec_upsampling, upsampling);
        }
        if (ec_upsampling > 8) {
          return JXL_FAILURE("EC upsampling too large (%u)", ec_upsampling);
        }
      }
    } else {
      extra_channel_upsampling.clear();
    }
  }

  // Modular- or VarDCT-specific data.
  if (visitor->Conditional(encoding == FrameEncoding::kModular)) {
    JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(2, 1, &group_size_shift));
  }
  if (visitor->Conditional(encoding == FrameEncoding::kVarDCT &&
                           color_transform == ColorTransform::kXYB)) {
    JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(3, 3, &x_qm_scale));
    JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(3, 2, &b_qm_scale));
  } else {
    x_qm_scale = b_qm_scale = 2;  // noop
  }

  // Not useful for kPatchSource
  if (visitor->Conditional(frame_type != FrameType::kReferenceOnly)) {
    JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&passes));
  }

  if (visitor->Conditional(frame_type == FrameType::kDCFrame)) {
    // Up to 4 pyramid levels - for up to 16384x downsampling.
    JXL_QUIET_RETURN_IF_ERROR(
        visitor->U32(Val(1), Val(2), Val(3), Val(4), 1, &dc_level));
  }
  if (frame_type != FrameType::kDCFrame) {
    dc_level = 0;
  }

  bool is_partial_frame = false;
  if (visitor->Conditional(frame_type != FrameType::kDCFrame)) {
    JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(false, &custom_size_or_origin));
    if (visitor->Conditional(custom_size_or_origin)) {
      const U32Enc enc(Bits(8), BitsOffset(11, 256), BitsOffset(14, 2304),
                       BitsOffset(30, 18688));
      // Frame offset, only if kRegularFrame or kSkipProgressive.
      if (visitor->Conditional(frame_type == FrameType::kRegularFrame ||
                               frame_type == FrameType::kSkipProgressive)) {
        uint32_t ux0 = PackSigned(frame_origin.x0);
        uint32_t uy0 = PackSigned(frame_origin.y0);
        JXL_QUIET_RETURN_IF_ERROR(visitor->U32(enc, 0, &ux0));
        JXL_QUIET_RETURN_IF_ERROR(visitor->U32(enc, 0, &uy0));
        frame_origin.x0 = UnpackSigned(ux0);
        frame_origin.y0 = UnpackSigned(uy0);
      }
      // Frame size
      JXL_QUIET_RETURN_IF_ERROR(visitor->U32(enc, 0, &frame_size.xsize));
      JXL_QUIET_RETURN_IF_ERROR(visitor->U32(enc, 0, &frame_size.ysize));
      if (custom_size_or_origin &&
          (frame_size.xsize == 0 || frame_size.ysize == 0)) {
        return JXL_FAILURE(
            "Invalid crop dimensions for frame: zero width or height");
      }
      int32_t image_xsize = default_xsize();
      int32_t image_ysize = default_ysize();
      if (frame_type == FrameType::kRegularFrame ||
          frame_type == FrameType::kSkipProgressive) {
        is_partial_frame |= frame_origin.x0 > 0;
        is_partial_frame |= frame_origin.y0 > 0;
        is_partial_frame |= (static_cast<int32_t>(frame_size.xsize) +
                             frame_origin.x0) < image_xsize;
        is_partial_frame |= (static_cast<int32_t>(frame_size.ysize) +
                             frame_origin.y0) < image_ysize;
      }
    }
  }

  // Blending info, animation info and whether this is the last frame or not.
  if (visitor->Conditional(frame_type == FrameType::kRegularFrame ||
                           frame_type == FrameType::kSkipProgressive)) {
    blending_info.nonserialized_num_extra_channels = num_extra_channels;
    blending_info.nonserialized_is_partial_frame = is_partial_frame;
    JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&blending_info));
    bool replace_all = (blending_info.mode == BlendMode::kReplace);
    extra_channel_blending_info.resize(num_extra_channels);
    for (size_t i = 0; i < num_extra_channels; i++) {
      auto& ec_blending_info = extra_channel_blending_info[i];
      ec_blending_info.nonserialized_is_partial_frame = is_partial_frame;
      ec_blending_info.nonserialized_num_extra_channels = num_extra_channels;
      JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&ec_blending_info));
      replace_all &= (ec_blending_info.mode == BlendMode::kReplace);
    }
    if (visitor->IsReading() && nonserialized_is_preview) {
      if (!replace_all || custom_size_or_origin) {
        return JXL_FAILURE("Preview is not compatible with blending");
      }
    }
    if (visitor->Conditional(nonserialized_metadata != nullptr &&
                             nonserialized_metadata->m.have_animation)) {
      animation_frame.nonserialized_metadata = nonserialized_metadata;
      JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&animation_frame));
    }
    JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(true, &is_last));
  } else {
    is_last = false;
  }

  // ID of that can be used to refer to this frame. 0 for a non-zero-duration
  // frame means that it will not be referenced. Not necessary for the last
  // frame.
  if (visitor->Conditional(frame_type != kDCFrame && !is_last)) {
    JXL_QUIET_RETURN_IF_ERROR(
        visitor->U32(Val(0), Val(1), Val(2), Val(3), 0, &save_as_reference));
  }

  // If this frame is not blended on another frame post-color-transform, it may
  // be stored for being referenced either before or after the color transform.
  // If it is blended post-color-transform, it must be blended after. It must
  // also be blended after if this is a kRegular frame that does not cover the
  // full frame, as samples outside the partial region are from a
  // post-color-transform frame.
  if (frame_type != FrameType::kDCFrame) {
    if (visitor->Conditional(CanBeReferenced() &&
                             blending_info.mode == BlendMode::kReplace &&
                             !is_partial_frame &&
                             (frame_type == FrameType::kRegularFrame ||
                              frame_type == FrameType::kSkipProgressive))) {
      JXL_QUIET_RETURN_IF_ERROR(
          visitor->Bool(false, &save_before_color_transform));
    } else if (visitor->Conditional(frame_type == FrameType::kReferenceOnly)) {
      JXL_QUIET_RETURN_IF_ERROR(
          visitor->Bool(true, &save_before_color_transform));
      size_t xsize = custom_size_or_origin ? frame_size.xsize
                                           : nonserialized_metadata->xsize();
      size_t ysize = custom_size_or_origin ? frame_size.ysize
                                           : nonserialized_metadata->ysize();
      if (!save_before_color_transform &&
          (xsize < nonserialized_metadata->xsize() ||
           ysize < nonserialized_metadata->ysize() || frame_origin.x0 != 0 ||
           frame_origin.y0 != 0)) {
        return JXL_FAILURE(
            "non-patch reference frame with invalid crop: %" PRIuS "x%" PRIuS
            "%+d%+d",
            xsize, ysize, static_cast<int>(frame_origin.x0),
            static_cast<int>(frame_origin.y0));
      }
    }
  } else {
    save_before_color_transform = true;
  }

  JXL_QUIET_RETURN_IF_ERROR(VisitNameString(visitor, &name));

  loop_filter.nonserialized_is_modular = is_modular;
  JXL_RETURN_IF_ERROR(visitor->VisitNested(&loop_filter));

  JXL_QUIET_RETURN_IF_ERROR(visitor->BeginExtensions(&extensions));
  // Extensions: in chronological order of being added to the format.
  return visitor->EndExtensions();
}

#if JXL_DEBUG_V_LEVEL >= 1
std::string FrameHeader::DebugString() const {
  std::ostringstream os;
  os << (encoding == FrameEncoding::kVarDCT ? "VarDCT" : "Modular");
  os << ",";
  os << (frame_type == FrameType::kRegularFrame    ? "Regular"
         : frame_type == FrameType::kDCFrame       ? "DC"
         : frame_type == FrameType::kReferenceOnly ? "Reference"
                                                   : "SkipProgressive");
  if (frame_type == FrameType::kDCFrame) {
    os << "(lv" << dc_level << ")";
  }

  if (flags) {
    os << ",";
    uint32_t remaining = flags;

#define TEST_FLAG(name)           \
  if (flags & Flags::k##name) {   \
    remaining &= ~Flags::k##name; \
    os << #name;                  \
    if (remaining) os << "|";     \
  }
    TEST_FLAG(Noise);
    TEST_FLAG(Patches);
    TEST_FLAG(Splines);
    TEST_FLAG(UseDcFrame);
    TEST_FLAG(SkipAdaptiveDCSmoothing);
#undef TEST_FLAG
  }

  os << ",";
  os << (color_transform == ColorTransform::kXYB     ? "XYB"
         : color_transform == ColorTransform::kYCbCr ? "YCbCr"
                                                     : "None");

  if (encoding == FrameEncoding::kModular) {
    os << ",shift=" << group_size_shift;
  } else if (color_transform == ColorTransform::kXYB) {
    os << ",qm=" << x_qm_scale << ";" << b_qm_scale;
  }
  if (frame_type != FrameType::kReferenceOnly) {
    os << "," << passes.DebugString();
  }
  if (custom_size_or_origin) {
    os << ",xs=" << frame_size.xsize;
    os << ",ys=" << frame_size.ysize;
    if (frame_type == FrameType::kRegularFrame ||
        frame_type == FrameType::kSkipProgressive) {
      os << ",x0=" << frame_origin.x0;
      os << ",y0=" << frame_origin.y0;
    }
  }
  if (upsampling > 1) os << ",up=" << upsampling;
  if (loop_filter.gab) os << ",Gaborish";
  if (loop_filter.epf_iters > 0) os << ",epf=" << loop_filter.epf_iters;
  if (animation_frame.duration > 0) os << ",dur=" << animation_frame.duration;
  if (frame_type == FrameType::kRegularFrame ||
      frame_type == FrameType::kSkipProgressive) {
    os << ",";
    os << blending_info.DebugString();
    for (size_t i = 0; i < extra_channel_blending_info.size(); ++i) {
      os << (i == 0 ? "[" : ";");
      os << extra_channel_blending_info[i].DebugString();
      if (i + 1 == extra_channel_blending_info.size()) os << "]";
    }
  }
  if (save_as_reference > 0) os << ",ref=" << save_as_reference;
  os << "," << (save_before_color_transform ? "before" : "after") << "_ct";
  if (is_last) os << ",last";
  return os.str();
}
#endif

}  // namespace jxl

Coverage Report

Created: 2026-02-14 07:09

Line	Count	Source
1		// Copyright (c) the JPEG XL Project Authors. All rights reserved.
2		//
3		// Use of this source code is governed by a BSD-style
4		// license that can be found in the LICENSE file.
5
6		#include "lib/jxl/frame_header.h"
7
8		#include <cstddef>
9		#include <cstdint>
10		#include <vector>
11
12		#include "lib/jxl/base/compiler_specific.h"
13		#include "lib/jxl/dec_bit_reader.h"
14		#include "lib/jxl/field_encodings.h"
15		#include "lib/jxl/image_metadata.h"
16
17		#if JXL_DEBUG_V_LEVEL >= 1
18		#include <sstream>
19		#include <string>
20		#endif
21
22		#include "lib/jxl/base/printf_macros.h"
23		#include "lib/jxl/base/status.h"
24		#include "lib/jxl/common.h" // kMaxNumPasses
25		#include "lib/jxl/fields.h"
26		#include "lib/jxl/pack_signed.h"
27
28		namespace jxl {
29
30		constexpr uint8_t YCbCrChromaSubsampling::kHShift[] = {0, 1, 1, 0};
31		constexpr uint8_t YCbCrChromaSubsampling::kVShift[] = {0, 1, 0, 1};
32
33		static Status VisitBlendMode(Visitor* JXL_RESTRICT visitor,
34	960k	BlendMode default_value, BlendMode* blend_mode) {
35	960k	uint32_t encoded = static_cast<uint32_t>(*blend_mode);
36
37	960k	JXL_QUIET_RETURN_IF_ERROR(visitor->U32(
38	960k	Val(static_cast<uint32_t>(BlendMode::kReplace)),
39	960k	Val(static_cast<uint32_t>(BlendMode::kAdd)),
40	960k	Val(static_cast<uint32_t>(BlendMode::kBlend)), BitsOffset(2, 3),
41	960k	static_cast<uint32_t>(default_value), &encoded));
42	960k	if (encoded > static_cast<uint32_t>(BlendMode::kMul)) {
43	0	return JXL_FAILURE("Invalid blend_mode");
44	0	}
45	960k	*blend_mode = static_cast<BlendMode>(encoded);
46	960k	return true;
47	960k	}
48
49		static Status VisitFrameType(Visitor* JXL_RESTRICT visitor,
50	228k	FrameType default_value, FrameType* frame_type) {
51	228k	uint32_t encoded = static_cast<uint32_t>(*frame_type);
52
53	228k	JXL_QUIET_RETURN_IF_ERROR(
54	228k	visitor->U32(Val(static_cast<uint32_t>(FrameType::kRegularFrame)),
55	228k	Val(static_cast<uint32_t>(FrameType::kDCFrame)),
56	228k	Val(static_cast<uint32_t>(FrameType::kReferenceOnly)),
57	228k	Val(static_cast<uint32_t>(FrameType::kSkipProgressive)),
58	228k	static_cast<uint32_t>(default_value), &encoded));
59	228k	*frame_type = static_cast<FrameType>(encoded);
60	228k	return true;
61	228k	}
62
63	645k	BlendingInfo::BlendingInfo() { Bundle::Init(this); }
64
65	960k	Status BlendingInfo::VisitFields(Visitor* JXL_RESTRICT visitor) {
66	960k	JXL_QUIET_RETURN_IF_ERROR(
67	960k	VisitBlendMode(visitor, BlendMode::kReplace, &mode));
68	960k	if (visitor->Conditional(nonserialized_num_extra_channels > 0 &&
69	260k	(mode == BlendMode::kBlend \|\|
70	645k	mode == BlendMode::kAlphaWeightedAdd))) {
71		// Up to 11 alpha channels for blending.
72	645k	JXL_QUIET_RETURN_IF_ERROR(visitor->U32(
73	645k	Val(0), Val(1), Val(2), BitsOffset(3, 3), 0, &alpha_channel));
74	645k	if (visitor->IsReading() &&
75	5	alpha_channel >= nonserialized_num_extra_channels) {
76	0	return JXL_FAILURE("Invalid alpha channel for blending");
77	0	}
78	645k	}
79	960k	if (visitor->Conditional((nonserialized_num_extra_channels > 0 &&
80	260k	(mode == BlendMode::kBlend \|\|
81	260k	mode == BlendMode::kAlphaWeightedAdd)) \|\|
82	960k	mode == BlendMode::kMul)) {
83	645k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(false, &clamp));
84	645k	}
85		// 'old' frame for blending. Only necessary if this is not a full frame, or
86		// blending is not kReplace.
87	960k	if (visitor->Conditional(mode != BlendMode::kReplace \|\|
88	959k	nonserialized_is_partial_frame)) {
89	647k	JXL_QUIET_RETURN_IF_ERROR(
90	647k	visitor->U32(Val(0), Val(1), Val(2), Val(3), 0, &source));
91	647k	}
92	960k	return true;
93	960k	}
94
95		#if JXL_DEBUG_V_LEVEL >= 1
96		std::string BlendingInfo::DebugString() const {
97		std::ostringstream os;
98		os << (mode == BlendMode::kReplace ? "Replace"
99		: mode == BlendMode::kAdd ? "Add"
100		: mode == BlendMode::kBlend ? "Blend"
101		: mode == BlendMode::kAlphaWeightedAdd ? "AlphaWeightedAdd"
102		: "Mul");
103		if (nonserialized_num_extra_channels > 0 &&
104		(mode == BlendMode::kBlend \|\| mode == BlendMode::kAlphaWeightedAdd)) {
105		os << ",alpha=" << alpha_channel << ",clamp=" << clamp;
106		} else if (mode == BlendMode::kMul) {
107		os << ",clamp=" << clamp;
108		}
109		if (mode != BlendMode::kReplace \|\| nonserialized_is_partial_frame) {
110		os << ",source=" << source;
111		}
112		return os.str();
113		}
114		#endif
115
116		AnimationFrame::AnimationFrame(const CodecMetadata* metadata)
117	153k	: nonserialized_metadata(metadata) {
118	153k	Bundle::Init(this);
119	153k	}
120	217k	Status AnimationFrame::VisitFields(Visitor* JXL_RESTRICT visitor) {
121	217k	if (visitor->Conditional(nonserialized_metadata != nullptr &&
122	217k	nonserialized_metadata->m.have_animation)) {
123	217k	JXL_QUIET_RETURN_IF_ERROR(
124	217k	visitor->U32(Val(0), Val(1), Bits(8), Bits(32), 0, &duration));
125	217k	}
126
127	217k	if (visitor->Conditional(
128	217k	nonserialized_metadata != nullptr &&
129	217k	nonserialized_metadata->m.animation.have_timecodes)) {
130	169k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(32, 0, &timecode));
131	169k	}
132	217k	return true;
133	217k	}
134
135	186k	YCbCrChromaSubsampling::YCbCrChromaSubsampling() { Bundle::Init(this); }
136	153k	Passes::Passes() { Bundle::Init(this); }
137	227k	Status Passes::VisitFields(Visitor* JXL_RESTRICT visitor) {
138	227k	JXL_QUIET_RETURN_IF_ERROR(
139	227k	visitor->U32(Val(1), Val(2), Val(3), BitsOffset(3, 4), 1, &num_passes));
140	227k	JXL_ENSURE(num_passes <= kMaxNumPasses); // Cannot happen when reading
141
142	227k	if (visitor->Conditional(num_passes != 1)) {
143	155k	JXL_QUIET_RETURN_IF_ERROR(visitor->U32(
144	155k	Val(0), Val(1), Val(2), BitsOffset(1, 3), 0, &num_downsample));
145	155k	JXL_ENSURE(num_downsample <= 4); // 1,2,4,8
146	155k	if (num_downsample > num_passes) {
147	0	return JXL_FAILURE("num_downsample %u > num_passes %u", num_downsample,
148	0	num_passes);
149	0	}
150
151	158k	for (uint32_t i = 0; i < num_passes - 1; i++) {
152	2.77k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(2, 0, &shift[i]));
153	2.77k	}
154	155k	shift[num_passes - 1] = 0;
155
156	156k	for (uint32_t i = 0; i < num_downsample; ++i) {
157	1.35k	JXL_QUIET_RETURN_IF_ERROR(
158	1.35k	visitor->U32(Val(1), Val(2), Val(4), Val(8), 1, &downsample[i]));
159	1.35k	if (i > 0 && downsample[i] >= downsample[i - 1]) {
160	2	return JXL_FAILURE("downsample sequence should be decreasing");
161	2	}
162	1.35k	}
163	156k	for (uint32_t i = 0; i < num_downsample; ++i) {
164	1.34k	JXL_QUIET_RETURN_IF_ERROR(
165	1.34k	visitor->U32(Val(0), Val(1), Val(2), Bits(3), 0, &last_pass[i]));
166	1.34k	if (i > 0 && last_pass[i] <= last_pass[i - 1]) {
167	1	return JXL_FAILURE("last_pass sequence should be increasing");
168	1	}
169	1.34k	if (last_pass[i] >= num_passes) {
170	0	return JXL_FAILURE("last_pass %u >= num_passes %u", last_pass[i],
171	0	num_passes);
172	0	}
173	1.34k	}
174	155k	}
175
176	227k	return true;
177	227k	}
178
179		#if JXL_DEBUG_V_LEVEL >= 1
180		std::string Passes::DebugString() const {
181		std::ostringstream os;
182		os << "p=" << num_passes;
183		if (num_downsample) {
184		os << ",ds=";
185		for (uint32_t i = 0; i < num_downsample; ++i) {
186		os << last_pass[i] << ":" << downsample[i];
187		if (i + 1 < num_downsample) os << ";";
188		}
189		}
190		bool have_shifts = false;
191		for (uint32_t i = 0; i < num_passes; ++i) {
192		if (shift[i]) have_shifts = true;
193		}
194		if (have_shifts) {
195		os << ",shifts=";
196		for (uint32_t i = 0; i < num_passes; ++i) {
197		os << shift[i];
198		if (i + 1 < num_passes) os << ";";
199		}
200		}
201		return os.str();
202		}
203		#endif
204
205		FrameHeader::FrameHeader(const CodecMetadata* metadata)
206	153k	: animation_frame(metadata), nonserialized_metadata(metadata) {
207	153k	Bundle::Init(this);
208	153k	}
209
210		Status ReadFrameHeader(BitReader* JXL_RESTRICT reader,
211	75.1k	FrameHeader* JXL_RESTRICT frame) {
212	75.1k	return Bundle::Read(reader, frame);
213	75.1k	}
214
215	229k	Status FrameHeader::VisitFields(Visitor* JXL_RESTRICT visitor) {
216	229k	if (visitor->AllDefault(*this, &all_default)) {
217		// Overwrite all serialized fields, but not any nonserialized_*.
218	198	visitor->SetDefault(this);
219	198	return true;
220	198	}
221
222	228k	JXL_QUIET_RETURN_IF_ERROR(
223	228k	VisitFrameType(visitor, FrameType::kRegularFrame, &frame_type));
224	228k	if (visitor->IsReading() && nonserialized_is_preview &&
225	2	frame_type != kRegularFrame) {
226	0	return JXL_FAILURE("Only regular frame could be a preview");
227	0	}
228
229		// FrameEncoding.
230	228k	bool is_modular = (encoding == FrameEncoding::kModular);
231	228k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(false, &is_modular));
232	228k	encoding = (is_modular ? FrameEncoding::kModular : FrameEncoding::kVarDCT);
233
234		// Flags
235	228k	JXL_QUIET_RETURN_IF_ERROR(visitor->U64(0, &flags));
236
237		// Color transform
238	228k	bool xyb_encoded = nonserialized_metadata == nullptr \|\|
239	228k	nonserialized_metadata->m.xyb_encoded;
240
241	228k	if (xyb_encoded) {
242	55.9k	color_transform = ColorTransform::kXYB;
243	172k	} else {
244		// Alternate if kYCbCr.
245	172k	bool alternate = color_transform == ColorTransform::kYCbCr;
246	172k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(false, &alternate));
247	172k	color_transform =
248	172k	(alternate ? ColorTransform::kYCbCr : ColorTransform::kNone);
249	172k	}
250
251		// Chroma subsampling for YCbCr, if no DC frame is used.
252	228k	if (visitor->Conditional(color_transform == ColorTransform::kYCbCr &&
253	155k	((flags & kUseDcFrame) == 0))) {
254	155k	JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&chroma_subsampling));
255	155k	}
256
257	228k	size_t num_extra_channels =
258	228k	nonserialized_metadata != nullptr
259	228k	? nonserialized_metadata->m.extra_channel_info.size()
260	228k	: 0;
261
262		// Upsampling
263	228k	if (visitor->Conditional((flags & kUseDcFrame) == 0)) {
264	228k	JXL_QUIET_RETURN_IF_ERROR(
265	228k	visitor->U32(Val(1), Val(2), Val(4), Val(8), 1, &upsampling));
266	228k	if (nonserialized_metadata != nullptr &&
267	228k	visitor->Conditional(num_extra_channels != 0)) {
268	170k	const std::vector<ExtraChannelInfo>& extra_channels =
269	170k	nonserialized_metadata->m.extra_channel_info;
270	170k	extra_channel_upsampling.resize(extra_channels.size(), 1);
271	904k	for (size_t i = 0; i < extra_channels.size(); ++i) {
272	734k	uint32_t dim_shift =
273	734k	nonserialized_metadata->m.extra_channel_info[i].dim_shift;
274	734k	uint32_t& ec_upsampling = extra_channel_upsampling[i];
275	734k	ec_upsampling >>= dim_shift;
276	734k	JXL_QUIET_RETURN_IF_ERROR(
277	734k	visitor->U32(Val(1), Val(2), Val(4), Val(8), 1, &ec_upsampling));
278	734k	ec_upsampling <<= dim_shift;
279	734k	if (ec_upsampling < upsampling) {
280	0	return JXL_FAILURE(
281	0	"EC upsampling (%u) < color upsampling (%u), which is invalid.",
282	0	ec_upsampling, upsampling);
283	0	}
284	734k	if (ec_upsampling > 8) {
285	0	return JXL_FAILURE("EC upsampling too large (%u)", ec_upsampling);
286	0	}
287	734k	}
288	170k	} else {
289	57.8k	extra_channel_upsampling.clear();
290	57.8k	}
291	228k	}
292
293		// Modular- or VarDCT-specific data.
294	228k	if (visitor->Conditional(encoding == FrameEncoding::kModular)) {
295	159k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(2, 1, &group_size_shift));
296	159k	}
297	228k	if (visitor->Conditional(encoding == FrameEncoding::kVarDCT &&
298	223k	color_transform == ColorTransform::kXYB)) {
299	169k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(3, 3, &x_qm_scale));
300	169k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bits(3, 2, &b_qm_scale));
301	169k	} else {
302	58.8k	x_qm_scale = b_qm_scale = 2; // noop
303	58.8k	}
304
305		// Not useful for kPatchSource
306	228k	if (visitor->Conditional(frame_type != FrameType::kReferenceOnly)) {
307	227k	JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&passes));
308	227k	}
309
310	228k	if (visitor->Conditional(frame_type == FrameType::kDCFrame)) {
311		// Up to 4 pyramid levels - for up to 16384x downsampling.
312	156k	JXL_QUIET_RETURN_IF_ERROR(
313	156k	visitor->U32(Val(1), Val(2), Val(3), Val(4), 1, &dc_level));
314	156k	}
315	228k	if (frame_type != FrameType::kDCFrame) {
316	226k	dc_level = 0;
317	226k	}
318
319	228k	bool is_partial_frame = false;
320	228k	if (visitor->Conditional(frame_type != FrameType::kDCFrame)) {
321	226k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(false, &custom_size_or_origin));
322	226k	if (visitor->Conditional(custom_size_or_origin)) {
323	154k	const U32Enc enc(Bits(8), BitsOffset(11, 256), BitsOffset(14, 2304),
324	154k	BitsOffset(30, 18688));
325		// Frame offset, only if kRegularFrame or kSkipProgressive.
326	154k	if (visitor->Conditional(frame_type == FrameType::kRegularFrame \|\|
327	154k	frame_type == FrameType::kSkipProgressive)) {
328	154k	uint32_t ux0 = PackSigned(frame_origin.x0);
329	154k	uint32_t uy0 = PackSigned(frame_origin.y0);
330	154k	JXL_QUIET_RETURN_IF_ERROR(visitor->U32(enc, 0, &ux0));
331	154k	JXL_QUIET_RETURN_IF_ERROR(visitor->U32(enc, 0, &uy0));
332	154k	frame_origin.x0 = UnpackSigned(ux0);
333	154k	frame_origin.y0 = UnpackSigned(uy0);
334	154k	}
335		// Frame size
336	154k	JXL_QUIET_RETURN_IF_ERROR(visitor->U32(enc, 0, &frame_size.xsize));
337	154k	JXL_QUIET_RETURN_IF_ERROR(visitor->U32(enc, 0, &frame_size.ysize));
338	154k	if (custom_size_or_origin &&
339	879	(frame_size.xsize == 0 \|\| frame_size.ysize == 0)) {
340	0	return JXL_FAILURE(
341	0	"Invalid crop dimensions for frame: zero width or height");
342	0	}
343	154k	int32_t image_xsize = default_xsize();
344	154k	int32_t image_ysize = default_ysize();
345	154k	if (frame_type == FrameType::kRegularFrame \|\|
346	154k	frame_type == FrameType::kSkipProgressive) {
347	154k	is_partial_frame \|= frame_origin.x0 > 0;
348	154k	is_partial_frame \|= frame_origin.y0 > 0;
349	154k	is_partial_frame \|= (static_cast<int32_t>(frame_size.xsize) +
350	154k	frame_origin.x0) < image_xsize;
351	154k	is_partial_frame \|= (static_cast<int32_t>(frame_size.ysize) +
352	154k	frame_origin.y0) < image_ysize;
353	154k	}
354	154k	}
355	226k	}
356
357		// Blending info, animation info and whether this is the last frame or not.
358	228k	if (visitor->Conditional(frame_type == FrameType::kRegularFrame \|\|
359	225k	frame_type == FrameType::kSkipProgressive)) {
360	225k	blending_info.nonserialized_num_extra_channels = num_extra_channels;
361	225k	blending_info.nonserialized_is_partial_frame = is_partial_frame;
362	225k	JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&blending_info));
363	225k	bool replace_all = (blending_info.mode == BlendMode::kReplace);
364	225k	extra_channel_blending_info.resize(num_extra_channels);
365	959k	for (size_t i = 0; i < num_extra_channels; i++) {
366	733k	auto& ec_blending_info = extra_channel_blending_info[i];
367	733k	ec_blending_info.nonserialized_is_partial_frame = is_partial_frame;
368	733k	ec_blending_info.nonserialized_num_extra_channels = num_extra_channels;
369	733k	JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&ec_blending_info));
370	733k	replace_all &= (ec_blending_info.mode == BlendMode::kReplace);
371	733k	}
372	225k	if (visitor->IsReading() && nonserialized_is_preview) {
373	2	if (!replace_all \|\| custom_size_or_origin) {
374	0	return JXL_FAILURE("Preview is not compatible with blending");
375	0	}
376	2	}
377	225k	if (visitor->Conditional(nonserialized_metadata != nullptr &&
378	225k	nonserialized_metadata->m.have_animation)) {
379	217k	animation_frame.nonserialized_metadata = nonserialized_metadata;
380	217k	JXL_QUIET_RETURN_IF_ERROR(visitor->VisitNested(&animation_frame));
381	217k	}
382	225k	JXL_QUIET_RETURN_IF_ERROR(visitor->Bool(true, &is_last));
383	225k	} else {
384	3.30k	is_last = false;
385	3.30k	}
386
387		// ID of that can be used to refer to this frame. 0 for a non-zero-duration
388		// frame means that it will not be referenced. Not necessary for the last
389		// frame.
390	228k	if (visitor->Conditional(frame_type != kDCFrame && !is_last)) {
391	225k	JXL_QUIET_RETURN_IF_ERROR(
392	225k	visitor->U32(Val(0), Val(1), Val(2), Val(3), 0, &save_as_reference));
393	225k	}
394
395		// If this frame is not blended on another frame post-color-transform, it may
396		// be stored for being referenced either before or after the color transform.
397		// If it is blended post-color-transform, it must be blended after. It must
398		// also be blended after if this is a kRegular frame that does not cover the
399		// full frame, as samples outside the partial region are from a
400		// post-color-transform frame.
401	228k	if (frame_type != FrameType::kDCFrame) {
402	226k	if (visitor->Conditional(CanBeReferenced() &&
403	69.8k	blending_info.mode == BlendMode::kReplace &&
404	68.7k	!is_partial_frame &&
405	68.1k	(frame_type == FrameType::kRegularFrame \|\|
406	221k	frame_type == FrameType::kSkipProgressive))) {
407	221k	JXL_QUIET_RETURN_IF_ERROR(
408	221k	visitor->Bool(false, &save_before_color_transform));
409	221k	} else if (visitor->Conditional(frame_type == FrameType::kReferenceOnly)) {
410	1.06k	JXL_QUIET_RETURN_IF_ERROR(
411	1.06k	visitor->Bool(true, &save_before_color_transform));
412	1.06k	size_t xsize = custom_size_or_origin ? frame_size.xsize
413	1.06k	: nonserialized_metadata->xsize();
414	1.06k	size_t ysize = custom_size_or_origin ? frame_size.ysize
415	1.06k	: nonserialized_metadata->ysize();
416	1.06k	if (!save_before_color_transform &&
417	797	(xsize < nonserialized_metadata->xsize() \|\|
418	796	ysize < nonserialized_metadata->ysize() \|\| frame_origin.x0 != 0 \|\|
419	796	frame_origin.y0 != 0)) {
420	1	return JXL_FAILURE(
421	1	"non-patch reference frame with invalid crop: %" PRIuS "x%" PRIuS
422	1	"%+d%+d",
423	1	xsize, ysize, static_cast<int>(frame_origin.x0),
424	1	static_cast<int>(frame_origin.y0));
425	1	}
426	1.06k	}
427	226k	} else {
428	2.23k	save_before_color_transform = true;
429	2.23k	}
430
431	228k	JXL_QUIET_RETURN_IF_ERROR(VisitNameString(visitor, &name));
432
433	228k	loop_filter.nonserialized_is_modular = is_modular;
434	228k	JXL_RETURN_IF_ERROR(visitor->VisitNested(&loop_filter));
435
436	227k	JXL_QUIET_RETURN_IF_ERROR(visitor->BeginExtensions(&extensions));
437		// Extensions: in chronological order of being added to the format.
438	227k	return visitor->EndExtensions();
439	227k	}
440
441		#if JXL_DEBUG_V_LEVEL >= 1
442		std::string FrameHeader::DebugString() const {
443		std::ostringstream os;
444		os << (encoding == FrameEncoding::kVarDCT ? "VarDCT" : "Modular");
445		os << ",";
446		os << (frame_type == FrameType::kRegularFrame ? "Regular"
447		: frame_type == FrameType::kDCFrame ? "DC"
448		: frame_type == FrameType::kReferenceOnly ? "Reference"
449		: "SkipProgressive");
450		if (frame_type == FrameType::kDCFrame) {
451		os << "(lv" << dc_level << ")";
452		}
453
454		if (flags) {
455		os << ",";
456		uint32_t remaining = flags;
457
458		#define TEST_FLAG(name) \
459		if (flags & Flags::k##name) { \
460		remaining &= ~Flags::k##name; \
461		os << #name; \
462		if (remaining) os << "\|"; \
463		}
464		TEST_FLAG(Noise);
465		TEST_FLAG(Patches);
466		TEST_FLAG(Splines);
467		TEST_FLAG(UseDcFrame);
468		TEST_FLAG(SkipAdaptiveDCSmoothing);
469		#undef TEST_FLAG
470		}
471
472		os << ",";
473		os << (color_transform == ColorTransform::kXYB ? "XYB"
474		: color_transform == ColorTransform::kYCbCr ? "YCbCr"
475		: "None");
476
477		if (encoding == FrameEncoding::kModular) {
478		os << ",shift=" << group_size_shift;
479		} else if (color_transform == ColorTransform::kXYB) {
480		os << ",qm=" << x_qm_scale << ";" << b_qm_scale;
481		}
482		if (frame_type != FrameType::kReferenceOnly) {
483		os << "," << passes.DebugString();
484		}
485		if (custom_size_or_origin) {
486		os << ",xs=" << frame_size.xsize;
487		os << ",ys=" << frame_size.ysize;
488		if (frame_type == FrameType::kRegularFrame \|\|
489		frame_type == FrameType::kSkipProgressive) {
490		os << ",x0=" << frame_origin.x0;
491		os << ",y0=" << frame_origin.y0;
492		}
493		}
494		if (upsampling > 1) os << ",up=" << upsampling;
495		if (loop_filter.gab) os << ",Gaborish";
496		if (loop_filter.epf_iters > 0) os << ",epf=" << loop_filter.epf_iters;
497		if (animation_frame.duration > 0) os << ",dur=" << animation_frame.duration;
498		if (frame_type == FrameType::kRegularFrame \|\|
499		frame_type == FrameType::kSkipProgressive) {
500		os << ",";
501		os << blending_info.DebugString();
502		for (size_t i = 0; i < extra_channel_blending_info.size(); ++i) {
503		os << (i == 0 ? "[" : ";");
504		os << extra_channel_blending_info[i].DebugString();
505		if (i + 1 == extra_channel_blending_info.size()) os << "]";
506		}
507		}
508		if (save_as_reference > 0) os << ",ref=" << save_as_reference;
509		os << "," << (save_before_color_transform ? "before" : "after") << "_ct";
510		if (is_last) os << ",last";
511		return os.str();
512		}
513		#endif
514
515		} // namespace jxl