content/common/gpu/image_transport_surface_iosurface_mac.cc

   1 // Copyright 2014 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 "content/common/gpu/image_transport_surface_iosurface_mac.h"
   6
   7 #include "content/common/gpu/gpu_messages.h"
   8 #include "ui/accelerated_widget_mac/surface_handle_types.h"
   9
  10 namespace content {
  11 namespace {
  12
  13 // IOSurface dimensions will be rounded up to a multiple of this value in order
  14 // to reduce memory thrashing during resize. This must be a power of 2.
  15 const uint32 kIOSurfaceDimensionRoundup = 64;
  16
  17 int RoundUpSurfaceDimension(int number) {
  18   DCHECK(number >= 0);
  19   // Cast into unsigned space for portable bitwise ops.
  20   uint32 unsigned_number = static_cast<uint32>(number);
  21   uint32 roundup_sub_1 = kIOSurfaceDimensionRoundup - 1;
  22   unsigned_number = (unsigned_number + roundup_sub_1) & ~roundup_sub_1;
  23   return static_cast<int>(unsigned_number);
  24 }
  25
  26 void AddBooleanValue(CFMutableDictionaryRef dictionary,
  27                      const CFStringRef key,
  28                      bool value) {
  29   CFDictionaryAddValue(dictionary, key,
  30                        (value ? kCFBooleanTrue : kCFBooleanFalse));
  31 }
  32
  33 void AddIntegerValue(CFMutableDictionaryRef dictionary,
  34                      const CFStringRef key,
  35                      int32 value) {
  36   base::ScopedCFTypeRef<CFNumberRef> number(
  37       CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
  38   CFDictionaryAddValue(dictionary, key, number.get());
  39 }
  40
  41 }  // namespace
  42
  43 IOSurfaceStorageProvider::IOSurfaceStorageProvider(
  44     ImageTransportSurfaceFBO* transport_surface)
  45         : transport_surface_(transport_surface),
  46           frame_scale_factor_(1) {}
  47
  48 IOSurfaceStorageProvider::~IOSurfaceStorageProvider() {
  49   DCHECK(!io_surface_);
  50 }
  51
  52 gfx::Size IOSurfaceStorageProvider::GetRoundedSize(gfx::Size size) {
  53   return gfx::Size(RoundUpSurfaceDimension(size.width()),
  54                    RoundUpSurfaceDimension(size.height()));
  55 }
  56
  57 bool IOSurfaceStorageProvider::AllocateColorBufferStorage(
  58     CGLContextObj context, const base::Closure& context_dirtied_callback,
  59     GLuint texture, gfx::Size pixel_size, float scale_factor) {
  60   // Allocate a new IOSurface, which is the GPU resource that can be
  61   // shared across processes.
  62   base::ScopedCFTypeRef<CFMutableDictionaryRef> properties;
  63   properties.reset(CFDictionaryCreateMutable(kCFAllocatorDefault,
  64                                              0,
  65                                              &kCFTypeDictionaryKeyCallBacks,
  66                                              &kCFTypeDictionaryValueCallBacks));
  67   AddIntegerValue(properties,
  68                   kIOSurfaceWidth,
  69                   pixel_size.width());
  70   AddIntegerValue(properties,
  71                   kIOSurfaceHeight,
  72                   pixel_size.height());
  73   AddIntegerValue(properties,
  74                   kIOSurfaceBytesPerElement, 4);
  75   AddBooleanValue(properties,
  76                   kIOSurfaceIsGlobal, true);
  77   // I believe we should be able to unreference the IOSurfaces without
  78   // synchronizing with the browser process because they are
  79   // ultimately reference counted by the operating system.
  80   io_surface_.reset(IOSurfaceCreate(properties));
  81   io_surface_id_ = IOSurfaceGetID(io_surface_);
  82
  83   // Don't think we need to identify a plane.
  84   GLuint plane = 0;
  85   CGLError cglerror = CGLTexImageIOSurface2D(
  86       context,
  87       GL_TEXTURE_RECTANGLE_ARB,
  88       GL_RGBA,
  89       pixel_size.width(),
  90       pixel_size.height(),
  91       GL_BGRA,
  92       GL_UNSIGNED_INT_8_8_8_8_REV,
  93       io_surface_.get(),
  94       plane);
  95   if (cglerror != kCGLNoError) {
  96     DLOG(ERROR) << "CGLTexImageIOSurface2D failed with CGL error: " << cglerror;
  97     return false;
  98   }
  99
 100   glFlush();
 101   return true;
 102 }
 103
 104 void IOSurfaceStorageProvider::FreeColorBufferStorage() {
 105   io_surface_.reset();
 106   io_surface_id_ = 0;
 107 }
 108
 109 void IOSurfaceStorageProvider::FrameSizeChanged(const gfx::Size& pixel_size,
 110                                                 float scale_factor) {
 111   frame_pixel_size_ = pixel_size;
 112   frame_scale_factor_ = scale_factor;
 113 }
 114
 115 void IOSurfaceStorageProvider::SwapBuffers(const gfx::Rect& dirty_rect) {
 116   // The browser compositor will throttle itself, so we are free to unblock the
 117   // context immediately. Make sure that the browser is doing its throttling
 118   // appropriately by ensuring that the previous swap was acknowledged before
 119   // we get another swap.
 120   DCHECK(pending_swapped_surfaces_.empty());
 121   pending_swapped_surfaces_.push_back(io_surface_);
 122
 123   transport_surface_->SendSwapBuffers(
 124       ui::SurfaceHandleFromIOSurfaceID(io_surface_id_),
 125       frame_pixel_size_,
 126       frame_scale_factor_);
 127 }
 128
 129 void IOSurfaceStorageProvider::WillWriteToBackbuffer() {
 130 }
 131
 132 void IOSurfaceStorageProvider::DiscardBackbuffer() {
 133 }
 134
 135 void IOSurfaceStorageProvider::SwapBuffersAckedByBrowser(
 136     bool disable_throttling) {
 137   DCHECK(!pending_swapped_surfaces_.empty());
 138   pending_swapped_surfaces_.pop_front();
 139 }
 140
 141 }  //  namespace content