avfilter/vf_blend: rename addition128 and difference128 to grainmerge and grainextract

doc/filters.texi

@@ -4854,13 +4854,13 @@ of @var{all_mode}. Default value is @code{normal}.
 Available values for component modes are:
 @table @samp
 @item addition
-@item addition128
+@item grainmerge
 @item and
 @item average
 @item burn
 @item darken
 @item difference
-@item difference128
+@item grainextract
 @item divide
 @item dodge
 @item freeze
@@ -4987,7 +4987,7 @@ blend=all_expr=if(gt(X,Y*(W/H)),A,B)
 @item
 Display differences between the current and the previous frame:
 @example
-tblend=all_mode=difference128
+tblend=all_mode=grainextract
 @end example
 @end itemize
 

libavfilter/blend.h

@@ -33,7 +33,7 @@ enum BlendMode {
     BLEND_BURN,
     BLEND_DARKEN,
     BLEND_DIFFERENCE,
-    BLEND_DIFFERENCE128,
+    BLEND_GRAINEXTRACT,
     BLEND_DIVIDE,
     BLEND_DODGE,
     BLEND_EXCLUSION,
@@ -54,7 +54,7 @@ enum BlendMode {
     BLEND_HARDMIX,
     BLEND_LINEARLIGHT,
     BLEND_GLOW,
-    BLEND_ADDITION128,
+    BLEND_GRAINMERGE,
     BLEND_MULTIPLY128,
     BLEND_HEAT,
     BLEND_FREEZE,

libavfilter/vf_blend.c

@@ -66,13 +66,15 @@ typedef struct ThreadData {
     { "c3_mode", "set component #3 blend mode", OFFSET(params[3].mode), AV_OPT_TYPE_INT, {.i64=0}, 0, BLEND_NB-1, FLAGS, "mode"},\
     { "all_mode", "set blend mode for all components", OFFSET(all_mode), AV_OPT_TYPE_INT, {.i64=-1},-1, BLEND_NB-1, FLAGS, "mode"},\
     { "addition",   "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_ADDITION},   0, 0, FLAGS, "mode" },\
-    { "addition128", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_ADDITION128}, 0, 0, FLAGS, "mode" },\
+    { "addition128","", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GRAINMERGE}, 0, 0, FLAGS, "mode" },\
+    { "grainmerge", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GRAINMERGE}, 0, 0, FLAGS, "mode" },\
     { "and",        "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_AND},        0, 0, FLAGS, "mode" },\
     { "average",    "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_AVERAGE},    0, 0, FLAGS, "mode" },\
     { "burn",       "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_BURN},       0, 0, FLAGS, "mode" },\
     { "darken",     "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DARKEN},     0, 0, FLAGS, "mode" },\
     { "difference", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIFFERENCE}, 0, 0, FLAGS, "mode" },\
-    { "difference128", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIFFERENCE128}, 0, 0, FLAGS, "mode" },\
+    { "difference128", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GRAINEXTRACT}, 0, 0, FLAGS, "mode" },\
+    { "grainextract", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GRAINEXTRACT}, 0, 0, FLAGS, "mode" },\
     { "divide",     "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIVIDE},     0, 0, FLAGS, "mode" },\
     { "dodge",      "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DODGE},      0, 0, FLAGS, "mode" },\
     { "exclusion",  "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_EXCLUSION},  0, 0, FLAGS, "mode" },\
@@ -236,7 +238,7 @@ static void blend_## name##_16bit(const uint8_t *_top, ptrdiff_t top_linesize,
 #define DODGE(a, b)       (((a) == 255) ? (a) : FFMIN(255, (((b) << 8) / (255 - (a)))))
 
 DEFINE_BLEND8(addition,   FFMIN(255, A + B))
-DEFINE_BLEND8(addition128, av_clip_uint8(A + B - 128))
+DEFINE_BLEND8(grainmerge, av_clip_uint8(A + B - 128))
 DEFINE_BLEND8(average,    (A + B) / 2)
 DEFINE_BLEND8(subtract,   FFMAX(0, A - B))
 DEFINE_BLEND8(multiply,   MULTIPLY(1, A, B))
@@ -244,7 +246,7 @@ DEFINE_BLEND8(multiply128,av_clip_uint8((A - 128) * B / 32. + 128))
 DEFINE_BLEND8(negation,   255 - FFABS(255 - A - B))
 DEFINE_BLEND8(extremity,  FFABS(255 - A - B))
 DEFINE_BLEND8(difference, FFABS(A - B))
