Add MSA optimized RAW/RGB/ARGB to ARGB/Y/UV row functions

source/convert.cc

 /*
  *  Copyright 2011 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.
  */
 
@@ skipping 814 matching lines @@
                 int src_stride_rgb24,
                 uint8* dst_y,
                 int dst_stride_y,
                 uint8* dst_u,
                 int dst_stride_u,
                 uint8* dst_v,
                 int dst_stride_v,
                 int width,
                 int height) {
   int y;
-#if defined(HAS_RGB24TOYROW_NEON)
+#if (defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_MSA))
   void (*RGB24ToUVRow)(const uint8* src_rgb24, int src_stride_rgb24,
                        uint8* dst_u, uint8* dst_v, int width) = RGB24ToUVRow_C;
   void (*RGB24ToYRow)(const uint8* src_rgb24, uint8* dst_y, int width) =
       RGB24ToYRow_C;
 #else
   void (*RGB24ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int width) =
       RGB24ToARGBRow_C;
   void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, uint8* dst_u,
                       uint8* dst_v, int width) = ARGBToUVRow_C;
   void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
@@ skipping 14 matching lines @@
   if (TestCpuFlag(kCpuHasNEON)) {
     RGB24ToUVRow = RGB24ToUVRow_Any_NEON;
     RGB24ToYRow = RGB24ToYRow_Any_NEON;
     if (IS_ALIGNED(width, 8)) {
       RGB24ToYRow = RGB24ToYRow_NEON;
       if (IS_ALIGNED(width, 16)) {
         RGB24ToUVRow = RGB24ToUVRow_NEON;
       }
     }
   }
+#elif defined(HAS_RGB24TOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGB24ToUVRow = RGB24ToUVRow_Any_MSA;
+    RGB24ToYRow = RGB24ToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYRow = RGB24ToYRow_MSA;
+      RGB24ToUVRow = RGB24ToUVRow_MSA;
+    }
+  }
 // Other platforms do intermediate conversion from RGB24 to ARGB.
 #else
 #if defined(HAS_RGB24TOARGBROW_SSSE3)
   if (TestCpuFlag(kCpuHasSSSE3)) {
     RGB24ToARGBRow = RGB24ToARGBRow_Any_SSSE3;
     if (IS_ALIGNED(width, 16)) {
       RGB24ToARGBRow = RGB24ToARGBRow_SSSE3;
     }
   }
 #endif
@@ skipping 17 matching lines @@
     }
   }
 #endif
   {
     // Allocate 2 rows of ARGB.
     const int kRowSize = (width * 4 + 31) & ~31;
     align_buffer_64(row, kRowSize * 2);
 #endif
 
   for (y = 0; y < height - 1; y += 2) {
-#if defined(HAS_RGB24TOYROW_NEON)
+#if (defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_MSA))
     RGB24ToUVRow(src_rgb24, src_stride_rgb24, dst_u, dst_v, width);
     RGB24ToYRow(src_rgb24, dst_y, width);
     RGB24ToYRow(src_rgb24 + src_stride_rgb24, dst_y + dst_stride_y, width);
 #else
-      RGB24ToARGBRow(src_rgb24, row, width);
-      RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + kRowSize, width);
-      ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
-      ARGBToYRow(row, dst_y, width);
-      ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+    RGB24ToARGBRow(src_rgb24, row, width);
+    RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + kRowSize, width);
+    ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+    ARGBToYRow(row, dst_y, width);
+    ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
 #endif
     src_rgb24 += src_stride_rgb24 * 2;
     dst_y += dst_stride_y * 2;
     dst_u += dst_stride_u;
     dst_v += dst_stride_v;
   }
   if (height & 1) {
-#if defined(HAS_RGB24TOYROW_NEON)
+#if (defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_MSA))
     RGB24ToUVRow(src_rgb24, 0, dst_u, dst_v, width);
     RGB24ToYRow(src_rgb24, dst_y, width);
 #else
-      RGB24ToARGBRow(src_rgb24, row, width);
-      ARGBToUVRow(row, 0, dst_u, dst_v, width);
-      ARGBToYRow(row, dst_y, width);
+    RGB24ToARGBRow(src_rgb24, row, width);
+    ARGBToUVRow(row, 0, dst_u, dst_v, width);
+    ARGBToYRow(row, dst_y, width);
 #endif
   }
