PR #25781 opened by Niklas Haas (haasn)
URL: https://code.ffmpeg.org/FFmpeg/FFmpeg/pulls/25781
Patch URL: https://code.ffmpeg.org/FFmpeg/FFmpeg/pulls/25781.patch

The only difference is that MUL takes a vec4 data instead of a scalar. The 
performance difference between this and scalar multiply was inconsequential. 
The upside is that a vector MUL allows us to replace the (inefficient) diagonal 
linear kernels by a regular vector multiply.

This is also one step closer to nuking my (hated) SWS_OP_SCALE and replacing it 
by integer linear ops everywhere, but that's a larger change so I held off on 
it for this PR.


>From 24ff2caa00325695a996498cdee61cc43184ba07 Mon Sep 17 00:00:00 2001
From: Niklas Haas <[email protected]>
Date: Wed, 4 Nov 2026 22:14:33 +0100
Subject: [PATCH 1/5] swscale/uops: rename SWS_UOP_SCALE to SWS_UOP_MUL
 (cosmetic)

Preparation for turning it into a per-component multiplication, in line
with SWS_UOP_ADD/MIN/MAX. No functional change.

The x86 kernel macro is named MUL_OP because MUL is already used as a
single-line macro by the linear and filter kernels.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Signed-off-by: Niklas Haas <[email protected]>
---
 libswscale/aarch64/ops.c           |  2 +-
 libswscale/aarch64/ops_asmgen.c    |  6 ++--
 libswscale/aarch64/ops_entries.c   | 22 ++++++------
 libswscale/aarch64/ops_static.c    |  8 ++---
 libswscale/ops_optimizer.c         |  4 +--
 libswscale/tests/sws_ops_aarch64.c |  4 +--
 libswscale/uops.c                  |  2 +-
 libswscale/uops.h                  |  2 +-
 libswscale/uops_backend.c          |  2 +-
 libswscale/uops_list.h             |  2 +-
 libswscale/uops_macros.h           | 56 +++++++++++++++---------------
 libswscale/uops_tmpl.c             |  6 ++--
 libswscale/vulkan/ops.c            |  2 +-
 libswscale/x86/ops.c               |  6 ++--
 libswscale/x86/ops_float.asm       |  4 +--
 libswscale/x86/ops_int.asm         |  4 +--
 libswscale/x86/uops_macros.asm     | 28 +++++++--------
 libswscale/x86/uops_macros.h       | 56 +++++++++++++++---------------
 tests/checkasm/sw_ops.c            |  2 +-
 tests/ref/fate/sws-ops-list        |  2 +-
 20 files changed, 110 insertions(+), 110 deletions(-)

diff --git a/libswscale/aarch64/ops.c b/libswscale/aarch64/ops.c
index 0c4fb7d7682..edce195f10b 100644
--- a/libswscale/aarch64/ops.c
+++ b/libswscale/aarch64/ops.c
@@ -139,7 +139,7 @@ static int aarch64_setup(const SwsUOp *uop, const 
SwsAArch64OpImplParams *p,
     case SWS_UOP_MIN:
     case SWS_UOP_MAX:
         return ff_sws_setup_vec4(&(const SwsImplParams) { .uop = uop }, out);
-    case SWS_UOP_SCALE:
+    case SWS_UOP_MUL:
         return ff_sws_setup_scalar(&(const SwsImplParams) { .uop = uop }, out);
     case SWS_UOP_LINEAR:
     case SWS_UOP_LINEAR_FMA:
diff --git a/libswscale/aarch64/ops_asmgen.c b/libswscale/aarch64/ops_asmgen.c
index b2eb0b178d4..40834e3ae99 100644
--- a/libswscale/aarch64/ops_asmgen.c
+++ b/libswscale/aarch64/ops_asmgen.c
@@ -812,10 +812,10 @@ static void asmgen_op_max(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *p,
 
 /*********************************************************************/
 /* multiplication by scalar */
-/* SWS_UOP_SCALE */
+/* SWS_UOP_MUL */
 
-static void asmgen_op_scale(SwsAArch64Context *s, const SwsAArch64OpImplParams 
*p,
-                            SwsAArch64OpRegs *regs)
+static void asmgen_op_mul(SwsAArch64Context *s, const SwsAArch64OpImplParams 
*p,
+                          SwsAArch64OpRegs *regs)
 {
     RasmContext *r = s->rctx;
     RasmOp *sl       = regs->sl;
diff --git a/libswscale/aarch64/ops_entries.c b/libswscale/aarch64/ops_entries.c
index c2487e5a0cc..22c13a6cc6e 100644
--- a/libswscale/aarch64/ops_entries.c
+++ b/libswscale/aarch64/ops_entries.c
@@ -234,17 +234,17 @@ ENTRY(ff_sws_to_f32_8_u32_0010_neon,                { 
.uop = SWS_UOP_TO_F32,
 ENTRY(ff_sws_to_f32_8_u32_0100_neon,                { .uop = SWS_UOP_TO_F32,   
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x4 })
 ENTRY(ff_sws_to_f32_8_u32_0111_neon,                { .uop = SWS_UOP_TO_F32,   
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x7 })
 ENTRY(ff_sws_to_f32_8_u32_1110_neon,                { .uop = SWS_UOP_TO_F32,   
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0xe })
-ENTRY(ff_sws_scale_8_u32_0001_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x1 })
-ENTRY(ff_sws_scale_8_u32_0111_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x7 })
-ENTRY(ff_sws_scale_8_f32_0001_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1 })
-ENTRY(ff_sws_scale_8_f32_0011_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x3 })
-ENTRY(ff_sws_scale_8_f32_0111_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7 })
-ENTRY(ff_sws_scale_8_f32_1110_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xe })
-ENTRY(ff_sws_scale_8_f32_1111_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf })
-ENTRY(ff_sws_scale_16_u8_0001_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x1 })
-ENTRY(ff_sws_scale_16_u8_0111_neon,                 { .uop = SWS_UOP_SCALE,    
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x7 })
-ENTRY(ff_sws_scale_16_u16_0001_neon,                { .uop = SWS_UOP_SCALE,    
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0x1 })
-ENTRY(ff_sws_scale_16_u16_0111_neon,                { .uop = SWS_UOP_SCALE,    
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0x7 })
+ENTRY(ff_sws_mul_8_u32_0001_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x1 })
+ENTRY(ff_sws_mul_8_u32_0111_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x7 })
+ENTRY(ff_sws_mul_8_f32_0001_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1 })
+ENTRY(ff_sws_mul_8_f32_0011_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x3 })
+ENTRY(ff_sws_mul_8_f32_0111_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7 })
+ENTRY(ff_sws_mul_8_f32_1110_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xe })
+ENTRY(ff_sws_mul_8_f32_1111_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf })
+ENTRY(ff_sws_mul_16_u8_0001_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x1 })
+ENTRY(ff_sws_mul_16_u8_0111_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x7 })
+ENTRY(ff_sws_mul_16_u16_0001_neon,                  { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0x1 })
+ENTRY(ff_sws_mul_16_u16_0111_neon,                  { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0x7 })
 ENTRY(ff_sws_min_8_f32_0001_neon,                   { .uop = SWS_UOP_MIN,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1 })
 ENTRY(ff_sws_min_8_f32_0010_neon,                   { .uop = SWS_UOP_MIN,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x2 })
 ENTRY(ff_sws_min_8_f32_0011_neon,                   { .uop = SWS_UOP_MIN,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x3 })
