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

589 lines
22KB
Raw Blame History 

  1. /*

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

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2.1 of the License, or (at your option) any later version.

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with FFmpeg; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. /**

  22.  * @file

  23.  * 3D Lookup table filter

  24.  */

  25. 

  26. #include "libavutil/opt.h"

  27. #include "libavutil/file.h"

  28. #include "libavutil/intreadwrite.h"

  29. #include "libavutil/avassert.h"

  30. #include "libavutil/pixdesc.h"

  31. #include "libavutil/avstring.h"

  32. #include "avfilter.h"

  33. #include "drawutils.h"

  34. #include "formats.h"

  35. #include "internal.h"

  36. #include "video.h"

  37. 

  38. #define R 0

  39. #define G 1

  40. #define B 2

  41. #define A 3

  42. 

  43. enum interp_mode {

  44.     INTERPOLATE_NEAREST,

  45.     INTERPOLATE_TRILINEAR,

  46.     INTERPOLATE_TETRAHEDRAL,

  47.     NB_INTERP_MODE

  48. };

  49. 

  50. struct rgbvec {

  51.     float r, g, b;

  52. };

  53. 

  54. #define MAX_LEVEL 36

  55. 

  56. typedef struct LUT3DContext {

  57.     const AVClass *class;

  58.     enum interp_mode interpolation;

  59.     char *file;

  60.     uint8_t rgba_map[4];

  61.     int step;

  62.     int is16bit;

  63.     struct rgbvec (*interp_8) (const struct LUT3DContext*, uint8_t,  uint8_t,  uint8_t);

  64.     struct rgbvec (*interp_16)(const struct LUT3DContext*, uint16_t, uint16_t, uint16_t);

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

  66.     int lutsize;

  67. } LUT3DContext;

  68. 

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

  70. #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

  71. static const AVOption lut3d_options[] = {

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

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

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

  75.         { "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" },

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

  77.     { NULL }

  78. };

  79. 

  80. AVFILTER_DEFINE_CLASS(lut3d);

  81. 

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

  83. {

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

  85. }

  86. 

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

  88. {

  89.     struct rgbvec v = {

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

  91.     };

  92.     return v;

  93. }

  94. 

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

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

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

  98. 

  99. /**

  100.  * Get the nearest defined point

  101.  */

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

  103.                                            const struct rgbvec *s)

  104. {

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

  106. }

  107. 

  108. /**

  109.  * Interpolate using the 8 vertices of a cube

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

  111.  */

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

  113.                                              const struct rgbvec *s)

  114. {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  133.     return c;

  134. }

  135. 

  136. /**

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

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

  139.  */

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

  141.                                                const struct rgbvec *s)

  142. {

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

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

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

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

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

  148.     struct rgbvec c;

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

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

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

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

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

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

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

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

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

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

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

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

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

  162.         } else {

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

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

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

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

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

  168.         }

  169.     } else {

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

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

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

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

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

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

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

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

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

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

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

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

  182.         } else {

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

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

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

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

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

  188.         }

  189.     }

  190.     return c;

  191. }

  192. 

  193. #define DEFINE_INTERP_FUNC(name, nbits)                                     \

  194. static struct rgbvec interp_##nbits##_##name(const LUT3DContext *lut3d,     \

  195.                                              uint##nbits##_t r,             \

  196.                                              uint##nbits##_t g,             \

  197.                                              uint##nbits##_t b)             \

  198. {                                                                           \

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

  200.     const struct rgbvec scaled_rgb = {r * scale, g * scale, b * scale};     \

  201.     return interp_##name(lut3d, &scaled_rgb);                               \

  202. }

  203. 

  204. DEFINE_INTERP_FUNC(nearest,     8)

  205. DEFINE_INTERP_FUNC(trilinear,   8)

  206. DEFINE_INTERP_FUNC(tetrahedral, 8)

  207. 

  208. DEFINE_INTERP_FUNC(nearest,     16)

  209. DEFINE_INTERP_FUNC(trilinear,   16)

  210. DEFINE_INTERP_FUNC(tetrahedral, 16)

  211. 

  212. #define MAX_LINE_SIZE 512

  213. 

  214. static int skip_line(const char *p)

  215. {

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

  217.         p++;

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

  219. }

  220. 

  221. #define NEXT_LINE(loop_cond) do {                           \

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

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

  224.         return AVERROR_INVALIDDATA;                         \

  225.     }                                                       \

  226. } while (loop_cond)

  227. 

  228. /* Basically r g and b float values on each line; seems to be generated by

  229.  * Davinci */

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

  231. {

  232.     LUT3DContext *lut3d = ctx->priv;

  233.     const int size = lut3d->lutsize;

  234.     int i, j, k;

  235. 

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

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

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

  239.                 char line[MAX_LINE_SIZE];

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

  241.                 NEXT_LINE(skip_line(line));

  242.                 sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b);

  243.             }

  244.         }

  245.     }

  246.     return 0;

  247. }

  248. 

  249. /* Iridas format */

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

  251. {

  252.     LUT3DContext *lut3d = ctx->priv;

  253.     char line[MAX_LINE_SIZE];

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

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

  256. 

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

  258.         if (!strncmp(line, "LUT_3D_SIZE ", 12)) {

  259.             int i, j, k;

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

  261. 

  262.             if (size > MAX_LEVEL) {

  263.                 av_log(ctx, AV_LOG_ERROR, "Too large 3D LUT\n");

  264.                 return AVERROR(EINVAL);

  265.             }

  266.             lut3d->lutsize = size;

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

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

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

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

  271. 

  272.                         do {

  273.                             NEXT_LINE(0);

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

  275.                                 float *vals = NULL;

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

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

  278.                                 if (!vals)

  279.                                     return AVERROR_INVALIDDATA;

  280.                                 sscanf(line + 11, "%f %f %f", vals, vals + 1, vals + 2);

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

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

  283.                                 continue;

  284.                             }

  285.                         } while (skip_line(line));

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

  287.                             return AVERROR_INVALIDDATA;

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

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

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

  291.                     }

  292.                 }

  293.             }

  294.             break;

  295.         }

  296.     }

  297.     return 0;

  298. }

  299. 

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

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

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

  303. {

  304.     char line[MAX_LINE_SIZE];

  305.     LUT3DContext *lut3d = ctx->priv;

  306.     int i, j, k;

  307.     const int size = 17;

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

  309. 

  310.     lut3d->lutsize = size;

  311.     if (!fgets(line, sizeof(line), f))

  312.         return AVERROR_INVALIDDATA;

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

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

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

  316.                 int r, g, b;

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

  318. 

  319.                 NEXT_LINE(skip_line(line));

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

  321.                     return AVERROR_INVALIDDATA;

  322.                 vec->r = r / scale;

  323.                 vec->g = g / scale;

  324.                 vec->b = b / scale;

  325.             }

  326.         }

  327.     }

  328.     return 0;

  329. }

  330. 

  331. /* Pandora format */

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

  333. {

  334.     LUT3DContext *lut3d = ctx->priv;

  335.     float scale;

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

  337.     char line[MAX_LINE_SIZE];

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

  339. 

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

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

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

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

  344.             const char *p = line + 6;

  345. #define SET_COLOR(id) do {                  \

  346.     while (av_isspace(*p))                  \

  347.         p++;                                \

  348.     switch (*p) {                           \

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

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

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

  352.     }                                       \

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

  354.         p++;                                \

  355. } while (0)

  356.             SET_COLOR(0);

  357.             SET_COLOR(1);

  358.             SET_COLOR(2);

  359.             break;

  360.         }

  361.     }

  362. 

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

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

  365.         return AVERROR_INVALIDDATA;

  366.     }

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

  368.     lut3d->lutsize = size;

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

  370. 

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

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

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

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

  375.                 float val[3];

  376. 

  377.                 NEXT_LINE(0);

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

  379.                     return AVERROR_INVALIDDATA;

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

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

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

  383.             }

  384.         }

  385.     }

  386.     return 0;

  387. }

  388. 

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

  390. {

  391.     int i, j, k;

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

  393. 

  394.     lut3d->lutsize = size;

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

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

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

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

  399.                 vec->r = k * c;

  400.                 vec->g = j * c;

  401.                 vec->b = i * c;

  402.             }

  403.         }

  404.     }

  405. }

  406. 

  407. static av_cold int init(AVFilterContext *ctx)

  408. {

  409.     int ret;

  410.     FILE *f;

  411.     const char *ext;

  412.     LUT3DContext *lut3d = ctx->priv;

  413. 

  414.     if (!lut3d->file) {

  415.         set_identity_matrix(lut3d, 32);

  416.         return 0;

  417.     }

  418. 

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

  420.     if (!f) {

  421.         ret = AVERROR(errno);

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

  423.         return ret;

  424.     }

  425. 

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

  427.     if (!ext) {

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

  429.         ret = AVERROR_INVALIDDATA;

  430.         goto end;

  431.     }

  432.     ext++;

  433. 

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

  435.         lut3d->lutsize = 33;

  436.         ret = parse_dat(ctx, f);

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

  438.         ret = parse_3dl(ctx, f);

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

  440.         ret = parse_cube(ctx, f);

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

  442.         ret = parse_m3d(ctx, f);

  443.     } else {

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

  445.         ret = AVERROR(EINVAL);

  446.     }

  447. 

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

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

  450.         ret = AVERROR_INVALIDDATA;

  451.     }

  452. 

  453. end:

  454.     fclose(f);

  455.     return ret;

  456. }

  457. 

  458. static int query_formats(AVFilterContext *ctx)

  459. {

  460.     static const enum AVPixelFormat pix_fmts[] = {

  461.         AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,

  462.         AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,

  463.         AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,

  464.         AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,

  465.         AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,

  466.         AV_PIX_FMT_RGB48,  AV_PIX_FMT_BGR48,

  467.         AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,

  468.         AV_PIX_FMT_NONE

  469.     };

  470.     ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));

  471.     return 0;

  472. }

  473. 

  474. static int config_input(AVFilterLink *inlink)

  475. {

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

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

  478. 

  479.     switch (inlink->format) {

  480.     case AV_PIX_FMT_RGB48:

  481.     case AV_PIX_FMT_BGR48:

  482.     case AV_PIX_FMT_RGBA64:

  483.     case AV_PIX_FMT_BGRA64:

  484.         lut3d->is16bit = 1;

  485.     }

  486. 

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

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

  489. 

  490. #define SET_FUNC(name) do {                                     \

  491.     if (lut3d->is16bit) lut3d->interp_16 = interp_16_##name;    \

  492.     else                lut3d->interp_8  = interp_8_##name;     \

  493. } while (0)

  494. 

  495.     switch (lut3d->interpolation) {

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

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

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

  499.     default:

  500.         av_assert0(0);

  501.     }

  502. 

  503.     return 0;

  504. }

  505. 

  506. #define FILTER(nbits) do {                                                                          \

  507.     uint8_t       *dstrow = out->data[0];                                                           \

  508.     const uint8_t *srcrow = in ->data[0];                                                           \

  509.                                                                                                     \

  510.     for (y = 0; y < inlink->h; y++) {                                                               \

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

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

  513.         for (x = 0; x < inlink->w * step; x += step) {                                              \

  514.             struct rgbvec vec = lut3d->interp_##nbits(lut3d, src[x + r], src[x + g], src[x + b]);   \

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

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

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

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

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

  520.         }                                                                                           \

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

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

  523.     }                                                                                               \

  524. } while (0)

  525. 

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

  527. {

  528.     int x, y, direct = 0;

  529.     AVFilterContext *ctx = inlink->dst;

  530.     LUT3DContext *lut3d = ctx->priv;

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

  532.     AVFrame *out;

  533.     const int step = lut3d->step;

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

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

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

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

  538. 

  539.     if (av_frame_is_writable(in)) {

  540.         direct = 1;

  541.         out = in;

  542.     } else {

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

  544.         if (!out) {

  545.             av_frame_free(&in);

  546.             return AVERROR(ENOMEM);

  547.         }

  548.         av_frame_copy_props(out, in);

  549.     }

  550. 

  551.     if (lut3d->is16bit) FILTER(16);

  552.     else                FILTER(8);

  553. 

  554.     if (!direct)

  555.         av_frame_free(&in);

  556. 

  557.     return ff_filter_frame(outlink, out);

  558. }

  559. 

  560. static const AVFilterPad lut3d_inputs[] = {

  561.     {

  562.         .name         = "default",

  563.         .type         = AVMEDIA_TYPE_VIDEO,

  564.         .filter_frame = filter_frame,

  565.         .config_props = config_input,

  566.     },

  567.     { NULL }

  568. };

  569. 

  570. static const AVFilterPad lut3d_outputs[] = {

  571.      {

  572.          .name = "default",

  573.          .type = AVMEDIA_TYPE_VIDEO,

  574.      },

  575.      { NULL }

  576. };

  577. 

  578. AVFilter avfilter_vf_lut3d = {

  579.     .name          = "lut3d",

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

  581.     .priv_size     = sizeof(LUT3DContext),

  582.     .init          = init,

  583.     .query_formats = query_formats,

  584.     .inputs        = lut3d_inputs,

  585.     .outputs       = lut3d_outputs,

  586.     .priv_class    = &lut3d_class,

  587.     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

  588. };