/src/libjxl/lib/jxl/blending.cc
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/blending.h" |
7 | | |
8 | | #include <jxl/memory_manager.h> |
9 | | |
10 | | #include <cstddef> |
11 | | #include <cstring> |
12 | | #include <vector> |
13 | | |
14 | | #include "lib/jxl/alpha.h" |
15 | | #include "lib/jxl/base/status.h" |
16 | | #include "lib/jxl/dec_patch_dictionary.h" |
17 | | #include "lib/jxl/frame_header.h" |
18 | | #include "lib/jxl/image.h" |
19 | | #include "lib/jxl/image_metadata.h" |
20 | | |
21 | | namespace jxl { |
22 | | |
23 | 0 | bool NeedsBlending(const FrameHeader& frame_header) { |
24 | 0 | if (!(frame_header.frame_type == FrameType::kRegularFrame || |
25 | 0 | frame_header.frame_type == FrameType::kSkipProgressive)) { |
26 | 0 | return false; |
27 | 0 | } |
28 | 0 | const auto& info = frame_header.blending_info; |
29 | 0 | bool replace_all = (info.mode == BlendMode::kReplace); |
30 | 0 | for (const auto& ec_i : frame_header.extra_channel_blending_info) { |
31 | 0 | if (ec_i.mode != BlendMode::kReplace) { |
32 | 0 | replace_all = false; |
33 | 0 | } |
34 | 0 | } |
35 | | // Replace the full frame: nothing to do. |
36 | 0 | if (!frame_header.custom_size_or_origin && replace_all) { |
37 | 0 | return false; |
38 | 0 | } |
39 | 0 | return true; |
40 | 0 | } |
41 | | |
42 | | Status PerformBlending( |
43 | | JxlMemoryManager* memory_manager, const float* const* bg, |
44 | | const float* const* fg, float* const* out, size_t x0, size_t xsize, |
45 | | const PatchBlending& color_blending, const PatchBlending* ec_blending, |
46 | 0 | const std::vector<ExtraChannelInfo>& extra_channel_info) { |
47 | 0 | bool has_alpha = false; |
48 | 0 | size_t num_ec = extra_channel_info.size(); |
49 | 0 | for (size_t i = 0; i < num_ec; i++) { |
50 | 0 | if (extra_channel_info[i].type == jxl::ExtraChannel::kAlpha) { |
51 | 0 | has_alpha = true; |
52 | 0 | break; |
53 | 0 | } |
54 | 0 | } |
55 | 0 | JXL_ASSIGN_OR_RETURN(ImageF tmp, |
56 | 0 | ImageF::Create(memory_manager, xsize, 3 + num_ec)); |
57 | | // Blend extra channels first so that we use the pre-blending alpha. |
58 | 0 | for (size_t i = 0; i < num_ec; i++) { |
59 | 0 | switch (ec_blending[i].mode) { |
60 | 0 | case PatchBlendMode::kAdd: |
61 | 0 | for (size_t x = 0; x < xsize; x++) { |
62 | 0 | tmp.Row(3 + i)[x] = bg[3 + i][x + x0] + fg[3 + i][x + x0]; |
63 | 0 | } |
64 | 0 | continue; |
65 | | |
66 | 0 | case PatchBlendMode::kBlendAbove: { |
67 | 0 | size_t alpha = ec_blending[i].alpha_channel; |
68 | 0 | bool is_premultiplied = extra_channel_info[alpha].alpha_associated; |
69 | 0 | PerformAlphaBlending(bg[3 + i] + x0, bg[3 + alpha] + x0, fg[3 + i] + x0, |
70 | 0 | fg[3 + alpha] + x0, tmp.Row(3 + i), xsize, |
71 | 0 | is_premultiplied, ec_blending[i].clamp); |
72 | 0 | continue; |
73 | 0 | } |
74 | | |
75 | 0 | case PatchBlendMode::kBlendBelow: { |
76 | 0 | size_t alpha = ec_blending[i].alpha_channel; |
77 | 0 | bool is_premultiplied = extra_channel_info[alpha].alpha_associated; |
78 | 0 | PerformAlphaBlending(fg[3 + i] + x0, fg[3 + alpha] + x0, bg[3 + i] + x0, |
79 | 0 | bg[3 + alpha] + x0, tmp.Row(3 + i), xsize, |
80 | 0 | is_premultiplied, ec_blending[i].clamp); |
81 | 0 | continue; |
82 | 0 | } |
83 | | |
84 | 0 | case PatchBlendMode::kAlphaWeightedAddAbove: { |
85 | 0 | size_t alpha = ec_blending[i].alpha_channel; |
86 | 0 | PerformAlphaWeightedAdd(bg[3 + i] + x0, fg[3 + i] + x0, |
87 | 0 | fg[3 + alpha] + x0, tmp.Row(3 + i), xsize, |
88 | 0 | ec_blending[i].clamp); |
89 | 0 | continue; |
90 | 0 | } |
91 | | |
92 | 0 | case PatchBlendMode::kAlphaWeightedAddBelow: { |
93 | 0 | size_t alpha = ec_blending[i].alpha_channel; |
94 | 0 | PerformAlphaWeightedAdd(fg[3 + i] + x0, bg[3 + i] + x0, |
95 | 0 | bg[3 + alpha] + x0, tmp.Row(3 + i), xsize, |
96 | 0 | ec_blending[i].clamp); |
97 | 0 | continue; |
98 | 0 | } |
99 | | |
100 | 0 | case PatchBlendMode::kMul: |
101 | 0 | PerformMulBlending(bg[3 + i] + x0, fg[3 + i] + x0, tmp.Row(3 + i), |
102 | 0 | xsize, ec_blending[i].clamp); |
103 | 0 | continue; |
104 | | |
105 | 0 | case PatchBlendMode::kReplace: |
106 | 0 | if (xsize) memcpy(tmp.Row(3 + i), fg[3 + i] + x0, xsize * sizeof(**fg)); |
107 | 0 | continue; |
108 | | |
109 | 0 | case PatchBlendMode::kNone: |
110 | 0 | if (xsize) memcpy(tmp.Row(3 + i), bg[3 + i] + x0, xsize * sizeof(**fg)); |
111 | 0 | continue; |
112 | 0 | } |
113 | 0 | } |
114 | 0 | size_t alpha = color_blending.alpha_channel; |
115 | |
|
116 | 0 | const auto add = [&]() { |
117 | 0 | for (int p = 0; p < 3; p++) { |
118 | 0 | float* out = tmp.Row(p); |
119 | 0 | for (size_t x = 0; x < xsize; x++) { |
120 | 0 | out[x] = bg[p][x + x0] + fg[p][x + x0]; |
121 | 0 | } |
122 | 0 | } |
123 | 0 | }; |
124 | |
|
125 | 0 | const auto blend_weighted = [&](const float* const* bottom, |
126 | 0 | const float* const* top) { |
127 | 0 | bool is_premultiplied = extra_channel_info[alpha].alpha_associated; |
128 | 0 | PerformAlphaBlending( |
129 | 0 | {bottom[0] + x0, bottom[1] + x0, bottom[2] + x0, |
130 | 0 | bottom[3 + alpha] + x0}, |
131 | 0 | {top[0] + x0, top[1] + x0, top[2] + x0, top[3 + alpha] + x0}, |
132 | 0 | {tmp.Row(0), tmp.Row(1), tmp.Row(2), tmp.Row(3 + alpha)}, xsize, |
133 | 0 | is_premultiplied, color_blending.clamp); |
134 | 0 | }; |
135 | |
|
136 | 0 | const auto add_weighted = [&](const float* const* bottom, |
137 | 0 | const float* const* top) { |
138 | 0 | for (size_t c = 0; c < 3; c++) { |
139 | 0 | PerformAlphaWeightedAdd(bottom[c] + x0, top[c] + x0, top[3 + alpha] + x0, |
140 | 0 | tmp.Row(c), xsize, color_blending.clamp); |
141 | 0 | } |
142 | 0 | }; |
143 | |
|
144 | 0 | const auto copy = [&](const float* const* src) { |
145 | 0 | for (size_t p = 0; p < 3; p++) { |
146 | 0 | memcpy(tmp.Row(p), src[p] + x0, xsize * sizeof(**src)); |
147 | 0 | } |
148 | 0 | }; |
149 | |
|
150 | 0 | switch (color_blending.mode) { |
151 | 0 | case PatchBlendMode::kAdd: |
152 | 0 | add(); |
153 | 0 | break; |
154 | | |
155 | 0 | case PatchBlendMode::kAlphaWeightedAddAbove: |
156 | 0 | has_alpha ? add_weighted(bg, fg) : add(); |
157 | 0 | break; |
158 | | |
159 | 0 | case PatchBlendMode::kAlphaWeightedAddBelow: |
160 | 0 | has_alpha ? add_weighted(fg, bg) : add(); |
161 | 0 | break; |
162 | | |
163 | 0 | case PatchBlendMode::kBlendAbove: |
164 | 0 | has_alpha ? blend_weighted(bg, fg) : copy(fg); |
165 | 0 | break; |
166 | | |
167 | 0 | case PatchBlendMode::kBlendBelow: |
168 | 0 | has_alpha ? blend_weighted(fg, bg) : copy(fg); |
169 | 0 | break; |
170 | | |
171 | 0 | case PatchBlendMode::kMul: |
172 | 0 | for (int p = 0; p < 3; p++) { |
173 | 0 | PerformMulBlending(bg[p] + x0, fg[p] + x0, tmp.Row(p), xsize, |
174 | 0 | color_blending.clamp); |
175 | 0 | } |
176 | 0 | break; |
177 | | |
178 | 0 | case PatchBlendMode::kReplace: |
179 | 0 | copy(fg); |
180 | 0 | break; |
181 | | |
182 | 0 | case PatchBlendMode::kNone: |
183 | 0 | copy(bg); |
184 | 0 | } |
185 | | |
186 | 0 | for (size_t i = 0; i < 3 + num_ec; i++) { |
187 | 0 | if (xsize != 0) memcpy(out[i] + x0, tmp.Row(i), xsize * sizeof(**out)); |
188 | 0 | } |
189 | 0 | return true; |
190 | 0 | } |
191 | | |
192 | | } // namespace jxl |