Index: pjproject/trunk/third_party/yuv/source/row_neon.cc
===================================================================
--- pjproject/trunk/third_party/yuv/source/row_neon.cc	(revision 5633)
+++ pjproject/trunk/third_party/yuv/source/row_neon.cc	(revision 5699)
@@ -116,5 +116,5 @@
       YUVTORGB_SETUP
       "vmov.u8    d23, #255                      \n"
-      "1:                                          \n" READYUV444 YUVTORGB
+      "1:                                        \n" READYUV444 YUVTORGB
       "subs       %4, %4, #8                     \n"
       "vst4.8     {d20, d21, d22, d23}, [%3]!    \n"
@@ -142,5 +142,5 @@
       YUVTORGB_SETUP
       "vmov.u8    d23, #255                      \n"
-      "1:                                          \n" READYUV422 YUVTORGB
+      "1:                                        \n" READYUV422 YUVTORGB
       "subs       %4, %4, #8                     \n"
       "vst4.8     {d20, d21, d22, d23}, [%3]!    \n"
@@ -168,5 +168,5 @@
   asm volatile(
       YUVTORGB_SETUP
-      "1:                                          \n" READYUV422 YUVTORGB
+      "1:                                        \n" READYUV422 YUVTORGB
       "subs       %5, %5, #8                     \n"
       "vld1.8     {d23}, [%3]!                   \n"
@@ -195,5 +195,5 @@
   asm volatile(
       YUVTORGB_SETUP
-      "1:                                          \n" READYUV422 YUVTORGB
+      "1:                                        \n" READYUV422 YUVTORGB
       "subs       %4, %4, #8                     \n"
       "vmov.u8    d19, #255                      \n"  // d19 modified by
@@ -222,5 +222,5 @@
   asm volatile(
       YUVTORGB_SETUP
-      "1:                                          \n" READYUV422 YUVTORGB
+      "1:                                        \n" READYUV422 YUVTORGB
       "subs       %4, %4, #8                     \n"
       "vst3.8     {d20, d21, d22}, [%3]!         \n"
@@ -254,5 +254,5 @@
   asm volatile(
       YUVTORGB_SETUP
-      "1:                                          \n" READYUV422 YUVTORGB
+      "1:                                        \n" READYUV422 YUVTORGB
       "subs       %4, %4, #8                     \n" ARGBTORGB565
       "vst1.8     {q0}, [%3]!                    \n"  // store 8 pixels RGB565.
@@ -288,5 +288,5 @@
   asm volatile(
       YUVTORGB_SETUP
-      "1:                                          \n" READYUV422 YUVTORGB
+      "1:                                        \n" READYUV422 YUVTORGB
       "subs       %4, %4, #8                     \n"
       "vmov.u8    d23, #255                      \n" ARGBTOARGB1555
@@ -326,5 +326,5 @@
       "vmov.u8    d4, #0x0f                      \n"  // bits to clear with
                                                       // vbic.
-      "1:                                          \n" READYUV422 YUVTORGB
+      "1:                                        \n" READYUV422 YUVTORGB
       "subs       %4, %4, #8                     \n"
       "vmov.u8    d23, #255                      \n" ARGBTOARGB4444
@@ -349,5 +349,5 @@
       YUVTORGB_SETUP
       "vmov.u8    d23, #255                      \n"
-      "1:                                          \n" READYUV400 YUVTORGB
+      "1:                                        \n" READYUV400 YUVTORGB
       "subs       %2, %2, #8                     \n"
       "vst4.8     {d20, d21, d22, d23}, [%1]!    \n"
@@ -367,5 +367,5 @@
   asm volatile(
       "vmov.u8    d23, #255                      \n"
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {d20}, [%0]!                   \n"
       "vmov       d21, d20                       \n"
@@ -386,21 +386,20 @@
                         const struct YuvConstants* yuvconstants,
                         int width) {
-  asm volatile(
-      YUVTORGB_SETUP
-      "vmov.u8    d23, #255                      \n"
-      "1:                                          \n" READNV12 YUVTORGB
-      "subs       %3, %3, #8                     \n"
-      "vst4.8     {d20, d21, d22, d23}, [%2]!    \n"
-      "bgt        1b                             \n"
-      : "+r"(src_y),     // %0
-        "+r"(src_uv),    // %1
-        "+r"(dst_argb),  // %2
-        "+r"(width)      // %3
-      : [kUVToRB] "r"(&yuvconstants->kUVToRB),
-        [kUVToG] "r"(&yuvconstants->kUVToG),
-        [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR),
-        [kYToRgb] "r"(&yuvconstants->kYToRgb)
-      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", "q10", "q11",
-        "q12", "q13", "q14", "q15");
+  asm volatile(YUVTORGB_SETUP
+               "vmov.u8    d23, #255                      \n"
+               "1:                                        \n" READNV12 YUVTORGB
+               "subs       %3, %3, #8                     \n"
+               "vst4.8     {d20, d21, d22, d23}, [%2]!    \n"
+               "bgt        1b                             \n"
+               : "+r"(src_y),     // %0
+                 "+r"(src_uv),    // %1
+                 "+r"(dst_argb),  // %2
+                 "+r"(width)      // %3
+               : [kUVToRB] "r"(&yuvconstants->kUVToRB),
+                 [kUVToG] "r"(&yuvconstants->kUVToG),
+                 [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR),
+                 [kYToRgb] "r"(&yuvconstants->kYToRgb)
+               : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9",
+                 "q10", "q11", "q12", "q13", "q14", "q15");
 }
 
@@ -410,21 +409,20 @@
                         const struct YuvConstants* yuvconstants,
                         int width) {
-  asm volatile(
-      YUVTORGB_SETUP
-      "vmov.u8    d23, #255                      \n"
-      "1:                                          \n" READNV21 YUVTORGB
-      "subs       %3, %3, #8                     \n"
-      "vst4.8     {d20, d21, d22, d23}, [%2]!    \n"
-      "bgt        1b                             \n"
-      : "+r"(src_y),     // %0
-        "+r"(src_vu),    // %1
-        "+r"(dst_argb),  // %2
-        "+r"(width)      // %3
-      : [kUVToRB] "r"(&yuvconstants->kUVToRB),
-        [kUVToG] "r"(&yuvconstants->kUVToG),
-        [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR),
-        [kYToRgb] "r"(&yuvconstants->kYToRgb)
-      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", "q10", "q11",
-        "q12", "q13", "q14", "q15");
+  asm volatile(YUVTORGB_SETUP
+               "vmov.u8    d23, #255                      \n"
+               "1:                                        \n" READNV21 YUVTORGB
+               "subs       %3, %3, #8                     \n"
+               "vst4.8     {d20, d21, d22, d23}, [%2]!    \n"
+               "bgt        1b                             \n"
+               : "+r"(src_y),     // %0
+                 "+r"(src_vu),    // %1
+                 "+r"(dst_argb),  // %2
+                 "+r"(width)      // %3
+               : [kUVToRB] "r"(&yuvconstants->kUVToRB),
+                 [kUVToG] "r"(&yuvconstants->kUVToG),
+                 [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR),
+                 [kYToRgb] "r"(&yuvconstants->kYToRgb)
+               : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9",
+                 "q10", "q11", "q12", "q13", "q14", "q15");
 }
 
@@ -436,5 +434,5 @@
   asm volatile(
       YUVTORGB_SETUP
-      "1:                                          \n" READNV12 YUVTORGB
+      "1:                                        \n" READNV12 YUVTORGB
       "subs       %3, %3, #8                     \n" ARGBTORGB565
       "vst1.8     {q0}, [%2]!                    \n"  // store 8 pixels RGB565.
@@ -456,20 +454,19 @@
                         const struct YuvConstants* yuvconstants,
                         int width) {
-  asm volatile(
-      YUVTORGB_SETUP
-      "vmov.u8    d23, #255                      \n"
-      "1:                                          \n" READYUY2 YUVTORGB
-      "subs       %2, %2, #8                     \n"
-      "vst4.8     {d20, d21, d22, d23}, [%1]!    \n"
-      "bgt        1b                             \n"
-      : "+r"(src_yuy2),  // %0
-        "+r"(dst_argb),  // %1
-        "+r"(width)      // %2
-      : [kUVToRB] "r"(&yuvconstants->kUVToRB),
-        [kUVToG] "r"(&yuvconstants->kUVToG),
-        [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR),
-        [kYToRgb] "r"(&yuvconstants->kYToRgb)
-      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", "q10", "q11",
-        "q12", "q13", "q14", "q15");
+  asm volatile(YUVTORGB_SETUP
+               "vmov.u8    d23, #255                      \n"
+               "1:                                        \n" READYUY2 YUVTORGB
+               "subs       %2, %2, #8                     \n"
+               "vst4.8     {d20, d21, d22, d23}, [%1]!    \n"
+               "bgt        1b                             \n"
+               : "+r"(src_yuy2),  // %0
+                 "+r"(dst_argb),  // %1
+                 "+r"(width)      // %2
+               : [kUVToRB] "r"(&yuvconstants->kUVToRB),
+                 [kUVToG] "r"(&yuvconstants->kUVToG),
+                 [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR),
+                 [kYToRgb] "r"(&yuvconstants->kYToRgb)
+               : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9",
+                 "q10", "q11", "q12", "q13", "q14", "q15");
 }
 
@@ -478,20 +475,19 @@
                         const struct YuvConstants* yuvconstants,
                         int width) {
-  asm volatile(
-      YUVTORGB_SETUP
-      "vmov.u8    d23, #255                      \n"
-      "1:                                          \n" READUYVY YUVTORGB
-      "subs       %2, %2, #8                     \n"
-      "vst4.8     {d20, d21, d22, d23}, [%1]!    \n"
-      "bgt        1b                             \n"
-      : "+r"(src_uyvy),  // %0
-        "+r"(dst_argb),  // %1
-        "+r"(width)      // %2
-      : [kUVToRB] "r"(&yuvconstants->kUVToRB),
-        [kUVToG] "r"(&yuvconstants->kUVToG),
-        [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR),
-        [kYToRgb] "r"(&yuvconstants->kYToRgb)
-      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9", "q10", "q11",
-        "q12", "q13", "q14", "q15");
+  asm volatile(YUVTORGB_SETUP
+               "vmov.u8    d23, #255                      \n"
+               "1:                                        \n" READUYVY YUVTORGB
+               "subs       %2, %2, #8                     \n"
+               "vst4.8     {d20, d21, d22, d23}, [%1]!    \n"
+               "bgt        1b                             \n"
+               : "+r"(src_uyvy),  // %0
+                 "+r"(dst_argb),  // %1
+                 "+r"(width)      // %2
+               : [kUVToRB] "r"(&yuvconstants->kUVToRB),
+                 [kUVToG] "r"(&yuvconstants->kUVToG),
+                 [kUVBiasBGR] "r"(&yuvconstants->kUVBiasBGR),
+                 [kYToRgb] "r"(&yuvconstants->kYToRgb)
+               : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q8", "q9",
+                 "q10", "q11", "q12", "q13", "q14", "q15");
 }
 
@@ -502,5 +498,5 @@
                      int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld2.8     {q0, q1}, [%0]!                \n"  // load 16 pairs of UV
       "subs       %3, %3, #16                    \n"  // 16 processed per loop
@@ -523,9 +519,9 @@
                      int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load U
       "vld1.8     {q1}, [%1]!                    \n"  // load V
       "subs       %3, %3, #16                    \n"  // 16 processed per loop
-      "vst2.u8    {q0, q1}, [%2]!                \n"  // store 16 pairs of UV
+      "vst2.8     {q0, q1}, [%2]!                \n"  // store 16 pairs of UV
       "bgt        1b                             \n"
       : "+r"(src_u),                // %0
@@ -538,8 +534,58 @@
 }
 
+// Reads 16 packed RGB and write to planar dst_r, dst_g, dst_b.
+void SplitRGBRow_NEON(const uint8* src_rgb,
+                      uint8* dst_r,
+                      uint8* dst_g,
+                      uint8* dst_b,
+                      int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld3.8     {d0, d2, d4}, [%0]!            \n"  // load 8 RGB
+      "vld3.8     {d1, d3, d5}, [%0]!            \n"  // next 8 RGB
+      "subs       %4, %4, #16                    \n"  // 16 processed per loop
+      "vst1.8     {q0}, [%1]!                    \n"  // store R
+      "vst1.8     {q1}, [%2]!                    \n"  // store G
+      "vst1.8     {q2}, [%3]!                    \n"  // store B
+      "bgt        1b                             \n"
+      : "+r"(src_rgb),                    // %0
+        "+r"(dst_r),                      // %1
+        "+r"(dst_g),                      // %2
+        "+r"(dst_b),                      // %3
+        "+r"(width)                       // %4
+      :                                   // Input registers
+      : "cc", "memory", "d0", "d1", "d2"  // Clobber List
+      );
+}
+
+// Reads 16 planar R's, G's and B's and writes out 16 packed RGB at a time
+void MergeRGBRow_NEON(const uint8* src_r,
+                      const uint8* src_g,
+                      const uint8* src_b,
+                      uint8* dst_rgb,
+                      int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8     {q0}, [%0]!                    \n"  // load R
+      "vld1.8     {q1}, [%1]!                    \n"  // load G
+      "vld1.8     {q2}, [%2]!                    \n"  // load B
+      "subs       %4, %4, #16                    \n"  // 16 processed per loop
+      "vst3.8     {d0, d2, d4}, [%3]!            \n"  // store 8 RGB
+      "vst3.8     {d1, d3, d5}, [%3]!            \n"  // next 8 RGB
+      "bgt        1b                             \n"
+      : "+r"(src_r),                      // %0
+        "+r"(src_g),                      // %1
+        "+r"(src_b),                      // %2
+        "+r"(dst_rgb),                    // %3
+        "+r"(width)                       // %4
+      :                                   // Input registers
+      : "cc", "memory", "q0", "q1", "q2"  // Clobber List
+      );
+}
+
 // Copy multiple of 32.  vld4.8  allow unaligned and is fastest on a15.
 void CopyRow_NEON(const uint8* src, uint8* dst, int count) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 32
       "subs       %2, %2, #32                    \n"  // 32 processed per loop
