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.
92466 Commits
32 Branches
428MB
Tree: f951036d32
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f951036d32'
${ noResults }
FFmpeg/libavfilter/vf_lut3d.c

1486 lines
60KB
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 void set_identity_matrix(LUT3DContext *lut3d, int size)

  527. {

  528.     int i, j, k;

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

  530. 

  531.     lut3d->lutsize = size;

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

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

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

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

  536.                 vec->r = k * c;

  537.                 vec->g = j * c;

  538.                 vec->b = i * c;

  539.             }

  540.         }

  541.     }

  542. }

  543. 

  544. static int query_formats(AVFilterContext *ctx)

  545. {

  546.     static const enum AVPixelFormat pix_fmts[] = {

  547.         AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,

  548.         AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,

  549.         AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,

  550.         AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,

  551.         AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,

  552.         AV_PIX_FMT_RGB48,  AV_PIX_FMT_BGR48,

  553.         AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,

  554.         AV_PIX_FMT_GBRP,   AV_PIX_FMT_GBRAP,

  555.         AV_PIX_FMT_GBRP9,

  556.         AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,

  557.         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,

  558.         AV_PIX_FMT_GBRP14,

  559.         AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,

  560.         AV_PIX_FMT_NONE

  561.     };

  562.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  563.     if (!fmts_list)

  564.         return AVERROR(ENOMEM);

  565.     return ff_set_common_formats(ctx, fmts_list);

  566. }

  567. 

  568. static int config_input(AVFilterLink *inlink)

  569. {

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

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

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

  573. 

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

  575. 

  576.     switch (inlink->format) {

  577.     case AV_PIX_FMT_RGB48:

  578.     case AV_PIX_FMT_BGR48:

  579.     case AV_PIX_FMT_RGBA64:

  580.     case AV_PIX_FMT_BGRA64:

  581.         is16bit = 1;

  582.         break;

  583.     case AV_PIX_FMT_GBRP9:

  584.     case AV_PIX_FMT_GBRP10:

  585.     case AV_PIX_FMT_GBRP12:

  586.     case AV_PIX_FMT_GBRP14:

  587.     case AV_PIX_FMT_GBRP16:

  588.     case AV_PIX_FMT_GBRAP10:

  589.     case AV_PIX_FMT_GBRAP12:

  590.     case AV_PIX_FMT_GBRAP16:

  591.         is16bit = 1;

  592.     case AV_PIX_FMT_GBRP:

  593.     case AV_PIX_FMT_GBRAP:

  594.         planar = 1;

  595.         break;

  596.     }

  597. 

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

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

  600. 

  601. #define SET_FUNC(name) do {                                     \

  602.     if (planar) {                                               \

  603.         switch (depth) {                                        \

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

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

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

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

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

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

  610.         }                                                       \

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

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

  613. } while (0)

  614. 

  615.     switch (lut3d->interpolation) {

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

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

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

  619.     default:

  620.         av_assert0(0);

  621.     }

  622. 

  623.     return 0;

  624. }

  625. 

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

  627. {

  628.     AVFilterContext *ctx = inlink->dst;

  629.     LUT3DContext *lut3d = ctx->priv;

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

  631.     AVFrame *out;

  632.     ThreadData td;

  633. 

  634.     if (av_frame_is_writable(in)) {

  635.         out = in;

  636.     } else {

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

  638.         if (!out) {

  639.             av_frame_free(&in);

  640.             return NULL;

  641.         }

  642.         av_frame_copy_props(out, in);

  643.     }

  644. 

  645.     td.in  = in;

  646.     td.out = out;

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

  648. 

  649.     if (out != in)

  650.         av_frame_free(&in);

  651. 

  652.     return out;

  653. }

  654. 

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

  656. {

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

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

  659.     if (!out)

  660.         return AVERROR(ENOMEM);

  661.     return ff_filter_frame(outlink, out);

  662. }

  663. 

  664. #if CONFIG_LUT3D_FILTER

  665. static const AVOption lut3d_options[] = {

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

  667.     COMMON_OPTIONS

  668. };

  669. 

  670. AVFILTER_DEFINE_CLASS(lut3d);

  671. 

  672. static av_cold int lut3d_init(AVFilterContext *ctx)

  673. {

  674.     int ret;

  675.     FILE *f;

  676.     const char *ext;

  677.     LUT3DContext *lut3d = ctx->priv;

  678. 

  679.     if (!lut3d->file) {

  680.         set_identity_matrix(lut3d, 32);

  681.         return 0;

  682.     }

  683. 

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

  685.     if (!f) {

  686.         ret = AVERROR(errno);

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

  688.         return ret;

  689.     }

  690. 

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

  692.     if (!ext) {

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

  694.         ret = AVERROR_INVALIDDATA;

  695.         goto end;

  696.     }

  697.     ext++;

  698. 

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

  700.         ret = parse_dat(ctx, f);

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

  702.         ret = parse_3dl(ctx, f);

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

  704.         ret = parse_cube(ctx, f);

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

  706.         ret = parse_m3d(ctx, f);

  707.     } else {

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

  709.         ret = AVERROR(EINVAL);

  710.     }

  711. 

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

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

  714.         ret = AVERROR_INVALIDDATA;

  715.     }

  716. 

  717. end:

  718.     fclose(f);

  719.     return ret;

  720. }

  721. 

  722. static const AVFilterPad lut3d_inputs[] = {

  723.     {

  724.         .name         = "default",

  725.         .type         = AVMEDIA_TYPE_VIDEO,

  726.         .filter_frame = filter_frame,

  727.         .config_props = config_input,

  728.     },

  729.     { NULL }

  730. };

  731. 

  732. static const AVFilterPad lut3d_outputs[] = {

  733.     {

  734.         .name = "default",

  735.         .type = AVMEDIA_TYPE_VIDEO,

  736.     },

  737.     { NULL }

  738. };

  739. 

  740. AVFilter ff_vf_lut3d = {

  741.     .name          = "lut3d",

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

  743.     .priv_size     = sizeof(LUT3DContext),

  744.     .init          = lut3d_init,

  745.     .query_formats = query_formats,

  746.     .inputs        = lut3d_inputs,

  747.     .outputs       = lut3d_outputs,

  748.     .priv_class    = &lut3d_class,

  749.     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

  750. };

  751. #endif

  752. 

  753. #if CONFIG_HALDCLUT_FILTER

  754. 

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

  756. {

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

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

  759.     const int w = lut3d->clut_width;

  760.     const int step = lut3d->clut_step;

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

  762.     const int level = lut3d->lutsize;

  763. 

  764. #define LOAD_CLUT(nbits) do {                                           \

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

  766.                                                                         \

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

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

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

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

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

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

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

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

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

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

  777.                     x = 0;                                              \

  778.                     y++;                                                \

  779.                 }                                                       \

  780.             }                                                           \

  781.         }                                                               \

  782.     }                                                                   \

  783. } while (0)

  784. 

  785.     switch (lut3d->clut_bits) {

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

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

  788.     }

  789. }

  790. 

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

  792. {

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

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

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

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

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

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

  799.     const int w = lut3d->clut_width;

  800.     const int level = lut3d->lutsize;

  801. 

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

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

  804.                                                                         \

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

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

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

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

  809.                     (datag + y*glinesize);                              \

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

  811.                     (datab + y*blinesize);                              \

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

  813.                     (datar + y*rlinesize);                              \

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

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

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

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

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

  819.                     x = 0;                                              \

  820.                     y++;                                                \

  821.                 }                                                       \

  822.             }                                                           \

  823.         }                                                               \

  824.     }                                                                   \

  825. } while (0)

  826. 

  827.     switch (lut3d->clut_bits) {

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

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

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

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

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

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

  834.     }

  835. }

  836. 

  837. static int config_output(AVFilterLink *outlink)

  838. {

  839.     AVFilterContext *ctx = outlink->src;

  840.     LUT3DContext *lut3d = ctx->priv;

  841.     int ret;

  842. 

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

  844.     if (ret < 0)

  845.         return ret;

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

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

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

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

  850.         return ret;

  851.     return 0;

  852. }

  853. 

  854. static int activate(AVFilterContext *ctx)

  855. {

  856.     LUT3DContext *s = ctx->priv;

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

  858. }

  859. 

  860. static int config_clut(AVFilterLink *inlink)

  861. {

  862.     int size, level, w, h;

  863.     AVFilterContext *ctx = inlink->dst;

  864.     LUT3DContext *lut3d = ctx->priv;

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

  866. 

  867.     av_assert0(desc);

  868. 

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

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

  871. 

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

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

  874. 

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

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

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

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

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

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

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

  882. 

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

  884.     size = level*level*level;

  885.     if (size != w) {

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

  887.         return AVERROR_INVALIDDATA;

  888.     }

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

  890.     level *= level;

  891.     if (level > MAX_LEVEL) {

  892.         const int max_clut_level = sqrt(MAX_LEVEL);

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

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

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

  896.                max_clut_level, max_clut_size, max_clut_size);

  897.         return AVERROR(EINVAL);

  898.     }

  899.     lut3d->lutsize = level;

  900. 

  901.     return 0;

  902. }

  903. 

  904. static int update_apply_clut(FFFrameSync *fs)

  905. {

  906.     AVFilterContext *ctx = fs->parent;

  907.     LUT3DContext *lut3d = ctx->priv;

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

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

  910.     int ret;

  911. 

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

  913.     if (ret < 0)

  914.         return ret;

  915.     if (!second)

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

  917.     if (lut3d->clut_planar)

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

  919.     else

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

  921.     out = apply_lut(inlink, master);

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

  923. }

  924. 

  925. static av_cold int haldclut_init(AVFilterContext *ctx)

  926. {

  927.     LUT3DContext *lut3d = ctx->priv;

  928.     lut3d->fs.on_event = update_apply_clut;

  929.     return 0;

  930. }

  931. 

  932. static av_cold void haldclut_uninit(AVFilterContext *ctx)

  933. {

  934.     LUT3DContext *lut3d = ctx->priv;

  935.     ff_framesync_uninit(&lut3d->fs);

  936. }

  937. 

  938. static const AVOption haldclut_options[] = {

  939.     COMMON_OPTIONS

  940. };

  941. 

  942. FRAMESYNC_DEFINE_CLASS(haldclut, LUT3DContext, fs);

  943. 

  944. static const AVFilterPad haldclut_inputs[] = {

  945.     {

  946.         .name         = "main",

  947.         .type         = AVMEDIA_TYPE_VIDEO,

  948.         .config_props = config_input,

  949.     },{

  950.         .name         = "clut",

  951.         .type         = AVMEDIA_TYPE_VIDEO,

  952.         .config_props = config_clut,

  953.     },

  954.     { NULL }

  955. };

  956. 

  957. static const AVFilterPad haldclut_outputs[] = {

  958.     {

  959.         .name          = "default",

  960.         .type          = AVMEDIA_TYPE_VIDEO,

  961.         .config_props  = config_output,

  962.     },

  963.     { NULL }

  964. };

  965. 

  966. AVFilter ff_vf_haldclut = {

  967.     .name          = "haldclut",

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

  969.     .priv_size     = sizeof(LUT3DContext),

  970.     .preinit       = haldclut_framesync_preinit,

  971.     .init          = haldclut_init,

  972.     .uninit        = haldclut_uninit,

  973.     .query_formats = query_formats,

  974.     .activate      = activate,

  975.     .inputs        = haldclut_inputs,

  976.     .outputs       = haldclut_outputs,

  977.     .priv_class    = &haldclut_class,

  978.     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,

  979. };

  980. #endif

  981. 

  982. #if CONFIG_LUT1D_FILTER

  983. 

  984. enum interp_1d_mode {

  985.     INTERPOLATE_1D_NEAREST,

  986.     INTERPOLATE_1D_LINEAR,

  987.     INTERPOLATE_1D_CUBIC,

  988.     INTERPOLATE_1D_COSINE,

  989.     INTERPOLATE_1D_SPLINE,

  990.     NB_INTERP_1D_MODE

  991. };

  992. 

  993. #define MAX_1D_LEVEL 65536

  994. 

  995. typedef struct LUT1DContext {

  996.     const AVClass *class;

  997.     char *file;

  998.     int interpolation;          ///<interp_1d_mode

  999.     uint8_t rgba_map[4];

  1000.     int step;

  1001.     float lut[3][MAX_1D_LEVEL];

  1002.     int lutsize;

  1003.     avfilter_action_func *interp;

  1004. } LUT1DContext;

  1005. 

  1006. #undef OFFSET

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

  1008. 

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

  1010. {

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

  1012.     int i;

  1013. 

  1014.     lut1d->lutsize = size;

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

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

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

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

  1019.     }

  1020. }

  1021. 

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

  1023. {

  1024.     LUT1DContext *lut1d = ctx->priv;

  1025.     char line[MAX_LINE_SIZE];

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

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

  1028. 

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

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

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

  1032.             int i;

  1033. 

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

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

  1036.                 return AVERROR(EINVAL);

  1037.             }

  1038.             lut1d->lutsize = size;

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

  1040.                 do {

  1041. try_again:

  1042.                     NEXT_LINE(0);

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

  1044.                         float *vals = NULL;

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

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

  1047.                         if (!vals)

  1048.                             return AVERROR_INVALIDDATA;

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

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

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

  1052.                         goto try_again;

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

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

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

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

  1057.                         goto try_again;

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

  1059.                         goto try_again;

  1060.                     }

  1061.                 } while (skip_line(line));

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

  1063.                     return AVERROR_INVALIDDATA;

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

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

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

  1067.             }

  1068.             break;

  1069.         }

  1070.     }

  1071.     return 0;

  1072. }

  1073. 

  1074. static const AVOption lut1d_options[] = {

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

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

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

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

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

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

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

  1082.     { NULL }

  1083. };

  1084. 

  1085. AVFILTER_DEFINE_CLASS(lut1d);

  1086. 

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

  1088.                                       int idx, const float s)

  1089. {

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

  1091. }

  1092. 

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

  1094. 

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

  1096.                                      int idx, const float s)

  1097. {

  1098.     const int prev = PREV(s);

  1099.     const int next = NEXT1D(s);

  1100.     const float d = s - prev;

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

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

  1103. 

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

  1105. }

  1106. 

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

  1108.                                      int idx, const float s)

  1109. {

  1110.     const int prev = PREV(s);

  1111.     const int next = NEXT1D(s);

  1112.     const float d = s - prev;

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

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

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

  1116. 

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

  1118. }

  1119. 

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

  1121.                                     int idx, const float s)

  1122. {

  1123.     const int prev = PREV(s);

  1124.     const int next = NEXT1D(s);

  1125.     const float mu = s - prev;

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

  1127. 

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

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

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

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

  1132. 

  1133. 

  1134.     mu2 = mu * mu;

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

  1136.     a1 = y0 - y1 - a0;

  1137.     a2 = y2 - y0;

  1138.     a3 = y1;

  1139. 

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

  1141. }

  1142. 

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

  1144.                                      int idx, const float s)

  1145. {

  1146.     const int prev = PREV(s);

  1147.     const int next = NEXT1D(s);

  1148.     const float x = s - prev;

  1149.     float c0, c1, c2, c3;

  1150. 

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

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

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

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

  1155. 

  1156.     c0 = y1;

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

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

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

  1160. 

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

  1162. }

  1163. 

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

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

  1166.                                                  void *arg, int jobnr,       \

  1167.                                                  int nb_jobs)                \

  1168. {                                                                            \

  1169.     int x, y;                                                                \

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

  1171.     const ThreadData *td = arg;                                              \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1187.                                                                              \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1209.         }                                                                    \

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

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

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

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

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

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

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

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

  1218.     }                                                                        \

  1219.     return 0;                                                                \

  1220. }

  1221. 

  1222. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     8, 8)

  1223. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      8, 8)

  1224. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      8, 8)

  1225. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       8, 8)

  1226. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      8, 8)

  1227. 

  1228. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 9)

  1229. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 9)

  1230. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 9)

  1231. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 9)

  1232. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 9)

  1233. 

  1234. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 10)

  1235. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 10)

  1236. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 10)

  1237. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 10)

  1238. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 10)

  1239. 

  1240. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 12)

  1241. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 12)

  1242. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 12)

  1243. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 12)

  1244. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 12)

  1245. 

  1246. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 14)

  1247. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 14)

  1248. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 14)

  1249. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 14)

  1250. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 14)

  1251. 

  1252. DEFINE_INTERP_FUNC_PLANAR_1D(nearest,     16, 16)

  1253. DEFINE_INTERP_FUNC_PLANAR_1D(linear,      16, 16)

  1254. DEFINE_INTERP_FUNC_PLANAR_1D(cosine,      16, 16)

  1255. DEFINE_INTERP_FUNC_PLANAR_1D(cubic,       16, 16)

  1256. DEFINE_INTERP_FUNC_PLANAR_1D(spline,      16, 16)

  1257. 

  1258. #define DEFINE_INTERP_FUNC_1D(name, nbits)                                   \

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

  1260.                                       int jobnr, int nb_jobs)                \

  1261. {                                                                            \

  1262.     int x, y;                                                                \

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

  1264.     const ThreadData *td = arg;                                              \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1279.                                                                              \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1295.         }                                                                    \

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

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

  1298.     }                                                                        \

  1299.     return 0;                                                                \

  1300. }

  1301. 

  1302. DEFINE_INTERP_FUNC_1D(nearest,     8)

  1303. DEFINE_INTERP_FUNC_1D(linear,      8)

  1304. DEFINE_INTERP_FUNC_1D(cosine,      8)

  1305. DEFINE_INTERP_FUNC_1D(cubic,       8)

  1306. DEFINE_INTERP_FUNC_1D(spline,      8)

  1307. 

  1308. DEFINE_INTERP_FUNC_1D(nearest,     16)

  1309. DEFINE_INTERP_FUNC_1D(linear,      16)

  1310. DEFINE_INTERP_FUNC_1D(cosine,      16)

  1311. DEFINE_INTERP_FUNC_1D(cubic,       16)

  1312. DEFINE_INTERP_FUNC_1D(spline,      16)

  1313. 

  1314. static int config_input_1d(AVFilterLink *inlink)

  1315. {

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

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

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

  1319. 

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

  1321. 

  1322.     switch (inlink->format) {

  1323.     case AV_PIX_FMT_RGB48:

  1324.     case AV_PIX_FMT_BGR48:

  1325.     case AV_PIX_FMT_RGBA64:

  1326.     case AV_PIX_FMT_BGRA64:

  1327.         is16bit = 1;

  1328.         break;

  1329.     case AV_PIX_FMT_GBRP9:

  1330.     case AV_PIX_FMT_GBRP10:

  1331.     case AV_PIX_FMT_GBRP12:

  1332.     case AV_PIX_FMT_GBRP14:

  1333.     case AV_PIX_FMT_GBRP16:

  1334.     case AV_PIX_FMT_GBRAP10:

  1335.     case AV_PIX_FMT_GBRAP12:

  1336.     case AV_PIX_FMT_GBRAP16:

  1337.         is16bit = 1;

  1338.     case AV_PIX_FMT_GBRP:

  1339.     case AV_PIX_FMT_GBRAP:

  1340.         planar = 1;

  1341.         break;

  1342.     }

  1343. 

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

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

  1346. 

  1347. #define SET_FUNC_1D(name) do {                                     \

  1348.     if (planar) {                                                  \

  1349.         switch (depth) {                                           \

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

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

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

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

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

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

  1356.         }                                                          \

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

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

  1359. } while (0)

  1360. 

  1361.     switch (lut1d->interpolation) {

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

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

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

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

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

  1367.     default:

  1368.         av_assert0(0);

  1369.     }

  1370. 

  1371.     return 0;

  1372. }

  1373. 

  1374. static av_cold int lut1d_init(AVFilterContext *ctx)

  1375. {

  1376.     int ret;

  1377.     FILE *f;

  1378.     const char *ext;

  1379.     LUT1DContext *lut1d = ctx->priv;

  1380. 

  1381.     if (!lut1d->file) {

  1382.         set_identity_matrix_1d(lut1d, 32);

  1383.         return 0;

  1384.     }

  1385. 

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

  1387.     if (!f) {

  1388.         ret = AVERROR(errno);

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

  1390.         return ret;

  1391.     }

  1392. 

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

  1394.     if (!ext) {

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

  1396.         ret = AVERROR_INVALIDDATA;

  1397.         goto end;

  1398.     }

  1399.     ext++;

  1400. 

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

  1402.         ret = parse_cube_1d(ctx, f);

  1403.     } else {

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

  1405.         ret = AVERROR(EINVAL);

  1406.     }

  1407. 

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

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

  1410.         ret = AVERROR_INVALIDDATA;

  1411.     }

  1412. 

  1413. end:

  1414.     fclose(f);

  1415.     return ret;

  1416. }

  1417. 

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

  1419. {

  1420.     AVFilterContext *ctx = inlink->dst;

  1421.     LUT1DContext *lut1d = ctx->priv;

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

  1423.     AVFrame *out;

  1424.     ThreadData td;

  1425. 

  1426.     if (av_frame_is_writable(in)) {

  1427.         out = in;

  1428.     } else {

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

  1430.         if (!out) {

  1431.             av_frame_free(&in);

  1432.             return NULL;

  1433.         }

  1434.         av_frame_copy_props(out, in);

  1435.     }

  1436. 

  1437.     td.in  = in;

  1438.     td.out = out;

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

  1440. 

  1441.     if (out != in)

  1442.         av_frame_free(&in);

  1443. 

  1444.     return out;

  1445. }

  1446. 

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

  1448. {

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

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

  1451.     if (!out)

  1452.         return AVERROR(ENOMEM);

  1453.     return ff_filter_frame(outlink, out);

  1454. }

  1455. 

  1456. static const AVFilterPad lut1d_inputs[] = {

  1457.     {

  1458.         .name         = "default",

  1459.         .type         = AVMEDIA_TYPE_VIDEO,

  1460.         .filter_frame = filter_frame_1d,

  1461.         .config_props = config_input_1d,

  1462.     },

  1463.     { NULL }

  1464. };

  1465. 

  1466. static const AVFilterPad lut1d_outputs[] = {

  1467.     {

  1468.         .name = "default",

  1469.         .type = AVMEDIA_TYPE_VIDEO,

  1470.     },

  1471.     { NULL }

  1472. };

  1473. 

  1474. AVFilter ff_vf_lut1d = {

  1475.     .name          = "lut1d",

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

  1477.     .priv_size     = sizeof(LUT1DContext),

  1478.     .init          = lut1d_init,

  1479.     .query_formats = query_formats,

  1480.     .inputs        = lut1d_inputs,

  1481.     .outputs       = lut1d_outputs,

  1482.     .priv_class    = &lut1d_class,

  1483.     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

  1484. };

  1485. #endif