Fix up mac capturer to flip image.

remoting/host/capturer_mac.cc

 // Copyright (c) 2010 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/host/capturer_mac.h"
 
 #include <stddef.h>
 
 #include <OpenGL/CGLMacro.h>
 
@@ skipping 37 matching lines @@
   CGDirectDisplayID mainDevice = CGMainDisplayID();
 
   width_ = CGDisplayPixelsWide(mainDevice);
   height_ = CGDisplayPixelsHigh(mainDevice);
   pixel_format_ = media::VideoFrame::RGB32;
   bytes_per_row_ = width_ * sizeof(uint32_t);
   size_t buffer_size = height() * bytes_per_row_;
   for (int i = 0; i < kNumBuffers; ++i) {
     buffers_[i].reset(new uint8[buffer_size]);
   }
+  flip_buffer_.reset(new uint8[buffer_size]);
   CGLPixelFormatAttribute attributes[] = {
     kCGLPFAFullScreen,
     kCGLPFADisplayMask,
     (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(mainDevice),
     (CGLPixelFormatAttribute)0
   };
   CGLPixelFormatObj pixel_format = NULL;
   GLint matching_pixel_format_count = 0;
   CGLError err = CGLChoosePixelFormat(attributes,
                                       &pixel_format,
@@ skipping 17 matching lines @@
   CGLContextObj CGL_MACRO_CONTEXT = cgl_context_;
   glReadBuffer(GL_FRONT);
   glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
 
   glPixelStorei(GL_PACK_ALIGNMENT, 4);  // Force 4-byte alignment.
   glPixelStorei(GL_PACK_ROW_LENGTH, 0);
   glPixelStorei(GL_PACK_SKIP_ROWS, 0);
   glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
 
   // Read a block of pixels from the frame buffer.
-  glReadPixels(0, 0, width(), height(), GL_BGRA, GL_UNSIGNED_BYTE,
-               buffers_[current_buffer_].get());
+  int h = height();
+  int w = width();
+  uint8* flip_buffer = flip_buffer_.get();
+  uint8* current_buffer = buffers_[current_buffer_].get();
+
+  glReadPixels(0, 0, w, h, GL_BGRA, GL_UNSIGNED_BYTE, flip_buffer);
   glPopClientAttrib();
 
+  // OpenGL reads with a vertical flip, and sadly there is no optimized
+  // way to get it flipped automatically.
+  DCHECK_EQ(bytes_per_row_ % sizeof(uint32_t), 0U);
+  for (int y = 0; y < h; ++y) {
+    uint32_t* flip_row = reinterpret_cast<uint32_t*>(
+        &(flip_buffer[y * bytes_per_row_]));
+    uint32_t* current_row = reinterpret_cast<uint32_t*>(
+        &(current_buffer[(h - (y + 1)) * bytes_per_row_]));
+    for (int x = 0; x < w; ++x) {

[Alpha Left Google, 2011/03/03 01:43:33]

Do a memcpy instead of doing yourself, memcpy is pretty optimized.

+      current_row[x] = flip_row[x];
+    }
+  }
+
   DataPlanes planes;
   planes.data[0] = buffers_[current_buffer_].get();
   planes.strides[0] = bytes_per_row_;
 
-  scoped_refptr<CaptureData> data(new CaptureData(planes,
-                                                  width(),
-                                                  height(),
-                                                  pixel_format()));
+  scoped_refptr<CaptureData> data(
+      new CaptureData(planes, w, h, pixel_format()));
   data->mutable_dirty_rects() = rects;
   FinishCapture(data, callback);
 }
 
 void CapturerMac::ScreenRefresh(CGRectCount count, const CGRect *rect_array) {
   InvalidRects rects;
   for (CGRectCount i = 0; i < count; ++i) {
     CGRect rect = rect_array[i];
     rect.origin.y = height() - rect.size.height;
     rects.insert(gfx::Rect(rect));
@@ skipping 40 matching lines @@
     capturer->ScreenConfigurationChanged();
   }
 }
 
 // static
 Capturer* Capturer::Create(MessageLoop* message_loop) {
   return new CapturerMac(message_loop);
 }
 
 }  // namespace remoting