Add MSA optimized YUY2ToI422, YUY2ToI420, UYVYToI422, UYVYToI420 functions

source/row_msa.cc

 /*
  *  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.
  */
 
@@ skipping 83 matching lines @@
     ILVRL_B2_UB(src_y0, vec_uv0, dst_uyvy0, dst_uyvy1);
     ILVRL_B2_UB(src_y1, vec_uv1, dst_uyvy2, dst_uyvy3);
     ST_UB4(dst_uyvy0, dst_uyvy1, dst_uyvy2, dst_uyvy3, dst_uyvy, 16);
     src_u += 16;
     src_v += 16;
     src_y += 32;
     dst_uyvy += 64;
   }
 }
 
+void YUY2ToYRow_MSA(const uint8* src_yuy2, uint8* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < width; x += 64) {

[fbarchard1, 2016/10/05 22:03:58]

suggest 32 at a time... or 16.  4 of everything requires a lot of alignment (any
will be used more) and code size/icache goes up, hurting performance.
On many cpus, too many of 1 instruction causes execution unittest to saturate. 
e.g. you can often do 2 of the same instruction, but few cpus have 4 execution
units that can run in parallel for the same instruction.  2 of everything is
usually a good compromise.

[manojkumar.bhosale, 2016/10/07 10:42:09]

We have done loop unrolling considering the load latency of 8-10 cycles and to
avoid un-necessary stalls. However, agreed that any will be used more impacting
performance so processing 32 at a time will be a good compromise. Modified for
32.

+    LD_UB8(src_yuy2, 16, src0, src1, src2, src3, src4, src5, src6, src7);
+    PCKEV_B4_UB(src1, src0, src3, src2, src5, src4, src7, src6,
+                dst0, dst1, dst2, dst3);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_y, 16);
+    src_yuy2 += 128;
+    dst_y += 64;

[fbarchard1, 2016/10/05 22:03:58]

this is unrolled quite alot.  other platforms are doing 16 pixels?

[manojkumar.bhosale, 2016/10/07 10:42:09]

Done.

+  }
+}
+
+void YUY2ToUVRow_MSA(const uint8* src_yuy2, int src_stride_yuy2,
+                     uint8* dst_u, uint8* dst_v, int width) {
+  const uint8* nxt = src_yuy2 + src_stride_yuy2;
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 vec0, vec1, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    LD_UB4(src_yuy2, 16, src0, src1, src2, src3);
+    LD_UB4(nxt, 16, src4, src5, src6, src7);
+    PCKOD_B4_UB(src1, src0, src3, src2, src5, src4, src7, src6,
+                src0, src1, src2, src3);
+    AVER_UB2_UB(src0, src2, src1, src3, vec0, vec1);
+    dst0 = (v16u8) __msa_pckev_b((v16i8) vec1, (v16i8) vec0);

[fbarchard1, 2016/10/05 22:03:58]

style nit - i like seeing the intrinisics (or inline asm) used directly and
would prefer avoid the macros, except for large blocks of reusable code, such as
YUVToRGB

[manojkumar.bhosale, 2016/10/07 10:42:09]

Acknowledged.

+    dst1 = (v16u8) __msa_pckod_b((v16i8) vec1, (v16i8) vec0);
+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    src_yuy2 += 64;
+    nxt += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void YUY2ToUV422Row_MSA(const uint8* src_yuy2, uint8* dst_u, uint8* dst_v,

[fbarchard1, 2016/10/05 22:03:58]

prefer this be same as YUY2TToUV and do 32 at a time.
Code should be almost the same, but with averaging removed.

[manojkumar.bhosale, 2016/10/07 10:42:09]

Done.

+                        int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < width; x += 64) {
+    LD_UB8(src_yuy2, 16, src0, src1, src2, src3, src4, src5, src6, src7);
+    PCKOD_B4_UB(src1, src0, src3, src2, src5, src4, src7, src6,
+                src0, src1, src2, src3);
+    PCKEV_B2_UB(src1, src0, src3, src2, dst0, dst1);
+    PCKOD_B2_UB(src1, src0, src3, src2, dst2, dst3);
+    ST_UB2(dst0, dst1, dst_u, 16);
+    ST_UB2(dst2, dst3, dst_v, 16);
+    src_yuy2 += 128;
+    dst_u += 32;
+    dst_v += 32;
+  }
+}
+
+void UYVYToYRow_MSA(const uint8* src_uyvy, uint8* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < width; x += 64) {
+    LD_UB8(src_uyvy, 16, src0, src1, src2, src3, src4, src5, src6, src7);
+    PCKOD_B4_UB(src1, src0, src3, src2, src5, src4, src7, src6,
+                dst0, dst1, dst2, dst3);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_y, 16);
+    src_uyvy += 128;
+    dst_y += 64;
+  }
+}
+
+void UYVYToUVRow_MSA(const uint8* src_uyvy, int src_stride_uyvy,
+                     uint8* dst_u, uint8* dst_v, int width) {
+  const uint8 *nxt = src_uyvy + src_stride_uyvy;
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 vec0, vec1, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    LD_UB4(src_uyvy, 16, src0, src1, src2, src3);
+    LD_UB4(nxt, 16, src4, src5, src6, src7);
+    PCKEV_B4_UB(src1, src0, src3, src2, src5, src4, src7, src6,
+                src0, src1, src2, src3);
+    AVER_UB2_UB(src0, src2, src1, src3, vec0, vec1);
+    dst0 = (v16u8) __msa_pckev_b((v16i8) vec1, (v16i8) vec0);
+    dst1 = (v16u8) __msa_pckod_b((v16i8) vec1, (v16i8) vec0);

[fbarchard1, 2016/10/05 22:03:58]

the i8 version of vectors seems to be preferred?  use those types instead to
reduce casting?

[manojkumar.bhosale, 2016/10/07 10:42:09]

As we are operating on pixel data (u8), we have used all u8 vector types. The i8
version of vectors can be used but then all the intrinsic have to be used for i8
operations except aver as it is sign dependent intrinsic and then it will need
u8 casting.

The type casting here can be removed using -flax-vector-conversions gcc flag
however we have avoided its use as per gcc recommendation at below link,
https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html

Considering pckev_b/od_b intrinsic currently accepting i8 operands & returning
i8 result, keeping the casting as is.

+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    src_uyvy += 64;
+    nxt += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void UYVYToUV422Row_MSA(const uint8* src_uyvy, uint8* dst_u, uint8* dst_v,
+                        int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < width; x += 64) {
+    LD_UB8(src_uyvy, 16, src0, src1, src2, src3, src4, src5, src6, src7);
+    PCKEV_B4_UB(src1, src0, src3, src2, src5, src4, src7, src6,
+                src0, src1, src2, src3);
+    PCKEV_B2_UB(src1, src0, src3, src2, dst0, dst1);
+    PCKOD_B2_UB(src1, src0, src3, src2, dst2, dst3);
+    ST_UB2(dst0, dst1, dst_u, 16);
+    ST_UB2(dst2, dst3, dst_v, 16);
+    src_uyvy += 128;
+    dst_u += 32;
+    dst_v += 32;
+  }
+}
+
 #ifdef __cplusplus
 }  // extern "C"
 }  // namespace libyuv
 #endif
 
 #endif  // !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)