Implements RGB to YV12 conversion in YASM.

media/base/yuv_convert_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "media/base/djb2.h"
+#include "media/base/simd/convert_row.h"
 #include "media/base/yuv_convert.h"
 #include "media/base/yuv_row.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Size of raw image.
 static const int kSourceWidth = 640;
 static const int kSourceHeight = 360;
 static const int kSourceYSize = kSourceWidth * kSourceHeight;
 static const int kScaledWidth = 1024;
 static const int kScaledHeight = 768;
@@ skipping 307 matching lines @@
   media::ConvertYUY2ToYUV(yuy_bytes.get(),
                           yuv_converted_bytes.get(),
                           yuv_converted_bytes.get() + kSourceYSize,
                           yuv_converted_bytes.get() + kSourceYSize * 5 / 4,
                           kSourceWidth, kSourceHeight);
 
   uint32 yuy_hash = DJB2Hash(yuv_converted_bytes.get(), kYUV12Size,
                              kDJB2HashSeed);
   EXPECT_EQ(666823187u, yuy_hash);
 }
+
+// A loop-back test that converts RGB pixels to YV12 pixels, converts the
+// converted YV12 pixels back to RGB pixels, and compare the converted RGB
+// pixels with the source RGB pixels. RGB-to-YV12 conversion discards the U and
+// V values of src[2 * k + 1] (k >= 0). We repeat the same RGB pixel twice so
+// the U and V values of src[2 * k + 1] become the same as the ones of
+// src[2 * k + 1], respectively.
+TEST(YUVConvertTest, LoopbackRGB) {
+  const int kStep = 4;
+  const int kElements = 256 / kStep;
+  const int kRowSize = kElements * kElements * kElements * 2;
+  static uint8 src[kElements][kElements][kElements][6];
+  static uint8 dst[kElements][kElements][kElements][6];
+  static uint8 y[kRowSize];
+  static uint8 u[(kRowSize + 1) / 2];
+  static uint8 v[(kRowSize + 1) / 2];
+
+  for (int r = 0; r < kElements; ++r) {
+    for (int g = 0; g < kElements; ++g) {
+      for (int b = 0; b < kElements; ++b) {
+        src[r][g][b][0] = b * kStep;
+        src[r][g][b][1] = g * kStep;
+        src[r][g][b][2] = r * kStep;
+        src[r][g][b][3] = b * kStep;
+        src[r][g][b][4] = g * kStep;
+        src[r][g][b][5] = r * kStep;
+      }
+    }
+  }
+
+  media::simd::ConvertRGBtoYUVRow(&src[0][0][0][0], y, u, v, kRowSize);
+  media::simd::ConvertYUVtoRGBRow(y, u, v, &dst[0][0][0][0], kRowSize);
+
+  for (int r = 0; r < kElements; ++r) {
+    for (int g = 0; g < kElements; ++g) {
+      for (int b = 0; b < kElements; ++b) {
+        int error = abs(src[r][g][b][0] - dst[r][g][b][0]);
+        error += abs(src[r][g][b][1] - dst[r][g][b][1]);
+        error += abs(src[r][g][b][2] - dst[r][g][b][2]);
+        EXPECT_LE(error, 4);
+      }
+    }
+  }
+}
+
+TEST(YUVConvertTest, LoopbackRGBA) {
+  const int kStep = 4;
+  const int kElements = 256 / kStep;
+  const int kRowSize = kElements * kElements * kElements * 2;
+  static uint8 src[kElements][kElements][kElements][8];
+  static uint8 dst[kElements][kElements][kElements][8];
+  static uint8 y[kRowSize];
+  static uint8 u[(kRowSize + 1) / 2];
+  static uint8 v[(kRowSize + 1) / 2];
+
+  for (int r = 0; r < kElements; ++r) {
+    for (int g = 0; g < kElements; ++g) {
+      for (int b = 0; b < kElements; ++b) {
+        src[r][g][b][0] = b * kStep;
+        src[r][g][b][1] = g * kStep;
+        src[r][g][b][2] = r * kStep;
+        src[r][g][b][3] = 255;
+        src[r][g][b][4] = b * kStep;
+        src[r][g][b][5] = g * kStep;
+        src[r][g][b][6] = r * kStep;
+        src[r][g][b][7] = 255;
+      }
+    }
+  }
+
+  media::simd::ConvertRGBAtoYUVRow(&src[0][0][0][0], y, u, v, kRowSize);
+  media::simd::ConvertYUVtoRGBARow(y, u, v, &dst[0][0][0][0], kRowSize);
+
+  for (int r = 0; r < kElements; ++r) {
+    for (int g = 0; g < kElements; ++g) {
+      for (int b = 0; b < kElements; ++b) {
+        int error = abs(src[r][g][b][0] - dst[r][g][b][0]);
+        error += abs(src[r][g][b][1] - dst[r][g][b][1]);
+        error += abs(src[r][g][b][2] - dst[r][g][b][2]);
+        EXPECT_LE(error, 4);
+      }
+    }
+  }
+}