-DEFINE_BLEND8(difference128, av_clip_uint8(128 + A - B))
+DEFINE_BLEND8(grainextract, av_clip_uint8(128 + A - B))
 DEFINE_BLEND8(screen,     SCREEN(1, A, B))
 DEFINE_BLEND8(overlay,    (A < 128) ? MULTIPLY(2, A, B) : SCREEN(2, A, B))
 DEFINE_BLEND8(hardlight,  (B < 128) ? MULTIPLY(2, B, A) : SCREEN(2, B, A))
@@ -279,7 +281,7 @@ DEFINE_BLEND8(linearlight,av_clip_uint8((B < 128) ? B + 2 * A - 255 : B + 2 * (A
 #define DODGE(a, b)       (((a) == 65535) ? (a) : FFMIN(65535, (((b) << 16) / (65535 - (a)))))
 
 DEFINE_BLEND16(addition,   FFMIN(65535, A + B))
-DEFINE_BLEND16(addition128, av_clip_uint16(A + B - 32768))
+DEFINE_BLEND16(grainmerge, av_clip_uint16(A + B - 32768))
 DEFINE_BLEND16(average,    (A + B) / 2)
 DEFINE_BLEND16(subtract,   FFMAX(0, A - B))
 DEFINE_BLEND16(multiply,   MULTIPLY(1, A, B))
@@ -287,7 +289,7 @@ DEFINE_BLEND16(multiply128, av_clip_uint16((A - 32768) * B / 8192. + 32768))
 DEFINE_BLEND16(negation,   65535 - FFABS(65535 - A - B))
 DEFINE_BLEND16(extremity,  FFABS(65535 - A - B))
 DEFINE_BLEND16(difference, FFABS(A - B))
-DEFINE_BLEND16(difference128, av_clip_uint16(32768 + A - B))
+DEFINE_BLEND16(grainextract, av_clip_uint16(32768 + A - B))
 DEFINE_BLEND16(screen,     SCREEN(1, A, B))
 DEFINE_BLEND16(overlay,    (A < 32768) ? MULTIPLY(2, A, B) : SCREEN(2, A, B))
 DEFINE_BLEND16(hardlight,  (B < 32768) ? MULTIPLY(2, B, A) : SCREEN(2, B, A))
@@ -450,13 +452,13 @@ void ff_blend_init(FilterParams *param, int is_16bit)
 {
     switch (param->mode) {
     case BLEND_ADDITION:   param->blend = is_16bit ? blend_addition_16bit   : blend_addition_8bit;   break;
-    case BLEND_ADDITION128: param->blend = is_16bit ? blend_addition128_16bit : blend_addition128_8bit; break;
+    case BLEND_GRAINMERGE: param->blend = is_16bit ? blend_grainmerge_16bit : blend_grainmerge_8bit; break;
     case BLEND_AND:        param->blend = is_16bit ? blend_and_16bit        : blend_and_8bit;        break;
     case BLEND_AVERAGE:    param->blend = is_16bit ? blend_average_16bit    : blend_average_8bit;    break;
     case BLEND_BURN:       param->blend = is_16bit ? blend_burn_16bit       : blend_burn_8bit;       break;
     case BLEND_DARKEN:     param->blend = is_16bit ? blend_darken_16bit     : blend_darken_8bit;     break;
     case BLEND_DIFFERENCE: param->blend = is_16bit ? blend_difference_16bit : blend_difference_8bit; break;
-    case BLEND_DIFFERENCE128: param->blend = is_16bit ? blend_difference128_16bit: blend_difference128_8bit; break;
+    case BLEND_GRAINEXTRACT: param->blend = is_16bit ? blend_grainextract_16bit: blend_grainextract_8bit; break;
     case BLEND_DIVIDE:     param->blend = is_16bit ? blend_divide_16bit     : blend_divide_8bit;     break;
     case BLEND_DODGE:      param->blend = is_16bit ? blend_dodge_16bit      : blend_dodge_8bit;      break;
     case BLEND_EXCLUSION:  param->blend = is_16bit ? blend_exclusion_16bit  : blend_exclusion_8bit;  break;

libavfilter/x86/vf_blend.asm

@@ -83,7 +83,7 @@ BLEND_SIMPLE subtract, subusb
 BLEND_SIMPLE darken,   minub
 BLEND_SIMPLE lighten,  maxub
 
-BLEND_INIT difference128, 4
+BLEND_INIT grainextract, 4
     pxor       m2, m2
     mova       m3, [pw_128]
 .nextrow:
@@ -181,7 +181,7 @@ BLEND_INIT average, 3
     jl .loop
 BLEND_END
 
-BLEND_INIT addition128, 4
+BLEND_INIT grainmerge, 4
     pxor       m2, m2
     mova       m3, [pw_128]
 .nextrow:

libavfilter/x86/vf_blend_init.c

@@ -31,11 +31,11 @@ void ff_blend_##name##_##opt(const uint8_t *top, ptrdiff_t top_linesize,       \
                              struct FilterParams *param, double *values, int starty);
 
 BLEND_FUNC(addition, sse2)
-BLEND_FUNC(addition128, sse2)
+BLEND_FUNC(grainmerge, sse2)
 BLEND_FUNC(average, sse2)
 BLEND_FUNC(and, sse2)
 BLEND_FUNC(darken, sse2)
-BLEND_FUNC(difference128, sse2)
+BLEND_FUNC(grainextract, sse2)
 BLEND_FUNC(multiply, sse2)
 BLEND_FUNC(screen, sse2)
 BLEND_FUNC(hardmix, sse2)
@@ -59,29 +59,29 @@ av_cold void ff_blend_init_x86(FilterParams *param, int is_16bit)
     if (EXTERNAL_SSE2(cpu_flags) && param->opacity == 1 && !is_16bit) {
         switch (param->mode) {
         case BLEND_ADDITION: param->blend = ff_blend_addition_sse2; break;
-        case BLEND_ADDITION128: param->blend = ff_blend_addition128_sse2; break;
+        case BLEND_GRAINMERGE: param->blend = ff_blend_grainmerge_sse2; break;
         case BLEND_AND:      param->blend = ff_blend_and_sse2;      break;
         case BLEND_AVERAGE:  param->blend = ff_blend_average_sse2;  break;
         case BLEND_DARKEN:   param->blend = ff_blend_darken_sse2;   break;
-        case BLEND_DIFFERENCE128: param->blend = ff_blend_difference128_sse2; break;
+        case BLEND_GRAINEXTRACT: param->blend = ff_blend_grainextract_sse2; break;
         case BLEND_DIVIDE:   param->blend = ff_blend_divide_sse2;   break;
         case BLEND_HARDMIX:  param->blend = ff_blend_hardmix_sse2;  break;
         case BLEND_LIGHTEN:  param->blend = ff_blend_lighten_sse2;  break;
         case BLEND_MULTIPLY: param->blend = ff_blend_multiply_sse2; break;
         case BLEND_OR:       param->blend = ff_blend_or_sse2;       break;
         case BLEND_PHOENIX:  param->blend = ff_blend_phoenix_sse2;  break;
-        case BLEND_SCREEN:   param->blend = ff_blend_screen_sse2; break;
+        case BLEND_SCREEN:   param->blend = ff_blend_screen_sse2;   break;
         case BLEND_SUBTRACT: param->blend = ff_blend_subtract_sse2; break;
         case BLEND_XOR:      param->blend = ff_blend_xor_sse2;      break;
         case BLEND_DIFFERENCE: param->blend = ff_blend_difference_sse2; break;
-        case BLEND_EXTREMITY:  param->blend = ff_blend_extremity_sse2; break;
+        case BLEND_EXTREMITY:  param->blend = ff_blend_extremity_sse2;  break;
         case BLEND_NEGATION:   param->blend = ff_blend_negation_sse2;   break;
         }
     }
     if (EXTERNAL_SSSE3(cpu_flags) && param->opacity == 1 && !is_16bit) {
         switch (param->mode) {
         case BLEND_DIFFERENCE: param->blend = ff_blend_difference_ssse3; break;
-        case BLEND_EXTREMITY:  param->blend = ff_blend_extremity_ssse3; break;
+        case BLEND_EXTREMITY:  param->blend = ff_blend_extremity_ssse3;  break;
         case BLEND_NEGATION:   param->blend = ff_blend_negation_ssse3;   break;
         }
     }