Change CHROMIUM_image declarations to support multi planar input.

content/common/gpu/client/command_buffer_proxy_impl.cc

 // Copyright (c) 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 "content/common/gpu/client/command_buffer_proxy_impl.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/stl_util.h"
@@ skipping 329 matching lines @@
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_DestroyTransferBuffer(route_id_, id));
 }
 
 gpu::Capabilities CommandBufferProxyImpl::GetCapabilities() {
   return capabilities_;
 }
 
-int32_t CommandBufferProxyImpl::CreateImage(ClientBuffer buffer,
+int32_t CommandBufferProxyImpl::CreateImage(ClientBuffer* const buffers,
                                             size_t width,
                                             size_t height,
                                             unsigned internalformat) {
   CheckLock();
   if (last_state_.error != gpu::error::kNoError)
     return -1;
 
   int32 new_id = channel_->ReserveImageId();
 
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
       channel_->gpu_memory_buffer_manager();
-  gfx::GpuMemoryBuffer* gpu_memory_buffer =
-      gpu_memory_buffer_manager->GpuMemoryBufferFromClientBuffer(buffer);
-  DCHECK(gpu_memory_buffer);
 
-  // This handle is owned by the GPU process and must be passed to it or it
-  // will leak. In otherwords, do not early out on error between here and the
-  // sending of the CreateImage IPC below.
+  // Check the buffer count for the given |internalformat| and initialize the
+  // vectors where data will be passed. Log and return if the |internalformat|
+  // isn't supported.
+  int num_buffers =
+      gpu::ImageFactory::GpuMemoryBufferCountForImageFormat(internalformat);
+  if (num_buffers < 1) {
+    LOG(ERROR) << "Internalformat is not supported.";
+    return -1;
+  }
+  std::vector<gfx::GpuMemoryBufferHandle> handles;
+  handles.reserve(num_buffers);

[reveman, 2015/03/12 19:37:22]

Don't bother with this micro optimization. Just let the vector grow as needed
instead.

[emircan, 2015/03/12 22:34:26]

Done. 

I still think it might be worth it in the long run as this will decrease 3
reallocs going 1-2-4 elements to just one alloc.

+  std::vector<gfx::GpuMemoryBuffer::Format> formats;
+  formats.reserve(num_buffers);

[reveman, 2015/03/12 19:37:22]

Ditto.

[emircan, 2015/03/12 22:34:26]

Done.

   bool requires_sync_point = false;
-  gfx::GpuMemoryBufferHandle handle =
-      channel_->ShareGpuMemoryBufferToGpuProcess(gpu_memory_buffer->GetHandle(),
-                                                 &requires_sync_point);
 
-  DCHECK(gpu::ImageFactory::IsImageSizeValidForGpuMemoryBufferFormat(
-      gfx::Size(width, height), gpu_memory_buffer->GetFormat()));
-  DCHECK(gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
-      internalformat, gpu_memory_buffer->GetFormat()));
+  for (int i = 0; i < num_buffers; ++i) {
+    gfx::GpuMemoryBuffer* gpu_memory_buffer =
+        gpu_memory_buffer_manager->GpuMemoryBufferFromClientBuffer(buffers[i]);
+    DCHECK(gpu_memory_buffer);
+
+    formats.push_back(gpu_memory_buffer->GetFormat());
+    DCHECK(gpu::ImageFactory::IsImageSizeValidForGpuMemoryBufferFormat(
+        gfx::Size(width, height), formats[i]));
+    DCHECK(gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
+        internalformat, i, formats[i]));
+
+    bool buffer_requires_sync_point = false;
+    // This handle is owned by the GPU process and must be passed to it or it
+    // will leak. In other words, do not early out on error between here and the
+    // sending of the CreateImage IPC below.
+    handles.push_back(channel_->ShareGpuMemoryBufferToGpuProcess(
+        gpu_memory_buffer->GetHandle(), &buffer_requires_sync_point));
+
+    // We want to set a destruction sync point on all buffers if one happen to

[reveman, 2015/03/12 19:37:22]

s/want to// as "want to" makes it sound like we have to. that's not the case, we
just do it as it's simpler and never going to make a difference in practice.

[emircan, 2015/03/12 22:34:26]

Done.

+    // require one.
+    requires_sync_point |= buffer_requires_sync_point;
+  }
+
   if (!Send(new GpuCommandBufferMsg_CreateImage(route_id_,
                                                 new_id,
-                                                handle,
+                                                handles,
                                                 gfx::Size(width, height),
-                                                gpu_memory_buffer->GetFormat(),
+                                                formats,
                                                 internalformat))) {
     return -1;
   }
 
   if (requires_sync_point) {
-    gpu_memory_buffer_manager->SetDestructionSyncPoint(gpu_memory_buffer,
-                                                       InsertSyncPoint());
+    for (int i = 0; i < num_buffers; ++i) {
+      gfx::GpuMemoryBuffer* gpu_memory_buffer =
+          gpu_memory_buffer_manager->GpuMemoryBufferFromClientBuffer(
+              buffers[i]);
+      gpu_memory_buffer_manager->SetDestructionSyncPoint(gpu_memory_buffer,
+                                                         InsertSyncPoint());

[reveman, 2015/03/12 19:37:22]

InsertSyncPoint() is a relatively expensive call. It performs a synchronous IPC
call. Call it before the loop and use the result for all buffers.

[emircan, 2015/03/12 22:34:26]

Done.

+    }
   }
 
   return new_id;
 }
 
 void CommandBufferProxyImpl::DestroyImage(int32 id) {
   CheckLock();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_DestroyImage(route_id_, id));
 }
 
 int32_t CommandBufferProxyImpl::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
   CheckLock();
