avformat/mpegts: fix memory leak with merge_pmt_versions=1
[ffmpeg.git] / libavfilter / vf_paletteuse.c
1 /*
2  * Copyright (c) 2015 Stupeflix
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  * Use a palette to downsample an input video stream.
24  */
25
26 #include "libavutil/bprint.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/qsort.h"
29 #include "dualinput.h"
30 #include "avfilter.h"
31
32 enum dithering_mode {
33     DITHERING_NONE,
34     DITHERING_BAYER,
35     DITHERING_HECKBERT,
36     DITHERING_FLOYD_STEINBERG,
37     DITHERING_SIERRA2,
38     DITHERING_SIERRA2_4A,
39     NB_DITHERING
40 };
41
42 enum color_search_method {
43     COLOR_SEARCH_NNS_ITERATIVE,
44     COLOR_SEARCH_NNS_RECURSIVE,
45     COLOR_SEARCH_BRUTEFORCE,
46     NB_COLOR_SEARCHES
47 };
48
49 enum diff_mode {
50     DIFF_MODE_NONE,
51     DIFF_MODE_RECTANGLE,
52     NB_DIFF_MODE
53 };
54
55 struct color_node {
56     uint8_t val[3];
57     uint8_t palette_id;
58     int split;
59     int left_id, right_id;
60 };
61
62 #define NBITS 5
63 #define CACHE_SIZE (1<<(3*NBITS))
64
65 struct cached_color {
66     uint32_t color;
67     uint8_t pal_entry;
68 };
69
70 struct cache_node {
71     struct cached_color *entries;
72     int nb_entries;
73 };
74
75 struct PaletteUseContext;
76
77 typedef int (*set_frame_func)(struct PaletteUseContext *s, AVFrame *out, AVFrame *in,
78                               int x_start, int y_start, int width, int height);
79
80 typedef struct PaletteUseContext {
81     const AVClass *class;
82     FFDualInputContext dinput;
83     struct cache_node cache[CACHE_SIZE];    /* lookup cache */
84     struct color_node map[AVPALETTE_COUNT]; /* 3D-Tree (KD-Tree with K=3) for reverse colormap */
85     uint32_t palette[AVPALETTE_COUNT];
86     int palette_loaded;
87     int dither;
88     set_frame_func set_frame;
89     int bayer_scale;
90     int ordered_dither[8*8];
91     int diff_mode;
92     AVFrame *last_in;
93     AVFrame *last_out;
94
95     /* debug options */
96     char *dot_filename;
97     int color_search_method;
98     int calc_mean_err;
99     uint64_t total_mean_err;
100     int debug_accuracy;
101 } PaletteUseContext;
102
103 #define OFFSET(x) offsetof(PaletteUseContext, x)
104 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
105 static const AVOption paletteuse_options[] = {
106     { "dither", "select dithering mode", OFFSET(dither), AV_OPT_TYPE_INT, {.i64=DITHERING_SIERRA2_4A}, 0, NB_DITHERING-1, FLAGS, "dithering_mode" },
107         { "bayer",           "ordered 8x8 bayer dithering (deterministic)",                            0, AV_OPT_TYPE_CONST, {.i64=DITHERING_BAYER},           INT_MIN, INT_MAX, FLAGS, "dithering_mode" },
108         { "heckbert",        "dithering as defined by Paul Heckbert in 1982 (simple error diffusion)", 0, AV_OPT_TYPE_CONST, {.i64=DITHERING_HECKBERT},        INT_MIN, INT_MAX, FLAGS, "dithering_mode" },
109         { "floyd_steinberg", "Floyd and Steingberg dithering (error diffusion)",                       0, AV_OPT_TYPE_CONST, {.i64=DITHERING_FLOYD_STEINBERG}, INT_MIN, INT_MAX, FLAGS, "dithering_mode" },
110         { "sierra2",         "Frankie Sierra dithering v2 (error diffusion)",                          0, AV_OPT_TYPE_CONST, {.i64=DITHERING_SIERRA2},         INT_MIN, INT_MAX, FLAGS, "dithering_mode" },
111         { "sierra2_4a",      "Frankie Sierra dithering v2 \"Lite\" (error diffusion)",                 0, AV_OPT_TYPE_CONST, {.i64=DITHERING_SIERRA2_4A},      INT_MIN, INT_MAX, FLAGS, "dithering_mode" },
112     { "bayer_scale", "set scale for bayer dithering", OFFSET(bayer_scale), AV_OPT_TYPE_INT, {.i64=2}, 0, 5, FLAGS },
113     { "diff_mode",   "set frame difference mode",     OFFSET(diff_mode),   AV_OPT_TYPE_INT, {.i64=DIFF_MODE_NONE}, 0, NB_DIFF_MODE-1, FLAGS, "diff_mode" },
114         { "rectangle", "process smallest different rectangle", 0, AV_OPT_TYPE_CONST, {.i64=DIFF_MODE_RECTANGLE}, INT_MIN, INT_MAX, FLAGS, "diff_mode" },
115
116     /* following are the debug options, not part of the official API */
117     { "debug_kdtree", "save Graphviz graph of the kdtree in specified file", OFFSET(dot_filename), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, FLAGS },
118     { "color_search", "set reverse colormap color search method", OFFSET(color_search_method), AV_OPT_TYPE_INT, {.i64=COLOR_SEARCH_NNS_ITERATIVE}, 0, NB_COLOR_SEARCHES-1, FLAGS, "search" },
119         { "nns_iterative", "iterative search",             0, AV_OPT_TYPE_CONST, {.i64=COLOR_SEARCH_NNS_ITERATIVE}, INT_MIN, INT_MAX, FLAGS, "search" },
120         { "nns_recursive", "recursive search",             0, AV_OPT_TYPE_CONST, {.i64=COLOR_SEARCH_NNS_RECURSIVE}, INT_MIN, INT_MAX, FLAGS, "search" },
121         { "bruteforce",    "brute-force into the palette", 0, AV_OPT_TYPE_CONST, {.i64=COLOR_SEARCH_BRUTEFORCE},    INT_MIN, INT_MAX, FLAGS, "search" },
122     { "mean_err", "compute and print mean error", OFFSET(calc_mean_err), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS },
123     { "debug_accuracy", "test color search accuracy", OFFSET(debug_accuracy), AV_OPT_TYPE_FLAGS, {.i64=0}, 0, 1, FLAGS },
124     { NULL }
125 };
126
127 AVFILTER_DEFINE_CLASS(paletteuse);
128
129 static int query_formats(AVFilterContext *ctx)
130 {
131     static const enum AVPixelFormat in_fmts[]    = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
132     static const enum AVPixelFormat inpal_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
133     static const enum AVPixelFormat out_fmts[]   = {AV_PIX_FMT_PAL8,  AV_PIX_FMT_NONE};
134     AVFilterFormats *in    = ff_make_format_list(in_fmts);
135     AVFilterFormats *inpal = ff_make_format_list(inpal_fmts);
136     AVFilterFormats *out   = ff_make_format_list(out_fmts);
137     if (!in || !inpal || !out) {
138         av_freep(&in);
139         av_freep(&inpal);
140         av_freep(&out);
141         return AVERROR(ENOMEM);
142     }
143     ff_formats_ref(in,    &ctx->inputs[0]->out_formats);
144     ff_formats_ref(inpal, &ctx->inputs[1]->out_formats);
145     ff_formats_ref(out,   &ctx->outputs[0]->in_formats);
146     return 0;
147 }
148
149 static av_always_inline int dither_color(uint32_t px, int er, int eg, int eb, int scale, int shift)
150 {
151     return av_clip_uint8((px >> 16 & 0xff) + ((er * scale) / (1<<shift))) << 16
152          | av_clip_uint8((px >>  8 & 0xff) + ((eg * scale) / (1<<shift))) <<  8
153          | av_clip_uint8((px       & 0xff) + ((eb * scale) / (1<<shift)));
154 }
155
156 static av_always_inline int diff(const uint8_t *c1, const uint8_t *c2)
157 {
158     // XXX: try L*a*b with CIE76 (dL*dL + da*da + db*db)
159     const int dr = c1[0] - c2[0];
160     const int dg = c1[1] - c2[1];
161     const int db = c1[2] - c2[2];
162     return dr*dr + dg*dg + db*db;
163 }
164
165 static av_always_inline uint8_t colormap_nearest_bruteforce(const uint32_t *palette, const uint8_t *rgb)
166 {
167     int i, pal_id = -1, min_dist = INT_MAX;
168
169     for (i = 0; i < AVPALETTE_COUNT; i++) {
170         const uint32_t c = palette[i];
171
172         if ((c & 0xff000000) == 0xff000000) { // ignore transparent entry
173             const uint8_t palrgb[] = {
174                 palette[i]>>16 & 0xff,
175                 palette[i]>> 8 & 0xff,
176                 palette[i]     & 0xff,
177             };
178             const int d = diff(palrgb, rgb);
179             if (d < min_dist) {
180                 pal_id = i;
181                 min_dist = d;
182             }
183         }
184     }
185     return pal_id;
186 }
187
188 /* Recursive form, simpler but a bit slower. Kept for reference. */
189 struct nearest_color {
190     int node_pos;
191     int dist_sqd;
192 };
193
194 static void colormap_nearest_node(const struct color_node *map,
195                                   const int node_pos,
196                                   const uint8_t *target,
197                                   struct nearest_color *nearest)
198 {
199     const struct color_node *kd = map + node_pos;
200     const int s = kd->split;
201     int dx, nearer_kd_id, further_kd_id;
202     const uint8_t *current = kd->val;
203     const int current_to_target = diff(target, current);
204
205     if (current_to_target < nearest->dist_sqd) {
206         nearest->node_pos = node_pos;
207         nearest->dist_sqd = current_to_target;
208     }
209
210     if (kd->left_id != -1 || kd->right_id != -1) {
211         dx = target[s] - current[s];
212
213         if (dx <= 0) nearer_kd_id = kd->left_id,  further_kd_id = kd->right_id;
214         else         nearer_kd_id = kd->right_id, further_kd_id = kd->left_id;
215
216         if (nearer_kd_id != -1)
217             colormap_nearest_node(map, nearer_kd_id, target, nearest);
218
219         if (further_kd_id != -1 && dx*dx < nearest->dist_sqd)
220             colormap_nearest_node(map, further_kd_id, target, nearest);
221     }
222 }
223
224 static av_always_inline uint8_t colormap_nearest_recursive(const struct color_node *node, const uint8_t *rgb)
225 {
226     struct nearest_color res = {.dist_sqd = INT_MAX, .node_pos = -1};
227     colormap_nearest_node(node, 0, rgb, &res);
228     return node[res.node_pos].palette_id;
229 }
230
231 struct stack_node {
232     int color_id;
233     int dx2;
234 };
235
236 static av_always_inline uint8_t colormap_nearest_iterative(const struct color_node *root, const uint8_t *target)
237 {
238     int pos = 0, best_node_id = -1, best_dist = INT_MAX, cur_color_id = 0;
239     struct stack_node nodes[16];
240     struct stack_node *node = &nodes[0];
241
242     for (;;) {
243
244         const struct color_node *kd = &root[cur_color_id];
245         const uint8_t *current = kd->val;
246         const int current_to_target = diff(target, current);
247
248         /* Compare current color node to the target and update our best node if
249          * it's actually better. */
250         if (current_to_target < best_dist) {
251             best_node_id = cur_color_id;
252             if (!current_to_target)
253                 goto end; // exact match, we can return immediately
254             best_dist = current_to_target;
255         }
256
257         /* Check if it's not a leaf */
258         if (kd->left_id != -1 || kd->right_id != -1) {
259             const int split = kd->split;
260             const int dx = target[split] - current[split];
261             int nearer_kd_id, further_kd_id;
262
263             /* Define which side is the most interesting. */
264             if (dx <= 0) nearer_kd_id = kd->left_id,  further_kd_id = kd->right_id;
265             else         nearer_kd_id = kd->right_id, further_kd_id = kd->left_id;
266
267             if (nearer_kd_id != -1) {
268                 if (further_kd_id != -1) {
269                     /* Here, both paths are defined, so we push a state for
270                      * when we are going back. */
271                     node->color_id = further_kd_id;
272                     node->dx2 = dx*dx;
273                     pos++;
274                     node++;
275                 }
276                 /* We can now update current color with the most probable path
277                  * (no need to create a state since there is nothing to save
278                  * anymore). */
279                 cur_color_id = nearer_kd_id;
280                 continue;
281             } else if (dx*dx < best_dist) {
282                 /* The nearest path isn't available, so there is only one path
283                  * possible and it's the least probable. We enter it only if the
284                  * distance from the current point to the hyper rectangle is
285                  * less than our best distance. */
286                 cur_color_id = further_kd_id;
287                 continue;
288             }
289         }
290
291         /* Unstack as much as we can, typically as long as the least probable
292          * branch aren't actually probable. */
293         do {
294             if (--pos < 0)
295                 goto end;
296             node--;
297         } while (node->dx2 >= best_dist);
298
299         /* We got a node where the least probable branch might actually contain
300          * a relevant color. */
301         cur_color_id = node->color_id;
302     }
303
304 end:
305     return root[best_node_id].palette_id;
306 }
307
308 #define COLORMAP_NEAREST(search, palette, root, target)                                    \
309     search == COLOR_SEARCH_NNS_ITERATIVE ? colormap_nearest_iterative(root, target) :      \
310     search == COLOR_SEARCH_NNS_RECURSIVE ? colormap_nearest_recursive(root, target) :      \
311                                            colormap_nearest_bruteforce(palette, target)
312
313 /**
314  * Check if the requested color is in the cache already. If not, find it in the
315  * color tree and cache it.
316  * Note: r, g, and b are the component of c but are passed as well to avoid
317  * recomputing them (they are generally computed by the caller for other uses).
318  */
319 static av_always_inline uint8_t color_get(struct cache_node *cache, uint32_t color,
320                                           uint8_t r, uint8_t g, uint8_t b,
321                                           const struct color_node *map,
322                                           const uint32_t *palette,
323                                           const enum color_search_method search_method)
324 {
325     int i;
326     const uint8_t rgb[] = {r, g, b};
327     const uint8_t rhash = r & ((1<<NBITS)-1);
328     const uint8_t ghash = g & ((1<<NBITS)-1);
329     const uint8_t bhash = b & ((1<<NBITS)-1);
330     const unsigned hash = rhash<<(NBITS*2) | ghash<<NBITS | bhash;
331     struct cache_node *node = &cache[hash];
332     struct cached_color *e;
333
334     for (i = 0; i < node->nb_entries; i++) {
335         e = &node->entries[i];
336         if (e->color == color)
337             return e->pal_entry;
338     }
339
340     e = av_dynarray2_add((void**)&node->entries, &node->nb_entries,
341                          sizeof(*node->entries), NULL);
342     if (!e)
343         return AVERROR(ENOMEM);
344     e->color = color;
345     e->pal_entry = COLORMAP_NEAREST(search_method, palette, map, rgb);
346     return e->pal_entry;
347 }
348
349 static av_always_inline uint8_t get_dst_color_err(struct cache_node *cache,
350                                                   uint32_t c, const struct color_node *map,
351                                                   const uint32_t *palette,
352                                                   int *er, int *eg, int *eb,
353                                                   const enum color_search_method search_method)
354 {
355     const uint8_t r = c >> 16 & 0xff;
356     const uint8_t g = c >>  8 & 0xff;
357     const uint8_t b = c       & 0xff;
358     const uint8_t dstx = color_get(cache, c, r, g, b, map, palette, search_method);
359     const uint32_t dstc = palette[dstx];
360     *er = r - (dstc >> 16 & 0xff);
361     *eg = g - (dstc >>  8 & 0xff);
362     *eb = b - (dstc       & 0xff);
363     return dstx;
364 }
365
366 static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFrame *in,
367                                       int x_start, int y_start, int w, int h,
368                                       enum dithering_mode dither,
369                                       const enum color_search_method search_method)
370 {
371     int x, y;
372     const struct color_node *map = s->map;
373     struct cache_node *cache = s->cache;
374     const uint32_t *palette = s->palette;
375     const int src_linesize = in ->linesize[0] >> 2;
376     const int dst_linesize = out->linesize[0];
377     uint32_t *src = ((uint32_t *)in ->data[0]) + y_start*src_linesize;
378     uint8_t  *dst =              out->data[0]  + y_start*dst_linesize;
379
380     w += x_start;
381     h += y_start;
382
383     for (y = y_start; y < h; y++) {
384         for (x = x_start; x < w; x++) {
385             int er, eg, eb;
386
387             if (dither == DITHERING_BAYER) {
388                 const int d = s->ordered_dither[(y & 7)<<3 | (x & 7)];
389                 const uint8_t r8 = src[x] >> 16 & 0xff;
390                 const uint8_t g8 = src[x] >>  8 & 0xff;
391                 const uint8_t b8 = src[x]       & 0xff;
392                 const uint8_t r = av_clip_uint8(r8 + d);
393                 const uint8_t g = av_clip_uint8(g8 + d);
394                 const uint8_t b = av_clip_uint8(b8 + d);
395                 const uint32_t c = r<<16 | g<<8 | b;
396                 const int color = color_get(cache, c, r, g, b, map, palette, search_method);
397
398                 if (color < 0)
399                     return color;
400                 dst[x] = color;
401
402             } else if (dither == DITHERING_HECKBERT) {
403                 const int right = x < w - 1, down = y < h - 1;
404                 const int color = get_dst_color_err(cache, src[x], map, palette, &er, &eg, &eb, search_method);
405
406                 if (color < 0)
407                     return color;
408                 dst[x] = color;
409
410                 if (right)         src[               x + 1] = dither_color(src[               x + 1], er, eg, eb, 3, 3);
411                 if (         down) src[src_linesize + x    ] = dither_color(src[src_linesize + x    ], er, eg, eb, 3, 3);
412                 if (right && down) src[src_linesize + x + 1] = dither_color(src[src_linesize + x + 1], er, eg, eb, 2, 3);
413
414             } else if (dither == DITHERING_FLOYD_STEINBERG) {
415                 const int right = x < w - 1, down = y < h - 1, left = x > x_start;
416                 const int color = get_dst_color_err(cache, src[x], map, palette, &er, &eg, &eb, search_method);
417
418                 if (color < 0)
419                     return color;
420                 dst[x] = color;
421
422                 if (right)         src[               x + 1] = dither_color(src[               x + 1], er, eg, eb, 7, 4);
423                 if (left  && down) src[src_linesize + x - 1] = dither_color(src[src_linesize + x - 1], er, eg, eb, 3, 4);
424                 if (         down) src[src_linesize + x    ] = dither_color(src[src_linesize + x    ], er, eg, eb, 5, 4);
425                 if (right && down) src[src_linesize + x + 1] = dither_color(src[src_linesize + x + 1], er, eg, eb, 1, 4);
426
427             } else if (dither == DITHERING_SIERRA2) {
428                 const int right  = x < w - 1, down  = y < h - 1, left  = x > x_start;
429                 const int right2 = x < w - 2,                    left2 = x > x_start + 1;
430                 const int color = get_dst_color_err(cache, src[x], map, palette, &er, &eg, &eb, search_method);
431
432                 if (color < 0)
433                     return color;
434                 dst[x] = color;
435
436                 if (right)          src[                 x + 1] = dither_color(src[                 x + 1], er, eg, eb, 4, 4);
437                 if (right2)         src[                 x + 2] = dither_color(src[                 x + 2], er, eg, eb, 3, 4);
438
439                 if (down) {
440                     if (left2)      src[  src_linesize + x - 2] = dither_color(src[  src_linesize + x - 2], er, eg, eb, 1, 4);
441                     if (left)       src[  src_linesize + x - 1] = dither_color(src[  src_linesize + x - 1], er, eg, eb, 2, 4);
442                                     src[  src_linesize + x    ] = dither_color(src[  src_linesize + x    ], er, eg, eb, 3, 4);
443                     if (right)      src[  src_linesize + x + 1] = dither_color(src[  src_linesize + x + 1], er, eg, eb, 2, 4);
444                     if (right2)     src[  src_linesize + x + 2] = dither_color(src[  src_linesize + x + 2], er, eg, eb, 1, 4);
445                 }
446
447             } else if (dither == DITHERING_SIERRA2_4A) {
448                 const int right = x < w - 1, down = y < h - 1, left = x > x_start;
449                 const int color = get_dst_color_err(cache, src[x], map, palette, &er, &eg, &eb, search_method);
450
451                 if (color < 0)
452                     return color;
453                 dst[x] = color;
454
455                 if (right)         src[               x + 1] = dither_color(src[               x + 1], er, eg, eb, 2, 2);
456                 if (left  && down) src[src_linesize + x - 1] = dither_color(src[src_linesize + x - 1], er, eg, eb, 1, 2);
457                 if (         down) src[src_linesize + x    ] = dither_color(src[src_linesize + x    ], er, eg, eb, 1, 2);
458
459             } else {
460                 const uint8_t r = src[x] >> 16 & 0xff;
461                 const uint8_t g = src[x] >>  8 & 0xff;
462                 const uint8_t b = src[x]       & 0xff;
463                 const int color = color_get(cache, src[x] & 0xffffff, r, g, b, map, palette, search_method);
464
465                 if (color < 0)
466                     return color;
467                 dst[x] = color;
468             }
469         }
470         src += src_linesize;
471         dst += dst_linesize;
472     }
473     return 0;
474 }
475
476 #define INDENT 4
477 static void disp_node(AVBPrint *buf,
478                       const struct color_node *map,
479                       int parent_id, int node_id,
480                       int depth)
481 {
482     const struct color_node *node = &map[node_id];
483     const uint32_t fontcolor = node->val[0] > 0x50 &&
484                                node->val[1] > 0x50 &&
485                                node->val[2] > 0x50 ? 0 : 0xffffff;
486     av_bprintf(buf, "%*cnode%d ["
487                "label=\"%c%02X%c%02X%c%02X%c\" "
488                "fillcolor=\"#%02x%02x%02x\" "
489                "fontcolor=\"#%06X\"]\n",
490                depth*INDENT, ' ', node->palette_id,
491                "[  "[node->split], node->val[0],
492                "][ "[node->split], node->val[1],
493                " ]["[node->split], node->val[2],
494                "  ]"[node->split],
495                node->val[0], node->val[1], node->val[2],
496                fontcolor);
497     if (parent_id != -1)
498         av_bprintf(buf, "%*cnode%d -> node%d\n", depth*INDENT, ' ',
499                    map[parent_id].palette_id, node->palette_id);
500     if (node->left_id  != -1) disp_node(buf, map, node_id, node->left_id,  depth + 1);
501     if (node->right_id != -1) disp_node(buf, map, node_id, node->right_id, depth + 1);
502 }
503
504 // debug_kdtree=kdtree.dot -> dot -Tpng kdtree.dot > kdtree.png
505 static int disp_tree(const struct color_node *node, const char *fname)
506 {
507     AVBPrint buf;
508     FILE *f = av_fopen_utf8(fname, "w");
509
510     if (!f) {
511         int ret = AVERROR(errno);
512         av_log(NULL, AV_LOG_ERROR, "Cannot open file '%s' for writing: %s\n",
513                fname, av_err2str(ret));
514         return ret;
515     }
516
517     av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
518
519     av_bprintf(&buf, "digraph {\n");
520     av_bprintf(&buf, "    node [style=filled fontsize=10 shape=box]\n");
521     disp_node(&buf, node, -1, 0, 0);
522     av_bprintf(&buf, "}\n");
523
524     fwrite(buf.str, 1, buf.len, f);
525     fclose(f);
526     av_bprint_finalize(&buf, NULL);
527     return 0;
528 }
529
530 static int debug_accuracy(const struct color_node *node, const uint32_t *palette,
531                           const enum color_search_method search_method)
532 {
533     int r, g, b, ret = 0;
534
535     for (r = 0; r < 256; r++) {
536         for (g = 0; g < 256; g++) {
537             for (b = 0; b < 256; b++) {
538                 const uint8_t rgb[] = {r, g, b};
539                 const int r1 = COLORMAP_NEAREST(search_method, palette, node, rgb);
540                 const int r2 = colormap_nearest_bruteforce(palette, rgb);
541                 if (r1 != r2) {
542                     const uint32_t c1 = palette[r1];
543                     const uint32_t c2 = palette[r2];
544                     const uint8_t palrgb1[] = { c1>>16 & 0xff, c1>> 8 & 0xff, c1 & 0xff };
545                     const uint8_t palrgb2[] = { c2>>16 & 0xff, c2>> 8 & 0xff, c2 & 0xff };
546                     const int d1 = diff(palrgb1, rgb);
547                     const int d2 = diff(palrgb2, rgb);
548                     if (d1 != d2) {
549                         av_log(NULL, AV_LOG_ERROR,
550                                "/!\\ %02X%02X%02X: %d ! %d (%06X ! %06X) / dist: %d ! %d\n",
551                                r, g, b, r1, r2, c1 & 0xffffff, c2 & 0xffffff, d1, d2);
552                         ret = 1;
553                     }
554                 }
555             }
556         }
557     }
558     return ret;
559 }
560
561 struct color {
562     uint32_t value;
563     uint8_t pal_id;
564 };
565
566 struct color_rect {
567     uint8_t min[3];
568     uint8_t max[3];
569 };
570
571 typedef int (*cmp_func)(const void *, const void *);
572
573 #define DECLARE_CMP_FUNC(name, pos)                     \
574 static int cmp_##name(const void *pa, const void *pb)   \
575 {                                                       \
576     const struct color *a = pa;                         \
577     const struct color *b = pb;                         \
578     return   (a->value >> (8 * (2 - (pos))) & 0xff)     \
579            - (b->value >> (8 * (2 - (pos))) & 0xff);    \
580 }
581
582 DECLARE_CMP_FUNC(r, 0)
583 DECLARE_CMP_FUNC(g, 1)
584 DECLARE_CMP_FUNC(b, 2)
585
586 static const cmp_func cmp_funcs[] = {cmp_r, cmp_g, cmp_b};
587
588 static int get_next_color(const uint8_t *color_used, const uint32_t *palette,
589                           int *component, const struct color_rect *box)
590 {
591     int wr, wg, wb;
592     int i, longest = 0;
593     unsigned nb_color = 0;
594     struct color_rect ranges;
595     struct color tmp_pal[256];
596     cmp_func cmpf;
597
598     ranges.min[0] = ranges.min[1] = ranges.min[2] = 0xff;
599     ranges.max[0] = ranges.max[1] = ranges.max[2] = 0x00;
600
601     for (i = 0; i < AVPALETTE_COUNT; i++) {
602         const uint32_t c = palette[i];
603         const uint8_t r = c >> 16 & 0xff;
604         const uint8_t g = c >>  8 & 0xff;
605         const uint8_t b = c       & 0xff;
606
607         if (color_used[i] ||
608             r < box->min[0] || g < box->min[1] || b < box->min[2] ||
609             r > box->max[0] || g > box->max[1] || b > box->max[2])
610             continue;
611
612         if (r < ranges.min[0]) ranges.min[0] = r;
613         if (g < ranges.min[1]) ranges.min[1] = g;
614         if (b < ranges.min[2]) ranges.min[2] = b;
615
616         if (r > ranges.max[0]) ranges.max[0] = r;
617         if (g > ranges.max[1]) ranges.max[1] = g;
618         if (b > ranges.max[2]) ranges.max[2] = b;
619
620         tmp_pal[nb_color].value  = c;
621         tmp_pal[nb_color].pal_id = i;
622
623         nb_color++;
624     }
625
626     if (!nb_color)
627         return -1;
628
629     /* define longest axis that will be the split component */
630     wr = ranges.max[0] - ranges.min[0];
631     wg = ranges.max[1] - ranges.min[1];
632     wb = ranges.max[2] - ranges.min[2];
633     if (wr >= wg && wr >= wb) longest = 0;
634     if (wg >= wr && wg >= wb) longest = 1;
635     if (wb >= wr && wb >= wg) longest = 2;
636     cmpf = cmp_funcs[longest];
637     *component = longest;
638
639     /* sort along this axis to get median */
640     AV_QSORT(tmp_pal, nb_color, struct color, cmpf);
641
642     return tmp_pal[nb_color >> 1].pal_id;
643 }
644
645 static int colormap_insert(struct color_node *map,
646                            uint8_t *color_used,
647                            int *nb_used,
648                            const uint32_t *palette,
649                            const struct color_rect *box)
650 {
651     uint32_t c;
652     int component, cur_id;
653     int node_left_id = -1, node_right_id = -1;
654     struct color_node *node;
655     struct color_rect box1, box2;
656     const int pal_id = get_next_color(color_used, palette, &component, box);
657
658     if (pal_id < 0)
659         return -1;
660
661     /* create new node with that color */
662     cur_id = (*nb_used)++;
663     c = palette[pal_id];
664     node = &map[cur_id];
665     node->split = component;
666     node->palette_id = pal_id;
667     node->val[0] = c>>16 & 0xff;
668     node->val[1] = c>> 8 & 0xff;
669     node->val[2] = c     & 0xff;
670
671     color_used[pal_id] = 1;
672
673     /* get the two boxes this node creates */
674     box1 = box2 = *box;
675     box1.max[component] = node->val[component];
676     box2.min[component] = node->val[component] + 1;
677
678     node_left_id = colormap_insert(map, color_used, nb_used, palette, &box1);
679
680     if (box2.min[component] <= box2.max[component])
681         node_right_id = colormap_insert(map, color_used, nb_used, palette, &box2);
682
683     node->left_id  = node_left_id;
684     node->right_id = node_right_id;
685
686     return cur_id;
687 }
688
689 static int cmp_pal_entry(const void *a, const void *b)
690 {
691     const int c1 = *(const uint32_t *)a & 0xffffff;
692     const int c2 = *(const uint32_t *)b & 0xffffff;
693     return c1 - c2;
694 }
695
696 static void load_colormap(PaletteUseContext *s)
697 {
698     int i, nb_used = 0;
699     uint8_t color_used[AVPALETTE_COUNT] = {0};
700     uint32_t last_color = 0;
701     struct color_rect box;
702
703     /* disable transparent colors and dups */
704     qsort(s->palette, AVPALETTE_COUNT, sizeof(*s->palette), cmp_pal_entry);
705     for (i = 0; i < AVPALETTE_COUNT; i++) {
706         const uint32_t c = s->palette[i];
707         if (i != 0 && c == last_color) {
708             color_used[i] = 1;
709             continue;
710         }
711         last_color = c;
712         if ((c & 0xff000000) != 0xff000000) {
713             color_used[i] = 1; // ignore transparent color(s)
714             continue;
715         }
716     }
717
718     box.min[0] = box.min[1] = box.min[2] = 0x00;
719     box.max[0] = box.max[1] = box.max[2] = 0xff;
720
721     colormap_insert(s->map, color_used, &nb_used, s->palette, &box);
722
723     if (s->dot_filename)
724         disp_tree(s->map, s->dot_filename);
725
726     if (s->debug_accuracy) {
727         if (!debug_accuracy(s->map, s->palette, s->color_search_method))
728             av_log(NULL, AV_LOG_INFO, "Accuracy check passed\n");
729     }
730 }
731
732 static void debug_mean_error(PaletteUseContext *s, const AVFrame *in1,
733                              const AVFrame *in2, int frame_count)
734 {
735     int x, y;
736     const uint32_t *palette = s->palette;
737     uint32_t *src1 = (uint32_t *)in1->data[0];
738     uint8_t  *src2 =             in2->data[0];
739     const int src1_linesize = in1->linesize[0] >> 2;
740     const int src2_linesize = in2->linesize[0];
741     const float div = in1->width * in1->height * 3;
742     unsigned mean_err = 0;
743
744     for (y = 0; y < in1->height; y++) {
745         for (x = 0; x < in1->width; x++) {
746             const uint32_t c1 = src1[x];
747             const uint32_t c2 = palette[src2[x]];
748             const uint8_t rgb1[] = {c1 >> 16 & 0xff, c1 >> 8 & 0xff, c1 & 0xff};
749             const uint8_t rgb2[] = {c2 >> 16 & 0xff, c2 >> 8 & 0xff, c2 & 0xff};
750             mean_err += diff(rgb1, rgb2);
751         }
752         src1 += src1_linesize;
753         src2 += src2_linesize;
754     }
755
756     s->total_mean_err += mean_err;
757
758     av_log(NULL, AV_LOG_INFO, "MEP:%.3f TotalMEP:%.3f\n",
759            mean_err / div, s->total_mean_err / (div * frame_count));
760 }
761
762 static void set_processing_window(enum diff_mode diff_mode,
763                                   const AVFrame *prv_src, const AVFrame *cur_src,
764                                   const AVFrame *prv_dst,       AVFrame *cur_dst,
765                                   int *xp, int *yp, int *wp, int *hp)
766 {
767     int x_start = 0, y_start = 0;
768     int width  = cur_src->width;
769     int height = cur_src->height;
770
771     if (prv_src && diff_mode == DIFF_MODE_RECTANGLE) {
772         int y;
773         int x_end = cur_src->width  - 1,
774             y_end = cur_src->height - 1;
775         const uint32_t *prv_srcp = (const uint32_t *)prv_src->data[0];
776         const uint32_t *cur_srcp = (const uint32_t *)cur_src->data[0];
777         const uint8_t  *prv_dstp = prv_dst->data[0];
778         uint8_t        *cur_dstp = cur_dst->data[0];
779
780         const int prv_src_linesize = prv_src->linesize[0] >> 2;
781         const int cur_src_linesize = cur_src->linesize[0] >> 2;
782         const int prv_dst_linesize = prv_dst->linesize[0];
783         const int cur_dst_linesize = cur_dst->linesize[0];
784
785         /* skip common lines */
786         while (y_start < y_end && !memcmp(prv_srcp + y_start*prv_src_linesize,
787                                           cur_srcp + y_start*cur_src_linesize,
788                                           cur_src->width * 4)) {
789             memcpy(cur_dstp + y_start*cur_dst_linesize,
790                    prv_dstp + y_start*prv_dst_linesize,
791                    cur_dst->width);
792             y_start++;
793         }
794         while (y_end > y_start && !memcmp(prv_srcp + y_end*prv_src_linesize,
795                                           cur_srcp + y_end*cur_src_linesize,
796                                           cur_src->width * 4)) {
797             memcpy(cur_dstp + y_end*cur_dst_linesize,
798                    prv_dstp + y_end*prv_dst_linesize,
799                    cur_dst->width);
800             y_end--;
801         }
802
803         height = y_end + 1 - y_start;
804
805         /* skip common columns */
806         while (x_start < x_end) {
807             int same_column = 1;
808             for (y = y_start; y <= y_end; y++) {
809                 if (prv_srcp[y*prv_src_linesize + x_start] != cur_srcp[y*cur_src_linesize + x_start]) {
810                     same_column = 0;
811                     break;
812                 }
813             }
814             if (!same_column)
815                 break;
816             x_start++;
817         }
818         while (x_end > x_start) {
819             int same_column = 1;
820             for (y = y_start; y <= y_end; y++) {
821                 if (prv_srcp[y*prv_src_linesize + x_end] != cur_srcp[y*cur_src_linesize + x_end]) {
822                     same_column = 0;
823                     break;
824                 }
825             }
826             if (!same_column)
827                 break;
828             x_end--;
829         }
830         width = x_end + 1 - x_start;
831
832         if (x_start) {
833             for (y = y_start; y <= y_end; y++)
834                 memcpy(cur_dstp + y*cur_dst_linesize,
835                        prv_dstp + y*prv_dst_linesize, x_start);
836         }
837         if (x_end != cur_src->width - 1) {
838             const int copy_len = cur_src->width - 1 - x_end;
839             for (y = y_start; y <= y_end; y++)
840                 memcpy(cur_dstp + y*cur_dst_linesize + x_end + 1,
841                        prv_dstp + y*prv_dst_linesize + x_end + 1,
842                        copy_len);
843         }
844     }
845     *xp = x_start;
846     *yp = y_start;
847     *wp = width;
848     *hp = height;
849 }
850
851 static AVFrame *apply_palette(AVFilterLink *inlink, AVFrame *in)
852 {
853     int x, y, w, h;
854     AVFilterContext *ctx = inlink->dst;
855     PaletteUseContext *s = ctx->priv;
856     AVFilterLink *outlink = inlink->dst->outputs[0];
857
858     AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
859     if (!out) {
860         av_frame_free(&in);
861         return NULL;
862     }
863     av_frame_copy_props(out, in);
864
865     set_processing_window(s->diff_mode, s->last_in, in,
866                           s->last_out, out, &x, &y, &w, &h);
867     av_frame_free(&s->last_in);
868     av_frame_free(&s->last_out);
869     s->last_in  = av_frame_clone(in);
870     s->last_out = av_frame_clone(out);
871     if (!s->last_in || !s->last_out ||
872         av_frame_make_writable(s->last_in) < 0) {
873         av_frame_free(&in);
874         av_frame_free(&out);
875         return NULL;
876     }
877
878     av_dlog(ctx, "%dx%d rect: (%d;%d) -> (%d,%d) [area:%dx%d]\n",
879             w, h, x, y, x+w, y+h, in->width, in->height);
880
881     if (s->set_frame(s, out, in, x, y, w, h) < 0) {
882         av_frame_free(&out);
883         return NULL;
884     }
885     memcpy(out->data[1], s->palette, AVPALETTE_SIZE);
886     if (s->calc_mean_err)
887         debug_mean_error(s, in, out, inlink->frame_count);
888     av_frame_free(&in);
889     return out;
890 }
891
892 static int config_output(AVFilterLink *outlink)
893 {
894     int ret;
895     AVFilterContext *ctx = outlink->src;
896     PaletteUseContext *s = ctx->priv;
897
898     outlink->w = ctx->inputs[0]->w;
899     outlink->h = ctx->inputs[0]->h;
900
901     outlink->time_base = ctx->inputs[0]->time_base;
902     if ((ret = ff_dualinput_init(ctx, &s->dinput)) < 0)
903         return ret;
904     return 0;
905 }
906
907 static int config_input_palette(AVFilterLink *inlink)
908 {
909     AVFilterContext *ctx = inlink->dst;
910
911     if (inlink->w * inlink->h != AVPALETTE_COUNT) {
912         av_log(ctx, AV_LOG_ERROR,
913                "Palette input must contain exactly %d pixels. "
914                "Specified input has %dx%d=%d pixels\n",
915                AVPALETTE_COUNT, inlink->w, inlink->h,
916                inlink->w * inlink->h);
917         return AVERROR(EINVAL);
918     }
919     return 0;
920 }
921
922 static void load_palette(PaletteUseContext *s, const AVFrame *palette_frame)
923 {
924     int i, x, y;
925     const uint32_t *p = (const uint32_t *)palette_frame->data[0];
926     const int p_linesize = palette_frame->linesize[0] >> 2;
927
928     i = 0;
929     for (y = 0; y < palette_frame->height; y++) {
930         for (x = 0; x < palette_frame->width; x++)
931             s->palette[i++] = p[x];
932         p += p_linesize;
933     }
934
935     load_colormap(s);
936
937     s->palette_loaded = 1;
938 }
939
940 static AVFrame *load_apply_palette(AVFilterContext *ctx, AVFrame *main,
941                                    const AVFrame *second)
942 {
943     AVFilterLink *inlink = ctx->inputs[0];
944     PaletteUseContext *s = ctx->priv;
945     if (!s->palette_loaded) {
946         load_palette(s, second);
947     }
948     return apply_palette(inlink, main);
949 }
950
951 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
952 {
953     PaletteUseContext *s = inlink->dst->priv;
954     return ff_dualinput_filter_frame(&s->dinput, inlink, in);
955 }
956
957 #define DEFINE_SET_FRAME(color_search, name, value)                             \
958 static int set_frame_##name(PaletteUseContext *s, AVFrame *out, AVFrame *in,    \
959                             int x_start, int y_start, int w, int h)             \
960 {                                                                               \
961     return set_frame(s, out, in, x_start, y_start, w, h, value, color_search);  \
962 }
963
964 #define DEFINE_SET_FRAME_COLOR_SEARCH(color_search, color_search_macro)                                 \
965     DEFINE_SET_FRAME(color_search_macro, color_search##_##none,            DITHERING_NONE)              \
966     DEFINE_SET_FRAME(color_search_macro, color_search##_##bayer,           DITHERING_BAYER)             \
967     DEFINE_SET_FRAME(color_search_macro, color_search##_##heckbert,        DITHERING_HECKBERT)          \
968     DEFINE_SET_FRAME(color_search_macro, color_search##_##floyd_steinberg, DITHERING_FLOYD_STEINBERG)   \
969     DEFINE_SET_FRAME(color_search_macro, color_search##_##sierra2,         DITHERING_SIERRA2)           \
970     DEFINE_SET_FRAME(color_search_macro, color_search##_##sierra2_4a,      DITHERING_SIERRA2_4A)        \
971
972 DEFINE_SET_FRAME_COLOR_SEARCH(nns_iterative, COLOR_SEARCH_NNS_ITERATIVE)
973 DEFINE_SET_FRAME_COLOR_SEARCH(nns_recursive, COLOR_SEARCH_NNS_RECURSIVE)
974 DEFINE_SET_FRAME_COLOR_SEARCH(bruteforce,    COLOR_SEARCH_BRUTEFORCE)
975
976 #define DITHERING_ENTRIES(color_search) {       \
977     set_frame_##color_search##_none,            \
978     set_frame_##color_search##_bayer,           \
979     set_frame_##color_search##_heckbert,        \
980     set_frame_##color_search##_floyd_steinberg, \
981     set_frame_##color_search##_sierra2,         \
982     set_frame_##color_search##_sierra2_4a,      \
983 }
984
985 static const set_frame_func set_frame_lut[NB_COLOR_SEARCHES][NB_DITHERING] = {
986     DITHERING_ENTRIES(nns_iterative),
987     DITHERING_ENTRIES(nns_recursive),
988     DITHERING_ENTRIES(bruteforce),
989 };
990
991 static int dither_value(int p)
992 {
993     const int q = p ^ (p >> 3);
994     return   (p & 4) >> 2 | (q & 4) >> 1 \
995            | (p & 2) << 1 | (q & 2) << 2 \
996            | (p & 1) << 4 | (q & 1) << 5;
997 }
998
999 static av_cold int init(AVFilterContext *ctx)
1000 {
1001     PaletteUseContext *s = ctx->priv;
1002     s->dinput.repeatlast = 1; // only 1 frame in the palette
1003     s->dinput.process    = load_apply_palette;
1004
1005     s->set_frame = set_frame_lut[s->color_search_method][s->dither];
1006
1007     if (s->dither == DITHERING_BAYER) {
1008         int i;
1009         const int delta = 1 << (5 - s->bayer_scale); // to avoid too much luma
1010
1011         for (i = 0; i < FF_ARRAY_ELEMS(s->ordered_dither); i++)
1012             s->ordered_dither[i] = (dither_value(i) >> s->bayer_scale) - delta;
1013     }
1014
1015     return 0;
1016 }
1017
1018 static int request_frame(AVFilterLink *outlink)
1019 {
1020     PaletteUseContext *s = outlink->src->priv;
1021     return ff_dualinput_request_frame(&s->dinput, outlink);
1022 }
1023
1024 static av_cold void uninit(AVFilterContext *ctx)
1025 {
1026     int i;
1027     PaletteUseContext *s = ctx->priv;
1028
1029     ff_dualinput_uninit(&s->dinput);
1030     for (i = 0; i < CACHE_SIZE; i++)
1031         av_freep(&s->cache[i].entries);
1032     av_frame_free(&s->last_in);
1033     av_frame_free(&s->last_out);
1034 }
1035
1036 static const AVFilterPad paletteuse_inputs[] = {
1037     {
1038         .name           = "default",
1039         .type           = AVMEDIA_TYPE_VIDEO,
1040         .filter_frame   = filter_frame,
1041         .needs_writable = 1, // for error diffusal dithering
1042     },{
1043         .name           = "palette",
1044         .type           = AVMEDIA_TYPE_VIDEO,
1045         .config_props   = config_input_palette,
1046         .filter_frame   = filter_frame,
1047     },
1048     { NULL }
1049 };
1050
1051 static const AVFilterPad paletteuse_outputs[] = {
1052     {
1053         .name          = "default",
1054         .type          = AVMEDIA_TYPE_VIDEO,
1055         .config_props  = config_output,
1056         .request_frame = request_frame,
1057     },
1058     { NULL }
1059 };
1060
1061 AVFilter ff_vf_paletteuse = {
1062     .name          = "paletteuse",
1063     .description   = NULL_IF_CONFIG_SMALL("Use a palette to downsample an input video stream."),
1064     .priv_size     = sizeof(PaletteUseContext),
1065     .query_formats = query_formats,
1066     .init          = init,
1067     .uninit        = uninit,
1068     .inputs        = paletteuse_inputs,
1069     .outputs       = paletteuse_outputs,
1070     .priv_class    = &paletteuse_class,
1071 };