diff --git a/libswscale/aarch64/ops_static.c b/libswscale/aarch64/ops_static.c
index 2a7933d6752..a8ea437454f 100644
--- a/libswscale/aarch64/ops_static.c
+++ b/libswscale/aarch64/ops_static.c
@@ -270,8 +270,8 @@ static void asmgen_setup_max(SwsAArch64Context *s, const 
SwsAArch64OpImplParams
     LOOP_MASK(p, i) { i_dup(r, vk[i], a64op_elem(max_vec, i));      CMTF("v128 
vmax%u = max_vec[%u];", i, i); }
 }
 
-static void asmgen_setup_scale(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *p,
-                               SwsAArch64OpRegs *regs)
+static void asmgen_setup_mul(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *p,
+                             SwsAArch64OpRegs *regs)
 {
     RasmContext *r = s->rctx;
     RasmOp scale_vec = regs->vk[0];
@@ -586,7 +586,7 @@ static void asmgen_op_cps(SwsAArch64Context *s, const 
SwsAArch64OpEntry *entry)
     case SWS_UOP_CLEAR:        asmgen_setup_clear(s, p, &s->regs);        
break;
     case SWS_UOP_MIN:          asmgen_setup_min(s, p, &s->regs);          
break;
     case SWS_UOP_MAX:          asmgen_setup_max(s, p, &s->regs);          
break;
-    case SWS_UOP_SCALE:        asmgen_setup_scale(s, p, &s->regs);        
break;
+    case SWS_UOP_MUL:          asmgen_setup_mul(s, p, &s->regs);          
break;
     case SWS_UOP_LINEAR:       asmgen_setup_linear(s, p, &s->regs);       
break;
     case SWS_UOP_LINEAR_FMA:   asmgen_setup_linear(s, p, &s->regs);       
break;
     case SWS_UOP_DITHER:       asmgen_setup_dither(s, p, &s->regs);       
break;
@@ -620,7 +620,7 @@ static void asmgen_op_cps(SwsAArch64Context *s, const 
SwsAArch64OpEntry *entry)
     case SWS_UOP_EXPAND_QUAD:  asmgen_op_expand(s, p, &s->regs);       break;
     case SWS_UOP_MIN:          asmgen_op_min(s, p, &s->regs);          break;
     case SWS_UOP_MAX:          asmgen_op_max(s, p, &s->regs);          break;
-    case SWS_UOP_SCALE:        asmgen_op_scale(s, p, &s->regs);        break;
+    case SWS_UOP_MUL:          asmgen_op_mul(s, p, &s->regs);          break;
     case SWS_UOP_LINEAR:       asmgen_op_linear(s, p, &s->regs);       break;
     case SWS_UOP_LINEAR_FMA:   asmgen_op_linear(s, p, &s->regs);       break;
     case SWS_UOP_DITHER:       asmgen_op_dither(s, p, &s->regs);       break;
diff --git a/libswscale/ops_optimizer.c b/libswscale/ops_optimizer.c
index 731dffbf027..aedd4400629 100644
--- a/libswscale/ops_optimizer.c
+++ b/libswscale/ops_optimizer.c
@@ -1047,7 +1047,7 @@ static int solve_shuffle(const SwsUOpList *const uops, 
SwsUOp *out)
 /* Only checks exact integer scale ops */
 static bool is_scale(const SwsUOp *op, int64_t val)
 {
-    if (op->uop != SWS_UOP_SCALE)
+    if (op->uop != SWS_UOP_MUL)
         return false;
 
     switch (op->type) {
@@ -1084,7 +1084,7 @@ retry:
             }
             break;
 
-        case SWS_UOP_SCALE:
+        case SWS_UOP_MUL:
             if (flags & SWS_UOP_FLAG_EXPAND_BIT) {
                 const int bits = 8 * ff_sws_pixel_type_size(op->type);
                 if (is_scale(op, UINT64_MAX >> (64 - bits))) {
diff --git a/libswscale/tests/sws_ops_aarch64.c 
b/libswscale/tests/sws_ops_aarch64.c
index 3a56d71f593..4a9729c1779 100644
--- a/libswscale/tests/sws_ops_aarch64.c
+++ b/libswscale/tests/sws_ops_aarch64.c
@@ -300,7 +300,7 @@ static const char op_type_names[SWS_UOP_TYPE_NB][16] = {
     [SWS_UOP_EXPAND_QUAD   ] = "expand_quad",
     [SWS_UOP_MIN           ] = "min",
     [SWS_UOP_MAX           ] = "max",
-    [SWS_UOP_SCALE         ] = "scale",
+    [SWS_UOP_MUL           ] = "mul",
     [SWS_UOP_LINEAR        ] = "linear",
     [SWS_UOP_LINEAR_FMA    ] = "linear_fma",
     [SWS_UOP_DITHER        ] = "dither",
@@ -338,7 +338,7 @@ static const char uop_types[SWS_UOP_TYPE_NB][32] = {
     [SWS_UOP_EXPAND_QUAD   ] = "SWS_UOP_EXPAND_QUAD",
     [SWS_UOP_MIN           ] = "SWS_UOP_MIN",
     [SWS_UOP_MAX           ] = "SWS_UOP_MAX",
-    [SWS_UOP_SCALE         ] = "SWS_UOP_SCALE",
+    [SWS_UOP_MUL           ] = "SWS_UOP_MUL",
     [SWS_UOP_LINEAR        ] = "SWS_UOP_LINEAR",
     [SWS_UOP_LINEAR_FMA    ] = "SWS_UOP_LINEAR_FMA",
     [SWS_UOP_DITHER        ] = "SWS_UOP_DITHER",
diff --git a/libswscale/uops.c b/libswscale/uops.c
index 54d5581107f..5797f9e4267 100644
--- a/libswscale/uops.c
+++ b/libswscale/uops.c
@@ -611,7 +611,7 @@ static int translate_op(SwsContext *ctx, SwsUOpList *uops, 
SwsUOpFlags flags,
         }
         break;
     case SWS_OP_SCALE:
-        uop.uop = SWS_UOP_SCALE;
+        uop.uop = SWS_UOP_MUL;
         uop.data.scalar = ff_sws_pixel_from_q64(uop.type, op->scale.factor);
         break;
     case SWS_OP_MIN:
diff --git a/libswscale/uops.h b/libswscale/uops.h
index 4d25107927b..5660bf9c42c 100644
--- a/libswscale/uops.h
+++ b/libswscale/uops.h
@@ -191,7 +191,7 @@ typedef enum SwsUOpType {
     SWS_UOP_TO_F32,          /* cast pixel values to SWS_PIXEL_F32 */
 
     /* Arithmetic uops */
-    SWS_UOP_SCALE,           /* multiply masked components by scalar */
+    SWS_UOP_MUL,             /* multiply masked components by scalar */
     SWS_UOP_ADD,             /* add vec4 to masked components */
     SWS_UOP_MIN,             /* min(x, vec4) on masked components */
     SWS_UOP_MAX,             /* max(x, vec4) on masked components */
diff --git a/libswscale/uops_backend.c b/libswscale/uops_backend.c
index 1fd07fdeeec..861d9897505 100644
--- a/libswscale/uops_backend.c
+++ b/libswscale/uops_backend.c
@@ -81,7 +81,7 @@
     SWS_FOR(TYPE, TO_U16,         REF_ENTRY)                \
     SWS_FOR(TYPE, TO_U32,         REF_ENTRY)                \
     SWS_FOR(TYPE, TO_F32,         REF_ENTRY)                \
-    SWS_FOR(TYPE, SCALE,          REF_ENTRY)                \
+    SWS_FOR(TYPE, MUL,            REF_ENTRY)                \
     SWS_FOR(TYPE, ADD,            REF_ENTRY)                \
     SWS_FOR(TYPE, MIN,            REF_ENTRY)                \
     SWS_FOR(TYPE, MAX,            REF_ENTRY)                \
diff --git a/libswscale/uops_list.h b/libswscale/uops_list.h
index 31632dfcc0f..bad63d40683 100644
--- a/libswscale/uops_list.h
+++ b/libswscale/uops_list.h
@@ -45,7 +45,7 @@
     ENTRY(SWS_UOP_TO_U16,               "to_u16")                    \
     ENTRY(SWS_UOP_TO_U32,               "to_u32")                    \
     ENTRY(SWS_UOP_TO_F32,               "to_f32")                    \
-    ENTRY(SWS_UOP_SCALE,                "scale")                     \
+    ENTRY(SWS_UOP_MUL,                  "mul")                       \
     ENTRY(SWS_UOP_LINEAR,               "linear")                    \
     ENTRY(SWS_UOP_LINEAR_FMA,           "linear_fma")                \
     ENTRY(SWS_UOP_ADD,                  "add")                       \
diff --git a/libswscale/uops_macros.h b/libswscale/uops_macros.h
index acad94d2f82..7ca879f3084 100644
--- a/libswscale/uops_macros.h
+++ b/libswscale/uops_macros.h
@@ -227,10 +227,10 @@
     MACRO(__VA_ARGS__, u8_to_f32_zw                            , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xc) \
     MACRO(__VA_ARGS__, u8_to_f32_yzw                           , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xe) \
     MACRO(__VA_ARGS__, u8_to_f32_xyzw                          , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xf)
-#define SWS_FOR_U8_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u8_scale_xyz                            , SWS_PIXEL_U8 
, SWS_UOP_SCALE           , 0x7)
-#define SWS_FOR_STRUCT_U8_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u8_scale_xyz                            , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_SCALE           , .mask = 0x7)
+#define SWS_FOR_U8_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u8_mul_xyz                              , SWS_PIXEL_U8 
, SWS_UOP_MUL             , 0x7)
+#define SWS_FOR_STRUCT_U8_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u8_mul_xyz                              , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_MUL             , .mask = 0x7)
 #define SWS_FOR_U8_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U8_ADD(MACRO, ...)
 #define SWS_FOR_U8_MIN(MACRO, ...)
@@ -473,12 +473,12 @@
     MACRO(__VA_ARGS__, u16_to_f32_xyz                          , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32          , .mask = 0x7) \
     MACRO(__VA_ARGS__, u16_to_f32_yzw                          , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32          , .mask = 0xe) \
     MACRO(__VA_ARGS__, u16_to_f32_xyzw                         , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32          , .mask = 0xf)
-#define SWS_FOR_U16_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u16_scale_x                             , 
SWS_PIXEL_U16, SWS_UOP_SCALE           , 0x1) \
-    MACRO(__VA_ARGS__, u16_scale_xyz                           , 
SWS_PIXEL_U16, SWS_UOP_SCALE           , 0x7)
-#define SWS_FOR_STRUCT_U16_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u16_scale_x                             , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_SCALE           , .mask = 0x1) \
-    MACRO(__VA_ARGS__, u16_scale_xyz                           , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_SCALE           , .mask = 0x7)
+#define SWS_FOR_U16_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u16_mul_x                               , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x1) \
+    MACRO(__VA_ARGS__, u16_mul_xyz                             , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x7)
+#define SWS_FOR_STRUCT_U16_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u16_mul_x                               , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x1) \
+    MACRO(__VA_ARGS__, u16_mul_xyz                             , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x7)
 #define SWS_FOR_U16_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U16_ADD(MACRO, ...)
 #define SWS_FOR_U16_MIN(MACRO, ...)
@@ -751,12 +751,12 @@
     MACRO(__VA_ARGS__, u32_to_f32_z                            , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32          , .mask = 0x4) \
     MACRO(__VA_ARGS__, u32_to_f32_xyz                          , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32          , .mask = 0x7) \
     MACRO(__VA_ARGS__, u32_to_f32_yzw                          , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32          , .mask = 0xe)
-#define SWS_FOR_U32_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u32_scale_x                             , 
SWS_PIXEL_U32, SWS_UOP_SCALE           , 0x1) \
-    MACRO(__VA_ARGS__, u32_scale_xyz                           , 
SWS_PIXEL_U32, SWS_UOP_SCALE           , 0x7)
-#define SWS_FOR_STRUCT_U32_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u32_scale_x                             , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_SCALE           , .mask = 0x1) \
-    MACRO(__VA_ARGS__, u32_scale_xyz                           , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_SCALE           , .mask = 0x7)
+#define SWS_FOR_U32_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u32_mul_x                               , 
SWS_PIXEL_U32, SWS_UOP_MUL             , 0x1) \
+    MACRO(__VA_ARGS__, u32_mul_xyz                             , 
SWS_PIXEL_U32, SWS_UOP_MUL             , 0x7)
+#define SWS_FOR_STRUCT_U32_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u32_mul_x                               , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_MUL             , .mask = 0x1) \
+    MACRO(__VA_ARGS__, u32_mul_xyz                             , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_MUL             , .mask = 0x7)
 #define SWS_FOR_U32_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U32_ADD(MACRO, ...)
 #define SWS_FOR_U32_MIN(MACRO, ...)
@@ -911,18 +911,18 @@
     MACRO(__VA_ARGS__, f32_to_u32_xyzw                         , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_TO_U32          , .mask = 0xf)
 #define SWS_FOR_F32_TO_F32(MACRO, ...)
 #define SWS_FOR_STRUCT_F32_TO_F32(MACRO, ...)
-#define SWS_FOR_F32_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, f32_scale_x                             , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0x1) \
-    MACRO(__VA_ARGS__, f32_scale_xy                            , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0x3) \
-    MACRO(__VA_ARGS__, f32_scale_xyz                           , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0x7) \
-    MACRO(__VA_ARGS__, f32_scale_yzw                           , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0xe) \
-    MACRO(__VA_ARGS__, f32_scale_xyzw                          , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0xf)
-#define SWS_FOR_STRUCT_F32_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, f32_scale_x                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0x1) \
-    MACRO(__VA_ARGS__, f32_scale_xy                            , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0x3) \
-    MACRO(__VA_ARGS__, f32_scale_xyz                           , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0x7) \
-    MACRO(__VA_ARGS__, f32_scale_yzw                           , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0xe) \
-    MACRO(__VA_ARGS__, f32_scale_xyzw                          , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0xf)
+#define SWS_FOR_F32_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, f32_mul_x                               , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x1) \
+    MACRO(__VA_ARGS__, f32_mul_xy                              , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x3) \
+    MACRO(__VA_ARGS__, f32_mul_xyz                             , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x7) \
+    MACRO(__VA_ARGS__, f32_mul_yzw                             , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0xe) \
+    MACRO(__VA_ARGS__, f32_mul_xyzw                            , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0xf)
+#define SWS_FOR_STRUCT_F32_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, f32_mul_x                               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x1) \
+    MACRO(__VA_ARGS__, f32_mul_xy                              , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x3) \
+    MACRO(__VA_ARGS__, f32_mul_xyz                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x7) \
+    MACRO(__VA_ARGS__, f32_mul_yzw                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0xe) \
+    MACRO(__VA_ARGS__, f32_mul_xyzw                            , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0xf)
 #define SWS_FOR_F32_ADD(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_add_x                               , 
SWS_PIXEL_F32, SWS_UOP_ADD             , 0x1) \
     MACRO(__VA_ARGS__, f32_add_xy                              , 
SWS_PIXEL_F32, SWS_UOP_ADD             , 0x3) \
diff --git a/libswscale/uops_tmpl.c b/libswscale/uops_tmpl.c
index 56e28749b12..78c021e6ebb 100644
--- a/libswscale/uops_tmpl.c
+++ b/libswscale/uops_tmpl.c
@@ -665,7 +665,7 @@ SWS_FOR_STRUCT(PX, CLEAR, DECL_ENTRY, .setup = 
ff_sws_setup_vec4)
  * Arithmetic operations *
  *************************/
 
-DECL_FUNC(scale, const SwsCompMask mask)
+DECL_FUNC(mul, const SwsCompMask mask)
 {
     const pixel_t scale = impl->priv.px[0];
 
@@ -719,11 +719,11 @@ DECL_FUNC(max, const SwsCompMask mask)
     CONTINUE(x, y, z, w);
 }
 
-SWS_FOR(PX, SCALE, DECL_IMPL, scale)
+SWS_FOR(PX, MUL,   DECL_IMPL, mul)
 SWS_FOR(PX, ADD,   DECL_IMPL, add)
 SWS_FOR(PX, MIN,   DECL_IMPL, min)
 SWS_FOR(PX, MAX,   DECL_IMPL, max)
-SWS_FOR_STRUCT(PX, SCALE, DECL_ENTRY, .setup = ff_sws_setup_scalar )
+SWS_FOR_STRUCT(PX, MUL,   DECL_ENTRY, .setup = ff_sws_setup_scalar )
 SWS_FOR_STRUCT(PX, ADD,   DECL_ENTRY, .setup = ff_sws_setup_vec4 )
 SWS_FOR_STRUCT(PX, MIN,   DECL_ENTRY, .setup = ff_sws_setup_vec4 )
 SWS_FOR_STRUCT(PX, MAX,   DECL_ENTRY, .setup = ff_sws_setup_vec4 )
diff --git a/libswscale/vulkan/ops.c b/libswscale/vulkan/ops.c
index f18be1efe20..5e8bb13651e 100644
--- a/libswscale/vulkan/ops.c
+++ b/libswscale/vulkan/ops.c
@@ -1183,7 +1183,7 @@ static int emit_shader(SwsContext *sws, VulkanPriv *p, 
FFVulkanOpsCtx *s,
                 data = spi_OpShiftRightLogical(spi, type_v, data, shift_v);
             break;
         }
-        case SWS_UOP_SCALE:
+        case SWS_UOP_MUL:
             data = emit_mul(spi, uop->type, type_v, data,
                             const_splat(spi, id, uop->type, uop->data.scalar));
             break;
diff --git a/libswscale/x86/ops.c b/libswscale/x86/ops.c
index 9cc5ba7a0aa..dc5037df25c 100644
--- a/libswscale/x86/ops.c
+++ b/libswscale/x86/ops.c
@@ -248,7 +248,7 @@ static int setup_filter_h_4x4(const SwsImplParams *params, 
SwsImplResult *out)
     return 0;
 }
 
-static int setup_scale(const SwsImplParams *params, SwsImplResult *out)
+static int setup_mul(const SwsImplParams *params, SwsImplResult *out)
 {
     const SwsUOp *uop = params->uop;
     switch (uop->type) {
@@ -360,7 +360,7 @@ SWS_FOR_STRUCT(TYPE, SWAP_BYTES,      DECL_ENTRY, EXT, 
NULL, NULL)
 SWS_FOR_STRUCT(TYPE, EXPAND_BIT,      DECL_ENTRY, EXT, NULL, NULL)             
 \
 SWS_FOR_STRUCT(TYPE, PERMUTE,         DECL_ENTRY, EXT, NULL, NULL)             
 \
 SWS_FOR_STRUCT(TYPE, COPY,            DECL_ENTRY, EXT, NULL, NULL)             
 \
-SWS_FOR_STRUCT(TYPE, SCALE,           DECL_ENTRY, EXT, NULL, setup_scale)      
 \
+SWS_FOR_STRUCT(TYPE, MUL,             DECL_ENTRY, EXT, NULL, setup_mul)        
 \
 SWS_FOR_STRUCT(TYPE, ADD,             DECL_ENTRY, EXT, NULL, 
ff_sws_setup_vec4) \
 SWS_FOR_STRUCT(TYPE, MIN,             DECL_ENTRY, EXT, NULL, 
ff_sws_setup_vec4) \
 SWS_FOR_STRUCT(TYPE, MAX,             DECL_ENTRY, EXT, NULL, 
ff_sws_setup_vec4) \
@@ -385,7 +385,7 @@ SWS_FOR_STRUCT(TYPE, DITHER,          DECL_ENTRY, EXT, 
NULL, setup_dither)
     SWS_FOR(TYPE, EXPAND_BIT,     REF_ENTRY, EXT)                              
 \
     SWS_FOR(TYPE, PERMUTE,        REF_ENTRY, EXT)                              
 \
     SWS_FOR(TYPE, COPY,           REF_ENTRY, EXT)                              
 \
-    SWS_FOR(TYPE, SCALE,          REF_ENTRY, EXT)                              
 \
+    SWS_FOR(TYPE, MUL,            REF_ENTRY, EXT)                              
 \
     SWS_FOR(TYPE, ADD,            REF_ENTRY, EXT)                              
 \
     SWS_FOR(TYPE, MIN,            REF_ENTRY, EXT)                              
 \
     SWS_FOR(TYPE, MAX,            REF_ENTRY, EXT)                              
 \
diff --git a/libswscale/x86/ops_float.asm b/libswscale/x86/ops_float.asm
index fe46cffe9da..ea71e77de1c 100644
--- a/libswscale/x86/ops_float.asm
+++ b/libswscale/x86/ops_float.asm
@@ -466,7 +466,7 @@ IF W,   mulps mw2, m10
 ;---------------------------------------------------------
 ; Arithmetic operations
 
-%macro SCALE 0
+%macro MUL_OP 0
         vbroadcastss m8, [implq + SwsOpImpl.priv]
         LOAD_CONT tmp0q
 IF X,   mulps mx, m8
@@ -685,7 +685,7 @@ IF W,   addps mw2, m11
 %endmacro
 
 %macro decl_float_ops 1 ; type
-    DECL_%1_SCALE           SCALE
+    DECL_%1_MUL             MUL_OP
     DECL_%1_ADD             ADD
     DECL_%1_MIN             MIN
     DECL_%1_MAX             MAX
diff --git a/libswscale/x86/ops_int.asm b/libswscale/x86/ops_int.asm
index c5d38b69ff3..aaacd12cdc5 100644
--- a/libswscale/x86/ops_int.asm
+++ b/libswscale/x86/ops_int.asm
@@ -733,7 +733,7 @@ IF Z,   packuswb %3, m10
 IF W,   packuswb %4, m11
 %endmacro
 
-%macro SCALE 0
+%macro MUL_OP 0
         LOAD_CONT tmp0q
 %if BITS == 8
 %if cpuflag(avx2)
@@ -895,7 +895,7 @@ IF2 V2, linear_pass 2
     DECL_%1_COPY            MOVE
     DECL_%1_SWAP_BYTES      SWAP_BYTES
     DECL_%1_EXPAND_BIT      EXPAND_BIT
-    DECL_%1_SCALE           SCALE
+    DECL_%1_MUL             MUL_OP
     DECL_%1_ADD             ADD
     DECL_%1_MIN             MIN
     DECL_%1_MAX             MAX
diff --git a/libswscale/x86/uops_macros.asm b/libswscale/x86/uops_macros.asm
index ba002f0edcf..6344aaec921 100644
--- a/libswscale/x86/uops_macros.asm
+++ b/libswscale/x86/uops_macros.asm
@@ -182,8 +182,8 @@
     DECL_OP %1, u8_to_f32_xyzw                          , SWS_PIXEL_U8 , 
SWS_UOP_TO_F32          , 0xf
 %endmacro
 
-%macro DECL_U8_SCALE 1
-    DECL_OP %1, u8_scale_xyz                            , SWS_PIXEL_U8 , 
SWS_UOP_SCALE           , 0x7
+%macro DECL_U8_MUL 1
+    DECL_OP %1, u8_mul_xyz                              , SWS_PIXEL_U8 , 
SWS_UOP_MUL             , 0x7
 %endmacro
 
 %macro DECL_U8_ADD 1
@@ -381,9 +381,9 @@
     DECL_OP %1, u16_to_f32_xyzw                         , SWS_PIXEL_U16, 
SWS_UOP_TO_F32          , 0xf
 %endmacro
 
-%macro DECL_U16_SCALE 1
-    DECL_OP %1, u16_scale_x                             , SWS_PIXEL_U16, 
SWS_UOP_SCALE           , 0x1
-    DECL_OP %1, u16_scale_xyz                           , SWS_PIXEL_U16, 
SWS_UOP_SCALE           , 0x7
+%macro DECL_U16_MUL 1
+    DECL_OP %1, u16_mul_x                               , SWS_PIXEL_U16, 
SWS_UOP_MUL             , 0x1
+    DECL_OP %1, u16_mul_xyz                             , SWS_PIXEL_U16, 
SWS_UOP_MUL             , 0x7
 %endmacro
 
 %macro DECL_U16_ADD 1
@@ -592,9 +592,9 @@
     DECL_OP %1, u32_to_f32_yzw                          , SWS_PIXEL_U32, 
SWS_UOP_TO_F32          , 0xe
 %endmacro
 
-%macro DECL_U32_SCALE 1
-    DECL_OP %1, u32_scale_x                             , SWS_PIXEL_U32, 
SWS_UOP_SCALE           , 0x1
-    DECL_OP %1, u32_scale_xyz                           , SWS_PIXEL_U32, 
SWS_UOP_SCALE           , 0x7
+%macro DECL_U32_MUL 1
+    DECL_OP %1, u32_mul_x                               , SWS_PIXEL_U32, 
SWS_UOP_MUL             , 0x1
+    DECL_OP %1, u32_mul_xyz                             , SWS_PIXEL_U32, 
SWS_UOP_MUL             , 0x7
 %endmacro
 
 %macro DECL_U32_ADD 1
@@ -748,12 +748,12 @@
 %macro DECL_F32_TO_F32 1
 %endmacro
 
-%macro DECL_F32_SCALE 1
-    DECL_OP %1, f32_scale_x                             , SWS_PIXEL_F32, 
SWS_UOP_SCALE           , 0x1
-    DECL_OP %1, f32_scale_xy                            , SWS_PIXEL_F32, 
SWS_UOP_SCALE           , 0x3
-    DECL_OP %1, f32_scale_xyz                           , SWS_PIXEL_F32, 
SWS_UOP_SCALE           , 0x7
-    DECL_OP %1, f32_scale_yzw                           , SWS_PIXEL_F32, 
SWS_UOP_SCALE           , 0xe
-    DECL_OP %1, f32_scale_xyzw                          , SWS_PIXEL_F32, 
SWS_UOP_SCALE           , 0xf
+%macro DECL_F32_MUL 1
+    DECL_OP %1, f32_mul_x                               , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0x1
+    DECL_OP %1, f32_mul_xy                              , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0x3
+    DECL_OP %1, f32_mul_xyz                             , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0x7
+    DECL_OP %1, f32_mul_yzw                             , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0xe
+    DECL_OP %1, f32_mul_xyzw                            , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0xf
 %endmacro
 
 %macro DECL_F32_ADD 1
diff --git a/libswscale/x86/uops_macros.h b/libswscale/x86/uops_macros.h
index b3312873713..e60aaad99a2 100644
--- a/libswscale/x86/uops_macros.h
+++ b/libswscale/x86/uops_macros.h
@@ -275,10 +275,10 @@
     MACRO(__VA_ARGS__, u8_to_f32_zw                            , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xc) \
     MACRO(__VA_ARGS__, u8_to_f32_yzw                           , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xe) \
     MACRO(__VA_ARGS__, u8_to_f32_xyzw                          , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xf)
-#define SWS_FOR_U8_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u8_scale_xyz                            , SWS_PIXEL_U8 
, SWS_UOP_SCALE           , 0x7)
-#define SWS_FOR_STRUCT_U8_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u8_scale_xyz                            , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_SCALE           , .mask = 0x7)
+#define SWS_FOR_U8_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u8_mul_xyz                              , SWS_PIXEL_U8 
, SWS_UOP_MUL             , 0x7)
+#define SWS_FOR_STRUCT_U8_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u8_mul_xyz                              , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_MUL             , .mask = 0x7)
 #define SWS_FOR_U8_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U8_ADD(MACRO, ...)
 #define SWS_FOR_U8_MIN(MACRO, ...)
@@ -529,12 +529,12 @@
     MACRO(__VA_ARGS__, u16_to_f32_xyz                          , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32          , .mask = 0x7) \
     MACRO(__VA_ARGS__, u16_to_f32_yzw                          , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32          , .mask = 0xe) \
     MACRO(__VA_ARGS__, u16_to_f32_xyzw                         , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32          , .mask = 0xf)
-#define SWS_FOR_U16_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u16_scale_x                             , 
SWS_PIXEL_U16, SWS_UOP_SCALE           , 0x1) \
-    MACRO(__VA_ARGS__, u16_scale_xyz                           , 
SWS_PIXEL_U16, SWS_UOP_SCALE           , 0x7)
-#define SWS_FOR_STRUCT_U16_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u16_scale_x                             , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_SCALE           , .mask = 0x1) \
-    MACRO(__VA_ARGS__, u16_scale_xyz                           , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_SCALE           , .mask = 0x7)
+#define SWS_FOR_U16_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u16_mul_x                               , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x1) \
+    MACRO(__VA_ARGS__, u16_mul_xyz                             , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x7)
+#define SWS_FOR_STRUCT_U16_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u16_mul_x                               , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x1) \
+    MACRO(__VA_ARGS__, u16_mul_xyz                             , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x7)
 #define SWS_FOR_U16_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U16_ADD(MACRO, ...)
 #define SWS_FOR_U16_MIN(MACRO, ...)
@@ -807,12 +807,12 @@
     MACRO(__VA_ARGS__, u32_to_f32_z                            , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32          , .mask = 0x4) \
     MACRO(__VA_ARGS__, u32_to_f32_xyz                          , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32          , .mask = 0x7) \
     MACRO(__VA_ARGS__, u32_to_f32_yzw                          , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_TO_F32          , .mask = 0xe)
-#define SWS_FOR_U32_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u32_scale_x                             , 
SWS_PIXEL_U32, SWS_UOP_SCALE           , 0x1) \
-    MACRO(__VA_ARGS__, u32_scale_xyz                           , 
SWS_PIXEL_U32, SWS_UOP_SCALE           , 0x7)
-#define SWS_FOR_STRUCT_U32_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, u32_scale_x                             , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_SCALE           , .mask = 0x1) \
-    MACRO(__VA_ARGS__, u32_scale_xyz                           , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_SCALE           , .mask = 0x7)
+#define SWS_FOR_U32_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u32_mul_x                               , 
SWS_PIXEL_U32, SWS_UOP_MUL             , 0x1) \
+    MACRO(__VA_ARGS__, u32_mul_xyz                             , 
SWS_PIXEL_U32, SWS_UOP_MUL             , 0x7)
+#define SWS_FOR_STRUCT_U32_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u32_mul_x                               , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_MUL             , .mask = 0x1) \
+    MACRO(__VA_ARGS__, u32_mul_xyz                             , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_MUL             , .mask = 0x7)
 #define SWS_FOR_U32_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U32_ADD(MACRO, ...)
 #define SWS_FOR_U32_MIN(MACRO, ...)
