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