1 // Copyright 2013 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 #ifndef GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_ 6 #define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_ 7 8 #include <map> 9 #include <vector> 10 11 #include "base/callback.h" 12 #include "base/compiler_specific.h" 13 #include "base/containers/scoped_ptr_hash_map.h" 14 #include "base/memory/ref_counted.h" 15 #include "base/memory/scoped_ptr.h" 16 #include "base/memory/weak_ptr.h" 17 #include "base/synchronization/lock.h" 18 #include "base/synchronization/waitable_event.h" 19 #include "gpu/command_buffer/client/gpu_control.h" 20 #include "gpu/command_buffer/common/command_buffer.h" 21 #include "gpu/gpu_export.h" 22 #include "ui/gfx/gpu_memory_buffer.h" 23 #include "ui/gfx/native_widget_types.h" 24 #include "ui/gl/gl_surface.h" 25 #include "ui/gl/gpu_preference.h" 26 27 namespace base { 28 class SequenceChecker; 29 } 30 31 namespace gfx { 32 class GLContext; 33 class GLShareGroup; 34 class GLSurface; 35 class Size; 36 } 37 38 #if defined(OS_ANDROID) 39 namespace gfx { 40 class SurfaceTexture; 41 } 42 namespace gpu { 43 class StreamTextureManagerInProcess; 44 } 45 #endif 46 47 namespace gpu { 48 49 namespace gles2 { 50 class GLES2Decoder; 51 class MailboxManager; 52 class ShaderTranslatorCache; 53 } 54 55 class CommandBufferServiceBase; 56 class GpuScheduler; 57 class TransferBufferManagerInterface; 58 59 // TODO(reveman): Remove this interface when InProcessCommandBuffer doesn't need 60 // a custom factory interface and android_webview implementation of GPU memory 61 // buffers can use the same mechanism for buffer allocation as what's used for 62 // out of process GPU service. 63 class GPU_EXPORT InProcessGpuMemoryBufferFactory { 64 public: 65 virtual scoped_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer( 66 size_t width, 67 size_t height, 68 unsigned internalformat, 69 unsigned usage) = 0; 70 virtual scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer( 71 const gfx::GpuMemoryBufferHandle& handle, 72 const gfx::Size& size, 73 unsigned internalformat) = 0; 74 75 protected: ~InProcessGpuMemoryBufferFactory()76 virtual ~InProcessGpuMemoryBufferFactory() {} 77 }; 78 79 // This class provides a thread-safe interface to the global GPU service (for 80 // example GPU thread) when being run in single process mode. 81 // However, the behavior for accessing one context (i.e. one instance of this 82 // class) from different client threads is undefined. 83 class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer, 84 public GpuControl { 85 public: 86 class Service; 87 explicit InProcessCommandBuffer(const scoped_refptr<Service>& service); 88 virtual ~InProcessCommandBuffer(); 89 90 static void SetGpuMemoryBufferFactory( 91 InProcessGpuMemoryBufferFactory* factory); 92 93 // If |surface| is not NULL, use it directly; in this case, the command 94 // buffer gpu thread must be the same as the client thread. Otherwise create 95 // a new GLSurface. 96 bool Initialize(scoped_refptr<gfx::GLSurface> surface, 97 bool is_offscreen, 98 gfx::AcceleratedWidget window, 99 const gfx::Size& size, 100 const std::vector<int32>& attribs, 101 gfx::GpuPreference gpu_preference, 102 const base::Closure& context_lost_callback, 103 InProcessCommandBuffer* share_group); 104 void Destroy(); 105 106 // CommandBuffer implementation: 107 virtual bool Initialize() OVERRIDE; 108 virtual State GetLastState() OVERRIDE; 109 virtual int32 GetLastToken() OVERRIDE; 110 virtual void Flush(int32 put_offset) OVERRIDE; 111 virtual void WaitForTokenInRange(int32 start, int32 end) OVERRIDE; 112 virtual void WaitForGetOffsetInRange(int32 start, int32 end) OVERRIDE; 113 virtual void SetGetBuffer(int32 shm_id) OVERRIDE; 114 virtual scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size, 115 int32* id) OVERRIDE; 116 virtual void DestroyTransferBuffer(int32 id) OVERRIDE; 117 virtual gpu::error::Error GetLastError() OVERRIDE; 118 119 // GpuControl implementation: 120 virtual gpu::Capabilities GetCapabilities() OVERRIDE; 121 virtual gfx::GpuMemoryBuffer* CreateGpuMemoryBuffer(size_t width, 122 size_t height, 123 unsigned internalformat, 124 unsigned usage, 125 int32* id) OVERRIDE; 126 virtual void DestroyGpuMemoryBuffer(int32 id) OVERRIDE; 127 virtual uint32 InsertSyncPoint() OVERRIDE; 128 virtual uint32 InsertFutureSyncPoint() OVERRIDE; 129 virtual void RetireSyncPoint(uint32 sync_point) OVERRIDE; 130 virtual void SignalSyncPoint(uint32 sync_point, 131 const base::Closure& callback) OVERRIDE; 132 virtual void SignalQuery(uint32 query_id, 133 const base::Closure& callback) OVERRIDE; 134 virtual void SetSurfaceVisible(bool visible) OVERRIDE; 135 virtual void Echo(const base::Closure& callback) OVERRIDE; 136 virtual uint32 CreateStreamTexture(uint32 texture_id) OVERRIDE; 137 138 // The serializer interface to the GPU service (i.e. thread). 139 class Service { 140 public: 141 Service(); 142 virtual ~Service(); 143 144 virtual void AddRef() const = 0; 145 virtual void Release() const = 0; 146 147 // Queues a task to run as soon as possible. 148 virtual void ScheduleTask(const base::Closure& task) = 0; 149 150 // Schedules |callback| to run at an appropriate time for performing idle 151 // work. 152 virtual void ScheduleIdleWork(const base::Closure& task) = 0; 153 154 virtual bool UseVirtualizedGLContexts() = 0; 155 virtual scoped_refptr<gles2::ShaderTranslatorCache> 156 shader_translator_cache() = 0; 157 scoped_refptr<gles2::MailboxManager> mailbox_manager(); 158 159 private: 160 scoped_refptr<gles2::MailboxManager> mailbox_manager_; 161 }; 162 163 #if defined(OS_ANDROID) 164 scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture( 165 uint32 stream_id); 166 #endif 167 168 private: 169 struct InitializeOnGpuThreadParams { 170 bool is_offscreen; 171 gfx::AcceleratedWidget window; 172 const gfx::Size& size; 173 const std::vector<int32>& attribs; 174 gfx::GpuPreference gpu_preference; 175 gpu::Capabilities* capabilities; // Ouptut. 176 InProcessCommandBuffer* context_group; 177 InitializeOnGpuThreadParamsInitializeOnGpuThreadParams178 InitializeOnGpuThreadParams(bool is_offscreen, 179 gfx::AcceleratedWidget window, 180 const gfx::Size& size, 181 const std::vector<int32>& attribs, 182 gfx::GpuPreference gpu_preference, 183 gpu::Capabilities* capabilities, 184 InProcessCommandBuffer* share_group) 185 : is_offscreen(is_offscreen), 186 window(window), 187 size(size), 188 attribs(attribs), 189 gpu_preference(gpu_preference), 190 capabilities(capabilities), 191 context_group(share_group) {} 192 }; 193 194 bool InitializeOnGpuThread(const InitializeOnGpuThreadParams& params); 195 bool DestroyOnGpuThread(); 196 void FlushOnGpuThread(int32 put_offset); 197 void ScheduleIdleWorkOnGpuThread(); 198 uint32 CreateStreamTextureOnGpuThread(uint32 client_texture_id); 199 bool MakeCurrent(); 200 base::Closure WrapCallback(const base::Closure& callback); 201 State GetStateFast(); QueueTask(const base::Closure & task)202 void QueueTask(const base::Closure& task) { service_->ScheduleTask(task); } 203 void CheckSequencedThread(); 204 void RetireSyncPointOnGpuThread(uint32 sync_point); 205 void SignalSyncPointOnGpuThread(uint32 sync_point, 206 const base::Closure& callback); 207 bool WaitSyncPointOnGpuThread(uint32 sync_point); 208 void SignalQueryOnGpuThread(unsigned query_id, const base::Closure& callback); 209 void DestroyTransferBufferOnGpuThread(int32 id); 210 void RegisterGpuMemoryBufferOnGpuThread( 211 int32 id, 212 const gfx::GpuMemoryBufferHandle& handle, 213 size_t width, 214 size_t height, 215 unsigned internalformat); 216 void UnregisterGpuMemoryBufferOnGpuThread(int32 id); 217 218 // Callbacks: 219 void OnContextLost(); 220 void OnResizeView(gfx::Size size, float scale_factor); 221 bool GetBufferChanged(int32 transfer_buffer_id); 222 void PumpCommands(); 223 void PerformIdleWork(); 224 225 static scoped_refptr<Service> GetDefaultService(); 226 227 // Members accessed on the gpu thread (possibly with the exception of 228 // creation): 229 bool context_lost_; 230 scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_; 231 scoped_ptr<GpuScheduler> gpu_scheduler_; 232 scoped_ptr<gles2::GLES2Decoder> decoder_; 233 scoped_refptr<gfx::GLContext> context_; 234 scoped_refptr<gfx::GLSurface> surface_; 235 base::Closure context_lost_callback_; 236 bool idle_work_pending_; // Used to throttle PerformIdleWork. 237 238 // Members accessed on the client thread: 239 State last_state_; 240 int32 last_put_offset_; 241 gpu::Capabilities capabilities_; 242 typedef base::ScopedPtrHashMap<int32, gfx::GpuMemoryBuffer> 243 GpuMemoryBufferMap; 244 GpuMemoryBufferMap gpu_memory_buffers_; 245 246 // Accessed on both threads: 247 scoped_ptr<CommandBufferServiceBase> command_buffer_; 248 base::Lock command_buffer_lock_; 249 base::WaitableEvent flush_event_; 250 scoped_refptr<Service> service_; 251 State state_after_last_flush_; 252 base::Lock state_after_last_flush_lock_; 253 scoped_refptr<gfx::GLShareGroup> gl_share_group_; 254 255 #if defined(OS_ANDROID) 256 scoped_ptr<StreamTextureManagerInProcess> stream_texture_manager_; 257 #endif 258 259 // Only used with explicit scheduling and the gpu thread is the same as 260 // the client thread. 261 scoped_ptr<base::SequenceChecker> sequence_checker_; 262 263 base::WeakPtr<InProcessCommandBuffer> gpu_thread_weak_ptr_; 264 base::WeakPtrFactory<InProcessCommandBuffer> gpu_thread_weak_ptr_factory_; 265 266 DISALLOW_COPY_AND_ASSIGN(InProcessCommandBuffer); 267 }; 268 269 } // namespace gpu 270 271 #endif // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_ 272