Debian Codegraph @

lib/jxl/render_pipeline/stage_blending.cc

raw
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/render_pipeline/stage_blending.h"
7
8 #include <jxl/memory_manager.h>
9
10 #undef HWY_TARGET_INCLUDE
11 #define HWY_TARGET_INCLUDE "lib/jxl/render_pipeline/stage_blending.cc"
12 #include <hwy/foreach_target.h>
13 #include <hwy/highway.h>
14
15 #include "lib/jxl/base/printf_macros.h"
16 #include "lib/jxl/blending.h"
17
18 HWY_BEFORE_NAMESPACE();
19 namespace jxl {
20 namespace HWY_NAMESPACE {
21
22 class BlendingStage : public RenderPipelineStage {
23 public:
24 explicit BlendingStage(const FrameHeader& frame_header,
25 const PassesDecoderState* dec_state,
26 const ColorEncoding& frame_color_encoding)
27 : RenderPipelineStage(RenderPipelineStage::Settings()),
28 frame_header_(frame_header),
29 state_(*dec_state->shared) {
30 image_xsize_ = frame_header_.nonserialized_metadata->xsize();
31 image_ysize_ = frame_header_.nonserialized_metadata->ysize();
32 extra_channel_info_ =
33 &frame_header_.nonserialized_metadata->m.extra_channel_info;
34 info_ = frame_header_.blending_info;
35 const std::vector<BlendingInfo>& ec_info =
36 frame_header_.extra_channel_blending_info;
37 const ImageBundle& bg = *state_.reference_frames[info_.source].frame;
38 bg_ = &bg;
39 if (bg.xsize() == 0 || bg.ysize() == 0) {
40 zeroes_.resize(image_xsize_, 0.f);
41 } else if (state_.reference_frames[info_.source].ib_is_in_xyb) {
42 initialized_ = JXL_FAILURE(
43 "Trying to blend XYB reference frame %i and non-XYB frame",
44 info_.source);
45 return;
46 } else if (std::any_of(ec_info.begin(), ec_info.end(),
47 [this](const BlendingInfo& info) {
48 const ImageBundle& bg =
49 *state_.reference_frames[info.source].frame;
50 return bg.xsize() == 0 || bg.ysize() == 0;
51 })) {
52 zeroes_.resize(image_xsize_, 0.f);
53 }
54
55 auto verify_bg_size = [&](const ImageBundle& bg) -> Status {
56 if (bg.xsize() != 0 && bg.ysize() != 0 &&
57 (bg.xsize() < image_xsize_ || bg.ysize() < image_ysize_ ||
58 bg.origin.x0 != 0 || bg.origin.y0 != 0)) {
59 return JXL_FAILURE("Trying to use a %" PRIuS "x%" PRIuS
60 " crop as a background",
61 bg.xsize(), bg.ysize());
62 }
63 return true;
64 };
65
66 Status ok = verify_bg_size(bg);
67 for (const auto& info : ec_info) {
68 const ImageBundle& bg = *state_.reference_frames[info.source].frame;
69 if (!!ok) ok = verify_bg_size(bg);
70 }
71 if (!ok) {
72 initialized_ = ok;
73 return;
74 }
75
76 if (state_.metadata->m.xyb_encoded) {
77 if (!dec_state->output_encoding_info.color_encoding_is_original) {
78 initialized_ = JXL_FAILURE("Blending in unsupported color space");
79 return;
80 }
81 }
82
83 blending_info_.resize(ec_info.size() + 1);
84 auto make_blending = [&](const BlendingInfo& info, PatchBlending* pb) {
85 pb->alpha_channel = info.alpha_channel;
86 pb->clamp = info.clamp;
87 switch (info.mode) {
88 case BlendMode::kReplace: {
89 pb->mode = PatchBlendMode::kReplace;
90 break;
91 }
92 case BlendMode::kAdd: {
93 pb->mode = PatchBlendMode::kAdd;
94 break;
95 }
96 case BlendMode::kMul: {
97 pb->mode = PatchBlendMode::kMul;
98 break;
99 }
100 case BlendMode::kBlend: {
101 pb->mode = PatchBlendMode::kBlendAbove;
102 break;
103 }
104 case BlendMode::kAlphaWeightedAdd: {
105 pb->mode = PatchBlendMode::kAlphaWeightedAddAbove;
106 break;
107 }
108 }
109 };
110 make_blending(info_, blending_info_.data());
111 for (size_t i = 0; i < ec_info.size(); i++) {
112 make_blending(ec_info[i], &blending_info_[1 + i]);
113 }
114 }
115
116 Status IsInitialized() const override { return initialized_; }
117
118 Status ProcessRow(const RowInfo& input_rows, const RowInfo& output_rows,
119 size_t xextra, size_t xsize, size_t xpos, size_t ypos,
120 size_t thread_id) const final {
121 JXL_ENSURE(initialized_);
122 JxlMemoryManager* memory_manager = state_.memory_manager;
123 const FrameOrigin& frame_origin = frame_header_.frame_origin;
124 ssize_t bg_xpos = frame_origin.x0 + static_cast<ssize_t>(xpos);
125 ssize_t bg_ypos = frame_origin.y0 + static_cast<ssize_t>(ypos);
126 int offset = 0;
127 if (bg_xpos + static_cast<ssize_t>(xsize) <= 0 ||
128 frame_origin.x0 >= static_cast<ssize_t>(image_xsize_) || bg_ypos < 0 ||
129 bg_ypos >= static_cast<ssize_t>(image_ysize_)) {
130 // TODO(eustas): or fail?
131 return true;
132 }
133 if (bg_xpos < 0) {
134 offset -= bg_xpos;
135 xsize += bg_xpos;
136 bg_xpos = 0;
137 }
138 if (bg_xpos + xsize > image_xsize_) {
139 xsize =
140 std::max<ssize_t>(0, static_cast<ssize_t>(image_xsize_) - bg_xpos);
141 }
142 std::vector<const float*> bg_row_ptrs_(input_rows.size());
143 std::vector<float*> fg_row_ptrs_(input_rows.size());
144 size_t num_c = std::min(input_rows.size(), extra_channel_info_->size() + 3);
145 for (size_t c = 0; c < num_c; ++c) {
146 fg_row_ptrs_[c] = GetInputRow(input_rows, c, 0) + offset;
147 if (c < 3) {
148 bg_row_ptrs_[c] = bg_->xsize() != 0 && bg_->ysize() != 0
149 ? bg_->color().ConstPlaneRow(c, bg_ypos) + bg_xpos
150 : zeroes_.data();
151 } else {
152 const ImageBundle& ec_bg =
153 *state_
154 .reference_frames
155 [frame_header_.extra_channel_blending_info[c - 3].source]
156 .frame;
157 bg_row_ptrs_[c] =
158 ec_bg.xsize() != 0 && ec_bg.ysize() != 0
159 ? ec_bg.extra_channels()[c - 3].ConstRow(bg_ypos) + bg_xpos
160 : zeroes_.data();
161 }
162 }
163 return PerformBlending(memory_manager, bg_row_ptrs_.data(),
164 fg_row_ptrs_.data(), fg_row_ptrs_.data(), 0, xsize,
165 blending_info_[0], blending_info_.data() + 1,
166 *extra_channel_info_);
167 }
168
169 RenderPipelineChannelMode GetChannelMode(size_t c) const final {
170 return RenderPipelineChannelMode::kInPlace;
171 }
172
173 bool SwitchToImageDimensions() const override { return true; }
174
175 void GetImageDimensions(size_t* xsize, size_t* ysize,
176 FrameOrigin* frame_origin) const override {
177 *xsize = image_xsize_;
178 *ysize = image_ysize_;
179 *frame_origin = frame_header_.frame_origin;
180 }
181
182 void ProcessPaddingRow(const RowInfo& output_rows, size_t xsize, size_t xpos,
183 size_t ypos) const override {
184 if (bg_->xsize() == 0 || bg_->ysize() == 0) {
185 for (size_t c = 0; c < 3; ++c) {
186 memset(GetInputRow(output_rows, c, 0), 0, xsize * sizeof(float));
187 }
188 } else {
189 for (size_t c = 0; c < 3; ++c) {
190 memcpy(GetInputRow(output_rows, c, 0),
191 bg_->color().ConstPlaneRow(c, ypos) + xpos,
192 xsize * sizeof(float));
193 }
194 }
195 for (size_t ec = 0; ec < extra_channel_info_->size(); ++ec) {
196 const ImageBundle& ec_bg =
197 *state_
198 .reference_frames[frame_header_.extra_channel_blending_info[ec]
199 .source]
200 .frame;
201 if (ec_bg.xsize() == 0 || ec_bg.ysize() == 0) {
202 memset(GetInputRow(output_rows, 3 + ec, 0), 0, xsize * sizeof(float));
203 } else {
204 memcpy(GetInputRow(output_rows, 3 + ec, 0),
205 ec_bg.extra_channels()[ec].ConstRow(ypos) + xpos,
206 xsize * sizeof(float));
207 }
208 }
209 }
210
211 const char* GetName() const override { return "Blending"; }
212
213 private:
214 const FrameHeader& frame_header_;
215 const PassesSharedState& state_;
216 BlendingInfo info_;
217 const ImageBundle* bg_;
218 Status initialized_ = true;
219 size_t image_xsize_;
220 size_t image_ysize_;
221 std::vector<PatchBlending> blending_info_;
222 const std::vector<ExtraChannelInfo>* extra_channel_info_;
223 std::vector<float> zeroes_;
224 };
225
226 std::unique_ptr<RenderPipelineStage> GetBlendingStage(
227 const FrameHeader& frame_header, const PassesDecoderState* dec_state,
228 const ColorEncoding& frame_color_encoding) {
229 return jxl::make_unique<BlendingStage>(frame_header, dec_state,
230 frame_color_encoding);
231 }
232
233 // NOLINTNEXTLINE(google-readability-namespace-comments)
234 } // namespace HWY_NAMESPACE
235 } // namespace jxl
236 HWY_AFTER_NAMESPACE();
237
238 #if HWY_ONCE
239 namespace jxl {
240
241 HWY_EXPORT(GetBlendingStage);
242
243 std::unique_ptr<RenderPipelineStage> GetBlendingStage(
244 const FrameHeader& frame_header, const PassesDecoderState* dec_state,
245 const ColorEncoding& frame_color_encoding) {
246 return HWY_DYNAMIC_DISPATCH(GetBlendingStage)(frame_header, dec_state,
247 frame_color_encoding);
248 }
249
250 } // namespace jxl
251 #endif