@@ -558,5 +604,5 @@
   asm volatile(
       "vdup.8    q0, %2                          \n"  // duplicate 16 bytes
-      "1:                                          \n"
+      "1:                                        \n"
       "subs      %1, %1, #16                     \n"  // 16 bytes per loop
       "vst1.8    {q0}, [%0]!                     \n"  // store
@@ -572,5 +618,5 @@
   asm volatile(
       "vdup.u32  q0, %2                          \n"  // duplicate 4 ints
-      "1:                                          \n"
+      "1:                                        \n"
       "subs      %1, %1, #4                      \n"  // 4 pixels per loop
       "vst1.8    {q0}, [%0]!                     \n"  // store
@@ -589,5 +635,5 @@
       "sub        %0, #16                        \n"
 
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0], r3                 \n"  // src -= 16
       "subs       %2, #16                        \n"  // 16 pixels per loop.
@@ -613,5 +659,5 @@
       "sub        %0, #16                        \n"
 
-      "1:                                          \n"
+      "1:                                        \n"
       "vld2.8     {d0, d1}, [%0], r12            \n"  // src -= 16
       "subs       %3, #8                         \n"  // 8 pixels per loop.
@@ -635,5 +681,5 @@
       "sub        %0, #16                        \n"
 
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0], r3                 \n"  // src -= 16
       "subs       %2, #4                         \n"  // 4 pixels per loop.
