media: replace LUMINANCE_F16 by RG_88 for 9/10-bit h264 videos

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 74 matching lines @@
       break;
     case BGRA_8888:
       storage_format = GL_BGRA8_EXT;
       break;
     case RGBA_4444:
     case ALPHA_8:
     case LUMINANCE_8:
     case RGB_565:
     case ETC1:
     case RED_8:
+    case RG_88:
     case LUMINANCE_F16:
       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 ETC1:
     case RED_8:
+    case RG_88:
     case LUMINANCE_F16:
       return false;
   }
   return false;
 }
 
 GrPixelConfig ToGrPixelConfig(ResourceFormat format) {
   switch (format) {
     case RGBA_8888:
       return kRGBA_8888_GrPixelConfig;
@@ skipping 279 matching lines @@
       next_id_(1),
       next_child_(1),
       delegated_sync_points_required_(delegated_sync_points_required),
       default_resource_type_(use_gpu_memory_buffer_resources
                                  ? RESOURCE_TYPE_GPU_MEMORY_BUFFER
                                  : RESOURCE_TYPE_GL_TEXTURE),
       use_texture_storage_ext_(false),
       use_texture_format_bgra_(false),
       use_texture_usage_hint_(false),
       use_compressed_texture_etc1_(false),
-      yuv_resource_format_(LUMINANCE_8),
       max_texture_size_(0),
       best_texture_format_(RGBA_8888),
       best_render_buffer_format_(RGBA_8888),
       enable_color_correct_rendering_(enable_color_correct_rendering),
       id_allocation_chunk_size_(id_allocation_chunk_size),
       use_sync_query_(false),
       buffer_to_texture_target_map_(buffer_to_texture_target_map),
       tracing_id_(g_next_resource_provider_tracing_id.GetNext()) {
   DCHECK(id_allocation_chunk_size_);
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 17 matching lines @@
   DCHECK(!texture_id_allocator_);
   DCHECK(!buffer_id_allocator_);
 
   const auto& caps = compositor_context_provider_->ContextCapabilities();
 
   DCHECK(IsGpuResourceType(default_resource_type_));
   use_texture_storage_ext_ = caps.texture_storage;
   use_texture_format_bgra_ = caps.texture_format_bgra8888;
   use_texture_usage_hint_ = caps.texture_usage;
   use_compressed_texture_etc1_ = caps.texture_format_etc1;
-
-  if (caps.disable_one_component_textures) {
-    yuv_resource_format_ = yuv_highbit_resource_format_ = RGBA_8888;
-  } else {
-    yuv_resource_format_ = caps.texture_rg ? RED_8 : LUMINANCE_8;
-    yuv_highbit_resource_format_ =
-        caps.texture_half_float_linear ? LUMINANCE_F16 : yuv_resource_format_;
-  }
-
   use_sync_query_ = caps.sync_query;
 
   GLES2Interface* gl = ContextGL();
 
   max_texture_size_ = 0;  // Context expects cleared value.
   gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_);
   best_texture_format_ =
       PlatformColor::BestSupportedTextureFormat(use_texture_format_bgra_);
 
   best_render_buffer_format_ = PlatformColor::BestSupportedTextureFormat(
@@ skipping 45 matching lines @@
     case RGBA_4444:
     case RGBA_8888:
     case RGB_565:
     case LUMINANCE_8:
       return true;
     case BGRA_8888:
       return caps.texture_format_bgra8888;
     case ETC1:
       return caps.texture_format_etc1;
     case RED_8:
+    case RG_88:
       return caps.texture_rg;
     case LUMINANCE_F16:
       return caps.texture_half_float_linear;
   }
 
   NOTREACHED();
   return false;
 }
 
 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;
 }
 
 void ResourceProvider::LoseResourceForTesting(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(resource);
   resource->lost = true;
 }
 
-ResourceFormat ResourceProvider::YuvResourceFormat(int bits) const {
-  if (bits > 8) {
-    return yuv_highbit_resource_format_;
-  } else {
-    return yuv_resource_format_;
-  }
-}
-
 ResourceId ResourceProvider::CreateResource(
     const gfx::Size& size,
     TextureHint hint,
     ResourceFormat format,
     const gfx::ColorSpace& color_space) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case RESOURCE_TYPE_GPU_MEMORY_BUFFER:
       // GPU memory buffers don't support LUMINANCE_F16.
       if (format != LUMINANCE_F16) {
@@ skipping 79 matching lines @@
   Resource* resource = InsertResource(
       id,
       Resource(pixels, bitmap.release(), size, Resource::INTERNAL, GL_LINEAR));
   resource->allocated = true;
   resource->color_space = color_space;
   return id;
 }
 
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
+    ResourceFormat format,
     std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl,
     bool read_lock_fences_enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource* resource = nullptr;
   if (mailbox.IsTexture()) {
     resource = InsertResource(
-        id,
-        Resource(0, mailbox.size_in_pixels(), Resource::EXTERNAL,
-                 mailbox.target(),
-                 mailbox.nearest_neighbor() ? GL_NEAREST : GL_LINEAR,
-                 TEXTURE_HINT_IMMUTABLE, RESOURCE_TYPE_GL_TEXTURE, RGBA_8888));
+        id, Resource(0, mailbox.size_in_pixels(), Resource::EXTERNAL,
+                     mailbox.target(),
+                     mailbox.nearest_neighbor() ? GL_NEAREST : GL_LINEAR,
+                     TEXTURE_HINT_IMMUTABLE, RESOURCE_TYPE_GL_TEXTURE, format));
   } else {
     DCHECK(mailbox.IsSharedMemory());
     SharedBitmap* shared_bitmap = mailbox.shared_bitmap();
     uint8_t* pixels = shared_bitmap->pixels();
     DCHECK(pixels);
     resource = InsertResource(
         id, Resource(pixels, shared_bitmap, mailbox.size_in_pixels(),
                      Resource::EXTERNAL, GL_LINEAR));
+    resource->format = format;
   }
   resource->allocated = true;
   resource->set_mailbox(mailbox);
   resource->color_space = mailbox.color_space();
   resource->release_callback_impl =
       base::Bind(&SingleReleaseCallbackImpl::Run,
                  base::Owned(release_callback_impl.release()));
   resource->read_lock_fences_enabled = read_lock_fences_enabled;
   resource->is_overlay_candidate = mailbox.is_overlay_candidate();
   resource->color_space = mailbox.color_space();
 
   return id;
 }
 
+// TODO(dswang): remove this method. crbug.com/624436
+ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
+    const TextureMailbox& mailbox,
+    std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl,
+    bool read_lock_fences_enabled) {
+  return CreateResourceFromTextureMailbox(
+      mailbox, RGBA_8888, std::move(release_callback_impl), false);
+}
+
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
     std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
   return CreateResourceFromTextureMailbox(
       mailbox, std::move(release_callback_impl), false);
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
@@ skipping 113 matching lines @@
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
   return GetResource(id)->type;
 }
 
 GLenum ResourceProvider::GetResourceTextureTarget(ResourceId id) {
   return GetResource(id)->target;
 }
 
+ResourceFormat ResourceProvider::GetResourceFormat(ResourceId id) {
+  return GetResource(id)->format;
+}
+
 bool ResourceProvider::IsImmutable(ResourceId id) {
   if (IsGpuResourceType(default_resource_type_)) {
     return GetTextureHint(id) == TEXTURE_HINT_IMMUTABLE;
   } else {
     // Software resources are immutable; they cannot change format or be
     // resized.
     return true;
   }
 }
 
@@ skipping 1221 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc