Tile Compression

cc/resources/resource_provider.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 57 matching lines @@
   switch (format) {
     case RGBA_8888:
       break;
     case BGRA_8888:
       storage_format = GL_BGRA8_EXT;
       break;
     case RGBA_4444:
     case ALPHA_8:
     case LUMINANCE_8:
     case RGB_565:
+    case ATC:
+    case ATC_IA:
+    case DXT1:
+    case DXT5:
     case ETC1:
     case RED_8:
       NOTREACHED();
       break;
   }
 
   return storage_format;
 }
 
 bool IsFormatSupportedForStorage(ResourceFormat format, bool use_bgra) {
   switch (format) {
     case RGBA_8888:
       return true;
     case BGRA_8888:
       return use_bgra;
     case RGBA_4444:
     case ALPHA_8:
     case LUMINANCE_8:
     case RGB_565:
+    case ATC:
+    case ATC_IA:
+    case DXT1:
+    case DXT5:
     case ETC1:
     case RED_8:
       return false;
   }
   return false;
 }
 
 GrPixelConfig ToGrPixelConfig(ResourceFormat format) {
   switch (format) {
     case RGBA_8888:
       return kRGBA_8888_GrPixelConfig;
     case BGRA_8888:
       return kBGRA_8888_GrPixelConfig;
     case RGBA_4444:
       return kRGBA_4444_GrPixelConfig;
     default:
       break;
   }
   DCHECK(false) << "Unsupported resource format.";
   return kSkia8888_GrPixelConfig;
 }
 
 gfx::GpuMemoryBuffer::Format ToGpuMemoryBufferFormat(ResourceFormat format) {
   switch (format) {
     case RGBA_8888:
       return gfx::GpuMemoryBuffer::Format::RGBA_8888;
     case BGRA_8888:
       return gfx::GpuMemoryBuffer::Format::BGRA_8888;
+    case ATC:
+      return gfx::GpuMemoryBuffer::Format::ATC;
+    case ATC_IA:
+      return gfx::GpuMemoryBuffer::Format::ATCIA;
+    case DXT1:
+      return gfx::GpuMemoryBuffer::Format::DXT1;
+    case DXT5:
+      return gfx::GpuMemoryBuffer::Format::DXT5;
+    case ETC1:
+      return gfx::GpuMemoryBuffer::Format::ETC1;
+    case RED_8:
     case RGBA_4444:
     case ALPHA_8:
     case LUMINANCE_8:
     case RGB_565:
-    case ETC1:
-    case RED_8:
       break;
   }
   NOTREACHED();
   return gfx::GpuMemoryBuffer::Format::RGBA_8888;
 }
 
 class ScopedSetActiveTexture {
  public:
   ScopedSetActiveTexture(GLES2Interface* gl, GLenum unit)
       : gl_(gl), unit_(unit) {
@@ skipping 271 matching lines @@
       wrap_mode(wrap_mode),
       hint(TextureHintImmutable),
       type(Bitmap),
       format(RGBA_8888),
       shared_bitmap_id(bitmap_id),
       shared_bitmap(NULL),
       gpu_memory_buffer(NULL) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
 }
 
+bool ResourceProvider::Resource::IsCompressed() const {
+  return IsFormatCompressed(format);
+}
+
+size_t ResourceProvider::Resource::CompressedSize() const {
+  switch (format) {
+    case ATC:
+    case DXT1:
+    case ETC1:
+      return size.width() * size.height() / 2;
+    case ATC_IA:
+    case DXT5:
+      return size.width() * size.height();
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
 ResourceProvider::Child::Child() : marked_for_deletion(false) {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
+    bool use_texture_compression,
     size_t id_allocation_chunk_size) {
-  scoped_ptr<ResourceProvider> resource_provider(
-      new ResourceProvider(output_surface,
-                           shared_bitmap_manager,
-                           gpu_memory_buffer_manager,
-                           blocking_main_thread_task_runner,
-                           highp_threshold_min,
-                           use_rgba_4444_texture_format,
-                           id_allocation_chunk_size));
+  scoped_ptr<ResourceProvider> resource_provider(new ResourceProvider(
+      output_surface, shared_bitmap_manager, gpu_memory_buffer_manager,
+      blocking_main_thread_task_runner, highp_threshold_min,
+      use_rgba_4444_texture_format, use_texture_compression,
+      id_allocation_chunk_size));
 
   if (resource_provider->ContextGL())
     resource_provider->InitializeGL();
   else
     resource_provider->InitializeSoftware();
 
   DCHECK_NE(InvalidType, resource_provider->default_resource_type());
   return resource_provider.Pass();
 }
 
 ResourceProvider::~ResourceProvider() {
   while (!children_.empty())
     DestroyChildInternal(children_.begin(), ForShutdown);
   while (!resources_.empty())
     DeleteResourceInternal(resources_.begin(), ForShutdown);
 
   CleanUpGLIfNeeded();
 }
 
+ResourceFormat ResourceProvider::memory_efficient_texture_format(
+    ResourceFormatUsage usage) const {
+  if (use_texture_compression_ && usage != FORMAT_USAGE_NATIVE) {
+    // Try to select the prefered compression method.
+    switch (preferred_tile_compression_method_) {
+      case TILE_COMPRESSION_METHOD_ATC:
+        if (use_compressed_texture_atc_) {
+          return usage == FORMAT_USAGE_OPAQUE ? ATC : ATC_IA;
+        }
+        break;
+      case TILE_COMPRESSION_METHOD_DXT:
+        if (use_compressed_texture_dxt_) {
+          return usage == FORMAT_USAGE_OPAQUE ? DXT1 : DXT5;
+        }
+        break;
+      case TILE_COMPRESSION_METHOD_ETC:
+        if (use_compressed_texture_etc1_ && usage == FORMAT_USAGE_OPAQUE) {
+          return ETC1;
+        }
+        break;
+      default:
+        break;
+    }
+
+    // Check the formats in preferred order, based on encoding speed and
+    // compression ratio.
+    if (use_compressed_texture_atc_) {
+      return usage == FORMAT_USAGE_OPAQUE ? ATC : ATC_IA;
+    }
+    if (use_compressed_texture_dxt_) {
+      return usage == FORMAT_USAGE_OPAQUE ? DXT1 : DXT5;
+    }
+  }
+
+  return use_rgba_4444_texture_format_ ? RGBA_4444 : best_texture_format_;
+}
+
 bool ResourceProvider::InUseByConsumer(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lock_for_read_count > 0 || resource->exported_count > 0 ||
          resource->lost;
 }
 
 bool ResourceProvider::IsLost(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lost;
 }
@@ skipping 727 matching lines @@
   gl_->Finish();
 }
 
 ResourceProvider::ResourceProvider(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
+    bool use_texture_compression,
     size_t id_allocation_chunk_size)
     : output_surface_(output_surface),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       default_resource_type_(InvalidType),
       use_texture_storage_ext_(false),
       use_texture_format_bgra_(false),
       use_texture_usage_hint_(false),
+      use_compressed_texture_atc_(false),
+      use_compressed_texture_dxt_(false),
       use_compressed_texture_etc1_(false),
       yuv_resource_format_(LUMINANCE_8),
       max_texture_size_(0),
       best_texture_format_(RGBA_8888),
       use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
+      use_texture_compression_(use_texture_compression),
       id_allocation_chunk_size_(id_allocation_chunk_size),
       use_sync_query_(false) {
   DCHECK(output_surface_->HasClient());
   DCHECK(id_allocation_chunk_size_);
 }
 
 void ResourceProvider::InitializeSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(Bitmap, default_resource_type_);
 
@@ skipping 14 matching lines @@
 
   default_resource_type_ = GLTexture;
 
   const ContextProvider::Capabilities& caps =
       output_surface_->context_provider()->ContextCapabilities();
 
   bool use_bgra = caps.gpu.texture_format_bgra8888;
   use_texture_storage_ext_ = caps.gpu.texture_storage;
   use_texture_format_bgra_ = caps.gpu.texture_format_bgra8888;
   use_texture_usage_hint_ = caps.gpu.texture_usage;
+  use_compressed_texture_atc_ = caps.gpu.texture_format_atc;
+  use_compressed_texture_dxt_ = caps.gpu.texture_format_dxt;
   use_compressed_texture_etc1_ = caps.gpu.texture_format_etc1;
   yuv_resource_format_ = caps.gpu.texture_rg ? RED_8 : LUMINANCE_8;
   use_sync_query_ = caps.gpu.sync_query;
 
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
 
   texture_uploader_ = TextureUploader::Create(gl);
   max_texture_size_ = 0;  // Context expects cleared value.
   GLC(gl, gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_));
@@ skipping 455 matching lines @@
 }
 
 void ResourceProvider::AcquirePixelBuffer(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::AcquirePixelBuffer");
 
   Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
-  DCHECK_NE(ETC1, resource->format);
 
   DCHECK_EQ(GLTexture, resource->type);
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   if (!resource->gl_pixel_buffer_id)
     resource->gl_pixel_buffer_id = buffer_id_allocator_->NextId();
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
-  unsigned bytes_per_pixel = BitsPerPixel(resource->format) / 8;
-  gl->BufferData(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-                 resource->size.height() *
-                     RoundUp(bytes_per_pixel * resource->size.width(), 4u),
-                 NULL,
+  unsigned width_in_bytes =
+      BitsPerPixel(resource->format) * resource->size.width() / 8;
+  unsigned image_size = resource->size.height() * RoundUp(width_in_bytes, 4u);
+  DCHECK(image_size);
+  gl->BufferData(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, image_size, NULL,
                  GL_DYNAMIC_DRAW);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 }
 
 void ResourceProvider::ReleasePixelBuffer(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::ReleasePixelBuffer");
 
   Resource* resource = GetResource(id);
   DCHECK(resource->origin == Resource::Internal);
@@ skipping 116 matching lines @@
   DCHECK(gl);
   DCHECK(resource->gl_pixel_buffer_id);
   DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
   gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
                  resource->gl_pixel_buffer_id);
   if (!resource->gl_upload_query_id)
     gl->GenQueriesEXT(1, &resource->gl_upload_query_id);
   gl->BeginQueryEXT(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM,
                     resource->gl_upload_query_id);
-  if (allocate) {
-    gl->AsyncTexImage2DCHROMIUM(GL_TEXTURE_2D,
-                                0, /* level */
-                                GLInternalFormat(resource->format),
-                                resource->size.width(),
-                                resource->size.height(),
-                                0, /* border */
-                                GLDataFormat(resource->format),
-                                GLDataType(resource->format),
-                                NULL);
+  if (resource->IsCompressed()) {
+    if (allocate) {
+      gl->AsyncCompressedTexImage2DCHROMIUM(
+          GL_TEXTURE_2D, 0 /* level */, GLInternalFormat(resource->format),
+          resource->size.width(), resource->size.height(), 0 /* border */,
+          resource->CompressedSize(), NULL);
+    } else {
+      gl->AsyncCompressedTexSubImage2DCHROMIUM(
+          GL_TEXTURE_2D, 0 /* level */, 0 /* x */, 0 /* y */,
+          resource->size.width(), resource->size.height(),
+          GLInternalFormat(resource->format), resource->CompressedSize(), NULL);
+    }
   } else {
-    gl->AsyncTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
-                                   0, /* level */
-                                   0, /* x */
-                                   0, /* y */
-                                   resource->size.width(),
-                                   resource->size.height(),
-                                   GLDataFormat(resource->format),
-                                   GLDataType(resource->format),
-                                   NULL);
+    if (allocate) {
+      gl->AsyncTexImage2DCHROMIUM(
+          GL_TEXTURE_2D, 0, /* level */
+          GLInternalFormat(resource->format), resource->size.width(),
+          resource->size.height(), 0, /* border */
+          GLDataFormat(resource->format), GLDataType(resource->format), NULL);
+    } else {
+      gl->AsyncTexSubImage2DCHROMIUM(
+          GL_TEXTURE_2D, 0, /* level */
+          0,                /* x */
+          0,                /* y */
+          resource->size.width(), resource->size.height(),
+          GLDataFormat(resource->format), GLDataType(resource->format), NULL);
+    }
   }
   gl->EndQueryEXT(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM);
   gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
 
   resource->pending_set_pixels = true;
   resource->set_pixels_completion_forced = false;
 }
 
 void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
