Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

avfilter/vf_palette(gen|use): support palettes with alpha

Browse Source
pull/370/head
Soft Works 3 years ago committed by Paul B Mahol
parent 3ee7250116
commit dea673d0d5
3 changed files with 231 additions and 138 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      doc/filters.texi
  2. 136
      libavfilter/vf_palettegen.c
  3. 225
      libavfilter/vf_paletteuse.c

8
doc/filters.texi
Unescape View File

@ -16580,6 +16580,9 @@ Compute new histogram for each frame.
@end table @end table
Default value is @var{full}. Default value is @var{full}.
@item use_alpha
Create a palette of colors with alpha components.
Setting this, will automatically disable 'reserve_transparent'.
@end table @end table
The filter also exports the frame metadata @code{lavfi.color_quant_ratio} The filter also exports the frame metadata @code{lavfi.color_quant_ratio}
@ -16658,6 +16661,11 @@ will be treated as completely opaque, and values below this threshold will be
treated as completely transparent. treated as completely transparent.
The option must be an integer value in the range [0,255]. Default is @var{128}. The option must be an integer value in the range [0,255]. Default is @var{128}.
@item use_alpha
Apply the palette by taking alpha values into account. Only useful with
palettes that are containing multiple colors with alpha components.
Setting this will automatically disable 'alpha_treshold'.
@end table @end table
@subsection Examples @subsection Examples

136
libavfilter/vf_palettegen.c
Unescape View File

