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

Source (jump to first uncovered line)
// 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"

#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: 2025-09-08 07:52

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