@@ -975,18 +975,18 @@
     MACRO(__VA_ARGS__, f32_to_u32_xyzw                         , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_TO_U32          , .mask = 0xf)
 #define SWS_FOR_F32_TO_F32(MACRO, ...)
 #define SWS_FOR_STRUCT_F32_TO_F32(MACRO, ...)
-#define SWS_FOR_F32_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, f32_scale_x                             , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0x1) \
-    MACRO(__VA_ARGS__, f32_scale_xy                            , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0x3) \
-    MACRO(__VA_ARGS__, f32_scale_xyz                           , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0x7) \
-    MACRO(__VA_ARGS__, f32_scale_yzw                           , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0xe) \
-    MACRO(__VA_ARGS__, f32_scale_xyzw                          , 
SWS_PIXEL_F32, SWS_UOP_SCALE           , 0xf)
-#define SWS_FOR_STRUCT_F32_SCALE(MACRO, ...) \
-    MACRO(__VA_ARGS__, f32_scale_x                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0x1) \
-    MACRO(__VA_ARGS__, f32_scale_xy                            , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0x3) \
-    MACRO(__VA_ARGS__, f32_scale_xyz                           , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0x7) \
-    MACRO(__VA_ARGS__, f32_scale_yzw                           , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0xe) \
-    MACRO(__VA_ARGS__, f32_scale_xyzw                          , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_SCALE           , .mask = 0xf)
+#define SWS_FOR_F32_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, f32_mul_x                               , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x1) \
+    MACRO(__VA_ARGS__, f32_mul_xy                              , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x3) \
+    MACRO(__VA_ARGS__, f32_mul_xyz                             , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x7) \
+    MACRO(__VA_ARGS__, f32_mul_yzw                             , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0xe) \
+    MACRO(__VA_ARGS__, f32_mul_xyzw                            , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0xf)
+#define SWS_FOR_STRUCT_F32_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, f32_mul_x                               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x1) \
+    MACRO(__VA_ARGS__, f32_mul_xy                              , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x3) \
+    MACRO(__VA_ARGS__, f32_mul_xyz                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x7) \
+    MACRO(__VA_ARGS__, f32_mul_yzw                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0xe) \
+    MACRO(__VA_ARGS__, f32_mul_xyzw                            , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0xf)
 #define SWS_FOR_F32_ADD(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_add_x                               , 
SWS_PIXEL_F32, SWS_UOP_ADD             , 0x1) \
     MACRO(__VA_ARGS__, f32_add_xy                              , 
SWS_PIXEL_F32, SWS_UOP_ADD             , 0x3) \
diff --git a/tests/checkasm/sw_ops.c b/tests/checkasm/sw_ops.c
index 0d17d8bd7df..164c182122d 100644
--- a/tests/checkasm/sw_ops.c
+++ b/tests/checkasm/sw_ops.c
@@ -707,7 +707,7 @@ void checkasm_check_sw_ops(void)
     CHECK_FOR(TO_U16,           check_cast);
     CHECK_FOR(TO_U32,           check_cast);
     CHECK_FOR(TO_F32,           check_cast);
-    CHECK_FOR(SCALE,            check_scale);
+    CHECK_FOR(MUL,              check_scale);
     CHECK_FOR(ADD,              check_scalar);
     CHECK_FOR(MIN,              check_vec4);
     CHECK_FOR(MAX,              check_vec4);
diff --git a/tests/ref/fate/sws-ops-list b/tests/ref/fate/sws-ops-list
index 89652b8541a..b22c6b980dd 100644
--- a/tests/ref/fate/sws-ops-list
+++ b/tests/ref/fate/sws-ops-list
@@ -1 +1 @@
-4e6b06a456afad8365188ff8ff897b79
+86e2905e47e498a515d47df0c40dbafc
-- 
2.54.0


>From aff94022aa1dad587dc865c0b188d1305c7babce Mon Sep 17 00:00:00 2001
From: Niklas Haas <[email protected]>
Date: Wed, 4 Nov 2026 22:14:52 +0100
Subject: [PATCH 2/5] tests/checkasm/sw_ops: test SWS_UOP_ADD with
 per-component constants

SWS_UOP_ADD reads data.vec4, but check_scalar() only randomized
data.scalar, i.e. the first component.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Signed-off-by: Niklas Haas <[email protected]>
---
 tests/checkasm/sw_ops.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/tests/checkasm/sw_ops.c b/tests/checkasm/sw_ops.c
index 164c182122d..7d21ad1885b 100644
--- a/tests/checkasm/sw_ops.c
+++ b/tests/checkasm/sw_ops.c
@@ -474,12 +474,6 @@ static void check_simple(const char *name, const SwsUOp 
*uop)
     check_range(name, uop, NULL);
 }
 