-#if !defined(HAS_RGB24TOYROW_NEON)
+#if !(defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_MSA))
   free_aligned_buffer_64(row);
 }
 #endif
 return 0;
 }
 
 // Convert RAW to I420.
 LIBYUV_API
 int RAWToI420(const uint8* src_raw,
               int src_stride_raw,
               uint8* dst_y,
               int dst_stride_y,
               uint8* dst_u,
               int dst_stride_u,
               uint8* dst_v,
               int dst_stride_v,
               int width,
               int height) {
   int y;
-#if defined(HAS_RAWTOYROW_NEON)
+#if (defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_MSA))
   void (*RAWToUVRow)(const uint8* src_raw, int src_stride_raw, uint8* dst_u,
                      uint8* dst_v, int width) = RAWToUVRow_C;
   void (*RAWToYRow)(const uint8* src_raw, uint8* dst_y, int width) =
       RAWToYRow_C;
 #else
-    void (*RAWToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int width) =
-        RAWToARGBRow_C;
-    void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb,
-                        uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C;
-    void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
-        ARGBToYRow_C;
+  void (*RAWToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int width) =
+      RAWToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, uint8* dst_u,
+                      uint8* dst_v, int width) = ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
+      ARGBToYRow_C;
 #endif
   if (!src_raw || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
     return -1;
   }
   // Negative height means invert the image.
   if (height < 0) {
     height = -height;
     src_raw = src_raw + (height - 1) * src_stride_raw;
     src_stride_raw = -src_stride_raw;
   }
 
 // Neon version does direct RAW to YUV.
 #if defined(HAS_RAWTOYROW_NEON)
   if (TestCpuFlag(kCpuHasNEON)) {
     RAWToUVRow = RAWToUVRow_Any_NEON;
     RAWToYRow = RAWToYRow_Any_NEON;
     if (IS_ALIGNED(width, 8)) {
       RAWToYRow = RAWToYRow_NEON;
       if (IS_ALIGNED(width, 16)) {
         RAWToUVRow = RAWToUVRow_NEON;
       }
     }
   }
+#elif defined(HAS_RAWTOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RAWToUVRow = RAWToUVRow_Any_MSA;
+    RAWToYRow = RAWToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYRow = RAWToYRow_MSA;
+      RAWToUVRow = RAWToUVRow_MSA;
+    }
+  }
 // Other platforms do intermediate conversion from RAW to ARGB.
 #else
 #if defined(HAS_RAWTOARGBROW_SSSE3)
     if (TestCpuFlag(kCpuHasSSSE3)) {
       RAWToARGBRow = RAWToARGBRow_Any_SSSE3;
       if (IS_ALIGNED(width, 16)) {
         RAWToARGBRow = RAWToARGBRow_SSSE3;
       }
     }
 #endif
@@ skipping 17 matching lines @@
       }
     }
 #endif
     {
       // Allocate 2 rows of ARGB.
       const int kRowSize = (width * 4 + 31) & ~31;
       align_buffer_64(row, kRowSize * 2);
 #endif
 
   for (y = 0; y < height - 1; y += 2) {
-#if defined(HAS_RAWTOYROW_NEON)
+#if (defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_MSA))
     RAWToUVRow(src_raw, src_stride_raw, dst_u, dst_v, width);
     RAWToYRow(src_raw, dst_y, width);
     RAWToYRow(src_raw + src_stride_raw, dst_y + dst_stride_y, width);
 #else
-        RAWToARGBRow(src_raw, row, width);
-        RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width);
-        ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
-        ARGBToYRow(row, dst_y, width);
-        ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+    RAWToARGBRow(src_raw, row, width);
+    RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width);
+    ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+    ARGBToYRow(row, dst_y, width);
+    ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
 #endif
     src_raw += src_stride_raw * 2;
     dst_y += dst_stride_y * 2;
     dst_u += dst_stride_u;
     dst_v += dst_stride_v;
   }
   if (height & 1) {
-#if defined(HAS_RAWTOYROW_NEON)
+#if (defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_MSA))
     RAWToUVRow(src_raw, 0, dst_u, dst_v, width);
     RAWToYRow(src_raw, dst_y, width);
 #else
-        RAWToARGBRow(src_raw, row, width);
-        ARGBToUVRow(row, 0, dst_u, dst_v, width);
-        ARGBToYRow(row, dst_y, width);
+    RAWToARGBRow(src_raw, row, width);
+    ARGBToUVRow(row, 0, dst_u, dst_v, width);
+    ARGBToYRow(row, dst_y, width);
 #endif
   }
