| @@ -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 | |
| | 32 | SwsLut3D *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 | |
| | 42 | void sws_lut3d_free(SwsLut3D **plut3d) |
| | 43 | { |
| | 44 | av_freep(plut3d); |
| | 45 | } |
| | 46 | |
| | 47 | bool sws_lut3d_test_fmt(enum AVPixelFormat fmt, int output) |
| | 48 | { |
| | 49 | return fmt == AV_PIX_FMT_RGBA64; |
| | 50 | } |
| | 51 | |
| | 52 | enum 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 | */ |
| | 62 | static av_always_inline |
| | 63 | v3u16_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 | |
| | 80 | static av_always_inline |
| | 81 | v3u16_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 | |
| | 122 | static 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 | |
| | 134 | static 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 | */ |
| | 154 | static 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 | |
| | 163 | static 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 | |
| | 173 | static 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 | |
| | 206 | static 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 | |
| | 224 | int 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 | |
| | 252 | void 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 | |
| | 263 | void 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 | } |