-static void check_scalar(const char *name, SwsUOp *uop)
-{
-    uop->data.scalar = rndpx(uop->type);
-    check_simple(name, uop);
-}
-
 static void check_vec4(const char *name, SwsUOp *uop)
 {
     for (int i = 0; i < 4; i++)
@@ -708,7 +702,7 @@ void checkasm_check_sw_ops(void)
     CHECK_FOR(TO_U32,           check_cast);
     CHECK_FOR(TO_F32,           check_cast);
     CHECK_FOR(MUL,              check_scale);
-    CHECK_FOR(ADD,              check_scalar);
+    CHECK_FOR(ADD,              check_vec4);
     CHECK_FOR(MIN,              check_vec4);
     CHECK_FOR(MAX,              check_vec4);
     CHECK_FOR(UNPACK,           check_unpack);
-- 
2.54.0


>From b4236b6110660452e115346412bd46824ea7ab78 Mon Sep 17 00:00:00 2001
From: Niklas Haas <[email protected]>
Date: Wed, 4 Nov 2026 22:18:18 +0100
Subject: [PATCH 3/5] swscale/uops: make SWS_UOP_MUL take per-component
 coefficients

Store the multiplication factors in data.vec4, like SWS_UOP_ADD/MIN/MAX.
SWS_OP_SCALE is still translated with the same factor for every component.

The x86 u8 kernel is restructured to widen one component at a time, since
holding four broadcast coefficients next to four temporaries and the zero
register would exceed the 16 available registers.

The cost is one extra broadcast per active component, which is within noise
on my CPU (Intel Core Ultra 7 258V):

  checkasm sw_ops                 before   after
  f32 mul x/xy/xyz/xyzw (AVX2)   799-800 802-809  (+0.4..+1.3%)
  u16 mul x/xyz (AVX2)           341/338 340/339
  u32 mul x/xyz (AVX2)           802/802 803/808
  u8 mul xyz (AVX2/SSE4)         195/279 196/286

  swscale 1080p, us/frame         before   after
  bgr444le -> rgba                   318     321  (u8 mul)
  bgr444le -> rgb48le                572     568  (u16 mul)
  0bgr -> gbrp10le                   673     680  (f32 mul yzw)
  rgb24 -> gbrpf32le                1077    1067  (f32 mul xyz)
  rgba -> rgbaf32le                 1905    1900  (f32 mul xyzw)

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Signed-off-by: Niklas Haas <[email protected]>
---
 libswscale/aarch64/ops.c        |  3 +-
 libswscale/aarch64/ops_asmgen.c | 20 ++++-----
 libswscale/aarch64/ops_static.c |  8 ++--
 libswscale/ops_optimizer.c      | 20 ++++++---
 libswscale/uops.c               |  5 ++-
 libswscale/uops.h               |  2 +-
 libswscale/uops_tmpl.c          | 12 +++---
 libswscale/vulkan/ops.c         | 16 ++++++--
 libswscale/x86/ops.c            | 11 ++---
 libswscale/x86/ops_float.asm    | 17 ++++----
 libswscale/x86/ops_int.asm      | 73 ++++++++++++++++++---------------
 tests/checkasm/sw_ops.c         | 23 ++++++-----
 12 files changed, 118 insertions(+), 92 deletions(-)

diff --git a/libswscale/aarch64/ops.c b/libswscale/aarch64/ops.c
index edce195f10b..e8db85c5a1c 100644
--- a/libswscale/aarch64/ops.c
+++ b/libswscale/aarch64/ops.c
@@ -138,9 +138,8 @@ static int aarch64_setup(const SwsUOp *uop, const 
SwsAArch64OpImplParams *p,
     case SWS_UOP_CLEAR:
     case SWS_UOP_MIN:
     case SWS_UOP_MAX:
-        return ff_sws_setup_vec4(&(const SwsImplParams) { .uop = uop }, out);
     case SWS_UOP_MUL:
-        return ff_sws_setup_scalar(&(const SwsImplParams) { .uop = uop }, out);
+        return ff_sws_setup_vec4(&(const SwsImplParams) { .uop = uop }, out);
     case SWS_UOP_LINEAR:
     case SWS_UOP_LINEAR_FMA:
         return aarch64_setup_linear(p, uop, out);
diff --git a/libswscale/aarch64/ops_asmgen.c b/libswscale/aarch64/ops_asmgen.c
index 40834e3ae99..f96f6590657 100644
--- a/libswscale/aarch64/ops_asmgen.c
+++ b/libswscale/aarch64/ops_asmgen.c
@@ -811,25 +811,25 @@ static void asmgen_op_max(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *p,
 }
 
 /*********************************************************************/
-/* multiplication by scalar */
+/* multiplication */
 /* SWS_UOP_MUL */
 
 static void asmgen_op_mul(SwsAArch64Context *s, const SwsAArch64OpImplParams 
*p,
                           SwsAArch64OpRegs *regs)
 {
     RasmContext *r = s->rctx;
-    RasmOp *sl       = regs->sl;
-    RasmOp *sh       = regs->sh;
-    RasmOp *dl       = regs->dl;
-    RasmOp *dh       = regs->dh;
-    RasmOp scale_vec = regs->vk[0];
+    RasmOp *sl = regs->sl;
+    RasmOp *sh = regs->sh;
+    RasmOp *dl = regs->dl;
+    RasmOp *dh = regs->dh;
+    RasmOp *vk = regs->vk;
 
     if (p->type == SWS_PIXEL_F32) {
-        LOOP_MASK      (p, i) { i_fmul(r, dl[i], sl[i], scale_vec); 
CMTF("vl[%u] *= scale_vec;", i); }
-        LOOP_MASK_VH(s, p, i) { i_fmul(r, dh[i], sh[i], scale_vec); 
CMTF("vh[%u] *= scale_vec;", i); }
+        LOOP_MASK      (p, i) { i_fmul(r, dl[i], sl[i], vk[i]);     
CMTF("vl[%u] *= vmul%u;", i, i); }
+        LOOP_MASK_VH(s, p, i) { i_fmul(r, dh[i], sh[i], vk[i]);     
CMTF("vh[%u] *= vmul%u;", i, i); }
     } else {
-        LOOP_MASK      (p, i) { i_mul (r, dl[i], sl[i], scale_vec); 
CMTF("vl[%u] *= scale_vec;", i); }
-        LOOP_MASK_VH(s, p, i) { i_mul (r, dh[i], sh[i], scale_vec); 
CMTF("vh[%u] *= scale_vec;", i); }
+        LOOP_MASK      (p, i) { i_mul (r, dl[i], sl[i], vk[i]);     
CMTF("vl[%u] *= vmul%u;", i, i); }
+        LOOP_MASK_VH(s, p, i) { i_mul (r, dh[i], sh[i], vk[i]);     
CMTF("vh[%u] *= vmul%u;", i, i); }
     }
 }
 
diff --git a/libswscale/aarch64/ops_static.c b/libswscale/aarch64/ops_static.c
index a8ea437454f..e33abb9351a 100644
--- a/libswscale/aarch64/ops_static.c
+++ b/libswscale/aarch64/ops_static.c
@@ -274,12 +274,12 @@ static void asmgen_setup_mul(SwsAArch64Context *s, const 
SwsAArch64OpImplParams
                              SwsAArch64OpRegs *regs)
 {
     RasmContext *r = s->rctx;
-    RasmOp scale_vec = regs->vk[0];
+    RasmOp *vk = regs->vk;
 
-    RasmOp priv_ptr = s->tmp0;
-    i_add (r, priv_ptr, s->impl, IMM(offsetof_impl_priv));          CMT("v128 
*scale_vec_ptr = &impl->priv;");
+    RasmOp mul_vec = regs->vt[0];
+    i_ldr(r, v_q(mul_vec), IMPL_PRIV(s));                           CMT("v128 
mul_vec = impl->priv.v128;");
     asmgen_set_load_cont_node(s);
-    i_ld1r(r, vv_1(scale_vec), a64op_base(priv_ptr));               CMT("v128 
scale_vec = broadcast(*scale_vec_ptr);");
+    LOOP_MASK(p, i) { i_dup(r, vk[i], a64op_elem(mul_vec, i));      CMTF("v128 
vmul%u = mul_vec[%u];", i, i); }
 }
 
 static void asmgen_setup_linear(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *p,
diff --git a/libswscale/ops_optimizer.c b/libswscale/ops_optimizer.c
index aedd4400629..767471641a6 100644
--- a/libswscale/ops_optimizer.c
+++ b/libswscale/ops_optimizer.c
@@ -1044,18 +1044,26 @@ static int solve_shuffle(const SwsUOpList *const uops, 
SwsUOp *out)
     return AVERROR(EINVAL);
 }
 
-/* Only checks exact integer scale ops */
+/* Only checks exact integer multiplications, with the same value for all
+ * components */
 static bool is_scale(const SwsUOp *op, int64_t val)
 {
     if (op->uop != SWS_UOP_MUL)
         return false;
 
-    switch (op->type) {
-    case SWS_PIXEL_U8:  return op->data.scalar.u8  == val;
-    case SWS_PIXEL_U16: return op->data.scalar.u16 == val;
-    case SWS_PIXEL_U32: return op->data.scalar.u32 == val;
-    default: return false;
+    for (int i = 0; i < 4; i++) {
+        if (!SWS_COMP_TEST(op->mask, i))
+            continue;
+        const SwsPixel px = op->data.vec4[i];
+        switch (op->type) {
+        case SWS_PIXEL_U8:  if (px.u8  != val) return false; break;
+        case SWS_PIXEL_U16: if (px.u16 != val) return false; break;
+        case SWS_PIXEL_U32: if (px.u32 != val) return false; break;
+        default: return false;
+        }
     }
+
+    return true;
 }
 
 int ff_sws_uop_list_optimize(SwsContext *ctx, SwsUOpFlags flags, SwsUOpList 
*uops)
diff --git a/libswscale/uops.c b/libswscale/uops.c
index 5797f9e4267..51c675b5d97 100644
--- a/libswscale/uops.c
+++ b/libswscale/uops.c
@@ -612,7 +612,10 @@ static int translate_op(SwsContext *ctx, SwsUOpList *uops, 
SwsUOpFlags flags,
         break;
     case SWS_OP_SCALE:
         uop.uop = SWS_UOP_MUL;
-        uop.data.scalar = ff_sws_pixel_from_q64(uop.type, op->scale.factor);
+        for (int i = 0; i < 4; i++) {
+            if (SWS_COMP_TEST(uop.mask, i))
+                uop.data.vec4[i] = ff_sws_pixel_from_q64(uop.type, 
op->scale.factor);
+        }
         break;
     case SWS_OP_MIN:
     case SWS_OP_MAX:
diff --git a/libswscale/uops.h b/libswscale/uops.h
index 5660bf9c42c..7b0c77d24d6 100644
--- a/libswscale/uops.h
+++ b/libswscale/uops.h
@@ -191,7 +191,7 @@ typedef enum SwsUOpType {
     SWS_UOP_TO_F32,          /* cast pixel values to SWS_PIXEL_F32 */
 
     /* Arithmetic uops */
-    SWS_UOP_MUL,             /* multiply masked components by scalar */
+    SWS_UOP_MUL,             /* multiply masked components by vec4 */
     SWS_UOP_ADD,             /* add vec4 to masked components */
     SWS_UOP_MIN,             /* min(x, vec4) on masked components */
     SWS_UOP_MAX,             /* max(x, vec4) on masked components */
diff --git a/libswscale/uops_tmpl.c b/libswscale/uops_tmpl.c
index 78c021e6ebb..8246bcbc00b 100644
--- a/libswscale/uops_tmpl.c
+++ b/libswscale/uops_tmpl.c
@@ -667,14 +667,12 @@ SWS_FOR_STRUCT(PX, CLEAR, DECL_ENTRY, .setup = 
ff_sws_setup_vec4)
 
 DECL_FUNC(mul, const SwsCompMask mask)
 {
-    const pixel_t scale = impl->priv.px[0];
-
     SWS_LOOP
     for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
-        if (X) x[i] *= scale;
-        if (Y) y[i] *= scale;
-        if (Z) z[i] *= scale;
-        if (W) w[i] *= scale;
+        if (X) x[i] *= impl->priv.px[0];
+        if (Y) y[i] *= impl->priv.px[1];
+        if (Z) z[i] *= impl->priv.px[2];
+        if (W) w[i] *= impl->priv.px[3];
     }
 
     CONTINUE(x, y, z, w);
@@ -723,7 +721,7 @@ SWS_FOR(PX, MUL,   DECL_IMPL, mul)
 SWS_FOR(PX, ADD,   DECL_IMPL, add)
 SWS_FOR(PX, MIN,   DECL_IMPL, min)
 SWS_FOR(PX, MAX,   DECL_IMPL, max)
-SWS_FOR_STRUCT(PX, MUL,   DECL_ENTRY, .setup = ff_sws_setup_scalar )
+SWS_FOR_STRUCT(PX, MUL,   DECL_ENTRY, .setup = ff_sws_setup_vec4 )
 SWS_FOR_STRUCT(PX, ADD,   DECL_ENTRY, .setup = ff_sws_setup_vec4 )
 SWS_FOR_STRUCT(PX, MIN,   DECL_ENTRY, .setup = ff_sws_setup_vec4 )
 SWS_FOR_STRUCT(PX, MAX,   DECL_ENTRY, .setup = ff_sws_setup_vec4 )
diff --git a/libswscale/vulkan/ops.c b/libswscale/vulkan/ops.c
index 5e8bb13651e..d9c6be03d92 100644
--- a/libswscale/vulkan/ops.c
+++ b/libswscale/vulkan/ops.c
@@ -1183,10 +1183,20 @@ static int emit_shader(SwsContext *sws, VulkanPriv *p, 
FFVulkanOpsCtx *s,
                 data = spi_OpShiftRightLogical(spi, type_v, data, shift_v);
             break;
         }
-        case SWS_UOP_MUL:
-            data = emit_mul(spi, uop->type, type_v, data,
-                            const_splat(spi, id, uop->type, uop->data.scalar));
+        case SWS_UOP_MUL: {
+            const int one = const_pixel(spi, id, uop->type,
+                                        ff_sws_pixel_from_q64(uop->type, 
(AVRational64) { 1, 1 }));
+            int arg[4] = { one, one, one, one };
+            for (int i = 0; i < 4; i++) {
+                if (!SWS_COMP_TEST(uop->mask, i))
+                    continue;
+                arg[i] = const_pixel(spi, id, uop->type, uop->data.vec4[i]);
+            }
+
+            int arg_v = spi_OpConstantComposite(spi, type_v, arg[0], arg[1], 
arg[2], arg[3]);
+            data = emit_mul(spi, uop->type, type_v, data, arg_v);
             break;
+        }
         case SWS_UOP_ADD: {
             const int zero = const_zero(id, uop->type);
             int arg[4] = { zero, zero, zero, zero };
diff --git a/libswscale/x86/ops.c b/libswscale/x86/ops.c
index dc5037df25c..e9986ec4084 100644
--- a/libswscale/x86/ops.c
+++ b/libswscale/x86/ops.c
@@ -251,14 +251,11 @@ static int setup_filter_h_4x4(const SwsImplParams 
*params, SwsImplResult *out)
 static int setup_mul(const SwsImplParams *params, SwsImplResult *out)
 {
     const SwsUOp *uop = params->uop;
-    switch (uop->type) {
-    case SWS_PIXEL_U8:  out->priv.u16[0] = uop->data.scalar.u8;  break; /* for 
pmullw */
-    case SWS_PIXEL_U16: out->priv.u16[0] = uop->data.scalar.u16; break;
-    case SWS_PIXEL_U32: out->priv.u32[0] = uop->data.scalar.u32; break;
-    case SWS_PIXEL_F32: out->priv.f32[0] = uop->data.scalar.f32; break;
-    default: return AVERROR(EINVAL);
-    }
+    if (uop->type != SWS_PIXEL_U8)
+        return ff_sws_setup_vec4(params, out);
 
+    for (int i = 0; i < 4; i++)
+        out->priv.u16[i] = uop->data.vec4[i].u8; /* for pmullw */
     return 0;
 }
 
diff --git a/libswscale/x86/ops_float.asm b/libswscale/x86/ops_float.asm
index ea71e77de1c..559603554a5 100644
--- a/libswscale/x86/ops_float.asm
+++ b/libswscale/x86/ops_float.asm
@@ -467,16 +467,19 @@ IF W,   mulps mw2, m10
 ; Arithmetic operations
 
 %macro MUL_OP 0
-        vbroadcastss m8, [implq + SwsOpImpl.priv]
+IF X,   vbroadcastss m8,  [implq + SwsOpImpl.priv + 0 * BYTES]
+IF Y,   vbroadcastss m9,  [implq + SwsOpImpl.priv + 1 * BYTES]
+IF Z,   vbroadcastss m10, [implq + SwsOpImpl.priv + 2 * BYTES]
+IF W,   vbroadcastss m11, [implq + SwsOpImpl.priv + 3 * BYTES]
         LOAD_CONT tmp0q
 IF X,   mulps mx, m8
-IF Y,   mulps my, m8
-IF Z,   mulps mz, m8
-IF W,   mulps mw, m8
+IF Y,   mulps my, m9
+IF Z,   mulps mz, m10
+IF W,   mulps mw, m11
 IF X,   mulps mx2, m8
-IF Y,   mulps my2, m8
-IF Z,   mulps mz2, m8
-IF W,   mulps mw2, m8
+IF Y,   mulps my2, m9
+IF Z,   mulps mz2, m10
+IF W,   mulps mw2, m11
         CONTINUE tmp0q
 %endmacro
 
diff --git a/libswscale/x86/ops_int.asm b/libswscale/x86/ops_int.asm
index aaacd12cdc5..8218543cfd3 100644
--- a/libswscale/x86/ops_int.asm
+++ b/libswscale/x86/ops_int.asm
@@ -705,50 +705,55 @@ IF W,   psrlx mw2, %1
 ;---------------------------------------------------------
 ; Arithmetic operations
 
-%macro pmull4 6 ; suffix, x, y, z, w, k
-IF X,   pmull%1 %2, %6
-IF Y,   pmull%1 %3, %6
-IF Z,   pmull%1 %4, %6
-IF W,   pmull%1 %5, %6
-%endmacro
-
-%macro scale8 5 ; mx, my, mz, mw, k
-IF X,   mova m8,  %1
-IF Y,   mova m9,  %2
-IF Z,   mova m10, %3
-IF W,   mova m11, %4
-IF X,   punpcklbw %1,  m15
-IF Y,   punpcklbw %2,  m15
-IF Z,   punpcklbw %3,  m15
-IF W,   punpcklbw %4,  m15
-IF X,   punpckhbw m8,  m15
-IF Y,   punpckhbw m9,  m15
-IF Z,   punpckhbw m10, m15
-IF W,   punpckhbw m11, m15
-        pmull4 w, %1, %2, %3,  %4,  m12
-        pmull4 w, m8, m9, m10, m11, m12
-IF X,   packuswb %1, m8
-IF Y,   packuswb %2, m9
-IF Z,   packuswb %3, m10
-IF W,   packuswb %4, m11
+%macro mullb 3 ; dst, k, tmp
+        punpckhbw %3, %1, m15
+        punpcklbw %1, m15
+        pmullw    %1, %2
+        pmullw    %3, %2
+        packuswb  %1, %3
 %endmacro
 
 %macro MUL_OP 0
         LOAD_CONT tmp0q
 %if BITS == 8
 %if cpuflag(avx2)
-        vpbroadcastw m12, [implq + SwsOpImpl.priv]
+IF X,   vpbroadcastw m9,  [implq + SwsOpImpl.priv + 0]
+IF Y,   vpbroadcastw m10, [implq + SwsOpImpl.priv + 2]
+IF Z,   vpbroadcastw m11, [implq + SwsOpImpl.priv + 4]
+IF W,   vpbroadcastw m12, [implq + SwsOpImpl.priv + 6]
 %else
-        movd xm12, [implq + SwsOpImpl.priv]
-        SPLATW m12, xm12, 0
+        movq m12, [implq + SwsOpImpl.priv]
+IF X,   SPLATW m9,  m12, 0
+IF Y,   SPLATW m10, m12, 1
+IF Z,   SPLATW m11, m12, 2
+IF W,   SPLATW m12, m12, 3
 %endif
         pxor m15, m15
-        scale8 mx,  my,  mz,  mw,  m12
-IF1 V2, scale8 mx2, my2, mz2, mw2, m12
+IF X,   mullb mx,  m9,  m8
+IF Y,   mullb my,  m10, m8
+IF Z,   mullb mz,  m11, m8
+IF W,   mullb mw,  m12, m8
+%if V2
+IF X,   mullb mx2, m9,  m8
+IF Y,   mullb my2, m10, m8
+IF Z,   mullb mz2, m11, m8
+IF W,   mullb mw2, m12, m8
+%endif
 %else
-        vpbroadcastx m12, [implq + SwsOpImpl.priv]
-        pmull4 x, mx,  my,  mz,  mw,  m12
-IF1 V2, pmull4 x, mx2, my2, mz2, mw2, m12
+IF X,   vpbroadcastx m8,  [implq + SwsOpImpl.priv + 0 * BYTES]
+IF Y,   vpbroadcastx m9,  [implq + SwsOpImpl.priv + 1 * BYTES]
+IF Z,   vpbroadcastx m10, [implq + SwsOpImpl.priv + 2 * BYTES]
+IF W,   vpbroadcastx m11, [implq + SwsOpImpl.priv + 3 * BYTES]
+IF X,   pmullx mx,  m8
+IF Y,   pmullx my,  m9
+IF Z,   pmullx mz,  m10
+IF W,   pmullx mw,  m11
+%if V2
+IF X,   pmullx mx2, m8
+IF Y,   pmullx my2, m9
+IF Z,   pmullx mz2, m10
+IF W,   pmullx mw2, m11
+%endif
 %endif
         CONTINUE tmp0q
 %endmacro
diff --git a/tests/checkasm/sw_ops.c b/tests/checkasm/sw_ops.c
index 7d21ad1885b..a6c3411291d 100644
--- a/tests/checkasm/sw_ops.c
+++ b/tests/checkasm/sw_ops.c
@@ -565,21 +565,24 @@ static void check_cast(const char *name, const SwsUOp 
*uop)
     check_uop(name, uop, uop->mask, uop->mask, MK_RANGES(range));
 }
 
-static void check_scale(const char *name, SwsUOp *uop)
+static void check_mul(const char *name, SwsUOp *uop)
 {
     const int bits = ff_sws_pixel_type_size(uop->type) * 8;
     const unsigned max = UINT32_MAX >> (32 - bits);
-    SwsPixel scale = uop->data.scalar = rndpx(uop->type);
-    unsigned range = 0;
+    unsigned ranges[NB_PLANES] = {0};
 
-    /* Ensure the result won't exceed the value range */
-    switch (uop->type) {
-    case SWS_PIXEL_U8:  range = max / (scale.u8  ? scale.u8  : 1); break;
-    case SWS_PIXEL_U16: range = max / (scale.u16 ? scale.u16 : 1); break;
-    case SWS_PIXEL_U32: range = max / (scale.u32 ? scale.u32 : 1); break;
+    for (int i = 0; i < 4; i++) {
+        const SwsPixel k = uop->data.vec4[i] = rndpx(uop->type);
+
+        /* Ensure the result won't exceed the value range */
+        switch (uop->type) {
+        case SWS_PIXEL_U8:  ranges[i] = max / (k.u8  ? k.u8  : 1); break;
+        case SWS_PIXEL_U16: ranges[i] = max / (k.u16 ? k.u16 : 1); break;
+        case SWS_PIXEL_U32: ranges[i] = max / (k.u32 ? k.u32 : 1); break;
+        }
     }
 
-    check_range(name, uop, MK_RANGES(range));
+    check_range(name, uop, ranges);
 }
 
 static void check_unpack(const char *name, const SwsUOp *uop)
@@ -701,7 +704,7 @@ void checkasm_check_sw_ops(void)
     CHECK_FOR(TO_U16,           check_cast);
     CHECK_FOR(TO_U32,           check_cast);
     CHECK_FOR(TO_F32,           check_cast);
-    CHECK_FOR(MUL,              check_scale);
+    CHECK_FOR(MUL,              check_mul);
     CHECK_FOR(ADD,              check_vec4);
     CHECK_FOR(MIN,              check_vec4);
     CHECK_FOR(MAX,              check_vec4);
-- 
2.54.0


>From 8041913856d88d2e3a9242f19fe4b4fecd05f5e0 Mon Sep 17 00:00:00 2001
From: Niklas Haas <[email protected]>
Date: Wed, 4 Nov 2026 23:35:44 +0100
Subject: [PATCH 4/5] swscale/uops: remove unused SwsUOp.data.scalar

SWS_UOP_MUL was the last user of data.scalar and ff_sws_setup_scalar().

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Signed-off-by: Niklas Haas <[email protected]>
---
 libswscale/ops_chain.c | 15 ---------------
 libswscale/ops_chain.h |  1 -
 libswscale/uops.h      |  1 -
 3 files changed, 17 deletions(-)

diff --git a/libswscale/ops_chain.c b/libswscale/ops_chain.c
index 42f26035a7b..07db4530680 100644
--- a/libswscale/ops_chain.c
+++ b/libswscale/ops_chain.c
@@ -126,21 +126,6 @@ int ff_sws_uop_lookup(SwsContext *ctx, const SwsUOpTable 
*const tables[],
     return 0;
 }
 
-int ff_sws_setup_scalar(const SwsImplParams *params, SwsImplResult *out)
-{
-    const SwsUOp *uop = params->uop;
-    const SwsPixel scalar = uop->data.scalar;
-    switch (uop->type) {
-    case SWS_PIXEL_U8:  out->priv.u8[0]  = scalar.u8;  break;
-    case SWS_PIXEL_U16: out->priv.u16[0] = scalar.u16; break;
-    case SWS_PIXEL_U32: out->priv.u32[0] = scalar.u32; break;
-    case SWS_PIXEL_F32: out->priv.f32[0] = scalar.f32; break;
-    default: return AVERROR(EINVAL);
-    }
-
-    return 0;
-}
-
 int ff_sws_setup_vec4(const SwsImplParams *params, SwsImplResult *out)
 {
     const SwsUOp *uop = params->uop;
diff --git a/libswscale/ops_chain.h b/libswscale/ops_chain.h
index e3a25e3af54..7fc166dc040 100644
--- a/libswscale/ops_chain.h
+++ b/libswscale/ops_chain.h
@@ -130,7 +130,6 @@ typedef struct SwsUOpEntry {
 } SwsUOpEntry;
 
 /* Setup helpers for SwsUOp data */
-int ff_sws_setup_scalar(const SwsImplParams *params, SwsImplResult *out);
 int ff_sws_setup_vec4(const SwsImplParams *params, SwsImplResult *out);
 
 static inline void ff_op_priv_free(SwsOpPriv *priv)
diff --git a/libswscale/uops.h b/libswscale/uops.h
index 7b0c77d24d6..9879558a4f5 100644
--- a/libswscale/uops.h
+++ b/libswscale/uops.h
@@ -301,7 +301,6 @@ typedef struct SwsUOp {
     union {
         SwsFilterWeights *kernel;   /* refstruct */
         SwsPixel *ptr;              /* refstruct */
-        SwsPixel scalar;
         SwsPixel vec4[4];
         SwsPixel mat4x5[4][5];      /* row major */
         SwsShuffleMask shuffle;     /* for SWS_UOP_RW_SHUFFLE */
-- 
2.54.0


>From 2974623f64f95531cfa176525ff2d28eae48429b Mon Sep 17 00:00:00 2001
From: Niklas Haas <[email protected]>
Date: Wed, 4 Nov 2026 23:53:06 +0100
Subject: [PATCH 5/5] swscale/uops: translate diagonal linear ops to
 SWS_UOP_MUL

Per-component scaling without an offset is common, e.g. when converting
between formats with different per-component bit depths. A single
SWS_UOP_MUL is slightly faster than SWS_UOP_LINEAR here (1080p, x86):

                          before   after
  rgb24 -> rgb565le        612 us  605 us
  rgb24 -> bgr8            649 us  643 us
  bgr24 -> rgb4_byte       652 us  644 us

Diagonal matrices with offsets are left as SWS_UOP_LINEAR, since splitting
them into SWS_UOP_MUL + SWS_UOP_ADD measured 8-20% slower.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Signed-off-by: Niklas Haas <[email protected]>
---
 libswscale/aarch64/ops_entries.c | 17 +++-------
 libswscale/uops.c                | 16 ++++++++-
 libswscale/uops_macros.h         | 46 ++++++++++---------------
 libswscale/x86/uops_macros.asm   | 17 +++-------
 libswscale/x86/uops_macros.h     | 58 +++++++++++---------------------
 tests/ref/fate/sws-ops-list      |  2 +-
 6 files changed, 62 insertions(+), 94 deletions(-)

diff --git a/libswscale/aarch64/ops_entries.c b/libswscale/aarch64/ops_entries.c
index 22c13a6cc6e..15cb465d447 100644
--- a/libswscale/aarch64/ops_entries.c
+++ b/libswscale/aarch64/ops_entries.c
@@ -237,14 +237,18 @@ ENTRY(ff_sws_to_f32_8_u32_1110_neon,                { 
.uop = SWS_UOP_TO_F32,
 ENTRY(ff_sws_mul_8_u32_0001_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x1 })
 ENTRY(ff_sws_mul_8_u32_0111_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x7 })
 ENTRY(ff_sws_mul_8_f32_0001_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1 })
+ENTRY(ff_sws_mul_8_f32_0010_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x2 })
 ENTRY(ff_sws_mul_8_f32_0011_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x3 })
 ENTRY(ff_sws_mul_8_f32_0111_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7 })
+ENTRY(ff_sws_mul_8_f32_1000_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x8 })
 ENTRY(ff_sws_mul_8_f32_1110_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xe })
 ENTRY(ff_sws_mul_8_f32_1111_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf })
 ENTRY(ff_sws_mul_16_u8_0001_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x1 })
+ENTRY(ff_sws_mul_16_u8_0010_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x2 })
 ENTRY(ff_sws_mul_16_u8_0111_neon,                   { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x7 })
 ENTRY(ff_sws_mul_16_u16_0001_neon,                  { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0x1 })
 ENTRY(ff_sws_mul_16_u16_0111_neon,                  { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0x7 })
+ENTRY(ff_sws_mul_16_u16_1111_neon,                  { .uop = SWS_UOP_MUL,      
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0xf })
 ENTRY(ff_sws_min_8_f32_0001_neon,                   { .uop = SWS_UOP_MIN,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1 })
 ENTRY(ff_sws_min_8_f32_0010_neon,                   { .uop = SWS_UOP_MIN,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x2 })
 ENTRY(ff_sws_min_8_f32_0011_neon,                   { .uop = SWS_UOP_MIN,      
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x3 })
@@ -380,12 +384,6 @@ ENTRY(ff_sws_linear_400400400f_16_u8_0001_neon,     { .uop 
= SWS_UOP_LINEAR,
 ENTRY(ff_sws_linear_400400400f_16_u16_0001_neon,    { .uop = SWS_UOP_LINEAR,   
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0x1, .par.lin = { .one = 
0x41040, .zero = 0xbefae } })
 ENTRY(ff_sws_linear_40040040fc_8_f32_0001_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1, .par.lin = { .one = 
0x41040, .zero = 0xbefb8 } })
 ENTRY(ff_sws_linear_40040040ff_8_f32_0001_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1, .par.lin = { .one = 
0x41040, .zero = 0xbefa8 } })
-ENTRY(ff_sws_linear_400400c004_8_f32_0010_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x2, .par.lin = { .one = 
0x41001, .zero = 0xbefbe } })
-ENTRY(ff_sws_linear_400400c004_16_u8_0010_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x2, .par.lin = { .one = 
0x41001, .zero = 0xbefbe } })
-ENTRY(ff_sws_linear_400c00c00c_8_u32_0111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xbefbe } })
-ENTRY(ff_sws_linear_400c00c00c_8_f32_0111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xbefbe } })
-ENTRY(ff_sws_linear_400c00c00c_16_u8_0111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xbefbe } })
-ENTRY(ff_sws_linear_400c00c00c_16_u16_0111_neon,    { .uop = SWS_UOP_LINEAR,   
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xbefbe } })
 ENTRY(ff_sws_linear_400c30cc0f_8_u32_0111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_U32, .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xbadae } })
 ENTRY(ff_sws_linear_400c30cc0f_8_f32_0111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xbadae } })
 ENTRY(ff_sws_linear_400c30cc0f_16_u8_0111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size = 16, .type = SWS_PIXEL_U8,  .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xbadae } })