-#if !defined(HAS_RAWTOYROW_NEON)
+#if !(defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_MSA))
   free_aligned_buffer_64(row);
 }
 #endif
 return 0;
 }
 
 // Convert RGB565 to I420.
 LIBYUV_API
 int RGB565ToI420(const uint8* src_rgb565,
                  int src_stride_rgb565,
                  uint8* dst_y,
                  int dst_stride_y,
                  uint8* dst_u,
                  int dst_stride_u,
                  uint8* dst_v,
                  int dst_stride_v,
                  int width,
                  int height) {
   int y;
-#if defined(HAS_RGB565TOYROW_NEON)
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA))
   void (*RGB565ToUVRow)(const uint8* src_rgb565, int src_stride_rgb565,
                         uint8* dst_u, uint8* dst_v, int width) =
       RGB565ToUVRow_C;
   void (*RGB565ToYRow)(const uint8* src_rgb565, uint8* dst_y, int width) =
       RGB565ToYRow_C;
 #else
-      void (*RGB565ToARGBRow)(const uint8* src_rgb, uint8* dst_argb,
-                              int width) = RGB565ToARGBRow_C;
-      void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb,
-                          uint8* dst_u, uint8* dst_v, int width) =
-          ARGBToUVRow_C;
-      void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
-          ARGBToYRow_C;
+  void (*RGB565ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int width) =
+      RGB565ToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, uint8* dst_u,
+                      uint8* dst_v, int width) = ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
+      ARGBToYRow_C;
 #endif
   if (!src_rgb565 || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
     return -1;
   }
   // Negative height means invert the image.
   if (height < 0) {
     height = -height;
     src_rgb565 = src_rgb565 + (height - 1) * src_stride_rgb565;
     src_stride_rgb565 = -src_stride_rgb565;
   }
 
 // Neon version does direct RGB565 to YUV.
 #if defined(HAS_RGB565TOYROW_NEON)
   if (TestCpuFlag(kCpuHasNEON)) {
     RGB565ToUVRow = RGB565ToUVRow_Any_NEON;
     RGB565ToYRow = RGB565ToYRow_Any_NEON;
     if (IS_ALIGNED(width, 8)) {
       RGB565ToYRow = RGB565ToYRow_NEON;
       if (IS_ALIGNED(width, 16)) {
         RGB565ToUVRow = RGB565ToUVRow_NEON;
       }
     }
   }
+#elif defined(HAS_RGB565TOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGB565ToUVRow = RGB565ToUVRow_Any_MSA;
+    RGB565ToYRow = RGB565ToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGB565ToYRow = RGB565ToYRow_MSA;
+      RGB565ToUVRow = RGB565ToUVRow_MSA;
+    }
+  }
 // Other platforms do intermediate conversion from RGB565 to ARGB.
 #else
 #if defined(HAS_RGB565TOARGBROW_SSE2)
       if (TestCpuFlag(kCpuHasSSE2)) {
         RGB565ToARGBRow = RGB565ToARGBRow_Any_SSE2;
         if (IS_ALIGNED(width, 8)) {
           RGB565ToARGBRow = RGB565ToARGBRow_SSE2;
         }
       }
 #endif
@@ skipping 25 matching lines @@
         }
       }
 #endif
       {
         // Allocate 2 rows of ARGB.
         const int kRowSize = (width * 4 + 31) & ~31;
         align_buffer_64(row, kRowSize * 2);
 #endif
 
   for (y = 0; y < height - 1; y += 2) {
-#if defined(HAS_RGB565TOYROW_NEON)
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA))
     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);
 #else
-          RGB565ToARGBRow(src_rgb565, row, width);
-          RGB565ToARGBRow(src_rgb565 + src_stride_rgb565, row + kRowSize,
-                          width);
-          ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
-          ARGBToYRow(row, dst_y, width);
-          ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+    RGB565ToARGBRow(src_rgb565, row, width);
+    RGB565ToARGBRow(src_rgb565 + src_stride_rgb565, row + kRowSize, width);
+    ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+    ARGBToYRow(row, dst_y, width);
+    ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
 #endif
     src_rgb565 += src_stride_rgb565 * 2;
     dst_y += dst_stride_y * 2;
     dst_u += dst_stride_u;
     dst_v += dst_stride_v;
   }
   if (height & 1) {
-#if defined(HAS_RGB565TOYROW_NEON)
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA))
     RGB565ToUVRow(src_rgb565, 0, dst_u, dst_v, width);
     RGB565ToYRow(src_rgb565, dst_y, width);
 #else
