This is an automated email from the git hooks/post-receive script.

Git pushed a commit to branch master
in repository ffmpeg.

commit e66601ac6b410f05d353d63ad4b9f05816fcf18c
Author:     Ramiro Polla <[email protected]>
AuthorDate: Fri Jun 12 21:18:35 2026 +0200
Commit:     Ramiro Polla <[email protected]>
CommitDate: Sun Jul 19 15:07:02 2026 +0200

    swscale/aarch64/ops: specialize linear operation
    
    This is similar to the way SWS_UOP_LINEAR{,_FMA} work and will simplify
    the move to uops.
    
    Sponsored-by: Sovereign Tech Fund
    Signed-off-by: Ramiro Polla <[email protected]>
---
 libswscale/aarch64/ops_asmgen.c    | 18 ++++++-----
 libswscale/aarch64/ops_entries.c   | 64 +++++++++++++++++++-------------------
 libswscale/aarch64/ops_impl.c      |  6 ++--
 libswscale/aarch64/ops_impl.h      |  2 +-
 libswscale/aarch64/ops_impl_conv.c |  8 +++--
 libswscale/tests/sws_ops_aarch64.c |  4 +--
 6 files changed, 55 insertions(+), 47 deletions(-)

diff --git a/libswscale/aarch64/ops_asmgen.c b/libswscale/aarch64/ops_asmgen.c
index 4dffb592a9..260279117c 100644
--- a/libswscale/aarch64/ops_asmgen.c
+++ b/libswscale/aarch64/ops_asmgen.c
@@ -1053,6 +1053,7 @@ static void asmgen_op_scale(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *
 /*********************************************************************/
 /* generalized linear affine transform */
 /* AARCH64_SWS_OP_LINEAR */
+/* AARCH64_SWS_OP_LINEAR_FMA */
 
 /**
  * Performs one pass of the linear transform over a single vector bank
@@ -1115,7 +1116,14 @@ static void linear_pass(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *p,
                 } else {
                     i_fmul  (r, vx[i], vsrc, vcoeff);   CMTF("v%c[%u]  = 
vsrc[%u] * vc[%u][%u];", cvh, i, src_j, vc_i, vc_j);
                 }
-            } else if (!p->linear.fmla) {
+            } else if (p->op == AARCH64_SWS_OP_LINEAR_FMA) {
+                /**
+                 * Most modern aarch64 cores have a fastpath for sequences
+                 * of fmla instructions. This means that even if the 
coefficient
+                 * is 1, it is still faster to use fmla by 1 instead of fadd.
+                 */
+                i_fmla(r, vx[i], vsrc, vcoeff);         CMTF("v%c[%u] += 
vsrc[%u] * vc[%u][%u];", cvh, i, src_j, vc_i, vc_j);
+            } else {
                 /**
                  * Split the multiply-accumulate into fmul+fadd. All
                  * multiplications are performed first into temporary
@@ -1131,13 +1139,6 @@ static void linear_pass(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *p,
                 } else {
                     i_fadd(r, vx[i], vx[i], vsrc);          CMTF("v%c[%u] += 
vsrc[%u];", cvh, i, vc_j);
                 }
-            } else {
-                /**
-                 * Most modern aarch64 cores have a fastpath for sequences
-                 * of fmla instructions. This means that even if the 
coefficient
-                 * is 1, it is still faster to use fmla by 1 instead of fadd.
-                 */
-                i_fmla(r, vx[i], vsrc, vcoeff);         CMTF("v%c[%u] += 
vsrc[%u] * vc[%u][%u];", cvh, i, src_j, vc_i, vc_j);
             }
             first = false;
         }
@@ -1382,6 +1383,7 @@ static void asmgen_op_cps(SwsAArch64Context *s, const 
SwsAArch64OpImplParams *p)
     case AARCH64_SWS_OP_MAX:          asmgen_op_max(s, p);          break;
     case AARCH64_SWS_OP_SCALE:        asmgen_op_scale(s, p);        break;
     case AARCH64_SWS_OP_LINEAR:       asmgen_op_linear(s, p);       break;
+    case AARCH64_SWS_OP_LINEAR_FMA:   asmgen_op_linear(s, p);       break;
     case AARCH64_SWS_OP_DITHER:       asmgen_op_dither(s, p);       break;
     /* TODO implement AARCH64_SWS_OP_SHUFFLE */
     default:
diff --git a/libswscale/aarch64/ops_entries.c b/libswscale/aarch64/ops_entries.c
index 4f59aef574..3f0fc83e26 100644
--- a/libswscale/aarch64/ops_entries.c
+++ b/libswscale/aarch64/ops_entries.c
@@ -346,38 +346,38 @@
 { .op = AARCH64_SWS_OP_SCALE, .block_size = 16, .type = AARCH64_PIXEL_U8, 
.mask = 0x0111 },
 { .op = AARCH64_SWS_OP_SCALE, .block_size = 16, .type = AARCH64_PIXEL_U16, 
.mask = 0x0001 },
 { .op = AARCH64_SWS_OP_SCALE, .block_size = 16, .type = AARCH64_PIXEL_U16, 
.mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000000000fULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000000000fULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x00000000fcULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x00000000fcULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x00000000ffULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x00000000ffULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000000c000ULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0010 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000000c000ULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0010 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000373dcc7ULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000373dcc7ULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x0003f3fccfULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x0003f3fccfULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000c00c00cULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000c00c00cULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000c30cc0fULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000c30cc0fULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000ff3fcfcULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000ff3fcfcULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000ff3fcffULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000ff3fcffULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc000000000ULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1000 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc000000000ULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1000 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00000000fULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00000000fULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc0000000fcULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc0000000fcULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1001 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc003f3fccfULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc003f3fccfULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00c00c00cULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00c00c00cULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00ff3fcffULL, .linear.fmla = 
0, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
-{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00ff3fcffULL, .linear.fmla = 
1, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000000000fULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x00000000fcULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x00000000ffULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000000c000ULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0010 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000373dcc7ULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x0003f3fccfULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000c00c00cULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000c30cc0fULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000ff3fcfcULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0x000ff3fcffULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc000000000ULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x1000 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00000000fULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x1001 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc0000000fcULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x1001 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc003f3fccfULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00c00c00cULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
+{ .op = AARCH64_SWS_OP_LINEAR, .linear.mask = 0xc00ff3fcffULL, .block_size = 
8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x000000000fULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x00000000fcULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x00000000ffULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0001 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x000000c000ULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0010 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x000373dcc7ULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x0003f3fccfULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x000c00c00cULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x000c30cc0fULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x000ff3fcfcULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0x000ff3fcffULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x0111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0xc000000000ULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x1000 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0xc00000000fULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x1001 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0xc0000000fcULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x1001 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0xc003f3fccfULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0xc00c00c00cULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
+{ .op = AARCH64_SWS_OP_LINEAR_FMA, .linear.mask = 0xc00ff3fcffULL, .block_size 
= 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
 { .op = AARCH64_SWS_OP_DITHER, .dither.y_offset = 0x0325, .dither.size_log2 = 
4, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
 { .op = AARCH64_SWS_OP_DITHER, .dither.y_offset = 0x032f, .dither.size_log2 = 
4, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1110 },
 { .op = AARCH64_SWS_OP_DITHER, .dither.y_offset = 0x2305, .dither.size_log2 = 
4, .block_size = 8, .type = AARCH64_PIXEL_F32, .mask = 0x1111 },
diff --git a/libswscale/aarch64/ops_impl.c b/libswscale/aarch64/ops_impl.c
index 2ed1effce6..e0dbcd5d80 100644
--- a/libswscale/aarch64/ops_impl.c
+++ b/libswscale/aarch64/ops_impl.c
@@ -102,6 +102,7 @@ static const char op_types[AARCH64_SWS_OP_TYPE_NB][32] = {
     [AARCH64_SWS_OP_MAX           ] = "AARCH64_SWS_OP_MAX",
     [AARCH64_SWS_OP_SCALE         ] = "AARCH64_SWS_OP_SCALE",
     [AARCH64_SWS_OP_LINEAR        ] = "AARCH64_SWS_OP_LINEAR",
+    [AARCH64_SWS_OP_LINEAR_FMA    ] = "AARCH64_SWS_OP_LINEAR_FMA",
     [AARCH64_SWS_OP_DITHER        ] = "AARCH64_SWS_OP_DITHER",
 };
 
@@ -142,6 +143,7 @@ static const char op_type_names[AARCH64_SWS_OP_TYPE_NB][16] 
= {
     [AARCH64_SWS_OP_MAX           ] = "max",
     [AARCH64_SWS_OP_SCALE         ] = "scale",
     [AARCH64_SWS_OP_LINEAR        ] = "linear",
+    [AARCH64_SWS_OP_LINEAR_FMA    ] = "linear_fma",
     [AARCH64_SWS_OP_DITHER        ] = "dither",
 };
 
@@ -345,7 +347,6 @@ static const ParamField field_shift            = { 
PARAM_FIELD(shift),
 static const ParamField field_move             = { PARAM_FIELD(move),          
   print_u48_name,   print_u48_val,   cmp_u48 };
 static const ParamField field_pack             = { PARAM_FIELD(pack),          
   print_u16_name,   print_u16_val,   cmp_u16 };
 static const ParamField field_linear_mask      = { PARAM_FIELD(linear.mask),   
   print_u40_name,   print_u40_val,   cmp_u40 };
-static const ParamField field_linear_fmla      = { PARAM_FIELD(linear.fmla),   
   print_u8_name,    print_u8_val,    cmp_u8 };
 static const ParamField field_dither_y_offset  = { 
PARAM_FIELD(dither.y_offset),  print_u16_name,   print_u16_val,   cmp_u16 };
 static const ParamField field_dither_size_log2 = { 
PARAM_FIELD(dither.size_log2), print_u8_name,    print_u8_val,    cmp_u8 };
 
@@ -377,6 +378,7 @@ static const ParamField 
*op_fields[AARCH64_SWS_OP_TYPE_NB][MAX_LEVELS] = {
     [AARCH64_SWS_OP_MIN           ] = { &field_op,                             
                     &field_block_size, &field_type, &field_mask },
     [AARCH64_SWS_OP_MAX           ] = { &field_op,                             
                     &field_block_size, &field_type, &field_mask },
     [AARCH64_SWS_OP_SCALE         ] = { &field_op,                             
                     &field_block_size, &field_type, &field_mask },
-    [AARCH64_SWS_OP_LINEAR        ] = { &field_op, &field_linear_mask,     
&field_linear_fmla,      &field_block_size, &field_type, &field_mask },
+    [AARCH64_SWS_OP_LINEAR        ] = { &field_op, &field_linear_mask,         
                     &field_block_size, &field_type, &field_mask },
+    [AARCH64_SWS_OP_LINEAR_FMA    ] = { &field_op, &field_linear_mask,         
                     &field_block_size, &field_type, &field_mask },
     [AARCH64_SWS_OP_DITHER        ] = { &field_op, &field_dither_y_offset, 
&field_dither_size_log2, &field_block_size, &field_type, &field_mask },
 };
diff --git a/libswscale/aarch64/ops_impl.h b/libswscale/aarch64/ops_impl.h
index afad648938..60fc14ee89 100644
--- a/libswscale/aarch64/ops_impl.h
+++ b/libswscale/aarch64/ops_impl.h
@@ -63,6 +63,7 @@ typedef enum SwsAArch64OpType {
     AARCH64_SWS_OP_MAX,
     AARCH64_SWS_OP_SCALE,
     AARCH64_SWS_OP_LINEAR,
+    AARCH64_SWS_OP_LINEAR_FMA,
     AARCH64_SWS_OP_DITHER,
     AARCH64_SWS_OP_TYPE_NB,
 } SwsAArch64OpType;
@@ -85,7 +86,6 @@ typedef uint64_t SwsAArch64LinearOpMask;
 
 typedef struct SwsAArch64LinearOp {
     SwsAArch64LinearOpMask mask;
-    uint8_t fmla;
 } SwsAArch64LinearOp;
 
 typedef struct SwsAArch64DitherOp {
diff --git a/libswscale/aarch64/ops_impl_conv.c 
b/libswscale/aarch64/ops_impl_conv.c
index 6afd69f33e..1279108e98 100644
--- a/libswscale/aarch64/ops_impl_conv.c
+++ b/libswscale/aarch64/ops_impl_conv.c
@@ -214,7 +214,11 @@ static int convert_to_aarch64_impl(SwsContext *ctx, const 
SwsOpList *ops, int n,
     case SWS_OP_MIN:        out->op = AARCH64_SWS_OP_MIN;        break;
     case SWS_OP_MAX:        out->op = AARCH64_SWS_OP_MAX;        break;
     case SWS_OP_SCALE:      out->op = AARCH64_SWS_OP_SCALE;      break;
-    case SWS_OP_LINEAR:     out->op = AARCH64_SWS_OP_LINEAR;     break;
+    case SWS_OP_LINEAR:
+        out->op = (ctx->flags & SWS_BITEXACT)
+                ? AARCH64_SWS_OP_LINEAR
+                : AARCH64_SWS_OP_LINEAR_FMA;
+        break;
     case SWS_OP_DITHER:     out->op = AARCH64_SWS_OP_DITHER;     break;
     case SWS_OP_FILTER_H:
     case SWS_OP_FILTER_V:
@@ -277,6 +281,7 @@ static int convert_to_aarch64_impl(SwsContext *ctx, const 
SwsOpList *ops, int n,
         }
         break;
     case AARCH64_SWS_OP_LINEAR:
+    case AARCH64_SWS_OP_LINEAR_FMA:
         /**
          * The out->linear.mask field packs the 4x5 matrix from SwsLinearOp as
          * 2 bits per element:
@@ -299,7 +304,6 @@ static int convert_to_aarch64_impl(SwsContext *ctx, const 
SwsOpList *ops, int n,
                     LINEAR_MASK_SET(out->linear.mask, i, jj, LINEAR_MASK_X);
             }
         }
-        out->linear.fmla = !(ctx->flags & SWS_BITEXACT);
         break;
     case AARCH64_SWS_OP_DITHER:
         out->mask = 0;
diff --git a/libswscale/tests/sws_ops_aarch64.c 
b/libswscale/tests/sws_ops_aarch64.c
index fb53b2194e..c106677462 100644
--- a/libswscale/tests/sws_ops_aarch64.c
+++ b/libswscale/tests/sws_ops_aarch64.c
@@ -94,12 +94,12 @@ static int collect_ops_compile(SwsContext *ctx, const 
SwsOpList *ops,
         ret = aarch64_collect_op(&params, root);
         if (ret < 0)
             goto end;
-        if (params.op == AARCH64_SWS_OP_LINEAR) {
+        if (params.op == AARCH64_SWS_OP_LINEAR_FMA) {
             /**
              * Generate both sets of linear op functions that do use
              * and do not use fmla (selected by SWS_BITEXACT).
              */
-            params.linear.fmla = !params.linear.fmla;
+            params.op = AARCH64_SWS_OP_LINEAR;
             ret = aarch64_collect_op(&params, root);
             if (ret < 0)
                 goto end;

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

Reply via email to