@@ -393,27 +391,20 @@ ENTRY(ff_sws_linear_400c30cc0f_16_u16_0111_neon,    { 
.uop = SWS_UOP_LINEAR,
 ENTRY(ff_sws_linear_400ff3fcfc_8_f32_0111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xba118 } })
 ENTRY(ff_sws_linear_400ff3fcff_8_f32_0111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, .par.lin = { .one = 
0x40000, .zero = 0xba108 } })
 ENTRY(ff_sws_linear_c003f3fccf_8_f32_1111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf, .par.lin = { .one = 
0x0, .zero = 0xbb10a } })
-ENTRY(ff_sws_linear_c004004004_8_f32_1000_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x8, .par.lin = { .one = 
0x1041, .zero = 0xbefbe } })
 ENTRY(ff_sws_linear_c00400400f_8_f32_1001_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x9, .par.lin = { .one = 
0x1040, .zero = 0xbefae } })
 ENTRY(ff_sws_linear_c0040040fc_8_f32_1001_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x9, .par.lin = { .one = 
0x1040, .zero = 0xbefb8 } })
-ENTRY(ff_sws_linear_c00c00c00c_8_f32_1111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf, .par.lin = { .one = 
0x0, .zero = 0xbefbe } })
-ENTRY(ff_sws_linear_c00c00c00c_16_u16_1111_neon,    { .uop = SWS_UOP_LINEAR,   
    .block_size = 16, .type = SWS_PIXEL_U16, .mask = 0xf, .par.lin = { .one = 
0x0, .zero = 0xbefbe } })
 ENTRY(ff_sws_linear_c00ff3fcff_8_f32_1111_neon,     { .uop = SWS_UOP_LINEAR,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf, .par.lin = { .one = 
0x0, .zero = 0xba108 } })
 ENTRY(ff_sws_linear_fma_400373dcc7_8_f32_0111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, 
.par.lin = { .one = 0x40421, .zero = 0xbb10a } })
 ENTRY(ff_sws_linear_fma_4003f3fccf_8_f32_0111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, 
.par.lin = { .one = 0x40000, .zero = 0xbb10a } })
 ENTRY(ff_sws_linear_fma_400400400f_8_f32_0001_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1, 
.par.lin = { .one = 0x41040, .zero = 0xbefae } })
 ENTRY(ff_sws_linear_fma_40040040fc_8_f32_0001_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1, 
.par.lin = { .one = 0x41040, .zero = 0xbefb8 } })
 ENTRY(ff_sws_linear_fma_40040040ff_8_f32_0001_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x1, 
.par.lin = { .one = 0x41040, .zero = 0xbefa8 } })
-ENTRY(ff_sws_linear_fma_400400c004_8_f32_0010_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x2, 
.par.lin = { .one = 0x41001, .zero = 0xbefbe } })
-ENTRY(ff_sws_linear_fma_400c00c00c_8_f32_0111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, 
.par.lin = { .one = 0x40000, .zero = 0xbefbe } })
 ENTRY(ff_sws_linear_fma_400c30cc0f_8_f32_0111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, 
.par.lin = { .one = 0x40000, .zero = 0xbadae } })
 ENTRY(ff_sws_linear_fma_400ff3fcfc_8_f32_0111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, 
.par.lin = { .one = 0x40000, .zero = 0xba118 } })
 ENTRY(ff_sws_linear_fma_400ff3fcff_8_f32_0111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x7, 
.par.lin = { .one = 0x40000, .zero = 0xba108 } })
 ENTRY(ff_sws_linear_fma_c003f3fccf_8_f32_1111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf, 
.par.lin = { .one = 0x0, .zero = 0xbb10a } })
-ENTRY(ff_sws_linear_fma_c004004004_8_f32_1000_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x8, 
.par.lin = { .one = 0x1041, .zero = 0xbefbe } })
 ENTRY(ff_sws_linear_fma_c00400400f_8_f32_1001_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x9, 
.par.lin = { .one = 0x1040, .zero = 0xbefae } })
 ENTRY(ff_sws_linear_fma_c0040040fc_8_f32_1001_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0x9, 
.par.lin = { .one = 0x1040, .zero = 0xbefb8 } })
-ENTRY(ff_sws_linear_fma_c00c00c00c_8_f32_1111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf, 
.par.lin = { .one = 0x0, .zero = 0xbefbe } })
 ENTRY(ff_sws_linear_fma_c00ff3fcff_8_f32_1111_neon, { .uop = 
SWS_UOP_LINEAR_FMA,   .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf, 
.par.lin = { .one = 0x0, .zero = 0xba108 } })
 ENTRY(ff_sws_dither_0325_4_8_f32_1111_neon,         { .uop = SWS_UOP_DITHER,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xf, .par.dither = { 
.y_offset = {5, 2, 3, 0}, .size_log2 = 4 } })
 ENTRY(ff_sws_dither_032f_4_8_f32_1110_neon,         { .uop = SWS_UOP_DITHER,   
    .block_size =  8, .type = SWS_PIXEL_F32, .mask = 0xe, .par.dither = { 
.y_offset = {0, 2, 3, 0}, .size_log2 = 4 } })
diff --git a/libswscale/uops.c b/libswscale/uops.c
index 51c675b5d97..77b638164e9 100644
--- a/libswscale/uops.c
+++ b/libswscale/uops.c
@@ -507,6 +507,7 @@ static int translate_linear_op(SwsContext *ctx, SwsUOpList 
*ops,
     const SwsPixel one = ff_sws_pixel_from_q64(uop.type, (AVRational64) {1, 
1});
     const uint32_t mask = ff_sws_linear_mask(&op->lin);
     const bool bitexact = ctx->flags & SWS_BITEXACT;
+    bool diagonal = true;
     uint32_t exact = 0;
 
     for (int i = 0; i < 4; i++) {
@@ -528,11 +529,24 @@ static int translate_linear_op(SwsContext *ctx, 
SwsUOpList *ops,
                 uop.par.lin.one |= SWS_MASK(i, j);
             else if (j < 4 && nonzero && (!bitexact || exact_prod(px, 
&inputs[j])))
                 exact |= SWS_MASK(i, j);
-            if (k.num != 0)
+            if (k.num != 0) {
                 nonzero = true;
+                diagonal &= (i == j);
+            }
         }
     }
 
+    if (diagonal) {
+        SwsUOp mul = {
+            .uop  = SWS_UOP_MUL,
+            .type = uop.type,
+            .mask = uop.mask,
+        };
+        for (int i = 0; i < 4; i++)
+            mul.data.vec4[i] = uop.data.mat4x5[i][i];
+        return ff_sws_uop_list_append(ops, &mul);
+    }
+
     if ((flags & SWS_UOP_FLAG_FMA) && !ff_sws_pixel_type_is_int(uop.type)) {
         /* multiplication by 1 and 0 are always exact by definition */
         uop.uop = SWS_UOP_LINEAR_FMA;
diff --git a/libswscale/uops_macros.h b/libswscale/uops_macros.h
index 7ca879f3084..7c9197cc738 100644
--- a/libswscale/uops_macros.h
+++ b/libswscale/uops_macros.h
@@ -228,8 +228,10 @@
     MACRO(__VA_ARGS__, u8_to_f32_yzw                           , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xe) \
     MACRO(__VA_ARGS__, u8_to_f32_xyzw                          , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xf)
 #define SWS_FOR_U8_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u8_mul_y                                , SWS_PIXEL_U8 
, SWS_UOP_MUL             , 0x2) \
     MACRO(__VA_ARGS__, u8_mul_xyz                              , SWS_PIXEL_U8 
, SWS_UOP_MUL             , 0x7)
 #define SWS_FOR_STRUCT_U8_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u8_mul_y                                , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_MUL             , .mask = 0x2) \
     MACRO(__VA_ARGS__, u8_mul_xyz                              , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_MUL             , .mask = 0x7)
 #define SWS_FOR_U8_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U8_ADD(MACRO, ...)
@@ -289,14 +291,10 @@
     MACRO(__VA_ARGS__, u8_clear_xzw_xx1                        , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR           , .mask = 0xd, .par.clear.one = 
0x00008, .par.clear.zero = 0x00000)
 #define SWS_FOR_U8_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u8_linear_x_x000x                       , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae) \
-    MACRO(__VA_ARGS__, u8_linear_y_0x000                       , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x2, 0x41001, 0xbefbe) \
-    MACRO(__VA_ARGS__, u8_linear_xyz_x000x_0x00x_00x0x         , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae) \
-    MACRO(__VA_ARGS__, u8_linear_xyz_x0000_0x000_00x00         , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe)
+    MACRO(__VA_ARGS__, u8_linear_xyz_x000x_0x00x_00x0x         , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae)
 #define SWS_FOR_STRUCT_U8_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u8_linear_x_x000x                       , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefae) \
-    MACRO(__VA_ARGS__, u8_linear_y_0x000                       , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x2, .par.lin.one = 
0x41001, .par.lin.zero = 0xbefbe) \
-    MACRO(__VA_ARGS__, u8_linear_xyz_x000x_0x00x_00x0x         , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae) \
-    MACRO(__VA_ARGS__, u8_linear_xyz_x0000_0x000_00x00         , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe)
+    MACRO(__VA_ARGS__, u8_linear_xyz_x000x_0x00x_00x0x         , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae)
 #define SWS_FOR_U8_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_STRUCT_U8_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_U8_DITHER(MACRO, ...)
@@ -475,10 +473,12 @@
     MACRO(__VA_ARGS__, u16_to_f32_xyzw                         , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32          , .mask = 0xf)
 #define SWS_FOR_U16_MUL(MACRO, ...) \
     MACRO(__VA_ARGS__, u16_mul_x                               , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x1) \
-    MACRO(__VA_ARGS__, u16_mul_xyz                             , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x7)
+    MACRO(__VA_ARGS__, u16_mul_xyz                             , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x7) \
+    MACRO(__VA_ARGS__, u16_mul_xyzw                            , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0xf)
 #define SWS_FOR_STRUCT_U16_MUL(MACRO, ...) \
     MACRO(__VA_ARGS__, u16_mul_x                               , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x1) \
-    MACRO(__VA_ARGS__, u16_mul_xyz                             , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x7)
+    MACRO(__VA_ARGS__, u16_mul_xyz                             , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x7) \
+    MACRO(__VA_ARGS__, u16_mul_xyzw                            , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0xf)
 #define SWS_FOR_U16_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U16_ADD(MACRO, ...)
 #define SWS_FOR_U16_MIN(MACRO, ...)
@@ -573,14 +573,10 @@
     MACRO(__VA_ARGS__, u16_clear_xzw_1xx                       , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR           , .mask = 0xd, .par.clear.one = 
0x00001, .par.clear.zero = 0x00000)
 #define SWS_FOR_U16_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u16_linear_x_x000x                      , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae) \
-    MACRO(__VA_ARGS__, u16_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae) \
-    MACRO(__VA_ARGS__, u16_linear_xyz_x0000_0x000_00x00        , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe) \
-    MACRO(__VA_ARGS__, u16_linear_xyzw_x0000_0x000_00x00_000x0 , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbefbe)
+    MACRO(__VA_ARGS__, u16_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae)
 #define SWS_FOR_STRUCT_U16_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u16_linear_x_x000x                      , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefae) \
-    MACRO(__VA_ARGS__, u16_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae) \
-    MACRO(__VA_ARGS__, u16_linear_xyz_x0000_0x000_00x00        , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe) \
-    MACRO(__VA_ARGS__, u16_linear_xyzw_x0000_0x000_00x00_000x0 , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbefbe)
+    MACRO(__VA_ARGS__, u16_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae)
 #define SWS_FOR_U16_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_STRUCT_U16_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_U16_DITHER(MACRO, ...)
@@ -803,12 +799,10 @@
     MACRO(__VA_ARGS__, u32_clear_xzw_xxx                       , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR           , .mask = 0xd, .par.clear.one = 
0x00000, .par.clear.zero = 0x00000)
 #define SWS_FOR_U32_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u32_linear_x_x000x                      , 
SWS_PIXEL_U32, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae) \
-    MACRO(__VA_ARGS__, u32_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_U32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae) \
-    MACRO(__VA_ARGS__, u32_linear_xyz_x0000_0x000_00x00        , 
SWS_PIXEL_U32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe)
+    MACRO(__VA_ARGS__, u32_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_U32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae)
 #define SWS_FOR_STRUCT_U32_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u32_linear_x_x000x                      , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefae) \