@@ skipping 113 matching lines @@
   ResourceFormat format = resource->format;
   GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
   if (use_texture_storage_ext_ &&
       IsFormatSupportedForStorage(format, use_texture_format_bgra_) &&
       (resource->hint & TextureHintImmutable)) {
     GLenum storage_format = TextureToStorageFormat(format);
     GLC(gl,
         gl->TexStorage2DEXT(
             GL_TEXTURE_2D, 1, storage_format, size.width(), size.height()));
   } else {
-    // ETC1 does not support preallocation.
-    if (format != ETC1) {
+    // Compressed formats does not support preallocation.
+    if (!IsFormatCompressed(format)) {
       GLC(gl,
           gl->TexImage2D(GL_TEXTURE_2D,
                          0,
                          GLInternalFormat(format),
                          size.width(),
                          size.height(),
                          0,
                          GLDataFormat(format),
                          GLDataType(format),
                          NULL));
@@ skipping 44 matching lines @@
     BindImageForSampling(source_resource);
   }
   if (use_sync_query_) {
     if (!source_resource->gl_read_lock_query_id)
       gl->GenQueriesEXT(1, &source_resource->gl_read_lock_query_id);
     gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
                       source_resource->gl_read_lock_query_id);
   }
   DCHECK(!dest_resource->image_id);
   dest_resource->allocated = true;
-  gl->CopyTextureCHROMIUM(dest_resource->target,
-                          source_resource->gl_id,
-                          dest_resource->gl_id,
-                          0,
-                          GLInternalFormat(dest_resource->format),
-                          GLDataType(dest_resource->format));
+  if (!source_resource->IsCompressed()) {
+    gl->CopyTextureCHROMIUM(dest_resource->target, source_resource->gl_id,
+                            dest_resource->gl_id, 0,
+                            GLInternalFormat(dest_resource->format),
+                            GLDataType(dest_resource->format));
+  } else {
+    gl->CopyCompressedTextureCHROMIUM(
+        dest_resource->target, source_resource->gl_id, dest_resource->gl_id,
+        GLInternalFormat(dest_resource->format),
+        GLDataType(dest_resource->format));
+  }
   if (source_resource->gl_read_lock_query_id) {
     // End query and create a read lock fence that will prevent access to
     // source resource until CopyTextureCHROMIUM command has completed.
     gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
     source_resource->read_lock_fence = make_scoped_refptr(
         new CopyTextureFence(gl, source_resource->gl_read_lock_query_id));
   } else {
     // Create a SynchronousFence when CHROMIUM_sync_query extension is missing.
     // Try to use one synchronous fence for as many CopyResource operations as
     // possible as that reduce the number of times we have to synchronize with
@@ skipping 39 matching lines @@
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 class GrContext* ResourceProvider::GrContext() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc