Change CHROMIUM_image declarations to support multi planar input.

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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 "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 682 matching lines @@
 
 void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32 id) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 gpu::Capabilities InProcessCommandBuffer::GetCapabilities() {
   return capabilities_;
 }
 
-int32 InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
+int32 InProcessCommandBuffer::CreateImage(ClientBuffer* const buffers,
                                           size_t width,
                                           size_t height,
                                           unsigned internalformat) {
   CheckSequencedThread();
 
   DCHECK(gpu_memory_buffer_manager_);
-  gfx::GpuMemoryBuffer* gpu_memory_buffer =
-      gpu_memory_buffer_manager_->GpuMemoryBufferFromClientBuffer(buffer);
-  DCHECK(gpu_memory_buffer);
-
   int32 new_id = next_image_id_.GetNext();
 
-  DCHECK(gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
-      internalformat, gpu_memory_buffer->GetFormat()));
+  // Log and return if the |internalformat| isn't supported.
+  if (!gpu::ImageFactory::IsImageFormatSupported(internalformat)) {
+    LOG(ERROR) << "Internalformat is not supported.";
+    return -1;
+  }
 
-  // This handle is owned by the GPU thread and must be passed to it or it
-  // will leak. In otherwords, do not early out on error between here and the
-  // queuing of the CreateImage task below.
+  // Check the buffer count for the given |internalformat| and initialize the
+  // vectors where data will be passed.
+  size_t num_buffers =
+      gpu::ImageFactory::NumberOfPlanesForImageFormat(internalformat);
+  std::vector<gfx::GpuMemoryBufferHandle> handles;
+  std::vector<gfx::GpuMemoryBuffer::Format> formats;
   bool requires_sync_point = false;
-  gfx::GpuMemoryBufferHandle handle =
-      ShareGpuMemoryBufferToGpuThread(gpu_memory_buffer->GetHandle(),
-                                      &requires_sync_point);
+
+  for (size_t 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 thread and must be passed to it or it
+    // will leak. In other words, do not early out on error between here and the
+    // queuing of the CreateImage task below.
+    handles.push_back(ShareGpuMemoryBufferToGpuThread(
+        gpu_memory_buffer->GetHandle(), &buffer_requires_sync_point));
+
+    // We set a destruction sync point on all buffers if one happen to require
+    // one.
+    requires_sync_point |= buffer_requires_sync_point;
+  }
 
   QueueTask(base::Bind(&InProcessCommandBuffer::CreateImageOnGpuThread,
                        base::Unretained(this),
                        new_id,
-                       handle,
+                       handles,
                        gfx::Size(width, height),
-                       gpu_memory_buffer->GetFormat(),
+                       formats,
                        internalformat));
 
   if (requires_sync_point) {
-    gpu_memory_buffer_manager_->SetDestructionSyncPoint(gpu_memory_buffer,
-                                                        InsertSyncPoint());
+    uint32 sync_point = InsertSyncPoint();
+    for (size_t 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,
+                                                          sync_point);
+    }
   }
 
   return new_id;
 }
 
 void InProcessCommandBuffer::CreateImageOnGpuThread(
     int32 id,
-    const gfx::GpuMemoryBufferHandle& handle,
+    const std::vector<gfx::GpuMemoryBufferHandle>& handles,
     const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
+    const std::vector<gfx::GpuMemoryBuffer::Format>& formats,
     uint32 internalformat) {
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image already exists with same ID.";
     return;
   }
 
   // Note: this assumes that client ID is always 0.
   const int kClientId = 0;
 
   DCHECK(image_factory_);
   scoped_refptr<gfx::GLImage> image =
-      image_factory_->CreateImageForGpuMemoryBuffer(
-          handle, size, format, internalformat, kClientId);
+      image_factory_->CreateImageForGpuMemoryBuffers(handles, size, formats,
+                                                    internalformat, kClientId);
   if (!image.get())
     return;
 
   image_manager->AddImage(image.get(), id);
 }
 
 void InProcessCommandBuffer::DestroyImage(int32 id) {
   CheckSequencedThread();
 
   QueueTask(base::Bind(&InProcessCommandBuffer::DestroyImageOnGpuThread,
@@ skipping 14 matching lines @@
 
   image_manager->RemoveImage(id);
 }
 
 int32 InProcessCommandBuffer::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
   CheckSequencedThread();
+  DCHECK(gpu::ImageFactory::IsImageFormatSupported(internalformat));
+  DCHECK(gpu_memory_buffer_manager_);
 
-  DCHECK(gpu_memory_buffer_manager_);
-  scoped_ptr<gfx::GpuMemoryBuffer> buffer(
-      gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
-          gfx::Size(width, height),
-          gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormat(internalformat),
-          gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
-  if (!buffer)
-    return -1;
+  size_t num_buffers =
+      gpu::ImageFactory::NumberOfPlanesForImageFormat(internalformat);
+  ScopedVector<gfx::GpuMemoryBuffer> buffers;
+  std::vector<ClientBuffer> client_buffers;
 
-  return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
+  for (size_t i = 0; i < num_buffers; ++i) {
+    gfx::GpuMemoryBuffer::Format format =
+        gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormat(internalformat,
+                                                              i);
+    buffers.push_back(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);
 }
 
 uint32 InProcessCommandBuffer::InsertSyncPoint() {
   uint32 sync_point = g_sync_point_manager.Get().GenerateSyncPoint();
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
   return sync_point;
 }
 
@@ skipping 140 matching lines @@
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 }  // namespace gpu