-    MACRO(__VA_ARGS__, u32_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae) \
-    MACRO(__VA_ARGS__, u32_linear_xyz_x0000_0x000_00x00        , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe)
+    MACRO(__VA_ARGS__, u32_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae)
 #define SWS_FOR_U32_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_STRUCT_U32_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_U32_DITHER(MACRO, ...)
@@ -913,14 +907,18 @@
 #define SWS_FOR_STRUCT_F32_TO_F32(MACRO, ...)
 #define SWS_FOR_F32_MUL(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_mul_x                               , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x1) \
+    MACRO(__VA_ARGS__, f32_mul_y                               , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x2) \
     MACRO(__VA_ARGS__, f32_mul_xy                              , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x3) \
     MACRO(__VA_ARGS__, f32_mul_xyz                             , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x7) \
+    MACRO(__VA_ARGS__, f32_mul_w                               , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x8) \
     MACRO(__VA_ARGS__, f32_mul_yzw                             , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0xe) \
     MACRO(__VA_ARGS__, f32_mul_xyzw                            , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0xf)
 #define SWS_FOR_STRUCT_F32_MUL(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_mul_x                               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x1) \
+    MACRO(__VA_ARGS__, f32_mul_y                               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x2) \
     MACRO(__VA_ARGS__, f32_mul_xy                              , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x3) \
     MACRO(__VA_ARGS__, f32_mul_xyz                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x7) \
+    MACRO(__VA_ARGS__, f32_mul_w                               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x8) \
     MACRO(__VA_ARGS__, f32_mul_yzw                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0xe) \
     MACRO(__VA_ARGS__, f32_mul_xyzw                            , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0xf)
 #define SWS_FOR_F32_ADD(MACRO, ...) \
@@ -991,36 +989,28 @@
     MACRO(__VA_ARGS__, f32_linear_x_xxx0x                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefa8) \
     MACRO(__VA_ARGS__, f32_linear_x_x000x                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae) \
     MACRO(__VA_ARGS__, f32_linear_x_xxx00                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefb8) \
-    MACRO(__VA_ARGS__, f32_linear_y_0x000                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x2, 0x41001, 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xyz_xxx0x_xxx0x_xxx0x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xba108) \
     MACRO(__VA_ARGS__, f32_linear_xyz_x0x0x_xxx0x_xx00x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbb10a) \
     MACRO(__VA_ARGS__, f32_linear_xyz_xxx00_xxx0x_xxx0x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xba118) \
     MACRO(__VA_ARGS__, f32_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae) \
-    MACRO(__VA_ARGS__, f32_linear_xyz_x0000_0x000_00x00        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xyz_10x0x_1xx0x_1x00x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40421, 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_w_000x0                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x8, 0x01041, 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xw_x000x_000x0               , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x9, 0x01040, 0xbefae) \
     MACRO(__VA_ARGS__, f32_linear_xw_xxx00_000x0               , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x9, 0x01040, 0xbefb8) \
     MACRO(__VA_ARGS__, f32_linear_xyzw_xxx0x_xxx0x_xxx0x_000x0 , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xba108) \
-    MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_xyzw_x0000_0x000_00x00_000x0 , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbefbe)
+    MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbb10a)
 #define SWS_FOR_STRUCT_F32_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_linear_x_xxx0x                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefa8) \
     MACRO(__VA_ARGS__, f32_linear_x_x000x                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefae) \
     MACRO(__VA_ARGS__, f32_linear_x_xxx00                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefb8) \