@@ -652,5 +698,5 @@
   asm volatile(
       "vmov.u8    d4, #255                       \n"  // Alpha
-      "1:                                          \n"
+      "1:                                        \n"
       "vld3.8     {d1, d2, d3}, [%0]!            \n"  // load 8 pixels of RGB24.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -668,5 +714,5 @@
   asm volatile(
       "vmov.u8    d4, #255                       \n"  // Alpha
-      "1:                                          \n"
+      "1:                                        \n"
       "vld3.8     {d1, d2, d3}, [%0]!            \n"  // load 8 pixels of RAW.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -684,5 +730,5 @@
 void RAWToRGB24Row_NEON(const uint8* src_raw, uint8* dst_rgb24, int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld3.8     {d1, d2, d3}, [%0]!            \n"  // load 8 pixels of RAW.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -714,5 +760,5 @@
   asm volatile(
       "vmov.u8    d3, #255                       \n"  // Alpha
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 RGB565 pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -760,5 +806,5 @@
   asm volatile(
       "vmov.u8    d3, #255                       \n"  // Alpha
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB1555 pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -789,5 +835,5 @@
   asm volatile(
       "vmov.u8    d3, #255                       \n"  // Alpha
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB4444 pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -805,5 +851,5 @@
 void ARGBToRGB24Row_NEON(const uint8* src_argb, uint8* dst_rgb24, int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d1, d2, d3, d4}, [%0]!        \n"  // load 8 pixels of ARGB.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -821,5 +867,5 @@
 void ARGBToRAWRow_NEON(const uint8* src_argb, uint8* dst_raw, int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d1, d2, d3, d4}, [%0]!        \n"  // load 8 pixels of ARGB.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -837,5 +883,5 @@
 void YUY2ToYRow_NEON(const uint8* src_yuy2, uint8* dst_y, int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld2.8     {q0, q1}, [%0]!                \n"  // load 16 pixels of YUY2.
       "subs       %2, %2, #16                    \n"  // 16 processed per loop.
@@ -852,5 +898,5 @@
 void UYVYToYRow_NEON(const uint8* src_uyvy, uint8* dst_y, int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld2.8     {q0, q1}, [%0]!                \n"  // load 16 pixels of UYVY.
       "subs       %2, %2, #16                    \n"  // 16 processed per loop.
@@ -870,5 +916,5 @@
                          int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 16 pixels of YUY2.
       "subs       %3, %3, #16                    \n"  // 16 pixels = 8 UVs.
@@ -890,5 +936,5 @@
                          int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 16 pixels of UYVY.
       "subs       %3, %3, #16                    \n"  // 16 pixels = 8 UVs.
@@ -912,5 +958,5 @@
   asm volatile(
       "add        %1, %0, %1                     \n"  // stride + src_yuy2
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 16 pixels of YUY2.
       "subs       %4, %4, #16                    \n"  // 16 pixels = 8 UVs.
@@ -939,5 +985,5 @@
   asm volatile(
       "add        %1, %0, %1                     \n"  // stride + src_uyvy
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 16 pixels of UYVY.
       "subs       %4, %4, #16                    \n"  // 16 pixels = 8 UVs.
@@ -966,5 +1012,5 @@
   asm volatile(
       "vld1.8     {q2}, [%3]                     \n"  // shuffler
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 4 pixels.
       "subs       %2, %2, #4                     \n"  // 4 processed per loop
@@ -987,5 +1033,5 @@
                         int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld2.8     {d0, d2}, [%0]!                \n"  // load 16 Ys
       "vld1.8     {d1}, [%1]!                    \n"  // load 8 Us
@@ -1009,5 +1055,5 @@
                         int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld2.8     {d1, d3}, [%0]!                \n"  // load 16 Ys
       "vld1.8     {d0}, [%1]!                    \n"  // load 8 Us
@@ -1027,5 +1073,5 @@
 void ARGBToRGB565Row_NEON(const uint8* src_argb, uint8* dst_rgb565, int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d20, d21, d22, d23}, [%0]!    \n"  // load 8 pixels of ARGB.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1046,11 +1092,12 @@
   asm volatile(
       "vdup.32    d2, %2                         \n"  // dither4
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d20, d21, d22, d23}, [%1]!    \n"  // load 8 pixels of ARGB.
       "subs       %3, %3, #8                     \n"  // 8 processed per loop.
       "vqadd.u8   d20, d20, d2                   \n"
       "vqadd.u8   d21, d21, d2                   \n"
-      "vqadd.u8   d22, d22, d2                   \n" ARGBTORGB565
-      "vst1.8     {q0}, [%0]!                    \n"  // store 8 pixels RGB565.
+      "vqadd.u8   d22, d22, d2                   \n"  // add for dither
+      ARGBTORGB565
+      "vst1.8     {q0}, [%0]!                    \n"  // store 8 RGB565.
       "bgt        1b                             \n"
       : "+r"(dst_rgb)   // %0
@@ -1065,10 +1112,9 @@
                             int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d20, d21, d22, d23}, [%0]!    \n"  // load 8 pixels of ARGB.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
       ARGBTOARGB1555
-      "vst1.8     {q0}, [%1]!                    \n"  // store 8 pixels
-                                                      // ARGB1555.
+      "vst1.8     {q0}, [%1]!                    \n"  // store 8 ARGB1555.
       "bgt        1b                             \n"
       : "+r"(src_argb),      // %0
@@ -1085,10 +1131,9 @@
       "vmov.u8    d4, #0x0f                      \n"  // bits to clear with
                                                       // vbic.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d20, d21, d22, d23}, [%0]!    \n"  // load 8 pixels of ARGB.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
       ARGBTOARGB4444
-      "vst1.8     {q0}, [%1]!                    \n"  // store 8 pixels
-                                                      // ARGB4444.
+      "vst1.8     {q0}, [%1]!                    \n"  // store 8 ARGB4444.
       "bgt        1b                             \n"
       : "+r"(src_argb),      // %0
@@ -1105,5 +1150,5 @@
       "vmov.u8    d26, #33                       \n"  // R * 0.2578 coefficient
       "vmov.u8    d27, #16                       \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1124,5 +1169,5 @@
 void ARGBExtractAlphaRow_NEON(const uint8* src_argb, uint8* dst_a, int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ARGB pixels
       "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 ARGB pixels
@@ -1143,5 +1188,5 @@
       "vmov.u8    d25, #75                       \n"  // G * 0.58700 coefficient
       "vmov.u8    d26, #38                       \n"  // R * 0.29900 coefficient
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1172,5 +1217,5 @@
       "vmov.u8    d28, #94                       \n"  // VG -0.7344 coefficient
       "vmov.u16   q15, #0x8080                   \n"  // 128.5
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels.
       "subs       %3, %3, #8                     \n"  // 8 processed per loop.
@@ -1200,22 +1245,18 @@
 }
 
+// clang-format off
 // 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16.
 #define RGBTOUV(QB, QG, QR)                                                 \
-  "vmul.s16   q8, " #QB                                                     \
-  ", q10               \n" /* B                    */                       \
-  "vmls.s16   q8, " #QG                                                     \
-  ", q11               \n" /* G                    */                       \
-  "vmls.s16   q8, " #QR                                                     \
-  ", q12               \n"                       /* R                    */ \
+  "vmul.s16   q8, " #QB ", q10               \n" /* B                    */ \
+  "vmls.s16   q8, " #QG ", q11               \n" /* G                    */ \
+  "vmls.s16   q8, " #QR ", q12               \n" /* R                    */ \
   "vadd.u16   q8, q8, q15                    \n" /* +128 -> unsigned     */ \
-  "vmul.s16   q9, " #QR                                                     \
-  ", q10               \n" /* R                    */                       \
-  "vmls.s16   q9, " #QG                                                     \
-  ", q14               \n" /* G                    */                       \
-  "vmls.s16   q9, " #QB                                                     \
-  ", q13               \n"                       /* B                    */ \
+  "vmul.s16   q9, " #QR ", q10               \n" /* R                    */ \
+  "vmls.s16   q9, " #QG ", q14               \n" /* G                    */ \
+  "vmls.s16   q9, " #QB ", q13               \n" /* B                    */ \
   "vadd.u16   q9, q9, q15                    \n" /* +128 -> unsigned     */ \
   "vqshrn.u16  d0, q8, #8                    \n" /* 16 bit to 8 bit U    */ \
   "vqshrn.u16  d1, q9, #8                    \n" /* 16 bit to 8 bit V    */
+// clang-format on
 
 // TODO(fbarchard): Consider vhadd vertical, then vpaddl horizontal, avoid shr.
@@ -1233,5 +1274,5 @@
     "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
     "vmov.u16   q15, #0x8080                   \n"  // 128.5
-  "1:                                          \n"
+    "1:                                        \n"
     "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ARGB pixels.
     "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 ARGB pixels.
@@ -1279,5 +1320,5 @@
     "vmov.s16   q14, #107 / 2                  \n"  // VG -0.41869 coefficient
     "vmov.u16   q15, #0x8080                   \n"  // 128.5
-  "1:                                          \n"
+    "1:                                        \n"
     "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ARGB pixels.
     "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 ARGB pixels.
@@ -1324,5 +1365,5 @@
     "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
     "vmov.u16   q15, #0x8080                   \n"  // 128.5
-  "1:                                          \n"
+    "1:                                        \n"
     "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 BGRA pixels.
     "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 BGRA pixels.
@@ -1369,5 +1410,5 @@
     "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
     "vmov.u16   q15, #0x8080                   \n"  // 128.5
-  "1:                                          \n"
+    "1:                                        \n"
     "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ABGR pixels.
     "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 ABGR pixels.
@@ -1414,5 +1455,5 @@
     "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
     "vmov.u16   q15, #0x8080                   \n"  // 128.5
-  "1:                                          \n"
+    "1:                                        \n"
     "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 RGBA pixels.
     "vld4.8     {d1, d3, d5, d7}, [%0]!        \n"  // load next 8 RGBA pixels.
@@ -1459,5 +1500,5 @@
     "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
     "vmov.u16   q15, #0x8080                   \n"  // 128.5
-  "1:                                          \n"
+    "1:                                        \n"
     "vld3.8     {d0, d2, d4}, [%0]!            \n"  // load 8 RGB24 pixels.
     "vld3.8     {d1, d3, d5}, [%0]!            \n"  // load next 8 RGB24 pixels.
@@ -1504,5 +1545,5 @@
     "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
     "vmov.u16   q15, #0x8080                   \n"  // 128.5
-  "1:                                          \n"
+    "1:                                        \n"
     "vld3.8     {d0, d2, d4}, [%0]!            \n"  // load 8 RAW pixels.
     "vld3.8     {d1, d3, d5}, [%0]!            \n"  // load next 8 RAW pixels.
@@ -1551,5 +1592,5 @@
       "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
       "vmov.u16   q15, #0x8080                   \n"  // 128.5
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 RGB565 pixels.
       RGB565TOARGB
@@ -1617,5 +1658,5 @@
       "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
       "vmov.u16   q15, #0x8080                   \n"  // 128.5
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB1555 pixels.
       RGB555TOARGB
@@ -1683,5 +1724,5 @@
       "vmov.s16   q14, #94 / 2                   \n"  // VG -0.7344 coefficient
       "vmov.u16   q15, #0x8080                   \n"  // 128.5
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB4444 pixels.
       ARGB4444TOARGB
@@ -1740,5 +1781,5 @@
       "vmov.u8    d26, #33                       \n"  // R * 0.2578 coefficient
       "vmov.u8    d27, #16                       \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 RGB565 pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1764,5 +1805,5 @@
       "vmov.u8    d26, #33                       \n"  // R * 0.2578 coefficient
       "vmov.u8    d27, #16                       \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB1555 pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1788,5 +1829,5 @@
       "vmov.u8    d26, #33                       \n"  // R * 0.2578 coefficient
       "vmov.u8    d27, #16                       \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 8 ARGB4444 pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1812,5 +1853,5 @@
       "vmov.u8    d6, #13                        \n"  // B * 0.1016 coefficient
       "vmov.u8    d7, #16                        \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of BGRA.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1835,5 +1876,5 @@
       "vmov.u8    d6, #13                        \n"  // B * 0.1016 coefficient
       "vmov.u8    d7, #16                        \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of ABGR.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1858,5 +1899,5 @@
       "vmov.u8    d6, #33                        \n"  // R * 0.2578 coefficient
       "vmov.u8    d7, #16                        \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of RGBA.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1881,5 +1922,5 @@
       "vmov.u8    d6, #33                        \n"  // R * 0.2578 coefficient
       "vmov.u8    d7, #16                        \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld3.8     {d0, d1, d2}, [%0]!            \n"  // load 8 pixels of RGB24.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1904,5 +1945,5 @@
       "vmov.u8    d6, #13                        \n"  // B * 0.1016 coefficient
       "vmov.u8    d7, #16                        \n"  // Add 16 constant
-      "1:                                          \n"
+      "1:                                        \n"
       "vld3.8     {d0, d1, d2}, [%0]!            \n"  // load 8 pixels of RAW.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -1939,5 +1980,5 @@
       "vdup.8     d4, %4                         \n"
       // General purpose row blend.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%1]!                    \n"
       "vld1.8     {q1}, [%2]!                    \n"
@@ -1954,5 +1995,5 @@
 
       // Blend 50 / 50.
-      "50:                                         \n"
+      "50:                                       \n"
       "vld1.8     {q0}, [%1]!                    \n"
       "vld1.8     {q1}, [%2]!                    \n"
@@ -1964,5 +2005,5 @@
 
       // Blend 100 / 0 - Copy row unchanged.
-      "100:                                        \n"
+      "100:                                      \n"
       "vld1.8     {q0}, [%1]!                    \n"
       "subs       %3, %3, #16                    \n"
@@ -1970,5 +2011,5 @@
       "bgt        100b                           \n"
 
-      "99:                                         \n"
+      "99:                                       \n"
       : "+r"(dst_ptr),     // %0
         "+r"(src_ptr),     // %1
@@ -1989,5 +2030,5 @@
       "blt        89f                            \n"
       // Blend 8 pixels.
-      "8:                                          \n"
+      "8:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of ARGB0.
       "vld4.8     {d4, d5, d6, d7}, [%1]!        \n"  // load 8 pixels of ARGB1.
@@ -2007,10 +2048,10 @@
       "bge        8b                             \n"
 
-      "89:                                         \n"
+      "89:                                       \n"
       "adds       %3, #8-1                       \n"
       "blt        99f                            \n"
 
       // Blend 1 pixels.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0[0],d1[0],d2[0],d3[0]}, [%0]! \n"  // load 1 pixel ARGB0.
       "vld4.8     {d4[0],d5[0],d6[0],d7[0]}, [%1]! \n"  // load 1 pixel ARGB1.
@@ -2044,5 +2085,5 @@
   asm volatile(
       // Attenuate 8 pixels.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 pixels of ARGB.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -2076,5 +2117,5 @@
 
       // 8 pixel loop.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d2, d4, d6}, [%0]         \n"  // load 8 pixels of ARGB.
       "subs       %1, %1, #8                     \n"  // 8 processed per loop.
@@ -2117,5 +2158,5 @@
 
       // 8 pixel loop.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d20, d22, d24, d26}, [%0]!    \n"  // load 8 pixels of ARGB.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -2149,5 +2190,5 @@
       "vmov.u8    d25, #75                       \n"  // G * 0.58700 coefficient
       "vmov.u8    d26, #38                       \n"  // R * 0.29900 coefficient
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -2182,5 +2223,5 @@
       "vmov.u8    d29, #98                       \n"  // BG coefficient
       "vmov.u8    d30, #50                       \n"  // BR coefficient
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]         \n"  // load 8 ARGB pixels.
       "subs       %1, %1, #8                     \n"  // 8 processed per loop.
@@ -2218,5 +2259,5 @@
       "vmovl.s8   q1, d5                         \n"  // R,A coefficients s16.
 
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d16, d18, d20, d22}, [%0]!    \n"  // load 8 ARGB pixels.
       "subs       %2, %2, #8                     \n"  // 8 processed per loop.
@@ -2274,8 +2315,7 @@
   asm volatile(
       // 8 pixel loop.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d2, d4, d6}, [%0]!        \n"  // load 8 ARGB pixels.
       "vld4.8     {d1, d3, d5, d7}, [%1]!        \n"  // load 8 more ARGB
-                                                      // pixels.
       "subs       %3, %3, #8                     \n"  // 8 processed per loop.
       "vmull.u8   q0, d0, d1                     \n"  // multiply B
@@ -2289,5 +2329,4 @@
       "vst4.8     {d0, d1, d2, d3}, [%2]!        \n"  // store 8 ARGB pixels.
       "bgt        1b                             \n"
-
       : "+r"(src_argb0),  // %0
         "+r"(src_argb1),  // %1
@@ -2305,8 +2344,7 @@
   asm volatile(
       // 8 pixel loop.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels.
       "vld4.8     {d4, d5, d6, d7}, [%1]!        \n"  // load 8 more ARGB
-                                                      // pixels.
       "subs       %3, %3, #8                     \n"  // 8 processed per loop.
       "vqadd.u8   q0, q0, q2                     \n"  // add B, G
@@ -2314,5 +2352,4 @@
       "vst4.8     {d0, d1, d2, d3}, [%2]!        \n"  // store 8 ARGB pixels.
       "bgt        1b                             \n"
-
       : "+r"(src_argb0),  // %0
         "+r"(src_argb1),  // %1
@@ -2330,8 +2367,7 @@
   asm volatile(
       // 8 pixel loop.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld4.8     {d0, d1, d2, d3}, [%0]!        \n"  // load 8 ARGB pixels.
       "vld4.8     {d4, d5, d6, d7}, [%1]!        \n"  // load 8 more ARGB
-                                                      // pixels.
       "subs       %3, %3, #8                     \n"  // 8 processed per loop.
       "vqsub.u8   q0, q0, q2                     \n"  // subtract B, G
@@ -2339,5 +2375,4 @@
       "vst4.8     {d0, d1, d2, d3}, [%2]!        \n"  // store 8 ARGB pixels.
       "bgt        1b                             \n"
-
       : "+r"(src_argb0),  // %0
         "+r"(src_argb1),  // %1
@@ -2360,5 +2395,5 @@
       "vmov.u8    d3, #255                       \n"  // alpha
       // 8 pixel loop.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {d0}, [%0]!                    \n"  // load 8 sobelx.
       "vld1.8     {d1}, [%1]!                    \n"  // load 8 sobely.
@@ -2384,5 +2419,5 @@
   asm volatile(
       // 16 pixel loop.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q0}, [%0]!                    \n"  // load 16 sobelx.
       "vld1.8     {q1}, [%1]!                    \n"  // load 16 sobely.
@@ -2411,5 +2446,5 @@
       "vmov.u8    d3, #255                       \n"  // alpha
       // 8 pixel loop.
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {d2}, [%0]!                    \n"  // load 8 sobelx.
       "vld1.8     {d0}, [%1]!                    \n"  // load 8 sobely.
@@ -2436,5 +2471,5 @@
                     int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {d0}, [%0],%5                  \n"  // top
       "vld1.8     {d1}, [%0],%6                  \n"
@@ -2474,5 +2509,5 @@
                     int width) {
   asm volatile(
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {d0}, [%0],%4                  \n"  // left
       "vld1.8     {d1}, [%1],%4                  \n"
@@ -2506,5 +2541,5 @@
       "vdup.32    q0, %3                         \n"
 
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q1}, [%0]!                    \n"  // load 8 shorts
       "subs       %2, %2, #8                     \n"  // 8 pixels per loop
@@ -2531,5 +2566,5 @@
       "vdup.32    q0, %3                         \n"
 
-      "1:                                          \n"
+      "1:                                        \n"
       "vld1.8     {q1}, [%0]!                    \n"  // load 8 shorts
       "subs       %2, %2, #8                     \n"  // 8 pixels per loop
