Remove LazyInstance usage from media/

media/base/yuv_convert.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.
 
 // This webpage shows layout of YV12 and other YUV formats
 // http://www.fourcc.org/yuv.php
 // The actual conversion is best described here
 // http://en.wikipedia.org/wiki/YUV
 // An article on optimizing YUV conversion using tables instead of multiplies
 // http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
 //
 // YV12 is a full plane of Y and a half height, half width chroma planes
 // YV16 is a full plane of Y and a full height, half width chroma planes
 //
 // ARGB pixel format is output, which on little endian is stored as BGRA.
 // The alpha is set to 255, allowing the application to use RGBA or RGB32.
 
 #include "media/base/yuv_convert.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/cpu.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "build/build_config.h"
 #include "media/base/simd/convert_rgb_to_yuv.h"
 #include "media/base/simd/convert_yuv_to_rgb.h"
 #include "media/base/simd/filter_yuv.h"
 
 #if defined(ARCH_CPU_X86_FAMILY)
@@ skipping 73 matching lines @@
 static ConvertYUVToRGB32RowProc g_convert_yuv_to_rgb32_row_proc_ = NULL;
 static ScaleYUVToRGB32RowProc g_scale_yuv_to_rgb32_row_proc_ = NULL;
 static ScaleYUVToRGB32RowProc g_linear_scale_yuv_to_rgb32_row_proc_ = NULL;
 static ConvertRGBToYUVProc g_convert_rgb32_to_yuv_proc_ = NULL;
 static ConvertRGBToYUVProc g_convert_rgb24_to_yuv_proc_ = NULL;
 static ConvertYUVToRGB32Proc g_convert_yuv_to_rgb32_proc_ = NULL;
 static ConvertYUVAToARGBProc g_convert_yuva_to_argb_proc_ = NULL;
 
 static const int kYUVToRGBTableSize = 256 * 4 * 4 * sizeof(int16_t);
 
-// base::AlignedMemory has a private operator new(), so wrap it in a struct so
-// that we can put it in a LazyInstance::Leaky.
-struct YUVToRGBTableWrapper {
-  base::AlignedMemory<kYUVToRGBTableSize, 16> table;
-};
-
-typedef base::LazyInstance<YUVToRGBTableWrapper>::Leaky
-    YUVToRGBTable;
-static YUVToRGBTable g_table_rec601 = LAZY_INSTANCE_INITIALIZER;
-static YUVToRGBTable g_table_jpeg = LAZY_INSTANCE_INITIALIZER;
-static YUVToRGBTable g_table_rec709 = LAZY_INSTANCE_INITIALIZER;
-static const int16_t* g_table_rec601_ptr = NULL;
-static const int16_t* g_table_jpeg_ptr = NULL;
-static const int16_t* g_table_rec709_ptr = NULL;
+static int16_t* g_table_rec601 = NULL;
+static int16_t* g_table_jpeg = NULL;
+static int16_t* g_table_rec709 = NULL;
 
 // Empty SIMD registers state after using them.
 void EmptyRegisterStateStub() {}
 #if defined(MEDIA_MMX_INTRINSICS_AVAILABLE)
 void EmptyRegisterStateIntrinsic() { _mm_empty(); }
 #endif
 typedef void (*EmptyRegisterStateProc)();
 static EmptyRegisterStateProc g_empty_register_state_proc_ = NULL;
 
 // Get the appropriate value to bitshift by for vertical indices.
 int GetVerticalShift(YUVType type) {
   switch (type) {
     case YV16:
       return 0;
     case YV12:
     case YV12J:
     case YV12HD:
       return 1;
   }
   NOTREACHED();
   return 0;
 }
 
 const int16_t* GetLookupTable(YUVType type) {
   switch (type) {
     case YV12:
     case YV16:
-      return g_table_rec601_ptr;
+      return g_table_rec601;
     case YV12J:
-      return g_table_jpeg_ptr;
+      return g_table_jpeg;
     case YV12HD:
-      return g_table_rec709_ptr;
+      return g_table_rec709;
   }
   NOTREACHED();
   return NULL;
 }
 
 // Populates a pre-allocated lookup table from a YUV->RGB matrix.
 const int16_t* PopulateYUVToRGBTable(const double matrix[3][3],
                                      bool full_range,
                                      int16_t* table) {
   // We'll have 4 sub-tables that lie contiguous in memory, one for each of Y,
@@ skipping 119 matching lines @@
   const double kJPEGConvertMatrix[3][3] = {
       {1.0, 1.0, 1.0}, {0.0, -0.34414, 1.772}, {1.402, -0.71414, 0.0},
   };
 
   // Rec709 "HD" color space, values from:
   // http://www.equasys.de/colorconversion.html
   const double kRec709ConvertMatrix[3][3] = {
       {1.164, 1.164, 1.164}, {0.0, -0.213, 2.112}, {1.793, -0.533, 0.0},
   };
 
-  PopulateYUVToRGBTable(kRec601ConvertMatrix, false,
-                        g_table_rec601.Get().table.data_as<int16_t>());
-  PopulateYUVToRGBTable(kJPEGConvertMatrix, true,
-                        g_table_jpeg.Get().table.data_as<int16_t>());
-  PopulateYUVToRGBTable(kRec709ConvertMatrix, false,
-                        g_table_rec709.Get().table.data_as<int16_t>());
-  g_table_rec601_ptr = g_table_rec601.Get().table.data_as<int16_t>();
-  g_table_rec709_ptr = g_table_rec709.Get().table.data_as<int16_t>();
-  g_table_jpeg_ptr = g_table_jpeg.Get().table.data_as<int16_t>();
+  g_table_rec601 =
+      static_cast<int16_t*>(base::AlignedAlloc(kYUVToRGBTableSize, 16));
+  PopulateYUVToRGBTable(kRec601ConvertMatrix, false, g_table_rec601);
+
+  g_table_rec709 =
+      static_cast<int16_t*>(base::AlignedAlloc(kYUVToRGBTableSize, 16));
+  PopulateYUVToRGBTable(kRec709ConvertMatrix, false, g_table_rec709);
+
+  g_table_jpeg =
+      static_cast<int16_t*>(base::AlignedAlloc(kYUVToRGBTableSize, 16));
+  PopulateYUVToRGBTable(kJPEGConvertMatrix, true, g_table_jpeg);
 }
 
 // Empty SIMD registers state after using them.
 void EmptyRegisterState() { g_empty_register_state_proc_(); }
 
 // 16.16 fixed point arithmetic
 const int kFractionBits = 16;
 const int kFractionMax = 1 << kFractionBits;
 const int kFractionMask = ((1 << kFractionBits) - 1);
 
@@ skipping 412 matching lines @@
                                width,
                                height,
                                ystride,
                                uvstride,
                                astride,
                                rgbstride,
                                yuv_type);
 }
 
 }  // namespace media