History

swscale/lut3d: add 3DLUT dispatch system

This is a lightweight wrapper around the underlying color management system, whose job it is merely to manage the 3DLUT state and apply them to the frame data. This is where we might add platform-specific optimizations in the future. I also plan on adding support for more pixel formats in the future. In particular, we could support YUV or XYZ input formats directly using only negligible additional code in the 3DLUT setup functions. This would eliminate the major source of slowdown, which is currently the roundtrip to RGBA64.

Niklas Haas committed 1 year ago

Commit a57fe511 parent dddf5363 files · +389 −0Browse files

Unified · Split

3 files
  1. libswscale/Makefile +1 −0
  2. libswscale/lut3d.c +290 −0
  3. libswscale/lut3d.h +98 −0
libswscale/Makefile+1−0
@@ -14,6 +14,7 @@ OBJS = alphablend.o \ · 13 unmodified lines
14 graph.o \14 graph.o \
15 half2float.o \15 half2float.o \
16 input.o \16 input.o \
17 lut3d.o \
17 options.o \18 options.o \
18 output.o \19 output.o \
19 rgb2rgb.o \20 rgb2rgb.o \
libswscale/lut3d.c+290−0
@@ -0,0 +1,290 @@
1/*
2 * Copyright (C) 2024 Niklas Haas
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21#include <assert.h>
22#include <string.h>
23
24#include "libavutil/attributes.h"
25#include "libavutil/avassert.h"
26#include "libavutil/mem.h"
27
28#include "cms.h"
29#include "csputils.h"
30#include "lut3d.h"
31
32SwsLut3D *sws_lut3d_alloc(void)
33{
34 SwsLut3D *lut3d = av_malloc(sizeof(*lut3d));
35 if (!lut3d)
36 return NULL;
37
38 lut3d->dynamic = false;
39 return lut3d;
40}
41
42void sws_lut3d_free(SwsLut3D **plut3d)
43{
44 av_freep(plut3d);
45}
46
47bool sws_lut3d_test_fmt(enum AVPixelFormat fmt, int output)
48{
49 return fmt == AV_PIX_FMT_RGBA64;
50}
51
52enum AVPixelFormat sws_lut3d_pick_pixfmt(SwsFormat fmt, int output)
53{
54 return AV_PIX_FMT_RGBA64;
55}
56
57/**
58 * v0 and v1 are 'black' and 'white'
59 * v2 and v3 are closest RGB/CMY vertices
60 * x >= y >= z are relative weights
61 */
62static av_always_inline
63v3u16_t barycentric(int shift, int x, int y, int z,
64 v3u16_t v0, v3u16_t v1, v3u16_t v2, v3u16_t v3)
65{
66 const int a = (1 << shift) - x;
67 const int b = x - y;
68 const int c = y - z;
69 const int d = z;
70 av_assert2(x >= y);
71 av_assert2(y >= z);
72
73 return (v3u16_t) {
74 (a * v0.x + b * v1.x + c * v2.x + d * v3.x) >> shift,
75 (a * v0.y + b * v1.y + c * v2.y + d * v3.y) >> shift,
76 (a * v0.z + b * v1.z + c * v2.z + d * v3.z) >> shift,
77 };
78}
79
80static av_always_inline
81v3u16_t tetrahedral(const SwsLut3D *lut3d, int Rx, int Gx, int Bx,
82 int Rf, int Gf, int Bf)
83{
84 const int shift = 16 - INPUT_LUT_BITS;
85 const int Rn = FFMIN(Rx + 1, INPUT_LUT_SIZE - 1);
86 const int Gn = FFMIN(Gx + 1, INPUT_LUT_SIZE - 1);
87 const int Bn = FFMIN(Bx + 1, INPUT_LUT_SIZE - 1);
88
89 const v3u16_t c000 = lut3d->input[Bx][Gx][Rx];
90 const v3u16_t c111 = lut3d->input[Bn][Gn][Rn];
91 if (Rf > Gf) {
92 if (Gf > Bf) {
93 const v3u16_t c100 = lut3d->input[Bx][Gx][Rn];
94 const v3u16_t c110 = lut3d->input[Bx][Gn][Rn];
95 return barycentric(shift, Rf, Gf, Bf, c000, c100, c110, c111);
96 } else if (Rf > Bf) {
97 const v3u16_t c100 = lut3d->input[Bx][Gx][Rn];
98 const v3u16_t c101 = lut3d->input[Bn][Gx][Rn];
99 return barycentric(shift, Rf, Bf, Gf, c000, c100, c101, c111);
100 } else {
101 const v3u16_t c001 = lut3d->input[Bn][Gx][Rx];
102 const v3u16_t c101 = lut3d->input[Bn][Gx][Rn];
103 return barycentric(shift, Bf, Rf, Gf, c000, c001, c101, c111);
104 }
105 } else {
106 if (Bf > Gf) {
107 const v3u16_t c001 = lut3d->input[Bn][Gx][Rx];
108 const v3u16_t c011 = lut3d->input[Bn][Gn][Rx];
109 return barycentric(shift, Bf, Gf, Rf, c000, c001, c011, c111);
110 } else if (Bf > Rf) {
111 const v3u16_t c010 = lut3d->input[Bx][Gn][Rx];
112 const v3u16_t c011 = lut3d->input[Bn][Gn][Rx];
113 return barycentric(shift, Gf, Bf, Rf, c000, c010, c011, c111);
114 } else {
115 const v3u16_t c010 = lut3d->input[Bx][Gn][Rx];
116 const v3u16_t c110 = lut3d->input[Bx][Gn][Rn];
117 return barycentric(shift, Gf, Rf, Bf, c000, c010, c110, c111);
118 }
119 }
120}
121
122static av_always_inline v3u16_t lookup_input16(const SwsLut3D *lut3d, v3u16_t rgb)
123{
124 const int shift = 16 - INPUT_LUT_BITS;
125 const int Rx = rgb.x >> shift;
126 const int Gx = rgb.y >> shift;
127 const int Bx = rgb.z >> shift;
128 const int Rf = rgb.x & ((1 << shift) - 1);
129 const int Gf = rgb.y & ((1 << shift) - 1);
130 const int Bf = rgb.z & ((1 << shift) - 1);
131 return tetrahedral(lut3d, Rx, Gx, Bx, Rf, Gf, Bf);
132}
133
134static av_always_inline v3u16_t lookup_input8(const SwsLut3D *lut3d, v3u8_t rgb)
135{
136 static_assert(INPUT_LUT_BITS <= 8, "INPUT_LUT_BITS must be <= 8");
137 const int shift = 8 - INPUT_LUT_BITS;
138 const int Rx = rgb.x >> shift;
139 const int Gx = rgb.y >> shift;
140 const int Bx = rgb.z >> shift;
141 const int Rf = rgb.x & ((1 << shift) - 1);
142 const int Gf = rgb.y & ((1 << shift) - 1);
143 const int Bf = rgb.z & ((1 << shift) - 1);
144 return tetrahedral(lut3d, Rx, Gx, Bx, Rf, Gf, Bf);
145}
146
147/**
148 * Note: These functions are scaled such that x == (1 << shift) corresponds to
149 * a value of 1.0. This makes them suitable for use when interpolation LUT
150 * entries with a fractional part that is just masked away from the index,
151 * since a fractional coordinate of e.g. 0xFFFF corresponds to a mix weight of
152 * just slightly *less* than 1.0.
153 */
154static av_always_inline v2u16_t lerp2u16(v2u16_t a, v2u16_t b, int x, int shift)
155{
156 const int xi = (1 << shift) - x;
157 return (v2u16_t) {
158 (a.x * xi + b.x * x) >> shift,
159 (a.y * xi + b.y * x) >> shift,
160 };
161}
162
163static av_always_inline v3u16_t lerp3u16(v3u16_t a, v3u16_t b, int x, int shift)
164{
165 const int xi = (1 << shift) - x;
166 return (v3u16_t) {
167 (a.x * xi + b.x * x) >> shift,
168 (a.y * xi + b.y * x) >> shift,
169 (a.z * xi + b.z * x) >> shift,
170 };
171}
172
173static av_always_inline v3u16_t lookup_output(const SwsLut3D *lut3d, v3u16_t ipt)
174{
175 const int Ishift = 16 - OUTPUT_LUT_BITS_I;
176 const int Cshift = 16 - OUTPUT_LUT_BITS_PT;
177 const int Ix = ipt.x >> Ishift;
178 const int Px = ipt.y >> Cshift;
179 const int Tx = ipt.z >> Cshift;
180 const int If = ipt.x & ((1 << Ishift) - 1);
181 const int Pf = ipt.y & ((1 << Cshift) - 1);
182 const int Tf = ipt.z & ((1 << Cshift) - 1);
183 const int In = FFMIN(Ix + 1, OUTPUT_LUT_SIZE_I - 1);
184 const int Pn = FFMIN(Px + 1, OUTPUT_LUT_SIZE_PT - 1);
185 const int Tn = FFMIN(Tx + 1, OUTPUT_LUT_SIZE_PT - 1);
186
187 /* Trilinear interpolation */
188 const v3u16_t c000 = lut3d->output[Tx][Px][Ix];
189 const v3u16_t c001 = lut3d->output[Tx][Px][In];
190 const v3u16_t c010 = lut3d->output[Tx][Pn][Ix];
191 const v3u16_t c011 = lut3d->output[Tx][Pn][In];
192 const v3u16_t c100 = lut3d->output[Tn][Px][Ix];
193 const v3u16_t c101 = lut3d->output[Tn][Px][In];
194 const v3u16_t c110 = lut3d->output[Tn][Pn][Ix];
195 const v3u16_t c111 = lut3d->output[Tn][Pn][In];
196 const v3u16_t c00 = lerp3u16(c000, c100, Tf, Cshift);
197 const v3u16_t c10 = lerp3u16(c010, c110, Tf, Cshift);
198 const v3u16_t c01 = lerp3u16(c001, c101, Tf, Cshift);
199 const v3u16_t c11 = lerp3u16(c011, c111, Tf, Cshift);
200 const v3u16_t c0 = lerp3u16(c00, c10, Pf, Cshift);
201 const v3u16_t c1 = lerp3u16(c01, c11, Pf, Cshift);
202 const v3u16_t c = lerp3u16(c0, c1, If, Ishift);
203 return c;
204}
205
206static av_always_inline v3u16_t apply_tone_map(const SwsLut3D *lut3d, v3u16_t ipt)
207{
208 const int shift = 16 - TONE_LUT_BITS;
209 const int Ix = ipt.x >> shift;
210 const int If = ipt.x & ((1 << shift) - 1);
211 const int In = FFMIN(Ix + 1, TONE_LUT_SIZE - 1);
212
213 const v2u16_t w0 = lut3d->tone_map[Ix];
214 const v2u16_t w1 = lut3d->tone_map[In];
215 const v2u16_t w = lerp2u16(w0, w1, If, shift);
216 const int base = (1 << 15) - w.y;
217
218 ipt.x = w.x;
219 ipt.y = base + (ipt.y * w.y >> 15);
220 ipt.z = base + (ipt.z * w.y >> 15);
221 return ipt;
222}
223
224int sws_lut3d_generate(SwsLut3D *lut3d, enum AVPixelFormat fmt_in,
225 enum AVPixelFormat fmt_out, const SwsColorMap *map)
226{
227 int ret;
228
229 if (!sws_lut3d_test_fmt(fmt_in, 0) || !sws_lut3d_test_fmt(fmt_out, 1))
230 return AVERROR(EINVAL);
231
232 lut3d->dynamic = map->src.frame_peak.num > 0;
233 lut3d->map = *map;
234
235 if (lut3d->dynamic) {
236 ret = sws_color_map_generate_dynamic(&lut3d->input[0][0][0],
237 &lut3d->output[0][0][0],
238 INPUT_LUT_SIZE, OUTPUT_LUT_SIZE_I,
239 OUTPUT_LUT_SIZE_PT, map);
240 if (ret < 0)
241 return ret;
242
243 /* Make sure initial state is valid */
244 sws_lut3d_update(lut3d, &map->src);
245 return 0;
246 } else {
247 return sws_color_map_generate_static(&lut3d->input[0][0][0],
248 INPUT_LUT_SIZE, map);
249 }
250}
251
252void sws_lut3d_update(SwsLut3D *lut3d, const SwsColor *new_src)
253{
254 if (!new_src || !lut3d->dynamic)
255 return;
256
257 lut3d->map.src.frame_peak = new_src->frame_peak;
258 lut3d->map.src.frame_avg = new_src->frame_avg;
259
260 sws_tone_map_generate(lut3d->tone_map, TONE_LUT_SIZE, &lut3d->map);
261}
262
263void sws_lut3d_apply(const SwsLut3D *lut3d, const uint8_t *in, int in_stride,
264 uint8_t *out, int out_stride, int w, int h)
265{
266 while (h--) {
267 const uint16_t *in16 = (const uint16_t *) in;
268 uint16_t *out16 = (uint16_t *) out;
269
270 for (int x = 0; x < w; x++) {
271 v3u16_t c = { in16[0], in16[1], in16[2] };
272 c = lookup_input16(lut3d, c);
273
274 if (lut3d->dynamic) {
275 c = apply_tone_map(lut3d, c);
276 c = lookup_output(lut3d, c);
277 }
278
279 out16[0] = c.x;
280 out16[1] = c.y;
281 out16[2] = c.z;
282 out16[3] = in16[3];
283 in16 += 4;
284 out16 += 4;
285 }
286
287 in += in_stride;
288 out += out_stride;
289 }
290}
libswscale/lut3d.h+98−0
@@ -0,0 +1,98 @@
1/*
2 * Copyright (C) 2024 Niklas Haas
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21#ifndef SWSCALE_LUT3D_H
22#define SWSCALE_LUT3D_H
23
24#include <stdint.h>
25
26#include "libavutil/csp.h"
27#include "libavutil/pixfmt.h"
28
29#include "cms.h"
30#include "csputils.h"
31#include "utils.h"
32
33enum {
34 /* Input LUT size. This is only calculated once. */
35 INPUT_LUT_BITS = 6,
36 INPUT_LUT_SIZE = (1 << INPUT_LUT_BITS) + 1, /* +1 to simplify interpolation */
37
38 /* Tone mapping LUT size. This is regenerated possibly per frame. */
39 TONE_LUT_BITS = 8,
40 TONE_LUT_SIZE = (1 << TONE_LUT_BITS) + 1,
41
42 /* Output LUT size (for dynamic tone mapping). This is only calculated once. */
43 OUTPUT_LUT_BITS_I = 6,
44 OUTPUT_LUT_BITS_PT = 7,
45
46 OUTPUT_LUT_SIZE_I = (1 << OUTPUT_LUT_BITS_I) + 1,
47 OUTPUT_LUT_SIZE_PT = (1 << OUTPUT_LUT_BITS_PT) + 1,
48};
49
50typedef struct SwsLut3D {
51 SwsColorMap map;
52 bool dynamic;
53
54 /* Gamut mapping 3DLUT(s) */
55 v3u16_t input[INPUT_LUT_SIZE][INPUT_LUT_SIZE][INPUT_LUT_SIZE];
56 v3u16_t output[OUTPUT_LUT_SIZE_PT][OUTPUT_LUT_SIZE_PT][OUTPUT_LUT_SIZE_I];
57
58 /* Split tone mapping LUT (for dynamic tone mapping) */
59 v2u16_t tone_map[TONE_LUT_SIZE]; /* new luma, desaturation */
60} SwsLut3D;
61
62SwsLut3D *sws_lut3d_alloc(void);
63void sws_lut3d_free(SwsLut3D **lut3d);
64
65/**
66 * Test to see if a given format is supported by the 3DLUT input/output code.
67 */
68bool sws_lut3d_test_fmt(enum AVPixelFormat fmt, int output);
69
70/**
71 * Pick the best compatible pixfmt for a given SwsFormat.
72 */
73enum AVPixelFormat sws_lut3d_pick_pixfmt(SwsFormat fmt, int output);
74
75/**
76 * Recalculate the (static) 3DLUT state with new settings. This will recompute
77 * everything. To only update per-frame tone mapping state, instead call
78 * sws_lut3d_update().
79 *
80 * Returns 0 or a negative error code.
81 */
82int sws_lut3d_generate(SwsLut3D *lut3d, enum AVPixelFormat fmt_in,
83 enum AVPixelFormat fmt_out, const SwsColorMap *map);
84
85/**
86 * Update the tone mapping state. This will only use per-frame metadata. The
87 * static metadata is ignored.
88 */
89void sws_lut3d_update(SwsLut3D *lut3d, const SwsColor *new_src);
90
91/**
92 * Applies a color transformation to a plane. The format must match the format
93 * provided during sws_lut3d_update().
94 */
95void sws_lut3d_apply(const SwsLut3D *lut3d, const uint8_t *in, int in_stride,
96 uint8_t *out, int out_stride, int w, int h);
97
98#endif /* SWSCALE_LUT3D_H */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t