falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
93664 Commits
32 Branches
283MB
Tree: a42e761b96
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a42e761b96'
${ noResults }
FFmpeg/libavfilter/vf_lut3d.c

1654 lines
66KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2013 Clément Bœsch

  3.  * Copyright (c) 2018 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. /**

  23.  * @file

  24.  * 3D Lookup table filter

  25.  */

  26. 

  27. #include "libavutil/opt.h"

  28. #include "libavutil/file.h"

  29. #include "libavutil/intreadwrite.h"

  30. #include "libavutil/avassert.h"

  31. #include "libavutil/pixdesc.h"

  32. #include "libavutil/avstring.h"

  33. #include "avfilter.h"

  34. #include "drawutils.h"

  35. #include "formats.h"

  36. #include "framesync.h"

  37. #include "internal.h"

  38. #include "video.h"

  39. 

  40. #define R 0

  41. #define G 1

  42. #define B 2

  43. #define A 3

  44. 

  45. enum interp_mode {

  46.     INTERPOLATE_NEAREST,

  47.     INTERPOLATE_TRILINEAR,

  48.     INTERPOLATE_TETRAHEDRAL,

  49.     NB_INTERP_MODE

  50. };

  51. 

  52. struct rgbvec {

  53.     float r, g, b;

  54. };

  55. 

  56. /* 3D LUT don't often go up to level 32, but it is common to have a Hald CLUT

  57.  * of 512x512 (64x64x64) */

  58. #define MAX_LEVEL 64

  59. 

  60. typedef struct LUT3DContext {

  61.     const AVClass *class;

  62.     int interpolation;          ///<interp_mode

  63.     char *file;

  64.     uint8_t rgba_map[4];

  65.     int step;

  66.     avfilter_action_func *interp;

  67.     struct rgbvec lut[MAX_LEVEL][MAX_LEVEL][MAX_LEVEL];

  68.     int lutsize;

  69. #if CONFIG_HALDCLUT_FILTER

  70.     uint8_t clut_rgba_map[4];

  71.     int clut_step;

  72.     int clut_bits;

  73.     int clut_planar;

  74.     int clut_width;

  75.     FFFrameSync fs;

  76. #endif

  77. } LUT3DContext;

  78. 

  79. typedef struct ThreadData {

  80.     AVFrame *in, *out;

  81. } ThreadData;

  82. 

  83. #define OFFSET(x) offsetof(LUT3DContext, x)

  84. #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

  85. #define COMMON_OPTIONS \

  86.     { "interp", "select interpolation mode", OFFSET(interpolation), AV_OPT_TYPE_INT, {.i64=INTERPOLATE_TETRAHEDRAL}, 0, NB_INTERP_MODE-1, FLAGS, "interp_mode" }, \

  87.         { "nearest",     "use values from the nearest defined points",            0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_NEAREST},     INT_MIN, INT_MAX, FLAGS, "interp_mode" }, \

  88.         { "trilinear",   "interpolate values using the 8 points defining a cube", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_TRILINEAR},   INT_MIN, INT_MAX, FLAGS, "interp_mode" }, \

  89.         { "tetrahedral", "interpolate values using a tetrahedron",                0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_TETRAHEDRAL}, INT_MIN, INT_MAX, FLAGS, "interp_mode" }, \

  90.     { NULL }

  91. 

  92. static inline float lerpf(float v0, float v1, float f)

  93. {

  94.     return v0 + (v1 - v0) * f;

  95. }

  96. 

  97. static inline struct rgbvec lerp(const struct rgbvec *v0, const struct rgbvec *v1, float f)

  98. {

  99.     struct rgbvec v = {

  100.         lerpf(v0->r, v1->r, f), lerpf(v0->g, v1->g, f), lerpf(v0->b, v1->b, f)

  101.     };

  102.     return v;

  103. }

  104. 

  105. #define NEAR(x) ((int)((x) + .5))

  106. #define PREV(x) ((int)(x))

  107. #define NEXT(x) (FFMIN((int)(x) + 1, lut3d->lutsize - 1))

  108. 

  109. /**

  110.  * Get the nearest defined point

  111.  */

  112. static inline struct rgbvec interp_nearest(const LUT3DContext *lut3d,

  113.                                            const struct rgbvec *s)

  114. {

  115.     return lut3d->lut[NEAR(s->r)][NEAR(s->g)][NEAR(s->b)];

  116. }

  117. 

  118. /**

  119.  * Interpolate using the 8 vertices of a cube

  120.  * @see https://en.wikipedia.org/wiki/Trilinear_interpolation

  121.  */

  122. static inline struct rgbvec interp_trilinear(const LUT3DContext *lut3d,

  123.                                              const struct rgbvec *s)

  124. {

  125.     const int prev[] = {PREV(s->r), PREV(s->g), PREV(s->b)};

  126.     const int next[] = {NEXT(s->r), NEXT(s->g), NEXT(s->b)};

  127.     const struct rgbvec d = {s->r - prev[0], s->g - prev[1], s->b - prev[2]};

  128.     const struct rgbvec c000 = lut3d->lut[prev[0]][prev[1]][prev[2]];

  129.     const struct rgbvec c001 = lut3d->lut[prev[0]][prev[1]][next[2]];

  130.     const struct rgbvec c010 = lut3d->lut[prev[0]][next[1]][prev[2]];

  131.     const struct rgbvec c011 = lut3d->lut[prev[0]][next[1]][next[2]];

  132.     const struct rgbvec c100 = lut3d->lut[next[0]][prev[1]][prev[2]];

  133.     const struct rgbvec c101 = lut3d->lut[next[0]][prev[1]][next[2]];

  134.     const struct rgbvec c110 = lut3d->lut[next[0]][next[1]][prev[2]];

  135.     const struct rgbvec c111 = lut3d->lut[next[0]][next[1]][next[2]];

  136.     const struct rgbvec c00  = lerp(&c000, &c100, d.r);

  137.     const struct rgbvec c10  = lerp(&c010, &c110, d.r);

  138.     const struct rgbvec c01  = lerp(&c001, &c101, d.r);

  139.     const struct rgbvec c11  = lerp(&c011, &c111, d.r);

  140.     const struct rgbvec c0   = lerp(&c00,  &c10,  d.g);

  141.     const struct rgbvec c1   = lerp(&c01,  &c11,  d.g);

  142.     const struct rgbvec c    = lerp(&c0,   &c1,   d.b);

  143.     return c;

  144. }

  145. 

  146. /**

  147.  * Tetrahedral interpolation. Based on code found in Truelight Software Library paper.

  148.  * @see http://www.filmlight.ltd.uk/pdf/whitepapers/FL-TL-TN-0057-SoftwareLib.pdf

  149.  */

  150. static inline struct rgbvec interp_tetrahedral(const LUT3DContext *lut3d,

  151.                                                const struct rgbvec *s)

  152. {

  153.     const int prev[] = {PREV(s->r), PREV(s->g), PREV(s->b)};

  154.     const int next[] = {NEXT(s->r), NEXT(s->g), NEXT(s->b)};

  155.     const struct rgbvec d = {s->r - prev[0], s->g - prev[1], s->b - prev[2]};

  156.     const struct rgbvec c000 = lut3d->lut[prev[0]][prev[1]][prev[2]];

  157.     const struct rgbvec c111 = lut3d->lut[next[0]][next[1]][next[2]];

  158.     struct rgbvec c;

  159.     if (d.r > d.g) {

  160.         if (d.g > d.b) {

  161.             const struct rgbvec c100 = lut3d->lut[next[0]][prev[1]][prev[2]];

  162.             const struct rgbvec c110 = lut3d->lut[next[0]][next[1]][prev[2]];

  163.             c.r = (1-d.r) * c000.r + (d.r-d.g) * c100.r + (d.g-d.b) * c110.r + (d.b) * c111.r;

  164.             c.g = (1-d.r) * c000.g + (d.r-d.g) * c100.g + (d.g-d.b) * c110.g + (d.b) * c111.g;

  165.             c.b = (1-d.r) * c000.b + (d.r-d.g) * c100.b + (d.g-d.b) * c110.b + (d.b) * c111.b;

  166.         } else if (d.r > d.b) {

  167.             const struct rgbvec c100 = lut3d->lut[next[0]][prev[1]][prev[2]];

  168.             const struct rgbvec c101 = lut3d->lut[next[0]][prev[1]][next[2]];

  169.             c.r = (1-d.r) * c000.r + (d.r-d.b) * c100.r + (d.b-d.g) * c101.r + (d.g) * c111.r;

  170.             c.g = (1-d.r) * c000.g + (d.r-d.b) * c100.g + (d.b-d.g) * c101.g + (d.g) * c111.g;

  171.             c.b = (1-d.r) * c000.b + (d.r-d.b) * c100.b + (d.b-d.g) * c101.b + (d.g) * c111.b;

  172.         } else {

  173.             const struct rgbvec c001 = lut3d->lut[prev[0]][prev[1]][next[2]];

  174.             const struct rgbvec c101 = lut3d->lut[next[0]][prev[1]][next[2]];

  175.             c.r = (1-d.b) * c000.r + (d.b-d.r) * c001.r + (d.r-d.g) * c101.r + (d.g) * c111.r;

  176.             c.g = (1-d.b) * c000.g + (d.b-d.r) * c001.g + (d.r-d.g) * c101.g + (d.g) * c111.g;

  177.             c.b = (1-d.b) * c000.b + (d.b-d.r) * c001.b + (d.r-d.g) * c101.b + (d.g) * c111.b;

  178.         }

  179.     } else {

  180.         if (d.b > d.g) {

  181.             const struct rgbvec c001 = lut3d->lut[prev[0]][prev[1]][next[2]];

  182.             const struct rgbvec c011 = lut3d->lut[prev[0]][next[1]][next[2]];

  183.             c.r = (1-d.b) * c000.r + (d.b-d.g) * c001.r + (d.g-d.r) * c011.r + (d.r) * c111.r;

  184.             c.g = (1-d.b) * c000.g + (d.b-d.g) * c001.g + (d.g-d.r) * c011.g + (d.r) * c111.g;

  185.             c.b = (1-d.b) * c000.b + (d.b-d.g) * c001.b + (d.g-d.r) * c011.b + (d.r) * c111.b;

  186.         } else if (d.b > d.r) {

  187.             const struct rgbvec c010 = lut3d->lut[prev[0]][next[1]][prev[2]];

  188.             const struct rgbvec c011 = lut3d->lut[prev[0]][next[1]][next[2]];

  189.             c.r = (1-d.g) * c000.r + (d.g-d.b) * c010.r + (d.b-d.r) * c011.r + (d.r) * c111.r;

  190.             c.g = (1-d.g) * c000.g + (d.g-d.b) * c010.g + (d.b-d.r) * c011.g + (d.r) * c111.g;

  191.             c.b = (1-d.g) * c000.b + (d.g-d.b) * c010.b + (d.b-d.r) * c011.b + (d.r) * c111.b;

  192.         } else {

  193.             const struct rgbvec c010 = lut3d->lut[prev[0]][next[1]][prev[2]];

  194.             const struct rgbvec c110 = lut3d->lut[next[0]][next[1]][prev[2]];

  195.             c.r = (1-d.g) * c000.r + (d.g-d.r) * c010.r + (d.r-d.b) * c110.r + (d.b) * c111.r;

  196.             c.g = (1-d.g) * c000.g + (d.g-d.r) * c010.g + (d.r-d.b) * c110.g + (d.b) * c111.g;

  197.             c.b = (1-d.g) * c000.b + (d.g-d.r) * c010.b + (d.r-d.b) * c110.b + (d.b) * c111.b;

  198.         }

  199.     }

  200.     return c;

  201. }

  202. 

  203. #define DEFINE_INTERP_FUNC_PLANAR(name, nbits, depth)                                                  \

  204. static int interp_##nbits##_##name##_p##depth(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \

  205. {                                                                                                      \

  206.     int x, y;                                                                                          \

  207.     const LUT3DContext *lut3d = ctx->priv;                                                             \

  208.     const ThreadData *td = arg;                                                                        \

  209.     const AVFrame *in  = td->in;                                                                       \

  210.     const AVFrame *out = td->out;                                                                      \

  211.     const int direct = out == in;                                                                      \

  212.     const int slice_start = (in->height *  jobnr   ) / nb_jobs;                                        \

  213.     const int slice_end   = (in->height * (jobnr+1)) / nb_jobs;                                        \

  214.     uint8_t *grow = out->data[0] + slice_start * out->linesize[0];                                     \

  215.     uint8_t *brow = out->data[1] + slice_start * out->linesize[1];                                     \

  216.     uint8_t *rrow = out->data[2] + slice_start * out->linesize[2];                                     \

  217.     uint8_t *arow = out->data[3] + slice_start * out->linesize[3];                                     \

  218.     const uint8_t *srcgrow = in->data[0] + slice_start * in->linesize[0];                              \

  219.     const uint8_t *srcbrow = in->data[1] + slice_start * in->linesize[1];                              \

  220.     const uint8_t *srcrrow = in->data[2] + slice_start * in->linesize[2];                              \

  221.     const uint8_t *srcarow = in->data[3] + slice_start * in->linesize[3];                              \

  222.     const float scale = (1. / ((1<<depth) - 1)) * (lut3d->lutsize - 1);                                \

  223.                                                                                                        \

  224.     for (y = slice_start; y < slice_end; y++) {                                                        \

  225.         uint##nbits##_t *dstg = (uint##nbits##_t *)grow;                                               \

  226.         uint##nbits##_t *dstb = (uint##nbits##_t *)brow;                                               \

  227.         uint##nbits##_t *dstr = (uint##nbits##_t *)rrow;                                               \

  228.         uint##nbits##_t *dsta = (uint##nbits##_t *)arow;                                               \

  229.         const uint##nbits##_t *srcg = (const uint##nbits##_t *)srcgrow;                                \

  230.         const uint##nbits##_t *srcb = (const uint##nbits##_t *)srcbrow;                                \

  231.         const uint##nbits##_t *srcr = (const uint##nbits##_t *)srcrrow;                                \

  232.         const uint##nbits##_t *srca = (const uint##nbits##_t *)srcarow;                                \

  233.         for (x = 0; x < in->width; x++) {                                                              \

  234.             const struct rgbvec scaled_rgb = {srcr[x] * scale,                                         \

  235.                                               srcg[x] * scale,                                         \

  236.                                               srcb[x] * scale};                                        \

  237.             struct rgbvec vec = interp_##name(lut3d, &scaled_rgb);                                     \

  238.             dstr[x] = av_clip_uintp2(vec.r * (float)((1<<depth) - 1), depth);                          \

  239.             dstg[x] = av_clip_uintp2(vec.g * (float)((1<<depth) - 1), depth);                          \

  240.             dstb[x] = av_clip_uintp2(vec.b * (float)((1<<depth) - 1), depth);                          \

  241.             if (!direct && in->linesize[3])                                                            \

  242.                 dsta[x] = srca[x];                                                                     \

  243.         }                                                                                              \

  244.         grow += out->linesize[0];                                                                      \

  245.         brow += out->linesize[1];                                                                      \

  246.         rrow += out->linesize[2];                                                                      \

  247.         arow += out->linesize[3];                                                                      \

  248.         srcgrow += in->linesize[0];                                                                    \

  249.         srcbrow += in->linesize[1];                                                                    \

  250.         srcrrow += in->linesize[2];                                                                    \

  251.         srcarow += in->linesize[3];                                                                    \

  252.     }                                                                                                  \

  253.     return 0;                                                                                          \

  254. }

  255. 

  256. DEFINE_INTERP_FUNC_PLANAR(nearest,     8, 8)

  257. DEFINE_INTERP_FUNC_PLANAR(trilinear,   8, 8)

  258. DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 8, 8)

  259. 

  260. DEFINE_INTERP_FUNC_PLANAR(nearest,     16, 9)

  261. DEFINE_INTERP_FUNC_PLANAR(trilinear,   16, 9)

  262. DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 9)

  263. 

  264. DEFINE_INTERP_FUNC_PLANAR(nearest,     16, 10)

  265. DEFINE_INTERP_FUNC_PLANAR(trilinear,   16, 10)

  266. DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 10)

  267. 

  268. DEFINE_INTERP_FUNC_PLANAR(nearest,     16, 12)

  269. DEFINE_INTERP_FUNC_PLANAR(trilinear,   16, 12)

  270. DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 12)

  271. 

  272. DEFINE_INTERP_FUNC_PLANAR(nearest,     16, 14)

  273. DEFINE_INTERP_FUNC_PLANAR(trilinear,   16, 14)

  274. DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 14)

  275. 

  276. DEFINE_INTERP_FUNC_PLANAR(nearest,     16, 16)

  277. DEFINE_INTERP_FUNC_PLANAR(trilinear,   16, 16)

  278. DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 16)

  279. 

  280. #define DEFINE_INTERP_FUNC(name, nbits)                                                             \

  281. static int interp_##nbits##_##name(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)         \

  282. {                                                                                                   \

  283.     int x, y;                                                                                       \

  284.     const LUT3DContext *lut3d = ctx->priv;                                                          \

  285.     const ThreadData *td = arg;                                                                     \

  286.     const AVFrame *in  = td->in;                                                                    \

  287.     const AVFrame *out = td->out;                                                                   \

  288.     const int direct = out == in;                                                                   \

  289.     const int step = lut3d->step;                                                                   \

  290.     const uint8_t r = lut3d->rgba_map[R];                                                           \

  291.     const uint8_t g = lut3d->rgba_map[G];                                                           \

  292.     const uint8_t b = lut3d->rgba_map[B];                                                           \

  293.     const uint8_t a = lut3d->rgba_map[A];                                                           \

  294.     const int slice_start = (in->height *  jobnr   ) / nb_jobs;                                     \

  295.     const int slice_end   = (in->height * (jobnr+1)) / nb_jobs;                                     \

  296.     uint8_t       *dstrow = out->data[0] + slice_start * out->linesize[0];                          \

  297.     const uint8_t *srcrow = in ->data[0] + slice_start * in ->linesize[0];                          \

  298.     const float scale = (1. / ((1<<nbits) - 1)) * (lut3d->lutsize - 1);                             \

  299.                                                                                                     \

  300.     for (y = slice_start; y < slice_end; y++) {                                                     \

  301.         uint##nbits##_t *dst = (uint##nbits##_t *)dstrow;                                           \

  302.         const uint##nbits##_t *src = (const uint##nbits##_t *)srcrow;                               \

  303.         for (x = 0; x < in->width * step; x += step) {                                              \

  304.             const struct rgbvec scaled_rgb = {src[x + r] * scale,                                   \

  305.                                               src[x + g] * scale,                                   \

  306.                                               src[x + b] * scale};                                  \

  307.             struct rgbvec vec = interp_##name(lut3d, &scaled_rgb);                                  \

  308.             dst[x + r] = av_clip_uint##nbits(vec.r * (float)((1<<nbits) - 1));                      \

  309.             dst[x + g] = av_clip_uint##nbits(vec.g * (float)((1<<nbits) - 1));                      \

  310.             dst[x + b] = av_clip_uint##nbits(vec.b * (float)((1<<nbits) - 1));                      \

  311.             if (!direct && step == 4)                                                               \

  312.                 dst[x + a] = src[x + a];                                                            \

  313.         }                                                                                           \

  314.         dstrow += out->linesize[0];                                                                 \

  315.         srcrow += in ->linesize[0];                                                                 \

  316.     }                                                                                               \

  317.     return 0;                                                                                       \

  318. }

  319. 

  320. DEFINE_INTERP_FUNC(nearest,     8)

  321. DEFINE_INTERP_FUNC(trilinear,   8)

  322. DEFINE_INTERP_FUNC(tetrahedral, 8)

  323. 

  324. DEFINE_INTERP_FUNC(nearest,     16)

  325. DEFINE_INTERP_FUNC(trilinear,   16)

  326. DEFINE_INTERP_FUNC(tetrahedral, 16)

  327. 

  328. #define MAX_LINE_SIZE 512

  329. 

  330. static int skip_line(const char *p)

  331. {

  332.     while (*p && av_isspace(*p))

  333.         p++;

  334.     return !*p || *p == '#';

  335. }

  336. 

  337. #define NEXT_LINE(loop_cond) do {                           \

  338.     if (!fgets(line, sizeof(line), f)) {                    \

  339.         av_log(ctx, AV_LOG_ERROR, "Unexpected EOF\n");      \

  340.         return AVERROR_INVALIDDATA;                         \

  341.     }                                                       \

  342. } while (loop_cond)

  343. 

  344. /* Basically r g and b float values on each line, with a facultative 3DLUTSIZE

  345.  * directive; seems to be generated by Davinci */

  346. static int parse_dat(AVFilterContext *ctx, FILE *f)

  347. {

  348.     LUT3DContext *lut3d = ctx->priv;

  349.     char line[MAX_LINE_SIZE];

  350.     int i, j, k, size;

  351. 

  352.     lut3d->lutsize = size = 33;

  353. 

  354.     NEXT_LINE(skip_line(line));

  355.     if (!strncmp(line, "3DLUTSIZE ", 10)) {

  356.         size = strtol(line + 10, NULL, 0);

  357.         if (size < 2 || size > MAX_LEVEL) {

  358.             av_log(ctx, AV_LOG_ERROR, "Too large or invalid 3D LUT size\n");

  359.             return AVERROR(EINVAL);

  360.         }

  361.         lut3d->lutsize = size;

  362.         NEXT_LINE(skip_line(line));

  363.     }

  364.     for (k = 0; k < size; k++) {

  365.         for (j = 0; j < size; j++) {

  366.             for (i = 0; i < size; i++) {

  367.                 struct rgbvec *vec = &lut3d->lut[k][j][i];

  368.                 if (k != 0 || j != 0 || i != 0)

  369.                     NEXT_LINE(skip_line(line));

  370.                 if (av_sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b) != 3)

  371.                     return AVERROR_INVALIDDATA;

  372.             }

  373.         }

  374.     }

  375.     return 0;

  376. }

  377. 

  378. /* Iridas format */

  379. static int parse_cube(AVFilterContext *ctx, FILE *f)

  380. {

  381.     LUT3DContext *lut3d = ctx->priv;

  382.     char line[MAX_LINE_SIZE];

  383.     float min[3] = {0.0, 0.0, 0.0};

  384.     float max[3] = {1.0, 1.0, 1.0};

  385. 

  386.     while (fgets(line, sizeof(line), f)) {

  387.         if (!strncmp(line, "LUT_3D_SIZE", 11)) {

  388.             int i, j, k;

  389.             const int size = strtol(line + 12, NULL, 0);

  390. 

  391.             if (size < 2 || size > MAX_LEVEL) {

  392.                 av_log(ctx, AV_LOG_ERROR, "Too large or invalid 3D LUT size\n");

  393.                 return AVERROR(EINVAL);

  394.             }

  395.             lut3d->lutsize = size;

  396.             for (k = 0; k < size; k++) {

  397.                 for (j = 0; j < size; j++) {

  398.                     for (i = 0; i < size; i++) {

  399.                         struct rgbvec *vec = &lut3d->lut[i][j][k];

  400. 

  401.                         do {

  402. try_again:

  403.                             NEXT_LINE(0);

  404.                             if (!strncmp(line, "DOMAIN_", 7)) {

  405.                                 float *vals = NULL;

  406.                                 if      (!strncmp(line + 7, "MIN ", 4)) vals = min;

  407.                                 else if (!strncmp(line + 7, "MAX ", 4)) vals = max;

  408.                                 if (!vals)

  409.                                     return AVERROR_INVALIDDATA;

  410.                                 av_sscanf(line + 11, "%f %f %f", vals, vals + 1, vals + 2);

  411.                                 av_log(ctx, AV_LOG_DEBUG, "min: %f %f %f | max: %f %f %f\n",

  412.                                        min[0], min[1], min[2], max[0], max[1], max[2]);

  413.                                 goto try_again;

  414.                             } else if (!strncmp(line, "TITLE", 5)) {

  415.                                 goto try_again;

  416.                             }

  417.                         } while (skip_line(line));

  418.                         if (av_sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b) != 3)

  419.                             return AVERROR_INVALIDDATA;

  420.                         vec->r *= max[0] - min[0];

  421.                         vec->g *= max[1] - min[1];

  422.                         vec->b *= max[2] - min[2];

  423.                     }

  424.                 }

  425.             }

  426.             break;

  427.         }

  428.     }

  429.     return 0;

  430. }

  431. 

  432. /* Assume 17x17x17 LUT with a 16-bit depth

  433.  * FIXME: it seems there are various 3dl formats */

  434. static int parse_3dl(AVFilterContext *ctx, FILE *f)

  435. {

  436.     char line[MAX_LINE_SIZE];

  437.     LUT3DContext *lut3d = ctx->priv;

  438.     int i, j, k;

  439.     const int size = 17;

  440.     const float scale = 16*16*16;

  441. 

  442.     lut3d->lutsize = size;

  443.     NEXT_LINE(skip_line(line));

  444.     for (k = 0; k < size; k++) {

  445.         for (j = 0; j < size; j++) {

  446.             for (i = 0; i < size; i++) {

  447.                 int r, g, b;

  448.                 struct rgbvec *vec = &lut3d->lut[k][j][i];

  449. 

  450.                 NEXT_LINE(skip_line(line));

  451.                 if (av_sscanf(line, "%d %d %d", &r, &g, &b) != 3)

  452.                     return AVERROR_INVALIDDATA;

  453.                 vec->r = r / scale;

  454.                 vec->g = g / scale;

  455.                 vec->b = b / scale;

  456.             }

  457.         }

  458.     }

  459.     return 0;

  460. }

  461. 

  462. /* Pandora format */

  463. static int parse_m3d(AVFilterContext *ctx, FILE *f)

  464. {

  465.     LUT3DContext *lut3d = ctx->priv;

  466.     float scale;

  467.     int i, j, k, size, in = -1, out = -1;

  468.     char line[MAX_LINE_SIZE];

  469.     uint8_t rgb_map[3] = {0, 1, 2};

  470. 

  471.     while (fgets(line, sizeof(line), f)) {

  472.         if      (!strncmp(line, "in",  2)) in  = strtol(line + 2, NULL, 0);

  473.         else if (!strncmp(line, "out", 3)) out = strtol(line + 3, NULL, 0);

  474.         else if (!strncmp(line, "values", 6)) {

  475.             const char *p = line + 6;

  476. #define SET_COLOR(id) do {                  \

  477.     while (av_isspace(*p))                  \

  478.         p++;                                \

  479.     switch (*p) {                           \

  480.     case 'r': rgb_map[id] = 0; break;       \

  481.     case 'g': rgb_map[id] = 1; break;       \

  482.     case 'b': rgb_map[id] = 2; break;       \

  483.     }                                       \

  484.     while (*p && !av_isspace(*p))           \

  485.         p++;                                \

  486. } while (0)

  487.             SET_COLOR(0);

  488.             SET_COLOR(1);

  489.             SET_COLOR(2);

  490.             break;

  491.         }

  492.     }

  493. 

  494.     if (in == -1 || out == -1) {

  495.         av_log(ctx, AV_LOG_ERROR, "in and out must be defined\n");

  496.         return AVERROR_INVALIDDATA;

  497.     }

  498.     if (in < 2 || out < 2 ||

  499.         in  > MAX_LEVEL*MAX_LEVEL*MAX_LEVEL ||

  500.         out > MAX_LEVEL*MAX_LEVEL*MAX_LEVEL) {

  501.         av_log(ctx, AV_LOG_ERROR, "invalid in (%d) or out (%d)\n", in, out);

  502.         return AVERROR_INVALIDDATA;

  503.     }

  504.     for (size = 1; size*size*size < in; size++);

  505.     lut3d->lutsize = size;

  506.     scale = 1. / (out - 1);

  507. 

  508.     for (k = 0; k < size; k++) {

  509.         for (j = 0; j < size; j++) {

  510.             for (i = 0; i < size; i++) {

  511.                 struct rgbvec *vec = &lut3d->lut[k][j][i];

  512.                 float val[3];

  513. 

  514.                 NEXT_LINE(0);

  515.                 if (av_sscanf(line, "%f %f %f", val, val + 1, val + 2) != 3)

  516.                     return AVERROR_INVALIDDATA;

  517.                 vec->r = val[rgb_map[0]] * scale;

  518.                 vec->g = val[rgb_map[1]] * scale;

  519.                 vec->b = val[rgb_map[2]] * scale;

  520.             }

  521.         }

  522.     }

  523.     return 0;

  524. }

  525. 

  526. static int parse_cinespace(AVFilterContext *ctx, FILE *f)

  527. {

  528.     LUT3DContext *lut3d = ctx->priv;

  529.     char line[MAX_LINE_SIZE];

  530.     float in_min[3]  = {0.0, 0.0, 0.0};

  531.     float in_max[3]  = {1.0, 1.0, 1.0};

  532.     float out_min[3] = {0.0, 0.0, 0.0};

  533.     float out_max[3] = {1.0, 1.0, 1.0};

  534.     int inside_metadata = 0, size;

  535. 

  536.     NEXT_LINE(skip_line(line));

  537.     if (strncmp(line, "CSPLUTV100", 10)) {

  538.         av_log(ctx, AV_LOG_ERROR, "Not cineSpace LUT format\n");

  539.         return AVERROR(EINVAL);

  540.     }

  541. 

  542.     NEXT_LINE(skip_line(line));

  543.     if (strncmp(line, "3D", 2)) {

  544.         av_log(ctx, AV_LOG_ERROR, "Not 3D LUT format\n");

  545.         return AVERROR(EINVAL);

  546.     }

  547. 

  548.     while (1) {

  549.         NEXT_LINE(skip_line(line));

  550. 

  551.         if (!strncmp(line, "BEGIN METADATA", 14)) {

  552.             inside_metadata = 1;

  553.             continue;

  554.         }

  555.         if (!strncmp(line, "END METADATA", 12)) {

  556.             inside_metadata = 0;

  557.             continue;

  558.         }

  559.         if (inside_metadata == 0) {

  560.             int size_r, size_g, size_b;

  561. 

  562.             for (int i = 0; i < 3; i++) {

  563.                 int npoints = strtol(line, NULL, 0);

  564. 

  565.                 if (npoints != 2) {

  566.                     av_log(ctx, AV_LOG_ERROR, "Unsupported number of pre-lut points.\n");

  567.                     return AVERROR_PATCHWELCOME;

  568.                 }

  569. 

  570.                 NEXT_LINE(skip_line(line));

  571.                 if (av_sscanf(line, "%f %f", &in_min[i], &in_max[i]) != 2)

  572.                     return AVERROR_INVALIDDATA;

  573.                 NEXT_LINE(skip_line(line));

  574.                 if (av_sscanf(line, "%f %f", &out_min[i], &out_max[i]) != 2)

  575.                     return AVERROR_INVALIDDATA;

  576.                 NEXT_LINE(skip_line(line));

  577.             }

  578. 

  579.             if (av_sscanf(line, "%d %d %d", &size_r, &size_g, &size_b) != 3)

  580.                 return AVERROR(EINVAL);

  581.             if (size_r != size_g || size_r != size_b) {

  582.                 av_log(ctx, AV_LOG_ERROR, "Unsupported size combination: %dx%dx%d.\n", size_r, size_g, size_b);

  583.                 return AVERROR_PATCHWELCOME;

  584.             }

  585. 

  586.             size = size_r;

  587.             if (size < 2 || size > MAX_LEVEL) {

  588.                 av_log(ctx, AV_LOG_ERROR, "Too large or invalid 3D LUT size\n");

  589.                 return AVERROR(EINVAL);

  590.             }

  591. 

  592.             lut3d->lutsize = size;

  593. 

  594.             for (int k = 0; k < size; k++) {

  595.                 for (int j = 0; j < size; j++) {

  596.                     for (int i = 0; i < size; i++) {

  597.                         struct rgbvec *vec = &lut3d->lut[i][j][k];

  598.                         if (k != 0 || j != 0 || i != 0)

  599.                             NEXT_LINE(skip_line(line));

  600.                         if (av_sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b) != 3)

  601.                             return AVERROR_INVALIDDATA;

  602.                         vec->r *= out_max[0] - out_min[0];

  603.                         vec->g *= out_max[1] - out_min[1];

  604.                         vec->b *= out_max[2] - out_min[2];

  605.                     }

  606.                 }

  607.             }

  608. 

  609.             break;

  610.         }

  611.     }

  612.     return 0;

  613. }

  614. 

  615. static void set_identity_matrix(LUT3DContext *lut3d, int size)

  616. {

  617.     int i, j, k;

  618.     const float c = 1. / (size - 1);

  619. 

  620.     lut3d->lutsize = size;

  621.     for (k = 0; k < size; k++) {

  622.         for (j = 0; j < size; j++) {

  623.             for (i = 0; i < size; i++) {

  624.                 struct rgbvec *vec = &lut3d->lut[k][j][i];

  625.                 vec->r = k * c;

  626.                 vec->g = j * c;

  627.                 vec->b = i * c;

  628.             }

  629.         }

  630.     }

  631. }

  632. 

  633. static int query_formats(AVFilterContext *ctx)

  634. {

  635.     static const enum AVPixelFormat pix_fmts[] = {

  636.         AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,

  637.         AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,

  638.         AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,

  639.         AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,

  640.         AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,

  641.         AV_PIX_FMT_RGB48,  AV_PIX_FMT_BGR48,

  642.         AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,

  643.         AV_PIX_FMT_GBRP,   AV_PIX_FMT_GBRAP,

  644.         AV_PIX_FMT_GBRP9,

  645.         AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,

  646.         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,

  647.         AV_PIX_FMT_GBRP14,

  648.         AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,

  649.         AV_PIX_FMT_NONE

  650.     };

  651.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  652.     if (!fmts_list)

  653.         return AVERROR(ENOMEM);

  654.     return ff_set_common_formats(ctx, fmts_list);

  655. }

  656. 

  657. static int config_input(AVFilterLink *inlink)

  658. {

  659.     int depth, is16bit = 0, planar = 0;

  660.     LUT3DContext *lut3d = inlink->dst->priv;

  661.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

  662. 

  663.     depth = desc->comp[0].depth;

  664. 

  665.     switch (inlink->format) {

  666.     case AV_PIX_FMT_RGB48:

  667.     case AV_PIX_FMT_BGR48:

  668.     case AV_PIX_FMT_RGBA64:

  669.     case AV_PIX_FMT_BGRA64:

  670.         is16bit = 1;

  671.         break;

  672.     case AV_PIX_FMT_GBRP9:

  673.     case AV_PIX_FMT_GBRP10:

  674.     case AV_PIX_FMT_GBRP12:

  675.     case AV_PIX_FMT_GBRP14:

  676.     case AV_PIX_FMT_GBRP16:

  677.     case AV_PIX_FMT_GBRAP10:

  678.     case AV_PIX_FMT_GBRAP12:

  679.     case AV_PIX_FMT_GBRAP16:

  680.         is16bit = 1;

  681.     case AV_PIX_FMT_GBRP:

  682.     case AV_PIX_FMT_GBRAP:

  683.         planar = 1;

  684.         break;

  685.     }

  686. 

  687.     ff_fill_rgba_map(lut3d->rgba_map, inlink->format);

  688.     lut3d->step = av_get_padded_bits_per_pixel(desc) >> (3 + is16bit);

  689. 

  690. #define SET_FUNC(name) do {                                     \

  691.     if (planar) {                                               \

  692.         switch (depth) {                                        \

  693.         case  8: lut3d->interp = interp_8_##name##_p8;   break; \

  694.         case  9: lut3d->interp = interp_16_##name##_p9;  break; \

  695.         case 10: lut3d->interp = interp_16_##name##_p10; break; \

  696.         case 12: lut3d->interp = interp_16_##name##_p12; break; \

  697.         case 14: lut3d->interp = interp_16_##name##_p14; break; \

  698.         case 16: lut3d->interp = interp_16_##name##_p16; break; \

  699.         }                                                       \

  700.     } else if (is16bit) { lut3d->interp = interp_16_##name;     \

  701.     } else {       lut3d->interp = interp_8_##name; }           \

  702. } while (0)

  703. 

  704.     switch (lut3d->interpolation) {

  705.     case INTERPOLATE_NEAREST:     SET_FUNC(nearest);        break;

  706.     case INTERPOLATE_TRILINEAR:   SET_FUNC(trilinear);      break;

  707.     case INTERPOLATE_TETRAHEDRAL: SET_FUNC(tetrahedral);    break;

  708.     default:

  709.         av_assert0(0);

  710.     }

  711. 

  712.     return 0;

  713. }

  714. 

  715. static AVFrame *apply_lut(AVFilterLink *inlink, AVFrame *in)

  716. {

  717.     AVFilterContext *ctx = inlink->dst;

  718.     LUT3DContext *lut3d = ctx->priv;

  719.     AVFilterLink *outlink = inlink->dst->outputs[0];

  720.     AVFrame *out;

  721.     ThreadData td;

  722. 

  723.     if (av_frame_is_writable(in)) {

  724.         out = in;

  725.     } else {

  726.         out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

  727.         if (!out) {

  728.             av_frame_free(&in);

  729.             return NULL;

  730.         }

  731.         av_frame_copy_props(out, in);

  732.     }

  733. 

  734.     td.in  = in;

  735.     td.out = out;

  736.     ctx->internal->execute(ctx, lut3d->interp, &td, NULL, FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));

  737. 

  738.     if (out != in)

  739.         av_frame_free(&in);

  740. 

  741.     return out;

  742. }

  743. 

  744. static int filter_frame(AVFilterLink *inlink, AVFrame *in)

  745. {

  746.     AVFilterLink *outlink = inlink->dst->outputs[0];

  747.     AVFrame *out = apply_lut(inlink, in);

  748.     if (!out)

  749.         return AVERROR(ENOMEM);

  750.     return ff_filter_frame(outlink, out);

  751. }

  752. 

  753. #if CONFIG_LUT3D_FILTER

  754. static const AVOption lut3d_options[] = {

  755.     { "file", "set 3D LUT file name", OFFSET(file), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },

  756.     COMMON_OPTIONS

  757. };

  758. 

  759. AVFILTER_DEFINE_CLASS(lut3d);

  760. 

  761. static av_cold int lut3d_init(AVFilterContext *ctx)

  762. {

  763.     int ret;

  764.     FILE *f;

  765.     const char *ext;

  766.     LUT3DContext *lut3d = ctx->priv;

  767. 

  768.     if (!lut3d->file) {

  769.         set_identity_matrix(lut3d, 32);

  770.         return 0;

  771.     }

  772. 

  773.     f = fopen(lut3d->file, "r");

  774.     if (!f) {

  775.         ret = AVERROR(errno);

  776.         av_log(ctx, AV_LOG_ERROR, "%s: %s\n", lut3d->file, av_err2str(ret));

  777.         return ret;

  778.     }

  779. 

  780.     ext = strrchr(lut3d->file, '.');

  781.     if (!ext) {

  782.         av_log(ctx, AV_LOG_ERROR, "Unable to guess the format from the extension\n");

  783.         ret = AVERROR_INVALIDDATA;

  784.         goto end;

  785.     }

  786.     ext++;

  787. 

  788.     if (!av_strcasecmp(ext, "dat")) {

  789.         ret = parse_dat(ctx, f);

  790.     } else if (!av_strcasecmp(ext, "3dl")) {

  791.         ret = parse_3dl(ctx, f);

  792.     } else if (!av_strcasecmp(ext, "cube")) {

  793.         ret = parse_cube(ctx, f);

  794.     } else if (!av_strcasecmp(ext, "m3d")) {

  795.         ret = parse_m3d(ctx, f);

  796.     } else if (!av_strcasecmp(ext, "csp")) {

  797.         ret = parse_cinespace(ctx, f);

  798.     } else {

  799.         av_log(ctx, AV_LOG_ERROR, "Unrecognized '.%s' file type\n", ext);

  800.         ret = AVERROR(EINVAL);

  801.     }

  802. 

  803.     if (!ret && !lut3d->lutsize) {

  804.         av_log(ctx, AV_LOG_ERROR, "3D LUT is empty\n");

  805.         ret = AVERROR_INVALIDDATA;

  806.     }

  807. 

  808. end:

  809.     fclose(f);

  810.     return ret;

  811. }

  812. 

  813. static const AVFilterPad lut3d_inputs[] = {

  814.     {

  815.         .name         = "default",

  816.         .type         = AVMEDIA_TYPE_VIDEO,

  817.         .filter_frame = filter_frame,

  818.         .config_props = config_input,

  819.     },

  820.     { NULL }

  821. };

  822. 

  823. static const AVFilterPad lut3d_outputs[] = {

  824.     {

  825.         .name = "default",

  826.         .type = AVMEDIA_TYPE_VIDEO,

  827.     },

  828.     { NULL }

  829. };

  830. 

  831. AVFilter ff_vf_lut3d = {

  832.     .name          = "lut3d",

  833.     .description   = NULL_IF_CONFIG_SMALL("Adjust colors using a 3D LUT."),

  834.     .priv_size     = sizeof(LUT3DContext),

  835.     .init          = lut3d_init,

  836.     .query_formats = query_formats,

  837.     .inputs        = lut3d_inputs,

  838.     .outputs       = lut3d_outputs,

  839.     .priv_class    = &lut3d_class,

  840.     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

  841. };

  842. #endif

  843. 

  844. #if CONFIG_HALDCLUT_FILTER

  845. 

  846. static void update_clut_packed(LUT3DContext *lut3d, const AVFrame *frame)

  847. {

  848.     const uint8_t *data = frame->data[0];

  849.     const int linesize  = frame->linesize[0];

  850.     const int w = lut3d->clut_width;

  851.     const int step = lut3d->clut_step;

  852.     const uint8_t *rgba_map = lut3d->clut_rgba_map;

  853.     const int level = lut3d->lutsize;

  854. 

  855. #define LOAD_CLUT(nbits) do {                                           \

  856.     int i, j, k, x = 0, y = 0;                                          \

  857.                                                                         \

  858.     for (k = 0; k < level; k++) {                                       \

  859.         for (j = 0; j < level; j++) {                                   \

  860.             for (i = 0; i < level; i++) {                               \

  861.                 const uint##nbits##_t *src = (const uint##nbits##_t *)  \

  862.                     (data + y*linesize + x*step);                       \

  863.                 struct rgbvec *vec = &lut3d->lut[i][j][k];              \

  864.                 vec->r = src[rgba_map[0]] / (float)((1<<(nbits)) - 1);  \

  865.                 vec->g = src[rgba_map[1]] / (float)((1<<(nbits)) - 1);  \

  866.                 vec->b = src[rgba_map[2]] / (float)((1<<(nbits)) - 1);  \

  867.                 if (++x == w) {                                         \

  868.                     x = 0;                                              \

  869.                     y++;                                                \

  870.                 }                                                       \

  871.             }                                                           \

  872.         }                                                               \

  873.     }                                                                   \

  874. } while (0)

  875. 

  876.     switch (lut3d->clut_bits) {

  877.     case  8: LOAD_CLUT(8);  break;

  878.     case 16: LOAD_CLUT(16); break;

  879.     }

  880. }

  881. 

  882. static void update_clut_planar(LUT3DContext *lut3d, const AVFrame *frame)

  883. {

  884.     const uint8_t *datag = frame->data[0];

  885.     const uint8_t *datab = frame->data[1];

  886.     const uint8_t *datar = frame->data[2];

  887.     const int glinesize  = frame->linesize[0];

  888.     const int blinesize  = frame->linesize[1];

  889.     const int rlinesize  = frame->linesize[2];

  890.     const int w = lut3d->clut_width;

  891.     const int level = lut3d->lutsize;

  892. 

  893. #define LOAD_CLUT_PLANAR(nbits, depth) do {                             \

  894.     int i, j, k, x = 0, y = 0;                                          \

  895.                                                                         \

  896.     for (k = 0; k < level; k++) {                                       \

  897.         for (j = 0; j < level; j++) {                                   \

  898.             for (i = 0; i < level; i++) {                               \

  899.                 const uint##nbits##_t *gsrc = (const uint##nbits##_t *) \

  900.                     (datag + y*glinesize);                              \

  901.                 const uint##nbits##_t *bsrc = (const uint##nbits##_t *) \

  902.                     (datab + y*blinesize);                              \

  903.                 const uint##nbits##_t *rsrc = (const uint##nbits##_t *) \

  904.                     (datar + y*rlinesize);                              \

  905.                 struct rgbvec *vec = &lut3d->lut[i][j][k];              \

  906.                 vec->r = gsrc[x] / (float)((1<<(depth)) - 1);           \

  907.                 vec->g = bsrc[x] / (float)((1<<(depth)) - 1);           \

  908.                 vec->b = rsrc[x] / (float)((1<<(depth)) - 1);           \

  909.                 if (++x == w) {                                         \

  910.                     x = 0;                                              \

  911.                     y++;                                                \

  912.                 }                                                       \

  913.             }                                                           \

  914.         }                                                               \

  915.     }                                                                   \

  916. } while (0)

  917. 

  918.     switch (lut3d->clut_bits) {

  919.     case  8: LOAD_CLUT_PLANAR(8, 8);   break;

  920.     case  9: LOAD_CLUT_PLANAR(16, 9);  break;

  921.     case 10: LOAD_CLUT_PLANAR(16, 10); break;

  922.     case 12: LOAD_CLUT_PLANAR(16, 12); break;

  923.     case 14: LOAD_CLUT_PLANAR(16, 14); break;

  924.     case 16: LOAD_CLUT_PLANAR(16, 16); break;

  925.     }

  926. }

  927. 

  928. static int config_output(AVFilterLink *outlink)

  929. {

  930.     AVFilterContext *ctx = outlink->src;

  931.     LUT3DContext *lut3d = ctx->priv;

  932.     int ret;

  933. 

  934.     ret = ff_framesync_init_dualinput(&lut3d->fs, ctx);

  935.     if (ret < 0)

  936.         return ret;

  937.     outlink->w = ctx->inputs[0]->w;

  938.     outlink->h = ctx->inputs[0]->h;

  939.     outlink->time_base = ctx->inputs[0]->time_base;

  940.     if ((ret = ff_framesync_configure(&lut3d->fs)) < 0)

  941.         return ret;

  942.     return 0;

  943. }

  944. 

  945. static int activate(AVFilterContext *ctx)

  946. {

  947.     LUT3DContext *s = ctx->priv;

  948.     return ff_framesync_activate(&s->fs);

  949. }

  950. 

  951. static int config_clut(AVFilterLink *inlink)

  952. {

  953.     int size, level, w, h;

  954.     AVFilterContext *ctx = inlink->dst;

  955.     LUT3DContext *lut3d = ctx->priv;

  956.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

  957. 

  958.     av_assert0(desc);

  959. 

  960.     lut3d->clut_bits = desc->comp[0].depth;

  961.     lut3d->clut_planar = av_pix_fmt_count_planes(inlink->format) > 1;

  962. 

  963.     lut3d->clut_step = av_get_padded_bits_per_pixel(desc) >> 3;

  964.     ff_fill_rgba_map(lut3d->clut_rgba_map, inlink->format);

  965. 

  966.     if (inlink->w > inlink->h)

  967.         av_log(ctx, AV_LOG_INFO, "Padding on the right (%dpx) of the "

  968.                "Hald CLUT will be ignored\n", inlink->w - inlink->h);

  969.     else if (inlink->w < inlink->h)

  970.         av_log(ctx, AV_LOG_INFO, "Padding at the bottom (%dpx) of the "

  971.                "Hald CLUT will be ignored\n", inlink->h - inlink->w);

  972.     lut3d->clut_width = w = h = FFMIN(inlink->w, inlink->h);

  973. 

  974.     for (level = 1; level*level*level < w; level++);

  975.     size = level*level*level;

  976.     if (size != w) {

  977.         av_log(ctx, AV_LOG_WARNING, "The Hald CLUT width does not match the level\n");

  978.         return AVERROR_INVALIDDATA;

  979.     }

  980.     av_assert0(w == h && w == size);

  981.     level *= level;

  982.     if (level > MAX_LEVEL) {

  983.         const int max_clut_level = sqrt(MAX_LEVEL);

  984.         const int max_clut_size  = max_clut_level*max_clut_level*max_clut_level;

  985.         av_log(ctx, AV_LOG_ERROR, "Too large Hald CLUT "

  986.                "(maximum level is %d, or %dx%d CLUT)\n",

  987.                max_clut_level, max_clut_size, max_clut_size);

  988.         return AVERROR(EINVAL);

  989.     }

  990.     lut3d->lutsize = level;

  991. 

  992.     return 0;

  993. }

  994. 

  995. static int update_apply_clut(FFFrameSync *fs)

  996. {

  997.     AVFilterContext *ctx = fs->parent;

  998.     LUT3DContext *lut3d = ctx->priv;

  999.     AVFilterLink *inlink = ctx->inputs[0];

  1000.     AVFrame *master, *second, *out;

  1001.     int ret;

  1002. 

  1003.     ret = ff_framesync_dualinput_get(fs, &master, &second);

  1004.     if (ret < 0)

  1005.         return ret;

  1006.     if (!second)

  1007.         return ff_filter_frame(ctx->outputs[0], master);

  1008.     if (lut3d->clut_planar)

  1009.         update_clut_planar(ctx->priv, second);

  1010.     else

  1011.         update_clut_packed(ctx->priv, second);

  1012.     out = apply_lut(inlink, master);

  1013.     return ff_filter_frame(ctx->outputs[0], out);

  1014. }

  1015. 

  1016. static av_cold int haldclut_init(AVFilterContext *ctx)

  1017. {

  1018.     LUT3DContext *lut3d = ctx->priv;

  1019.     lut3d->fs.on_event = update_apply_clut;

  1020.     return 0;

  1021. }

  1022. 

  1023. static av_cold void haldclut_uninit(AVFilterContext *ctx)

  1024. {

  1025.     LUT3DContext *lut3d = ctx->priv;

  1026.     ff_framesync_uninit(&lut3d->fs);

  1027. }

  1028. 

  1029. static const AVOption haldclut_options[] = {

  1030.     COMMON_OPTIONS

  1031. };

  1032. 

  1033. FRAMESYNC_DEFINE_CLASS(haldclut, LUT3DContext, fs);

  1034. 

  1035. static const AVFilterPad haldclut_inputs[] = {

  1036.     {

  1037.         .name         = "main",

  1038.         .type         = AVMEDIA_TYPE_VIDEO,

  1039.         .config_props = config_input,

  1040.     },{

  1041.         .name         = "clut",

  1042.         .type         = AVMEDIA_TYPE_VIDEO,

  1043.         .config_props = config_clut,

  1044.     },

  1045.     { NULL }

  1046. };

  1047. 

  1048. static const AVFilterPad haldclut_outputs[] = {

  1049.     {

  1050.         .name          = "default",

  1051.         .type          = AVMEDIA_TYPE_VIDEO,

  1052.         .config_props  = config_output,

  1053.     },

  1054.     { NULL }

  1055. };

  1056. 

  1057. AVFilter ff_vf_haldclut = {

  1058.     .name          = "haldclut",

  1059.     .description   = NULL_IF_CONFIG_SMALL("Adjust colors using a Hald CLUT."),

  1060.     .priv_size     = sizeof(LUT3DContext),

  1061.     .preinit       = haldclut_framesync_preinit,

  1062.     .init          = haldclut_init,

  1063.     .uninit        = haldclut_uninit,

  1064.     .query_formats = query_formats,

  1065.     .activate      = activate,

  1066.     .inputs        = haldclut_inputs,

  1067.     .outputs       = haldclut_outputs,

  1068.     .priv_class    = &haldclut_class,

  1069.     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,

  1070. };

  1071. #endif

  1072. 

  1073. #if CONFIG_LUT1D_FILTER

  1074. 

  1075. enum interp_1d_mode {

  1076.     INTERPOLATE_1D_NEAREST,

  1077.     INTERPOLATE_1D_LINEAR,

  1078.     INTERPOLATE_1D_CUBIC,

  1079.     INTERPOLATE_1D_COSINE,

  1080.     INTERPOLATE_1D_SPLINE,

  1081.     NB_INTERP_1D_MODE

  1082. };

  1083. 

  1084. #define MAX_1D_LEVEL 65536

  1085. 

  1086. typedef struct LUT1DContext {

  1087.     const AVClass *class;

  1088.     char *file;

  1089.     int interpolation;          ///<interp_1d_mode

  1090.     uint8_t rgba_map[4];

  1091.     int step;

  1092.     float lut[3][MAX_1D_LEVEL];

  1093.     int lutsize;

  1094.     avfilter_action_func *interp;

  1095. } LUT1DContext;

  1096. 

  1097. #undef OFFSET

  1098. #define OFFSET(x) offsetof(LUT1DContext, x)

  1099. 

  1100. static void set_identity_matrix_1d(LUT1DContext *lut1d, int size)

  1101. {

  1102.     const float c = 1. / (size - 1);

  1103.     int i;

  1104. 

  1105.     lut1d->lutsize = size;

  1106.     for (i = 0; i < size; i++) {

  1107.         lut1d->lut[0][i] = i * c;

  1108.         lut1d->lut[1][i] = i * c;

  1109.         lut1d->lut[2][i] = i * c;

  1110.     }

  1111. }

  1112. 

  1113. static int parse_cinespace_1d(AVFilterContext *ctx, FILE *f)

  1114. {

  1115.     LUT1DContext *lut1d = ctx->priv;

  1116.     char line[MAX_LINE_SIZE];

  1117.     float in_min[3]  = {0.0, 0.0, 0.0};

  1118.     float in_max[3]  = {1.0, 1.0, 1.0};

  1119.     float out_min[3] = {0.0, 0.0, 0.0};

  1120.     float out_max[3] = {1.0, 1.0, 1.0};

  1121.     int inside_metadata = 0, size;

  1122. 

  1123.     NEXT_LINE(skip_line(line));

  1124.     if (strncmp(line, "CSPLUTV100", 10)) {

  1125.         av_log(ctx, AV_LOG_ERROR, "Not cineSpace LUT format\n");

  1126.         return AVERROR(EINVAL);

  1127.     }

  1128. 

  1129.     NEXT_LINE(skip_line(line));

  1130.     if (strncmp(line, "1D", 2)) {

  1131.         av_log(ctx, AV_LOG_ERROR, "Not 1D LUT format\n");

  1132.         return AVERROR(EINVAL);

  1133.     }

  1134. 

  1135.     while (1) {

  1136.         NEXT_LINE(skip_line(line));

  1137. 

  1138.         if (!strncmp(line, "BEGIN METADATA", 14)) {

  1139.             inside_metadata = 1;

  1140.             continue;

  1141.         }

  1142.         if (!strncmp(line, "END METADATA", 12)) {

  1143.             inside_metadata = 0;

  1144.             continue;

  1145.         }

  1146.         if (inside_metadata == 0) {

  1147.             for (int i = 0; i < 3; i++) {

  1148.                 int npoints = strtol(line, NULL, 0);

  1149. 

  1150.                 if (npoints != 2) {

  1151.                     av_log(ctx, AV_LOG_ERROR, "Unsupported number of pre-lut points.\n");

  1152.                     return AVERROR_PATCHWELCOME;

  1153.                 }

  1154. 

  1155.                 NEXT_LINE(skip_line(line));

  1156.                 if (av_sscanf(line, "%f %f", &in_min[i], &in_max[i]) != 2)

  1157.                     return AVERROR_INVALIDDATA;

  1158.                 NEXT_LINE(skip_line(line));

  1159.                 if (av_sscanf(line, "%f %f", &out_min[i], &out_max[i]) != 2)

  1160.                     return AVERROR_INVALIDDATA;

  1161.                 NEXT_LINE(skip_line(line));

  1162.             }

  1163. 

  1164.             size = strtol(line, NULL, 0);

  1165. 

  1166.             if (size < 2 || size > MAX_1D_LEVEL) {

  1167.                 av_log(ctx, AV_LOG_ERROR, "Too large or invalid 1D LUT size\n");

  1168.                 return AVERROR(EINVAL);

  1169.             }

  1170. 

  1171.             lut1d->lutsize = size;

  1172. 

  1173.             for (int i = 0; i < size; i++) {

  1174.                 NEXT_LINE(skip_line(line));

  1175.                 if (av_sscanf(line, "%f %f %f", &lut1d->lut[0][i], &lut1d->lut[1][i], &lut1d->lut[2][i]) != 3)

  1176.                     return AVERROR_INVALIDDATA;

  1177.                 lut1d->lut[0][i] *= out_max[0] - out_min[0];

  1178.                 lut1d->lut[1][i] *= out_max[1] - out_min[1];

  1179.                 lut1d->lut[2][i] *= out_max[2] - out_min[2];

  1180.             }

  1181. 

  1182.             break;

  1183.         }

  1184.     }

  1185.     return 0;

  1186. }

  1187. 

  1188. static int parse_cube_1d(AVFilterContext *ctx, FILE *f)

  1189. {

  1190.     LUT1DContext *lut1d = ctx->priv;

  1191.     char line[MAX_LINE_SIZE];

  1192.     float min[3] = {0.0, 0.0, 0.0};

  1193.     float max[3] = {1.0, 1.0, 1.0};

  1194. 

  1195.     while (fgets(line, sizeof(line), f)) {

  1196.         if (!strncmp(line, "LUT_1D_SIZE", 11)) {

  1197.             const int size = strtol(line + 12, NULL, 0);

  1198.             int i;

  1199. 

  1200.             if (size < 2 || size > MAX_1D_LEVEL) {

  1201.                 av_log(ctx, AV_LOG_ERROR, "Too large or invalid 1D LUT size\n");

  1202.                 return AVERROR(EINVAL);

  1203.             }

  1204.             lut1d->lutsize = size;

  1205.             for (i = 0; i < size; i++) {

  1206.                 do {

  1207. try_again:

  1208.                     NEXT_LINE(0);

  1209.                     if (!strncmp(line, "DOMAIN_", 7)) {

  1210.                         float *vals = NULL;

  1211.                         if      (!strncmp(line + 7, "MIN ", 4)) vals = min;

  1212.                         else if (!strncmp(line + 7, "MAX ", 4)) vals = max;

  1213.                         if (!vals)

  1214.                             return AVERROR_INVALIDDATA;

  1215.                         av_sscanf(line + 11, "%f %f %f", vals, vals + 1, vals + 2);

  1216.                         av_log(ctx, AV_LOG_DEBUG, "min: %f %f %f | max: %f %f %f\n",

  1217.                                min[0], min[1], min[2], max[0], max[1], max[2]);

  1218.                         goto try_again;

  1219.                     } else if (!strncmp(line, "LUT_1D_INPUT_RANGE ", 19)) {

  1220.                         av_sscanf(line + 19, "%f %f", min, max);

  1221.                         min[1] = min[2] = min[0];

  1222.                         max[1] = max[2] = max[0];

  1223.                         goto try_again;

  1224.                     } else if (!strncmp(line, "TITLE", 5)) {

  1225.                         goto try_again;

  1226.                     }

  1227.                 } while (skip_line(line));

  1228.                 if (av_sscanf(line, "%f %f %f", &lut1d->lut[0][i], &lut1d->lut[1][i], &lut1d->lut[2][i]) != 3)

  1229.                     return AVERROR_INVALIDDATA;

  1230.                 lut1d->lut[0][i] *= max[0] - min[0];

  1231.                 lut1d->lut[1][i] *= max[1] - min[1];

  1232.                 lut1d->lut[2][i] *= max[2] - min[2];

  1233.             }

  1234.             break;

  1235.         }

  1236.     }

  1237.     return 0;

  1238. }

  1239. 

  1240. static const AVOption lut1d_options[] = {

  1241.     { "file", "set 1D LUT file name", OFFSET(file), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },

  1242.     { "interp", "select interpolation mode", OFFSET(interpolation),    AV_OPT_TYPE_INT, {.i64=INTERPOLATE_1D_LINEAR}, 0, NB_INTERP_1D_MODE-1, FLAGS, "interp_mode" },

  1243.         { "nearest", "use values from the nearest defined points", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_NEAREST},   INT_MIN, INT_MAX, FLAGS, "interp_mode" },

  1244.         { "linear",  "use values from the linear interpolation",   0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_LINEAR},    INT_MIN, INT_MAX, FLAGS, "interp_mode" },

  1245.         { "cosine",  "use values from the cosine interpolation",   0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_COSINE},    INT_MIN, INT_MAX, FLAGS, "interp_mode" },

  1246.         { "cubic",   "use values from the cubic interpolation",    0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_CUBIC},     INT_MIN, INT_MAX, FLAGS, "interp_mode" },

  1247.         { "spline",  "use values from the spline interpolation",   0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_SPLINE},    INT_MIN, INT_MAX, FLAGS, "interp_mode" },

  1248.     { NULL }

  1249. };

  1250. 

  1251. AVFILTER_DEFINE_CLASS(lut1d);

  1252. 

  1253. static inline float interp_1d_nearest(const LUT1DContext *lut1d,

  1254.                                       int idx, const float s)

  1255. {

  1256.     return lut1d->lut[idx][NEAR(s)];

  1257. }

  1258. 

  1259. #define NEXT1D(x) (FFMIN((int)(x) + 1, lut1d->lutsize - 1))

  1260. 

  1261. static inline float interp_1d_linear(const LUT1DContext *lut1d,

  1262.                                      int idx, const float s)

  1263. {

  1264.     const int prev = PREV(s);

  1265.     const int next = NEXT1D(s);

  1266.     const float d = s - prev;

  1267.     const float p = lut1d->lut[idx][prev];

  1268.     const float n = lut1d->lut[idx][next];

  1269. 

  1270.     return lerpf(p, n, d);

  1271. }

  1272. 

  1273. static inline float interp_1d_cosine(const LUT1DContext *lut1d,

  1274.                                      int idx, const float s)

  1275. {

  1276.     const int prev = PREV(s);

  1277.     const int next = NEXT1D(s);

  1278.     const float d = s - prev;

  1279.     const float p = lut1d->lut[idx][prev];

  1280.     const float n = lut1d->lut[idx][next];

  1281.     const float m = (1.f - cosf(d * M_PI)) * .5f;

  1282. 

  1283.     return lerpf(p, n, m);

  1284. }

  1285. 

  1286. static inline float interp_1d_cubic(const LUT1DContext *lut1d,

  1287.                                     int idx, const float s)

  1288. {

  1289.     const int prev = PREV(s);

  1290.     const int next = NEXT1D(s);

  1291.     const float mu = s - prev;

  1292.     float a0, a1, a2, a3, mu2;

  1293. 

  1294.     float y0 = lut1d->lut[idx][FFMAX(prev - 1, 0)];

  1295.     float y1 = lut1d->lut[idx][prev];

  1296.     float y2 = lut1d->lut[idx][next];

  1297.     float y3 = lut1d->lut[idx][FFMIN(next + 1, lut1d->lutsize - 1)];

  1298. 

  1299. 

  1300.     mu2 = mu * mu;

  1301.     a0 = y3 - y2 - y0 + y1;

  1302.     a1 = y0 - y1 - a0;

  1303.     a2 = y2 - y0;

  1304.     a3 = y1;

  1305. 

  1306.     return a0 * mu * mu2 + a1 * mu2 + a2 * mu + a3;

  1307. }

  1308. 

  1309. static inline float interp_1d_spline(const LUT1DContext *lut1d,

  1310.                                      int idx, const float s)

  1311. {

  1312.     const int prev = PREV(s);

  1313.     const int next = NEXT1D(s);

  1314.     const float x = s - prev;

  1315.     float c0, c1, c2, c3;

  1316. 

  1317.     float y0 = lut1d->lut[idx][FFMAX(prev - 1, 0)];

  1318.     float y1 = lut1d->lut[idx][prev];

  1319.     float y2 = lut1d->lut[idx][next];

  1320.     float y3 = lut1d->lut[idx][FFMIN(next + 1, lut1d->lutsize - 1)];

  1321. 

  1322.     c0 = y1;

  1323.     c1 = .5f * (y2 - y0);

  1324.     c2 = y0 - 2.5f * y1 + 2.f * y2 - .5f * y3;

  1325.     c3 = .5f * (y3 - y0) + 1.5f * (y1 - y2);

  1326. 

  1327.     return ((c3 * x + c2) * x + c1) * x + c0;

  1328. }

  1329. 

  1330. #define DEFINE_INTERP_FUNC_PLANAR_1D(name, nbits, depth)                     \

  1331. static int interp_1d_##nbits##_##name##_p##depth(AVFilterContext *ctx,       \

  1332.                                                  void *arg, int jobnr,       \

  1333.                                                  int nb_jobs)                \

  1334. {                                                                            \

  1335.     int x, y;                                                                \

  1336.     const LUT1DContext *lut1d = ctx->priv;                                   \

  1337.     const ThreadData *td = arg;                                              \

  1338.     const AVFrame *in  = td->in;                                             \

  1339.     const AVFrame *out = td->out;                                            \

  1340.     const int direct = out == in;                                            \

  1341.     const int slice_start = (in->height *  jobnr   ) / nb_jobs;              \

  1342.     const int slice_end   = (in->height * (jobnr+1)) / nb_jobs;              \

  1343.     uint8_t *grow = out->data[0] + slice_start * out->linesize[0];           \

  1344.     uint8_t *brow = out->data[1] + slice_start * out->linesize[1];           \

  1345.     uint8_t *rrow = out->data[2] + slice_start * out->linesize[2];           \

  1346.     uint8_t *arow = out->data[3] + slice_start * out->linesize[3];           \

  1347.     const uint8_t *srcgrow = in->data[0] + slice_start * in->linesize[0];    \

  1348.     const uint8_t *srcbrow = in->data[1] + slice_start * in->linesize[1];    \

  1349.     const uint8_t *srcrrow = in->data[2] + slice_start * in->linesize[2];    \

  1350.     const uint8_t *srcarow = in->data[3] + slice_start * in->linesize[3];    \

  1351.     const float factor = (1 << depth) - 1;                                   \

  1352.     const float scale = (1. / factor) * (lut1d->lutsize - 1);                \

  1353.                                                                              \

  1354.     for (y = slice_start; y < slice_end; y++) {                              \

  1355.         uint##nbits##_t *dstg = (uint##nbits##_t *)grow;                     \

  1356.         uint##nbits##_t *dstb = (uint##nbits##_t *)brow;                     \

  1357.         uint##nbits##_t *dstr = (uint##nbits##_t *)rrow;                     \

  1358.         uint##nbits##_t *dsta = (uint##nbits##_t *)arow;                     \

  1359.         const uint##nbits##_t *srcg = (const uint##nbits##_t *)srcgrow;      \

  1360.         const uint##nbits##_t *srcb = (const uint##nbits##_t *)srcbrow;      \

  1361.         const uint##nbits##_t *srcr = (const uint##nbits##_t *)srcrrow;      \

  1362.         const uint##nbits##_t *srca = (const uint##nbits##_t *)srcarow;      \

  1363.         for (x = 0; x < in->width; x++) {                                    \

  1364.             float r = srcr[x] * scale;                                       \

  1365.             float g = srcg[x] * scale;                                       \

  1366.             float b = srcb[x] * scale;                                       \

  1367.             r = interp_1d_##name(lut1d, 0, r);                               \

  1368.             g = interp_1d_##name(lut1d, 1, g);                               \

  1369.             b = interp_1d_##name(lut1d, 2, b);                               \

  1370.             dstr[x] = av_clip_uintp2(r * factor, depth);                     \

  1371.             dstg[x] = av_clip_uintp2(g * factor, depth);                     \

  1372.             dstb[x] = av_clip_uintp2(b * factor, depth);                     \

  1373.             if (!direct && in->linesize[3])                                  \

  1374.                 dsta[x] = srca[x];                                           \

  1375.         }                                                                    \

  1376.         grow += out->linesize[0];                                            \

  1377.         brow += out->linesize[1];                                            \

  1378.         rrow += out->linesize[2];                                            \

  1379.         arow += out->linesize[3];                                            \

  1380.         srcgrow += in->linesize[0];                                          \

  1381.         srcbrow += in->linesize[1];                                          \

  1382.         srcrrow += in->linesize[2];                                          \

  1383.         srcarow += in->linesize[3];                                          \

  1384.     }                                                                        \

  1385.     return 0;                                                                \

  1386. }

  1387. 

  1388. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     8, 8)

  1389. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      8, 8)

  1390. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      8, 8)

  1391. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       8, 8)

  1392. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      8, 8)

  1393. 

  1394. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 9)

  1395. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 9)

  1396. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 9)

  1397. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 9)

  1398. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 9)

  1399. 

  1400. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 10)

  1401. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 10)

  1402. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 10)

  1403. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 10)

  1404. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 10)

  1405. 

  1406. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 12)

  1407. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 12)

  1408. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 12)

  1409. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 12)

  1410. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 12)

  1411. 

  1412. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 14)

  1413. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 14)

  1414. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 14)

  1415. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 14)

  1416. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 14)

  1417. 

  1418. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 16)

  1419. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 16)

  1420. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 16)

  1421. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 16)

  1422. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 16)

  1423. 

  1424. #define DEFINE_INTERP_FUNC_1D(name, nbits)                                   \

  1425. static int interp_1d_##nbits##_##name(AVFilterContext *ctx, void *arg,       \

  1426.                                       int jobnr, int nb_jobs)                \

  1427. {                                                                            \

  1428.     int x, y;                                                                \

  1429.     const LUT1DContext *lut1d = ctx->priv;                                   \

  1430.     const ThreadData *td = arg;                                              \

  1431.     const AVFrame *in  = td->in;                                             \

  1432.     const AVFrame *out = td->out;                                            \

  1433.     const int direct = out == in;                                            \

  1434.     const int step = lut1d->step;                                            \

  1435.     const uint8_t r = lut1d->rgba_map[R];                                    \

  1436.     const uint8_t g = lut1d->rgba_map[G];                                    \

  1437.     const uint8_t b = lut1d->rgba_map[B];                                    \

  1438.     const uint8_t a = lut1d->rgba_map[A];                                    \

  1439.     const int slice_start = (in->height *  jobnr   ) / nb_jobs;              \

  1440.     const int slice_end   = (in->height * (jobnr+1)) / nb_jobs;              \

  1441.     uint8_t       *dstrow = out->data[0] + slice_start * out->linesize[0];   \

  1442.     const uint8_t *srcrow = in ->data[0] + slice_start * in ->linesize[0];   \

  1443.     const float factor = (1 << nbits) - 1;                                   \

  1444.     const float scale = (1. / factor) * (lut1d->lutsize - 1);                \

  1445.                                                                              \

  1446.     for (y = slice_start; y < slice_end; y++) {                              \

  1447.         uint##nbits##_t *dst = (uint##nbits##_t *)dstrow;                    \

  1448.         const uint##nbits##_t *src = (const uint##nbits##_t *)srcrow;        \

  1449.         for (x = 0; x < in->width * step; x += step) {                       \

  1450.             float rr = src[x + r] * scale;                                   \

  1451.             float gg = src[x + g] * scale;                                   \

  1452.             float bb = src[x + b] * scale;                                   \

  1453.             rr = interp_1d_##name(lut1d, 0, rr);                             \

  1454.             gg = interp_1d_##name(lut1d, 1, gg);                             \

  1455.             bb = interp_1d_##name(lut1d, 2, bb);                             \

  1456.             dst[x + r] = av_clip_uint##nbits(rr * factor);                   \

  1457.             dst[x + g] = av_clip_uint##nbits(gg * factor);                   \

  1458.             dst[x + b] = av_clip_uint##nbits(bb * factor);                   \

  1459.             if (!direct && step == 4)                                        \

  1460.                 dst[x + a] = src[x + a];                                     \

  1461.         }                                                                    \

  1462.         dstrow += out->linesize[0];                                          \

  1463.         srcrow += in ->linesize[0];                                          \

  1464.     }                                                                        \

  1465.     return 0;                                                                \

  1466. }

  1467. 

  1468. DEFINE_INTERP_FUNC_1D(nearest,     8)

  1469. DEFINE_INTERP_FUNC_1D(linear,      8)

  1470. DEFINE_INTERP_FUNC_1D(cosine,      8)

  1471. DEFINE_INTERP_FUNC_1D(cubic,       8)

  1472. DEFINE_INTERP_FUNC_1D(spline,      8)

  1473. 

  1474. DEFINE_INTERP_FUNC_1D(nearest,     16)

  1475. DEFINE_INTERP_FUNC_1D(linear,      16)

  1476. DEFINE_INTERP_FUNC_1D(cosine,      16)

  1477. DEFINE_INTERP_FUNC_1D(cubic,       16)

  1478. DEFINE_INTERP_FUNC_1D(spline,      16)

  1479. 

  1480. static int config_input_1d(AVFilterLink *inlink)

  1481. {

  1482.     int depth, is16bit = 0, planar = 0;

  1483.     LUT1DContext *lut1d = inlink->dst->priv;

  1484.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

  1485. 

  1486.     depth = desc->comp[0].depth;

  1487. 

  1488.     switch (inlink->format) {

  1489.     case AV_PIX_FMT_RGB48:

  1490.     case AV_PIX_FMT_BGR48:

  1491.     case AV_PIX_FMT_RGBA64:

  1492.     case AV_PIX_FMT_BGRA64:

  1493.         is16bit = 1;

  1494.         break;

  1495.     case AV_PIX_FMT_GBRP9:

  1496.     case AV_PIX_FMT_GBRP10:

  1497.     case AV_PIX_FMT_GBRP12:

  1498.     case AV_PIX_FMT_GBRP14:

  1499.     case AV_PIX_FMT_GBRP16:

  1500.     case AV_PIX_FMT_GBRAP10:

  1501.     case AV_PIX_FMT_GBRAP12:

  1502.     case AV_PIX_FMT_GBRAP16:

  1503.         is16bit = 1;

  1504.     case AV_PIX_FMT_GBRP:

  1505.     case AV_PIX_FMT_GBRAP:

  1506.         planar = 1;

  1507.         break;

  1508.     }

  1509. 

  1510.     ff_fill_rgba_map(lut1d->rgba_map, inlink->format);

  1511.     lut1d->step = av_get_padded_bits_per_pixel(desc) >> (3 + is16bit);

  1512. 

  1513. #define SET_FUNC_1D(name) do {                                     \

  1514.     if (planar) {                                                  \

  1515.         switch (depth) {                                           \

  1516.         case  8: lut1d->interp = interp_1d_8_##name##_p8;   break; \

  1517.         case  9: lut1d->interp = interp_1d_16_##name##_p9;  break; \

  1518.         case 10: lut1d->interp = interp_1d_16_##name##_p10; break; \

  1519.         case 12: lut1d->interp = interp_1d_16_##name##_p12; break; \

  1520.         case 14: lut1d->interp = interp_1d_16_##name##_p14; break; \

  1521.         case 16: lut1d->interp = interp_1d_16_##name##_p16; break; \

  1522.         }                                                          \

  1523.     } else if (is16bit) { lut1d->interp = interp_1d_16_##name;     \

  1524.     } else {              lut1d->interp = interp_1d_8_##name; }    \

  1525. } while (0)

  1526. 

  1527.     switch (lut1d->interpolation) {

  1528.     case INTERPOLATE_1D_NEAREST:     SET_FUNC_1D(nearest);  break;

  1529.     case INTERPOLATE_1D_LINEAR:      SET_FUNC_1D(linear);   break;

  1530.     case INTERPOLATE_1D_COSINE:      SET_FUNC_1D(cosine);   break;

  1531.     case INTERPOLATE_1D_CUBIC:       SET_FUNC_1D(cubic);    break;

  1532.     case INTERPOLATE_1D_SPLINE:      SET_FUNC_1D(spline);   break;

  1533.     default:

  1534.         av_assert0(0);

  1535.     }

  1536. 

  1537.     return 0;

  1538. }

  1539. 

  1540. static av_cold int lut1d_init(AVFilterContext *ctx)

  1541. {

  1542.     int ret;

  1543.     FILE *f;

  1544.     const char *ext;

  1545.     LUT1DContext *lut1d = ctx->priv;

  1546. 

  1547.     if (!lut1d->file) {

  1548.         set_identity_matrix_1d(lut1d, 32);

  1549.         return 0;

  1550.     }

  1551. 

  1552.     f = fopen(lut1d->file, "r");

  1553.     if (!f) {

  1554.         ret = AVERROR(errno);

  1555.         av_log(ctx, AV_LOG_ERROR, "%s: %s\n", lut1d->file, av_err2str(ret));

  1556.         return ret;

  1557.     }

  1558. 

  1559.     ext = strrchr(lut1d->file, '.');

  1560.     if (!ext) {

  1561.         av_log(ctx, AV_LOG_ERROR, "Unable to guess the format from the extension\n");

  1562.         ret = AVERROR_INVALIDDATA;

  1563.         goto end;

  1564.     }

  1565.     ext++;

  1566. 

  1567.     if (!av_strcasecmp(ext, "cube") || !av_strcasecmp(ext, "1dlut")) {

  1568.         ret = parse_cube_1d(ctx, f);

  1569.     } else if (!av_strcasecmp(ext, "csp")) {

  1570.         ret = parse_cinespace_1d(ctx, f);

  1571.     } else {

  1572.         av_log(ctx, AV_LOG_ERROR, "Unrecognized '.%s' file type\n", ext);

  1573.         ret = AVERROR(EINVAL);

  1574.     }

  1575. 

  1576.     if (!ret && !lut1d->lutsize) {

  1577.         av_log(ctx, AV_LOG_ERROR, "1D LUT is empty\n");

  1578.         ret = AVERROR_INVALIDDATA;

  1579.     }

  1580. 

  1581. end:

  1582.     fclose(f);

  1583.     return ret;

  1584. }

  1585. 

  1586. static AVFrame *apply_1d_lut(AVFilterLink *inlink, AVFrame *in)

  1587. {

  1588.     AVFilterContext *ctx = inlink->dst;

  1589.     LUT1DContext *lut1d = ctx->priv;

  1590.     AVFilterLink *outlink = inlink->dst->outputs[0];

  1591.     AVFrame *out;

  1592.     ThreadData td;

  1593. 

  1594.     if (av_frame_is_writable(in)) {

  1595.         out = in;

  1596.     } else {

  1597.         out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

  1598.         if (!out) {

  1599.             av_frame_free(&in);

  1600.             return NULL;

  1601.         }

  1602.         av_frame_copy_props(out, in);

  1603.     }

  1604. 

  1605.     td.in  = in;

  1606.     td.out = out;

  1607.     ctx->internal->execute(ctx, lut1d->interp, &td, NULL, FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));

  1608. 

  1609.     if (out != in)

  1610.         av_frame_free(&in);

  1611. 

  1612.     return out;

  1613. }

  1614. 

  1615. static int filter_frame_1d(AVFilterLink *inlink, AVFrame *in)

  1616. {

  1617.     AVFilterLink *outlink = inlink->dst->outputs[0];

  1618.     AVFrame *out = apply_1d_lut(inlink, in);

  1619.     if (!out)

  1620.         return AVERROR(ENOMEM);

  1621.     return ff_filter_frame(outlink, out);

  1622. }

  1623. 

  1624. static const AVFilterPad lut1d_inputs[] = {

  1625.     {

  1626.         .name         = "default",

  1627.         .type         = AVMEDIA_TYPE_VIDEO,

  1628.         .filter_frame = filter_frame_1d,

  1629.         .config_props = config_input_1d,

  1630.     },

  1631.     { NULL }

  1632. };

  1633. 

  1634. static const AVFilterPad lut1d_outputs[] = {

  1635.     {

  1636.         .name = "default",

  1637.         .type = AVMEDIA_TYPE_VIDEO,

  1638.     },

  1639.     { NULL }

  1640. };

  1641. 

  1642. AVFilter ff_vf_lut1d = {

  1643.     .name          = "lut1d",

  1644.     .description   = NULL_IF_CONFIG_SMALL("Adjust colors using a 1D LUT."),

  1645.     .priv_size     = sizeof(LUT1DContext),

  1646.     .init          = lut1d_init,

  1647.     .query_formats = query_formats,

  1648.     .inputs        = lut1d_inputs,

  1649.     .outputs       = lut1d_outputs,

  1650.     .priv_class    = &lut1d_class,

  1651.     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

  1652. };

  1653. #endif