libavfilter/vf_ciescope.c

   1 /*
   2  * Copyright (c) 2000 John Walker
   3  * Copyright (c) 2016 Paul B Mahol
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/avassert.h"
  23 #include "libavutil/intreadwrite.h"
  24 #include "libavutil/opt.h"
  25 #include "libavutil/parseutils.h"
  26 #include "libavutil/pixdesc.h"
  27 #include "avfilter.h"
  28 #include "formats.h"
  29 #include "internal.h"
  30 #include "video.h"
  31
  32 enum CieSystem {
  33     XYY,
  34     UCS,
  35     LUV,
  36     NB_CIE
  37 };
  38
  39 enum ColorsSystems {
  40     NTSCsystem,
  41     EBUsystem,
  42     SMPTEsystem,
  43     SMPTE240Msystem,
  44     APPLEsystem,
  45     wRGBsystem,
  46     CIE1931system,
  47     Rec709system,
  48     Rec2020system,
  49     DCIP3,
  50     NB_CS
  51 };
  52
  53 typedef struct CiescopeContext {
  54     const AVClass *class;
  55     int color_system;
  56     unsigned gamuts;
  57     int size;
  58     int show_white;
  59     int correct_gamma;
  60     int cie;
  61     float intensity;
  62     float contrast;
  63     int background;
  64     int fill;
  65
  66     float log2lin[65536];
  67     float igamma;
  68     float i[3][3];
  69     float m[3][3];
  70     AVFrame *f;
  71     void (*filter)(AVFilterContext *ctx, const uint8_t *ptr,
  72                    ptrdiff_t linesize,
  73                    float *cx, float *cy, int x, int y);
  74 } CiescopeContext;
  75
  76 #define OFFSET(x) offsetof(CiescopeContext, x)
  77 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
  78
  79 static const AVOption ciescope_options[] = {
  80     { "system",     "set color system", OFFSET(color_system), AV_OPT_TYPE_INT, {.i64=Rec709system}, 0, NB_CS-1, FLAGS, "system" },
  81     {   "ntsc",       "NTSC 1953 Y'I'O' (ITU-R BT.470 System M)", 0, AV_OPT_TYPE_CONST, {.i64=NTSCsystem},     0, 0, FLAGS, "system" },
  82     {   "470m",       "NTSC 1953 Y'I'O' (ITU-R BT.470 System M)", 0, AV_OPT_TYPE_CONST, {.i64=NTSCsystem},     0, 0, FLAGS, "system" },
  83     {   "ebu",        "EBU Y'U'V' (PAL/SECAM) (ITU-R BT.470 System B, G)", 0, AV_OPT_TYPE_CONST, {.i64=EBUsystem},      0, 0, FLAGS, "system" },
  84     {   "470bg",      "EBU Y'U'V' (PAL/SECAM) (ITU-R BT.470 System B, G)", 0, AV_OPT_TYPE_CONST, {.i64=EBUsystem},      0, 0, FLAGS, "system" },
  85     {   "smpte",      "SMPTE-C RGB",            0, AV_OPT_TYPE_CONST, {.i64=SMPTEsystem},    0, 0, FLAGS, "system" },
  86     {   "240m",       "SMPTE-240M Y'PbPr",      0, AV_OPT_TYPE_CONST, {.i64=SMPTE240Msystem},0, 0, FLAGS, "system" },
  87     {   "apple",      "Apple RGB",              0, AV_OPT_TYPE_CONST, {.i64=APPLEsystem},    0, 0, FLAGS, "system" },
  88     {   "widergb",    "Adobe Wide Gamut RGB",   0, AV_OPT_TYPE_CONST, {.i64=wRGBsystem},     0, 0, FLAGS, "system" },
  89     {   "cie1931",    "CIE 1931 RGB",           0, AV_OPT_TYPE_CONST, {.i64=CIE1931system},  0, 0, FLAGS, "system" },
  90     {   "hdtv",       "ITU.BT-709 Y'CbCr",      0, AV_OPT_TYPE_CONST, {.i64=Rec709system},   0, 0, FLAGS, "system" },
  91     {   "rec709",     "ITU.BT-709 Y'CbCr",      0, AV_OPT_TYPE_CONST, {.i64=Rec709system},   0, 0, FLAGS, "system" },
  92     {   "uhdtv",      "ITU-R.BT-2020",          0, AV_OPT_TYPE_CONST, {.i64=Rec2020system},  0, 0, FLAGS, "system" },
  93     {   "rec2020",    "ITU-R.BT-2020",          0, AV_OPT_TYPE_CONST, {.i64=Rec2020system},  0, 0, FLAGS, "system" },
  94     {   "dcip3",      "DCI-P3",                 0, AV_OPT_TYPE_CONST, {.i64=DCIP3},          0, 0, FLAGS, "system" },
  95     { "cie",        "set cie system", OFFSET(cie), AV_OPT_TYPE_INT,   {.i64=XYY}, 0, NB_CIE-1, FLAGS, "cie" },
  96     {   "xyy",      "CIE 1931 xyY", 0, AV_OPT_TYPE_CONST, {.i64=XYY}, 0, 0, FLAGS, "cie" },
  97     {   "ucs",      "CIE 1960 UCS", 0, AV_OPT_TYPE_CONST, {.i64=UCS}, 0, 0, FLAGS, "cie" },
  98     {   "luv",      "CIE 1976 Luv", 0, AV_OPT_TYPE_CONST, {.i64=LUV}, 0, 0, FLAGS, "cie" },
  99     { "gamuts",     "set what gamuts to draw", OFFSET(gamuts), AV_OPT_TYPE_FLAGS, {.i64=0}, 0, 0xFFF, FLAGS, "gamuts" },
 100     {   "ntsc",     NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<NTSCsystem},      0, 0, FLAGS, "gamuts" },
 101     {   "470m",     NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<NTSCsystem},      0, 0, FLAGS, "gamuts" },
 102     {   "ebu",      NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<EBUsystem},       0, 0, FLAGS, "gamuts" },
 103     {   "470bg",    NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<EBUsystem},       0, 0, FLAGS, "gamuts" },
 104     {   "smpte",    NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<SMPTEsystem},     0, 0, FLAGS, "gamuts" },
 105     {   "240m",     NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<SMPTE240Msystem}, 0, 0, FLAGS, "gamuts" },
 106     {   "apple",    NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<APPLEsystem},     0, 0, FLAGS, "gamuts" },
 107     {   "widergb",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<wRGBsystem},      0, 0, FLAGS, "gamuts" },
 108     {   "cie1931",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<CIE1931system},   0, 0, FLAGS, "gamuts" },
 109     {   "hdtv",     NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<Rec709system},    0, 0, FLAGS, "gamuts" },
 110     {   "rec709",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<Rec709system},    0, 0, FLAGS, "gamuts" },
 111     {   "uhdtv",    NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<Rec2020system},   0, 0, FLAGS, "gamuts" },
 112     {   "rec2020",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<Rec2020system},   0, 0, FLAGS, "gamuts" },
 113     {   "dcip3",    NULL, 0, AV_OPT_TYPE_CONST, {.i64=1<<DCIP3},           0, 0, FLAGS, "gamuts" },
 114     { "size",       "set ciescope size", OFFSET(size), AV_OPT_TYPE_INT, {.i64=512}, 256, 8192, FLAGS },
 115     { "s",          "set ciescope size", OFFSET(size), AV_OPT_TYPE_INT, {.i64=512}, 256, 8192, FLAGS },
 116     { "intensity",  "set ciescope intensity", OFFSET(intensity), AV_OPT_TYPE_FLOAT, {.dbl=0.001}, 0, 1, FLAGS },
 117     { "i",          "set ciescope intensity", OFFSET(intensity), AV_OPT_TYPE_FLOAT, {.dbl=0.001}, 0, 1, FLAGS },
 118     { "contrast",   NULL, OFFSET(contrast), AV_OPT_TYPE_FLOAT, {.dbl=0.75},  0, 1, FLAGS },
 119     { "corrgamma",  NULL, OFFSET(correct_gamma), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
 120     { "showwhite",  NULL, OFFSET(show_white), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
 121     { "gamma",      NULL, OFFSET(igamma), AV_OPT_TYPE_DOUBLE, {.dbl=2.6}, 0.1, 6, FLAGS },
 122     { "fill",       "fill with CIE colors", OFFSET(fill), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
 123     { NULL }
 124 };
 125
 126 AVFILTER_DEFINE_CLASS(ciescope);
 127
 128 static const enum AVPixelFormat in_pix_fmts[] = {
 129     AV_PIX_FMT_RGB24,
 130     AV_PIX_FMT_RGBA,
 131     AV_PIX_FMT_RGB48,
 132     AV_PIX_FMT_RGBA64,
 133     AV_PIX_FMT_XYZ12,
 134     AV_PIX_FMT_NONE
 135 };
 136
 137 static const enum AVPixelFormat out_pix_fmts[] = {
 138     AV_PIX_FMT_RGBA64,
 139     AV_PIX_FMT_NONE
 140 };
 141
 142 static int query_formats(AVFilterContext *ctx)
 143 {
 144     int ret;
 145
 146     if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
 147         return ret;
 148
 149     if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
 150         return ret;
 151
 152     return 0;
 153 }
 154
 155 static int config_output(AVFilterLink *outlink)
 156 {
 157     CiescopeContext *s = outlink->src->priv;
 158
 159     outlink->h = outlink->w = s->size;
 160     outlink->sample_aspect_ratio = (AVRational){1,1};
 161
 162     return 0;
 163 }
 164
 165 /* A  color  system is defined by the CIE x and y  coordinates of its
 166    three primary illuminants and the x and y coordinates of the  white
 167    point. */
 168
 169 struct ColorSystem {
 170     float xRed, yRed,        /* Red primary illuminant */
 171           xGreen, yGreen,    /* Green primary illuminant */
 172           xBlue, yBlue,      /* Blue primary illuminant */
 173           xWhite, yWhite,    /* White point */
 174           gamma;             /* gamma of nonlinear correction */
 175 };
 176
 177 static float const spectral_chromaticity[][3] = {
 178     { 0.175560, 0.005294, 0.819146 },
 179     { 0.175483, 0.005286, 0.819231 },
 180     { 0.175400, 0.005279, 0.819321 },
 181     { 0.175317, 0.005271, 0.819412 },
 182     { 0.175237, 0.005263, 0.819500 },
 183     { 0.175161, 0.005256, 0.819582 },
 184     { 0.175088, 0.005247, 0.819665 },
 185     { 0.175015, 0.005236, 0.819749 },
 186     { 0.174945, 0.005226, 0.819829 },
 187     { 0.174880, 0.005221, 0.819899 },
 188     { 0.174821, 0.005221, 0.819959 },
 189     { 0.174770, 0.005229, 0.820001 },
 190     { 0.174722, 0.005238, 0.820040 },
 191     { 0.174665, 0.005236, 0.820098 },
 192     { 0.174595, 0.005218, 0.820187 },
 193     { 0.174510, 0.005182, 0.820309 },
 194     { 0.174409, 0.005127, 0.820464 },
 195     { 0.174308, 0.005068, 0.820624 },
 196     { 0.174222, 0.005017, 0.820761 },
 197     { 0.174156, 0.004981, 0.820863 },
 198     { 0.174112, 0.004964, 0.820924 },
 199     { 0.174088, 0.004964, 0.820948 },
 200     { 0.174073, 0.004973, 0.820955 },
 201     { 0.174057, 0.004982, 0.820961 },
 202     { 0.174036, 0.004986, 0.820978 },
 203     { 0.174008, 0.004981, 0.821012 },
 204     { 0.173972, 0.004964, 0.821064 },
 205     { 0.173932, 0.004943, 0.821125 },
 206     { 0.173889, 0.004926, 0.821185 },
 207     { 0.173845, 0.004916, 0.821239 },
 208     { 0.173801, 0.004915, 0.821284 },
 209     { 0.173754, 0.004925, 0.821321 },
 210     { 0.173705, 0.004937, 0.821358 },
 211     { 0.173655, 0.004944, 0.821401 },
 212     { 0.173606, 0.004940, 0.821454 },
 213     { 0.173560, 0.004923, 0.821517 },
 214     { 0.173514, 0.004895, 0.821590 },
 215     { 0.173468, 0.004865, 0.821667 },
 216     { 0.173424, 0.004836, 0.821740 },
 217     { 0.173380, 0.004813, 0.821807 },
 218     { 0.173337, 0.004797, 0.821866 },
 219     { 0.173291, 0.004786, 0.821923 },
 220     { 0.173238, 0.004779, 0.821983 },
 221     { 0.173174, 0.004775, 0.822051 },
 222     { 0.173101, 0.004774, 0.822125 },
 223     { 0.173021, 0.004775, 0.822204 },
 224     { 0.172934, 0.004781, 0.822285 },
 225     { 0.172843, 0.004791, 0.822366 },
 226     { 0.172751, 0.004799, 0.822450 },
 227     { 0.172662, 0.004802, 0.822536 },
 228     { 0.172577, 0.004799, 0.822624 },
 229     { 0.172489, 0.004795, 0.822715 },
 230     { 0.172396, 0.004796, 0.822808 },
 231     { 0.172296, 0.004803, 0.822901 },
 232     { 0.172192, 0.004815, 0.822993 },
 233     { 0.172087, 0.004833, 0.823081 },
 234     { 0.171982, 0.004855, 0.823163 },
 235     { 0.171871, 0.004889, 0.823240 },
 236     { 0.171741, 0.004939, 0.823319 },
 237     { 0.171587, 0.005010, 0.823402 },
 238     { 0.171407, 0.005102, 0.823490 },
 239     { 0.171206, 0.005211, 0.823583 },
 240     { 0.170993, 0.005334, 0.823674 },
 241     { 0.170771, 0.005470, 0.823759 },
 242     { 0.170541, 0.005621, 0.823838 },
 243     { 0.170301, 0.005789, 0.823911 },
 244     { 0.170050, 0.005974, 0.823976 },
 245     { 0.169786, 0.006177, 0.824037 },
 246     { 0.169505, 0.006398, 0.824097 },
 247     { 0.169203, 0.006639, 0.824158 },
 248     { 0.168878, 0.006900, 0.824222 },
 249     { 0.168525, 0.007184, 0.824291 },
 250     { 0.168146, 0.007491, 0.824363 },
 251     { 0.167746, 0.007821, 0.824433 },
 252     { 0.167328, 0.008175, 0.824496 },
 253     { 0.166895, 0.008556, 0.824549 },
 254     { 0.166446, 0.008964, 0.824589 },
 255     { 0.165977, 0.009402, 0.824622 },
 256     { 0.165483, 0.009865, 0.824652 },
 257     { 0.164963, 0.010351, 0.824687 },
 258     { 0.164412, 0.010858, 0.824731 },
 259     { 0.163828, 0.011385, 0.824787 },
 260     { 0.163210, 0.011937, 0.824853 },
 261     { 0.162552, 0.012520, 0.824928 },
 262     { 0.161851, 0.013137, 0.825011 },
 263     { 0.161105, 0.013793, 0.825102 },
 264     { 0.160310, 0.014491, 0.825199 },
 265     { 0.159466, 0.015232, 0.825302 },
 266     { 0.158573, 0.016015, 0.825412 },
 267     { 0.157631, 0.016840, 0.825529 },
 268     { 0.156641, 0.017705, 0.825654 },
 269     { 0.155605, 0.018609, 0.825786 },
 270     { 0.154525, 0.019556, 0.825920 },
 271     { 0.153397, 0.020554, 0.826049 },
 272     { 0.152219, 0.021612, 0.826169 },
 273     { 0.150985, 0.022740, 0.826274 },
 274     { 0.149691, 0.023950, 0.826359 },
 275     { 0.148337, 0.025247, 0.826416 },
 276     { 0.146928, 0.026635, 0.826437 },
 277     { 0.145468, 0.028118, 0.826413 },
 278     { 0.143960, 0.029703, 0.826337 },
 279     { 0.142405, 0.031394, 0.826201 },
 280     { 0.140796, 0.033213, 0.825991 },
 281     { 0.139121, 0.035201, 0.825679 },
 282     { 0.137364, 0.037403, 0.825233 },
 283     { 0.135503, 0.039879, 0.824618 },
 284     { 0.133509, 0.042692, 0.823798 },
 285     { 0.131371, 0.045876, 0.822753 },
 286     { 0.129086, 0.049450, 0.821464 },
 287     { 0.126662, 0.053426, 0.819912 },
 288     { 0.124118, 0.057803, 0.818079 },
 289     { 0.121469, 0.062588, 0.815944 },
 290     { 0.118701, 0.067830, 0.813468 },
 291     { 0.115807, 0.073581, 0.810612 },
 292     { 0.112776, 0.079896, 0.807328 },
 293     { 0.109594, 0.086843, 0.803563 },
 294     { 0.106261, 0.094486, 0.799253 },
 295     { 0.102776, 0.102864, 0.794360 },
 296     { 0.099128, 0.112007, 0.788865 },
 297     { 0.095304, 0.121945, 0.782751 },
 298     { 0.091294, 0.132702, 0.776004 },
 299     { 0.087082, 0.144317, 0.768601 },
 300     { 0.082680, 0.156866, 0.760455 },
 301     { 0.078116, 0.170420, 0.751464 },
 302     { 0.073437, 0.185032, 0.741531 },
 303     { 0.068706, 0.200723, 0.730571 },
 304     { 0.063993, 0.217468, 0.718539 },
 305     { 0.059316, 0.235254, 0.705430 },
 306     { 0.054667, 0.254096, 0.691238 },
 307     { 0.050031, 0.274002, 0.675967 },
 308     { 0.045391, 0.294976, 0.659633 },
 309     { 0.040757, 0.316981, 0.642262 },
 310     { 0.036195, 0.339900, 0.623905 },
 311     { 0.031756, 0.363598, 0.604646 },
 312     { 0.027494, 0.387921, 0.584584 },
 313     { 0.023460, 0.412703, 0.563837 },
 314     { 0.019705, 0.437756, 0.542539 },
 315     { 0.016268, 0.462955, 0.520777 },
 316     { 0.013183, 0.488207, 0.498610 },
 317     { 0.010476, 0.513404, 0.476120 },
 318     { 0.008168, 0.538423, 0.453409 },
 319     { 0.006285, 0.563068, 0.430647 },
 320     { 0.004875, 0.587116, 0.408008 },
 321     { 0.003982, 0.610447, 0.385570 },
 322     { 0.003636, 0.633011, 0.363352 },
 323     { 0.003859, 0.654823, 0.341318 },
 324     { 0.004646, 0.675898, 0.319456 },
 325     { 0.006011, 0.696120, 0.297869 },
 326     { 0.007988, 0.715342, 0.276670 },
 327     { 0.010603, 0.733413, 0.255984 },
 328     { 0.013870, 0.750186, 0.235943 },
 329     { 0.017766, 0.765612, 0.216622 },
 330     { 0.022244, 0.779630, 0.198126 },
 331     { 0.027273, 0.792104, 0.180623 },
 332     { 0.032820, 0.802926, 0.164254 },
 333     { 0.038852, 0.812016, 0.149132 },
 334     { 0.045328, 0.819391, 0.135281 },
 335     { 0.052177, 0.825164, 0.122660 },
 336     { 0.059326, 0.829426, 0.111249 },
 337     { 0.066716, 0.832274, 0.101010 },
 338     { 0.074302, 0.833803, 0.091894 },
 339     { 0.082053, 0.834090, 0.083856 },
 340     { 0.089942, 0.833289, 0.076769 },
 341     { 0.097940, 0.831593, 0.070468 },
 342     { 0.106021, 0.829178, 0.064801 },
 343     { 0.114161, 0.826207, 0.059632 },
 344     { 0.122347, 0.822770, 0.054882 },
 345     { 0.130546, 0.818928, 0.050526 },
 346     { 0.138702, 0.814774, 0.046523 },
 347     { 0.146773, 0.810395, 0.042832 },
 348     { 0.154722, 0.805864, 0.039414 },
 349     { 0.162535, 0.801238, 0.036226 },
 350     { 0.170237, 0.796519, 0.033244 },
 351     { 0.177850, 0.791687, 0.030464 },
 352     { 0.185391, 0.786728, 0.027881 },
 353     { 0.192876, 0.781629, 0.025495 },
 354     { 0.200309, 0.776399, 0.023292 },
 355     { 0.207690, 0.771055, 0.021255 },
 356     { 0.215030, 0.765595, 0.019375 },
 357     { 0.222337, 0.760020, 0.017643 },
 358     { 0.229620, 0.754329, 0.016051 },
 359     { 0.236885, 0.748524, 0.014591 },
 360     { 0.244133, 0.742614, 0.013253 },
 361     { 0.251363, 0.736606, 0.012031 },
 362     { 0.258578, 0.730507, 0.010916 },
 363     { 0.265775, 0.724324, 0.009901 },
 364     { 0.272958, 0.718062, 0.008980 },
 365     { 0.280129, 0.711725, 0.008146 },
 366     { 0.287292, 0.705316, 0.007391 },
 367     { 0.294450, 0.698842, 0.006708 },
 368     { 0.301604, 0.692308, 0.006088 },
 369     { 0.308760, 0.685712, 0.005528 },
 370     { 0.315914, 0.679063, 0.005022 },
 371     { 0.323066, 0.672367, 0.004566 },
 372     { 0.330216, 0.665628, 0.004156 },
 373     { 0.337363, 0.658848, 0.003788 },
 374     { 0.344513, 0.652028, 0.003459 },
 375     { 0.351664, 0.645172, 0.003163 },
 376     { 0.358814, 0.638287, 0.002899 },
 377     { 0.365959, 0.631379, 0.002662 },
 378     { 0.373102, 0.624451, 0.002448 },
 379     { 0.380244, 0.617502, 0.002254 },
 380     { 0.387379, 0.610542, 0.002079 },
 381     { 0.394507, 0.603571, 0.001922 },
 382     { 0.401626, 0.596592, 0.001782 },
 383     { 0.408736, 0.589607, 0.001657 },
 384     { 0.415836, 0.582618, 0.001546 },
 385     { 0.422921, 0.575631, 0.001448 },
 386     { 0.429989, 0.568649, 0.001362 },
 387     { 0.437036, 0.561676, 0.001288 },
 388     { 0.444062, 0.554714, 0.001224 },
 389     { 0.451065, 0.547766, 0.001169 },
 390     { 0.458041, 0.540837, 0.001123 },
 391     { 0.464986, 0.533930, 0.001084 },
 392     { 0.471899, 0.527051, 0.001051 },
 393     { 0.478775, 0.520202, 0.001023 },
 394     { 0.485612, 0.513389, 0.001000 },
 395     { 0.492405, 0.506615, 0.000980 },
 396     { 0.499151, 0.499887, 0.000962 },
 397     { 0.505845, 0.493211, 0.000944 },
 398     { 0.512486, 0.486591, 0.000923 },
 399     { 0.519073, 0.480029, 0.000899 },
 400     { 0.525600, 0.473527, 0.000872 },
 401     { 0.532066, 0.467091, 0.000843 },
 402     { 0.538463, 0.460725, 0.000812 },
 403     { 0.544787, 0.454434, 0.000779 },
 404     { 0.551031, 0.448225, 0.000744 },
 405     { 0.557193, 0.442099, 0.000708 },
 406     { 0.563269, 0.436058, 0.000673 },
 407     { 0.569257, 0.430102, 0.000641 },
 408     { 0.575151, 0.424232, 0.000616 },
 409     { 0.580953, 0.418447, 0.000601 },
 410     { 0.586650, 0.412758, 0.000591 },
 411     { 0.592225, 0.407190, 0.000586 },
 412     { 0.597658, 0.401762, 0.000580 },
 413     { 0.602933, 0.396497, 0.000571 },
 414     { 0.608035, 0.391409, 0.000556 },
 415     { 0.612977, 0.386486, 0.000537 },
 416     { 0.617779, 0.381706, 0.000516 },
 417     { 0.622459, 0.377047, 0.000493 },
 418     { 0.627037, 0.372491, 0.000472 },
 419     { 0.631521, 0.368026, 0.000453 },
 420     { 0.635900, 0.363665, 0.000435 },
 421     { 0.640156, 0.359428, 0.000416 },
 422     { 0.644273, 0.355331, 0.000396 },
 423     { 0.648233, 0.351395, 0.000372 },
 424     { 0.652028, 0.347628, 0.000344 },
 425     { 0.655669, 0.344018, 0.000313 },
 426     { 0.659166, 0.340553, 0.000281 },
 427     { 0.662528, 0.337221, 0.000251 },
 428     { 0.665764, 0.334011, 0.000226 },
 429     { 0.668874, 0.330919, 0.000207 },
 430     { 0.671859, 0.327947, 0.000194 },
 431     { 0.674720, 0.325095, 0.000185 },
 432     { 0.677459, 0.322362, 0.000179 },
 433     { 0.680079, 0.319747, 0.000174 },
 434     { 0.682582, 0.317249, 0.000170 },
 435     { 0.684971, 0.314863, 0.000167 },
 436     { 0.687250, 0.312586, 0.000164 },
 437     { 0.689426, 0.310414, 0.000160 },
 438     { 0.691504, 0.308342, 0.000154 },
 439     { 0.693490, 0.306366, 0.000145 },
 440     { 0.695389, 0.304479, 0.000133 },
 441     { 0.697206, 0.302675, 0.000119 },
 442     { 0.698944, 0.300950, 0.000106 },
 443     { 0.700606, 0.299301, 0.000093 },
 444     { 0.702193, 0.297725, 0.000083 },
 445     { 0.703709, 0.296217, 0.000074 },
 446     { 0.705163, 0.294770, 0.000067 },
 447     { 0.706563, 0.293376, 0.000061 },
 448     { 0.707918, 0.292027, 0.000055 },
 449     { 0.709231, 0.290719, 0.000050 },
 450     { 0.710500, 0.289453, 0.000047 },
 451     { 0.711724, 0.288232, 0.000044 },
 452     { 0.712901, 0.287057, 0.000041 },
 453     { 0.714032, 0.285929, 0.000040 },
 454     { 0.715117, 0.284845, 0.000038 },
 455     { 0.716159, 0.283804, 0.000036 },
 456     { 0.717159, 0.282806, 0.000035 },
 457     { 0.718116, 0.281850, 0.000034 },
 458     { 0.719033, 0.280935, 0.000032 },
 459     { 0.719912, 0.280058, 0.000030 },
 460     { 0.720753, 0.279219, 0.000028 },
 461     { 0.721555, 0.278420, 0.000026 },
 462     { 0.722315, 0.277662, 0.000023 },
 463     { 0.723032, 0.276948, 0.000020 },
 464     { 0.723702, 0.276282, 0.000016 },
 465     { 0.724328, 0.275660, 0.000012 },
 466     { 0.724914, 0.275078, 0.000007 },
 467     { 0.725467, 0.274530, 0.000003 },
 468     { 0.725992, 0.274008, 0.000000 },
 469     { 0.726495, 0.273505, 0.000000 },
 470     { 0.726975, 0.273025, 0.000000 },
 471     { 0.727432, 0.272568, 0.000000 },
 472     { 0.727864, 0.272136, 0.000000 },
 473     { 0.728272, 0.271728, 0.000000 },
 474     { 0.728656, 0.271344, 0.000000 },
 475     { 0.729020, 0.270980, 0.000000 },
 476     { 0.729361, 0.270639, 0.000000 },
 477     { 0.729678, 0.270322, 0.000000 },
 478     { 0.729969, 0.270031, 0.000000 },
 479     { 0.730234, 0.269766, 0.000000 },
 480     { 0.730474, 0.269526, 0.000000 },
 481     { 0.730693, 0.269307, 0.000000 },
 482     { 0.730896, 0.269104, 0.000000 },
 483     { 0.731089, 0.268911, 0.000000 },
 484     { 0.731280, 0.268720, 0.000000 },
 485     { 0.731467, 0.268533, 0.000000 },
 486     { 0.731650, 0.268350, 0.000000 },
 487     { 0.731826, 0.268174, 0.000000 },
 488     { 0.731993, 0.268007, 0.000000 },
 489     { 0.732150, 0.267850, 0.000000 },
 490     { 0.732300, 0.267700, 0.000000 },
 491     { 0.732443, 0.267557, 0.000000 },
 492     { 0.732581, 0.267419, 0.000000 },
 493     { 0.732719, 0.267281, 0.000000 },
 494     { 0.732859, 0.267141, 0.000000 },
 495     { 0.733000, 0.267000, 0.000000 },
 496     { 0.733142, 0.266858, 0.000000 },
 497     { 0.733281, 0.266719, 0.000000 },
 498     { 0.733417, 0.266583, 0.000000 },
 499     { 0.733551, 0.266449, 0.000000 },
 500     { 0.733683, 0.266317, 0.000000 },
 501     { 0.733813, 0.266187, 0.000000 },
 502     { 0.733936, 0.266064, 0.000000 },
 503     { 0.734047, 0.265953, 0.000000 },
 504     { 0.734143, 0.265857, 0.000000 },
 505     { 0.734221, 0.265779, 0.000000 },
 506     { 0.734286, 0.265714, 0.000000 },
 507     { 0.734341, 0.265659, 0.000000 },
 508     { 0.734390, 0.265610, 0.000000 },
 509     { 0.734438, 0.265562, 0.000000 },
 510     { 0.734482, 0.265518, 0.000000 },
 511     { 0.734523, 0.265477, 0.000000 },
 512     { 0.734560, 0.265440, 0.000000 },
 513     { 0.734592, 0.265408, 0.000000 },
 514     { 0.734621, 0.265379, 0.000000 },
 515     { 0.734649, 0.265351, 0.000000 },
 516     { 0.734673, 0.265327, 0.000000 },
 517     { 0.734690, 0.265310, 0.000000 },
 518     { 0.734690, 0.265310, 0.000000 },
 519     { 0.734690, 0.265310, 0.000000 },
 520     { 0.734690, 0.265310, 0.000000 },
 521     { 0.734690, 0.265310, 0.000000 },
 522     { 0.734690, 0.265310, 0.000000 },
 523     { 0.734690, 0.265310, 0.000000 },
 524     { 0.734690, 0.265310, 0.000000 },
 525     { 0.734690, 0.265310, 0.000000 },
 526     { 0.734690, 0.265310, 0.000000 },
 527     { 0.734690, 0.265310, 0.000000 },
 528     { 0.734690, 0.265310, 0.000000 },
 529     { 0.734690, 0.265310, 0.000000 },
 530     { 0.734690, 0.265310, 0.000000 },
 531     { 0.734690, 0.265310, 0.000000 },
 532     { 0.734690, 0.265310, 0.000000 },
 533     { 0.734690, 0.265310, 0.000000 },
 534     { 0.734690, 0.265310, 0.000000 },
 535     { 0.734690, 0.265310, 0.000000 },
 536     { 0.734690, 0.265310, 0.000000 },
 537     { 0.734690, 0.265310, 0.000000 },
 538     { 0.734690, 0.265310, 0.000000 },
 539     { 0.734690, 0.265310, 0.000000 },
 540     { 0.734690, 0.265310, 0.000000 },
 541     { 0.734690, 0.265310, 0.000000 },
 542     { 0.734690, 0.265310, 0.000000 },
 543     { 0.734690, 0.265310, 0.000000 },
 544     { 0.734690, 0.265310, 0.000000 },
 545     { 0.734690, 0.265310, 0.000000 },
 546     { 0.734690, 0.265310, 0.000000 },
 547     { 0.734690, 0.265310, 0.000000 },
 548     { 0.734690, 0.265310, 0.000000 },
 549     { 0.734690, 0.265310, 0.000000 },
 550     { 0.734690, 0.265310, 0.000000 },
 551     { 0.734690, 0.265310, 0.000000 },
 552     { 0.734690, 0.265310, 0.000000 },
 553     { 0.734690, 0.265310, 0.000000 },
 554     { 0.734690, 0.265310, 0.000000 },
 555     { 0.734690, 0.265310, 0.000000 },
 556     { 0.734690, 0.265310, 0.000000 },
 557     { 0.734690, 0.265310, 0.000000 },
 558     { 0.734690, 0.265310, 0.000000 },
 559     { 0.734690, 0.265310, 0.000000 },
 560     { 0.734690, 0.265310, 0.000000 },
 561     { 0.734690, 0.265310, 0.000000 },
 562     { 0.734690, 0.265310, 0.000000 },
 563     { 0.734690, 0.265310, 0.000000 },
 564     { 0.734690, 0.265310, 0.000000 },
 565     { 0.734690, 0.265310, 0.000000 },
 566     { 0.734690, 0.265310, 0.000000 },
 567     { 0.734690, 0.265310, 0.000000 },
 568     { 0.734690, 0.265310, 0.000000 },
 569     { 0.734690, 0.265310, 0.000000 },
 570     { 0.734690, 0.265310, 0.000000 },
 571     { 0.734690, 0.265310, 0.000000 },
 572     { 0.734690, 0.265310, 0.000000 },
 573     { 0.734690, 0.265310, 0.000000 },
 574     { 0.734690, 0.265310, 0.000000 },
 575     { 0.734690, 0.265310, 0.000000 },
 576     { 0.734690, 0.265310, 0.000000 },
 577     { 0.734690, 0.265310, 0.000000 },
 578     { 0.734690, 0.265310, 0.000000 },
 579     { 0.734690, 0.265310, 0.000000 },
 580     { 0.734690, 0.265310, 0.000000 },
 581     { 0.734690, 0.265310, 0.000000 },
 582     { 0.734690, 0.265310, 0.000000 },
 583     { 0.734690, 0.265310, 0.000000 },
 584     { 0.734690, 0.265310, 0.000000 },
 585     { 0.734690, 0.265310, 0.000000 },
 586     { 0.734690, 0.265310, 0.000000 },
 587     { 0.734690, 0.265310, 0.000000 },
 588     { 0.734690, 0.265310, 0.000000 },
 589     { 0.734690, 0.265310, 0.000000 },
 590     { 0.734690, 0.265310, 0.000000 },
 591     { 0.734690, 0.265310, 0.000000 },
 592     { 0.734690, 0.265310, 0.000000 },
 593     { 0.734690, 0.265310, 0.000000 },
 594     { 0.734690, 0.265310, 0.000000 },
 595     { 0.734690, 0.265310, 0.000000 },
 596     { 0.734690, 0.265310, 0.000000 },
 597     { 0.734690, 0.265310, 0.000000 },
 598     { 0.734690, 0.265310, 0.000000 },
 599     { 0.734690, 0.265310, 0.000000 },
 600     { 0.734690, 0.265310, 0.000000 },
 601     { 0.734690, 0.265310, 0.000000 },
 602     { 0.734690, 0.265310, 0.000000 },
 603     { 0.734690, 0.265310, 0.000000 },
 604     { 0.734690, 0.265310, 0.000000 },
 605     { 0.734690, 0.265310, 0.000000 },
 606     { 0.734690, 0.265310, 0.000000 },
 607     { 0.734690, 0.265310, 0.000000 },
 608     { 0.734690, 0.265310, 0.000000 },
 609     { 0.734690, 0.265310, 0.000000 },
 610     { 0.734690, 0.265310, 0.000000 },
 611     { 0.734690, 0.265310, 0.000000 },
 612     { 0.734690, 0.265310, 0.000000 },
 613     { 0.734690, 0.265310, 0.000000 },
 614     { 0.734690, 0.265310, 0.000000 },
 615     { 0.734690, 0.265310, 0.000000 },
 616     { 0.734690, 0.265310, 0.000000 },
 617     { 0.734690, 0.265310, 0.000000 },
 618     { 0.734690, 0.265310, 0.000000 },
 619     { 0.734690, 0.265310, 0.000000 },
 620     { 0.734690, 0.265310, 0.000000 },
 621     { 0.734690, 0.265310, 0.000000 },
 622     { 0.734690, 0.265310, 0.000000 },
 623     { 0.734690, 0.265310, 0.000000 },
 624     { 0.734690, 0.265310, 0.000000 },
 625     { 0.734690, 0.265310, 0.000000 },
 626     { 0.734690, 0.265310, 0.000000 },
 627     { 0.734690, 0.265310, 0.000000 },
 628     { 0.734690, 0.265310, 0.000000 },
 629     { 0.734690, 0.265310, 0.000000 },
 630     { 0.734690, 0.265310, 0.000000 },
 631     { 0.734690, 0.265310, 0.000000 },
 632     { 0.734690, 0.265310, 0.000000 },
 633     { 0.734690, 0.265310, 0.000000 },
 634     { 0.734690, 0.265310, 0.000000 },
 635     { 0.734690, 0.265310, 0.000000 },
 636     { 0.734690, 0.265310, 0.000000 },
 637     { 0.734690, 0.265310, 0.000000 },
 638     { 0.734690, 0.265310, 0.000000 },
 639     { 0.734690, 0.265310, 0.000000 },
 640     { 0.734690, 0.265310, 0.000000 },
 641     { 0.734690, 0.265310, 0.000000 },
 642     { 0.734690, 0.265310, 0.000000 },
 643     { 0.734690, 0.265310, 0.000000 },
 644     { 0.734690, 0.265310, 0.000000 },
 645     { 0.734690, 0.265310, 0.000000 },
 646     { 0.734690, 0.265310, 0.000000 },
 647     { 0.734690, 0.265310, 0.000000 },
 648     { 0.734690, 0.265310, 0.000000 },
 649 };
 650
 651
 652 /* Standard white point chromaticities. */
 653
 654 #define C     0.310063, 0.316158
 655 #define E     1.0/3.0, 1.0/3.0
 656 #define D50   0.34570, 0.3585
 657 #define D65   0.312713, 0.329016
 658
 659 /* Gamma of nonlinear correction.
 660    See Charles Poynton's ColorFAQ Item 45 and GammaFAQ Item 6 at
 661    http://www.inforamp.net/~poynton/ColorFAQ.html
 662    http://www.inforamp.net/~poynton/GammaFAQ.html
 663 */
 664
 665 #define GAMMA_REC709    0.      /* Rec. 709 */
 666
 667 static const struct ColorSystem color_systems[] = {
 668     [NTSCsystem] = {
 669         0.67,  0.33,  0.21,  0.71,  0.14,  0.08,
 670         C, GAMMA_REC709
 671     },
 672     [EBUsystem] = {
 673         0.64,  0.33,  0.29,  0.60,  0.15,  0.06,
 674         D65, GAMMA_REC709
 675     },
 676     [SMPTEsystem] = {
 677         0.630, 0.340, 0.310, 0.595, 0.155, 0.070,
 678         D65, GAMMA_REC709
 679     },
 680     [SMPTE240Msystem] = {
 681         0.670, 0.330, 0.210, 0.710, 0.150, 0.060,
 682         D65, GAMMA_REC709
 683     },
 684     [APPLEsystem] = {
 685         0.625, 0.340, 0.280, 0.595, 0.115, 0.070,
 686         D65, GAMMA_REC709
 687     },
 688     [wRGBsystem] = {
 689         0.7347, 0.2653, 0.1152, 0.8264, 0.1566, 0.0177,
 690         D50, GAMMA_REC709
 691     },
 692     [CIE1931system] = {
 693         0.7347, 0.2653, 0.2738, 0.7174, 0.1666, 0.0089,
 694         E, GAMMA_REC709
 695     },
 696     [Rec709system] = {
 697         0.64,  0.33,  0.30,  0.60,  0.15,  0.06,
 698         D65, GAMMA_REC709
 699     },
 700     [Rec2020system] = {
 701         0.708,  0.292,  0.170,  0.797,  0.131,  0.046,
 702         D65, GAMMA_REC709
 703     },
 704     [DCIP3] = {
 705         0.680,  0.320,  0.265,  0.690,  0.150,  0.060,
 706         0.314,  0.351, GAMMA_REC709
 707     },
 708 };
 709
 710 /*
 711 static struct ColorSystem CustomSystem = {
 712     "Custom",
 713     0.64,  0.33,  0.30,  0.60,  0.15,  0.06,
 714     D65, GAMMA_REC709
 715 };
 716 */
 717
 718 static void
 719 uv_to_xy(float  const u,
 720          float  const v,
 721          float *const xc,
 722          float *const yc)
 723 {
 724 /*
 725     Given 1970 coordinates u, v, determine 1931 chromaticities x, y
 726 */
 727     *xc = 3.f*u / (2.f*u - 8.f*v + 4.f);
 728     *yc = 2.f*v / (2.f*u - 8.f*v + 4.f);
 729 }
 730
 731 static void
 732 upvp_to_xy(float   const up,
 733            float   const vp,
 734            float * const xc,
 735            float * const yc)
 736 {
 737 /*
 738     Given 1976 coordinates u', v', determine 1931 chromaticities x, y
 739 */
 740     *xc = 9*up / (6*up - 16*vp + 12);
 741     *yc = 4*vp / (6*up - 16*vp + 12);
 742 }
 743
 744 static void
 745 xy_to_upvp(float xc,
 746            float yc,
 747            float * const up,
 748            float * const vp)
 749 {
 750 /*
 751     Given 1931 chromaticities x, y, determine 1976 coordinates u', v'
 752 */
 753     const float scale = 1.f / (-2.f*xc + 12.f*yc + 3.f);
 754     *up = 4.f*xc * scale;
 755     *vp = 9.f*yc * scale;
 756 }
 757
 758 static void
 759 xy_to_uv(float xc,
 760          float yc,
 761          float * const u,
 762          float * const v)
 763 {
 764 /*
 765     Given 1931 chromaticities x, y, determine 1960 coordinates u, v
 766 */
 767     const float scale = 1.f / (-2.f*xc + 12.f*yc + 3.f);
 768     *u = 4.f*xc * scale;
 769     *v = 6.f*yc * scale;
 770 }
 771
 772 static void
 773 xyz_to_rgb(const float m[3][3],
 774            float xc, float yc, float zc,
 775            float * const r, float * const g, float * const b)
 776 {
 777     *r = m[0][0]*xc + m[0][1]*yc + m[0][2]*zc;
 778     *g = m[1][0]*xc + m[1][1]*yc + m[1][2]*zc;
 779     *b = m[2][0]*xc + m[2][1]*yc + m[2][2]*zc;
 780 }
 781
 782 static void invert_matrix3x3(float in[3][3], float out[3][3])
 783 {
 784     float m00 = in[0][0], m01 = in[0][1], m02 = in[0][2],
 785            m10 = in[1][0], m11 = in[1][1], m12 = in[1][2],
 786            m20 = in[2][0], m21 = in[2][1], m22 = in[2][2];
 787     int i, j;
 788     float det;
 789
 790     out[0][0] =  (m11 * m22 - m21 * m12);
 791     out[0][1] = -(m01 * m22 - m21 * m02);
 792     out[0][2] =  (m01 * m12 - m11 * m02);
 793     out[1][0] = -(m10 * m22 - m20 * m12);
 794     out[1][1] =  (m00 * m22 - m20 * m02);
 795     out[1][2] = -(m00 * m12 - m10 * m02);
 796     out[2][0] =  (m10 * m21 - m20 * m11);
 797     out[2][1] = -(m00 * m21 - m20 * m01);
 798     out[2][2] =  (m00 * m11 - m10 * m01);
 799
 800     det = m00 * out[0][0] + m10 * out[0][1] + m20 * out[0][2];
 801     det = 1.0 / det;
 802
 803     for (i = 0; i < 3; i++) {
 804         for (j = 0; j < 3; j++)
 805             out[i][j] *= det;
 806     }
 807 }
 808
 809 static void get_rgb2xyz_matrix(struct ColorSystem system, float m[3][3])
 810 {
 811     float S[3], X[4], Z[4];
 812     int i;
 813
 814     X[0] = system.xRed   / system.yRed;
 815     X[1] = system.xGreen / system.yGreen;
 816     X[2] = system.xBlue  / system.yBlue;
 817     X[3] = system.xWhite / system.yWhite;
 818
 819     Z[0] = (1 - system.xRed   - system.yRed)   / system.yRed;
 820     Z[1] = (1 - system.xGreen - system.yGreen) / system.yGreen;
 821     Z[2] = (1 - system.xBlue  - system.yBlue)  / system.yBlue;
 822     Z[3] = (1 - system.xWhite - system.yWhite) / system.yWhite;
 823
 824     for (i = 0; i < 3; i++) {
 825         m[0][i] = X[i];
 826         m[1][i] = 1;
 827         m[2][i] = Z[i];
 828     }
 829
 830     invert_matrix3x3(m, m);
 831
 832     for (i = 0; i < 3; i++)
 833         S[i] = m[i][0] * X[3] + m[i][1] * 1 + m[i][2] * Z[3];
 834
 835     for (i = 0; i < 3; i++) {
 836         m[0][i] = S[i] * X[i];
 837         m[1][i] = S[i] * 1;
 838         m[2][i] = S[i] * Z[i];
 839     }
 840 }
 841
 842 static void
 843 rgb_to_xy(float rc,
 844           float gc,
 845           float bc,
 846           float * const x,
 847           float * const y,
 848           float * const z,
 849           const float m[3][3])
 850 {
 851     float scale;
 852
 853     *x = m[0][0] * rc + m[0][1] * gc + m[0][2] * bc;
 854     *y = m[1][0] * rc + m[1][1] * gc + m[1][2] * bc;
 855     *z = m[2][0] * rc + m[2][1] * gc + m[2][2] * bc;
 856
 857     scale = *x + *y + *z;
 858     scale = 1.f / scale;
 859     *x = *x * scale;
 860     *y = *y * scale;
 861 }
 862
 863 static int
 864 constrain_rgb(float * const r,
 865               float * const g,
 866               float * const b)
 867 {
 868 /*----------------------------------------------------------------------------
 869     If  the  requested RGB shade contains a negative weight for one of
 870     the primaries, it lies outside the color  gamut  accessible  from
 871     the  given  triple  of  primaries.  Desaturate it by adding white,
 872     equal quantities of R, G, and B, enough to make RGB all positive.
 873 -----------------------------------------------------------------------------*/
 874     float w;
 875
 876     /* Amount of white needed is w = - min(0, *r, *g, *b) */
 877     w = (0 < *r) ? 0 : *r;
 878     w = (w < *g) ? w : *g;
 879     w = (w < *b) ? w : *b;
 880     w = - w;
 881
 882     /* Add just enough white to make r, g, b all positive. */
 883     if (w > 0) {
 884         *r += w;  *g += w; *b += w;
 885
 886         return 1;                     /* Color modified to fit RGB gamut */
 887     }
 888
 889     return 0;                         /* Color within RGB gamut */
 890 }
 891
 892 static void
 893 gamma_correct(const struct ColorSystem * const cs,
 894               float *                   const c)
 895 {
 896 /*----------------------------------------------------------------------------
 897     Transform linear RGB values to nonlinear RGB values.
 898
 899     Rec. 709 is ITU-R Recommendation BT. 709 (1990)
 900     ``Basic Parameter Values for the HDTV Standard for the Studio and for
 901     International Programme Exchange'', formerly CCIR Rec. 709.
 902
 903     For details see
 904        http://www.inforamp.net/~poynton/ColorFAQ.html
 905        http://www.inforamp.net/~poynton/GammaFAQ.html
 906 -----------------------------------------------------------------------------*/
 907     float gamma;
 908     float cc;
 909
 910     gamma = cs->gamma;
 911
 912     if (gamma == 0.) {
 913         /* Rec. 709 gamma correction. */
 914         cc = 0.018;
 915         if (*c < cc) {
 916             *c *= (1.099 * pow(cc, 0.45) - 0.099) / cc;
 917         } else {
 918             *c = 1.099 * pow(*c, 0.45) - 0.099;
 919         }
 920     } else {
 921     /* Nonlinear color = (Linear color)^(1/gamma) */
 922         *c = pow(*c, 1./gamma);
 923     }
 924 }
 925
 926
 927
 928 static void
 929 gamma_correct_rgb(const struct ColorSystem * const cs,
 930                   float * const r,
 931                   float * const g,
 932                   float * const b)
 933 {
 934     gamma_correct(cs, r);
 935     gamma_correct(cs, g);
 936     gamma_correct(cs, b);
 937 }
 938
 939 /* Sz(X) is the displacement in pixels of a displacement of X normalized
 940    distance units.  (A normalized distance unit is 1/512 of the smaller
 941    dimension of the canvas)
 942 */
 943 #define Sz(x) (((x) * (int)FFMIN(w, h)) / 512)
 944
 945 static void
 946 monochrome_color_location(float waveLength, int w, int h,
 947                           int cie, int *xP, int *yP)
 948 {
 949     const int ix = waveLength - 360;
 950     const float pX = spectral_chromaticity[ix][0];
 951     const float pY = spectral_chromaticity[ix][1];
 952     const float pZ = spectral_chromaticity[ix][2];
 953     const float px = pX / (pX + pY + pZ);
 954     const float py = pY / (pX + pY + pZ);
 955
 956     if (cie == LUV) {
 957         float up, vp;
 958
 959         xy_to_upvp(px, py, &up, &vp);
 960         *xP = up * (w - 1);
 961         *yP = (h - 1) - vp * (h - 1);
 962     } else if (cie == UCS) {
 963         float u, v;
 964
 965         xy_to_uv(px, py, &u, &v);
 966         *xP = u * (w - 1);
 967         *yP = (h - 1) - v * (h - 1);
 968     } else if (cie == XYY) {
 969         *xP = px * (w - 1);
 970         *yP = (h - 1) - py * (h - 1);
 971     } else {
 972         av_assert0(0);
 973     }
 974 }
 975
 976 static void
 977 find_tongue(uint16_t* const pixels,
 978             int       const w,
 979             int       const linesize,
 980             int       const row,
 981             int *     const presentP,
 982             int *     const leftEdgeP,
 983             int *     const rightEdgeP)
 984 {
 985     int i;
 986
 987     for (i = 0; i < w && pixels[row * linesize + i * 4 + 0] == 0; i++)
 988         ;
 989
 990     if (i >= w) {
 991         *presentP = 0;
 992     } else {
 993         int j;
 994         int const leftEdge = i;
 995
 996         *presentP = 1;
 997
 998         for (j = w - 1; j >= leftEdge && pixels[row * linesize + j * 4 + 0] == 0; j--)
 999             ;
1000
1001         *rightEdgeP = j;
1002         *leftEdgeP = leftEdge;
1003     }
1004 }
1005
1006 static void draw_line(uint16_t *const pixels, int linesize,
1007                       int x0, int y0, int x1, int y1,
1008                       int w, int h,
1009                       const uint16_t *const rgbcolor)
1010 {
1011     int sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1, x2;
1012     int dx = FFABS(x1-x0), dy = FFABS(y1-y0), err = dx * dx + dy * dy;
1013     int e2 = err == 0 ? 1 : 0xffffff / (dx + dy);
1014
1015     dx *= e2;
1016     dy *= e2;
1017     err = dx - dy;
1018
1019     for (;;) {
1020         pixels[y0 * linesize + x0 * 4 + 0] = rgbcolor[0]-(FFABS(err - dx + dy) >> 8);
1021         pixels[y0 * linesize + x0 * 4 + 1] = rgbcolor[1]-(FFABS(err - dx + dy) >> 8);
1022         pixels[y0 * linesize + x0 * 4 + 2] = rgbcolor[2]-(FFABS(err - dx + dy) >> 8);
1023         pixels[y0 * linesize + x0 * 4 + 3] = rgbcolor[3]-(FFABS(err - dx + dy) >> 8);
1024
1025         e2 = err;
1026         x2 = x0;
1027         if (2 * e2 >= -dx) {
1028             if (x0 == x1)
1029                 break;
1030             if (e2 + dy < 0xff0000) {
1031                 pixels[(y0 + sy) * linesize + x0 * 4 + 0] = rgbcolor[0]-(FFABS(e2 + dy) >> 8);
1032                 pixels[(y0 + sy) * linesize + x0 * 4 + 1] = rgbcolor[1]-(FFABS(e2 + dy) >> 8);
1033                 pixels[(y0 + sy) * linesize + x0 * 4 + 2] = rgbcolor[2]-(FFABS(e2 + dy) >> 8);
1034                 pixels[(y0 + sy) * linesize + x0 * 4 + 3] = rgbcolor[3]-(FFABS(e2 + dy) >> 8);
1035             }
1036             err -= dy;
1037             x0 += sx;
1038         }
1039
1040         if (2 * e2 <= dy) {
1041             if (y0 == y1)
1042                 break;
1043             if (dx - e2 < 0xff0000) {
1044                 pixels[y0 * linesize + (x2 + sx) * 4 + 0] = rgbcolor[0]-(FFABS(dx - e2) >> 8);
1045                 pixels[y0 * linesize + (x2 + sx) * 4 + 1] = rgbcolor[1]-(FFABS(dx - e2) >> 8);
1046                 pixels[y0 * linesize + (x2 + sx) * 4 + 2] = rgbcolor[2]-(FFABS(dx - e2) >> 8);
1047                 pixels[y0 * linesize + (x2 + sx) * 4 + 3] = rgbcolor[3]-(FFABS(dx - e2) >> 8);
1048             }
1049             err += dx;
1050             y0 += sy;
1051         }
1052     }
1053 }
1054
1055 static void draw_rline(uint16_t *const pixels, int linesize,
1056                        int x0, int y0, int x1, int y1,
1057                        int w, int h)
1058 {
1059     int dx  = FFABS(x1 - x0), sx = x0 < x1 ? 1 : -1;
1060     int dy  = FFABS(y1 - y0), sy = y0 < y1 ? 1 : -1;
1061     int err = (dx > dy ? dx : -dy) / 2, e2;
1062
1063     for (;;) {
1064         pixels[y0 * linesize + x0 * 4 + 0] = 65535 - pixels[y0 * linesize + x0 * 4 + 0];
1065         pixels[y0 * linesize + x0 * 4 + 1] = 65535 - pixels[y0 * linesize + x0 * 4 + 1];
1066         pixels[y0 * linesize + x0 * 4 + 2] = 65535 - pixels[y0 * linesize + x0 * 4 + 2];
1067         pixels[y0 * linesize + x0 * 4 + 3] = 65535;
1068
1069         if (x0 == x1 && y0 == y1)
1070             break;
1071
1072         e2 = err;
1073
1074         if (e2 >-dx) {
1075             err -= dy;
1076             x0 += sx;
1077         }
1078
1079         if (e2 < dy) {
1080             err += dx;
1081             y0 += sy;
1082         }
1083     }
1084 }
1085
1086 static void
1087 tongue_outline(uint16_t* const pixels,
1088                int       const linesize,
1089                int       const w,
1090                int       const h,
1091                uint16_t  const maxval,
1092                int       const cie)
1093 {
1094     const uint16_t rgbcolor[4] = { maxval, maxval, maxval, maxval };
1095     int wavelength;
1096     int lx, ly;
1097     int fx, fy;
1098
1099     for (wavelength = 360; wavelength <= 830; wavelength++) {
1100         int icx, icy;
1101
1102         monochrome_color_location(wavelength, w, h, cie,
1103                                   &icx, &icy);
1104
1105         if (wavelength > 360)
1106             draw_line(pixels, linesize, lx, ly, icx, icy, w, h, rgbcolor);
1107         else {
1108             fx = icx;
1109             fy = icy;
1110         }
1111         lx = icx;
1112         ly = icy;
1113     }
1114     draw_line(pixels, linesize, lx, ly, fx, fy, w, h, rgbcolor);
1115 }
1116
1117 static void
1118 fill_in_tongue(uint16_t*                  const pixels,
1119                int                        const linesize,
1120                int                        const w,
1121                int                        const h,
1122                uint16_t                   const maxval,
1123                const struct ColorSystem * const cs,
1124                float                      const m[3][3],
1125                int                        const cie,
1126                int                        const correct_gamma,
1127                float                      const contrast)
1128 {
1129     int y;
1130
1131     /* Scan the image line by line and  fill  the  tongue  outline
1132        with the RGB values determined by the color system for the x-y
1133        co-ordinates within the tongue.
1134     */
1135
1136     for (y = 0; y < h; ++y) {
1137         int  present;  /* There is some tongue on this line */
1138         int leftEdge; /* x position of leftmost pixel in tongue on this line */
1139         int rightEdge; /* same, but rightmost */
1140
1141         find_tongue(pixels, w, linesize, y, &present, &leftEdge, &rightEdge);
1142
1143         if (present) {
1144             int x;
1145
1146             for (x = leftEdge; x <= rightEdge; ++x) {
1147                 float cx, cy, cz, jr, jg, jb, jmax;
1148                 int r, g, b, mx = maxval;
1149
1150                 if (cie == LUV) {
1151                     float up, vp;
1152                     up = ((float) x) / (w - 1);
1153                     vp = 1.0 - ((float) y) / (h - 1);
1154                     upvp_to_xy(up, vp, &cx, &cy);
1155                     cz = 1.0 - (cx + cy);
1156                 } else if (cie == UCS) {
1157                     float u, v;
1158                     u = ((float) x) / (w - 1);
1159                     v = 1.0 - ((float) y) / (h - 1);
1160                     uv_to_xy(u, v, &cx, &cy);
1161                     cz = 1.0 - (cx + cy);
1162                 } else if (cie == XYY) {
1163                     cx = ((float) x) / (w - 1);
1164                     cy = 1.0 - ((float) y) / (h - 1);
1165                     cz = 1.0 - (cx + cy);
1166                 } else {
1167                     av_assert0(0);
1168                 }
1169
1170                 xyz_to_rgb(m, cx, cy, cz, &jr, &jg, &jb);
1171
1172                 /* Check whether the requested color  is  within  the
1173                    gamut  achievable with the given color system.  If
1174                    not, draw it in a reduced  intensity,  interpolated
1175                    by desaturation to the closest within-gamut color. */
1176
1177                 if (constrain_rgb(&jr, &jg, &jb))
1178                     mx *= contrast;
1179
1180                 jmax = FFMAX3(jr, jg, jb);
1181                 if (jmax > 0) {
1182                     jr = jr / jmax;
1183                     jg = jg / jmax;
1184                     jb = jb / jmax;
1185                 }
1186                 /* gamma correct from linear rgb to nonlinear rgb. */
1187                 if (correct_gamma)
1188                     gamma_correct_rgb(cs, &jr, &jg, &jb);
1189                 r = mx * jr;
1190                 g = mx * jg;
1191                 b = mx * jb;
1192                 pixels[y * linesize + x * 4 + 0] = r;
1193                 pixels[y * linesize + x * 4 + 1] = g;
1194                 pixels[y * linesize + x * 4 + 2] = b;
1195                 pixels[y * linesize + x * 4 + 3] = 65535;
1196             }
1197         }
1198     }
1199 }
1200
1201 static void
1202 plot_white_point(uint16_t*      pixels,
1203                  int      const linesize,
1204                  int      const w,
1205                  int      const h,
1206                  int      const maxval,
1207                  int      const color_system,
1208                  int      const cie)
1209 {
1210     const struct ColorSystem *cs = &color_systems[color_system];
1211     int wx, wy;
1212
1213     if (cie == LUV) {
1214         float wup, wvp;
1215         xy_to_upvp(cs->xWhite, cs->yWhite, &wup, &wvp);
1216         wx = (w - 1) * wup;
1217         wy = (h - 1) - ((int) ((h - 1) * wvp));
1218     } else if (cie == UCS) {
1219         float wu, wv;
1220         xy_to_uv(cs->xWhite, cs->yWhite, &wu, &wv);
1221         wx = (w - 1) * wu;
1222         wy = (h - 1) - ((int) ((h - 1) * wv));
1223     } else if (cie == XYY) {
1224         wx = (w - 1) * cs->xWhite;
1225         wy = (h - 1) - ((int) ((h - 1) * cs->yWhite));
1226     } else {
1227         av_assert0(0);
1228     }
1229
1230     draw_rline(pixels, linesize,
1231                wx + Sz(3), wy, wx + Sz(10), wy,
1232                w, h);
1233     draw_rline(pixels, linesize,
1234                wx - Sz(3), wy, wx - Sz(10), wy,
1235                w, h);
1236     draw_rline(pixels, linesize,
1237                wx, wy + Sz(3), wx, wy + Sz(10),
1238                w, h);
1239     draw_rline(pixels, linesize,
1240                wx, wy - Sz(3), wx, wy - Sz(10),
1241                w, h);
1242 }
1243
1244 static int draw_background(AVFilterContext *ctx)
1245 {
1246     CiescopeContext *s = ctx->priv;
1247     const struct ColorSystem *cs = &color_systems[s->color_system];
1248     AVFilterLink *outlink = ctx->outputs[0];
1249     int w = s->size;
1250     int h = s->size;
1251     uint16_t *pixels;
1252
1253     if ((s->f = ff_get_video_buffer(outlink, outlink->w, outlink->h)) == NULL)
1254         return AVERROR(ENOMEM);
1255     pixels = (uint16_t *)s->f->data[0];
1256
1257     tongue_outline(pixels, s->f->linesize[0] / 2, w, h, 65535, s->cie);
1258
1259     if (s->fill)
1260         fill_in_tongue(pixels, s->f->linesize[0] / 2, w, h, 65535, cs, (const float (*)[3])s->i, s->cie,
1261                        s->correct_gamma, s->contrast);
1262
1263     return 0;
1264 }
1265
1266 static void filter_rgb48(AVFilterContext *ctx, const uint8_t *ptr,
1267                          ptrdiff_t linesize,
1268                          float *cx, float *cy, int x, int y)
1269 {
1270     CiescopeContext *s = ctx->priv;
1271     const float scale = 1.f / 65535.f;
1272     const uint16_t *src = (const uint16_t*)(ptr + linesize * y + x * 6);
1273     float r = (src[0] + 0.01f) * scale;
1274     float g = (src[1] + 0.01f) * scale;
1275     float b = (src[2] + 0.01f) * scale;
1276     float cz;
1277
1278     rgb_to_xy(r, g, b, cx, cy, &cz, (const float (*)[3])s->m);
1279 }
1280
1281 static void filter_rgba64(AVFilterContext *ctx, const uint8_t *ptr,
1282                           ptrdiff_t linesize,
1283                           float *cx, float *cy, int x, int y)
1284 {
1285     CiescopeContext *s = ctx->priv;
1286     const float scale = 1.f / 65535.f;
1287     const uint16_t *src = (const uint16_t*)(ptr + linesize * y + x * 8);
1288     float r = (src[0] + 0.01f) * scale;
1289     float g = (src[1] + 0.01f) * scale;
1290     float b = (src[2] + 0.01f) * scale;
1291     float cz;
1292
1293     rgb_to_xy(r, g, b, cx, cy, &cz, (const float (*)[3])s->m);
1294 }
1295
1296 static void filter_rgb24(AVFilterContext *ctx, const uint8_t *ptr,
1297                          ptrdiff_t linesize,
1298                          float *cx, float *cy, int x, int y)
1299 {
1300     CiescopeContext *s = ctx->priv;
1301     const float scale = 1.f / 255.f;
1302     const uint8_t *src = ptr + linesize * y + x * 3;
1303     float r = (src[0] + 0.01f) * scale;
1304     float g = (src[1] + 0.01f) * scale;
1305     float b = (src[2] + 0.01f) * scale;
1306     float cz;
1307
1308     rgb_to_xy(r, g, b, cx, cy, &cz, (const float (*)[3])s->m);
1309 }
1310
1311 static void filter_rgba(AVFilterContext *ctx, const uint8_t *ptr,
1312                         ptrdiff_t linesize,
1313                         float *cx, float *cy, int x, int y)
1314 {
1315     CiescopeContext *s = ctx->priv;
1316     const float scale = 1.f / 255.f;
1317     const uint8_t *src = ptr + linesize * y + x * 4;
1318     float r = (src[0] + 0.01f) * scale;
1319     float g = (src[1] + 0.01f) * scale;
1320     float b = (src[2] + 0.01f) * scale;
1321     float cz;
1322
1323     rgb_to_xy(r, g, b, cx, cy, &cz, (const float (*)[3])s->m);
1324 }
1325
1326 static void filter_xyz(AVFilterContext *ctx, const uint8_t *ptr,
1327                        ptrdiff_t linesize,
1328                        float *cx, float *cy, int x, int y)
1329 {
1330     CiescopeContext *s = ctx->priv;
1331     const uint16_t* src = (uint16_t *)(ptr + linesize * y + x * 6);
1332     float lx = s->log2lin[src[0]];
1333     float ly = s->log2lin[src[1]];
1334     float lz = s->log2lin[src[2]];
1335     float sum = lx + ly + lz;
1336
1337     if (sum == 0)
1338         sum = 1;
1339     *cx = lx / sum;
1340     *cy = ly / sum;
1341 }
1342
1343 static void plot_gamuts(uint16_t *pixels, int linesize, int w, int h,
1344                         int cie, int gamuts)
1345 {
1346     int i;
1347
1348     for (i = 0; i < NB_CS; i++) {
1349         const struct ColorSystem *cs = &color_systems[i];
1350         int rx, ry, gx, gy, bx, by;
1351
1352         if (!((1 << i) & gamuts))
1353             continue;
1354         if (cie == LUV) {
1355             float wup, wvp;
1356             xy_to_upvp(cs->xRed, cs->yRed, &wup, &wvp);
1357             rx = (w - 1) * wup;
1358             ry = (h - 1) - ((int) ((h - 1) * wvp));
1359             xy_to_upvp(cs->xGreen, cs->yGreen, &wup, &wvp);
1360             gx = (w - 1) * wup;
1361             gy = (h - 1) - ((int) ((h - 1) * wvp));
1362             xy_to_upvp(cs->xBlue, cs->yBlue, &wup, &wvp);
1363             bx = (w - 1) * wup;
1364             by = (h - 1) - ((int) ((h - 1) * wvp));
1365         } else if (cie == UCS) {
1366             float wu, wv;
1367             xy_to_uv(cs->xRed, cs->yRed, &wu, &wv);
1368             rx = (w - 1) * wu;
1369             ry = (h - 1) - ((int) ((h - 1) * wv));
1370             xy_to_uv(cs->xGreen, cs->yGreen, &wu, &wv);
1371             gx = (w - 1) * wu;
1372             gy = (h - 1) - ((int) ((h - 1) * wv));
1373             xy_to_uv(cs->xBlue, cs->yBlue, &wu, &wv);
1374             bx = (w - 1) * wu;
1375             by = (h - 1) - ((int) ((h - 1) * wv));
1376         } else if (cie == XYY) {
1377             rx = (w - 1) * cs->xRed;
1378             ry = (h - 1) - ((int) ((h - 1) * cs->yRed));
1379             gx = (w - 1) * cs->xGreen;
1380             gy = (h - 1) - ((int) ((h - 1) * cs->yGreen));
1381             bx = (w - 1) * cs->xBlue;
1382             by = (h - 1) - ((int) ((h - 1) * cs->yBlue));
1383         } else {
1384             av_assert0(0);
1385         }
1386
1387         draw_rline(pixels, linesize, rx, ry, gx, gy, w, h);
1388         draw_rline(pixels, linesize, gx, gy, bx, by, w, h);
1389         draw_rline(pixels, linesize, bx, by, rx, ry, w, h);
1390     }
1391 }
1392
1393 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
1394 {
1395     AVFilterContext *ctx  = inlink->dst;
1396     CiescopeContext *s = ctx->priv;
1397     AVFilterLink *outlink = ctx->outputs[0];
1398     int i = s->intensity * 65535;
1399     int w = outlink->w;
1400     int h = outlink->h;
1401     AVFrame *out;
1402     int ret, x, y;
1403
1404     out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
1405     if (!out) {
1406         av_frame_free(&in);
1407         return AVERROR(ENOMEM);
1408     }
1409     out->pts = in->pts;
1410     out->duration = in->duration;
1411
1412     if (!s->background) {
1413         ret = draw_background(ctx);
1414         if (ret < 0) {
1415             av_frame_free(&out);
1416             return ret;
1417         }
1418         s->background = 1;
1419     }
1420     for (y = 0; y < outlink->h; y++) {
1421         memset(out->data[0] + y * out->linesize[0], 0, outlink->w * 8);
1422     }
1423
1424     for (y = 0; y < in->height; y++) {
1425         const uint8_t *src = in->data[0];
1426         const ptrdiff_t src_linesize = in->linesize[0];
1427         uint16_t *dst = (uint16_t *)out->data[0];
1428         const ptrdiff_t linesize = out->linesize[0] / 2;
1429         const int w_1 = w - 1;
1430         const int h_1 = h - 1;
1431
1432         for (x = 0; x < in->width; x++) {
1433             float cx, cy;
1434             int wx, wy, pos;
1435             int r, g, b;
1436
1437             s->filter(ctx, src, src_linesize, &cx, &cy, x, y);
1438
1439             if (s->cie == LUV) {
1440                 float up, vp;
1441                 xy_to_upvp(cx, cy, &up, &vp);
1442                 cx = up;
1443                 cy = vp;
1444             } else if (s->cie == UCS) {
1445                 float u, v;
1446                 xy_to_uv(cx, cy, &u, &v);
1447                 cx = u;
1448                 cy = v;
1449             }
1450
1451             wx = w_1 * cx;
1452             wy = h_1 - h_1 * cy;
1453
1454             if (wx < 0 || wx >= w ||
1455                 wy < 0 || wy >= h)
1456                 continue;
1457
1458             pos = wy * linesize + wx * 4;
1459             r = dst[pos + 0] + i;
1460             g = dst[pos + 1] + i;
1461             b = dst[pos + 2] + i;
1462
1463             dst[pos + 0] = FFMIN(r, 65535);
1464             dst[pos + 1] = FFMIN(g, 65535);
1465             dst[pos + 2] = FFMIN(b, 65535);
1466             dst[pos + 3] = 65535;
1467         }
1468     }
1469
1470     for (y = 0; y < outlink->h; y++) {
1471         uint16_t *dst = (uint16_t *)(out->data[0] + y * out->linesize[0]);
1472         const uint16_t *src = (const uint16_t *)(s->f->data[0] + y * s->f->linesize[0]);
1473         for (x = 0; x < outlink->w; x++) {
1474             const int xx = x * 4;
1475             if (dst[xx + 3] == 0) {
1476                 dst[xx + 0] = src[xx + 0];
1477                 dst[xx + 1] = src[xx + 1];
1478                 dst[xx + 2] = src[xx + 2];
1479                 dst[xx + 3] = src[xx + 3];
1480             }
1481         }
1482     }
1483
1484     if (s->show_white)
1485         plot_white_point((uint16_t *)out->data[0], out->linesize[0] / 2,
1486                          outlink->w, outlink->h, 65535,
1487                          s->color_system, s->cie);
1488
1489     plot_gamuts((uint16_t *)out->data[0], out->linesize[0] / 2,
1490                 outlink->w, outlink->h,
1491                 s->cie, s->gamuts);
1492
1493     av_frame_free(&in);
1494     return ff_filter_frame(outlink, out);
1495 }
1496
1497 static void av_cold uninit(AVFilterContext *ctx)
1498 {
1499     CiescopeContext *s = ctx->priv;
1500
1501     av_frame_free(&s->f);
1502 }
1503
1504 static int config_input(AVFilterLink *inlink)
1505 {
1506     CiescopeContext *s = inlink->dst->priv;
1507     int i;
1508
1509     get_rgb2xyz_matrix(color_systems[s->color_system], s->m);
1510     invert_matrix3x3(s->m, s->i);
1511
1512     switch (inlink->format) {
1513     case AV_PIX_FMT_RGB24:
1514         s->filter = filter_rgb24;
1515         break;
1516     case AV_PIX_FMT_RGBA:
1517         s->filter = filter_rgba;
1518         break;
1519     case AV_PIX_FMT_RGB48:
1520         s->filter = filter_rgb48;
1521         break;
1522     case AV_PIX_FMT_RGBA64:
1523         s->filter = filter_rgba64;
1524         break;
1525     case AV_PIX_FMT_XYZ12:
1526         s->filter = filter_xyz;
1527         for (i = 0; i < 65536; i++)
1528             s->log2lin[i] = pow(i / 65535., s->igamma) * 65535.;
1529         break;
1530     default:
1531         av_assert0(0);
1532     }
1533
1534     return 0;
1535 }
1536
1537 static const AVFilterPad inputs[] = {
1538     {
1539         .name         = "default",
1540         .type         = AVMEDIA_TYPE_VIDEO,
1541         .filter_frame = filter_frame,
1542         .config_props = config_input,
1543     },
1544 };
1545
1546 static const AVFilterPad outputs[] = {
1547     {
1548         .name         = "default",
1549         .type         = AVMEDIA_TYPE_VIDEO,
1550         .config_props = config_output,
1551     },
1552 };
1553
1554 const AVFilter ff_vf_ciescope = {
1555     .name          = "ciescope",
1556     .description   = NULL_IF_CONFIG_SMALL("Video CIE scope."),
1557     .priv_size     = sizeof(CiescopeContext),
1558     .priv_class    = &ciescope_class,
1559     .uninit        = uninit,
1560     FILTER_INPUTS(inputs),
1561     FILTER_OUTPUTS(outputs),
1562     FILTER_QUERY_FUNC(query_formats),
1563 };