Use libyuv for non-scaling RGB<->YUV conversions.

remoting/base/util.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 "remoting/base/util.h"
 
 #include <math.h>
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
+#include "third_party/libyuv/include/libyuv/convert.h"
 #include "third_party/skia/include/core/SkRegion.h"
 
 #if defined(OS_POSIX)
 #include <pwd.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif  // defined(OS_POSIX)
 
 using media::VideoFrame;
 
@@ skipping 34 matching lines @@
                                int y,
                                int width,
                                int height,
                                int rgb_stride,
                                int y_stride,
                                int uv_stride) {
   int rgb_offset = CalculateRGBOffset(x, y, rgb_stride);
   int y_offset = CalculateYOffset(x, y, y_stride);
   int uv_offset = CalculateUVOffset(x, y, uv_stride);;
 
-  media::ConvertRGB32ToYUV(rgb_plane + rgb_offset,
-                           y_plane + y_offset,
-                           u_plane + uv_offset,
-                           v_plane + uv_offset,
-                           width,
-                           height,
-                           rgb_stride,
-                           y_stride,
-                           uv_stride);
+  libyuv::ARGBToI420(rgb_plane + rgb_offset, rgb_stride,
+                     y_plane + y_offset, y_stride,
+                     u_plane + uv_offset, uv_stride,
+                     v_plane + uv_offset, uv_stride,
+                     width, height);
 }
 
 void ConvertAndScaleYUVToRGB32Rect(const uint8* source_yplane,
                                    const uint8* source_uplane,
                                    const uint8* source_vplane,
                                    int source_ystride,
                                    int source_uvstride,
                                    const SkISize& source_size,
                                    const SkIRect& source_buffer_rect,
                                    uint8* dest_buffer,
@@ skipping 17 matching lines @@
   int uv_offset = - CalculateUVOffset(source_buffer_rect.x(),
                                       source_buffer_rect.y(),
                                       source_uvstride);
   int rgb_offset = - CalculateRGBOffset(dest_buffer_rect.x(),
                                         dest_buffer_rect.y(),
                                         dest_stride);
 
   // See if scaling is needed.
   if (source_size == dest_size) {
     // Calculate the inner rectangle that can be copied by the optimized
-    // ConvertYUVToRGB32().
+    // libyuv::I420ToARGB().
     SkIRect inner_rect =
         SkIRect::MakeLTRB(RoundToTwosMultiple(dest_rect.left() + 1),
                           RoundToTwosMultiple(dest_rect.top() + 1),
                           dest_rect.right(),
                           dest_rect.bottom());
 
     // Offset pointers to point to the top left corner of the inner rectangle.
     y_offset += CalculateYOffset(inner_rect.x(), inner_rect.y(),
                                  source_ystride);
     uv_offset += CalculateUVOffset(inner_rect.x(), inner_rect.y(),
                                    source_uvstride);
     rgb_offset += CalculateRGBOffset(inner_rect.x(), inner_rect.y(),
                                      dest_stride);
 
-    media::ConvertYUVToRGB32(source_yplane + y_offset,
-                             source_uplane + uv_offset,
-                             source_vplane + uv_offset,
-                             dest_buffer + rgb_offset,
-                             inner_rect.width(),
-                             inner_rect.height(),
-                             source_ystride,
-                             source_uvstride,
-                             dest_stride,
-                             media::YV12);
+    libyuv::I420ToARGB(source_yplane + y_offset, source_ystride,
+                       source_uplane + uv_offset, source_uvstride,
+                       source_vplane + uv_offset, source_uvstride,
+                       dest_buffer + rgb_offset, dest_stride,
+                       inner_rect.width(), inner_rect.height());
 
     // Now see if some pixels weren't copied due to alignment.
     if (dest_rect != inner_rect) {
       SkIRect outer_rect =
         SkIRect::MakeLTRB(RoundToTwosMultiple(dest_rect.left()),
                           RoundToTwosMultiple(dest_rect.top()),
                           dest_rect.right(),
                           dest_rect.bottom());
 
       SkIPoint offset = SkIPoint::Make(outer_rect.x() - inner_rect.x(),
@@ skipping 179 matching lines @@
   getpwuid_r(getuid(), &passwd, buf.get(), buf_size, &passwd_result);
   if (!passwd_result)
     return std::string();
   return std::string(passwd_result->pw_name);
 #else  // !defined(OS_POSIX)
   return std::string();
 #endif  // defined(OS_POSIX)
 }
 
 }  // namespace remoting