Fix crash and off-by-one error in MMX YUVA->ARGB conversion.

media/base/yuv_convert_unittest.cc

 // Copyright (c) 2012 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/cpu.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "media/base/djb2.h"
@@ skipping 19 matching lines @@
 
 // Surface sizes for various test files.
 static const int kYUV12Size = kSourceYSize * 12 / 8;
 static const int kYUV16Size = kSourceYSize * 16 / 8;
 static const int kYUY2Size =  kSourceYSize * 16 / 8;
 static const int kRGBSize = kSourceYSize * kBpp;
 static const int kRGBSizeScaled = kScaledWidth * kScaledHeight * kBpp;
 static const int kRGB24Size = kSourceYSize * 3;
 static const int kRGBSizeConverted = kSourceYSize * kBpp;
 
+#if !defined(ARCH_CPU_ARM_FAMILY) && !defined(ARCH_CPU_MIPS_FAMILY)
+static const int kSourceAOffset = kSourceYSize * 12 / 8;
+static const int kYUVA12Size = kSourceYSize * 20 / 8;
+#endif
+
 // Helper for reading test data into a scoped_ptr<uint8[]>.
 static void ReadData(const base::FilePath::CharType* filename,
                      int expected_size,
                      scoped_ptr<uint8[]>* data) {
   data->reset(new uint8[expected_size]);
 
   base::FilePath path;
   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &path));
   path = path.Append(FILE_PATH_LITERAL("media"))
              .Append(FILE_PATH_LITERAL("test"))
@@ skipping 12 matching lines @@
 }
 
 static void ReadYV12Data(scoped_ptr<uint8[]>* data) {
   ReadData(FILE_PATH_LITERAL("bali_640x360_P420.yuv"), kYUV12Size, data);
 }
 
 static void ReadYV16Data(scoped_ptr<uint8[]>* data) {
   ReadData(FILE_PATH_LITERAL("bali_640x360_P422.yuv"), kYUV16Size, data);
 }
 
+#if !defined(ARCH_CPU_ARM_FAMILY) && !defined(ARCH_CPU_MIPS_FAMILY)
+static void ReadYV12AData(scoped_ptr<uint8[]>* data) {
+  ReadData(FILE_PATH_LITERAL("bali_640x360_P420_alpha.yuv"), kYUVA12Size, data);
+}
+#endif
+
 static void ReadRGB24Data(scoped_ptr<uint8[]>* data) {
   ReadData(FILE_PATH_LITERAL("bali_640x360_RGB24.rgb"), kRGB24Size, data);
 }
 
 static void ReadYUY2Data(scoped_ptr<uint8[]>* data) {
   ReadData(FILE_PATH_LITERAL("bali_640x360_YUY2.yuv"), kYUY2Size, data);
 }
 
 #if defined(OS_ANDROID)
 // Helper for swapping red and blue channels of RGBA or BGRA.
@@ skipping 428 matching lines @@
       sub_rect.set_x(sub_rect.x() + sub_rect.width() / 2);
     if (next_sub_rect & 2)
       sub_rect.set_y(sub_rect.y() + sub_rect.height() / 2);
     sub_rect.set_width(sub_rect.width() / 2);
     sub_rect.set_height(sub_rect.height() / 2);
     next_sub_rect++;
   }
 }
 
 #if !defined(ARCH_CPU_ARM_FAMILY) && !defined(ARCH_CPU_MIPS_FAMILY)
+TEST(YUVConvertTest, YUVAtoARGB_MMX_MatchReference) {
+  // Allocate all surfaces.
+  scoped_ptr<uint8[]> yuv_bytes;
+  scoped_ptr<uint8[]> rgb_bytes(new uint8[kRGBSize]);
+  scoped_ptr<uint8[]> rgb_converted_bytes(new uint8[kRGBSizeConverted]);
+  scoped_ptr<uint8[]> rgb_converted_bytes_ref(new uint8[kRGBSizeConverted]);
+
+  // Read YUV reference data from file.
+  ReadYV12AData(&yuv_bytes);
+
+  // Convert a frame of YUV to 32 bit ARGB using both C and MMX versions.
+  media::ConvertYUVAToARGB_C(yuv_bytes.get(),
+                             yuv_bytes.get() + kSourceUOffset,
+                             yuv_bytes.get() + kSourceVOffset,
+                             yuv_bytes.get() + kSourceAOffset,
+                             rgb_converted_bytes_ref.get(),
+                             kSourceWidth,
+                             kSourceHeight,
+                             kSourceWidth,
+                             kSourceWidth / 2,
+                             kSourceWidth,
+                             kSourceWidth * kBpp,
+                             media::YV12);
+  media::ConvertYUVAToARGB_MMX(yuv_bytes.get(),
+                               yuv_bytes.get() + kSourceUOffset,
+                               yuv_bytes.get() + kSourceVOffset,
+                               yuv_bytes.get() + kSourceAOffset,
+                               rgb_converted_bytes.get(),
+                               kSourceWidth,
+                               kSourceHeight,
+                               kSourceWidth,
+                               kSourceWidth / 2,
+                               kSourceWidth,
+                               kSourceWidth * kBpp,
+                               media::YV12);
+
+  EXPECT_EQ(0,
+            memcmp(rgb_converted_bytes.get(),
+                   rgb_converted_bytes_ref.get(),
+                   kRGBSizeConverted));
+}
+
 TEST(YUVConvertTest, RGB32ToYUV_SSE2_MatchReference) {
   base::CPU cpu;
   if (!cpu.has_sse2()) {
     LOG(WARNING) << "System doesn't support SSE2, test not executed.";
     return;
   }
 
   // Allocate all surfaces.
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes(new uint8[kRGBSize]);
@@ skipping 450 matching lines @@
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 #endif  // defined(ARCH_CPU_X86_64)
 
 #endif  // defined(ARCH_CPU_X86_FAMILY)
 
 }  // namespace media