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.
4
5#ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
6#define CC_RESOURCES_RESOURCE_PROVIDER_H_
7
8#include <deque>
9#include <set>
10#include <string>
11#include <utility>
12#include <vector>
13
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/size.h"
35
36class GrContext;
37
38namespace gpu {
39namespace gles {
40class GLES2Interface;
41}
42}
43
44namespace gfx {
45class Rect;
46class Vector2d;
47}
48
49namespace cc {
50class BlockingTaskRunner;
51class IdAllocator;
52class SharedBitmap;
53class SharedBitmapManager;
54class TextureUploader;
55
56// This class is not thread-safe and can only be called from the thread it was
57// created on (in practice, the impl thread).
58class CC_EXPORT ResourceProvider {
59 public:
60  typedef unsigned ResourceId;
61  typedef std::vector<ResourceId> ResourceIdArray;
62  typedef std::set<ResourceId> ResourceIdSet;
63  typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
64  enum TextureHint {
65    TextureHintDefault = 0x0,
66    TextureHintImmutable = 0x1,
67    TextureHintFramebuffer = 0x2,
68    TextureHintImmutableFramebuffer =
69        TextureHintImmutable | TextureHintFramebuffer
70  };
71  enum ResourceType {
72    InvalidType = 0,
73    GLTexture = 1,
74    Bitmap,
75  };
76
77  static scoped_ptr<ResourceProvider> Create(
78      OutputSurface* output_surface,
79      SharedBitmapManager* shared_bitmap_manager,
80      BlockingTaskRunner* blocking_main_thread_task_runner,
81      int highp_threshold_min,
82      bool use_rgba_4444_texture_format,
83      size_t id_allocation_chunk_size,
84      bool use_distance_field_text);
85  virtual ~ResourceProvider();
86
87  void InitializeSoftware();
88  void InitializeGL();
89
90  void DidLoseOutputSurface() { lost_output_surface_ = true; }
91
92  int max_texture_size() const { return max_texture_size_; }
93  ResourceFormat memory_efficient_texture_format() const {
94    return use_rgba_4444_texture_format_ ? RGBA_4444 : best_texture_format_;
95  }
96  ResourceFormat best_texture_format() const { return best_texture_format_; }
97  bool use_sync_query() const { return use_sync_query_; }
98  size_t num_resources() const { return resources_.size(); }
99
100  // Checks whether a resource is in use by a consumer.
101  bool InUseByConsumer(ResourceId id);
102
103  bool IsLost(ResourceId id);
104  bool AllowOverlay(ResourceId id);
105
106  // Producer interface.
107
108  ResourceType default_resource_type() const { return default_resource_type_; }
109  ResourceType GetResourceType(ResourceId id);
110
111  // Creates a resource of the default resource type.
112  ResourceId CreateResource(const gfx::Size& size,
113                            GLint wrap_mode,
114                            TextureHint hint,
115                            ResourceFormat format);
116
117  // Creates a resource which is tagged as being managed for GPU memory
118  // accounting purposes.
119  ResourceId CreateManagedResource(const gfx::Size& size,
120                                   GLenum target,
121                                   GLint wrap_mode,
122                                   TextureHint hint,
123                                   ResourceFormat format);
124
125  // You can also explicitly create a specific resource type.
126  ResourceId CreateGLTexture(const gfx::Size& size,
127                             GLenum target,
128                             GLenum texture_pool,
129                             GLint wrap_mode,
130                             TextureHint hint,
131                             ResourceFormat format);
132
133  ResourceId CreateBitmap(const gfx::Size& size, GLint wrap_mode);
134  // Wraps an IOSurface into a GL resource.
135  ResourceId CreateResourceFromIOSurface(const gfx::Size& size,
136                                         unsigned io_surface_id);
137
138  // Wraps an external texture mailbox into a GL resource.
139  ResourceId CreateResourceFromTextureMailbox(
140      const TextureMailbox& mailbox,
141      scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl);
142
143  void DeleteResource(ResourceId id);
144
145  // Update pixels from image, copying source_rect (in image) to dest_offset (in
146  // the resource).
147  void SetPixels(ResourceId id,
148                 const uint8_t* image,
149                 const gfx::Rect& image_rect,
150                 const gfx::Rect& source_rect,
151                 const gfx::Vector2d& dest_offset);
152
153  // Check upload status.
154  size_t NumBlockingUploads();
155  void MarkPendingUploadsAsNonBlocking();
156  size_t EstimatedUploadsPerTick();
157  void FlushUploads();
158  void ReleaseCachedData();
159  base::TimeTicks EstimatedUploadCompletionTime(size_t uploads_per_tick);
160
161  // Only flush the command buffer if supported.
162  // Returns true if the shallow flush occurred, false otherwise.
163  bool ShallowFlushIfSupported();
164
165  // Creates accounting for a child. Returns a child ID.
166  int CreateChild(const ReturnCallback& return_callback);
167
168  // Destroys accounting for the child, deleting all accounted resources.
169  void DestroyChild(int child);
170
171  // Gets the child->parent resource ID map.
172  const ResourceIdMap& GetChildToParentMap(int child) const;
173
174  // Prepares resources to be transfered to the parent, moving them to
175  // mailboxes and serializing meta-data into TransferableResources.
176  // Resources are not removed from the ResourceProvider, but are marked as
177  // "in use".
178  void PrepareSendToParent(const ResourceIdArray& resources,
179                           TransferableResourceArray* transferable_resources);
180
181  // Receives resources from a child, moving them from mailboxes. Resource IDs
182  // passed are in the child namespace, and will be translated to the parent
183  // namespace, added to the child->parent map.
184  // This adds the resources to the working set in the ResourceProvider without
185  // declaring which resources are in use. Use DeclareUsedResourcesFromChild
186  // after calling this method to do that. All calls to ReceiveFromChild should
187  // be followed by a DeclareUsedResourcesFromChild.
188  // NOTE: if the sync_point is set on any TransferableResource, this will
189  // wait on it.
190  void ReceiveFromChild(
191      int child, const TransferableResourceArray& transferable_resources);
192
193  // Once a set of resources have been received, they may or may not be used.
194  // This declares what set of resources are currently in use from the child,
195  // releasing any other resources back to the child.
196  void DeclareUsedResourcesFromChild(
197      int child,
198      const ResourceIdArray& resources_from_child);
199
200  // Receives resources from the parent, moving them from mailboxes. Resource
201  // IDs passed are in the child namespace.
202  // NOTE: if the sync_point is set on any TransferableResource, this will
203  // wait on it.
204  void ReceiveReturnsFromParent(
205      const ReturnedResourceArray& transferable_resources);
206
207  // The following lock classes are part of the ResourceProvider API and are
208  // needed to read and write the resource contents. The user must ensure
209  // that they only use GL locks on GL resources, etc, and this is enforced
210  // by assertions.
211  class CC_EXPORT ScopedReadLockGL {
212   public:
213    ScopedReadLockGL(ResourceProvider* resource_provider,
214                     ResourceProvider::ResourceId resource_id);
215    virtual ~ScopedReadLockGL();
216
217    unsigned texture_id() const { return texture_id_; }
218
219   protected:
220    ResourceProvider* resource_provider_;
221    ResourceProvider::ResourceId resource_id_;
222
223   private:
224    unsigned texture_id_;
225
226    DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL);
227  };
228
229  class CC_EXPORT ScopedSamplerGL : public ScopedReadLockGL {
230   public:
231    ScopedSamplerGL(ResourceProvider* resource_provider,
232                    ResourceProvider::ResourceId resource_id,
233                    GLenum filter);
234    ScopedSamplerGL(ResourceProvider* resource_provider,
235                    ResourceProvider::ResourceId resource_id,
236                    GLenum unit,
237                    GLenum filter);
238    virtual ~ScopedSamplerGL();
239
240    GLenum target() const { return target_; }
241
242   private:
243    GLenum unit_;
244    GLenum target_;
245
246    DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL);
247  };
248
249  class CC_EXPORT ScopedWriteLockGL {
250   public:
251    ScopedWriteLockGL(ResourceProvider* resource_provider,
252                      ResourceProvider::ResourceId resource_id);
253    ~ScopedWriteLockGL();
254
255    unsigned texture_id() const { return texture_id_; }
256
257   private:
258    ResourceProvider* resource_provider_;
259    ResourceProvider::ResourceId resource_id_;
260    unsigned texture_id_;
261
262    DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL);
263  };
264
265  class CC_EXPORT ScopedReadLockSoftware {
266   public:
267    ScopedReadLockSoftware(ResourceProvider* resource_provider,
268                           ResourceProvider::ResourceId resource_id);
269    ~ScopedReadLockSoftware();
270
271    const SkBitmap* sk_bitmap() const {
272      DCHECK(valid());
273      return &sk_bitmap_;
274    }
275    GLint wrap_mode() const { return wrap_mode_; }
276
277    bool valid() const { return !!sk_bitmap_.getPixels(); }
278
279   private:
280    ResourceProvider* resource_provider_;
281    ResourceProvider::ResourceId resource_id_;
282    SkBitmap sk_bitmap_;
283    GLint wrap_mode_;
284
285    DISALLOW_COPY_AND_ASSIGN(ScopedReadLockSoftware);
286  };
287
288  class CC_EXPORT ScopedWriteLockSoftware {
289   public:
290    ScopedWriteLockSoftware(ResourceProvider* resource_provider,
291                            ResourceProvider::ResourceId resource_id);
292    ~ScopedWriteLockSoftware();
293
294    SkCanvas* sk_canvas() { return sk_canvas_.get(); }
295    bool valid() const { return !!sk_bitmap_.getPixels(); }
296
297   private:
298    ResourceProvider* resource_provider_;
299    ResourceProvider::ResourceId resource_id_;
300    SkBitmap sk_bitmap_;
301    scoped_ptr<SkCanvas> sk_canvas_;
302
303    DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware);
304  };
305
306  class Fence : public base::RefCounted<Fence> {
307   public:
308    Fence() {}
309
310    virtual void Set() = 0;
311    virtual bool HasPassed() = 0;
312
313   protected:
314    friend class base::RefCounted<Fence>;
315    virtual ~Fence() {}
316
317   private:
318    DISALLOW_COPY_AND_ASSIGN(Fence);
319  };
320
321  // Acquire pixel buffer for resource. The pixel buffer can be used to
322  // set resource pixels without performing unnecessary copying.
323  void AcquirePixelBuffer(ResourceId resource);
324  void ReleasePixelBuffer(ResourceId resource);
325  // Map/unmap the acquired pixel buffer.
326  uint8_t* MapPixelBuffer(ResourceId id, int* stride);
327  void UnmapPixelBuffer(ResourceId id);
328  // Asynchronously update pixels from acquired pixel buffer.
329  void BeginSetPixels(ResourceId id);
330  void ForceSetPixelsToComplete(ResourceId id);
331  bool DidSetPixelsComplete(ResourceId id);
332
333  // Acquire and release an image. The image allows direct
334  // manipulation of texture memory.
335  void AcquireImage(ResourceId id);
336  void ReleaseImage(ResourceId id);
337  // Maps the acquired image so that its pixels could be modified.
338  // Unmap is called when all pixels are set.
339  uint8_t* MapImage(ResourceId id, int* stride);
340  void UnmapImage(ResourceId id);
341
342  // Acquire and release a SkSurface.
343  void AcquireSkSurface(ResourceId id);
344  void ReleaseSkSurface(ResourceId id);
345  // Lock/unlock resource for writing to SkSurface.
346  SkSurface* LockForWriteToSkSurface(ResourceId id);
347  void UnlockForWriteToSkSurface(ResourceId id);
348
349  // For tests only! This prevents detecting uninitialized reads.
350  // Use SetPixels or LockForWrite to allocate implicitly.
351  void AllocateForTesting(ResourceId id);
352
353  // For tests only!
354  void CreateForTesting(ResourceId id);
355
356  GLenum TargetForTesting(ResourceId id);
357
358  // Sets the current read fence. If a resource is locked for read
359  // and has read fences enabled, the resource will not allow writes
360  // until this fence has passed.
361  void SetReadLockFence(Fence* fence) { current_read_lock_fence_ = fence; }
362
363  // Enable read lock fences for a specific resource.
364  void EnableReadLockFences(ResourceId id);
365
366  // Indicates if we can currently lock this resource for write.
367  bool CanLockForWrite(ResourceId id);
368
369  // Copy pixels from source to destination.
370  void CopyResource(ResourceId source_id, ResourceId dest_id);
371
372  void WaitSyncPointIfNeeded(ResourceId id);
373
374  static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
375
376 private:
377  struct Resource {
378    enum Origin { Internal, External, Delegated };
379
380    Resource();
381    ~Resource();
382    Resource(unsigned texture_id,
383             const gfx::Size& size,
384             Origin origin,
385             GLenum target,
386             GLenum filter,
387             GLenum texture_pool,
388             GLint wrap_mode,
389             TextureHint hint,
390             ResourceFormat format);
391    Resource(uint8_t* pixels,
392             SharedBitmap* bitmap,
393             const gfx::Size& size,
394             Origin origin,
395             GLenum filter,
396             GLint wrap_mode);
397    Resource(const SharedBitmapId& bitmap_id,
398             const gfx::Size& size,
399             Origin origin,
400             GLenum filter,
401             GLint wrap_mode);
402
403    int child_id;
404    unsigned gl_id;
405    // Pixel buffer used for set pixels without unnecessary copying.
406    unsigned gl_pixel_buffer_id;
407    // Query used to determine when asynchronous set pixels complete.
408    unsigned gl_upload_query_id;
409    // Query used to determine when read lock fence has passed.
410    unsigned gl_read_lock_query_id;
411    TextureMailbox mailbox;
412    ReleaseCallbackImpl release_callback_impl;
413    uint8_t* pixels;
414    int lock_for_read_count;
415    int imported_count;
416    int exported_count;
417    bool dirty_image : 1;
418    bool locked_for_write : 1;
419    bool lost : 1;
420    bool marked_for_deletion : 1;
421    bool pending_set_pixels : 1;
422    bool set_pixels_completion_forced : 1;
423    bool allocated : 1;
424    bool read_lock_fences_enabled : 1;
425    bool has_shared_bitmap_id : 1;
426    bool allow_overlay : 1;
427    scoped_refptr<Fence> read_lock_fence;
428    gfx::Size size;
429    Origin origin;
430    GLenum target;
431    // TODO(skyostil): Use a separate sampler object for filter state.
432    GLenum original_filter;
433    GLenum filter;
434    unsigned image_id;
435    unsigned bound_image_id;
436    GLenum texture_pool;
437    GLint wrap_mode;
438    TextureHint hint;
439    ResourceType type;
440    ResourceFormat format;
441    SharedBitmapId shared_bitmap_id;
442    SharedBitmap* shared_bitmap;
443    skia::RefPtr<SkSurface> sk_surface;
444  };
445  typedef base::hash_map<ResourceId, Resource> ResourceMap;
446
447  static bool CompareResourceMapIteratorsByChildId(
448      const std::pair<ReturnedResource, ResourceMap::iterator>& a,
449      const std::pair<ReturnedResource, ResourceMap::iterator>& b);
450
451  struct Child {
452    Child();
453    ~Child();
454
455    ResourceIdMap child_to_parent_map;
456    ResourceIdMap parent_to_child_map;
457    ReturnCallback return_callback;
458    ResourceIdSet in_use_resources;
459    bool marked_for_deletion;
460  };
461  typedef base::hash_map<int, Child> ChildMap;
462
463  bool ReadLockFenceHasPassed(const Resource* resource) {
464    return !resource->read_lock_fence.get() ||
465           resource->read_lock_fence->HasPassed();
466  }
467
468  ResourceProvider(OutputSurface* output_surface,
469                   SharedBitmapManager* shared_bitmap_manager,
470                   BlockingTaskRunner* blocking_main_thread_task_runner,
471                   int highp_threshold_min,
472                   bool use_rgba_4444_texture_format,
473                   size_t id_allocation_chunk_size,
474                   bool use_distance_field_text);
475
476  void CleanUpGLIfNeeded();
477
478  Resource* GetResource(ResourceId id);
479  const Resource* LockForRead(ResourceId id);
480  void UnlockForRead(ResourceId id);
481  const Resource* LockForWrite(ResourceId id);
482  void UnlockForWrite(ResourceId id);
483  static void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
484                                           const Resource* resource);
485
486  void TransferResource(gpu::gles2::GLES2Interface* gl,
487                        ResourceId id,
488                        TransferableResource* resource);
489  enum DeleteStyle {
490    Normal,
491    ForShutdown,
492  };
493  void DeleteResourceInternal(ResourceMap::iterator it, DeleteStyle style);
494  void DeleteAndReturnUnusedResourcesToChild(ChildMap::iterator child_it,
495                                             DeleteStyle style,
496                                             const ResourceIdArray& unused);
497  void DestroyChildInternal(ChildMap::iterator it, DeleteStyle style);
498  void LazyCreate(Resource* resource);
499  void LazyAllocate(Resource* resource);
500
501  void BindImageForSampling(Resource* resource);
502  // Binds the given GL resource to a texture target for sampling using the
503  // specified filter for both minification and magnification. Returns the
504  // texture target used. The resource must be locked for reading.
505  GLenum BindForSampling(ResourceId resource_id, GLenum unit, GLenum filter);
506
507  // Returns NULL if the output_surface_ does not have a ContextProvider.
508  gpu::gles2::GLES2Interface* ContextGL() const;
509  class GrContext* GrContext() const;
510
511  OutputSurface* output_surface_;
512  SharedBitmapManager* shared_bitmap_manager_;
513  BlockingTaskRunner* blocking_main_thread_task_runner_;
514  bool lost_output_surface_;
515  int highp_threshold_min_;
516  ResourceId next_id_;
517  ResourceMap resources_;
518  int next_child_;
519  ChildMap children_;
520
521  ResourceType default_resource_type_;
522  bool use_texture_storage_ext_;
523  bool use_texture_format_bgra_;
524  bool use_texture_usage_hint_;
525  bool use_compressed_texture_etc1_;
526  scoped_ptr<TextureUploader> texture_uploader_;
527  int max_texture_size_;
528  ResourceFormat best_texture_format_;
529
530  base::ThreadChecker thread_checker_;
531
532  scoped_refptr<Fence> current_read_lock_fence_;
533  bool use_rgba_4444_texture_format_;
534
535  const size_t id_allocation_chunk_size_;
536  scoped_ptr<IdAllocator> texture_id_allocator_;
537  scoped_ptr<IdAllocator> buffer_id_allocator_;
538
539  bool use_sync_query_;
540
541  bool use_distance_field_text_;
542
543  DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
544};
545
546
547// TODO(epenner): Move these format conversions to resource_format.h
548// once that builds on mac (npapi.h currently #includes OpenGL.h).
549inline unsigned BitsPerPixel(ResourceFormat format) {
550  DCHECK_LE(format, RESOURCE_FORMAT_MAX);
551  static const unsigned format_bits_per_pixel[RESOURCE_FORMAT_MAX + 1] = {
552    32,  // RGBA_8888
553    16,  // RGBA_4444
554    32,  // BGRA_8888
555    8,   // ALPHA_8
556    8,   // LUMINANCE_8
557    16,  // RGB_565,
558    4    // ETC1
559  };
560  return format_bits_per_pixel[format];
561}
562
563inline GLenum GLDataType(ResourceFormat format) {
564  DCHECK_LE(format, RESOURCE_FORMAT_MAX);
565  static const unsigned format_gl_data_type[RESOURCE_FORMAT_MAX + 1] = {
566    GL_UNSIGNED_BYTE,           // RGBA_8888
567    GL_UNSIGNED_SHORT_4_4_4_4,  // RGBA_4444
568    GL_UNSIGNED_BYTE,           // BGRA_8888
569    GL_UNSIGNED_BYTE,           // ALPHA_8
570    GL_UNSIGNED_BYTE,           // LUMINANCE_8
571    GL_UNSIGNED_SHORT_5_6_5,    // RGB_565,
572    GL_UNSIGNED_BYTE            // ETC1
573  };
574  return format_gl_data_type[format];
575}
576
577inline GLenum GLDataFormat(ResourceFormat format) {
578  DCHECK_LE(format, RESOURCE_FORMAT_MAX);
579  static const unsigned format_gl_data_format[RESOURCE_FORMAT_MAX + 1] = {
580    GL_RGBA,           // RGBA_8888
581    GL_RGBA,           // RGBA_4444
582    GL_BGRA_EXT,       // BGRA_8888
583    GL_ALPHA,          // ALPHA_8
584    GL_LUMINANCE,      // LUMINANCE_8
585    GL_RGB,            // RGB_565
586    GL_ETC1_RGB8_OES   // ETC1
587  };
588  return format_gl_data_format[format];
589}
590
591inline GLenum GLInternalFormat(ResourceFormat format) {
592  return GLDataFormat(format);
593}
594
595}  // namespace cc
596
597#endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_
598