cc/resources/resource_provider.h

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