Deprecate MIPS and MSA support.

- Remove *_msa.cc source files
- Update build files
- Update header references, planar ifdefs for row functions
- Update documentation on supported platforms

Bug: 434383432
Change-Id: I072d6aac4956f0ed668e64614ac8557612171f76

Android.bp

@@ -34,7 +34,6 @@ cc_library {
         "source/compare.cc",
         "source/compare_common.cc",
         "source/compare_gcc.cc",
-        "source/compare_msa.cc",
         "source/compare_neon.cc",
         "source/compare_neon64.cc",
         "source/convert.cc",
@@ -53,13 +52,11 @@ cc_library {
         "source/rotate_argb.cc",
         "source/rotate_common.cc",
         "source/rotate_gcc.cc",
-        "source/rotate_msa.cc",
         "source/rotate_neon.cc",
         "source/rotate_neon64.cc",
         "source/row_any.cc",
         "source/row_common.cc",
         "source/row_gcc.cc",
-        "source/row_msa.cc",
         "source/row_neon.cc",
         "source/row_neon64.cc",
         "source/row_rvv.cc",
@@ -68,7 +65,6 @@ cc_library {
         "source/scale_argb.cc",
         "source/scale_common.cc",
         "source/scale_gcc.cc",
-        "source/scale_msa.cc",
         "source/scale_neon.cc",
         "source/scale_neon64.cc",
         "source/scale_rgb.cc",

Android.mk

@@ -9,7 +9,6 @@ LOCAL_SRC_FILES := \
     source/compare.cc           \
     source/compare_common.cc    \
     source/compare_gcc.cc       \
-    source/compare_msa.cc       \
     source/compare_neon.cc      \
     source/compare_neon64.cc    \
     source/compare_win.cc       \
@@ -26,14 +25,12 @@ LOCAL_SRC_FILES := \
     source/rotate_argb.cc       \
     source/rotate_common.cc     \
     source/rotate_gcc.cc        \
-    source/rotate_msa.cc        \
     source/rotate_neon.cc       \
     source/rotate_neon64.cc     \
     source/rotate_win.cc        \
     source/row_any.cc           \
     source/row_common.cc        \
     source/row_gcc.cc           \
-    source/row_msa.cc           \
     source/row_neon.cc          \
     source/row_neon64.cc        \
     source/row_win.cc           \
@@ -42,7 +39,6 @@ LOCAL_SRC_FILES := \
     source/scale_argb.cc        \
     source/scale_common.cc      \
     source/scale_gcc.cc         \
-    source/scale_msa.cc         \
     source/scale_neon.cc        \
     source/scale_neon64.cc      \
     source/scale_rgb.cc         \

BUILD.gn

@@ -23,7 +23,7 @@ declare_args() {
 config("libyuv_config") {
   include_dirs = [ "include" ]
   if (is_android) {
-    if (target_cpu == "arm" || target_cpu == "x86" || target_cpu == "mipsel") {
+    if (target_cpu == "arm" || target_cpu == "x86") {
       ldflags = [ "-Wl,--dynamic-linker,/system/bin/linker" ]
     } else {
       ldflags = [ "-Wl,--dynamic-linker,/system/bin/linker64" ]
@@ -92,10 +92,6 @@ group("libyuv") {
     deps += [ ":libyuv_sme" ]
   }
 
-  if (libyuv_use_msa) {
-    deps += [ ":libyuv_msa" ]
-  }
-
   if (libyuv_use_lsx) {
     deps += [ ":libyuv_lsx" ]
   }
@@ -127,7 +123,6 @@ static_library("libyuv_internal") {
     "include/libyuv/convert_from_argb.h",
     "include/libyuv/cpu_id.h",
     "include/libyuv/loongson_intrinsics.h",
-    "include/libyuv/macros_msa.h",
     "include/libyuv/mjpeg_decoder.h",
     "include/libyuv/planar_functions.h",
     "include/libyuv/rotate.h",
@@ -255,6 +250,7 @@ if (libyuv_use_sve) {
 
     # The -march arguments below are incompatible with libc++ modules.
     use_libcxx_modules = false
+
     # SVE2 is an Armv9-A feature.
     cflags = [ "-march=armv9-a+i8mm+sve2" ]
   }
@@ -274,27 +270,12 @@ if (libyuv_use_sme) {
 
     # The -march arguments below are incompatible with libc++ modules.
     use_libcxx_modules = false
+
     # SME is an Armv9-A feature.
     cflags = [ "-march=armv9-a+i8mm+sme" ]
   }
 }
 
-if (libyuv_use_msa) {
-  static_library("libyuv_msa") {
-    sources = [
-      # MSA Source Files
-      "source/compare_msa.cc",
-      "source/rotate_msa.cc",
-      "source/row_msa.cc",
-      "source/scale_msa.cc",
-    ]
-
-    deps = [ ":libyuv_internal" ]
-
-    public_configs = [ ":libyuv_config" ]
-  }
-}
-
 if (libyuv_use_lsx) {
   static_library("libyuv_lsx") {
     sources = [

CMakeLists.txt

@@ -23,7 +23,6 @@ set ( ly_common_source_files
   ${ly_src_dir}/compare.cc
   ${ly_src_dir}/compare_common.cc
   ${ly_src_dir}/compare_gcc.cc
-  ${ly_src_dir}/compare_msa.cc
   ${ly_src_dir}/compare_win.cc
   ${ly_src_dir}/convert_argb.cc
   ${ly_src_dir}/convert.cc
@@ -42,14 +41,12 @@ set ( ly_common_source_files
   ${ly_src_dir}/rotate_common.cc
   ${ly_src_dir}/rotate_gcc.cc
   ${ly_src_dir}/rotate_lsx.cc
-  ${ly_src_dir}/rotate_msa.cc
   ${ly_src_dir}/rotate_win.cc
   ${ly_src_dir}/row_any.cc
   ${ly_src_dir}/row_common.cc
   ${ly_src_dir}/row_gcc.cc
   ${ly_src_dir}/row_lasx.cc
   ${ly_src_dir}/row_lsx.cc
-  ${ly_src_dir}/row_msa.cc
   ${ly_src_dir}/row_rvv.cc
   ${ly_src_dir}/row_win.cc
   ${ly_src_dir}/scale_any.cc
@@ -58,7 +55,6 @@ set ( ly_common_source_files
   ${ly_src_dir}/scale_common.cc
   ${ly_src_dir}/scale_gcc.cc
   ${ly_src_dir}/scale_lsx.cc
-  ${ly_src_dir}/scale_msa.cc
   ${ly_src_dir}/scale_rgb.cc
   ${ly_src_dir}/scale_rvv.cc
   ${ly_src_dir}/scale_uv.cc

DEPS

@@ -1532,13 +1532,6 @@ hooks = [
     'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
                '--arch=x86'],
   },
-  {
-    'name': 'sysroot_mips',
-    'pattern': '.',
-    'condition': 'checkout_linux and checkout_mips',
-    'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
-               '--arch=mips'],
-  },
   {
     'name': 'sysroot_x64',
     'pattern': '.',

README.chromium

@@ -1,6 +1,6 @@
 Name: libyuv
 URL: https://chromium.googlesource.com/libyuv/libyuv/
-Version: 1920
+Version: 1921
 License: BSD-3-Clause
 License File: LICENSE
 Shipped: yes

docs/deprecated_builds.md

@@ -157,12 +157,6 @@ ia32
     GYP_DEFINES="OS=android target_arch=ia32 android_full_debug=1" GYP_CROSSCOMPILE=1 ./gyp_libyuv
     ninja -j7 -C out/Debug yuv_unittest_apk
 
-mipsel
-
-    GYP_DEFINES="OS=android target_arch=mipsel" GYP_CROSSCOMPILE=1 ./gyp_libyuv
-    ninja -j7 -C out/Debug yuv_unittest_apk
-    ninja -j7 -C out/Release yuv_unittest_apk
-
 arm32 disassembly:
 
     llvm-objdump -d out/Release/obj/source/libyuv.row_neon.o
@@ -195,16 +189,6 @@ Running test with C code:
     gn gen out/Official "--args=is_debug=false is_official_build=true is_chrome_branded=true"
     ninja -C out/Official
 
-#### Building mips with GN
-
-mipsel
-    gn gen out/Default "--args=is_debug=false target_cpu=\"mipsel\" target_os = \"android\" mips_arch_variant = \"r6\" mips_use_msa = true is_component_build = true is_clang = false"
-    ninja -C out/Default
-
-mips64el
-    gn gen out/Default "--args=is_debug=false target_cpu=\"mips64el\" target_os = \"android\" mips_arch_variant = \"r6\" mips_use_msa = true is_component_build = true is_clang = false"
-    ninja -C out/Default
-
 ### Linux
 
     GYP_DEFINES="target_arch=x64" ./gyp_libyuv

docs/environment_variables.md

@@ -43,10 +43,6 @@ By default the cpu is detected and the most advanced form of SIMD is used.  But
     LIBYUV_DISABLE_SVE2
     LIBYUV_DISABLE_SME
 
-## MIPS CPUs
-
-    LIBYUV_DISABLE_MSA
-
 ## LOONGARCH CPUs
 
     LIBYUV_DISABLE_LSX

docs/getting_started.md

@@ -130,13 +130,6 @@ ia32
     ninja -v -C out/Debug libyuv_unittest
     ninja -v -C out/Release libyuv_unittest
 
-mips
-
-    gn gen out/Release "--args=is_debug=false target_os=\"android\" target_cpu=\"mips64el\" mips_arch_variant=\"r6\" mips_use_msa=true is_component_build=true"
-    gn gen out/Debug "--args=is_debug=true target_os=\"android\" target_cpu=\"mips64el\" mips_arch_variant=\"r6\" mips_use_msa=true is_component_build=true"
-    ninja -v -C out/Debug libyuv_unittest
-    ninja -v -C out/Release libyuv_unittest
-
 arm disassembly:
 
     llvm-objdump -d ./out/Release/obj/libyuv/row_common.o >row_common.txt
@@ -176,13 +169,6 @@ Running test with C code:
     ninja -v -C out/Debug libyuv_unittest
     ninja -v -C out/Release libyuv_unittest
 
-### MIPS Linux
-
-    gn gen out/Release "--args=is_debug=false target_os=\"linux\" target_cpu=\"mips64el\" mips_arch_variant=\"loongson3\" is_component_build=false use_sysroot=false use_gold=false"
-    gn gen out/Debug "--args=is_debug=true target_os=\"linux\" target_cpu=\"mips64el\" mips_arch_variant=\"loongson3\" is_component_build=false use_sysroot=false use_gold=false"
-    ninja -v -C out/Debug libyuv_unittest
-    ninja -v -C out/Release libyuv_unittest
-
 ## Building the Library with make
 
 ### Linux

include/libyuv/compare_row.h

@@ -65,11 +65,6 @@ extern "C" {
 #define HAS_SUMSQUAREERROR_NEON_DOTPROD
 #endif
 
-#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
-#define HAS_HAMMINGDISTANCE_MSA
-#define HAS_SUMSQUAREERROR_MSA
-#endif
-
 uint32_t HammingDistance_C(const uint8_t* src_a,
                            const uint8_t* src_b,
                            int count);
@@ -88,9 +83,6 @@ uint32_t HammingDistance_NEON(const uint8_t* src_a,
 uint32_t HammingDistance_NEON_DotProd(const uint8_t* src_a,
                                       const uint8_t* src_b,
                                       int count);
-uint32_t HammingDistance_MSA(const uint8_t* src_a,
-                             const uint8_t* src_b,
-                             int count);
 uint32_t SumSquareError_C(const uint8_t* src_a,
                           const uint8_t* src_b,
                           int count);
@@ -106,9 +98,6 @@ uint32_t SumSquareError_NEON(const uint8_t* src_a,
 uint32_t SumSquareError_NEON_DotProd(const uint8_t* src_a,
                                      const uint8_t* src_b,
                                      int count);
-uint32_t SumSquareError_MSA(const uint8_t* src_a,
-                            const uint8_t* src_b,
-                            int count);
 
 uint32_t HashDjb2_C(const uint8_t* src, int count, uint32_t seed);
 uint32_t HashDjb2_SSE41(const uint8_t* src, int count, uint32_t seed);

include/libyuv/macros_msa.h

@@ -1,244 +0,0 @@
-/*
- *  Copyright 2016 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_MACROS_MSA_H_
-#define INCLUDE_LIBYUV_MACROS_MSA_H_
-
-#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
-#include <msa.h>
-#include <stdint.h>
-
-#if (__mips_isa_rev >= 6)
-#define LW(psrc)                                       \
-  ({                                                   \
-    const uint8_t* psrc_lw_m = (const uint8_t*)(psrc); \
-    uint32_t val_m;                                    \
-    asm("lw  %[val_m],  %[psrc_lw_m]  \n"              \
-        : [val_m] "=r"(val_m)                          \
-        : [psrc_lw_m] "m"(*psrc_lw_m));                \
-    val_m;                                             \
-  })
-
-#if (__mips == 64)
-#define LD(psrc)                                       \
-  ({                                                   \
-    const uint8_t* psrc_ld_m = (const uint8_t*)(psrc); \
-    uint64_t val_m = 0;                                \
-    asm("ld  %[val_m],  %[psrc_ld_m]  \n"              \
-        : [val_m] "=r"(val_m)                          \
-        : [psrc_ld_m] "m"(*psrc_ld_m));                \
-    val_m;                                             \
-  })
-#else  // !(__mips == 64)
-#define LD(psrc)                                                         \
-  ({                                                                     \
-    const uint8_t* psrc_ld_m = (const uint8_t*)(psrc);                   \
-    uint32_t val0_m, val1_m;                                             \
-    uint64_t val_m = 0;                                                  \
-    val0_m = LW(psrc_ld_m);                                              \
-    val1_m = LW(psrc_ld_m + 4);                                          \
-    val_m = (uint64_t)(val1_m);                             /* NOLINT */ \
-    val_m = (uint64_t)((val_m << 32) & 0xFFFFFFFF00000000); /* NOLINT */ \
-    val_m = (uint64_t)(val_m | (uint64_t)val0_m);           /* NOLINT */ \
-    val_m;                                                               \
-  })
-#endif  // (__mips == 64)
-
-#define SW(val, pdst)                                   \
-  ({                                                    \
-    uint8_t* pdst_sw_m = (uint8_t*)(pdst); /* NOLINT */ \
-    uint32_t val_m = (val);                             \
-    asm("sw  %[val_m],  %[pdst_sw_m]  \n"               \
-        : [pdst_sw_m] "=m"(*pdst_sw_m)                  \
-        : [val_m] "r"(val_m));                          \
-  })
-
-#if (__mips == 64)
-#define SD(val, pdst)                                   \
-  ({                                                    \
-    uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */ \
-    uint64_t val_m = (val);                             \
-    asm("sd  %[val_m],  %[pdst_sd_m]  \n"               \
-        : [pdst_sd_m] "=m"(*pdst_sd_m)                  \
-        : [val_m] "r"(val_m));                          \
-  })
-#else  // !(__mips == 64)
-#define SD(val, pdst)                                        \
-  ({                                                         \
-    uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */      \
-    uint32_t val0_m, val1_m;                                 \
-    val0_m = (uint32_t)((val)&0x00000000FFFFFFFF);           \
-    val1_m = (uint32_t)(((val) >> 32) & 0x00000000FFFFFFFF); \
-    SW(val0_m, pdst_sd_m);                                   \
-    SW(val1_m, pdst_sd_m + 4);                               \
-  })
-#endif  // !(__mips == 64)
-#else   // !(__mips_isa_rev >= 6)
-#define LW(psrc)                                \
-  ({                                            \
-    uint8_t* psrc_lw_m = (uint8_t*)(psrc);      \
-    uint32_t val_lw_m;                          \
-                                                \
-    asm("lwr %[val_lw_m], 0(%[psrc_lw_m]) \n\t" \
-        "lwl %[val_lw_m], 3(%[psrc_lw_m]) \n\t" \
-                                                \
-        : [val_lw_m] "=&r"(val_lw_m)            \
-        : [psrc_lw_m] "r"(psrc_lw_m));          \
-                                                \
-    val_lw_m;                                   \
-  })
-
-#if (__mips == 64)
-#define LD(psrc)                                \
-  ({                                            \
-    uint8_t* psrc_ld_m = (uint8_t*)(psrc);      \
-    uint64_t val_ld_m = 0;                      \
-                                                \
-    asm("ldr %[val_ld_m], 0(%[psrc_ld_m]) \n\t" \
-        "ldl %[val_ld_m], 7(%[psrc_ld_m]) \n\t" \
-                                                \
-        : [val_ld_m] "=&r"(val_ld_m)            \
-        : [psrc_ld_m] "r"(psrc_ld_m));          \
-                                                \
-    val_ld_m;                                   \
-  })
-#else  // !(__mips == 64)
-#define LD(psrc)                                                         \
-  ({                                                                     \
-    const uint8_t* psrc_ld_m = (const uint8_t*)(psrc);                   \
-    uint32_t val0_m, val1_m;                                             \
-    uint64_t val_m = 0;                                                  \
-    val0_m = LW(psrc_ld_m);                                              \
-    val1_m = LW(psrc_ld_m + 4);                                          \
-    val_m = (uint64_t)(val1_m);                             /* NOLINT */ \
-    val_m = (uint64_t)((val_m << 32) & 0xFFFFFFFF00000000); /* NOLINT */ \
-    val_m = (uint64_t)(val_m | (uint64_t)val0_m);           /* NOLINT */ \
-    val_m;                                                               \
-  })
-#endif  // (__mips == 64)
-
-#define SW(val, pdst)                                   \
-  ({                                                    \
-    uint8_t* pdst_sw_m = (uint8_t*)(pdst); /* NOLINT */ \
-    uint32_t val_m = (val);                             \
-    asm("usw  %[val_m],  %[pdst_sw_m]  \n"              \
-        : [pdst_sw_m] "=m"(*pdst_sw_m)                  \
-        : [val_m] "r"(val_m));                          \
-  })
-
-#define SD(val, pdst)                                        \
-  ({                                                         \
-    uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */      \
-    uint32_t val0_m, val1_m;                                 \
-    val0_m = (uint32_t)((val)&0x00000000FFFFFFFF);           \
-    val1_m = (uint32_t)(((val) >> 32) & 0x00000000FFFFFFFF); \
-    SW(val0_m, pdst_sd_m);                                   \
-    SW(val1_m, pdst_sd_m + 4);                               \
-  })
-#endif  // (__mips_isa_rev >= 6)
-
-// TODO(fbarchard): Consider removing __VAR_ARGS versions.
-#define LD_B(RTYPE, psrc) *((RTYPE*)(psrc)) /* NOLINT */
-#define LD_UB(...) LD_B(const v16u8, __VA_ARGS__)
-
-#define LD_H(RTYPE, psrc) *((RTYPE*)(psrc)) /* NOLINT */
-#define LD_UH(...) LD_H(const v8u16, __VA_ARGS__)
-
-#define ST_B(RTYPE, in, pdst) *((RTYPE*)(pdst)) = (in) /* NOLINT */
-#define ST_UB(...) ST_B(v16u8, __VA_ARGS__)
-
-#define ST_H(RTYPE, in, pdst) *((RTYPE*)(pdst)) = (in) /* NOLINT */
-#define ST_UH(...) ST_H(v8u16, __VA_ARGS__)
-
-/* Description : Load two vectors with 16 'byte' sized elements
-   Arguments   : Inputs  - psrc, stride
-                 Outputs - out0, out1
-                 Return Type - as per RTYPE
-   Details     : Load 16 byte elements in 'out0' from (psrc)
-                 Load 16 byte elements in 'out1' from (psrc + stride)
-*/
-#define LD_B2(RTYPE, psrc, stride, out0, out1) \
-  {                                            \
-    out0 = LD_B(RTYPE, (psrc));                \
-    out1 = LD_B(RTYPE, (psrc) + stride);       \
-  }
-#define LD_UB2(...) LD_B2(const v16u8, __VA_ARGS__)
-
-#define LD_B4(RTYPE, psrc, stride, out0, out1, out2, out3) \
-  {                                                        \
-    LD_B2(RTYPE, (psrc), stride, out0, out1);              \
-    LD_B2(RTYPE, (psrc) + 2 * stride, stride, out2, out3); \
-  }
-#define LD_UB4(...) LD_B4(const v16u8, __VA_ARGS__)
-
-/* Description : Store two vectors with stride each having 16 'byte' sized
-                 elements
-   Arguments   : Inputs - in0, in1, pdst, stride
-   Details     : Store 16 byte elements from 'in0' to (pdst)
-                 Store 16 byte elements from 'in1' to (pdst + stride)
-*/
-#define ST_B2(RTYPE, in0, in1, pdst, stride) \
-  {                                          \
-    ST_B(RTYPE, in0, (pdst));                \
-    ST_B(RTYPE, in1, (pdst) + stride);       \
-  }
-#define ST_UB2(...) ST_B2(v16u8, __VA_ARGS__)
-
-#define ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride)   \
-  {                                                      \
-    ST_B2(RTYPE, in0, in1, (pdst), stride);              \
-    ST_B2(RTYPE, in2, in3, (pdst) + 2 * stride, stride); \
-  }
-#define ST_UB4(...) ST_B4(v16u8, __VA_ARGS__)
-
-/* Description : Store vectors of 8 halfword elements with stride
-   Arguments   : Inputs - in0, in1, pdst, stride
-   Details     : Store 8 halfword elements from 'in0' to (pdst)
-                 Store 8 halfword elements from 'in1' to (pdst + stride)
-*/
-#define ST_H2(RTYPE, in0, in1, pdst, stride) \
-  {                                          \
-    ST_H(RTYPE, in0, (pdst));                \
-    ST_H(RTYPE, in1, (pdst) + stride);       \
-  }
-#define ST_UH2(...) ST_H2(v8u16, __VA_ARGS__)
-
-// TODO(fbarchard): Consider using __msa_vshf_b and __msa_ilvr_b directly.
-/* Description : Shuffle byte vector elements as per mask vector
-   Arguments   : Inputs  - in0, in1, in2, in3, mask0, mask1
-                 Outputs - out0, out1
-                 Return Type - as per RTYPE
-   Details     : Byte elements from 'in0' & 'in1' are copied selectively to
-                 'out0' as per control vector 'mask0'
-*/
-#define VSHF_B2(RTYPE, in0, in1, in2, in3, mask0, mask1, out0, out1)  \
-  {                                                                   \
-    out0 = (RTYPE)__msa_vshf_b((v16i8)mask0, (v16i8)in1, (v16i8)in0); \
-    out1 = (RTYPE)__msa_vshf_b((v16i8)mask1, (v16i8)in3, (v16i8)in2); \
-  }
-#define VSHF_B2_UB(...) VSHF_B2(v16u8, __VA_ARGS__)
-
-/* Description : Interleave both left and right half of input vectors
-   Arguments   : Inputs  - in0, in1
-                 Outputs - out0, out1
-                 Return Type - as per RTYPE
-   Details     : Right half of byte elements from 'in0' and 'in1' are
-                 interleaved and written to 'out0'
-*/
-#define ILVRL_B2(RTYPE, in0, in1, out0, out1)           \
-  {                                                     \
-    out0 = (RTYPE)__msa_ilvr_b((v16i8)in0, (v16i8)in1); \
-    out1 = (RTYPE)__msa_ilvl_b((v16i8)in0, (v16i8)in1); \
-  }
-#define ILVRL_B2_UB(...) ILVRL_B2(v16u8, __VA_ARGS__)
-
-#endif /* !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa) */
-
-#endif  // INCLUDE_LIBYUV_MACROS_MSA_H_

include/libyuv/rotate_row.h

@@ -60,11 +60,6 @@ extern "C" {
 #define HAS_TRANSPOSEUVWXH_SME
 #endif
 
-#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
-#define HAS_TRANSPOSEWX16_MSA
-#define HAS_TRANSPOSEUVWX16_MSA
-#endif
-
 #if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
 #define HAS_TRANSPOSEWX16_LSX
 #define HAS_TRANSPOSEUVWX16_LSX
@@ -113,11 +108,6 @@ void TransposeWx8_Fast_SSSE3(const uint8_t* src,
                              uint8_t* dst,
                              int dst_stride,
                              int width);
-void TransposeWx16_MSA(const uint8_t* src,
-                       int src_stride,
-                       uint8_t* dst,
-                       int dst_stride,
-                       int width);
 void TransposeWx16_LSX(const uint8_t* src,
                        int src_stride,
                        uint8_t* dst,
@@ -144,11 +134,6 @@ void TransposeWx8_Fast_Any_SSSE3(const uint8_t* src,
                                  uint8_t* dst,
                                  int dst_stride,
                                  int width);
-void TransposeWx16_Any_MSA(const uint8_t* src,
-                           int src_stride,
-                           uint8_t* dst,
-                           int dst_stride,
-                           int width);
 void TransposeWx16_Any_LSX(const uint8_t* src,
                            int src_stride,
                            uint8_t* dst,
@@ -200,13 +185,6 @@ void TransposeUVWxH_SME(const uint8_t* src,
                         int dst_stride_b,
                         int width,
                         int height);
-void TransposeUVWx16_MSA(const uint8_t* src,
-                         int src_stride,
-                         uint8_t* dst_a,
-                         int dst_stride_a,
-                         uint8_t* dst_b,
-                         int dst_stride_b,
-                         int width);
 void TransposeUVWx16_LSX(const uint8_t* src,
                          int src_stride,
                          uint8_t* dst_a,
@@ -229,13 +207,6 @@ void TransposeUVWx8_Any_NEON(const uint8_t* src,
                              uint8_t* dst_b,
                              int dst_stride_b,
                              int width);
-void TransposeUVWx16_Any_MSA(const uint8_t* src,
-                             int src_stride,
-                             uint8_t* dst_a,
-                             int dst_stride_a,
-                             uint8_t* dst_b,
-                             int dst_stride_b,
-                             int width);
 void TransposeUVWx16_Any_LSX(const uint8_t* src,
                              int src_stride,
                              uint8_t* dst_a,

include/libyuv/scale_row.h

@@ -136,19 +136,6 @@ extern "C" {
 #define HAS_SCALEUVROWDOWN2_SME
 #endif
 
-#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
-#define HAS_SCALEADDROW_MSA
-#define HAS_SCALEARGBCOLS_MSA
-#define HAS_SCALEARGBFILTERCOLS_MSA
-#define HAS_SCALEARGBROWDOWN2_MSA
-#define HAS_SCALEARGBROWDOWNEVEN_MSA
-#define HAS_SCALEFILTERCOLS_MSA
-#define HAS_SCALEROWDOWN2_MSA
-#define HAS_SCALEROWDOWN34_MSA
-#define HAS_SCALEROWDOWN38_MSA
-#define HAS_SCALEROWDOWN4_MSA
-#endif
-
 #if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
 #define HAS_SCALEARGBROWDOWN2_LSX
 #define HAS_SCALEARGBROWDOWNEVEN_LSX
@@ -269,17 +256,12 @@ enum FilterMode ScaleFilterReduce(int src_width,
 // Divide num by div and return as 16.16 fixed point result.
 int FixedDiv_C(int num, int div);
 int FixedDiv_X86(int num, int div);
-int FixedDiv_MIPS(int num, int div);
 // Divide num - 1 by div - 1 and return as 16.16 fixed point result.
 int FixedDiv1_C(int num, int div);
 int FixedDiv1_X86(int num, int div);
-int FixedDiv1_MIPS(int num, int div);
 #ifdef HAS_FIXEDDIV_X86
 #define FixedDiv FixedDiv_X86
 #define FixedDiv1 FixedDiv1_X86
-#elif defined HAS_FIXEDDIV_MIPS
-#define FixedDiv FixedDiv_MIPS
-#define FixedDiv1 FixedDiv1_MIPS
 #else
 #define FixedDiv FixedDiv_C
 #define FixedDiv1 FixedDiv1_C
@@ -935,26 +917,6 @@ void ScaleARGBCols_Any_NEON(uint8_t* dst_ptr,
                             int dst_width,
                             int x,
                             int dx);
-void ScaleARGBFilterCols_MSA(uint8_t* dst_argb,
-                             const uint8_t* src_argb,
-                             int dst_width,
-                             int x,
-                             int dx);
-void ScaleARGBCols_MSA(uint8_t* dst_argb,
-                       const uint8_t* src_argb,
-                       int dst_width,
-                       int x,
-                       int dx);
-void ScaleARGBFilterCols_Any_MSA(uint8_t* dst_ptr,
-                                 const uint8_t* src_ptr,
-                                 int dst_width,
-                                 int x,
-                                 int dx);
-void ScaleARGBCols_Any_MSA(uint8_t* dst_ptr,
-                           const uint8_t* src_ptr,
-                           int dst_width,
-                           int x,
-                           int dx);
 void ScaleARGBFilterCols_RVV(uint8_t* dst_argb,
                              const uint8_t* src_argb,
                              int dst_width,
@@ -1010,18 +972,6 @@ void ScaleARGBRowDown2Box_RVV(const uint8_t* src_argb,
                               ptrdiff_t src_stride,
                               uint8_t* dst_argb,
                               int dst_width);
-void ScaleARGBRowDown2_MSA(const uint8_t* src_argb,
-                           ptrdiff_t src_stride,
-                           uint8_t* dst_argb,
-                           int dst_width);
-void ScaleARGBRowDown2Linear_MSA(const uint8_t* src_argb,
-                                 ptrdiff_t src_stride,
-                                 uint8_t* dst_argb,
-                                 int dst_width);
-void ScaleARGBRowDown2Box_MSA(const uint8_t* src_argb,
-                              ptrdiff_t src_stride,
-                              uint8_t* dst_argb,
-                              int dst_width);
 void ScaleARGBRowDown2_LSX(const uint8_t* src_argb,
                            ptrdiff_t src_stride,
                            uint8_t* dst_argb,
@@ -1058,18 +1008,6 @@ void ScaleARGBRowDown2Box_Any_NEON(const uint8_t* src_ptr,
                                    ptrdiff_t src_stride,
                                    uint8_t* dst_ptr,
                                    int dst_width);
-void ScaleARGBRowDown2_Any_MSA(const uint8_t* src_ptr,
-                               ptrdiff_t src_stride,
-                               uint8_t* dst_ptr,
-                               int dst_width);
-void ScaleARGBRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
-                                     ptrdiff_t src_stride,
-                                     uint8_t* dst_ptr,
-                                     int dst_width);
-void ScaleARGBRowDown2Box_Any_MSA(const uint8_t* src_ptr,
-                                  ptrdiff_t src_stride,
-                                  uint8_t* dst_ptr,
-                                  int dst_width);
 void ScaleARGBRowDown2_Any_LSX(const uint8_t* src_ptr,
                                ptrdiff_t src_stride,
                                uint8_t* dst_ptr,
@@ -1102,16 +1040,6 @@ void ScaleARGBRowDownEvenBox_NEON(const uint8_t* src_argb,
                                   int src_stepx,
                                   uint8_t* dst_argb,
                                   int dst_width);
-void ScaleARGBRowDownEven_MSA(const uint8_t* src_argb,
-                              ptrdiff_t src_stride,
-                              int32_t src_stepx,
-                              uint8_t* dst_argb,
-                              int dst_width);
-void ScaleARGBRowDownEvenBox_MSA(const uint8_t* src_argb,
-                                 ptrdiff_t src_stride,
-                                 int src_stepx,
-                                 uint8_t* dst_argb,
-                                 int dst_width);
 void ScaleARGBRowDownEven_LSX(const uint8_t* src_argb,
                               ptrdiff_t src_stride,
                               int32_t src_stepx,
@@ -1152,16 +1080,6 @@ void ScaleARGBRowDownEvenBox_Any_NEON(const uint8_t* src_ptr,
                                       int src_stepx,
                                       uint8_t* dst_ptr,
                                       int dst_width);
-void ScaleARGBRowDownEven_Any_MSA(const uint8_t* src_ptr,
-                                  ptrdiff_t src_stride,
-                                  int32_t src_stepx,
-                                  uint8_t* dst_ptr,
-                                  int dst_width);
-void ScaleARGBRowDownEvenBox_Any_MSA(const uint8_t* src_ptr,
-                                     ptrdiff_t src_stride,
-                                     int src_stepx,
-                                     uint8_t* dst_ptr,
-                                     int dst_width);
 void ScaleARGBRowDownEven_Any_LSX(const uint8_t* src_ptr,
                                   ptrdiff_t src_stride,
                                   int32_t src_stepx,
@@ -1214,18 +1132,6 @@ void ScaleUVRowDown2Box_SME(const uint8_t* src_ptr,
                             ptrdiff_t src_stride,
                             uint8_t* dst,
                             int dst_width);
-void ScaleUVRowDown2_MSA(const uint8_t* src_ptr,
-                         ptrdiff_t src_stride,
-                         uint8_t* dst_uv,
-                         int dst_width);
-void ScaleUVRowDown2Linear_MSA(const uint8_t* src_ptr,
-                               ptrdiff_t src_stride,
-                               uint8_t* dst_uv,
-                               int dst_width);
-void ScaleUVRowDown2Box_MSA(const uint8_t* src_ptr,
-                            ptrdiff_t src_stride,
-                            uint8_t* dst_uv,
-                            int dst_width);
 void ScaleUVRowDown2_RVV(const uint8_t* src_ptr,
                          ptrdiff_t src_stride,
                          uint8_t* dst_uv,
@@ -1266,18 +1172,6 @@ void ScaleUVRowDown2Box_Any_NEON(const uint8_t* src_ptr,
                                  ptrdiff_t src_stride,
                                  uint8_t* dst_ptr,
                                  int dst_width);
-void ScaleUVRowDown2_Any_MSA(const uint8_t* src_ptr,
-                             ptrdiff_t src_stride,
-                             uint8_t* dst_ptr,
-                             int dst_width);
-void ScaleUVRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
-                                   ptrdiff_t src_stride,
-                                   uint8_t* dst_ptr,
-                                   int dst_width);
-void ScaleUVRowDown2Box_Any_MSA(const uint8_t* src_ptr,
-                                ptrdiff_t src_stride,
-                                uint8_t* dst_ptr,
-                                int dst_width);
 void ScaleUVRowDownEven_SSSE3(const uint8_t* src_ptr,
                               ptrdiff_t src_stride,
                               int src_stepx,
@@ -1308,16 +1202,6 @@ void ScaleUVRowDownEven_RVV(const uint8_t* src_ptr,
                             int32_t src_stepx,
                             uint8_t* dst_uv,
                             int dst_width);
-void ScaleUVRowDownEven_MSA(const uint8_t* src_ptr,
-                            ptrdiff_t src_stride,
-                            int32_t src_stepx,
-                            uint8_t* dst_uv,
-                            int dst_width);
-void ScaleUVRowDownEvenBox_MSA(const uint8_t* src_ptr,
-                               ptrdiff_t src_stride,
-                               int src_stepx,
-                               uint8_t* dst_uv,
-                               int dst_width);
 void ScaleUVRowDownEven_Any_SSSE3(const uint8_t* src_ptr,
                                   ptrdiff_t src_stride,
                                   int src_stepx,
@@ -1338,16 +1222,6 @@ void ScaleUVRowDownEvenBox_Any_NEON(const uint8_t* src_ptr,
                                     int src_stepx,
                                     uint8_t* dst_ptr,
                                     int dst_width);
-void ScaleUVRowDownEven_Any_MSA(const uint8_t* src_ptr,
-                                ptrdiff_t src_stride,
-                                int32_t src_stepx,
-                                uint8_t* dst_ptr,
-                                int dst_width);
-void ScaleUVRowDownEvenBox_Any_MSA(const uint8_t* src_ptr,
-                                   ptrdiff_t src_stride,
-                                   int src_stepx,
-                                   uint8_t* dst_ptr,
-                                   int dst_width);
 
 void ScaleUVRowUp2_Linear_SSSE3(const uint8_t* src_ptr,
                                 uint8_t* dst_ptr,
@@ -1664,110 +1538,6 @@ void ScaleFilterCols_Any_NEON(uint8_t* dst_ptr,
                               int x,
                               int dx);
 
-void ScaleRowDown2_MSA(const uint8_t* src_ptr,
-                       ptrdiff_t src_stride,
-                       uint8_t* dst,
-                       int dst_width);
-void ScaleRowDown2Linear_MSA(const uint8_t* src_ptr,
-                             ptrdiff_t src_stride,
-                             uint8_t* dst,
-                             int dst_width);
-void ScaleRowDown2Box_MSA(const uint8_t* src_ptr,
-                          ptrdiff_t src_stride,
-                          uint8_t* dst,
-                          int dst_width);
-void ScaleRowDown4_MSA(const uint8_t* src_ptr,
-                       ptrdiff_t src_stride,
-                       uint8_t* dst,
-                       int dst_width);
-void ScaleRowDown4Box_MSA(const uint8_t* src_ptr,
-                          ptrdiff_t src_stride,
-                          uint8_t* dst,
-                          int dst_width);
-void ScaleRowDown38_MSA(const uint8_t* src_ptr,
-                        ptrdiff_t src_stride,
-                        uint8_t* dst,
-                        int dst_width);
-void ScaleRowDown38_2_Box_MSA(const uint8_t* src_ptr,
-                              ptrdiff_t src_stride,
-                              uint8_t* dst_ptr,
-                              int dst_width);
-void ScaleRowDown38_3_Box_MSA(const uint8_t* src_ptr,
-                              ptrdiff_t src_stride,
-                              uint8_t* dst_ptr,
-                              int dst_width);
-void ScaleAddRow_MSA(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width);
-void ScaleFilterCols_MSA(uint8_t* dst_ptr,
-                         const uint8_t* src_ptr,
-                         int dst_width,
-                         int x,
-                         int dx);
-void ScaleRowDown34_MSA(const uint8_t* src_ptr,
-                        ptrdiff_t src_stride,
-                        uint8_t* dst,
-                        int dst_width);
-void ScaleRowDown34_0_Box_MSA(const uint8_t* src_ptr,
-                              ptrdiff_t src_stride,
-                              uint8_t* d,
-                              int dst_width);
-void ScaleRowDown34_1_Box_MSA(const uint8_t* src_ptr,
-                              ptrdiff_t src_stride,
-                              uint8_t* d,
-                              int dst_width);
-
-void ScaleRowDown2_Any_MSA(const uint8_t* src_ptr,
-                           ptrdiff_t src_stride,
-                           uint8_t* dst_ptr,
-                           int dst_width);
-void ScaleRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
-                                 ptrdiff_t src_stride,
-                                 uint8_t* dst_ptr,
-                                 int dst_width);
-void ScaleRowDown2Box_Any_MSA(const uint8_t* src_ptr,
-                              ptrdiff_t src_stride,
-                              uint8_t* dst_ptr,
-                              int dst_width);
-void ScaleRowDown4_Any_MSA(const uint8_t* src_ptr,
-                           ptrdiff_t src_stride,
-                           uint8_t* dst_ptr,
-                           int dst_width);
-void ScaleRowDown4Box_Any_MSA(const uint8_t* src_ptr,
-                              ptrdiff_t src_stride,
-                              uint8_t* dst_ptr,
-                              int dst_width);
-void ScaleRowDown38_Any_MSA(const uint8_t* src_ptr,
-                            ptrdiff_t src_stride,
-                            uint8_t* dst_ptr,
-                            int dst_width);
-void ScaleRowDown38_2_Box_Any_MSA(const uint8_t* src_ptr,
-                                  ptrdiff_t src_stride,
-                                  uint8_t* dst_ptr,
-                                  int dst_width);
-void ScaleRowDown38_3_Box_Any_MSA(const uint8_t* src_ptr,
-                                  ptrdiff_t src_stride,
-                                  uint8_t* dst_ptr,
-                                  int dst_width);
-void ScaleAddRow_Any_MSA(const uint8_t* src_ptr,
-                         uint16_t* dst_ptr,
-                         int src_width);
-void ScaleFilterCols_Any_MSA(uint8_t* dst_ptr,
-                             const uint8_t* src_ptr,
-                             int dst_width,
-                             int x,
-                             int dx);
-void ScaleRowDown34_Any_MSA(const uint8_t* src_ptr,
-                            ptrdiff_t src_stride,
-                            uint8_t* dst_ptr,
-                            int dst_width);
-void ScaleRowDown34_0_Box_Any_MSA(const uint8_t* src_ptr,
-                                  ptrdiff_t src_stride,
-                                  uint8_t* dst_ptr,
-                                  int dst_width);
-void ScaleRowDown34_1_Box_Any_MSA(const uint8_t* src_ptr,
-                                  ptrdiff_t src_stride,
-                                  uint8_t* dst_ptr,
-                                  int dst_width);
-
 void ScaleRowDown2_LSX(const uint8_t* src_ptr,
                        ptrdiff_t src_stride,
                        uint8_t* dst,

libyuv.gyp

@@ -26,20 +26,13 @@
     'clang%': 0,
     # Link-Time Optimizations.
     'use_lto%': 0,
-    'mips_msa%': 0,  # Default to msa off.
     'build_neon': 0,
-    'build_msa': 0,
     'conditions': [
        ['(target_arch == "armv7" or target_arch == "armv7s" or \
        (target_arch == "arm" and arm_version >= 7) or target_arch == "arm64")\
        and (arm_neon == 1 or arm_neon_optional == 1)', {
          'build_neon': 1,
        }],
-       ['(target_arch == "mipsel" or target_arch == "mips64el")\
-       and (mips_msa == 1)',
-       {
-         'build_msa': 1,
-       }],
     ],
   },
 
@@ -87,11 +80,6 @@
             }],
           ],
         }],
-        ['build_msa != 0', {
-          'defines': [
-            'LIBYUV_MSA',
-          ],
-        }],
         ['OS != "ios" and libyuv_disable_jpeg != 1', {
           'defines': [
             'HAVE_JPEG'

libyuv.gypi

@@ -21,7 +21,6 @@
       'include/libyuv/cpu_id.h',
       'include/libyuv/cpu_support.h',
       'include/libyuv/loongson_intrinsics.h',
-      'include/libyuv/macros_msa.h',
       'include/libyuv/mjpeg_decoder.h',
       'include/libyuv/planar_functions.h',
       'include/libyuv/rotate.h',
@@ -40,7 +39,6 @@
       'source/compare.cc',
       'source/compare_common.cc',
       'source/compare_gcc.cc',
-      'source/compare_msa.cc',
       'source/compare_neon.cc',
       'source/compare_neon64.cc',
       'source/compare_win.cc',
@@ -61,14 +59,12 @@
       'source/rotate_common.cc',
       'source/rotate_gcc.cc',
       'source/rotate_lsx.cc',
-      'source/rotate_msa.cc',
       'source/rotate_neon.cc',
       'source/rotate_neon64.cc',
       'source/rotate_win.cc',
       'source/row_any.cc',
       'source/row_common.cc',
       'source/row_gcc.cc',
-      'source/row_msa.cc',
       'source/row_lasx.cc',
       'source/row_lsx.cc',
       'source/row_neon.cc',
@@ -80,7 +76,6 @@
       'source/scale_common.cc',
       'source/scale_gcc.cc',
       'source/scale_lsx.cc',
-      'source/scale_msa.cc',
       'source/scale_neon.cc',
       'source/scale_neon64.cc',
       'source/scale_rgb.cc',

linux.mk

@@ -13,7 +13,6 @@ LOCAL_OBJ_FILES := \
 	source/compare.o           \
 	source/compare_common.o    \
 	source/compare_gcc.o       \
-	source/compare_msa.o       \
 	source/compare_neon.o      \
 	source/compare_neon64.o    \
 	source/compare_win.o       \
@@ -34,7 +33,6 @@ LOCAL_OBJ_FILES := \
 	source/rotate_common.o     \
 	source/rotate_gcc.o        \
 	source/rotate_lsx.o        \
-	source/rotate_msa.o        \
 	source/rotate_neon.o       \
 	source/rotate_neon64.o     \
 	source/rotate_win.o        \
@@ -43,7 +41,6 @@ LOCAL_OBJ_FILES := \
 	source/row_gcc.o           \
 	source/row_lasx.o          \
 	source/row_lsx.o           \
-	source/row_msa.o           \
 	source/row_neon.o          \
 	source/row_neon64.o        \
 	source/row_rvv.o           \
@@ -54,7 +51,6 @@ LOCAL_OBJ_FILES := \
 	source/scale_common.o      \
 	source/scale_gcc.o         \
 	source/scale_lsx.o         \
-	source/scale_msa.o         \
 	source/scale_neon.o        \
 	source/scale_neon64.o      \
 	source/scale_rgb.o         \

source/compare.cc

@@ -159,11 +159,6 @@ uint64_t ComputeHammingDistance(const uint8_t* src_a,
     HammingDistance = HammingDistance_AVX2;
   }
 #endif
-#if defined(HAS_HAMMINGDISTANCE_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    HammingDistance = HammingDistance_MSA;
-  }
-#endif
 
 #ifdef _OPENMP
 #pragma omp parallel for reduction(+ : diff)
@@ -221,11 +216,6 @@ uint64_t ComputeSumSquareError(const uint8_t* src_a,
     SumSquareError = SumSquareError_AVX2;
   }
 #endif
-#if defined(HAS_SUMSQUAREERROR_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    SumSquareError = SumSquareError_MSA;
-  }
-#endif
 #ifdef _OPENMP
 #pragma omp parallel for reduction(+ : sse)
 #endif

source/convert.cc

@@ -748,14 +748,6 @@ int I010ToNV12(const uint16_t* src_y,
     MergeUVRow = MergeUVRow_SME;
   }
 #endif
-#if defined(HAS_MERGEUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MergeUVRow = MergeUVRow_Any_MSA;
-    if (IS_ALIGNED(halfwidth, 16)) {
-      MergeUVRow = MergeUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MERGEUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MergeUVRow = MergeUVRow_Any_LSX;
@@ -1196,14 +1188,6 @@ int I422ToNV21(const uint8_t* src_y,
     MergeUVRow = MergeUVRow_SME;
   }
 #endif
-#if defined(HAS_MERGEUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MergeUVRow = MergeUVRow_Any_MSA;
-    if (IS_ALIGNED(halfwidth, 16)) {
-      MergeUVRow = MergeUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MERGEUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MergeUVRow = MergeUVRow_Any_LSX;
@@ -1246,14 +1230,6 @@ int I422ToNV21(const uint8_t* src_y,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;
@@ -1724,16 +1700,6 @@ int YUY2ToI420(const uint8_t* src_yuy2,
     }
   }
 #endif
-#if defined(HAS_YUY2TOYROW_MSA) && defined(HAS_YUY2TOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    YUY2ToYRow = YUY2ToYRow_Any_MSA;
-    YUY2ToUVRow = YUY2ToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      YUY2ToYRow = YUY2ToYRow_MSA;
-      YUY2ToUVRow = YUY2ToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_YUY2TOYROW_LSX) && defined(HAS_YUY2TOUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     YUY2ToYRow = YUY2ToYRow_Any_LSX;
@@ -1825,16 +1791,6 @@ int UYVYToI420(const uint8_t* src_uyvy,
     }
   }
 #endif
-#if defined(HAS_UYVYTOYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    UYVYToYRow = UYVYToYRow_Any_MSA;
-    UYVYToUVRow = UYVYToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      UYVYToYRow = UYVYToYRow_MSA;
-      UYVYToUVRow = UYVYToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_UYVYTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     UYVYToYRow = UYVYToYRow_Any_LSX;
@@ -2143,18 +2099,6 @@ int ARGBToI420(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    ARGBToUVRow = ARGBToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVRow = ARGBToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -2337,18 +2281,6 @@ int ARGBToI420Alpha(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    ARGBToUVRow = ARGBToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVRow = ARGBToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -2385,12 +2317,6 @@ int ARGBToI420Alpha(const uint8_t* src_argb,
                                                 : ARGBExtractAlphaRow_Any_NEON;
   }
 #endif
-#if defined(HAS_ARGBEXTRACTALPHAROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_MSA
-                                                : ARGBExtractAlphaRow_Any_MSA;
-  }
-#endif
 #if defined(HAS_ARGBEXTRACTALPHAROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_LSX
@@ -2532,18 +2458,6 @@ int BGRAToI420(const uint8_t* src_bgra,
     }
   }
 #endif
-#if defined(HAS_BGRATOYROW_MSA) && defined(HAS_BGRATOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    BGRAToYRow = BGRAToYRow_Any_MSA;
-    BGRAToUVRow = BGRAToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      BGRAToYRow = BGRAToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      BGRAToUVRow = BGRAToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_BGRATOYROW_LSX) && defined(HAS_BGRATOUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     BGRAToYRow = BGRAToYRow_Any_LSX;
@@ -2691,16 +2605,6 @@ int ABGRToI420(const uint8_t* src_abgr,
     }
   }
 #endif
-#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ABGRToYRow = ABGRToYRow_Any_MSA;
-    ABGRToUVRow = ABGRToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ABGRToYRow = ABGRToYRow_MSA;
-      ABGRToUVRow = ABGRToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ABGRTOYROW_LSX) && defined(HAS_ABGRTOUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ABGRToYRow = ABGRToYRow_Any_LSX;
@@ -2832,16 +2736,6 @@ int RGBAToI420(const uint8_t* src_rgba,
     }
   }
 #endif
-#if defined(HAS_RGBATOYROW_MSA) && defined(HAS_RGBATOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RGBAToYRow = RGBAToYRow_Any_MSA;
-    RGBAToUVRow = RGBAToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RGBAToYRow = RGBAToYRow_MSA;
-      RGBAToUVRow = RGBAToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RGBATOYROW_LSX) && defined(HAS_RGBATOUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RGBAToYRow = RGBAToYRow_Any_LSX;
@@ -2883,8 +2777,8 @@ int RGBAToI420(const uint8_t* src_rgba,
 }
 
 // Enabled if 1 pass is available
-#if (defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_MSA) || \
+#if (defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_LSX) || \
-     defined(HAS_RGB24TOYROW_LSX) || defined(HAS_RGB24TOYROW_RVV))
+     defined(HAS_RGB24TOYROW_RVV))
 #define HAS_RGB24TOYROW
 #endif
 
@@ -2939,16 +2833,6 @@ int RGB24ToI420(const uint8_t* src_rgb24,
     }
   }
 #endif
-#if defined(HAS_RGB24TOYROW_MSA) && defined(HAS_RGB24TOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RGB24ToUVRow = RGB24ToUVRow_Any_MSA;
-    RGB24ToYRow = RGB24ToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RGB24ToYRow = RGB24ToYRow_MSA;
-      RGB24ToUVRow = RGB24ToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RGB24TOYROW_LSX) && defined(HAS_RGB24TOUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RGB24ToUVRow = RGB24ToUVRow_Any_LSX;
@@ -3065,8 +2949,7 @@ int RGB24ToI420(const uint8_t* src_rgb24,
 #undef HAS_RGB24TOYROW
 
 // Enabled if 1 pass is available
-#if defined(HAS_RGB24TOYJROW_NEON) || defined(HAS_RGB24TOYJROW_MSA) || \
+#if defined(HAS_RGB24TOYJROW_NEON) || defined(HAS_RGB24TOYJROW_RVV)
-    defined(HAS_RGB24TOYJROW_RVV)
 #define HAS_RGB24TOYJROW
 #endif
 
@@ -3121,16 +3004,6 @@ int RGB24ToJ420(const uint8_t* src_rgb24,
     }
   }
 #endif
-#if defined(HAS_RGB24TOYJROW_MSA) && defined(HAS_RGB24TOUVJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RGB24ToUVJRow = RGB24ToUVJRow_Any_MSA;
-    RGB24ToYJRow = RGB24ToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RGB24ToYJRow = RGB24ToYJRow_MSA;
-      RGB24ToUVJRow = RGB24ToUVJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RGB24TOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RGB24ToYJRow = RGB24ToYJRow_Any_LSX;
@@ -3243,8 +3116,8 @@ int RGB24ToJ420(const uint8_t* src_rgb24,
 #undef HAS_RGB24TOYJROW
 
 // Enabled if 1 pass is available
-#if (defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_MSA) || \
+#if (defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_LSX) || \
-     defined(HAS_RAWTOYROW_LSX) || defined(HAS_RAWTOYROW_RVV))
+     defined(HAS_RAWTOYROW_RVV))
 #define HAS_RAWTOYROW
 #endif
 
@@ -3298,16 +3171,6 @@ int RAWToI420(const uint8_t* src_raw,
     }
   }
 #endif
-#if defined(HAS_RAWTOYROW_MSA) && defined(HAS_RAWTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RAWToUVRow = RAWToUVRow_Any_MSA;
-    RAWToYRow = RAWToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RAWToYRow = RAWToYRow_MSA;
-      RAWToUVRow = RAWToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RAWTOYROW_LSX) && defined(HAS_RAWTOUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RAWToUVRow = RAWToUVRow_Any_LSX;
@@ -3432,8 +3295,7 @@ int RAWToI420(const uint8_t* src_raw,
 #undef HAS_RAWTOYROW
 
 // Enabled if 1 pass is available
-#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_MSA) || \
+#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_RVV)
-    defined(HAS_RAWTOYJROW_RVV)
 #define HAS_RAWTOYJROW
 #endif
 
@@ -3488,16 +3350,6 @@ int RAWToJ420(const uint8_t* src_raw,
     }
   }
 #endif
-#if defined(HAS_RAWTOYJROW_MSA) && defined(HAS_RAWTOUVJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RAWToUVJRow = RAWToUVJRow_Any_MSA;
-    RAWToYJRow = RAWToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RAWToYJRow = RAWToYJRow_MSA;
-      RAWToUVJRow = RAWToUVJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RAWTOYJROW_LSX) && defined(HAS_RAWTOUVJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RAWToUVJRow = RAWToUVJRow_Any_LSX;
@@ -3683,14 +3535,6 @@ int RAWToI444(const uint8_t* src_raw,
     }
   }
 #endif
-#if defined(HAS_ARGBTOUV444ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToUV444Row = ARGBToUV444Row_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToUV444Row = ARGBToUV444Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOUV444ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToUV444Row = ARGBToUV444Row_Any_LSX;
@@ -3739,14 +3583,6 @@ int RAWToI444(const uint8_t* src_raw,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -3798,14 +3634,6 @@ int RAWToI444(const uint8_t* src_raw,
     RAWToARGBRow = RAWToARGBRow_SVE2;
   }
 #endif
-#if defined(HAS_RAWTOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RAWToARGBRow = RAWToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RAWToARGBRow = RAWToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RAWTOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RAWToARGBRow = RAWToARGBRow_Any_LSX;
@@ -3910,14 +3738,6 @@ int RAWToJ444(const uint8_t* src_raw,
     }
   }
 #endif
-#if defined(HAS_ARGBTOUVJ444ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToUVJ444Row = ARGBToUVJ444Row_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToUVJ444Row = ARGBToUVJ444Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOUVJ444ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToUVJ444Row = ARGBToUVJ444Row_Any_LSX;
@@ -3966,14 +3786,6 @@ int RAWToJ444(const uint8_t* src_raw,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYJRow = ARGBToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYJRow = ARGBToYJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYJRow = ARGBToYJRow_Any_LSX;
@@ -4025,14 +3837,6 @@ int RAWToJ444(const uint8_t* src_raw,
     RAWToARGBRow = RAWToARGBRow_SVE2;
   }
 #endif
-#if defined(HAS_RAWTOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RAWToARGBRow = RAWToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RAWToARGBRow = RAWToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RAWTOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RAWToARGBRow = RAWToARGBRow_Any_LSX;
@@ -4089,8 +3893,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
                  int width,
                  int height) {
   int y;
-#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
-     defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+     defined(HAS_RGB565TOYROW_LASX))
   void (*RGB565ToUVRow)(const uint8_t* src_rgb565, int src_stride_rgb565,
                         uint8_t* dst_u, uint8_t* dst_v, int width) =
       RGB565ToUVRow_C;
@@ -4134,16 +3938,6 @@ int RGB565ToI420(const uint8_t* src_rgb565,
   }
 #endif
 // MSA version does direct RGB565 to YUV.
-#if defined(HAS_RGB565TOYROW_MSA) && defined(HAS_RGB565TOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RGB565ToUVRow = RGB565ToUVRow_Any_MSA;
-    RGB565ToYRow = RGB565ToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RGB565ToYRow = RGB565ToYRow_MSA;
-      RGB565ToUVRow = RGB565ToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RGB565TOYROW_LSX) && defined(HAS_RGB565TOUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RGB565ToUVRow = RGB565ToUVRow_Any_LSX;
@@ -4214,8 +4008,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
   }
 #endif
   {
-#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
-      defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+      defined(HAS_RGB565TOYROW_LASX))
     // Allocate 2 rows of ARGB.
     const int row_size = (width * 4 + 31) & ~31;
     align_buffer_64(row, row_size * 2);
@@ -4223,8 +4017,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
       return 1;
 #endif
     for (y = 0; y < height - 1; y += 2) {
-#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
-     defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+     defined(HAS_RGB565TOYROW_LASX))
       RGB565ToUVRow(src_rgb565, src_stride_rgb565, dst_u, dst_v, width);
       RGB565ToYRow(src_rgb565, dst_y, width);
       RGB565ToYRow(src_rgb565 + src_stride_rgb565, dst_y + dst_stride_y, width);
@@ -4241,8 +4035,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
       dst_v += dst_stride_v;
     }
     if (height & 1) {
-#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
-     defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+     defined(HAS_RGB565TOYROW_LASX))
       RGB565ToUVRow(src_rgb565, 0, dst_u, dst_v, width);
       RGB565ToYRow(src_rgb565, dst_y, width);
 #else
@@ -4251,8 +4045,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
       ARGBToYRow(row, dst_y, width);
 #endif
     }
-#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
-      defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+      defined(HAS_RGB565TOYROW_LASX))
     free_aligned_buffer_64(row);
 #endif
   }
@@ -4272,8 +4066,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
                    int width,
                    int height) {
   int y;
-#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
-     defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+     defined(HAS_ARGB1555TOYROW_LASX))
   void (*ARGB1555ToUVRow)(const uint8_t* src_argb1555, int src_stride_argb1555,
                           uint8_t* dst_u, uint8_t* dst_v, int width) =
       ARGB1555ToUVRow_C;
@@ -4318,16 +4112,6 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
 #endif
 
 // MSA version does direct ARGB1555 to YUV.
-#if defined(HAS_ARGB1555TOYROW_MSA) && defined(HAS_ARGB1555TOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGB1555ToUVRow = ARGB1555ToUVRow_Any_MSA;
-    ARGB1555ToYRow = ARGB1555ToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGB1555ToYRow = ARGB1555ToYRow_MSA;
-      ARGB1555ToUVRow = ARGB1555ToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGB1555TOYROW_LSX) && defined(HAS_ARGB1555TOUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGB1555ToUVRow = ARGB1555ToUVRow_Any_LSX;
@@ -4399,8 +4183,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
   }
 #endif
   {
-#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
-      defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+      defined(HAS_ARGB1555TOYROW_LASX))
     // Allocate 2 rows of ARGB.
     const int row_size = (width * 4 + 31) & ~31;
     align_buffer_64(row, row_size * 2);
@@ -4409,8 +4193,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
 #endif
 
     for (y = 0; y < height - 1; y += 2) {
-#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
-     defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+     defined(HAS_ARGB1555TOYROW_LASX))
       ARGB1555ToUVRow(src_argb1555, src_stride_argb1555, dst_u, dst_v, width);
       ARGB1555ToYRow(src_argb1555, dst_y, width);
       ARGB1555ToYRow(src_argb1555 + src_stride_argb1555, dst_y + dst_stride_y,
@@ -4429,8 +4213,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
       dst_v += dst_stride_v;
     }
     if (height & 1) {
-#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
-     defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+     defined(HAS_ARGB1555TOYROW_LASX))
       ARGB1555ToUVRow(src_argb1555, 0, dst_u, dst_v, width);
       ARGB1555ToYRow(src_argb1555, dst_y, width);
 #else
@@ -4439,8 +4223,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
       ARGBToYRow(row, dst_y, width);
 #endif
     }
-#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
-      defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+      defined(HAS_ARGB1555TOYROW_LASX))
     free_aligned_buffer_64(row);
 #endif
   }
@@ -4519,14 +4303,6 @@ int ARGB4444ToI420(const uint8_t* src_argb4444,
     }
   }
 #endif
-#if defined(HAS_ARGB4444TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGB4444ToARGBRow = ARGB4444ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGB4444TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_LSX;
@@ -4575,18 +4351,6 @@ int ARGB4444ToI420(const uint8_t* src_argb4444,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToUVRow = ARGBToUVRow_Any_MSA;
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-      if (IS_ALIGNED(width, 32)) {
-        ARGBToUVRow = ARGBToUVRow_MSA;
-      }
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -4710,14 +4474,6 @@ int RGB24ToJ400(const uint8_t* src_rgb24,
     }
   }
 #endif
-#if defined(HAS_RGB24TOYJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RGB24ToYJRow = RGB24ToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RGB24ToYJRow = RGB24ToYJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RGB24TOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RGB24ToYJRow = RGB24ToYJRow_Any_LSX;
@@ -4799,14 +4555,6 @@ int RAWToJ400(const uint8_t* src_raw,
     }
   }
 #endif
-#if defined(HAS_RAWTOYJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RAWToYJRow = RAWToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RAWToYJRow = RAWToYJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RAWTOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RAWToYJRow = RAWToYJRow_Any_LSX;

source/convert_argb.cc

@@ -119,14 +119,6 @@ int I420ToARGBMatrix(const uint8_t* src_y,
     I422ToARGBRow = I422ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I422TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToARGBRow = I422ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToARGBRow = I422ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToARGBRow = I422ToARGBRow_Any_LSX;
@@ -383,14 +375,6 @@ int I422ToARGBMatrix(const uint8_t* src_y,
     I422ToARGBRow = I422ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I422TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToARGBRow = I422ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToARGBRow = I422ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToARGBRow = I422ToARGBRow_Any_LSX;
@@ -636,14 +620,6 @@ int I444ToARGBMatrix(const uint8_t* src_y,
     I444ToARGBRow = I444ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I444TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I444ToARGBRow = I444ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I444ToARGBRow = I444ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I444TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I444ToARGBRow = I444ToARGBRow_Any_LSX;
@@ -881,14 +857,6 @@ int I444ToRGB24Matrix(const uint8_t* src_y,
     I444ToRGB24Row = I444ToRGB24Row_SME;
   }
 #endif
-#if defined(HAS_I444TORGB24ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I444ToRGB24Row = I444ToRGB24Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I444ToRGB24Row = I444ToRGB24Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I444TORGB24ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I444ToRGB24Row = I444ToRGB24Row_Any_LSX;
@@ -2298,14 +2266,6 @@ int I420AlphaToARGBMatrix(const uint8_t* src_y,
     I422AlphaToARGBRow = I422AlphaToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I422ALPHATOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422AlphaToARGBRow = I422AlphaToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422ALPHATOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422AlphaToARGBRow = I422AlphaToARGBRow_Any_LSX;
@@ -2351,14 +2311,6 @@ int I420AlphaToARGBMatrix(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -2467,14 +2419,6 @@ int I422AlphaToARGBMatrix(const uint8_t* src_y,
     I422AlphaToARGBRow = I422AlphaToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I422ALPHATOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422AlphaToARGBRow = I422AlphaToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422ALPHATOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422AlphaToARGBRow = I422AlphaToARGBRow_Any_LSX;
@@ -2520,14 +2464,6 @@ int I422AlphaToARGBMatrix(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -2634,14 +2570,6 @@ int I444AlphaToARGBMatrix(const uint8_t* src_y,
     I444AlphaToARGBRow = I444AlphaToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I444ALPHATOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I444ALPHATOARGBROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     I444AlphaToARGBRow = I444AlphaToARGBRow_RVV;
@@ -2671,14 +2599,6 @@ int I444AlphaToARGBMatrix(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -2938,14 +2858,6 @@ int I010AlphaToARGBMatrix(const uint16_t* src_y,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -3078,14 +2990,6 @@ int I210AlphaToARGBMatrix(const uint16_t* src_y,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -3216,14 +3120,6 @@ int I410AlphaToARGBMatrix(const uint16_t* src_y,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -3324,14 +3220,6 @@ int I400ToARGBMatrix(const uint8_t* src_y,
     I400ToARGBRow = I400ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I400TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I400ToARGBRow = I400ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      I400ToARGBRow = I400ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I400TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I400ToARGBRow = I400ToARGBRow_Any_LSX;
@@ -3416,14 +3304,6 @@ int J400ToARGB(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_J400TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    J400ToARGBRow = J400ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      J400ToARGBRow = J400ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_J400TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     J400ToARGBRow = J400ToARGBRow_Any_LSX;
@@ -3771,14 +3651,6 @@ int RGB24ToARGB(const uint8_t* src_rgb24,
     RGB24ToARGBRow = RGB24ToARGBRow_SVE2;
   }
 #endif
-#if defined(HAS_RGB24TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RGB24ToARGBRow = RGB24ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RGB24ToARGBRow = RGB24ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RGB24TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RGB24ToARGBRow = RGB24ToARGBRow_Any_LSX;
@@ -3864,14 +3736,6 @@ int RAWToARGB(const uint8_t* src_raw,
     RAWToARGBRow = RAWToARGBRow_SVE2;
   }
 #endif
-#if defined(HAS_RAWTOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RAWToARGBRow = RAWToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RAWToARGBRow = RAWToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RAWTOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RAWToARGBRow = RAWToARGBRow_Any_LSX;
@@ -4013,14 +3877,6 @@ int RGB565ToARGB(const uint8_t* src_rgb565,
     }
   }
 #endif
-#if defined(HAS_RGB565TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RGB565ToARGBRow = RGB565ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RGB565ToARGBRow = RGB565ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RGB565TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RGB565ToARGBRow = RGB565ToARGBRow_Any_LSX;
@@ -4101,14 +3957,6 @@ int ARGB1555ToARGB(const uint8_t* src_argb1555,
     ARGB1555ToARGBRow = ARGB1555ToARGBRow_SVE2;
   }
 #endif
-#if defined(HAS_ARGB1555TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGB1555ToARGBRow = ARGB1555ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGB1555TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_LSX;
@@ -4184,14 +4032,6 @@ int ARGB4444ToARGB(const uint8_t* src_argb4444,
     }
   }
 #endif
-#if defined(HAS_ARGB4444TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGB4444ToARGBRow = ARGB4444ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGB4444TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_LSX;
@@ -4500,14 +4340,6 @@ int NV12ToARGBMatrix(const uint8_t* src_y,
     NV12ToARGBRow = NV12ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_NV12TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    NV12ToARGBRow = NV12ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      NV12ToARGBRow = NV12ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_NV12TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     NV12ToARGBRow = NV12ToARGBRow_Any_LSX;
@@ -4600,14 +4432,6 @@ int NV21ToARGBMatrix(const uint8_t* src_y,
     NV21ToARGBRow = NV21ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_NV21TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    NV21ToARGBRow = NV21ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      NV21ToARGBRow = NV21ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_NV21TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     NV21ToARGBRow = NV21ToARGBRow_Any_LSX;
@@ -5028,14 +4852,6 @@ int YUY2ToARGBMatrix(const uint8_t* src_yuy2,
     YUY2ToARGBRow = YUY2ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_YUY2TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    YUY2ToARGBRow = YUY2ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      YUY2ToARGBRow = YUY2ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_YUY2TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     YUY2ToARGBRow = YUY2ToARGBRow_Any_LSX;
@@ -5126,14 +4942,6 @@ int UYVYToARGBMatrix(const uint8_t* src_uyvy,
     UYVYToARGBRow = UYVYToARGBRow_SME;
   }
 #endif
-#if defined(HAS_UYVYTOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    UYVYToARGBRow = UYVYToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      UYVYToARGBRow = UYVYToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_UYVYTOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     UYVYToARGBRow = UYVYToARGBRow_Any_LSX;
@@ -5343,14 +5151,6 @@ int I422ToRGBAMatrix(const uint8_t* src_y,
     I422ToRGBARow = I422ToRGBARow_SME;
   }
 #endif
-#if defined(HAS_I422TORGBAROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToRGBARow = I422ToRGBARow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToRGBARow = I422ToRGBARow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TORGBAROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToRGBARow = I422ToRGBARow_Any_LSX;
@@ -5468,14 +5268,6 @@ int NV12ToRGB565Matrix(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_NV12TORGB565ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    NV12ToRGB565Row = NV12ToRGB565Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      NV12ToRGB565Row = NV12ToRGB565Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_NV12TORGB565ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     NV12ToRGB565Row = NV12ToRGB565Row_Any_LSX;
@@ -5581,14 +5373,6 @@ int I420ToRGBAMatrix(const uint8_t* src_y,
     I422ToRGBARow = I422ToRGBARow_SME;
   }
 #endif
-#if defined(HAS_I422TORGBAROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToRGBARow = I422ToRGBARow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToRGBARow = I422ToRGBARow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TORGBAROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToRGBARow = I422ToRGBARow_Any_LSX;
@@ -5721,14 +5505,6 @@ int I420ToRGB24Matrix(const uint8_t* src_y,
     I422ToRGB24Row = I422ToRGB24Row_SME;
   }
 #endif
-#if defined(HAS_I422TORGB24ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToRGB24Row = I422ToRGB24Row_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      I422ToRGB24Row = I422ToRGB24Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TORGB24ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToRGB24Row = I422ToRGB24Row_Any_LSX;
@@ -5933,14 +5709,6 @@ int I422ToRGB24Matrix(const uint8_t* src_y,
     I422ToRGB24Row = I422ToRGB24Row_SME;
   }
 #endif
-#if defined(HAS_I422TORGB24ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToRGB24Row = I422ToRGB24Row_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      I422ToRGB24Row = I422ToRGB24Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TORGB24ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToRGB24Row = I422ToRGB24Row_Any_LSX;
@@ -6070,14 +5838,6 @@ int I420ToARGB1555(const uint8_t* src_y,
     I422ToARGB1555Row = I422ToARGB1555Row_SME;
   }
 #endif
-#if defined(HAS_I422TOARGB1555ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToARGB1555Row = I422ToARGB1555Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToARGB1555Row = I422ToARGB1555Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOARGB1555ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToARGB1555Row = I422ToARGB1555Row_Any_LSX;
@@ -6169,14 +5929,6 @@ int I420ToARGB4444(const uint8_t* src_y,
     I422ToARGB4444Row = I422ToARGB4444Row_SME;
   }
 #endif
-#if defined(HAS_I422TOARGB4444ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToARGB4444Row = I422ToARGB4444Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToARGB4444Row = I422ToARGB4444Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOARGB4444ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToARGB4444Row = I422ToARGB4444Row_Any_LSX;
@@ -6269,14 +6021,6 @@ int I420ToRGB565Matrix(const uint8_t* src_y,
     I422ToRGB565Row = I422ToRGB565Row_SME;
   }
 #endif
-#if defined(HAS_I422TORGB565ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToRGB565Row = I422ToRGB565Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToRGB565Row = I422ToRGB565Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TORGB565ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToRGB565Row = I422ToRGB565Row_Any_LSX;
@@ -6419,14 +6163,6 @@ int I422ToRGB565Matrix(const uint8_t* src_y,
     I422ToRGB565Row = I422ToRGB565Row_SME;
   }
 #endif
-#if defined(HAS_I422TORGB565ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToRGB565Row = I422ToRGB565Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToRGB565Row = I422ToRGB565Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TORGB565ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToRGB565Row = I422ToRGB565Row_Any_LSX;
@@ -6552,14 +6288,6 @@ int I420ToRGB565Dither(const uint8_t* src_y,
     I422ToARGBRow = I422ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I422TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToARGBRow = I422ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I422ToARGBRow = I422ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToARGBRow = I422ToARGBRow_Any_LSX;
@@ -6610,14 +6338,6 @@ int I420ToRGB565Dither(const uint8_t* src_y,
     ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_SVE2;
   }
 #endif
-#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTORGB565DITHERROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_LSX;
@@ -6866,14 +6586,6 @@ static int I420ToARGBMatrixBilinear(const uint8_t* src_y,
     I444ToARGBRow = I444ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I444TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I444ToARGBRow = I444ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I444ToARGBRow = I444ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I444TOARGBROW_LASX)
   if (TestCpuFlag(kCpuHasLASX)) {
     I444ToARGBRow = I444ToARGBRow_Any_LASX;
@@ -7023,14 +6735,6 @@ static int I422ToARGBMatrixLinear(const uint8_t* src_y,
     I444ToARGBRow = I444ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I444TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I444ToARGBRow = I444ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I444ToARGBRow = I444ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I444TOARGBROW_LASX)
   if (TestCpuFlag(kCpuHasLASX)) {
     I444ToARGBRow = I444ToARGBRow_Any_LASX;
@@ -7157,14 +6861,6 @@ static int I420ToRGB24MatrixBilinear(const uint8_t* src_y,
     I444ToRGB24Row = I444ToRGB24Row_SME;
   }
 #endif
-#if defined(HAS_I444TORGB24ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I444ToRGB24Row = I444ToRGB24Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I444ToRGB24Row = I444ToRGB24Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I444TORGB24ROW_LASX)
   if (TestCpuFlag(kCpuHasLASX)) {
     I444ToRGB24Row = I444ToRGB24Row_Any_LASX;
@@ -7779,14 +7475,6 @@ static int I420AlphaToARGBMatrixBilinear(
     I444AlphaToARGBRow = I444AlphaToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I444ALPHATOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I444ALPHATOARGBROW_LASX)
   if (TestCpuFlag(kCpuHasLASX)) {
     I444AlphaToARGBRow = I444AlphaToARGBRow_Any_LASX;
@@ -7824,14 +7512,6 @@ static int I420AlphaToARGBMatrixBilinear(
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -8015,14 +7695,6 @@ static int I422AlphaToARGBMatrixLinear(const uint8_t* src_y,
     I444AlphaToARGBRow = I444AlphaToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I444ALPHATOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I444ALPHATOARGBROW_LASX)
   if (TestCpuFlag(kCpuHasLASX)) {
     I444AlphaToARGBRow = I444AlphaToARGBRow_Any_LASX;
@@ -8060,14 +7732,6 @@ static int I422AlphaToARGBMatrixLinear(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -8240,14 +7904,6 @@ static int I010AlphaToARGBMatrixBilinear(
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;
@@ -8442,14 +8098,6 @@ static int I210AlphaToARGBMatrixLinear(const uint16_t* src_y,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBAttenuateRow = ARGBAttenuateRow_RVV;

source/convert_from.cc

@@ -445,14 +445,6 @@ int I420ToYUY2(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_I422TOYUY2ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToYUY2Row = I422ToYUY2Row_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      I422ToYUY2Row = I422ToYUY2Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOYUY2ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToYUY2Row = I422ToYUY2Row_Any_LSX;
@@ -540,14 +532,6 @@ int I422ToUYVY(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_I422TOUYVYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      I422ToUYVYRow = I422ToUYVYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOUYVYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToUYVYRow = I422ToUYVYRow_Any_LSX;
@@ -623,14 +607,6 @@ int I420ToUYVY(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_I422TOUYVYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      I422ToUYVYRow = I422ToUYVYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOUYVYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToUYVYRow = I422ToUYVYRow_Any_LSX;

source/convert_from_argb.cc

@@ -84,14 +84,6 @@ int ARGBToI444(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOUV444ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToUV444Row = ARGBToUV444Row_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToUV444Row = ARGBToUV444Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOUV444ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToUV444Row = ARGBToUV444Row_Any_LSX;
@@ -140,14 +132,6 @@ int ARGBToI444(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -295,18 +279,6 @@ int ARGBToI422(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    ARGBToUVRow = ARGBToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVRow = ARGBToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -459,18 +431,6 @@ int ARGBToNV12(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    ARGBToUVRow = ARGBToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVRow = ARGBToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -531,14 +491,6 @@ int ARGBToNV12(const uint8_t* src_argb,
     MergeUVRow_ = MergeUVRow_SME;
   }
 #endif
-#if defined(HAS_MERGEUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MergeUVRow_ = MergeUVRow_Any_MSA;
-    if (IS_ALIGNED(halfwidth, 16)) {
-      MergeUVRow_ = MergeUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MERGEUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MergeUVRow_ = MergeUVRow_Any_LSX;
@@ -686,18 +638,6 @@ int ARGBToNV21(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    ARGBToUVRow = ARGBToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVRow = ARGBToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -768,14 +708,6 @@ int ARGBToNV21(const uint8_t* src_argb,
     MergeUVRow_ = MergeUVRow_SME;
   }
 #endif
-#if defined(HAS_MERGEUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MergeUVRow_ = MergeUVRow_Any_MSA;
-    if (IS_ALIGNED(halfwidth, 16)) {
-      MergeUVRow_ = MergeUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MERGEUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MergeUVRow_ = MergeUVRow_Any_LSX;
@@ -922,18 +854,6 @@ int ABGRToNV12(const uint8_t* src_abgr,
     }
   }
 #endif
-#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ABGRToYRow = ABGRToYRow_Any_MSA;
-    ABGRToUVRow = ABGRToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ABGRToYRow = ABGRToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ABGRToUVRow = ABGRToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ABGRTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ABGRToYRow = ABGRToYRow_Any_LSX;
@@ -992,14 +912,6 @@ int ABGRToNV12(const uint8_t* src_abgr,
     MergeUVRow_ = MergeUVRow_SME;
   }
 #endif
-#if defined(HAS_MERGEUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MergeUVRow_ = MergeUVRow_Any_MSA;
-    if (IS_ALIGNED(halfwidth, 16)) {
-      MergeUVRow_ = MergeUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MERGEUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MergeUVRow_ = MergeUVRow_Any_LSX;
@@ -1147,18 +1059,6 @@ int ABGRToNV21(const uint8_t* src_abgr,
     }
   }
 #endif
-#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ABGRToYRow = ABGRToYRow_Any_MSA;
-    ABGRToUVRow = ABGRToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ABGRToYRow = ABGRToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ABGRToUVRow = ABGRToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ABGRTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ABGRToYRow = ABGRToYRow_Any_LSX;
@@ -1217,14 +1117,6 @@ int ABGRToNV21(const uint8_t* src_abgr,
     MergeUVRow_ = MergeUVRow_SME;
   }
 #endif
-#if defined(HAS_MERGEUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MergeUVRow_ = MergeUVRow_Any_MSA;
-    if (IS_ALIGNED(halfwidth, 16)) {
-      MergeUVRow_ = MergeUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MERGEUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MergeUVRow_ = MergeUVRow_Any_LSX;
@@ -1377,18 +1269,6 @@ int ARGBToYUY2(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    ARGBToUVRow = ARGBToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVRow = ARGBToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -1446,14 +1326,6 @@ int ARGBToYUY2(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_I422TOYUY2ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToYUY2Row = I422ToYUY2Row_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      I422ToYUY2Row = I422ToYUY2Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOYUY2ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToYUY2Row = I422ToYUY2Row_Any_LSX;
@@ -1605,18 +1477,6 @@ int ARGBToUYVY(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    ARGBToUVRow = ARGBToUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVRow = ARGBToUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -1674,14 +1534,6 @@ int ARGBToUYVY(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_I422TOUYVYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      I422ToUYVYRow = I422ToUYVYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOUYVYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToUYVYRow = I422ToUYVYRow_Any_LSX;
@@ -1777,14 +1629,6 @@ int ARGBToI400(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYRow = ARGBToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYRow = ARGBToYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYRow = ARGBToYRow_Any_LSX;
@@ -1935,14 +1779,6 @@ int ARGBToRGB24(const uint8_t* src_argb,
     ARGBToRGB24Row = ARGBToRGB24Row_SVE2;
   }
 #endif
-#if defined(HAS_ARGBTORGB24ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToRGB24Row = ARGBToRGB24Row_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToRGB24Row = ARGBToRGB24Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTORGB24ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToRGB24Row = ARGBToRGB24Row_Any_LSX;
@@ -2027,14 +1863,6 @@ int ARGBToRAW(const uint8_t* src_argb,
     ARGBToRAWRow = ARGBToRAWRow_SVE2;
   }
 #endif
-#if defined(HAS_ARGBTORAWROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToRAWRow = ARGBToRAWRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToRAWRow = ARGBToRAWRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTORAWROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToRAWRow = ARGBToRAWRow_Any_LSX;
@@ -2123,14 +1951,6 @@ int ARGBToRGB565Dither(const uint8_t* src_argb,
     ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_SVE2;
   }
 #endif
-#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTORGB565DITHERROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_LSX;
@@ -2213,14 +2033,6 @@ int ARGBToRGB565(const uint8_t* src_argb,
     ARGBToRGB565Row = ARGBToRGB565Row_SVE2;
   }
 #endif
-#if defined(HAS_ARGBTORGB565ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToRGB565Row = ARGBToRGB565Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBToRGB565Row = ARGBToRGB565Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTORGB565ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToRGB565Row = ARGBToRGB565Row_Any_LSX;
@@ -2296,14 +2108,6 @@ int ARGBToARGB1555(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOARGB1555ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToARGB1555Row = ARGBToARGB1555Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBToARGB1555Row = ARGBToARGB1555Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOARGB1555ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToARGB1555Row = ARGBToARGB1555Row_Any_LSX;
@@ -2378,14 +2182,6 @@ int ARGBToARGB4444(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOARGB4444ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToARGB4444Row = ARGBToARGB4444Row_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBToARGB4444Row = ARGBToARGB4444Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOARGB4444ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToARGB4444Row = ARGBToARGB4444Row_Any_LSX;
@@ -2589,14 +2385,6 @@ int ARGBToJ444(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOUVJ444ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToUVJ444Row = ARGBToUVJ444Row_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToUVJ444Row = ARGBToUVJ444Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOUVJ444ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToUVJ444Row = ARGBToUVJ444Row_Any_LSX;
@@ -2645,14 +2433,6 @@ int ARGBToJ444(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYJRow = ARGBToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYJRow = ARGBToYJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYJRow = ARGBToYJRow_Any_LSX;
@@ -2793,18 +2573,6 @@ int ARGBToJ420(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYJROW_MSA) && defined(HAS_ARGBTOUVJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYJRow = ARGBToYJRow_Any_MSA;
-    ARGBToUVJRow = ARGBToUVJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYJRow = ARGBToYJRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVJRow = ARGBToUVJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYJROW_LSX) && defined(HAS_ARGBTOUVJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYJRow = ARGBToYJRow_Any_LSX;
@@ -2961,18 +2729,6 @@ int ARGBToJ422(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYJROW_MSA) && defined(HAS_ARGBTOUVJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYJRow = ARGBToYJRow_Any_MSA;
-    ARGBToUVJRow = ARGBToUVJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYJRow = ARGBToYJRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ARGBToUVJRow = ARGBToUVJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYJROW_LSX) && defined(HAS_ARGBTOUVJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYJRow = ARGBToYJRow_Any_LSX;
@@ -3067,14 +2823,6 @@ int ARGBToJ400(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYJRow = ARGBToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYJRow = ARGBToYJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYJROW_RVV)
   if (TestCpuFlag(kCpuHasRVV)) {
     ARGBToYJRow = ARGBToYJRow_RVV;
@@ -3146,14 +2894,6 @@ int RGBAToJ400(const uint8_t* src_rgba,
     }
   }
 #endif
-#if defined(HAS_RGBATOYJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RGBAToYJRow = RGBAToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RGBAToYJRow = RGBAToYJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RGBATOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RGBAToYJRow = RGBAToYJRow_Any_LSX;
@@ -3291,16 +3031,6 @@ int ABGRToJ420(const uint8_t* src_abgr,
     }
   }
 #endif
-#if defined(HAS_ABGRTOYJROW_MSA) && defined(HAS_ABGRTOUVJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ABGRToYJRow = ABGRToYJRow_Any_MSA;
-    ABGRToUVJRow = ABGRToUVJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ABGRToYJRow = ABGRToYJRow_MSA;
-      ABGRToUVJRow = ABGRToUVJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ABGRTOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ABGRToYJRow = ABGRToYJRow_Any_LSX;
@@ -3453,18 +3183,6 @@ int ABGRToJ422(const uint8_t* src_abgr,
     }
   }
 #endif
-#if defined(HAS_ABGRTOYJROW_MSA) && defined(HAS_ABGRTOUVJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ABGRToYJRow = ABGRToYJRow_Any_MSA;
-    ABGRToUVJRow = ABGRToUVJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ABGRToYJRow = ABGRToYJRow_MSA;
-    }
-    if (IS_ALIGNED(width, 32)) {
-      ABGRToUVJRow = ABGRToUVJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ABGRTOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ABGRToYJRow = ABGRToYJRow_Any_LSX;
@@ -3555,14 +3273,6 @@ int ABGRToJ400(const uint8_t* src_abgr,
     }
   }
 #endif
-#if defined(HAS_ABGRTOYJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ABGRToYJRow = ABGRToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ABGRToYJRow = ABGRToYJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ABGRTOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ABGRToYJRow = ABGRToYJRow_Any_LSX;
@@ -3722,8 +3432,7 @@ int ARGBToAB64(const uint8_t* src_argb,
 }
 
 // Enabled if 1 pass is available
-#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_MSA) || \
+#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_RVV)
-    defined(HAS_RAWTOYJROW_RVV)
 #define HAS_RAWTOYJROW
 #endif
 
@@ -3779,16 +3488,6 @@ int RAWToJNV21(const uint8_t* src_raw,
     }
   }
 #endif
-#if defined(HAS_RAWTOYJROW_MSA) && defined(HAS_RAWTOUVJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RAWToUVJRow = RAWToUVJRow_Any_MSA;
-    RAWToYJRow = RAWToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RAWToYJRow = RAWToYJRow_MSA;
-      RAWToUVJRow = RAWToUVJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RAWTOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RAWToYJRow = RAWToYJRow_Any_LSX;
@@ -3900,14 +3599,6 @@ int RAWToJNV21(const uint8_t* src_raw,
     MergeUVRow_ = MergeUVRow_SME;
   }
 #endif
-#if defined(HAS_MERGEUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MergeUVRow_ = MergeUVRow_Any_MSA;
-    if (IS_ALIGNED(halfwidth, 16)) {
-      MergeUVRow_ = MergeUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MERGEUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MergeUVRow_ = MergeUVRow_Any_LSX;

source/planar_functions.cc

@@ -631,14 +631,6 @@ void SplitUVPlane(const uint8_t* src_uv,
     }
   }
 #endif
-#if defined(HAS_SPLITUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    SplitUVRow = SplitUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      SplitUVRow = SplitUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SPLITUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     SplitUVRow = SplitUVRow_Any_LSX;
@@ -727,14 +719,6 @@ void MergeUVPlane(const uint8_t* src_u,
     MergeUVRow = MergeUVRow_SME;
   }
 #endif
-#if defined(HAS_MERGEUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MergeUVRow = MergeUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      MergeUVRow = MergeUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MERGEUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MergeUVRow = MergeUVRow_Any_LSX;
@@ -2251,16 +2235,6 @@ int YUY2ToI422(const uint8_t* src_yuy2,
     }
   }
 #endif
-#if defined(HAS_YUY2TOYROW_MSA) && defined(HAS_YUY2TOUV422ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    YUY2ToYRow = YUY2ToYRow_Any_MSA;
-    YUY2ToUV422Row = YUY2ToUV422Row_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      YUY2ToYRow = YUY2ToYRow_MSA;
-      YUY2ToUV422Row = YUY2ToUV422Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_YUY2TOYROW_LSX) && defined(HAS_YUY2TOUV422ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     YUY2ToYRow = YUY2ToYRow_Any_LSX;
@@ -2357,16 +2331,6 @@ int UYVYToI422(const uint8_t* src_uyvy,
     }
   }
 #endif
-#if defined(HAS_UYVYTOYROW_MSA) && defined(HAS_UYVYTOUV422ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    UYVYToYRow = UYVYToYRow_Any_MSA;
-    UYVYToUV422Row = UYVYToUV422Row_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      UYVYToYRow = UYVYToYRow_MSA;
-      UYVYToUV422Row = UYVYToUV422Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_UYVYTOYROW_LSX) && defined(HAS_UYVYTOUV422ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     UYVYToYRow = UYVYToYRow_Any_LSX;
@@ -2449,14 +2413,6 @@ int YUY2ToY(const uint8_t* src_yuy2,
     }
   }
 #endif
-#if defined(HAS_YUY2TOYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    YUY2ToYRow = YUY2ToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      YUY2ToYRow = YUY2ToYRow_MSA;
-    }
-  }
-#endif
 
   for (y = 0; y < height; ++y) {
     YUY2ToYRow(src_yuy2, dst_y, width);
@@ -2516,14 +2472,6 @@ int UYVYToY(const uint8_t* src_uyvy,
     }
   }
 #endif
-#if defined(HAS_UYVYTOYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    UYVYToYRow = UYVYToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      UYVYToYRow = UYVYToYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_UYVYTOYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     UYVYToYRow = UYVYToYRow_Any_LSX;
@@ -2582,14 +2530,6 @@ void MirrorPlane(const uint8_t* src_y,
     }
   }
 #endif
-#if defined(HAS_MIRRORROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MirrorRow = MirrorRow_Any_MSA;
-    if (IS_ALIGNED(width, 64)) {
-      MirrorRow = MirrorRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MIRRORROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MirrorRow = MirrorRow_Any_LSX;
@@ -2656,14 +2596,6 @@ void MirrorUVPlane(const uint8_t* src_uv,
     }
   }
 #endif
-#if defined(HAS_MIRRORUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MirrorUVRow = MirrorUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      MirrorUVRow = MirrorUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MIRRORUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MirrorUVRow = MirrorUVRow_Any_LSX;
@@ -2836,14 +2768,6 @@ int ARGBMirror(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBMIRRORROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBMirrorRow = ARGBMirrorRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBMirrorRow = ARGBMirrorRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBMIRRORROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBMirrorRow = ARGBMirrorRow_Any_LSX;
@@ -2955,11 +2879,6 @@ int ARGBBlend(const uint8_t* src_argb0,
     ARGBBlendRow = ARGBBlendRow_NEON;
   }
 #endif
-#if defined(HAS_ARGBBLENDROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBBlendRow = ARGBBlendRow_MSA;
-  }
-#endif
 #if defined(HAS_ARGBBLENDROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBBlendRow = ARGBBlendRow_LSX;
@@ -3241,14 +3160,6 @@ int ARGBMultiply(const uint8_t* src_argb0,
     ARGBMultiplyRow = ARGBMultiplyRow_SME;
   }
 #endif
-#if defined(HAS_ARGBMULTIPLYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBMultiplyRow = ARGBMultiplyRow_Any_MSA;
-    if (IS_ALIGNED(width, 4)) {
-      ARGBMultiplyRow = ARGBMultiplyRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBMULTIPLYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBMultiplyRow = ARGBMultiplyRow_Any_LSX;
@@ -3334,14 +3245,6 @@ int ARGBAdd(const uint8_t* src_argb0,
     }
   }
 #endif
-#if defined(HAS_ARGBADDROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAddRow = ARGBAddRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAddRow = ARGBAddRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBADDROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBAddRow = ARGBAddRow_Any_LSX;
@@ -3422,14 +3325,6 @@ int ARGBSubtract(const uint8_t* src_argb0,
     }
   }
 #endif
-#if defined(HAS_ARGBSUBTRACTROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBSubtractRow = ARGBSubtractRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBSubtractRow = ARGBSubtractRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBSUBTRACTROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBSubtractRow = ARGBSubtractRow_Any_LSX;
@@ -3504,14 +3399,6 @@ int RAWToRGB24(const uint8_t* src_raw,
     RAWToRGB24Row = RAWToRGB24Row_SVE2;
   }
 #endif
-#if defined(HAS_RAWTORGB24ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    RAWToRGB24Row = RAWToRGB24Row_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      RAWToRGB24Row = RAWToRGB24Row_MSA;
-    }
-  }
-#endif
 #if defined(HAS_RAWTORGB24ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     RAWToRGB24Row = RAWToRGB24Row_Any_LSX;
@@ -3579,11 +3466,6 @@ void SetPlane(uint8_t* dst_y,
     SetRow = SetRow_ERMS;
   }
 #endif
-#if defined(HAS_SETROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 16)) {
-    SetRow = SetRow_MSA;
-  }
-#endif
 #if defined(HAS_SETROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     SetRow = SetRow_Any_LSX;
@@ -3674,14 +3556,6 @@ int ARGBRect(uint8_t* dst_argb,
     ARGBSetRow = ARGBSetRow_X86;
   }
 #endif
-#if defined(HAS_ARGBSETROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBSetRow = ARGBSetRow_Any_MSA;
-    if (IS_ALIGNED(width, 4)) {
-      ARGBSetRow = ARGBSetRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBSETROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBSetRow = ARGBSetRow_Any_LSX;
@@ -3760,14 +3634,6 @@ int ARGBAttenuate(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBATTENUATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBATTENUATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBAttenuateRow = ARGBAttenuateRow_Any_LSX;
@@ -3889,11 +3755,6 @@ int ARGBGrayTo(const uint8_t* src_argb,
     ARGBGrayRow = ARGBGrayRow_NEON_DotProd;
   }
 #endif
-#if defined(HAS_ARGBGRAYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
-    ARGBGrayRow = ARGBGrayRow_MSA;
-  }
-#endif
 #if defined(HAS_ARGBGRAYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
     ARGBGrayRow = ARGBGrayRow_LSX;
@@ -3949,11 +3810,6 @@ int ARGBGray(uint8_t* dst_argb,
     ARGBGrayRow = ARGBGrayRow_NEON_DotProd;
   }
 #endif
-#if defined(HAS_ARGBGRAYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
-    ARGBGrayRow = ARGBGrayRow_MSA;
-  }
-#endif
 #if defined(HAS_ARGBGRAYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
     ARGBGrayRow = ARGBGrayRow_LSX;
@@ -4007,11 +3863,6 @@ int ARGBSepia(uint8_t* dst_argb,
     ARGBSepiaRow = ARGBSepiaRow_NEON_DotProd;
   }
 #endif
-#if defined(HAS_ARGBSEPIAROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
-    ARGBSepiaRow = ARGBSepiaRow_MSA;
-  }
-#endif
 #if defined(HAS_ARGBSEPIAROW_LSX)
   if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
     ARGBSepiaRow = ARGBSepiaRow_LSX;
@@ -4073,11 +3924,6 @@ int ARGBColorMatrix(const uint8_t* src_argb,
     ARGBColorMatrixRow = ARGBColorMatrixRow_NEON_I8MM;
   }
 #endif
-#if defined(HAS_ARGBCOLORMATRIXROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
-    ARGBColorMatrixRow = ARGBColorMatrixRow_MSA;
-  }
-#endif
 #if defined(HAS_ARGBCOLORMATRIXROW_LSX)
   if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
     ARGBColorMatrixRow = ARGBColorMatrixRow_LSX;
@@ -4243,11 +4089,6 @@ int ARGBQuantize(uint8_t* dst_argb,
     ARGBQuantizeRow = ARGBQuantizeRow_NEON;
   }
 #endif
-#if defined(HAS_ARGBQUANTIZEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
-    ARGBQuantizeRow = ARGBQuantizeRow_MSA;
-  }
-#endif
 #if defined(HAS_ARGBQUANTIZEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
     ARGBQuantizeRow = ARGBQuantizeRow_LSX;
@@ -4442,11 +4283,6 @@ int ARGBShade(const uint8_t* src_argb,
     ARGBShadeRow = ARGBShadeRow_NEON;
   }
 #endif
-#if defined(HAS_ARGBSHADEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 4)) {
-    ARGBShadeRow = ARGBShadeRow_MSA;
-  }
-#endif
 #if defined(HAS_ARGBSHADEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 4)) {
     ARGBShadeRow = ARGBShadeRow_LSX;
@@ -4525,14 +4361,6 @@ int InterpolatePlane(const uint8_t* src0,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;
@@ -4615,14 +4443,6 @@ int InterpolatePlane_16(const uint16_t* src0,
     InterpolateRow_16 = InterpolateRow_16_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_16_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow_16 = InterpolateRow_16_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      InterpolateRow_16 = InterpolateRow_16_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_16_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow_16 = InterpolateRow_16_Any_LSX;
@@ -4748,14 +4568,6 @@ int ARGBShuffle(const uint8_t* src_bgra,
     }
   }
 #endif
-#if defined(HAS_ARGBSHUFFLEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBShuffleRow = ARGBShuffleRow_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      ARGBShuffleRow = ARGBShuffleRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBSHUFFLEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBShuffleRow = ARGBShuffleRow_Any_LSX;
@@ -4973,14 +4785,6 @@ static int ARGBSobelize(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBTOYJROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBToYJRow = ARGBToYJRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBToYJRow = ARGBToYJRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBTOYJROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBToYJRow = ARGBToYJRow_Any_LSX;
@@ -5013,11 +4817,6 @@ static int ARGBSobelize(const uint8_t* src_argb,
     SobelYRow = SobelYRow_NEON;
   }
 #endif
-#if defined(HAS_SOBELYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    SobelYRow = SobelYRow_MSA;
-  }
-#endif
 #if defined(HAS_SOBELXROW_SSE2)
   if (TestCpuFlag(kCpuHasSSE2)) {
     SobelXRow = SobelXRow_SSE2;
@@ -5027,11 +4826,6 @@ static int ARGBSobelize(const uint8_t* src_argb,
   if (TestCpuFlag(kCpuHasNEON)) {
     SobelXRow = SobelXRow_NEON;
   }
-#endif
-#if defined(HAS_SOBELXROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    SobelXRow = SobelXRow_MSA;
-  }
 #endif
   {
     // 3 rows with edges before/after.
@@ -5109,14 +4903,6 @@ int ARGBSobel(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_SOBELROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    SobelRow = SobelRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      SobelRow = SobelRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SOBELROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     SobelRow = SobelRow_Any_LSX;
@@ -5155,14 +4941,6 @@ int ARGBSobelToPlane(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_SOBELTOPLANEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    SobelToPlaneRow = SobelToPlaneRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      SobelToPlaneRow = SobelToPlaneRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SOBELTOPLANEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     SobelToPlaneRow = SobelToPlaneRow_Any_LSX;
@@ -5202,14 +4980,6 @@ int ARGBSobelXY(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_SOBELXYROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    SobelXYRow = SobelXYRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      SobelXYRow = SobelXYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SOBELXYROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     SobelXYRow = SobelXYRow_Any_LSX;
@@ -5345,14 +5115,6 @@ int HalfFloatPlane(const uint16_t* src_y,
     HalfFloatRow = scale == 1.0f ? HalfFloat1Row_SVE2 : HalfFloatRow_SVE2;
   }
 #endif
-#if defined(HAS_HALFFLOATROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    HalfFloatRow = HalfFloatRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      HalfFloatRow = HalfFloatRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_HALFFLOATROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     HalfFloatRow = HalfFloatRow_Any_LSX;
@@ -5527,12 +5289,6 @@ int ARGBExtractAlpha(const uint8_t* src_argb,
                                                 : ARGBExtractAlphaRow_Any_NEON;
   }
 #endif
-#if defined(HAS_ARGBEXTRACTALPHAROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_MSA
-                                                : ARGBExtractAlphaRow_Any_MSA;
-  }
-#endif
 #if defined(HAS_ARGBEXTRACTALPHAROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_LSX
@@ -5657,14 +5413,6 @@ int YUY2ToNV12(const uint8_t* src_yuy2,
     }
   }
 #endif
-#if defined(HAS_YUY2TOYROW_MSA) && defined(HAS_YUY2TOUV422ROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    YUY2ToYRow = YUY2ToYRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      YUY2ToYRow = YUY2ToYRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_YUY2TOYROW_LSX) && defined(HAS_YUY2TOUV422ROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     YUY2ToYRow = YUY2ToYRow_Any_LSX;
@@ -5773,14 +5521,6 @@ int UYVYToNV12(const uint8_t* src_uyvy,
     }
   }
 #endif
-#if defined(HAS_SPLITUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    SplitUVRow = SplitUVRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      SplitUVRow = SplitUVRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SPLITUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     SplitUVRow = SplitUVRow_Any_LSX;
@@ -5824,14 +5564,6 @@ int UYVYToNV12(const uint8_t* src_uyvy,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(width, 32)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;

source/rotate.cc

@@ -35,8 +35,7 @@ void TransposePlane(const uint8_t* src,
   void (*TransposeWxH)(const uint8_t* src, int src_stride, uint8_t* dst,
                        int dst_stride, int width, int height) = NULL;
 #endif
-#if defined(HAS_TRANSPOSEWX16_MSA) || defined(HAS_TRANSPOSEWX16_LSX) || \
+#if defined(HAS_TRANSPOSEWX16_LSX) || defined(HAS_TRANSPOSEWX16_NEON)
-    defined(HAS_TRANSPOSEWX16_NEON)
   void (*TransposeWx16)(const uint8_t* src, int src_stride, uint8_t* dst,
                         int dst_stride, int width) = TransposeWx16_C;
 #else
@@ -81,14 +80,6 @@ void TransposePlane(const uint8_t* src,
     }
   }
 #endif
-#if defined(HAS_TRANSPOSEWX16_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    TransposeWx16 = TransposeWx16_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      TransposeWx16 = TransposeWx16_MSA;
-    }
-  }
-#endif
 #if defined(HAS_TRANSPOSEWX16_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     TransposeWx16 = TransposeWx16_Any_LSX;
@@ -104,8 +95,7 @@ void TransposePlane(const uint8_t* src,
     return;
   }
 #endif
-#if defined(HAS_TRANSPOSEWX16_MSA) || defined(HAS_TRANSPOSEWX16_LSX) || \
+#if defined(HAS_TRANSPOSEWX16_LSX) || defined(HAS_TRANSPOSEWX16_NEON)
-    defined(HAS_TRANSPOSEWX16_NEON)
   // Work across the source in 16x16 tiles
   while (i >= 16) {
     TransposeWx16(src, src_stride, dst, dst_stride, width);
@@ -200,14 +190,6 @@ void RotatePlane180(const uint8_t* src,
     }
   }
 #endif
-#if defined(HAS_MIRRORROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    MirrorRow = MirrorRow_Any_MSA;
-    if (IS_ALIGNED(width, 64)) {
-      MirrorRow = MirrorRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_MIRRORROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     MirrorRow = MirrorRow_Any_LSX;
@@ -288,11 +270,7 @@ void SplitTransposeUV(const uint8_t* src,
                          int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
                          int width, int height) = TransposeUVWxH_C;
 #endif
-#if defined(HAS_TRANSPOSEUVWX16_MSA)
+#if defined(HAS_TRANSPOSEUVWX16_LSX)
-  void (*TransposeUVWx16)(const uint8_t* src, int src_stride, uint8_t* dst_a,
-                          int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
-                          int width) = TransposeUVWx16_C;
-#elif defined(HAS_TRANSPOSEUVWX16_LSX)
   void (*TransposeUVWx16)(const uint8_t* src, int src_stride, uint8_t* dst_a,
                           int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
                           int width) = TransposeUVWx16_C;
@@ -302,21 +280,14 @@ void SplitTransposeUV(const uint8_t* src,
                          int width) = TransposeUVWx8_C;
 #endif
 
-#if defined(HAS_TRANSPOSEUVWX16_MSA)
+#if defined(HAS_TRANSPOSEUVWX16_LSX)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    TransposeUVWx16 = TransposeUVWx16_Any_MSA;
-    if (IS_ALIGNED(width, 8)) {
-      TransposeUVWx16 = TransposeUVWx16_MSA;
-    }
-  }
-#elif defined(HAS_TRANSPOSEUVWX16_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     TransposeUVWx16 = TransposeUVWx16_Any_LSX;
     if (IS_ALIGNED(width, 8)) {
       TransposeUVWx16 = TransposeUVWx16_LSX;
     }
   }
-#else
+#endif
 #if defined(HAS_TRANSPOSEUVWX8_NEON)
   if (TestCpuFlag(kCpuHasNEON)) {
     TransposeUVWx8 = TransposeUVWx8_Any_NEON;
@@ -338,7 +309,6 @@ void SplitTransposeUV(const uint8_t* src,
     }
   }
 #endif
-#endif /* defined(HAS_TRANSPOSEUVWX16_MSA) */
 
 #if defined(HAS_TRANSPOSEUVWXH_SME)
   if (TestCpuFlag(kCpuHasSME)) {
@@ -347,17 +317,7 @@ void SplitTransposeUV(const uint8_t* src,
     return;
   }
 #endif
-#if defined(HAS_TRANSPOSEUVWX16_MSA)
+#if defined(HAS_TRANSPOSEUVWX16_LSX)
-  // Work through the source in 8x8 tiles.
-  while (i >= 16) {
-    TransposeUVWx16(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
-                    width);
-    src += 16 * src_stride;  // Go down 16 rows.
-    dst_a += 16;             // Move over 8 columns.
-    dst_b += 16;             // Move over 8 columns.
-    i -= 16;
-  }
-#elif defined(HAS_TRANSPOSEUVWX16_LSX)
   // Work through the source in 8x8 tiles.
   while (i >= 16) {
     TransposeUVWx16(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
@@ -442,11 +402,6 @@ void SplitRotateUV180(const uint8_t* src,
     MirrorSplitUVRow = MirrorSplitUVRow_SSSE3;
   }
 #endif
-#if defined(HAS_MIRRORSPLITUVROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 32)) {
-    MirrorSplitUVRow = MirrorSplitUVRow_MSA;
-  }
-#endif
 #if defined(HAS_MIRRORSPLITUVROW_LSX)
   if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 32)) {
     MirrorSplitUVRow = MirrorSplitUVRow_LSX;

source/rotate_argb.cc

@@ -53,14 +53,6 @@ static int ARGBTranspose(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_SCALEARGBROWDOWNEVEN_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBRowDownEven = ScaleARGBRowDownEven_Any_MSA;
-    if (IS_ALIGNED(height, 4)) {  // Width of dest.
-      ScaleARGBRowDownEven = ScaleARGBRowDownEven_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBROWDOWNEVEN_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBRowDownEven = ScaleARGBRowDownEven_Any_LSX;
@@ -155,14 +147,6 @@ static int ARGBRotate180(const uint8_t* src_argb,
     }
   }
 #endif
-#if defined(HAS_ARGBMIRRORROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ARGBMirrorRow = ARGBMirrorRow_Any_MSA;
-    if (IS_ALIGNED(width, 16)) {
-      ARGBMirrorRow = ARGBMirrorRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_ARGBMIRRORROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ARGBMirrorRow = ARGBMirrorRow_Any_LSX;

source/row_any.cc

@@ -1074,14 +1074,6 @@ ANY11(ARGBToARGB1555Row_Any_NEON, ARGBToARGB1555Row_NEON, 0, 4, 2, 7)
 ANY11(ARGBToARGB4444Row_Any_NEON, ARGBToARGB4444Row_NEON, 0, 4, 2, 7)
 ANY11(J400ToARGBRow_Any_NEON, J400ToARGBRow_NEON, 0, 1, 4, 7)
 #endif
-#if defined(HAS_ARGBTORGB24ROW_MSA)
-ANY11(ARGBToRGB24Row_Any_MSA, ARGBToRGB24Row_MSA, 0, 4, 3, 15)
-ANY11(ARGBToRAWRow_Any_MSA, ARGBToRAWRow_MSA, 0, 4, 3, 15)
-ANY11(ARGBToRGB565Row_Any_MSA, ARGBToRGB565Row_MSA, 0, 4, 2, 7)
-ANY11(ARGBToARGB1555Row_Any_MSA, ARGBToARGB1555Row_MSA, 0, 4, 2, 7)
-ANY11(ARGBToARGB4444Row_Any_MSA, ARGBToARGB4444Row_MSA, 0, 4, 2, 7)
-ANY11(J400ToARGBRow_Any_MSA, J400ToARGBRow_MSA, 0, 1, 4, 15)
-#endif
 #if defined(HAS_ARGBTORGB24ROW_LSX)
 ANY11(ARGBToRGB24Row_Any_LSX, ARGBToRGB24Row_LSX, 0, 4, 3, 15)
 ANY11(ARGBToRAWRow_Any_LSX, ARGBToRAWRow_LSX, 0, 4, 3, 15)
@@ -1102,9 +1094,6 @@ ANY11(J400ToARGBRow_Any_LSX, J400ToARGBRow_LSX, 0, 1, 4, 15)
 #if defined(HAS_RAWTORGB24ROW_NEON)
 ANY11(RAWToRGB24Row_Any_NEON, RAWToRGB24Row_NEON, 0, 3, 3, 7)
 #endif
-#if defined(HAS_RAWTORGB24ROW_MSA)
-ANY11(RAWToRGB24Row_Any_MSA, RAWToRGB24Row_MSA, 0, 3, 3, 15)
-#endif
 #if defined(HAS_RAWTORGB24ROW_LSX)
 ANY11(RAWToRGB24Row_Any_LSX, RAWToRGB24Row_LSX, 0, 3, 3, 15)
 #endif
@@ -1552,14 +1541,6 @@ ANY11P(I400ToARGBRow_Any_NEON,
        4,
        7)
 #endif
-#if defined(HAS_I400TOARGBROW_MSA)
-ANY11P(I400ToARGBRow_Any_MSA,
-       I400ToARGBRow_MSA,
-       const struct YuvConstants*,
-       1,
-       4,
-       15)
-#endif
 #if defined(HAS_I400TOARGBROW_LSX)
 ANY11P(I400ToARGBRow_Any_LSX,
        I400ToARGBRow_LSX,
@@ -1593,14 +1574,6 @@ ANY11P(ARGBToRGB565DitherRow_Any_NEON,
        2,
        7)
 #endif
-#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
-ANY11P(ARGBToRGB565DitherRow_Any_MSA,
-       ARGBToRGB565DitherRow_MSA,
-       const uint32_t,
-       4,
-       2,
-       7)
-#endif
 #if defined(HAS_ARGBTORGB565DITHERROW_LSX)
 ANY11P(ARGBToRGB565DitherRow_Any_LSX,
        ARGBToRGB565DitherRow_LSX,
@@ -1926,10 +1899,6 @@ ANY11C(UYVYToARGBRow_Any_AVX2, UYVYToARGBRow_AVX2, 1, 4, 4, 31)
 ANY11C(YUY2ToARGBRow_Any_NEON, YUY2ToARGBRow_NEON, 1, 4, 4, 7)
 ANY11C(UYVYToARGBRow_Any_NEON, UYVYToARGBRow_NEON, 1, 4, 4, 7)
 #endif
-#if defined(HAS_YUY2TOARGBROW_MSA)
-ANY11C(YUY2ToARGBRow_Any_MSA, YUY2ToARGBRow_MSA, 1, 4, 4, 7)
-ANY11C(UYVYToARGBRow_Any_MSA, UYVYToARGBRow_MSA, 1, 4, 4, 7)
-#endif
 #if defined(HAS_YUY2TOARGBROW_LSX)
 ANY11C(YUY2ToARGBRow_Any_LSX, YUY2ToARGBRow_LSX, 1, 4, 4, 7)
 ANY11C(UYVYToARGBRow_Any_LSX, UYVYToARGBRow_LSX, 1, 4, 4, 7)

source/scale.cc

@@ -112,21 +112,6 @@ static void ScalePlaneDown2(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEROWDOWN2_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleRowDown2 =
-        filtering == kFilterNone
-            ? ScaleRowDown2_Any_MSA
-            : (filtering == kFilterLinear ? ScaleRowDown2Linear_Any_MSA
-                                          : ScaleRowDown2Box_Any_MSA);
-    if (IS_ALIGNED(dst_width, 32)) {
-      ScaleRowDown2 = filtering == kFilterNone ? ScaleRowDown2_MSA
-                                               : (filtering == kFilterLinear
-                                                      ? ScaleRowDown2Linear_MSA
-                                                      : ScaleRowDown2Box_MSA);
-    }
-  }
-#endif
 #if defined(HAS_SCALEROWDOWN2_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ScaleRowDown2 =
@@ -317,15 +302,6 @@ static void ScalePlaneDown4(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEROWDOWN4_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleRowDown4 =
-        filtering ? ScaleRowDown4Box_Any_MSA : ScaleRowDown4_Any_MSA;
-    if (IS_ALIGNED(dst_width, 16)) {
-      ScaleRowDown4 = filtering ? ScaleRowDown4Box_MSA : ScaleRowDown4_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEROWDOWN4_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ScaleRowDown4 =
@@ -694,26 +670,6 @@ static void ScalePlaneDown38(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEROWDOWN38_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    if (!filtering) {
-      ScaleRowDown38_3 = ScaleRowDown38_Any_MSA;
-      ScaleRowDown38_2 = ScaleRowDown38_Any_MSA;
-    } else {
-      ScaleRowDown38_3 = ScaleRowDown38_3_Box_Any_MSA;
-      ScaleRowDown38_2 = ScaleRowDown38_2_Box_Any_MSA;
-    }
-    if (dst_width % 12 == 0) {
-      if (!filtering) {
-        ScaleRowDown38_3 = ScaleRowDown38_MSA;
-        ScaleRowDown38_2 = ScaleRowDown38_MSA;
-      } else {
-        ScaleRowDown38_3 = ScaleRowDown38_3_Box_MSA;
-        ScaleRowDown38_2 = ScaleRowDown38_2_Box_MSA;
-      }
-    }
-  }
-#endif
 #if defined(HAS_SCALEROWDOWN38_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     if (!filtering) {
@@ -1015,14 +971,6 @@ static int ScalePlaneBox(int src_width,
       }
     }
 #endif
-#if defined(HAS_SCALEADDROW_MSA)
-    if (TestCpuFlag(kCpuHasMSA)) {
-      ScaleAddRow = ScaleAddRow_Any_MSA;
-      if (IS_ALIGNED(src_width, 16)) {
-        ScaleAddRow = ScaleAddRow_MSA;
-      }
-    }
-#endif
 #if defined(HAS_SCALEADDROW_LSX)
     if (TestCpuFlag(kCpuHasLSX)) {
       ScaleAddRow = ScaleAddRow_Any_LSX;
@@ -1178,14 +1126,6 @@ static int ScalePlaneBilinearDown(int src_width,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(src_width, 32)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;
@@ -1213,14 +1153,6 @@ static int ScalePlaneBilinearDown(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEFILTERCOLS_MSA)
-  if (TestCpuFlag(kCpuHasMSA) && src_width < 32768) {
-    ScaleFilterCols = ScaleFilterCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 16)) {
-      ScaleFilterCols = ScaleFilterCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEFILTERCOLS_LSX)
   if (TestCpuFlag(kCpuHasLSX) && src_width < 32768) {
     ScaleFilterCols = ScaleFilterCols_Any_LSX;
@@ -1430,14 +1362,6 @@ static int ScalePlaneBilinearUp(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEFILTERCOLS_MSA)
-  if (filtering && TestCpuFlag(kCpuHasMSA) && src_width < 32768) {
-    ScaleFilterCols = ScaleFilterCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 16)) {
-      ScaleFilterCols = ScaleFilterCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEFILTERCOLS_LSX)
   if (filtering && TestCpuFlag(kCpuHasLSX) && src_width < 32768) {
     ScaleFilterCols = ScaleFilterCols_Any_LSX;

source/scale_argb.cc

@@ -107,22 +107,6 @@ static void ScaleARGBDown2(int src_width,
                             : ScaleARGBRowDown2Box_SME;
   }
 #endif
-#if defined(HAS_SCALEARGBROWDOWN2_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBRowDown2 =
-        filtering == kFilterNone
-            ? ScaleARGBRowDown2_Any_MSA
-            : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_MSA
-                                          : ScaleARGBRowDown2Box_Any_MSA);
-    if (IS_ALIGNED(dst_width, 4)) {
-      ScaleARGBRowDown2 =
-          filtering == kFilterNone
-              ? ScaleARGBRowDown2_MSA
-              : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_MSA
-                                            : ScaleARGBRowDown2Box_MSA);
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBROWDOWN2_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBRowDown2 =
@@ -282,16 +266,6 @@ static void ScaleARGBDownEven(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEARGBROWDOWNEVEN_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_MSA
-                                     : ScaleARGBRowDownEven_Any_MSA;
-    if (IS_ALIGNED(dst_width, 4)) {
-      ScaleARGBRowDownEven =
-          filtering ? ScaleARGBRowDownEvenBox_MSA : ScaleARGBRowDownEven_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBROWDOWNEVEN_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_LSX
@@ -386,14 +360,6 @@ static int ScaleARGBBilinearDown(int src_width,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(clip_src_width, 32)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;
@@ -420,14 +386,6 @@ static int ScaleARGBBilinearDown(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 8)) {
-      ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBFILTERCOLS_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
@@ -525,14 +483,6 @@ static int ScaleARGBBilinearUp(int src_width,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(dst_width, 8)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;
@@ -563,14 +513,6 @@ static int ScaleARGBBilinearUp(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
-  if (filtering && TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 8)) {
-      ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBFILTERCOLS_LSX)
   if (filtering && TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
@@ -597,14 +539,6 @@ static int ScaleARGBBilinearUp(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEARGBCOLS_MSA)
-  if (!filtering && TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBFilterCols = ScaleARGBCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 4)) {
-      ScaleARGBFilterCols = ScaleARGBCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBCOLS_LSX)
   if (!filtering && TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBFilterCols = ScaleARGBCols_Any_LSX;
@@ -747,14 +681,6 @@ static int ScaleYUVToARGBBilinearUp(int src_width,
     I422ToARGBRow = I422ToARGBRow_SME;
   }
 #endif
-#if defined(HAS_I422TOARGBROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    I422ToARGBRow = I422ToARGBRow_Any_MSA;
-    if (IS_ALIGNED(src_width, 8)) {
-      I422ToARGBRow = I422ToARGBRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_I422TOARGBROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     I422ToARGBRow = I422ToARGBRow_Any_LSX;
@@ -809,14 +735,6 @@ static int ScaleYUVToARGBBilinearUp(int src_width,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(dst_width, 8)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;
@@ -851,14 +769,6 @@ static int ScaleYUVToARGBBilinearUp(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
-  if (filtering && TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 8)) {
-      ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBFILTERCOLS_LSX)
   if (filtering && TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
@@ -885,14 +795,6 @@ static int ScaleYUVToARGBBilinearUp(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEARGBCOLS_MSA)
-  if (!filtering && TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBFilterCols = ScaleARGBCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 4)) {
-      ScaleARGBFilterCols = ScaleARGBCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBCOLS_LSX)
   if (!filtering && TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBFilterCols = ScaleARGBCols_Any_LSX;
@@ -1025,14 +927,6 @@ static void ScaleARGBSimple(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEARGBCOLS_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleARGBCols = ScaleARGBCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 4)) {
-      ScaleARGBCols = ScaleARGBCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEARGBCOLS_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     ScaleARGBCols = ScaleARGBCols_Any_LSX;

source/scale_common.cc

@@ -1667,14 +1667,6 @@ void ScalePlaneVertical(int src_height,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(dst_width_bytes, 32)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;

source/scale_uv.cc

@@ -155,23 +155,6 @@ static void ScaleUVDown2(int src_width,
   }
 #endif
 
-#if defined(HAS_SCALEUVROWDOWN2_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleUVRowDown2 =
-        filtering == kFilterNone
-            ? ScaleUVRowDown2_Any_MSA
-            : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_Any_MSA
-                                          : ScaleUVRowDown2Box_Any_MSA);
-    if (IS_ALIGNED(dst_width, 2)) {
-      ScaleUVRowDown2 =
-          filtering == kFilterNone
-              ? ScaleUVRowDown2_MSA
-              : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_MSA
-                                            : ScaleUVRowDown2Box_MSA);
-    }
-  }
-#endif
-
   if (filtering == kFilterLinear) {
     src_stride = 0;
   }
@@ -321,16 +304,6 @@ static void ScaleUVDownEven(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEUVROWDOWNEVEN_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleUVRowDownEven =
-        filtering ? ScaleUVRowDownEvenBox_Any_MSA : ScaleUVRowDownEven_Any_MSA;
-    if (IS_ALIGNED(dst_width, 4)) {
-      ScaleUVRowDownEven =
-          filtering ? ScaleUVRowDownEvenBox_MSA : ScaleUVRowDownEven_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEUVROWDOWNEVEN_RVV) || defined(HAS_SCALEUVROWDOWN4_RVV)
   if (TestCpuFlag(kCpuHasRVV) && !filtering) {
 #if defined(HAS_SCALEUVROWDOWNEVEN_RVV)
@@ -419,14 +392,6 @@ static int ScaleUVBilinearDown(int src_width,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(clip_src_width, 32)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;
@@ -452,14 +417,6 @@ static int ScaleUVBilinearDown(int src_width,
       ScaleUVFilterCols = ScaleUVFilterCols_NEON;
     }
   }
-#endif
-#if defined(HAS_SCALEUVFILTERCOLS_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleUVFilterCols = ScaleUVFilterCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 8)) {
-      ScaleUVFilterCols = ScaleUVFilterCols_MSA;
-    }
-  }
 #endif
   // TODO(fbarchard): Consider not allocating row buffer for kFilterLinear.
   // Allocate a row of UV.
@@ -545,14 +502,6 @@ static int ScaleUVBilinearUp(int src_width,
     InterpolateRow = InterpolateRow_SME;
   }
 #endif
-#if defined(HAS_INTERPOLATEROW_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    InterpolateRow = InterpolateRow_Any_MSA;
-    if (IS_ALIGNED(dst_width, 16)) {
-      InterpolateRow = InterpolateRow_MSA;
-    }
-  }
-#endif
 #if defined(HAS_INTERPOLATEROW_LSX)
   if (TestCpuFlag(kCpuHasLSX)) {
     InterpolateRow = InterpolateRow_Any_LSX;
@@ -582,14 +531,6 @@ static int ScaleUVBilinearUp(int src_width,
     }
   }
 #endif
-#if defined(HAS_SCALEUVFILTERCOLS_MSA)
-  if (filtering && TestCpuFlag(kCpuHasMSA)) {
-    ScaleUVFilterCols = ScaleUVFilterCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 16)) {
-      ScaleUVFilterCols = ScaleUVFilterCols_MSA;
-    }
-  }
-#endif
 #if defined(HAS_SCALEUVCOLS_SSSE3)
   if (!filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
     ScaleUVFilterCols = ScaleUVCols_SSSE3;
@@ -602,14 +543,6 @@ static int ScaleUVBilinearUp(int src_width,
       ScaleUVFilterCols = ScaleUVCols_NEON;
     }
   }
-#endif
-#if defined(HAS_SCALEUVCOLS_MSA)
-  if (!filtering && TestCpuFlag(kCpuHasMSA)) {
-    ScaleUVFilterCols = ScaleUVCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 8)) {
-      ScaleUVFilterCols = ScaleUVCols_MSA;
-    }
-  }
 #endif
   if (!filtering && src_width * 2 == dst_width && x < 0x8000) {
     ScaleUVFilterCols = ScaleUVColsUp2_C;
@@ -944,14 +877,6 @@ static void ScaleUVSimple(int src_width,
       ScaleUVCols = ScaleUVCols_NEON;
     }
   }
-#endif
-#if defined(HAS_SCALEUVCOLS_MSA)
-  if (TestCpuFlag(kCpuHasMSA)) {
-    ScaleUVCols = ScaleUVCols_Any_MSA;
-    if (IS_ALIGNED(dst_width, 4)) {
-      ScaleUVCols = ScaleUVCols_MSA;
-    }
-  }
 #endif
   if (src_width * 2 == dst_width && x < 0x8000) {
     ScaleUVCols = ScaleUVColsUp2_C;

unit_test/cpu_test.cc

@@ -151,15 +151,6 @@ TEST_F(LibYUVBaseTest, TestCpuHas) {
   }
 #endif  // defined(__riscv)
 
-#if defined(__mips__)
-  int has_mips = TestCpuFlag(kCpuHasMIPS);
-  if (has_mips) {
-    int has_msa = TestCpuFlag(kCpuHasMSA);
-    printf("Has MIPS 0x%x\n", has_mips);
-    printf("Has MSA 0x%x\n", has_msa);
-  }
-#endif  // defined(__mips__)
-
 #if defined(__loongarch__)
   int has_loongarch = TestCpuFlag(kCpuHasLOONGARCH);
   if (has_loongarch) {
@@ -291,18 +282,6 @@ TEST_F(LibYUVBaseTest, TestCompilerMacros) {
 #ifdef __llvm__
   printf("__llvm__ %d\n", __llvm__);
 #endif
-#ifdef __mips_msa
-  printf("__mips_msa %d\n", __mips_msa);
-#endif
-#ifdef __mips
-  printf("__mips %d\n", __mips);
-#endif
-#ifdef __mips_isa_rev
-  printf("__mips_isa_rev %d\n", __mips_isa_rev);
-#endif
-#ifdef _MIPS_ARCH_LOONGSON3A
-  printf("_MIPS_ARCH_LOONGSON3A %d\n", _MIPS_ARCH_LOONGSON3A);
-#endif
 #ifdef __loongarch__
   printf("__loongarch__ %d\n", __loongarch__);
 #endif
@@ -388,19 +367,6 @@ TEST_F(LibYUVBaseTest, TestLinuxAArch64) {
 }
 #endif
 
-TEST_F(LibYUVBaseTest, DISABLED_TestLinuxMipsMsa) {
-  if (FileExists("../../unit_test/testdata/mips.txt")) {
-    printf("Note: testing to load \"../../unit_test/testdata/mips.txt\"\n");
-
-    EXPECT_EQ(0, MipsCpuCaps("../../unit_test/testdata/mips.txt"));
-    EXPECT_EQ(kCpuHasMSA, MipsCpuCaps("../../unit_test/testdata/mips_msa.txt"));
-    EXPECT_EQ(kCpuHasMSA,
-              MipsCpuCaps("../../unit_test/testdata/mips_loongson2k.txt"));
-  } else {
-    printf("WARNING: unable to load \"../../unit_test/testdata/mips.txt\"\n");
-  }
-}
-
 TEST_F(LibYUVBaseTest, DISABLED_TestLinuxRVV) {
   if (FileExists("../../unit_test/testdata/riscv64.txt")) {
     printf("Note: testing to load \"../../unit_test/testdata/riscv64.txt\"\n");

unit_test/testdata/mips_msa.txt

@@ -1,7 +0,0 @@
-system type             : generic-loongson-machine
-machine                 : loongson,generic
-processor               : 0
-
-isa                     : mips1 mips2 mips3 mips4 mips5 mips32r1 mips32r2 mips64r1 mips64r2
-ASEs implemented        : vz msa
-shadow register sets    : 1

unit_test/unit_test.cc

@@ -90,17 +90,10 @@ static int TestCpuEnv(int cpu_info) {
     cpu_info &= ~libyuv::kCpuHasSME;
   }
 #endif
-#if defined(__mips__) && defined(__linux__)
-  if (TestEnv("LIBYUV_DISABLE_MSA")) {
-    cpu_info &= ~libyuv::kCpuHasMSA;
-  }
-#endif
 #if defined(__longarch__) && defined(__linux__)
   if (TestEnv("LIBYUV_DISABLE_LSX")) {
     cpu_info &= ~libyuv::kCpuHasLSX;
   }
-#endif
-#if defined(__longarch__) && defined(__linux__)
   if (TestEnv("LIBYUV_DISABLE_LASX")) {
     cpu_info &= ~libyuv::kCpuHasLASX;
   }

util/cpuid.c

@@ -113,15 +113,6 @@ int main(int argc, const char* argv[]) {
   }
 #endif  // defined(__riscv)
 
-#if defined(__mips__)
-  int has_mips = TestCpuFlag(kCpuHasMIPS);
-  if (has_mips) {
-    int has_msa = TestCpuFlag(kCpuHasMSA);
-    printf("Has MIPS 0x%x\n", has_mips);
-    printf("Has MSA 0x%x\n", has_msa);
-  }
-#endif  // defined(__mips__)
-
 #if defined(__loongarch__)
   int has_loongarch = TestCpuFlag(kCpuHasLOONGARCH);
   if (has_loongarch) {