-          RGB565ToARGBRow(src_rgb565, row, width);
-          ARGBToUVRow(row, 0, dst_u, dst_v, width);
-          ARGBToYRow(row, dst_y, width);
+    RGB565ToARGBRow(src_rgb565, row, width);
+    ARGBToUVRow(row, 0, dst_u, dst_v, width);
+    ARGBToYRow(row, dst_y, width);
 #endif
   }
-#if !defined(HAS_RGB565TOYROW_NEON)
+#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA))
   free_aligned_buffer_64(row);
 }
 #endif
 return 0;
 }
 
 // Convert ARGB1555 to I420.
 LIBYUV_API
 int ARGB1555ToI420(const uint8* src_argb1555,
                    int src_stride_argb1555,
                    uint8* dst_y,
                    int dst_stride_y,
                    uint8* dst_u,
                    int dst_stride_u,
                    uint8* dst_v,
                    int dst_stride_v,
                    int width,
                    int height) {
   int y;
-#if defined(HAS_ARGB1555TOYROW_NEON)
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA))
   void (*ARGB1555ToUVRow)(const uint8* src_argb1555, int src_stride_argb1555,
                           uint8* dst_u, uint8* dst_v, int width) =
       ARGB1555ToUVRow_C;
   void (*ARGB1555ToYRow)(const uint8* src_argb1555, uint8* dst_y, int width) =
       ARGB1555ToYRow_C;
 #else
-        void (*ARGB1555ToARGBRow)(const uint8* src_rgb, uint8* dst_argb,
-                                  int width) = ARGB1555ToARGBRow_C;
-        void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb,
-                            uint8* dst_u, uint8* dst_v, int width) =
-            ARGBToUVRow_C;
-        void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
-            ARGBToYRow_C;
+  void (*ARGB1555ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int width) =
+      ARGB1555ToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, uint8* dst_u,
+                      uint8* dst_v, int width) = ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
+      ARGBToYRow_C;
 #endif
   if (!src_argb1555 || !dst_y || !dst_u || !dst_v || width <= 0 ||
       height == 0) {
     return -1;
   }
   // Negative height means invert the image.
   if (height < 0) {
     height = -height;
     src_argb1555 = src_argb1555 + (height - 1) * src_stride_argb1555;
     src_stride_argb1555 = -src_stride_argb1555;
   }
 
 // Neon version does direct ARGB1555 to YUV.
 #if defined(HAS_ARGB1555TOYROW_NEON)
   if (TestCpuFlag(kCpuHasNEON)) {
     ARGB1555ToUVRow = ARGB1555ToUVRow_Any_NEON;
     ARGB1555ToYRow = ARGB1555ToYRow_Any_NEON;
     if (IS_ALIGNED(width, 8)) {
       ARGB1555ToYRow = ARGB1555ToYRow_NEON;
       if (IS_ALIGNED(width, 16)) {
         ARGB1555ToUVRow = ARGB1555ToUVRow_NEON;
       }
     }
   }
+#elif defined(HAS_ARGB1555TOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGB1555ToUVRow = ARGB1555ToUVRow_Any_MSA;
+    ARGB1555ToYRow = ARGB1555ToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB1555ToYRow = ARGB1555ToYRow_MSA;
+      ARGB1555ToUVRow = ARGB1555ToUVRow_MSA;
+    }
+  }
 // Other platforms do intermediate conversion from ARGB1555 to ARGB.
 #else
 #if defined(HAS_ARGB1555TOARGBROW_SSE2)
         if (TestCpuFlag(kCpuHasSSE2)) {
           ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_SSE2;
           if (IS_ALIGNED(width, 8)) {
             ARGB1555ToARGBRow = ARGB1555ToARGBRow_SSE2;
           }
         }
 #endif
@@ skipping 25 matching lines @@
           }
         }
 #endif
         {
           // Allocate 2 rows of ARGB.
           const int kRowSize = (width * 4 + 31) & ~31;
           align_buffer_64(row, kRowSize * 2);
 #endif
 
   for (y = 0; y < height - 1; y += 2) {
-#if defined(HAS_ARGB1555TOYROW_NEON)
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA))
     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,
                    width);
 #else