-  scoped_ptr<gfx::GpuMemoryBuffer> buffer(
-      channel_->gpu_memory_buffer_manager()->AllocateGpuMemoryBuffer(
-          gfx::Size(width, height),
-          gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormat(internalformat),
-          gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
-  if (!buffer)
+
+  int num_buffers =
+      gpu::ImageFactory::GpuMemoryBufferCountForImageFormat(internalformat);
+  if (num_buffers < 1) {
+    LOG(ERROR) << "Internalformat is not supported.";
     return -1;
+  }
 
-  return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
+  ScopedVector<gfx::GpuMemoryBuffer> buffers;
+  buffers.reserve(num_buffers);

[reveman, 2015/03/12 19:37:22]

Skip this optimization.

[emircan, 2015/03/12 22:34:26]

Done.

+  std::vector<ClientBuffer> client_buffers;
+  client_buffers.reserve(num_buffers);

[reveman, 2015/03/12 19:37:22]

Ditto.

[emircan, 2015/03/12 22:34:26]

Done.

+  for (int i = 0; i < num_buffers; ++i) {
+    gfx::GpuMemoryBuffer::Format format =
+        gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormat(internalformat,
+                                                              i);
+    buffers.push_back(
+        channel_->gpu_memory_buffer_manager()->AllocateGpuMemoryBuffer(
+            gfx::Size(width, height), format,
+            gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
+    if (!buffers[i])
+      return -1;
+
+    client_buffers[i] = buffers[i]->AsClientBuffer();
+  }
+  return CreateImage(client_buffers.data(), width, height, internalformat);
 }
 
 int CommandBufferProxyImpl::GetRouteID() const {
   return route_id_;
 }
 
 uint32 CommandBufferProxyImpl::CreateStreamTexture(uint32 texture_id) {
   CheckLock();
   if (last_state_.error != gpu::error::kNoError)
     return 0;
@@ skipping 176 matching lines @@
   }
 }
 
 void CommandBufferProxyImpl::OnUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   if (!update_vsync_parameters_completion_callback_.is_null())
     update_vsync_parameters_completion_callback_.Run(timebase, interval);
 }
 
 }  // namespace content