Debian Codegraph @

lib/jxl/render_pipeline/simple_render_pipeline.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/simple_render_pipeline.h"
7
8 #include <algorithm>
9 #include <cstddef>
10 #include <cstdint>
11 #include <hwy/base.h>
12 #include <utility>
13 #include <vector>
14
15 #include "lib/jxl/base/rect.h"
16 #include "lib/jxl/base/sanitizers.h"
17 #include "lib/jxl/base/status.h"
18 #include "lib/jxl/image_ops.h"
19 #include "lib/jxl/render_pipeline/render_pipeline_stage.h"
20
21 namespace jxl {
22
23 Status SimpleRenderPipeline::PrepareForThreadsInternal(size_t num,
24 bool use_group_ids) {
25 if (!channel_data_.empty()) {
26 return true;
27 }
28 auto ch_size = [](size_t frame_size, size_t shift) {
29 return DivCeil(frame_size, 1 << shift) + kRenderPipelineXOffset * 2;
30 };
31 for (auto& entry : channel_shifts_[0]) {
32 JXL_ASSIGN_OR_RETURN(
33 ImageF ch,
34 ImageF::Create(
35 memory_manager_,
36 ch_size(frame_dimensions_.xsize_upsampled, entry.first),
37 ch_size(frame_dimensions_.ysize_upsampled, entry.second)));
38 channel_data_.push_back(std::move(ch));
39 msan::PoisonImage(channel_data_.back());
40 }
41 return true;
42 }
43
44 Rect SimpleRenderPipeline::MakeChannelRect(size_t group_id, size_t channel) {
45 size_t base_color_shift =
46 CeilLog2Nonzero(frame_dimensions_.xsize_upsampled_padded /
47 frame_dimensions_.xsize_padded);
48
49 const size_t gx = group_id % frame_dimensions_.xsize_groups;
50 const size_t gy = group_id / frame_dimensions_.xsize_groups;
51 size_t xgroupdim = (frame_dimensions_.group_dim << base_color_shift) >>
52 channel_shifts_[0][channel].first;
53 size_t ygroupdim = (frame_dimensions_.group_dim << base_color_shift) >>
54 channel_shifts_[0][channel].second;
55 return Rect(
56 kRenderPipelineXOffset + gx * xgroupdim,
57 kRenderPipelineXOffset + gy * ygroupdim, xgroupdim, ygroupdim,
58 kRenderPipelineXOffset + DivCeil(frame_dimensions_.xsize_upsampled,
59 1 << channel_shifts_[0][channel].first),
60 kRenderPipelineXOffset +
61 DivCeil(frame_dimensions_.ysize_upsampled,
62 1 << channel_shifts_[0][channel].second));
63 }
64
65 std::vector<std::pair<ImageF*, Rect>> SimpleRenderPipeline::PrepareBuffers(
66 size_t group_id, size_t thread_id) {
67 std::vector<std::pair<ImageF*, Rect>> ret;
68 for (size_t c = 0; c < channel_data_.size(); c++) {
69 ret.emplace_back(&channel_data_[c], MakeChannelRect(group_id, c));
70 }
71 return ret;
72 }
73
74 Status SimpleRenderPipeline::ProcessBuffers(size_t group_id, size_t thread_id) {
75 for (size_t c = 0; c < channel_data_.size(); c++) {
76 Rect r = MakeChannelRect(group_id, c);
77 (void)r;
78 JXL_CHECK_PLANE_INITIALIZED(channel_data_[c], r, c);
79 }
80
81 if (PassesWithAllInput() <= processed_passes_) return true;
82 processed_passes_++;
83
84 for (size_t stage_id = 0; stage_id < stages_.size(); stage_id++) {
85 const auto& stage = stages_[stage_id];
86 // Prepare buffers for kInOut channels.
87 std::vector<ImageF> new_channels(channel_data_.size());
88 std::vector<ImageF*> output_channels(channel_data_.size());
89
90 std::vector<std::pair<size_t, size_t>> input_sizes(channel_data_.size());
91 for (size_t c = 0; c < channel_data_.size(); c++) {
92 input_sizes[c] =
93 std::make_pair(channel_data_[c].xsize() - kRenderPipelineXOffset * 2,
94 channel_data_[c].ysize() - kRenderPipelineXOffset * 2);
95 }
96
97 for (size_t c = 0; c < channel_data_.size(); c++) {
98 if (stage->GetChannelMode(c) != RenderPipelineChannelMode::kInOut) {
99 continue;
100 }
101 // Ensure that the newly allocated channels are large enough to avoid
102 // problems with padding.
103 JXL_ASSIGN_OR_RETURN(
104 new_channels[c],
105 ImageF::Create(memory_manager_,
106 frame_dimensions_.xsize_upsampled_padded +
107 kRenderPipelineXOffset * 2 +
108 hwy::kMaxVectorSize * 8,
109 frame_dimensions_.ysize_upsampled_padded +
110 kRenderPipelineXOffset * 2));
111 JXL_RETURN_IF_ERROR(new_channels[c].ShrinkTo(
112 (input_sizes[c].first << stage->settings_.shift_x) +
113 kRenderPipelineXOffset * 2,
114 (input_sizes[c].second << stage->settings_.shift_y) +
115 kRenderPipelineXOffset * 2));
116 output_channels[c] = &new_channels[c];
117 }
118
119 auto get_row = [&](size_t c, int64_t y) {
120 return channel_data_[c].Row(kRenderPipelineXOffset + y) +
121 kRenderPipelineXOffset;
122 };
123
124 // Add mirrored pixels to all kInOut channels.
125 for (size_t c = 0; c < channel_data_.size(); c++) {
126 if (stage->GetChannelMode(c) != RenderPipelineChannelMode::kInOut) {
127 continue;
128 }
129 // Horizontal mirroring.
130 for (size_t y = 0; y < input_sizes[c].second; y++) {
131 float* row = get_row(c, y);
132 for (size_t ix = 0; ix < stage->settings_.border_x; ix++) {
133 *(row - ix - 1) =
134 row[Mirror(-static_cast<ssize_t>(ix) - 1, input_sizes[c].first)];
135 }
136 for (size_t ix = 0; ix < stage->settings_.border_x; ix++) {
137 *(row + ix + input_sizes[c].first) =
138 row[Mirror(ix + input_sizes[c].first, input_sizes[c].first)];
139 }
140 }
141 // Vertical mirroring.
142 for (int y = 0; y < static_cast<int>(stage->settings_.border_y); y++) {
143 memcpy(get_row(c, -y - 1) - stage->settings_.border_x,
144 get_row(c, Mirror(-static_cast<ssize_t>(y) - 1,
145 input_sizes[c].second)) -
146 stage->settings_.border_x,
147 sizeof(float) *
148 (input_sizes[c].first + 2 * stage->settings_.border_x));
149 }
150 for (int y = 0; y < static_cast<int>(stage->settings_.border_y); y++) {
151 memcpy(
152 get_row(c, input_sizes[c].second + y) - stage->settings_.border_x,
153 get_row(c,
154 Mirror(input_sizes[c].second + y, input_sizes[c].second)) -
155 stage->settings_.border_x,
156 sizeof(float) *
157 (input_sizes[c].first + 2 * stage->settings_.border_x));
158 }
159 }
160
161 size_t ysize = 0;
162 size_t xsize = 0;
163 for (size_t c = 0; c < channel_data_.size(); c++) {
164 if (stage->GetChannelMode(c) == RenderPipelineChannelMode::kIgnored) {
165 continue;
166 }
167 ysize = std::max(input_sizes[c].second, ysize);
168 xsize = std::max(input_sizes[c].first, xsize);
169 }
170
171 JXL_ENSURE(ysize != 0);
172 JXL_ENSURE(xsize != 0);
173
174 RenderPipelineStage::RowInfo input_rows(channel_data_.size());
175 RenderPipelineStage::RowInfo output_rows(channel_data_.size());
176
177 // Run the pipeline.
178 {
179 JXL_RETURN_IF_ERROR(stage->SetInputSizes(input_sizes));
180 int border_y = stage->settings_.border_y;
181 for (size_t y = 0; y < ysize; y++) {
182 // Prepare input rows.
183 for (size_t c = 0; c < channel_data_.size(); c++) {
184 if (stage->GetChannelMode(c) == RenderPipelineChannelMode::kIgnored) {
185 continue;
186 }
187 input_rows[c].resize(2 * border_y + 1);
188 for (int iy = -border_y; iy <= border_y; iy++) {
189 input_rows[c][iy + border_y] =
190 channel_data_[c].Row(y + kRenderPipelineXOffset + iy);
191 }
192 }
193 // Prepare output rows.
194 for (size_t c = 0; c < channel_data_.size(); c++) {
195 if (!output_channels[c]) continue;
196 output_rows[c].resize(1 << stage->settings_.shift_y);
197 for (size_t iy = 0; iy < output_rows[c].size(); iy++) {
198 output_rows[c][iy] = output_channels[c]->Row(
199 (y << stage->settings_.shift_y) + iy + kRenderPipelineXOffset);
200 }
201 }
202 JXL_RETURN_IF_ERROR(stage->ProcessRow(input_rows, output_rows,
203 /*xextra=*/0, xsize,
204 /*xpos=*/0, y, thread_id));
205 }
206 }
207
208 // Move new channels to current channels.
209 for (size_t c = 0; c < channel_data_.size(); c++) {
210 if (stage->GetChannelMode(c) != RenderPipelineChannelMode::kInOut) {
211 continue;
212 }
213 channel_data_[c] = std::move(new_channels[c]);
214 }
215 for (size_t c = 0; c < channel_data_.size(); c++) {
216 size_t next_stage = std::min(stage_id + 1, channel_shifts_.size() - 1);
217 size_t xsize = DivCeil(frame_dimensions_.xsize_upsampled,
218 1 << channel_shifts_[next_stage][c].first);
219 size_t ysize = DivCeil(frame_dimensions_.ysize_upsampled,
220 1 << channel_shifts_[next_stage][c].second);
221 JXL_RETURN_IF_ERROR(
222 channel_data_[c].ShrinkTo(xsize + 2 * kRenderPipelineXOffset,
223 ysize + 2 * kRenderPipelineXOffset));
224 JXL_CHECK_PLANE_INITIALIZED(
225 channel_data_[c],
226 Rect(kRenderPipelineXOffset, kRenderPipelineXOffset, xsize, ysize),
227 c);
228 }
229
230 if (stage->SwitchToImageDimensions()) {
231 size_t image_xsize;
232 size_t image_ysize;
233 FrameOrigin frame_origin;
234 stage->GetImageDimensions(&image_xsize, &image_ysize, &frame_origin);
235 frame_dimensions_.Set(image_xsize, image_ysize, 0, 0, 0, false, 1);
236 std::vector<ImageF> old_channels = std::move(channel_data_);
237 channel_data_.clear();
238 channel_data_.reserve(old_channels.size());
239 for (size_t c = 0; c < old_channels.size(); c++) {
240 JXL_ASSIGN_OR_RETURN(
241 ImageF ch,
242 ImageF::Create(memory_manager_,
243 2 * kRenderPipelineXOffset + image_xsize,
244 2 * kRenderPipelineXOffset + image_ysize));
245 channel_data_.emplace_back(std::move(ch));
246 }
247 for (size_t y = 0; y < image_ysize; ++y) {
248 for (size_t c = 0; c < channel_data_.size(); c++) {
249 output_rows[c].resize(1);
250 output_rows[c][0] = channel_data_[c].Row(kRenderPipelineXOffset + y);
251 }
252 // TODO(sboukortt): consider doing this only on the parts of the
253 // background that won't be occluded.
254 stage->ProcessPaddingRow(output_rows, image_xsize, 0, y);
255 }
256 ssize_t x0 = frame_origin.x0;
257 ssize_t y0 = frame_origin.y0;
258 size_t x0_fg = 0;
259 size_t y0_fg = 0;
260 if (x0 < 0) {
261 xsize += x0;
262 x0_fg -= x0;
263 x0 = 0;
264 }
265 if (x0 + xsize > image_xsize) {
266 xsize = image_xsize - x0;
267 }
268 if (y0 < 0) {
269 ysize += y0;
270 y0_fg -= x0;
271 y0 = 0;
272 }
273 if (y0 + ysize > image_ysize) {
274 ysize = image_ysize - y0;
275 }
276 const Rect rect_fg_relative_to_image =
277 Rect(x0, y0, xsize, ysize)
278 .Translate(kRenderPipelineXOffset, kRenderPipelineXOffset);
279 const Rect rect_fg =
280 Rect(x0_fg, y0_fg, xsize, ysize)
281 .Translate(kRenderPipelineXOffset, kRenderPipelineXOffset);
282 for (size_t c = 0; c < channel_data_.size(); c++) {
283 JXL_RETURN_IF_ERROR(CopyImageTo(rect_fg, old_channels[c],
284 rect_fg_relative_to_image,
285 &channel_data_[c]));
286 }
287 }
288 }
289 return true;
290 }
291 } // namespace jxl