@ -59,7 +59,7 @@ enum {
}; };
#define NBITS 5 #define NBITS 5
#define HIST_SIZE (1<<(3*NBITS)) #define HIST_SIZE (1<<(4*NBITS))
typedef struct PaletteGenContext { typedef struct PaletteGenContext {
const AVClass *class; const AVClass *class;
@ -67,6 +67,7 @@ typedef struct PaletteGenContext {
int max_colors; int max_colors;
int reserve_transparent; int reserve_transparent;
int stats_mode; int stats_mode;
int use_alpha;
AVFrame *prev_frame; // previous frame used for the diff stats_mode AVFrame *prev_frame; // previous frame used for the diff stats_mode
struct hist_node histogram[HIST_SIZE]; // histogram/hashtable of the colors struct hist_node histogram[HIST_SIZE]; // histogram/hashtable of the colors
@ -88,6 +89,7 @@ static const AVOption palettegen_options[] = {
{ "full", "compute full frame histograms", 0, AV_OPT_TYPE_CONST, {.i64=STATS_MODE_ALL_FRAMES}, INT_MIN, INT_MAX, FLAGS, "mode" }, { "full", "compute full frame histograms", 0, AV_OPT_TYPE_CONST, {.i64=STATS_MODE_ALL_FRAMES}, INT_MIN, INT_MAX, FLAGS, "mode" },
{ "diff", "compute histograms only for the part that differs from previous frame", 0, AV_OPT_TYPE_CONST, {.i64=STATS_MODE_DIFF_FRAMES}, INT_MIN, INT_MAX, FLAGS, "mode" }, { "diff", "compute histograms only for the part that differs from previous frame", 0, AV_OPT_TYPE_CONST, {.i64=STATS_MODE_DIFF_FRAMES}, INT_MIN, INT_MAX, FLAGS, "mode" },
{ "single", "compute new histogram for each frame", 0, AV_OPT_TYPE_CONST, {.i64=STATS_MODE_SINGLE_FRAMES}, INT_MIN, INT_MAX, FLAGS, "mode" }, { "single", "compute new histogram for each frame", 0, AV_OPT_TYPE_CONST, {.i64=STATS_MODE_SINGLE_FRAMES}, INT_MIN, INT_MAX, FLAGS, "mode" },
{ "use_alpha", "create a palette including alpha values", OFFSET(use_alpha), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },
{ NULL } { NULL }
}; };
@ -113,15 +115,16 @@ static int cmp_##name(const void *pa, const void *pb) \
{ \ { \
const struct color_ref * const *a = pa; \ const struct color_ref * const *a = pa; \
const struct color_ref * const *b = pb; \ const struct color_ref * const *b = pb; \
return (int)((*a)->color >> (8 * (2 - (pos))) & 0xff) \ return (int)((*a)->color >> (8 * (3 - (pos))) & 0xff) \
- (int)((*b)->color >> (8 * (2 - (pos))) & 0xff); \ - (int)((*b)->color >> (8 * (3 - (pos))) & 0xff); \
} }
DECLARE_CMP_FUNC(r, 0) DECLARE_CMP_FUNC(a, 0)
DECLARE_CMP_FUNC(g, 1) DECLARE_CMP_FUNC(r, 1)
DECLARE_CMP_FUNC(b, 2) DECLARE_CMP_FUNC(g, 2)
DECLARE_CMP_FUNC(b, 3)
static const cmp_func cmp_funcs[] = {cmp_r, cmp_g, cmp_b}; static const cmp_func cmp_funcs[] = {cmp_a, cmp_r, cmp_g, cmp_b};
/** /**
* Simple color comparison for sorting the final palette * Simple color comparison for sorting the final palette
@ -143,6 +146,17 @@ static av_always_inline int diff(const uint32_t a, const uint32_t b)
return dr*dr + dg*dg + db*db; return dr*dr + dg*dg + db*db;
} }
static av_always_inline int diff_alpha(const uint32_t a, const uint32_t b)
{
const uint8_t c1[] = {a >> 24 & 0xff, a >> 16 & 0xff, a >> 8 & 0xff, a & 0xff};
const uint8_t c2[] = {b >> 24 & 0xff, b >> 16 & 0xff, b >> 8 & 0xff, b & 0xff};
const int da = c1[0] - c2[0];
const int dr = c1[1] - c2[1];
const int dg = c1[2] - c2[2];
const int db = c1[3] - c2[3];
return da*da + dr*dr + dg*dg + db*db;
}
/** /**
* Find the next box to split: pick the one with the highest variance * Find the next box to split: pick the one with the highest variance
*/ */
@ -164,7 +178,10 @@ static int get_next_box_id_to_split(PaletteGenContext *s)
for (i = 0; i < box->len; i++) { for (i = 0; i < box->len; i++) {
const struct color_ref *ref = s->refs[box->start + i]; const struct color_ref *ref = s->refs[box->start + i];
variance += diff(ref->color, box->color) * ref->count; if (s->use_alpha)
variance += (int64_t)diff_alpha(ref->color, box->color) * ref->count;
else
variance += (int64_t)diff(ref->color, box->color) * ref->count;
} }
box->variance = variance; box->variance = variance;
} }
@ -184,24 +201,31 @@ static int get_next_box_id_to_split(PaletteGenContext *s)
* specified box. Takes into account the weight of each color. * specified box. Takes into account the weight of each color.
*/ */
static uint32_t get_avg_color(struct color_ref * const *refs, static uint32_t get_avg_color(struct color_ref * const *refs,
const struct range_box *box) const struct range_box *box, int use_alpha)
{ {
int i; int i;
const int n = box->len; const int n = box->len;
uint64_t r = 0, g = 0, b = 0, div = 0; uint64_t a = 0, r = 0, g = 0, b = 0, div = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
const struct color_ref *ref = refs[box->start + i]; const struct color_ref *ref = refs[box->start + i];
r += (ref->color >> 16 & 0xff) * ref->count; if (use_alpha)
g += (ref->color >> 8 & 0xff) * ref->count; a += (ref->color >> 24 & 0xff) * ref->count;
b += (ref->color & 0xff) * ref->count; r += (ref->color >> 16 & 0xff) * ref->count;
g += (ref->color >> 8 & 0xff) * ref->count;
b += (ref->color & 0xff) * ref->count;
div += ref->count; div += ref->count;
} }
if (use_alpha)
a = a / div;
r = r / div; r = r / div;
g = g / div; g = g / div;
b = b / div; b = b / div;
if (use_alpha)
return a<<24 | r<<16 | g<<8 | b;
return 0xffU<<24 | r<<16 | g<<8 | b; return 0xffU<<24 | r<<16 | g<<8 | b;
} }
@ -220,8 +244,8 @@ static void split_box(PaletteGenContext *s, struct range_box *box, int n)
av_assert0(box->len >= 1); av_assert0(box->len >= 1);
av_assert0(new_box->len >= 1); av_assert0(new_box->len >= 1);
box->color = get_avg_color(s->refs, box); box->color = get_avg_color(s->refs, box, s->use_alpha);
new_box->color = get_avg_color(s->refs, new_box); new_box->color = get_avg_color(s->refs, new_box, s->use_alpha);
box->variance = -1; box->variance = -1;
new_box->variance = -1; new_box->variance = -1;
} }
@ -251,7 +275,7 @@ static void write_palette(AVFilterContext *ctx, AVFrame *out)
pal += pal_linesize; pal += pal_linesize;
} }
if (s->reserve_transparent) { if (s->reserve_transparent && !s->use_alpha) {
av_assert0(s->nb_boxes < 256); av_assert0(s->nb_boxes < 256);
pal[out->width - pal_linesize - 1] = AV_RB32(&s->transparency_color) >> 8; pal[out->width - pal_linesize - 1] = AV_RB32(&s->transparency_color) >> 8;
} }
@ -319,40 +343,49 @@ static AVFrame *get_palette_frame(AVFilterContext *ctx)
box = &s->boxes[box_id]; box = &s->boxes[box_id];
box->len = s->nb_refs; box->len = s->nb_refs;
box->sorted_by = -1; box->sorted_by = -1;
box->color = get_avg_color(s->refs, box); box->color = get_avg_color(s->refs, box, s->use_alpha);
box->variance = -1; box->variance = -1;
s->nb_boxes = 1; s->nb_boxes = 1;
while (box && box->len > 1) { while (box && box->len > 1) {
int i, rr, gr, br, longest; int i, ar, rr, gr, br, longest;
uint64_t median, box_weight = 0; uint64_t median, box_weight = 0;
/* compute the box weight (sum all the weights of the colors in the /* compute the box weight (sum all the weights of the colors in the
* range) and its boundings */ * range) and its boundings */
uint8_t min[3] = {0xff, 0xff, 0xff}; uint8_t min[4] = {0xff, 0xff, 0xff, 0xff};
uint8_t max[3] = {0x00, 0x00, 0x00}; uint8_t max[4] = {0x00, 0x00, 0x00, 0x00};
for (i = box->start; i < box->start + box->len; i++) { for (i = box->start; i < box->start + box->len; i++) {
const struct color_ref *ref = s->refs[i]; const struct color_ref *ref = s->refs[i];
const uint32_t rgb = ref->color; const uint32_t rgb = ref->color;
const uint8_t r = rgb >> 16 & 0xff, g = rgb >> 8 & 0xff, b = rgb & 0xff; const uint8_t a = rgb >> 24 & 0xff, r = rgb >> 16 & 0xff, g = rgb >> 8 & 0xff, b = rgb & 0xff;
min[0] = FFMIN(r, min[0]), max[0] = FFMAX(r, max[0]); min[0] = FFMIN(a, min[0]); max[0] = FFMAX(a, max[0]);
min[1] = FFMIN(g, min[1]), max[1] = FFMAX(g, max[1]); min[1] = FFMIN(r, min[1]); max[1] = FFMAX(r, max[1]);
min[2] = FFMIN(b, min[2]), max[2] = FFMAX(b, max[2]); min[2] = FFMIN(g, min[2]); max[2] = FFMAX(g, max[2]);
min[3] = FFMIN(b, min[3]); max[3] = FFMAX(b, max[3]);
box_weight += ref->count; box_weight += ref->count;
} }
/* define the axis to sort by according to the widest range of colors */ /* define the axis to sort by according to the widest range of colors */
rr = max[0] - min[0]; ar = max[0] - min[0];
gr = max[1] - min[1]; rr = max[1] - min[1];
br = max[2] - min[2]; gr = max[2] - min[2];
longest = 1; // pick green by default (the color the eye is the most sensitive to) br = max[3] - min[3];
if (br >= rr && br >= gr) longest = 2; longest = 2; // pick green by default (the color the eye is the most sensitive to)
if (rr >= gr && rr >= br) longest = 0; if (s->use_alpha) {
if (gr >= rr && gr >= br) longest = 1; // prefer green again if (ar >= rr && ar >= br && ar >= gr) longest = 0;
if (br >= rr && br >= gr && br >= ar) longest = 3;
ff_dlog(ctx, "box #%02X [%6d..%-6d] (%6d) w:%-6"PRIu64" ranges:[%2x %2x %2x] sort by %c (already sorted:%c) ", if (rr >= gr && rr >= br && rr >= ar) longest = 1;
if (gr >= rr && gr >= br && gr >= ar) longest = 2; // prefer green again
} else {
if (br >= rr && br >= gr) longest = 3;
if (rr >= gr && rr >= br) longest = 1;
if (gr >= rr && gr >= br) longest = 2; // prefer green again
}
ff_dlog(ctx, "box #%02X [%6d..%-6d] (%6d) w:%-6"PRIu64" ranges:[%2x %2x %2x %2x] sort by %c (already sorted:%c) ",
box_id, box->start, box->start + box->len - 1, box->len, box_weight, box_id, box->start, box->start + box->len - 1, box->len, box_weight,
rr, gr, br, "rgb"[longest], box->sorted_by == longest ? 'y':'n'); ar, rr, gr, br, "argb"[longest], box->sorted_by == longest ? 'y' : 'n');
/* sort the range by its longest axis if it's not already sorted */ /* sort the range by its longest axis if it's not already sorted */
if (box->sorted_by != longest) { if (box->sorted_by != longest) {
@ -394,21 +427,27 @@ static AVFrame *get_palette_frame(AVFilterContext *ctx)
* It keeps the NBITS least significant bit of each component to make it * It keeps the NBITS least significant bit of each component to make it
* "random" even if the scene doesn't have much different colors. * "random" even if the scene doesn't have much different colors.
*/ */
static inline unsigned color_hash(uint32_t color) static inline unsigned color_hash(uint32_t color, int use_alpha)
{ {
const uint8_t r = color >> 16 & ((1<<NBITS)-1); const uint8_t r = color >> 16 & ((1<<NBITS)-1);
const uint8_t g = color >> 8 & ((1<<NBITS)-1); const uint8_t g = color >> 8 & ((1<<NBITS)-1);
const uint8_t b = color & ((1<<NBITS)-1); const uint8_t b = color & ((1<<NBITS)-1);
if (use_alpha) {
const uint8_t a = color >> 24 & ((1 << NBITS) - 1);
return a << (NBITS * 3) | r << (NBITS * 2) | g << NBITS | b;
}
return r<<(NBITS*2) | g<<NBITS | b; return r<<(NBITS*2) | g<<NBITS | b;
} }
/** /**
* Locate the color in the hash table and increment its counter. * Locate the color in the hash table and increment its counter.
*/ */
static int color_inc(struct hist_node *hist, uint32_t color) static int color_inc(struct hist_node *hist, uint32_t color, int use_alpha)
{ {
int i; int i;
const unsigned hash = color_hash(color); const unsigned hash = color_hash(color, use_alpha);
struct hist_node *node = &hist[hash]; struct hist_node *node = &hist[hash];
struct color_ref *e; struct color_ref *e;
@ -433,7 +472,7 @@ static int color_inc(struct hist_node *hist, uint32_t color)
* Update histogram when pixels differ from previous frame. * Update histogram when pixels differ from previous frame.
*/ */
static int update_histogram_diff(struct hist_node *hist, static int update_histogram_diff(struct hist_node *hist,
const AVFrame *f1, const AVFrame *f2) const AVFrame *f1, const AVFrame *f2, int use_alpha)
{ {
int x, y, ret, nb_diff_colors = 0; int x, y, ret, nb_diff_colors = 0;
@ -444,7 +483,7 @@ static int update_histogram_diff(struct hist_node *hist,
for (x = 0; x < f1->width; x++) { for (x = 0; x < f1->width; x++) {
if (p[x] == q[x]) if (p[x] == q[x])
continue; continue;
ret = color_inc(hist, p[x]); ret = color_inc(hist, p[x], use_alpha);
if (ret < 0) if (ret < 0)
return ret; return ret;
nb_diff_colors += ret; nb_diff_colors += ret;
@ -456,7 +495,7 @@ static int update_histogram_diff(struct hist_node *hist,
/** /**
* Simple histogram of the frame. * Simple histogram of the frame.
*/ */
static int update_histogram_frame(struct hist_node *hist, const AVFrame *f) static int update_histogram_frame(struct hist_node *hist, const AVFrame *f, int use_alpha)
{ {
int x, y, ret, nb_diff_colors = 0; int x, y, ret, nb_diff_colors = 0;
@ -464,7 +503,7 @@ static int update_histogram_frame(struct hist_node *hist, const AVFrame *f)
const uint32_t *p = (const uint32_t *)(f->data[0] + y*f->linesize[0]); const uint32_t *p = (const uint32_t *)(f->data[0] + y*f->linesize[0]);
for (x = 0; x < f->width; x++) { for (x = 0; x < f->width; x++) {
ret = color_inc(hist, p[x]); ret = color_inc(hist, p[x], use_alpha);
if (ret < 0) if (ret < 0)
return ret; return ret;
nb_diff_colors += ret; nb_diff_colors += ret;
@ -480,8 +519,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{ {
AVFilterContext *ctx = inlink->dst; AVFilterContext *ctx = inlink->dst;
PaletteGenContext *s = ctx->priv; PaletteGenContext *s = ctx->priv;
int ret = s->prev_frame ? update_histogram_diff(s->histogram, s->prev_frame, in) int ret = s->prev_frame ? update_histogram_diff(s->histogram, s->prev_frame, in, s->use_alpha)
: update_histogram_frame(s->histogram, in); : update_histogram_frame(s->histogram, in, s->use_alpha);
if (ret > 0) if (ret > 0)
s->nb_refs += ret; s->nb_refs += ret;
@ -540,6 +579,16 @@ static int config_output(AVFilterLink *outlink)
return 0; return 0;
} }
static int init(AVFilterContext *ctx)
{
PaletteGenContext* s = ctx->priv;
if (s->use_alpha && s->reserve_transparent)
s->reserve_transparent = 0;
return 0;
}
static av_cold void uninit(AVFilterContext *ctx) static av_cold void uninit(AVFilterContext *ctx)
{ {
int i; int i;
@ -572,6 +621,7 @@ const AVFilter ff_vf_palettegen = {
.name = "palettegen", .name = "palettegen",
.description = NULL_IF_CONFIG_SMALL("Find the optimal palette for a given stream."), .description = NULL_IF_CONFIG_SMALL("Find the optimal palette for a given stream."),
.priv_size = sizeof(PaletteGenContext), .priv_size = sizeof(PaletteGenContext),
.init = init,
.uninit = uninit, .uninit = uninit,
FILTER_INPUTS(palettegen_inputs), FILTER_INPUTS(palettegen_inputs),
FILTER_OUTPUTS(palettegen_outputs), FILTER_OUTPUTS(palettegen_outputs),

225
libavfilter/vf_paletteuse.c
Unescape View File

@ -28,7 +28,6 @@
#include "libavutil/opt.h" #include "libavutil/opt.h"
#include "libavutil/qsort.h" #include "libavutil/qsort.h"
#include "avfilter.h" #include "avfilter.h"
#include "filters.h"
#include "framesync.h" #include "framesync.h"
#include "internal.h" #include "internal.h"
@ -63,7 +62,7 @@ struct color_node {
}; };
#define NBITS 5 #define NBITS 5
#define CACHE_SIZE (1<<(3*NBITS)) #define CACHE_SIZE (1<<(4*NBITS))
struct cached_color { struct cached_color {
uint32_t color; uint32_t color;
@ -88,6 +87,7 @@ typedef struct PaletteUseContext {
uint32_t palette[AVPALETTE_COUNT]; uint32_t palette[AVPALETTE_COUNT];
int transparency_index; /* index in the palette of transparency. -1 if there is no transparency in the palette. */ int transparency_index; /* index in the palette of transparency. -1 if there is no transparency in the palette. */
int trans_thresh; int trans_thresh;
int use_alpha;
int palette_loaded; int palette_loaded;
int dither; int dither;
int new; int new;
@ -107,7 +107,7 @@ typedef struct PaletteUseContext {
} PaletteUseContext; } PaletteUseContext;
#define OFFSET(x) offsetof(PaletteUseContext, x) #define OFFSET(x) offsetof(PaletteUseContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
static const AVOption paletteuse_options[] = { static const AVOption paletteuse_options[] = {
{ "dither", "select dithering mode", OFFSET(dither), AV_OPT_TYPE_INT, {.i64=DITHERING_SIERRA2_4A}, 0, NB_DITHERING-1, FLAGS, "dithering_mode" }, { "dither", "select dithering mode", OFFSET(dither), AV_OPT_TYPE_INT, {.i64=DITHERING_SIERRA2_4A}, 0, NB_DITHERING-1, FLAGS, "dithering_mode" },
{ "bayer", "ordered 8x8 bayer dithering (deterministic)", 0, AV_OPT_TYPE_CONST, {.i64=DITHERING_BAYER}, INT_MIN, INT_MAX, FLAGS, "dithering_mode" }, { "bayer", "ordered 8x8 bayer dithering (deterministic)", 0, AV_OPT_TYPE_CONST, {.i64=DITHERING_BAYER}, INT_MIN, INT_MAX, FLAGS, "dithering_mode" },
@ -120,6 +120,7 @@ static const AVOption paletteuse_options[] = {
{ "rectangle", "process smallest different rectangle", 0, AV_OPT_TYPE_CONST, {.i64=DIFF_MODE_RECTANGLE}, INT_MIN, INT_MAX, FLAGS, "diff_mode" }, { "rectangle", "process smallest different rectangle", 0, AV_OPT_TYPE_CONST, {.i64=DIFF_MODE_RECTANGLE}, INT_MIN, INT_MAX, FLAGS, "diff_mode" },
{ "new", "take new palette for each output frame", OFFSET(new), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS }, { "new", "take new palette for each output frame", OFFSET(new), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
{ "alpha_threshold", "set the alpha threshold for transparency", OFFSET(trans_thresh), AV_OPT_TYPE_INT, {.i64=128}, 0, 255, FLAGS }, { "alpha_threshold", "set the alpha threshold for transparency", OFFSET(trans_thresh), AV_OPT_TYPE_INT, {.i64=128}, 0, 255, FLAGS },
{ "use_alpha", "use alpha channel for mapping", OFFSET(use_alpha), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
/* following are the debug options, not part of the official API */ /* following are the debug options, not part of the official API */
{ "debug_kdtree", "save Graphviz graph of the kdtree in specified file", OFFSET(dot_filename), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS }, { "debug_kdtree", "save Graphviz graph of the kdtree in specified file", OFFSET(dot_filename), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
@ -161,37 +162,41 @@ static av_always_inline uint32_t dither_color(uint32_t px, int er, int eg,
| av_clip_uint8((px & 0xff) + ((eb * scale) / (1<<shift))); | av_clip_uint8((px & 0xff) + ((eb * scale) / (1<<shift)));
} }
static av_always_inline int diff(const uint8_t *c1, const uint8_t *c2, const int trans_thresh) static av_always_inline int diff(const uint8_t *c1, const uint8_t *c2, const PaletteUseContext *s)
{ {
// XXX: try L*a*b with CIE76 (dL*dL + da*da + db*db) // XXX: try L*a*b with CIE76 (dL*dL + da*da + db*db)
const int da = c1[0] - c2[0];
const int dr = c1[1] - c2[1]; const int dr = c1[1] - c2[1];
const int dg = c1[2] - c2[2]; const int dg = c1[2] - c2[2];
const int db = c1[3] - c2[3]; const int db = c1[3] - c2[3];
if (c1[0] < trans_thresh && c2[0] < trans_thresh) { if (s->use_alpha)
return da*da + dr*dr + dg*dg + db*db;
if (c1[0] < s->trans_thresh && c2[0] < s->trans_thresh) {
return 0; return 0;
} else if (c1[0] >= trans_thresh && c2[0] >= trans_thresh) { } else if (c1[0] >= s->trans_thresh && c2[0] >= s->trans_thresh) {
return dr*dr + dg*dg + db*db; return dr*dr + dg*dg + db*db;
} else { } else {
return 255*255 + 255*255 + 255*255; return 255*255 + 255*255 + 255*255;
} }
} }
static av_always_inline uint8_t colormap_nearest_bruteforce(const uint32_t *palette, const uint8_t *argb, const int trans_thresh) static av_always_inline uint8_t colormap_nearest_bruteforce(const PaletteUseContext *s, const uint8_t *argb)
{ {
int i, pal_id = -1, min_dist = INT_MAX; int i, pal_id = -1, min_dist = INT_MAX;
for (i = 0; i < AVPALETTE_COUNT; i++) { for (i = 0; i < AVPALETTE_COUNT; i++) {
const uint32_t c = palette[i]; const uint32_t c = s->palette[i];
if (c >> 24 >= trans_thresh) { // ignore transparent entry if (s->use_alpha || c >> 24 >= s->trans_thresh) { // ignore transparent entry
const uint8_t palargb[] = { const uint8_t palargb[] = {
palette[i]>>24 & 0xff, s->palette[i]>>24 & 0xff,
palette[i]>>16 & 0xff, s->palette[i]>>16 & 0xff,
palette[i]>> 8 & 0xff, s->palette[i]>> 8 & 0xff,
palette[i] & 0xff, s->palette[i] & 0xff,
}; };
const int d = diff(palargb, argb, trans_thresh); const int d = diff(palargb, argb, s);
if (d < min_dist) { if (d < min_dist) {
pal_id = i; pal_id = i;
min_dist = d; min_dist = d;
@ -207,17 +212,17 @@ struct nearest_color {
int dist_sqd; int dist_sqd;
}; };
static void colormap_nearest_node(const struct color_node *map, static void colormap_nearest_node(const PaletteUseContext *s,
const struct color_node *map,
const int node_pos, const int node_pos,
const uint8_t *target, const uint8_t *target,
const int trans_thresh,
struct nearest_color *nearest) struct nearest_color *nearest)
{ {
const struct color_node *kd = map + node_pos; const struct color_node *kd = map + node_pos;
const int s = kd->split; const int split = kd->split;
int dx, nearer_kd_id, further_kd_id; int dx, nearer_kd_id, further_kd_id;
const uint8_t *current = kd->val; const uint8_t *current = kd->val;
const int current_to_target = diff(target, current, trans_thresh); const int current_to_target = diff(target, current, s);
if (current_to_target < nearest->dist_sqd) { if (current_to_target < nearest->dist_sqd) {
nearest->node_pos = node_pos; nearest->node_pos = node_pos;
@ -225,23 +230,23 @@ static void colormap_nearest_node(const struct color_node *map,
} }
if (kd->left_id != -1 || kd->right_id != -1) { if (kd->left_id != -1 || kd->right_id != -1) {
dx = target[s] - current[s]; dx = target[split] - current[split];
if (dx <= 0) nearer_kd_id = kd->left_id, further_kd_id = kd->right_id; if (dx <= 0) nearer_kd_id = kd->left_id, further_kd_id = kd->right_id;
else nearer_kd_id = kd->right_id, further_kd_id = kd->left_id; else nearer_kd_id = kd->right_id, further_kd_id = kd->left_id;
if (nearer_kd_id != -1) if (nearer_kd_id != -1)
colormap_nearest_node(map, nearer_kd_id, target, trans_thresh, nearest); colormap_nearest_node(s, map, nearer_kd_id, target, nearest);
if (further_kd_id != -1 && dx*dx < nearest->dist_sqd) if (further_kd_id != -1 && dx*dx < nearest->dist_sqd)
colormap_nearest_node(map, further_kd_id, target, trans_thresh, nearest); colormap_nearest_node(s, map, further_kd_id, target, nearest);
} }
} }
static av_always_inline uint8_t colormap_nearest_recursive(const struct color_node *node, const uint8_t *rgb, const int trans_thresh) static av_always_inline uint8_t colormap_nearest_recursive(const PaletteUseContext *s, const struct color_node *node, const uint8_t *rgb)
{ {
struct nearest_color res = {.dist_sqd = INT_MAX, .node_pos = -1}; struct nearest_color res = {.dist_sqd = INT_MAX, .node_pos = -1};
colormap_nearest_node(node, 0, rgb, trans_thresh, &res); colormap_nearest_node(s, node, 0, rgb, &res);
return node[res.node_pos].palette_id; return node[res.node_pos].palette_id;
} }
@ -250,7 +255,7 @@ struct stack_node {
int dx2; int dx2;
}; };
static av_always_inline uint8_t colormap_nearest_iterative(const struct color_node *root, const uint8_t *target, const int trans_thresh) static av_always_inline uint8_t colormap_nearest_iterative(const PaletteUseContext *s, const struct color_node *root, const uint8_t *target)
{ {
int pos = 0, best_node_id = -1, best_dist = INT_MAX, cur_color_id = 0; int pos = 0, best_node_id = -1, best_dist = INT_MAX, cur_color_id = 0;
struct stack_node nodes[16]; struct stack_node nodes[16];
@ -260,7 +265,7 @@ static av_always_inline uint8_t colormap_nearest_iterative(const struct color_no
const struct color_node *kd = &root[cur_color_id]; const struct color_node *kd = &root[cur_color_id];
const uint8_t *current = kd->val; const uint8_t *current = kd->val;
const int current_to_target = diff(target, current, trans_thresh); const int current_to_target = diff(target, current, s);
/* Compare current color node to the target and update our best node if /* Compare current color node to the target and update our best node if
* it's actually better. */ * it's actually better. */
@ -322,10 +327,10 @@ end:
return root[best_node_id].palette_id; return root[best_node_id].palette_id;
} }
#define COLORMAP_NEAREST(search, palette, root, target, trans_thresh) \ #define COLORMAP_NEAREST(s, search, root, target) \
search == COLOR_SEARCH_NNS_ITERATIVE ? colormap_nearest_iterative(root, target, trans_thresh) : \ search == COLOR_SEARCH_NNS_ITERATIVE ? colormap_nearest_iterative(s, root, target) : \
search == COLOR_SEARCH_NNS_RECURSIVE ? colormap_nearest_recursive(root, target, trans_thresh) : \ search == COLOR_SEARCH_NNS_RECURSIVE ? colormap_nearest_recursive(s, root, target) : \
colormap_nearest_bruteforce(palette, target, trans_thresh) colormap_nearest_bruteforce(s, target)
/** /**
* Check if the requested color is in the cache already. If not, find it in the * Check if the requested color is in the cache already. If not, find it in the
@ -362,13 +367,13 @@ static av_always_inline int color_get(PaletteUseContext *s, uint32_t color,
if (!e) if (!e)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
e->color = color; e->color = color;
e->pal_entry = COLORMAP_NEAREST(search_method, s->palette, s->map, argb_elts, s->trans_thresh); e->pal_entry = COLORMAP_NEAREST(s, search_method, s->map, argb_elts);
return e->pal_entry; return e->pal_entry;
} }
static av_always_inline int get_dst_color_err(PaletteUseContext *s, static av_always_inline int get_dst_color_err(PaletteUseContext *s,
uint32_t c, int *er, int *eg, int *eb, uint32_t c, int *ea, int *er, int *eg, int *eb,
const enum color_search_method search_method) const enum color_search_method search_method)
{ {
const uint8_t a = c >> 24 & 0xff; const uint8_t a = c >> 24 & 0xff;
@ -381,8 +386,9 @@ static av_always_inline int get_dst_color_err(PaletteUseContext *s,
return dstx; return dstx;
dstc = s->palette[dstx]; dstc = s->palette[dstx];
if (dstx == s->transparency_index) { if (dstx == s->transparency_index) {
*er = *eg = *eb = 0; *ea =*er = *eg = *eb = 0;
} else { } else {
*ea = (int)a - (int)(dstc >> 24 & 0xff);
*er = (int)r - (int)(dstc >> 16 & 0xff); *er = (int)r - (int)(dstc >> 16 & 0xff);
*eg = (int)g - (int)(dstc >> 8 & 0xff); *eg = (int)g - (int)(dstc >> 8 & 0xff);
*eb = (int)b - (int)(dstc & 0xff); *eb = (int)b - (int)(dstc & 0xff);
@ -406,7 +412,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
for (y = y_start; y < h; y++) { for (y = y_start; y < h; y++) {
for (x = x_start; x < w; x++) { for (x = x_start; x < w; x++) {
int er, eg, eb; int ea, er, eg, eb;
if (dither == DITHERING_BAYER) { if (dither == DITHERING_BAYER) {
const int d = s->ordered_dither[(y & 7)<<3 | (x & 7)]; const int d = s->ordered_dither[(y & 7)<<3 | (x & 7)];
@ -425,7 +431,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
} else if (dither == DITHERING_HECKBERT) { } else if (dither == DITHERING_HECKBERT) {
const int right = x < w - 1, down = y < h - 1; const int right = x < w - 1, down = y < h - 1;
const int color = get_dst_color_err(s, src[x], &er, &eg, &eb, search_method); const int color = get_dst_color_err(s, src[x], &ea, &er, &eg, &eb, search_method);
if (color < 0) if (color < 0)
return color; return color;
@ -437,7 +443,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
} else if (dither == DITHERING_FLOYD_STEINBERG) { } else if (dither == DITHERING_FLOYD_STEINBERG) {
const int right = x < w - 1, down = y < h - 1, left = x > x_start; const int right = x < w - 1, down = y < h - 1, left = x > x_start;
const int color = get_dst_color_err(s, src[x], &er, &eg, &eb, search_method); const int color = get_dst_color_err(s, src[x], &ea, &er, &eg, &eb, search_method);
if (color < 0) if (color < 0)
return color; return color;
@ -451,7 +457,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
} else if (dither == DITHERING_SIERRA2) { } else if (dither == DITHERING_SIERRA2) {
const int right = x < w - 1, down = y < h - 1, left = x > x_start; const int right = x < w - 1, down = y < h - 1, left = x > x_start;
const int right2 = x < w - 2, left2 = x > x_start + 1; const int right2 = x < w - 2, left2 = x > x_start + 1;
const int color = get_dst_color_err(s, src[x], &er, &eg, &eb, search_method); const int color = get_dst_color_err(s, src[x], &ea, &er, &eg, &eb, search_method);
if (color < 0) if (color < 0)
return color; return color;
@ -470,7 +476,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
} else if (dither == DITHERING_SIERRA2_4A) { } else if (dither == DITHERING_SIERRA2_4A) {
const int right = x < w - 1, down = y < h - 1, left = x > x_start; const int right = x < w - 1, down = y < h - 1, left = x > x_start;
const int color = get_dst_color_err(s, src[x], &er, &eg, &eb, search_method); const int color = get_dst_color_err(s, src[x], &ea, &er, &eg, &eb, search_method);
if (color < 0) if (color < 0)
return color; return color;
@ -553,8 +559,7 @@ static int disp_tree(const struct color_node *node, const char *fname)
return 0; return 0;
} }
static int debug_accuracy(const struct color_node *node, const uint32_t *palette, const int trans_thresh, static int debug_accuracy(const PaletteUseContext *s)
const enum color_search_method search_method)
{ {
int r, g, b, ret = 0; int r, g, b, ret = 0;
@ -562,19 +567,26 @@ static int debug_accuracy(const struct color_node *node, const uint32_t *palette
for (g = 0; g < 256; g++) { for (g = 0; g < 256; g++) {
for (b = 0; b < 256; b++) { for (b = 0; b < 256; b++) {
const uint8_t argb[] = {0xff, r, g, b}; const uint8_t argb[] = {0xff, r, g, b};
const int r1 = COLORMAP_NEAREST(search_method, palette, node, argb, trans_thresh); const int r1 = COLORMAP_NEAREST(s, s->color_search_method, s->map, argb);
const int r2 = colormap_nearest_bruteforce(palette, argb, trans_thresh); const int r2 = colormap_nearest_bruteforce(s, argb);
if (r1 != r2) { if (r1 != r2) {
const uint32_t c1 = palette[r1]; const uint32_t c1 = s->palette[r1];
const uint32_t c2 = palette[r2]; const uint32_t c2 = s->palette[r2];
const uint8_t palargb1[] = { 0xff, c1>>16 & 0xff, c1>> 8 & 0xff, c1 & 0xff }; const uint8_t a1 = s->use_alpha ? c1>>24 & 0xff : 0xff;
const uint8_t palargb2[] = { 0xff, c2>>16 & 0xff, c2>> 8 & 0xff, c2 & 0xff }; const uint8_t a2 = s->use_alpha ? c2>>24 & 0xff : 0xff;
const int d1 = diff(palargb1, argb, trans_thresh); const uint8_t palargb1[] = { a1, c1>>16 & 0xff, c1>> 8 & 0xff, c1 & 0xff };
const int d2 = diff(palargb2, argb, trans_thresh); const uint8_t palargb2[] = { a2, c2>>16 & 0xff, c2>> 8 & 0xff, c2 & 0xff };
const int d1 = diff(palargb1, argb, s);
const int d2 = diff(palargb2, argb, s);
if (d1 != d2) { if (d1 != d2) {
av_log(NULL, AV_LOG_ERROR, if (s->use_alpha)
"/!\\ %02X%02X%02X: %d ! %d (%06"PRIX32" ! %06"PRIX32") / dist: %d ! %d\n", av_log(NULL, AV_LOG_ERROR,
r, g, b, r1, r2, c1 & 0xffffff, c2 & 0xffffff, d1, d2); "/!\\ %02X%02X%02X: %d ! %d (%08"PRIX32" ! %08"PRIX32") / dist: %d ! %d\n",
r, g, b, r1, r2, c1, c2, d1, d2);
else
av_log(NULL, AV_LOG_ERROR,
"/!\\ %02X%02X%02X: %d ! %d (%06"PRIX32" ! %06"PRIX32") / dist: %d ! %d\n",
r, g, b, r1, r2, c1 & 0xffffff, c2 & 0xffffff, d1, d2);
ret = 1; ret = 1;
} }
} }
@ -590,8 +602,8 @@ struct color {
}; };
struct color_rect { struct color_rect {
uint8_t min[3]; uint8_t min[4];
uint8_t max[3]; uint8_t max[4];
}; };
typedef int (*cmp_func)(const void *, const void *); typedef int (*cmp_func)(const void *, const void *);
@ -612,43 +624,47 @@ DECLARE_CMP_FUNC(b, 3)
static const cmp_func cmp_funcs[] = {cmp_a, cmp_r, cmp_g, cmp_b}; static const cmp_func cmp_funcs[] = {cmp_a, cmp_r, cmp_g, cmp_b};
static int get_next_color(const uint8_t *color_used, const uint32_t *palette, static int get_next_color(const uint8_t *color_used, const PaletteUseContext *s,
const int trans_thresh,
int *component, const struct color_rect *box) int *component, const struct color_rect *box)
{ {
int wr, wg, wb; int wa, wr, wg, wb;
int i, longest = 0; int i, longest = 0;
unsigned nb_color = 0; unsigned nb_color = 0;
struct color_rect ranges; struct color_rect ranges;
struct color tmp_pal[256]; struct color tmp_pal[256];
cmp_func cmpf; cmp_func cmpf;
ranges.min[0] = ranges.min[1] = ranges.min[2] = 0xff; ranges.min[0] = ranges.min[1] = ranges.min[2] = ranges.min[3]= 0xff;
ranges.max[0] = ranges.max[1] = ranges.max[2] = 0x00; ranges.max[0] = ranges.max[1] = ranges.max[2] = ranges.max[3]= 0x00;
for (i = 0; i < AVPALETTE_COUNT; i++) { for (i = 0; i < AVPALETTE_COUNT; i++) {
const uint32_t c = palette[i]; const uint32_t c = s->palette[i];
const uint8_t a = c >> 24 & 0xff; const uint8_t a = c >> 24 & 0xff;
const uint8_t r = c >> 16 & 0xff; const uint8_t r = c >> 16 & 0xff;
const uint8_t g = c >> 8 & 0xff; const uint8_t g = c >> 8 & 0xff;
const uint8_t b = c & 0xff; const uint8_t b = c & 0xff;
if (a < trans_thresh) { if (!s->use_alpha && a < s->trans_thresh) {
continue; continue;
} }
if (color_used[i] || (a != 0xff) || if (color_used[i] || (a != 0xff && !s->use_alpha) ||
r < box->min[0] || g < box->min[1] || b < box->min[2] || r < box->min[1] || g < box->min[2] || b < box->min[3] ||
r > box->max[0] || g > box->max[1] || b > box->max[2]) r > box->max[1] || g > box->max[2] || b > box->max[3])
continue; continue;
if (r < ranges.min[0]) ranges.min[0] = r; if (s->use_alpha && (a < box->min[0] || a > box->max[0]))
if (g < ranges.min[1]) ranges.min[1] = g; continue;
if (b < ranges.min[2]) ranges.min[2] = b;
if (a < ranges.min[0]) ranges.min[0] = a;
if (r < ranges.min[1]) ranges.min[1] = r;
if (g < ranges.min[2]) ranges.min[2] = g;
if (b < ranges.min[3]) ranges.min[3] = b;
if (r > ranges.max[0]) ranges.max[0] = r; if (a > ranges.max[0]) ranges.max[0] = a;
if (g > ranges.max[1]) ranges.max[1] = g; if (r > ranges.max[1]) ranges.max[1] = r;
if (b > ranges.max[2]) ranges.max[2] = b; if (g > ranges.max[2]) ranges.max[2] = g;
if (b > ranges.max[3]) ranges.max[3] = b;
tmp_pal[nb_color].value = c; tmp_pal[nb_color].value = c;
tmp_pal[nb_color].pal_id = i; tmp_pal[nb_color].pal_id = i;
@ -660,12 +676,22 @@ static int get_next_color(const uint8_t *color_used, const uint32_t *palette,
return -1; return -1;
/* define longest axis that will be the split component */ /* define longest axis that will be the split component */
wr = ranges.max[0] - ranges.min[0]; wa = ranges.max[0] - ranges.min[0];
wg = ranges.max[1] - ranges.min[1]; wr = ranges.max[1] - ranges.min[1];
wb = ranges.max[2] - ranges.min[2]; wg = ranges.max[2] - ranges.min[2];
if (wr >= wg && wr >= wb) longest = 1; wb = ranges.max[3] - ranges.min[3];
if (wg >= wr && wg >= wb) longest = 2;
if (wb >= wr && wb >= wg) longest = 3; if (s->use_alpha) {
if (wa >= wr && wa >= wb && wa >= wg) longest = 0;
if (wr >= wg && wr >= wb && wr >= wa) longest = 1;
if (wg >= wr && wg >= wb && wg >= wa) longest = 2;
if (wb >= wr && wb >= wg && wb >= wa) longest = 3;
} else {
if (wr >= wg && wr >= wb) longest = 1;
if (wg >= wr && wg >= wb) longest = 2;
if (wb >= wr && wb >= wg) longest = 3;
}
cmpf = cmp_funcs[longest]; cmpf = cmp_funcs[longest];
*component = longest; *component = longest;
@ -678,8 +704,7 @@ static int get_next_color(const uint8_t *color_used, const uint32_t *palette,
static int colormap_insert(struct color_node *map, static int colormap_insert(struct color_node *map,
uint8_t *color_used, uint8_t *color_used,
int *nb_used, int *nb_used,
const uint32_t *palette, const PaletteUseContext *s,
const int trans_thresh,
const struct color_rect *box) const struct color_rect *box)
{ {
uint32_t c; uint32_t c;
@ -687,14 +712,14 @@ static int colormap_insert(struct color_node *map,
int node_left_id = -1, node_right_id = -1; int node_left_id = -1, node_right_id = -1;
struct color_node *node; struct color_node *node;
struct color_rect box1, box2; struct color_rect box1, box2;
const int pal_id = get_next_color(color_used, palette, trans_thresh, &component, box); const int pal_id = get_next_color(color_used, s, &component, box);
if (pal_id < 0) if (pal_id < 0)
return -1; return -1;
/* create new node with that color */ /* create new node with that color */
cur_id = (*nb_used)++; cur_id = (*nb_used)++;
c = palette[pal_id]; c = s->palette[pal_id];
node = &map[cur_id]; node = &map[cur_id];
node->split = component; node->split = component;
node->palette_id = pal_id; node->palette_id = pal_id;
@ -707,13 +732,13 @@ static int colormap_insert(struct color_node *map,
/* get the two boxes this node creates */ /* get the two boxes this node creates */
box1 = box2 = *box; box1 = box2 = *box;
box1.max[component-1] = node->val[component]; box1.max[component] = node->val[component];
box2.min[component-1] = FFMIN(node->val[component] + 1, 255); box2.min[component] = FFMIN(node->val[component] + 1, 255);
node_left_id = colormap_insert(map, color_used, nb_used, palette, trans_thresh, &box1); node_left_id = colormap_insert(map, color_used, nb_used, s, &box1);
if (box2.min[component-1] <= box2.max[component-1]) if (box2.min[component] <= box2.max[component])
node_right_id = colormap_insert(map, color_used, nb_used, palette, trans_thresh, &box2); node_right_id = colormap_insert(map, color_used, nb_used, s, &box2);
node->left_id = node_left_id; node->left_id = node_left_id;
node->right_id = node_right_id; node->right_id = node_right_id;
@ -728,6 +753,13 @@ static int cmp_pal_entry(const void *a, const void *b)
return c1 - c2; return c1 - c2;
} }
static int cmp_pal_entry_alpha(const void *a, const void *b)
{
const int c1 = *(const uint32_t *)a;
const int c2 = *(const uint32_t *)b;
return c1 - c2;
}
static void load_colormap(PaletteUseContext *s) static void load_colormap(PaletteUseContext *s)
{ {
int i, nb_used = 0; int i, nb_used = 0;
@ -735,12 +767,13 @@ static void load_colormap(PaletteUseContext *s)
uint32_t last_color = 0; uint32_t last_color = 0;
struct color_rect box; struct color_rect box;
if (s->transparency_index >= 0) { if (!s->use_alpha && s->transparency_index >= 0) {
FFSWAP(uint32_t, s->palette[s->transparency_index], s->palette[255]); FFSWAP(uint32_t, s->palette[s->transparency_index], s->palette[255]);
} }
/* disable transparent colors and dups */ /* disable transparent colors and dups */
qsort(s->palette, AVPALETTE_COUNT-(s->transparency_index >= 0), sizeof(*s->palette), cmp_pal_entry); qsort(s->palette, AVPALETTE_COUNT-(s->transparency_index >= 0), sizeof(*s->palette),
s->use_alpha ? cmp_pal_entry_alpha : cmp_pal_entry);
for (i = 0; i < AVPALETTE_COUNT; i++) { for (i = 0; i < AVPALETTE_COUNT; i++) {
const uint32_t c = s->palette[i]; const uint32_t c = s->palette[i];
@ -749,22 +782,22 @@ static void load_colormap(PaletteUseContext *s)
continue; continue;
} }
last_color = c; last_color = c;
if (c >> 24 < s->trans_thresh) { if (!s->use_alpha && c >> 24 < s->trans_thresh) {
color_used[i] = 1; // ignore transparent color(s) color_used[i] = 1; // ignore transparent color(s)
continue; continue;
} }
} }
box.min[0] = box.min[1] = box.min[2] = 0x00; box.min[0] = box.min[1] = box.min[2] = box.min[3] = 0x00;
box.max[0] = box.max[1] = box.max[2] = 0xff; box.max[0] = box.max[1] = box.max[2] = box.max[3] = 0xff;
colormap_insert(s->map, color_used, &nb_used, s->palette, s->trans_thresh, &box); colormap_insert(s->map, color_used, &nb_used, s, &box);
if (s->dot_filename) if (s->dot_filename)
disp_tree(s->map, s->dot_filename); disp_tree(s->map, s->dot_filename);
if (s->debug_accuracy) { if (s->debug_accuracy) {
if (!debug_accuracy(s->map, s->palette, s->trans_thresh, s->color_search_method)) if (!debug_accuracy(s))
av_log(NULL, AV_LOG_INFO, "Accuracy check passed\n"); av_log(NULL, AV_LOG_INFO, "Accuracy check passed\n");
} }
} }
@ -778,16 +811,18 @@ static void debug_mean_error(PaletteUseContext *s, const AVFrame *in1,
uint8_t *src2 = in2->data[0]; uint8_t *src2 = in2->data[0];
const int src1_linesize = in1->linesize[0] >> 2; const int src1_linesize = in1->linesize[0] >> 2;
const int src2_linesize = in2->linesize[0]; const int src2_linesize = in2->linesize[0];
const float div = in1->width * in1->height * 3; const float div = in1->width * in1->height * s->use_alpha ? 4 : 3;
unsigned mean_err = 0; unsigned mean_err = 0;
for (y = 0; y < in1->height; y++) { for (y = 0; y < in1->height; y++) {
for (x = 0; x < in1->width; x++) { for (x = 0; x < in1->width; x++) {
const uint32_t c1 = src1[x]; const uint32_t c1 = src1[x];
const uint32_t c2 = palette[src2[x]]; const uint32_t c2 = palette[src2[x]];
const uint8_t argb1[] = {0xff, c1 >> 16 & 0xff, c1 >> 8 & 0xff, c1 & 0xff}; const uint8_t a1 = s->use_alpha ? c1>>24 & 0xff : 0xff;
const uint8_t argb2[] = {0xff, c2 >> 16 & 0xff, c2 >> 8 & 0xff, c2 & 0xff}; const uint8_t a2 = s->use_alpha ? c2>>24 & 0xff : 0xff;
mean_err += diff(argb1, argb2, s->trans_thresh); const uint8_t argb1[] = {a1, c1 >> 16 & 0xff, c1 >> 8 & 0xff, c1 & 0xff};
const uint8_t argb2[] = {a2, c2 >> 16 & 0xff, c2 >> 8 & 0xff, c2 & 0xff};
mean_err += diff(argb1, argb2, s);
} }
src1 += src1_linesize; src1 += src1_linesize;
src2 += src2_linesize; src2 += src2_linesize;
@ -987,7 +1022,7 @@ static void load_palette(PaletteUseContext *s, const AVFrame *palette_frame)
for (y = 0; y < palette_frame->height; y++) { for (y = 0; y < palette_frame->height; y++) {
for (x = 0; x < palette_frame->width; x++) { for (x = 0; x < palette_frame->width; x++) {
s->palette[i] = p[x]; s->palette[i] = p[x];
if (p[x]>>24 < s->trans_thresh) { if (!s->use_alpha && p[x]>>24 < s->trans_thresh) {
s->transparency_index = i; // we are assuming at most one transparent color in palette s->transparency_index = i; // we are assuming at most one transparent color in palette
} }
i++; i++;

Write Preview
Loading…
Cancel
Save