[Remoting Android] Cursor & Cursor Feedback for OpenGL Renderer

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/strings/stringprintf.h"
@@ skipping 54 matching lines @@
 
   // Copy pixels in the rectangle line by line.
   const int bytes_per_line = kBytesPerPixelRGB32 * dest_rect.width();
   for (int i = 0 ; i < dest_rect.height(); ++i) {
     memcpy(dest_buffer, source_buffer, bytes_per_line);
     source_buffer += source_stride;
     dest_buffer += dest_stride;
   }
 }
 
+void CopyAndSwapRB(const uint8_t* source, uint8_t* dest, int length) {

[Sergey Ulanov, 2016/07/19 00:42:48]

Please use RGBAToARGB() from libyuv. It's optimized with NEON, so it should be
significantly faster. It doesn't matter for cursor, but someone will want to use
this function for something bigger than mouse cursor.

[Yuwei, 2016/07/19 04:11:52]

Wouldn't it be BGRAToRGBA()? Looks like there is no such function but
ABGRToARGB() seems to be doing the right thing... I guess that's in little
endian?

We are doing row-by-row memcpy in GlDesktop when we need to manually pack the
image. Is there any similar optimization for that?

We will need to list libyuv as the dependency of the renderer. Not sure whether
that's a good idea...

[Yuwei, 2016/07/19 20:34:23]

Done. Using libyuv::ABGRToARGB

[Sergey Ulanov, 2016/07/20 18:06:11]

memcpy() itself should be already optimized. 
Client already depends on libyuv, so this is not a problem

+  for (int i = 0; i < length / kBytesPerPixelRGB32; i++) {
+    dest[i * kBytesPerPixelRGB32] = source[i * kBytesPerPixelRGB32 + 2];
+    dest[i * kBytesPerPixelRGB32 + 1] = source[i * kBytesPerPixelRGB32 + 1];
+    dest[i * kBytesPerPixelRGB32 + 2] = source[i * kBytesPerPixelRGB32 + 0];
+    dest[i * kBytesPerPixelRGB32 + 3] = source[i * kBytesPerPixelRGB32 + 3];
+  }
+}
+
 std::string ReplaceLfByCrLf(const std::string& in) {
   std::string out;
   out.resize(2 * in.size());
   char* out_p_begin = &out[0];
   char* out_p = out_p_begin;
   const char* in_p_begin = &in[0];
   const char* in_p_end = &in[in.size()];
   for (const char* in_p = in_p_begin; in_p < in_p_end; ++in_p) {
     char c = *in_p;
     if (c == '\n') {
@@ skipping 58 matching lines @@
 }
 
 bool DoesRectContain(const webrtc::DesktopRect& a,
                      const webrtc::DesktopRect& b) {
   webrtc::DesktopRect intersection(a);
   intersection.IntersectWith(b);
   return intersection.equals(b);
 }
 
 }  // namespace remoting