-            ARGB1555ToARGBRow(src_argb1555, row, width);
-            ARGB1555ToARGBRow(src_argb1555 + src_stride_argb1555,
-                              row + kRowSize, width);
-            ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
-            ARGBToYRow(row, dst_y, width);
-            ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+    ARGB1555ToARGBRow(src_argb1555, row, width);
+    ARGB1555ToARGBRow(src_argb1555 + src_stride_argb1555, row + kRowSize,
+                      width);
+    ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+    ARGBToYRow(row, dst_y, width);
+    ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
 #endif
     src_argb1555 += src_stride_argb1555 * 2;
     dst_y += dst_stride_y * 2;
     dst_u += dst_stride_u;
     dst_v += dst_stride_v;
   }
   if (height & 1) {
-#if defined(HAS_ARGB1555TOYROW_NEON)
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA))
     ARGB1555ToUVRow(src_argb1555, 0, dst_u, dst_v, width);
     ARGB1555ToYRow(src_argb1555, dst_y, width);
 #else
-            ARGB1555ToARGBRow(src_argb1555, row, width);
-            ARGBToUVRow(row, 0, dst_u, dst_v, width);
-            ARGBToYRow(row, dst_y, width);
+    ARGB1555ToARGBRow(src_argb1555, row, width);
+    ARGBToUVRow(row, 0, dst_u, dst_v, width);
+    ARGBToYRow(row, dst_y, width);
 #endif
   }
-#if !defined(HAS_ARGB1555TOYROW_NEON)
+#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA))
   free_aligned_buffer_64(row);
 }
 #endif
 return 0;
 }
 
 // Convert ARGB4444 to I420.
 LIBYUV_API
 int ARGB4444ToI420(const uint8* src_argb4444,
                    int src_stride_argb4444,
                    uint8* dst_y,
                    int dst_stride_y,
                    uint8* dst_u,
                    int dst_stride_u,
                    uint8* dst_v,
                    int dst_stride_v,
                    int width,
                    int height) {
   int y;
 #if defined(HAS_ARGB4444TOYROW_NEON)
   void (*ARGB4444ToUVRow)(const uint8* src_argb4444, int src_stride_argb4444,
                           uint8* dst_u, uint8* dst_v, int width) =
       ARGB4444ToUVRow_C;
   void (*ARGB4444ToYRow)(const uint8* src_argb4444, uint8* dst_y, int width) =
       ARGB4444ToYRow_C;
 #else
-          void (*ARGB4444ToARGBRow)(const uint8* src_rgb, uint8* dst_argb,
-                                    int width) = ARGB4444ToARGBRow_C;
-          void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb,
-                              uint8* dst_u, uint8* dst_v, int width) =
-              ARGBToUVRow_C;
-          void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
-              ARGBToYRow_C;
+  void (*ARGB4444ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int width) =
+      ARGB4444ToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, uint8* dst_u,
+                      uint8* dst_v, int width) = ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
+      ARGBToYRow_C;
 #endif
   if (!src_argb4444 || !dst_y || !dst_u || !dst_v || width <= 0 ||
       height == 0) {
     return -1;
   }
   // Negative height means invert the image.
   if (height < 0) {
     height = -height;
     src_argb4444 = src_argb4444 + (height - 1) * src_stride_argb4444;
     src_stride_argb4444 = -src_stride_argb4444;
   }
 
 // Neon version does direct ARGB4444 to YUV.
 #if defined(HAS_ARGB4444TOYROW_NEON)
   if (TestCpuFlag(kCpuHasNEON)) {
     ARGB4444ToUVRow = ARGB4444ToUVRow_Any_NEON;
     ARGB4444ToYRow = ARGB4444ToYRow_Any_NEON;
     if (IS_ALIGNED(width, 8)) {
       ARGB4444ToYRow = ARGB4444ToYRow_NEON;
       if (IS_ALIGNED(width, 16)) {
         ARGB4444ToUVRow = ARGB4444ToUVRow_NEON;
       }
     }
   }
 // Other platforms do intermediate conversion from ARGB4444 to ARGB.
 #else
 #if defined(HAS_ARGB4444TOARGBROW_SSE2)
-          if (TestCpuFlag(kCpuHasSSE2)) {
-            ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_SSE2;
-            if (IS_ALIGNED(width, 8)) {
-              ARGB4444ToARGBRow = ARGB4444ToARGBRow_SSE2;
-            }
-          }
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_SSE2;
+    }
+  }
 #endif
 #if defined(HAS_ARGB4444TOARGBROW_AVX2)
