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