@@ -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

@@ -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,

@@ -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;

@@ -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:

@@ -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;

         }

     }