-    MACRO(__VA_ARGS__, f32_linear_y_0x000                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x2, .par.lin.one = 
0x41001, .par.lin.zero = 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xyz_xxx0x_xxx0x_xxx0x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xba108) \
     MACRO(__VA_ARGS__, f32_linear_xyz_x0x0x_xxx0x_xx00x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbb10a) \
     MACRO(__VA_ARGS__, f32_linear_xyz_xxx00_xxx0x_xxx0x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xba118) \
     MACRO(__VA_ARGS__, f32_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae) \
-    MACRO(__VA_ARGS__, f32_linear_xyz_x0000_0x000_00x00        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xyz_10x0x_1xx0x_1x00x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40421, .par.lin.zero = 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_w_000x0                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x8, .par.lin.one = 
0x01041, .par.lin.zero = 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xw_x000x_000x0               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x9, .par.lin.one = 
0x01040, .par.lin.zero = 0xbefae) \
     MACRO(__VA_ARGS__, f32_linear_xw_xxx00_000x0               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x9, .par.lin.one = 
0x01040, .par.lin.zero = 0xbefb8) \
     MACRO(__VA_ARGS__, f32_linear_xyzw_xxx0x_xxx0x_xxx0x_000x0 , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xba108) \
-    MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_xyzw_x0000_0x000_00x00_000x0 , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbefbe)
+    MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbb10a)
 #define SWS_FOR_F32_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_STRUCT_F32_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_F32_DITHER(MACRO, ...) \
diff --git a/libswscale/x86/uops_macros.asm b/libswscale/x86/uops_macros.asm
index 6344aaec921..03d68f4cce6 100644
--- a/libswscale/x86/uops_macros.asm
+++ b/libswscale/x86/uops_macros.asm
@@ -183,6 +183,7 @@
 %endmacro
 
 %macro DECL_U8_MUL 1
+    DECL_OP %1, u8_mul_y                                , SWS_PIXEL_U8 , 
SWS_UOP_MUL             , 0x2
     DECL_OP %1, u8_mul_xyz                              , SWS_PIXEL_U8 , 
SWS_UOP_MUL             , 0x7
 %endmacro
 
@@ -232,9 +233,7 @@
 
 %macro DECL_U8_LINEAR 1
     DECL_OP %1, u8_linear_x_x000x                       , SWS_PIXEL_U8 , 
SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae
-    DECL_OP %1, u8_linear_y_0x000                       , SWS_PIXEL_U8 , 
SWS_UOP_LINEAR          , 0x2, 0x41001, 0xbefbe
     DECL_OP %1, u8_linear_xyz_x000x_0x00x_00x0x         , SWS_PIXEL_U8 , 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae
-    DECL_OP %1, u8_linear_xyz_x0000_0x000_00x00         , SWS_PIXEL_U8 , 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe
 %endmacro
 
 %macro DECL_U8_LINEAR_FMA 1
@@ -384,6 +383,7 @@
 %macro DECL_U16_MUL 1
     DECL_OP %1, u16_mul_x                               , SWS_PIXEL_U16, 
SWS_UOP_MUL             , 0x1
     DECL_OP %1, u16_mul_xyz                             , SWS_PIXEL_U16, 
SWS_UOP_MUL             , 0x7
+    DECL_OP %1, u16_mul_xyzw                            , SWS_PIXEL_U16, 
SWS_UOP_MUL             , 0xf
 %endmacro
 
 %macro DECL_U16_ADD 1
@@ -451,8 +451,6 @@
 %macro DECL_U16_LINEAR 1
     DECL_OP %1, u16_linear_x_x000x                      , SWS_PIXEL_U16, 
SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae
     DECL_OP %1, u16_linear_xyz_x000x_0x00x_00x0x        , SWS_PIXEL_U16, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae
-    DECL_OP %1, u16_linear_xyz_x0000_0x000_00x00        , SWS_PIXEL_U16, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe
-    DECL_OP %1, u16_linear_xyzw_x0000_0x000_00x00_000x0 , SWS_PIXEL_U16, 
SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbefbe
 %endmacro
 
 %macro DECL_U16_LINEAR_FMA 1
@@ -638,7 +636,6 @@
 %macro DECL_U32_LINEAR 1
     DECL_OP %1, u32_linear_x_x000x                      , SWS_PIXEL_U32, 
SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae
     DECL_OP %1, u32_linear_xyz_x000x_0x00x_00x0x        , SWS_PIXEL_U32, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae
-    DECL_OP %1, u32_linear_xyz_x0000_0x000_00x00        , SWS_PIXEL_U32, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe
 %endmacro
 
 %macro DECL_U32_LINEAR_FMA 1
@@ -750,8 +747,10 @@
 
 %macro DECL_F32_MUL 1
     DECL_OP %1, f32_mul_x                               , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0x1
+    DECL_OP %1, f32_mul_y                               , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0x2
     DECL_OP %1, f32_mul_xy                              , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0x3
     DECL_OP %1, f32_mul_xyz                             , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0x7
+    DECL_OP %1, f32_mul_w                               , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0x8
     DECL_OP %1, f32_mul_yzw                             , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0xe
     DECL_OP %1, f32_mul_xyzw                            , SWS_PIXEL_F32, 
SWS_UOP_MUL             , 0xf
 %endmacro
@@ -808,19 +807,15 @@
     DECL_OP %1, f32_linear_x_xxx0x                      , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefa8
     DECL_OP %1, f32_linear_x_x000x                      , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae
     DECL_OP %1, f32_linear_x_xxx00                      , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefb8
-    DECL_OP %1, f32_linear_y_0x000                      , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x2, 0x41001, 0xbefbe
     DECL_OP %1, f32_linear_xyz_xxx0x_xxx0x_xxx0x        , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xba108
     DECL_OP %1, f32_linear_xyz_x0x0x_xxx0x_xx00x        , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbb10a
     DECL_OP %1, f32_linear_xyz_xxx00_xxx0x_xxx0x        , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xba118
     DECL_OP %1, f32_linear_xyz_x000x_0x00x_00x0x        , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae
-    DECL_OP %1, f32_linear_xyz_x0000_0x000_00x00        , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe
     DECL_OP %1, f32_linear_xyz_10x0x_1xx0x_1x00x        , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x7, 0x40421, 0xbb10a
-    DECL_OP %1, f32_linear_w_000x0                      , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x8, 0x01041, 0xbefbe
     DECL_OP %1, f32_linear_xw_x000x_000x0               , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x9, 0x01040, 0xbefae
     DECL_OP %1, f32_linear_xw_xxx00_000x0               , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0x9, 0x01040, 0xbefb8
     DECL_OP %1, f32_linear_xyzw_xxx0x_xxx0x_xxx0x_000x0 , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0xf, 0x00000, 0xba108
     DECL_OP %1, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbb10a
-    DECL_OP %1, f32_linear_xyzw_x0000_0x000_00x00_000x0 , SWS_PIXEL_F32, 
SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbefbe
 %endmacro
 
 %macro DECL_F32_LINEAR_FMA 1
@@ -833,7 +828,6 @@
     DECL_OP %1, f32_linear_fma_x_xXx00                  , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x1, 0x41040, 0xbefb8, 0xffffa
     DECL_OP %1, f32_linear_fma_x_xxX00                  , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x1, 0x41040, 0xbefb8, 0xffffc
     DECL_OP %1, f32_linear_fma_x_xXX00                  , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x1, 0x41040, 0xbefb8, 0xffffe
-    DECL_OP %1, f32_linear_fma_y_0x000                  , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x2, 0x41001, 0xbefbe, 0xfffbf
     DECL_OP %1, f32_linear_fma_xyz_xxx0x_xxx0x_xxx0x    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xba108, 0xfa108
     DECL_OP %1, f32_linear_fma_xyz_xxx0x_xxx0x_Xxx0x    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xba108, 0xfa508
     DECL_OP %1, f32_linear_fma_xyz_xxx0x_xxx0x_XXx0x    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xba108, 0xfad08
@@ -851,10 +845,8 @@
     DECL_OP %1, f32_linear_fma_xyz_x000x_0x00x_00x0x    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xbadae, 0xfadae
     DECL_OP %1, f32_linear_fma_xyz_X000x_0x00x_00X0x    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xbadae, 0xfbdaf
     DECL_OP %1, f32_linear_fma_xyz_X000x_0X00x_00X0x    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xbadae, 0xfbdef
-    DECL_OP %1, f32_linear_fma_xyz_x0000_0x000_00x00    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xbefbe, 0xfefbe
     DECL_OP %1, f32_linear_fma_xyz_10x0x_1xx0x_1x00x    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40421, 0xbb10a, 0xfb52b
     DECL_OP %1, f32_linear_fma_xyz_10X0x_1XX0x_1X00x    , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x7, 0x40421, 0xbb10a, 0xfbdef
-    DECL_OP %1, f32_linear_fma_w_000x0                  , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x8, 0x01041, 0xbefbe, 0xbffff
     DECL_OP %1, f32_linear_fma_xw_x000x_000x0           , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x9, 0x01040, 0xbefae, 0xbffee
     DECL_OP %1, f32_linear_fma_xw_X000x_000x0           , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x9, 0x01040, 0xbefae, 0xbffef
     DECL_OP %1, f32_linear_fma_xw_xxx00_000x0           , SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0x9, 0x01040, 0xbefb8, 0xbfff8
@@ -863,7 +855,6 @@
     DECL_OP %1, f32_linear_fma_xyzw_XXX0x_XXX0x_XXX0x_000x0, SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xba108, 0xbbdef
     DECL_OP %1, f32_linear_fma_xyzw_x0x0x_xxx0x_xx00x_000x0, SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xbb10a, 0xbb10a
     DECL_OP %1, f32_linear_fma_xyzw_X0X0x_XXX0x_XX00x_000x0, SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xbb10a, 0xbbdef
-    DECL_OP %1, f32_linear_fma_xyzw_x0000_0x000_00x00_000x0, SWS_PIXEL_F32, 
SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xbefbe, 0xbefbe
 %endmacro
 
 %macro DECL_F32_DITHER 1
diff --git a/libswscale/x86/uops_macros.h b/libswscale/x86/uops_macros.h
index e60aaad99a2..869429d064e 100644
--- a/libswscale/x86/uops_macros.h
+++ b/libswscale/x86/uops_macros.h
@@ -276,8 +276,10 @@
     MACRO(__VA_ARGS__, u8_to_f32_yzw                           , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xe) \
     MACRO(__VA_ARGS__, u8_to_f32_xyzw                          , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_TO_F32          , .mask = 0xf)
 #define SWS_FOR_U8_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u8_mul_y                                , SWS_PIXEL_U8 
, SWS_UOP_MUL             , 0x2) \
     MACRO(__VA_ARGS__, u8_mul_xyz                              , SWS_PIXEL_U8 
, SWS_UOP_MUL             , 0x7)
 #define SWS_FOR_STRUCT_U8_MUL(MACRO, ...) \
+    MACRO(__VA_ARGS__, u8_mul_y                                , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_MUL             , .mask = 0x2) \
     MACRO(__VA_ARGS__, u8_mul_xyz                              , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_MUL             , .mask = 0x7)
 #define SWS_FOR_U8_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U8_ADD(MACRO, ...)
@@ -337,14 +339,10 @@
     MACRO(__VA_ARGS__, u8_clear_xzw_xx1                        , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_CLEAR           , .mask = 0xd, .par.clear.one = 
0x00008, .par.clear.zero = 0x00000)
 #define SWS_FOR_U8_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u8_linear_x_x000x                       , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae) \
-    MACRO(__VA_ARGS__, u8_linear_y_0x000                       , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x2, 0x41001, 0xbefbe) \
-    MACRO(__VA_ARGS__, u8_linear_xyz_x000x_0x00x_00x0x         , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae) \
-    MACRO(__VA_ARGS__, u8_linear_xyz_x0000_0x000_00x00         , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe)
+    MACRO(__VA_ARGS__, u8_linear_xyz_x000x_0x00x_00x0x         , SWS_PIXEL_U8 
, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae)
 #define SWS_FOR_STRUCT_U8_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u8_linear_x_x000x                       , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefae) \
-    MACRO(__VA_ARGS__, u8_linear_y_0x000                       , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x2, .par.lin.one = 
0x41001, .par.lin.zero = 0xbefbe) \
-    MACRO(__VA_ARGS__, u8_linear_xyz_x000x_0x00x_00x0x         , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae) \
-    MACRO(__VA_ARGS__, u8_linear_xyz_x0000_0x000_00x00         , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe)
+    MACRO(__VA_ARGS__, u8_linear_xyz_x000x_0x00x_00x0x         , .type = 
SWS_PIXEL_U8 , .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae)
 #define SWS_FOR_U8_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_STRUCT_U8_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_U8_DITHER(MACRO, ...)
@@ -531,10 +529,12 @@
     MACRO(__VA_ARGS__, u16_to_f32_xyzw                         , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_TO_F32          , .mask = 0xf)
 #define SWS_FOR_U16_MUL(MACRO, ...) \
     MACRO(__VA_ARGS__, u16_mul_x                               , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x1) \
-    MACRO(__VA_ARGS__, u16_mul_xyz                             , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x7)
+    MACRO(__VA_ARGS__, u16_mul_xyz                             , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0x7) \
+    MACRO(__VA_ARGS__, u16_mul_xyzw                            , 
SWS_PIXEL_U16, SWS_UOP_MUL             , 0xf)
 #define SWS_FOR_STRUCT_U16_MUL(MACRO, ...) \
     MACRO(__VA_ARGS__, u16_mul_x                               , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x1) \
-    MACRO(__VA_ARGS__, u16_mul_xyz                             , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x7)
+    MACRO(__VA_ARGS__, u16_mul_xyz                             , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0x7) \
+    MACRO(__VA_ARGS__, u16_mul_xyzw                            , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_MUL             , .mask = 0xf)
 #define SWS_FOR_U16_ADD(MACRO, ...)
 #define SWS_FOR_STRUCT_U16_ADD(MACRO, ...)
 #define SWS_FOR_U16_MIN(MACRO, ...)
@@ -629,14 +629,10 @@
     MACRO(__VA_ARGS__, u16_clear_xzw_1xx                       , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_CLEAR           , .mask = 0xd, .par.clear.one = 
0x00001, .par.clear.zero = 0x00000)
 #define SWS_FOR_U16_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u16_linear_x_x000x                      , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae) \
-    MACRO(__VA_ARGS__, u16_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae) \
-    MACRO(__VA_ARGS__, u16_linear_xyz_x0000_0x000_00x00        , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe) \
-    MACRO(__VA_ARGS__, u16_linear_xyzw_x0000_0x000_00x00_000x0 , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbefbe)
+    MACRO(__VA_ARGS__, u16_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_U16, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae)
 #define SWS_FOR_STRUCT_U16_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u16_linear_x_x000x                      , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefae) \
-    MACRO(__VA_ARGS__, u16_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae) \
-    MACRO(__VA_ARGS__, u16_linear_xyz_x0000_0x000_00x00        , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe) \
-    MACRO(__VA_ARGS__, u16_linear_xyzw_x0000_0x000_00x00_000x0 , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbefbe)
+    MACRO(__VA_ARGS__, u16_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_U16, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae)
 #define SWS_FOR_U16_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_STRUCT_U16_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_U16_DITHER(MACRO, ...)
