1 // Copyright 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.
5 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
6 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
14 #include "base/basictypes.h"
15 #include "base/callback.h"
16 #include "base/containers/hash_tables.h"
17 #include "base/memory/linked_ptr.h"
18 #include "base/memory/scoped_ptr.h"
19 #include "base/threading/thread_checker.h"
20 #include "cc/base/cc_export.h"
21 #include "cc/output/context_provider.h"
22 #include "cc/output/output_surface.h"
23 #include "cc/resources/release_callback_impl.h"
24 #include "cc/resources/resource_format.h"
25 #include "cc/resources/return_callback.h"
26 #include "cc/resources/shared_bitmap.h"
27 #include "cc/resources/single_release_callback_impl.h"
28 #include "cc/resources/texture_mailbox.h"
29 #include "cc/resources/transferable_resource.h"
30 #include "third_party/khronos/GLES2/gl2.h"
31 #include "third_party/khronos/GLES2/gl2ext.h"
32 #include "third_party/skia/include/core/SkBitmap.h"
33 #include "third_party/skia/include/core/SkCanvas.h"
34 #include "ui/gfx/geometry/size.h"
39 class GpuMemoryBufferManager;
46 class GpuMemoryBuffer;
52 class BlockingTaskRunner;
55 class SharedBitmapManager;
56 class TextureUploader;
58 // This class is not thread-safe and can only be called from the thread it was
59 // created on (in practice, the impl thread).
60 class CC_EXPORT ResourceProvider {
65 typedef unsigned ResourceId;
66 typedef std::vector<ResourceId> ResourceIdArray;
67 typedef std::set<ResourceId> ResourceIdSet;
68 typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
70 TextureHintDefault = 0x0,
71 TextureHintImmutable = 0x1,
72 TextureHintFramebuffer = 0x2,
73 TextureHintImmutableFramebuffer =
74 TextureHintImmutable | TextureHintFramebuffer
82 static scoped_ptr<ResourceProvider> Create(
83 OutputSurface* output_surface,
84 SharedBitmapManager* shared_bitmap_manager,
85 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
86 BlockingTaskRunner* blocking_main_thread_task_runner,
87 int highp_threshold_min,
88 bool use_rgba_4444_texture_format,
89 size_t id_allocation_chunk_size);
90 virtual ~ResourceProvider();
92 void InitializeSoftware();
95 void DidLoseOutputSurface() { lost_output_surface_ = true; }
97 int max_texture_size() const { return max_texture_size_; }
98 ResourceFormat memory_efficient_texture_format() const {
99 return use_rgba_4444_texture_format_ ? RGBA_4444 : best_texture_format_;
101 ResourceFormat best_texture_format() const { return best_texture_format_; }
102 bool use_sync_query() const { return use_sync_query_; }
103 size_t num_resources() const { return resources_.size(); }
105 // Checks whether a resource is in use by a consumer.
106 bool InUseByConsumer(ResourceId id);
108 bool IsLost(ResourceId id);
109 bool AllowOverlay(ResourceId id);
111 // Producer interface.
113 ResourceType default_resource_type() const { return default_resource_type_; }
114 ResourceType GetResourceType(ResourceId id);
116 // Creates a resource of the default resource type.
117 ResourceId CreateResource(const gfx::Size& size,
120 ResourceFormat format);
122 // Creates a resource which is tagged as being managed for GPU memory
123 // accounting purposes.
124 ResourceId CreateManagedResource(const gfx::Size& size,
128 ResourceFormat format);
130 // You can also explicitly create a specific resource type.
131 ResourceId CreateGLTexture(const gfx::Size& size,
136 ResourceFormat format);
138 ResourceId CreateBitmap(const gfx::Size& size, GLint wrap_mode);
139 // Wraps an IOSurface into a GL resource.
140 ResourceId CreateResourceFromIOSurface(const gfx::Size& size,
141 unsigned io_surface_id);
143 // Wraps an external texture mailbox into a GL resource.
144 ResourceId CreateResourceFromTextureMailbox(
145 const TextureMailbox& mailbox,
146 scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl);
148 void DeleteResource(ResourceId id);
150 // Update pixels from image, copying source_rect (in image) to dest_offset (in
152 void SetPixels(ResourceId id,
153 const uint8_t* image,
154 const gfx::Rect& image_rect,
155 const gfx::Rect& source_rect,
156 const gfx::Vector2d& dest_offset);
158 // Check upload status.
159 size_t NumBlockingUploads();
160 void MarkPendingUploadsAsNonBlocking();
161 size_t EstimatedUploadsPerTick();
163 void ReleaseCachedData();
164 base::TimeTicks EstimatedUploadCompletionTime(size_t uploads_per_tick);
166 // Only flush the command buffer if supported.
167 // Returns true if the shallow flush occurred, false otherwise.
168 bool ShallowFlushIfSupported();
170 // Creates accounting for a child. Returns a child ID.
171 int CreateChild(const ReturnCallback& return_callback);
173 // Destroys accounting for the child, deleting all accounted resources.
174 void DestroyChild(int child);
176 // Gets the child->parent resource ID map.
177 const ResourceIdMap& GetChildToParentMap(int child) const;
179 // Prepares resources to be transfered to the parent, moving them to
180 // mailboxes and serializing meta-data into TransferableResources.
181 // Resources are not removed from the ResourceProvider, but are marked as
183 void PrepareSendToParent(const ResourceIdArray& resources,
184 TransferableResourceArray* transferable_resources);
186 // Receives resources from a child, moving them from mailboxes. Resource IDs
187 // passed are in the child namespace, and will be translated to the parent
188 // namespace, added to the child->parent map.
189 // This adds the resources to the working set in the ResourceProvider without
190 // declaring which resources are in use. Use DeclareUsedResourcesFromChild
191 // after calling this method to do that. All calls to ReceiveFromChild should
192 // be followed by a DeclareUsedResourcesFromChild.
193 // NOTE: if the sync_point is set on any TransferableResource, this will
195 void ReceiveFromChild(
196 int child, const TransferableResourceArray& transferable_resources);
198 // Once a set of resources have been received, they may or may not be used.
199 // This declares what set of resources are currently in use from the child,
200 // releasing any other resources back to the child.
201 void DeclareUsedResourcesFromChild(
203 const ResourceIdArray& resources_from_child);
205 // Receives resources from the parent, moving them from mailboxes. Resource
206 // IDs passed are in the child namespace.
207 // NOTE: if the sync_point is set on any TransferableResource, this will
209 void ReceiveReturnsFromParent(
210 const ReturnedResourceArray& transferable_resources);
212 // The following lock classes are part of the ResourceProvider API and are
213 // needed to read and write the resource contents. The user must ensure
214 // that they only use GL locks on GL resources, etc, and this is enforced
216 class CC_EXPORT ScopedReadLockGL {
218 ScopedReadLockGL(ResourceProvider* resource_provider,
219 ResourceProvider::ResourceId resource_id);
220 virtual ~ScopedReadLockGL();
222 unsigned texture_id() const { return texture_id_; }
225 ResourceProvider* resource_provider_;
226 ResourceProvider::ResourceId resource_id_;
229 unsigned texture_id_;
231 DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL);
234 class CC_EXPORT ScopedSamplerGL : public ScopedReadLockGL {
236 ScopedSamplerGL(ResourceProvider* resource_provider,
237 ResourceProvider::ResourceId resource_id,
239 ScopedSamplerGL(ResourceProvider* resource_provider,
240 ResourceProvider::ResourceId resource_id,
243 ~ScopedSamplerGL() override;
245 GLenum target() const { return target_; }
251 DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL);
254 class CC_EXPORT ScopedWriteLockGL {
256 ScopedWriteLockGL(ResourceProvider* resource_provider,
257 ResourceProvider::ResourceId resource_id);
258 ~ScopedWriteLockGL();
260 unsigned texture_id() const { return texture_id_; }
263 ResourceProvider* resource_provider_;
264 ResourceProvider::Resource* resource_;
265 unsigned texture_id_;
267 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL);
270 class CC_EXPORT ScopedReadLockSoftware {
272 ScopedReadLockSoftware(ResourceProvider* resource_provider,
273 ResourceProvider::ResourceId resource_id);
274 ~ScopedReadLockSoftware();
276 const SkBitmap* sk_bitmap() const {
280 GLint wrap_mode() const { return wrap_mode_; }
282 bool valid() const { return !!sk_bitmap_.getPixels(); }
285 ResourceProvider* resource_provider_;
286 ResourceProvider::ResourceId resource_id_;
290 DISALLOW_COPY_AND_ASSIGN(ScopedReadLockSoftware);
293 class CC_EXPORT ScopedWriteLockSoftware {
295 ScopedWriteLockSoftware(ResourceProvider* resource_provider,
296 ResourceProvider::ResourceId resource_id);
297 ~ScopedWriteLockSoftware();
299 SkCanvas* sk_canvas() { return sk_canvas_.get(); }
300 bool valid() const { return !!sk_bitmap_.getPixels(); }
303 ResourceProvider* resource_provider_;
304 ResourceProvider::Resource* resource_;
306 scoped_ptr<SkCanvas> sk_canvas_;
307 base::ThreadChecker thread_checker_;
309 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware);
312 class CC_EXPORT ScopedWriteLockGpuMemoryBuffer {
314 ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
315 ResourceProvider::ResourceId resource_id);
316 ~ScopedWriteLockGpuMemoryBuffer();
318 gfx::GpuMemoryBuffer* GetGpuMemoryBuffer();
321 ResourceProvider* resource_provider_;
322 ResourceProvider::Resource* resource_;
323 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
324 gfx::GpuMemoryBuffer* gpu_memory_buffer_;
326 ResourceFormat format_;
327 base::ThreadChecker thread_checker_;
329 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
332 class CC_EXPORT ScopedWriteLockGr {
334 ScopedWriteLockGr(ResourceProvider* resource_provider,
335 ResourceProvider::ResourceId resource_id);
336 ~ScopedWriteLockGr();
338 SkSurface* GetSkSurface(bool use_distance_field_text);
341 ResourceProvider* resource_provider_;
342 ResourceProvider::Resource* resource_;
343 base::ThreadChecker thread_checker_;
345 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGr);
348 class Fence : public base::RefCounted<Fence> {
352 virtual void Set() = 0;
353 virtual bool HasPassed() = 0;
354 virtual void Wait() = 0;
357 friend class base::RefCounted<Fence>;
361 DISALLOW_COPY_AND_ASSIGN(Fence);
364 class SynchronousFence : public ResourceProvider::Fence {
366 explicit SynchronousFence(gpu::gles2::GLES2Interface* gl);
368 // Overridden from Fence:
370 bool HasPassed() override;
371 void Wait() override;
373 // Returns true if fence has been set but not yet synchornized.
374 bool has_synchronized() const { return has_synchronized_; }
377 ~SynchronousFence() override;
381 gpu::gles2::GLES2Interface* gl_;
382 bool has_synchronized_;
384 DISALLOW_COPY_AND_ASSIGN(SynchronousFence);
387 // Acquire pixel buffer for resource. The pixel buffer can be used to
388 // set resource pixels without performing unnecessary copying.
389 void AcquirePixelBuffer(ResourceId resource);
390 void ReleasePixelBuffer(ResourceId resource);
391 // Map/unmap the acquired pixel buffer.
392 uint8_t* MapPixelBuffer(ResourceId id, int* stride);
393 void UnmapPixelBuffer(ResourceId id);
394 // Asynchronously update pixels from acquired pixel buffer.
395 void BeginSetPixels(ResourceId id);
396 void ForceSetPixelsToComplete(ResourceId id);
397 bool DidSetPixelsComplete(ResourceId id);
399 // For tests only! This prevents detecting uninitialized reads.
400 // Use SetPixels or LockForWrite to allocate implicitly.
401 void AllocateForTesting(ResourceId id);
404 void CreateForTesting(ResourceId id);
406 GLenum TargetForTesting(ResourceId id);
408 // Sets the current read fence. If a resource is locked for read
409 // and has read fences enabled, the resource will not allow writes
410 // until this fence has passed.
411 void SetReadLockFence(Fence* fence) { current_read_lock_fence_ = fence; }
413 // Indicates if we can currently lock this resource for write.
414 bool CanLockForWrite(ResourceId id);
416 // Copy pixels from source to destination.
417 void CopyResource(ResourceId source_id, ResourceId dest_id);
419 void WaitSyncPointIfNeeded(ResourceId id);
421 void WaitReadLockIfNeeded(ResourceId id);
423 static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
427 enum Origin { Internal, External, Delegated };
431 Resource(unsigned texture_id,
432 const gfx::Size& size,
439 ResourceFormat format);
440 Resource(uint8_t* pixels,
441 SharedBitmap* bitmap,
442 const gfx::Size& size,
446 Resource(const SharedBitmapId& bitmap_id,
447 const gfx::Size& size,
454 // Pixel buffer used for set pixels without unnecessary copying.
455 unsigned gl_pixel_buffer_id;
456 // Query used to determine when asynchronous set pixels complete.
457 unsigned gl_upload_query_id;
458 // Query used to determine when read lock fence has passed.
459 unsigned gl_read_lock_query_id;
460 TextureMailbox mailbox;
461 ReleaseCallbackImpl release_callback_impl;
463 int lock_for_read_count;
466 bool dirty_image : 1;
467 bool locked_for_write : 1;
469 bool marked_for_deletion : 1;
470 bool pending_set_pixels : 1;
471 bool set_pixels_completion_forced : 1;
473 bool read_lock_fences_enabled : 1;
474 bool has_shared_bitmap_id : 1;
475 bool allow_overlay : 1;
476 scoped_refptr<Fence> read_lock_fence;
480 // TODO(skyostil): Use a separate sampler object for filter state.
481 GLenum original_filter;
484 unsigned bound_image_id;
489 ResourceFormat format;
490 SharedBitmapId shared_bitmap_id;
491 SharedBitmap* shared_bitmap;
492 gfx::GpuMemoryBuffer* gpu_memory_buffer;
493 skia::RefPtr<SkSurface> sk_surface;
495 typedef base::hash_map<ResourceId, Resource> ResourceMap;
497 static bool CompareResourceMapIteratorsByChildId(
498 const std::pair<ReturnedResource, ResourceMap::iterator>& a,
499 const std::pair<ReturnedResource, ResourceMap::iterator>& b);
505 ResourceIdMap child_to_parent_map;
506 ResourceIdMap parent_to_child_map;
507 ReturnCallback return_callback;
508 ResourceIdSet in_use_resources;
509 bool marked_for_deletion;
511 typedef base::hash_map<int, Child> ChildMap;
513 bool ReadLockFenceHasPassed(const Resource* resource) {
514 return !resource->read_lock_fence.get() ||
515 resource->read_lock_fence->HasPassed();
518 ResourceProvider(OutputSurface* output_surface,
519 SharedBitmapManager* shared_bitmap_manager,
520 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
521 BlockingTaskRunner* blocking_main_thread_task_runner,
522 int highp_threshold_min,
523 bool use_rgba_4444_texture_format,
524 size_t id_allocation_chunk_size);
526 void CleanUpGLIfNeeded();
528 Resource* GetResource(ResourceId id);
529 const Resource* LockForRead(ResourceId id);
530 void UnlockForRead(ResourceId id);
531 Resource* LockForWrite(ResourceId id);
532 void UnlockForWrite(Resource* resource);
534 static void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
535 const Resource* resource);
537 void TransferResource(gpu::gles2::GLES2Interface* gl,
539 TransferableResource* resource);
544 void DeleteResourceInternal(ResourceMap::iterator it, DeleteStyle style);
545 void DeleteAndReturnUnusedResourcesToChild(ChildMap::iterator child_it,
547 const ResourceIdArray& unused);
548 void DestroyChildInternal(ChildMap::iterator it, DeleteStyle style);
549 void LazyCreate(Resource* resource);
550 void LazyAllocate(Resource* resource);
552 void BindImageForSampling(Resource* resource);
553 // Binds the given GL resource to a texture target for sampling using the
554 // specified filter for both minification and magnification. Returns the
555 // texture target used. The resource must be locked for reading.
556 GLenum BindForSampling(ResourceId resource_id, GLenum unit, GLenum filter);
558 // Returns NULL if the output_surface_ does not have a ContextProvider.
559 gpu::gles2::GLES2Interface* ContextGL() const;
560 class GrContext* GrContext() const;
562 OutputSurface* output_surface_;
563 SharedBitmapManager* shared_bitmap_manager_;
564 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
565 BlockingTaskRunner* blocking_main_thread_task_runner_;
566 bool lost_output_surface_;
567 int highp_threshold_min_;
569 ResourceMap resources_;
573 ResourceType default_resource_type_;
574 bool use_texture_storage_ext_;
575 bool use_texture_format_bgra_;
576 bool use_texture_usage_hint_;
577 bool use_compressed_texture_etc1_;
578 scoped_ptr<TextureUploader> texture_uploader_;
579 int max_texture_size_;
580 ResourceFormat best_texture_format_;
582 base::ThreadChecker thread_checker_;
584 scoped_refptr<Fence> current_read_lock_fence_;
585 bool use_rgba_4444_texture_format_;
587 const size_t id_allocation_chunk_size_;
588 scoped_ptr<IdAllocator> texture_id_allocator_;
589 scoped_ptr<IdAllocator> buffer_id_allocator_;
591 bool use_sync_query_;
592 // Fence used for CopyResource if CHROMIUM_sync_query is not supported.
593 scoped_refptr<SynchronousFence> synchronous_fence_;
595 DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
599 // TODO(epenner): Move these format conversions to resource_format.h
600 // once that builds on mac (npapi.h currently #includes OpenGL.h).
601 inline unsigned BitsPerPixel(ResourceFormat format) {
602 DCHECK_LE(format, RESOURCE_FORMAT_MAX);
603 static const unsigned format_bits_per_pixel[RESOURCE_FORMAT_MAX + 1] = {
612 return format_bits_per_pixel[format];
615 inline GLenum GLDataType(ResourceFormat format) {
616 DCHECK_LE(format, RESOURCE_FORMAT_MAX);
617 static const unsigned format_gl_data_type[RESOURCE_FORMAT_MAX + 1] = {
618 GL_UNSIGNED_BYTE, // RGBA_8888
619 GL_UNSIGNED_SHORT_4_4_4_4, // RGBA_4444
620 GL_UNSIGNED_BYTE, // BGRA_8888
621 GL_UNSIGNED_BYTE, // ALPHA_8
622 GL_UNSIGNED_BYTE, // LUMINANCE_8
623 GL_UNSIGNED_SHORT_5_6_5, // RGB_565,
624 GL_UNSIGNED_BYTE // ETC1
626 return format_gl_data_type[format];
629 inline GLenum GLDataFormat(ResourceFormat format) {
630 DCHECK_LE(format, RESOURCE_FORMAT_MAX);
631 static const unsigned format_gl_data_format[RESOURCE_FORMAT_MAX + 1] = {
632 GL_RGBA, // RGBA_8888
633 GL_RGBA, // RGBA_4444
634 GL_BGRA_EXT, // BGRA_8888
636 GL_LUMINANCE, // LUMINANCE_8
638 GL_ETC1_RGB8_OES // ETC1
640 return format_gl_data_format[format];
643 inline GLenum GLInternalFormat(ResourceFormat format) {
644 return GLDataFormat(format);
649 #endif // CC_RESOURCES_RESOURCE_PROVIDER_H_