-          if (TestCpuFlag(kCpuHasAVX2)) {
-            ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_AVX2;
-            if (IS_ALIGNED(width, 16)) {
-              ARGB4444ToARGBRow = ARGB4444ToARGBRow_AVX2;
-            }
-          }
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_AVX2;
+    }
+  }
 #endif
 #if defined(HAS_ARGB4444TOARGBROW_MSA)
-          if (TestCpuFlag(kCpuHasMSA)) {
-            ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_MSA;
-            if (IS_ALIGNED(width, 16)) {
-              ARGB4444ToARGBRow = ARGB4444ToARGBRow_MSA;
-            }
-          }
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_MSA;
+    }
+  }
 #endif
 #if defined(HAS_ARGBTOYROW_SSSE3) && defined(HAS_ARGBTOUVROW_SSSE3)
-          if (TestCpuFlag(kCpuHasSSSE3)) {
-            ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
-            ARGBToYRow = ARGBToYRow_Any_SSSE3;
-            if (IS_ALIGNED(width, 16)) {
-              ARGBToUVRow = ARGBToUVRow_SSSE3;
-              ARGBToYRow = ARGBToYRow_SSSE3;
-            }
-          }
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
 #endif
 #if defined(HAS_ARGBTOYROW_AVX2) && defined(HAS_ARGBTOUVROW_AVX2)
-          if (TestCpuFlag(kCpuHasAVX2)) {
-            ARGBToUVRow = ARGBToUVRow_Any_AVX2;
-            ARGBToYRow = ARGBToYRow_Any_AVX2;
-            if (IS_ALIGNED(width, 32)) {
-              ARGBToUVRow = ARGBToUVRow_AVX2;
-              ARGBToYRow = ARGBToYRow_AVX2;
-            }
-          }
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
 #endif
 #if defined(HAS_ARGBTOYROW_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;
-              }
-            }
-          }
+  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
-          {
-            // Allocate 2 rows of ARGB.
-            const int kRowSize = (width * 4 + 31) & ~31;
-            align_buffer_64(row, kRowSize * 2);
+  {
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
 #endif
 
   for (y = 0; y < height - 1; y += 2) {
 #if defined(HAS_ARGB4444TOYROW_NEON)
     ARGB4444ToUVRow(src_argb4444, src_stride_argb4444, dst_u, dst_v, width);
     ARGB4444ToYRow(src_argb4444, dst_y, width);
     ARGB4444ToYRow(src_argb4444 + src_stride_argb4444, dst_y + dst_stride_y,
                    width);
 #else
-              ARGB4444ToARGBRow(src_argb4444, row, width);
-              ARGB4444ToARGBRow(src_argb4444 + src_stride_argb4444,
-                                row + kRowSize, width);
-              ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
-              ARGBToYRow(row, dst_y, width);
-              ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+      ARGB4444ToARGBRow(src_argb4444, row, width);
+      ARGB4444ToARGBRow(src_argb4444 + src_stride_argb4444, row + kRowSize,
+                        width);
+      ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+      ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
 #endif
     src_argb4444 += src_stride_argb4444 * 2;
     dst_y += dst_stride_y * 2;
     dst_u += dst_stride_u;
     dst_v += dst_stride_v;
   }
   if (height & 1) {
 #if defined(HAS_ARGB4444TOYROW_NEON)
     ARGB4444ToUVRow(src_argb4444, 0, dst_u, dst_v, width);
     ARGB4444ToYRow(src_argb4444, dst_y, width);
 #else
-              ARGB4444ToARGBRow(src_argb4444, row, width);
-              ARGBToUVRow(row, 0, dst_u, dst_v, width);
-              ARGBToYRow(row, dst_y, width);
+      ARGB4444ToARGBRow(src_argb4444, row, width);
+      ARGBToUVRow(row, 0, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
 #endif
   }
 #if !defined(HAS_ARGB4444TOYROW_NEON)
   free_aligned_buffer_64(row);
 }
 #endif
 return 0;
 }
 
 static void SplitPixels(const uint8* src_u,
@@ skipping 75 matching lines @@
     dst_u += dst_stride_u;
     dst_v += dst_stride_v;
   }
   return 0;
 }
 
 #ifdef __cplusplus
 }  // extern "C"
 }  // namespace libyuv
 #endif