@@ -859,12 +855,10 @@
     MACRO(__VA_ARGS__, u32_clear_xzw_xxx                       , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_CLEAR           , .mask = 0xd, .par.clear.one = 
0x00000, .par.clear.zero = 0x00000)
 #define SWS_FOR_U32_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u32_linear_x_x000x                      , 
SWS_PIXEL_U32, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae) \
-    MACRO(__VA_ARGS__, u32_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_U32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae) \
-    MACRO(__VA_ARGS__, u32_linear_xyz_x0000_0x000_00x00        , 
SWS_PIXEL_U32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe)
+    MACRO(__VA_ARGS__, u32_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_U32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae)
 #define SWS_FOR_STRUCT_U32_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, u32_linear_x_x000x                      , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefae) \
-    MACRO(__VA_ARGS__, u32_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae) \
-    MACRO(__VA_ARGS__, u32_linear_xyz_x0000_0x000_00x00        , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe)
+    MACRO(__VA_ARGS__, u32_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_U32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae)
 #define SWS_FOR_U32_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_STRUCT_U32_LINEAR_FMA(MACRO, ...)
 #define SWS_FOR_U32_DITHER(MACRO, ...)
@@ -977,14 +971,18 @@
 #define SWS_FOR_STRUCT_F32_TO_F32(MACRO, ...)
 #define SWS_FOR_F32_MUL(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_mul_x                               , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x1) \
+    MACRO(__VA_ARGS__, f32_mul_y                               , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x2) \
     MACRO(__VA_ARGS__, f32_mul_xy                              , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x3) \
     MACRO(__VA_ARGS__, f32_mul_xyz                             , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x7) \
+    MACRO(__VA_ARGS__, f32_mul_w                               , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0x8) \
     MACRO(__VA_ARGS__, f32_mul_yzw                             , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0xe) \
     MACRO(__VA_ARGS__, f32_mul_xyzw                            , 
SWS_PIXEL_F32, SWS_UOP_MUL             , 0xf)
 #define SWS_FOR_STRUCT_F32_MUL(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_mul_x                               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x1) \
+    MACRO(__VA_ARGS__, f32_mul_y                               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x2) \
     MACRO(__VA_ARGS__, f32_mul_xy                              , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x3) \
     MACRO(__VA_ARGS__, f32_mul_xyz                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x7) \
+    MACRO(__VA_ARGS__, f32_mul_w                               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0x8) \
     MACRO(__VA_ARGS__, f32_mul_yzw                             , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0xe) \
     MACRO(__VA_ARGS__, f32_mul_xyzw                            , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_MUL             , .mask = 0xf)
 #define SWS_FOR_F32_ADD(MACRO, ...) \
@@ -1055,36 +1053,28 @@
     MACRO(__VA_ARGS__, f32_linear_x_xxx0x                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefa8) \
     MACRO(__VA_ARGS__, f32_linear_x_x000x                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefae) \
     MACRO(__VA_ARGS__, f32_linear_x_xxx00                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x1, 0x41040, 0xbefb8) \
-    MACRO(__VA_ARGS__, f32_linear_y_0x000                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x2, 0x41001, 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xyz_xxx0x_xxx0x_xxx0x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xba108) \
     MACRO(__VA_ARGS__, f32_linear_xyz_x0x0x_xxx0x_xx00x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbb10a) \
     MACRO(__VA_ARGS__, f32_linear_xyz_xxx00_xxx0x_xxx0x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xba118) \
     MACRO(__VA_ARGS__, f32_linear_xyz_x000x_0x00x_00x0x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbadae) \
-    MACRO(__VA_ARGS__, f32_linear_xyz_x0000_0x000_00x00        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40000, 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xyz_10x0x_1xx0x_1x00x        , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x7, 0x40421, 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_w_000x0                      , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x8, 0x01041, 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xw_x000x_000x0               , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x9, 0x01040, 0xbefae) \
     MACRO(__VA_ARGS__, f32_linear_xw_xxx00_000x0               , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0x9, 0x01040, 0xbefb8) \
     MACRO(__VA_ARGS__, f32_linear_xyzw_xxx0x_xxx0x_xxx0x_000x0 , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xba108) \
-    MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_xyzw_x0000_0x000_00x00_000x0 , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbefbe)
+    MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , 
SWS_PIXEL_F32, SWS_UOP_LINEAR          , 0xf, 0x00000, 0xbb10a)
 #define SWS_FOR_STRUCT_F32_LINEAR(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_linear_x_xxx0x                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefa8) \
     MACRO(__VA_ARGS__, f32_linear_x_x000x                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefae) \
     MACRO(__VA_ARGS__, f32_linear_x_xxx00                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefb8) \
-    MACRO(__VA_ARGS__, f32_linear_y_0x000                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x2, .par.lin.one = 
0x41001, .par.lin.zero = 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xyz_xxx0x_xxx0x_xxx0x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xba108) \
     MACRO(__VA_ARGS__, f32_linear_xyz_x0x0x_xxx0x_xx00x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbb10a) \
     MACRO(__VA_ARGS__, f32_linear_xyz_xxx00_xxx0x_xxx0x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xba118) \
     MACRO(__VA_ARGS__, f32_linear_xyz_x000x_0x00x_00x0x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae) \
-    MACRO(__VA_ARGS__, f32_linear_xyz_x0000_0x000_00x00        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xyz_10x0x_1xx0x_1x00x        , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x7, .par.lin.one = 
0x40421, .par.lin.zero = 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_w_000x0                      , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x8, .par.lin.one = 
0x01041, .par.lin.zero = 0xbefbe) \
     MACRO(__VA_ARGS__, f32_linear_xw_x000x_000x0               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x9, .par.lin.one = 
0x01040, .par.lin.zero = 0xbefae) \
     MACRO(__VA_ARGS__, f32_linear_xw_xxx00_000x0               , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0x9, .par.lin.one = 
0x01040, .par.lin.zero = 0xbefb8) \
     MACRO(__VA_ARGS__, f32_linear_xyzw_xxx0x_xxx0x_xxx0x_000x0 , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xba108) \
-    MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_xyzw_x0000_0x000_00x00_000x0 , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbefbe)
+    MACRO(__VA_ARGS__, f32_linear_xyzw_x0x0x_xxx0x_xx00x_000x0 , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR          , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbb10a)
 #define SWS_FOR_F32_LINEAR_FMA(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_linear_fma_x_xxx0x                  , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x1, 0x41040, 0xbefa8, 0xfffe8) \
     MACRO(__VA_ARGS__, f32_linear_fma_x_xXx0x                  , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x1, 0x41040, 0xbefa8, 0xfffea) \
@@ -1095,7 +1085,6 @@
     MACRO(__VA_ARGS__, f32_linear_fma_x_xXx00                  , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x1, 0x41040, 0xbefb8, 0xffffa) \
     MACRO(__VA_ARGS__, f32_linear_fma_x_xxX00                  , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x1, 0x41040, 0xbefb8, 0xffffc) \
     MACRO(__VA_ARGS__, f32_linear_fma_x_xXX00                  , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x1, 0x41040, 0xbefb8, 0xffffe) \
-    MACRO(__VA_ARGS__, f32_linear_fma_y_0x000                  , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x2, 0x41001, 0xbefbe, 0xfffbf) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_xxx0x_xxx0x_xxx0x    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xba108, 0xfa108) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_xxx0x_xxx0x_Xxx0x    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xba108, 0xfa508) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_xxx0x_xxx0x_XXx0x    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xba108, 0xfad08) \
@@ -1113,10 +1102,8 @@
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_x000x_0x00x_00x0x    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xbadae, 0xfadae) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_X000x_0x00x_00X0x    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xbadae, 0xfbdaf) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_X000x_0X00x_00X0x    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xbadae, 0xfbdef) \
-    MACRO(__VA_ARGS__, f32_linear_fma_xyz_x0000_0x000_00x00    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40000, 0xbefbe, 0xfefbe) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_10x0x_1xx0x_1x00x    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40421, 0xbb10a, 0xfb52b) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_10X0x_1XX0x_1X00x    , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x7, 0x40421, 0xbb10a, 0xfbdef) \
-    MACRO(__VA_ARGS__, f32_linear_fma_w_000x0                  , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x8, 0x01041, 0xbefbe, 0xbffff) \
     MACRO(__VA_ARGS__, f32_linear_fma_xw_x000x_000x0           , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x9, 0x01040, 0xbefae, 0xbffee) \
     MACRO(__VA_ARGS__, f32_linear_fma_xw_X000x_000x0           , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x9, 0x01040, 0xbefae, 0xbffef) \
     MACRO(__VA_ARGS__, f32_linear_fma_xw_xxx00_000x0           , 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0x9, 0x01040, 0xbefb8, 0xbfff8) \
@@ -1124,8 +1111,7 @@
     MACRO(__VA_ARGS__, f32_linear_fma_xyzw_xxx0x_xxx0x_xxx0x_000x0, 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xba108, 0xba108) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyzw_XXX0x_XXX0x_XXX0x_000x0, 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xba108, 0xbbdef) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyzw_x0x0x_xxx0x_xx00x_000x0, 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xbb10a, 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_fma_xyzw_X0X0x_XXX0x_XX00x_000x0, 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xbb10a, 0xbbdef) \
-    MACRO(__VA_ARGS__, f32_linear_fma_xyzw_x0000_0x000_00x00_000x0, 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xbefbe, 0xbefbe)
+    MACRO(__VA_ARGS__, f32_linear_fma_xyzw_X0X0x_XXX0x_XX00x_000x0, 
SWS_PIXEL_F32, SWS_UOP_LINEAR_FMA      , 0xf, 0x00000, 0xbb10a, 0xbbdef)
 #define SWS_FOR_STRUCT_F32_LINEAR_FMA(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_linear_fma_x_xxx0x                  , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefa8, .par.lin.exact = 0xfffe8) \
     MACRO(__VA_ARGS__, f32_linear_fma_x_xXx0x                  , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefa8, .par.lin.exact = 0xfffea) \
@@ -1136,7 +1122,6 @@
     MACRO(__VA_ARGS__, f32_linear_fma_x_xXx00                  , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefb8, .par.lin.exact = 0xffffa) \
     MACRO(__VA_ARGS__, f32_linear_fma_x_xxX00                  , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefb8, .par.lin.exact = 0xffffc) \
     MACRO(__VA_ARGS__, f32_linear_fma_x_xXX00                  , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x1, .par.lin.one = 
0x41040, .par.lin.zero = 0xbefb8, .par.lin.exact = 0xffffe) \
-    MACRO(__VA_ARGS__, f32_linear_fma_y_0x000                  , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x2, .par.lin.one = 
0x41001, .par.lin.zero = 0xbefbe, .par.lin.exact = 0xfffbf) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_xxx0x_xxx0x_xxx0x    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xba108, .par.lin.exact = 0xfa108) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_xxx0x_xxx0x_Xxx0x    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xba108, .par.lin.exact = 0xfa508) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_xxx0x_xxx0x_XXx0x    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xba108, .par.lin.exact = 0xfad08) \
@@ -1154,10 +1139,8 @@
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_x000x_0x00x_00x0x    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae, .par.lin.exact = 0xfadae) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_X000x_0x00x_00X0x    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae, .par.lin.exact = 0xfbdaf) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_X000x_0X00x_00X0x    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbadae, .par.lin.exact = 0xfbdef) \
-    MACRO(__VA_ARGS__, f32_linear_fma_xyz_x0000_0x000_00x00    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40000, .par.lin.zero = 0xbefbe, .par.lin.exact = 0xfefbe) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_10x0x_1xx0x_1x00x    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40421, .par.lin.zero = 0xbb10a, .par.lin.exact = 0xfb52b) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyz_10X0x_1XX0x_1X00x    , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x7, .par.lin.one = 
0x40421, .par.lin.zero = 0xbb10a, .par.lin.exact = 0xfbdef) \
-    MACRO(__VA_ARGS__, f32_linear_fma_w_000x0                  , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x8, .par.lin.one = 
0x01041, .par.lin.zero = 0xbefbe, .par.lin.exact = 0xbffff) \
     MACRO(__VA_ARGS__, f32_linear_fma_xw_x000x_000x0           , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x9, .par.lin.one = 
0x01040, .par.lin.zero = 0xbefae, .par.lin.exact = 0xbffee) \
     MACRO(__VA_ARGS__, f32_linear_fma_xw_X000x_000x0           , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x9, .par.lin.one = 
0x01040, .par.lin.zero = 0xbefae, .par.lin.exact = 0xbffef) \
     MACRO(__VA_ARGS__, f32_linear_fma_xw_xxx00_000x0           , .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0x9, .par.lin.one = 
0x01040, .par.lin.zero = 0xbefb8, .par.lin.exact = 0xbfff8) \
@@ -1165,8 +1148,7 @@
     MACRO(__VA_ARGS__, f32_linear_fma_xyzw_xxx0x_xxx0x_xxx0x_000x0, .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xba108, .par.lin.exact = 0xba108) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyzw_XXX0x_XXX0x_XXX0x_000x0, .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xba108, .par.lin.exact = 0xbbdef) \
     MACRO(__VA_ARGS__, f32_linear_fma_xyzw_x0x0x_xxx0x_xx00x_000x0, .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbb10a, .par.lin.exact = 0xbb10a) \
-    MACRO(__VA_ARGS__, f32_linear_fma_xyzw_X0X0x_XXX0x_XX00x_000x0, .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbb10a, .par.lin.exact = 0xbbdef) \
-    MACRO(__VA_ARGS__, f32_linear_fma_xyzw_x0000_0x000_00x00_000x0, .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbefbe, .par.lin.exact = 0xbefbe)
+    MACRO(__VA_ARGS__, f32_linear_fma_xyzw_X0X0x_XXX0x_XX00x_000x0, .type = 
SWS_PIXEL_F32, .uop = SWS_UOP_LINEAR_FMA      , .mask = 0xf, .par.lin.one = 
0x00000, .par.lin.zero = 0xbb10a, .par.lin.exact = 0xbbdef)
 #define SWS_FOR_F32_DITHER(MACRO, ...) \
     MACRO(__VA_ARGS__, f32_dither_x_0_16x16                    , 
SWS_PIXEL_F32, SWS_UOP_DITHER          , 0x1, 0, 0, 0, 0, 4) \
     MACRO(__VA_ARGS__, f32_dither_y_3_16x16                    , 
SWS_PIXEL_F32, SWS_UOP_DITHER          , 0x2, 0, 3, 0, 0, 4) \
diff --git a/tests/ref/fate/sws-ops-list b/tests/ref/fate/sws-ops-list
index b22c6b980dd..ba869d4f082 100644
--- a/tests/ref/fate/sws-ops-list
+++ b/tests/ref/fate/sws-ops-list
@@ -1 +1 @@
-86e2905e47e498a515d47df0c40dbafc
+db9d3798308e0d659b049d7cc8d985f9
-- 
2.54.0

_______________________________________________
ffmpeg-devel mailing list -- [email protected]
To unsubscribe send an email to [email protected]

Reply via email to