remoting/base/util.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/base/util.h"
   6
   7 #include <math.h>
   8
   9 #include "base/logging.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/time/time.h"
  12 #include "media/base/video_frame.h"
  13 #include "media/base/yuv_convert.h"
  14 #include "third_party/libyuv/include/libyuv/convert.h"
  15 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
  16
  17 using media::VideoFrame;
  18
  19 namespace remoting {
  20
  21 enum { kBytesPerPixelRGB32 = 4 };
  22
  23 // Do not write LOG messages in this routine since it is called from within
  24 // our LOG message handler. Bad things will happen.
  25 std::string GetTimestampString() {
  26   base::Time t = base::Time::NowFromSystemTime();
  27   base::Time::Exploded tex;
  28   t.LocalExplode(&tex);
  29   return base::StringPrintf("%02d%02d/%02d%02d%02d:",
  30                             tex.month, tex.day_of_month,
  31                             tex.hour, tex.minute, tex.second);
  32 }
  33
  34 int CalculateRGBOffset(int x, int y, int stride) {
  35   return stride * y + kBytesPerPixelRGB32 * x;
  36 }
  37
  38 int CalculateYOffset(int x, int y, int stride) {
  39   DCHECK(((x & 1) == 0) && ((y & 1) == 0));
  40   return stride * y + x;
  41 }
  42
  43 int CalculateUVOffset(int x, int y, int stride) {
  44   DCHECK(((x & 1) == 0) && ((y & 1) == 0));
  45   return stride * y / 2 + x / 2;
  46 }
  47
  48 void ConvertRGB32ToYUVWithRect(const uint8* rgb_plane,
  49                                uint8* y_plane,
  50                                uint8* u_plane,
  51                                uint8* v_plane,
  52                                int x,
  53                                int y,
  54                                int width,
  55                                int height,
  56                                int rgb_stride,
  57                                int y_stride,
  58                                int uv_stride) {
  59   int rgb_offset = CalculateRGBOffset(x, y, rgb_stride);
  60   int y_offset = CalculateYOffset(x, y, y_stride);
  61   int uv_offset = CalculateUVOffset(x, y, uv_stride);;
  62
  63   libyuv::ARGBToI420(rgb_plane + rgb_offset, rgb_stride,
  64                      y_plane + y_offset, y_stride,
  65                      u_plane + uv_offset, uv_stride,
  66                      v_plane + uv_offset, uv_stride,
  67                      width, height);
  68 }
  69
  70 void ConvertAndScaleYUVToRGB32Rect(
  71     const uint8* source_yplane,
  72     const uint8* source_uplane,
  73     const uint8* source_vplane,
  74     int source_ystride,
  75     int source_uvstride,
  76     const webrtc::DesktopSize& source_size,
  77     const webrtc::DesktopRect& source_buffer_rect,
  78     uint8* dest_buffer,
  79     int dest_stride,
  80     const webrtc::DesktopSize& dest_size,
  81     const webrtc::DesktopRect& dest_buffer_rect,
  82     const webrtc::DesktopRect& dest_rect) {
  83   // N.B. It is caller's responsibility to check if strides are large enough. We
  84   // cannot do it here anyway.
  85   DCHECK(DoesRectContain(webrtc::DesktopRect::MakeSize(source_size),
  86                          source_buffer_rect));
  87   DCHECK(DoesRectContain(webrtc::DesktopRect::MakeSize(dest_size),
  88                          dest_buffer_rect));
  89   DCHECK(DoesRectContain(dest_buffer_rect, dest_rect));
  90   DCHECK(DoesRectContain(ScaleRect(source_buffer_rect, source_size, dest_size),
  91                          dest_rect));
  92
  93   // If the source and/or destination buffers don't start at (0, 0)
  94   // offset the pointers to pretend we have complete buffers.
  95   int y_offset = - CalculateYOffset(source_buffer_rect.left(),
  96                                     source_buffer_rect.top(),
  97                                     source_ystride);
  98   int uv_offset = - CalculateUVOffset(source_buffer_rect.left(),
  99                                       source_buffer_rect.top(),
 100                                       source_uvstride);
 101   int rgb_offset = - CalculateRGBOffset(dest_buffer_rect.left(),
 102                                         dest_buffer_rect.top(),
 103                                         dest_stride);
 104
 105   // See if scaling is needed.
 106   if (source_size.equals(dest_size)) {
 107     // Calculate the inner rectangle that can be copied by the optimized
 108     // libyuv::I420ToARGB().
 109     webrtc::DesktopRect inner_rect =
 110         webrtc::DesktopRect::MakeLTRB(RoundToTwosMultiple(dest_rect.left() + 1),
 111                                       RoundToTwosMultiple(dest_rect.top() + 1),
 112                                       dest_rect.right(), dest_rect.bottom());
 113
 114     // Offset pointers to point to the top left corner of the inner rectangle.
 115     y_offset += CalculateYOffset(inner_rect.left(), inner_rect.top(),
 116                                  source_ystride);
 117     uv_offset += CalculateUVOffset(inner_rect.left(), inner_rect.top(),
 118                                    source_uvstride);
 119     rgb_offset += CalculateRGBOffset(inner_rect.left(), inner_rect.top(),
 120                                      dest_stride);
 121
 122     libyuv::I420ToARGB(source_yplane + y_offset, source_ystride,
 123                        source_uplane + uv_offset, source_uvstride,
 124                        source_vplane + uv_offset, source_uvstride,
 125                        dest_buffer + rgb_offset, dest_stride,
 126                        inner_rect.width(), inner_rect.height());
 127
 128     // Now see if some pixels weren't copied due to alignment.
 129     if (!dest_rect.equals(inner_rect)) {
 130       webrtc::DesktopRect outer_rect =
 131           webrtc::DesktopRect::MakeLTRB(RoundToTwosMultiple(dest_rect.left()),
 132                                         RoundToTwosMultiple(dest_rect.top()),
 133                                         dest_rect.right(), dest_rect.bottom());
 134
 135       webrtc::DesktopVector offset(outer_rect.left() - inner_rect.left(),
 136                                    outer_rect.top() - inner_rect.top());
 137
 138       // Offset the pointers to point to the top left corner of the outer
 139       // rectangle.
 140       y_offset += CalculateYOffset(offset.x(), offset.y(), source_ystride);
 141       uv_offset += CalculateUVOffset(offset.x(), offset.y(), source_uvstride);
 142       rgb_offset += CalculateRGBOffset(offset.x(), offset.y(), dest_stride);
 143
 144       // Draw unaligned edges.
 145       webrtc::DesktopRegion edges(dest_rect);
 146       edges.Subtract(inner_rect);
 147       for (webrtc::DesktopRegion::Iterator i(edges); !i.IsAtEnd();
 148            i.Advance()) {
 149         webrtc::DesktopRect rect = i.rect();
 150         rect.Translate(-outer_rect.left(), -outer_rect.top());
 151         media::ScaleYUVToRGB32WithRect(source_yplane + y_offset,
 152                                        source_uplane + uv_offset,
 153                                        source_vplane + uv_offset,
 154                                        dest_buffer + rgb_offset,
 155                                        source_size.width(),
 156                                        source_size.height(),
 157                                        dest_size.width(),
 158                                        dest_size.height(),
 159                                        rect.left(),
 160                                        rect.top(),
 161                                        rect.right(),
 162                                        rect.bottom(),
 163                                        source_ystride,
 164                                        source_uvstride,
 165                                        dest_stride);
 166       }
 167     }
 168   } else {
 169     media::ScaleYUVToRGB32WithRect(source_yplane + y_offset,
 170                                    source_uplane + uv_offset,
 171                                    source_vplane + uv_offset,
 172                                    dest_buffer + rgb_offset,
 173                                    source_size.width(),
 174                                    source_size.height(),
 175                                    dest_size.width(),
 176                                    dest_size.height(),
 177                                    dest_rect.left(),
 178                                    dest_rect.top(),
 179                                    dest_rect.right(),
 180                                    dest_rect.bottom(),
 181                                    source_ystride,
 182                                    source_uvstride,
 183                                    dest_stride);
 184   }
 185 }
 186
 187 int RoundToTwosMultiple(int x) {
 188   return x & (~1);
 189 }
 190
 191 webrtc::DesktopRect AlignRect(const webrtc::DesktopRect& rect) {
 192   int x = RoundToTwosMultiple(rect.left());
 193   int y = RoundToTwosMultiple(rect.top());
 194   int right = RoundToTwosMultiple(rect.right() + 1);
 195   int bottom = RoundToTwosMultiple(rect.bottom() + 1);
 196   return webrtc::DesktopRect::MakeLTRB(x, y, right, bottom);
 197 }
 198
 199 webrtc::DesktopRect ScaleRect(const webrtc::DesktopRect& rect,
 200                               const webrtc::DesktopSize& in_size,
 201                               const webrtc::DesktopSize& out_size) {
 202   int left = (rect.left() * out_size.width()) / in_size.width();
 203   int top = (rect.top() * out_size.height()) / in_size.height();
 204   int right = (rect.right() * out_size.width() + in_size.width() - 1) /
 205       in_size.width();
 206   int bottom = (rect.bottom() * out_size.height() + in_size.height() - 1) /
 207       in_size.height();
 208   return webrtc::DesktopRect::MakeLTRB(left, top, right, bottom);
 209 }
 210
 211 void CopyRGB32Rect(const uint8* source_buffer,
 212                    int source_stride,
 213                    const webrtc::DesktopRect& source_buffer_rect,
 214                    uint8* dest_buffer,
 215                    int dest_stride,
 216                    const webrtc::DesktopRect& dest_buffer_rect,
 217                    const webrtc::DesktopRect& dest_rect) {
 218   DCHECK(DoesRectContain(dest_buffer_rect, dest_rect));
 219   DCHECK(DoesRectContain(source_buffer_rect, dest_rect));
 220
 221   // Get the address of the starting point.
 222   source_buffer += CalculateRGBOffset(
 223       dest_rect.left() - source_buffer_rect.left(),
 224       dest_rect.top() - source_buffer_rect.top(),
 225       source_stride);
 226   dest_buffer += CalculateRGBOffset(
 227       dest_rect.left() - dest_buffer_rect.left(),
 228       dest_rect.top() - dest_buffer_rect.top(),
 229       source_stride);
 230
 231   // Copy pixels in the rectangle line by line.
 232   const int bytes_per_line = kBytesPerPixelRGB32 * dest_rect.width();
 233   for (int i = 0 ; i < dest_rect.height(); ++i) {
 234     memcpy(dest_buffer, source_buffer, bytes_per_line);
 235     source_buffer += source_stride;
 236     dest_buffer += dest_stride;
 237   }
 238 }
 239
 240 std::string ReplaceLfByCrLf(const std::string& in) {
 241   std::string out;
 242   out.resize(2 * in.size());
 243   char* out_p_begin = &out[0];
 244   char* out_p = out_p_begin;
 245   const char* in_p_begin = &in[0];
 246   const char* in_p_end = &in[in.size()];
 247   for (const char* in_p = in_p_begin; in_p < in_p_end; ++in_p) {
 248     char c = *in_p;
 249     if (c == '\n') {
 250       *out_p++ = '\r';
 251     }
 252     *out_p++ = c;
 253   }
 254   out.resize(out_p - out_p_begin);
 255   return out;
 256 }
 257
 258 std::string ReplaceCrLfByLf(const std::string& in) {
 259   std::string out;
 260   out.resize(in.size());
 261   char* out_p_begin = &out[0];
 262   char* out_p = out_p_begin;
 263   const char* in_p_begin = &in[0];
 264   const char* in_p_end = &in[in.size()];
 265   for (const char* in_p = in_p_begin; in_p < in_p_end; ++in_p) {
 266     char c = *in_p;
 267     if ((c == '\r') && (in_p + 1 < in_p_end) && (*(in_p + 1) == '\n')) {
 268       *out_p++ = '\n';
 269       ++in_p;
 270     } else {
 271       *out_p++ = c;
 272     }
 273   }
 274   out.resize(out_p - out_p_begin);
 275   return out;
 276 }
 277
 278 bool StringIsUtf8(const char* data, size_t length) {
 279   const char* ptr = data;
 280   const char* ptr_end = data + length;
 281   while (ptr != ptr_end) {
 282     if ((*ptr & 0x80) == 0) {
 283       // Single-byte symbol.
 284       ++ptr;
 285     } else if ((*ptr & 0xc0) == 0x80 || (*ptr & 0xfe) == 0xfe) {
 286       // Invalid first byte.
 287       return false;
 288     } else {
 289       // First byte of a multi-byte symbol. The bits from 2 to 6 are the count
 290       // of continuation bytes (up to 5 of them).
 291       for (char first = *ptr << 1; first & 0x80; first <<= 1) {
 292         ++ptr;
 293
 294         // Missing continuation byte.
 295         if (ptr == ptr_end)
 296           return false;
 297
 298         // Invalid continuation byte.
 299         if ((*ptr & 0xc0) != 0x80)
 300           return false;
 301       }
 302
 303       ++ptr;
 304     }
 305   }
 306
 307   return true;
 308 }
 309
 310 bool DoesRectContain(const webrtc::DesktopRect& a,
 311                      const webrtc::DesktopRect& b) {
 312   webrtc::DesktopRect intersection(a);
 313   intersection.IntersectWith(b);
 314   return intersection.equals(b);
 315 }
 316
 317 }  // namespace remoting