Allow multiple texture ids per picture buffer.

content/common/gpu/media/gpu_video_decode_accelerator.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/media/gpu_video_decode_accelerator.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 114 matching lines @@
   IPC::Sender* sender_;
 };
 
 GpuVideoDecodeAccelerator::GpuVideoDecodeAccelerator(
     int32_t host_route_id,
     GpuCommandBufferStub* stub,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : host_route_id_(host_route_id),
       stub_(stub),
       texture_target_(0),
+      textures_per_buffer_(0),
       filter_removed_(true, false),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
       weak_factory_for_io_(this) {
   DCHECK(stub_);
   stub_->AddDestructionObserver(this);
   make_context_current_ =
       base::Bind(&MakeDecoderContextCurrent, stub_->AsWeakPtr());
 }
 
@@ skipping 64 matching lines @@
 }
 
 void GpuVideoDecodeAccelerator::NotifyCdmAttached(bool success) {
   if (!Send(new AcceleratedVideoDecoderHostMsg_CdmAttached(host_route_id_,
                                                            success)))
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_CdmAttached) failed";
 }
 
 void GpuVideoDecodeAccelerator::ProvidePictureBuffers(
     uint32_t requested_num_of_buffers,
+    uint32_t textures_per_buffer,
     const gfx::Size& dimensions,
     uint32_t texture_target) {
   if (dimensions.width() > media::limits::kMaxDimension ||
       dimensions.height() > media::limits::kMaxDimension ||
       dimensions.GetArea() > media::limits::kMaxCanvas) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   if (!Send(new AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers(
-           host_route_id_,
-           requested_num_of_buffers,
-           dimensions,
-           texture_target))) {
+          host_route_id_, requested_num_of_buffers, textures_per_buffer,
+          dimensions, texture_target))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers) "
                 << "failed";
   }
   texture_dimensions_ = dimensions;
+  textures_per_buffer_ = textures_per_buffer;
   texture_target_ = texture_target;
 }
 
 void GpuVideoDecodeAccelerator::DismissPictureBuffer(
     int32_t picture_buffer_id) {
   // Notify client that picture buffer is now unused.
   if (!Send(new AcceleratedVideoDecoderHostMsg_DismissPictureBuffer(
           host_route_id_, picture_buffer_id))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_DismissPictureBuffer) "
                 << "failed";
@@ skipping 248 matching lines @@
 // Runs on IO thread if video_decode_accelerator_->CanDecodeOnIOThread() is
 // true, otherwise on the main thread.
 void GpuVideoDecodeAccelerator::OnDecode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(video_decode_accelerator_);
   video_decode_accelerator_->Decode(bitstream_buffer);
 }
 
 void GpuVideoDecodeAccelerator::OnAssignPictureBuffers(
     const std::vector<int32_t>& buffer_ids,
-    const std::vector<uint32_t>& texture_ids) {
+    const std::vector<media::PictureBuffer::TextureIds>& texture_ids) {
   if (buffer_ids.size() != texture_ids.size()) {
     NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
     return;
   }
 
   gpu::gles2::GLES2Decoder* command_decoder = stub_->decoder();
   gpu::gles2::TextureManager* texture_manager =
       command_decoder->GetContextGroup()->texture_manager();
 
   std::vector<media::PictureBuffer> buffers;
   std::vector<scoped_refptr<gpu::gles2::TextureRef> > textures;
   for (uint32_t i = 0; i < buffer_ids.size(); ++i) {
     if (buffer_ids[i] < 0) {
       DLOG(ERROR) << "Buffer id " << buffer_ids[i] << " out of range";
       NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
       return;
     }
-    gpu::gles2::TextureRef* texture_ref = texture_manager->GetTexture(
-        texture_ids[i]);
-    if (!texture_ref) {
-      DLOG(ERROR) << "Failed to find texture id " << texture_ids[i];
+    media::PictureBuffer::TextureIds buffer_texture_ids = texture_ids[i];
+    media::PictureBuffer::TextureIds service_ids;
+    if (buffer_texture_ids.size() != textures_per_buffer_) {
+      DLOG(ERROR) << "Requested " << textures_per_buffer_
+                  << " textures per picture buffer, got "
+                  << buffer_texture_ids.size();
       NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
       return;
     }
-    gpu::gles2::Texture* info = texture_ref->texture();
-    if (info->target() != texture_target_) {
-      DLOG(ERROR) << "Texture target mismatch for texture id "
-                  << texture_ids[i];
-      NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
-      return;
-    }
-    if (texture_target_ == GL_TEXTURE_EXTERNAL_OES ||
-        texture_target_ == GL_TEXTURE_RECTANGLE_ARB) {
-      // These textures have their dimensions defined by the underlying storage.
-      // Use |texture_dimensions_| for this size.
-      texture_manager->SetLevelInfo(
-          texture_ref, texture_target_, 0, GL_RGBA, texture_dimensions_.width(),
-          texture_dimensions_.height(), 1, 0, GL_RGBA, 0, gfx::Rect());
-    } else {
-      // For other targets, texture dimensions should already be defined.
-      GLsizei width = 0, height = 0;
-      info->GetLevelSize(texture_target_, 0, &width, &height, nullptr);
-      if (width != texture_dimensions_.width() ||
-          height != texture_dimensions_.height()) {
-        DLOG(ERROR) << "Size mismatch for texture id " << texture_ids[i];
+    for (size_t j = 0; j < textures_per_buffer_; j++) {
+      gpu::gles2::TextureRef* texture_ref =
+          texture_manager->GetTexture(buffer_texture_ids[j]);
+      if (!texture_ref) {
+        DLOG(ERROR) << "Failed to find texture id " << buffer_texture_ids[j];
         NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
         return;
       }
+      gpu::gles2::Texture* info = texture_ref->texture();
+      if (info->target() != texture_target_) {
+        DLOG(ERROR) << "Texture target mismatch for texture id "
+                    << buffer_texture_ids[j];
+        NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
+        return;
+      }
+      if (texture_target_ == GL_TEXTURE_EXTERNAL_OES ||
+          texture_target_ == GL_TEXTURE_RECTANGLE_ARB) {
+        // These textures have their dimensions defined by the underlying
+        // storage.
+        // Use |texture_dimensions_| for this size.
+        texture_manager->SetLevelInfo(texture_ref, texture_target_, 0, GL_RGBA,
+                                      texture_dimensions_.width(),
+                                      texture_dimensions_.height(), 1, 0,
+                                      GL_RGBA, 0, gfx::Rect());
+      } else {
+        // For other targets, texture dimensions should already be defined.
+        GLsizei width = 0, height = 0;
+        info->GetLevelSize(texture_target_, 0, &width, &height, nullptr);
+        if (width != texture_dimensions_.width() ||
+            height != texture_dimensions_.height()) {
+          DLOG(ERROR) << "Size mismatch for texture id "
+                      << buffer_texture_ids[j];
+          NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
+          return;
+        }
 
-      // TODO(dshwang): after moving to D3D11, remove this. crbug.com/438691
-      GLenum format =
-          video_decode_accelerator_.get()->GetSurfaceInternalFormat();
-      if (format != GL_RGBA) {
-        texture_manager->SetLevelInfo(texture_ref, texture_target_, 0, format,
-                                      width, height, 1, 0, format, 0,
-                                      gfx::Rect());
+        // TODO(dshwang): after moving to D3D11, remove this. crbug.com/438691
+        GLenum format =
+            video_decode_accelerator_.get()->GetSurfaceInternalFormat();
+        if (format != GL_RGBA) {
+          texture_manager->SetLevelInfo(texture_ref, texture_target_, 0, format,
+                                        width, height, 1, 0, format, 0,
+                                        gfx::Rect());
+        }
       }
+      service_ids.push_back(texture_ref->service_id());
+      textures.push_back(texture_ref);
     }
     buffers.push_back(media::PictureBuffer(buffer_ids[i], texture_dimensions_,
-                                           texture_ref->service_id(),
-                                           texture_ids[i]));
-    textures.push_back(texture_ref);
+                                           service_ids, buffer_texture_ids));
   }
   video_decode_accelerator_->AssignPictureBuffers(buffers);
   DebugAutoLock auto_lock(debug_uncleared_textures_lock_);
   for (uint32_t i = 0; i < buffer_ids.size(); ++i)
     uncleared_textures_[buffer_ids[i]] = textures[i];
 }
 
 void GpuVideoDecodeAccelerator::OnReusePictureBuffer(
     int32_t picture_buffer_id) {
   DCHECK(video_decode_accelerator_);
@@ skipping 33 matching lines @@
   scoped_refptr<gpu::gles2::TextureRef> texture_ref = it->second;
   GLenum target = texture_ref->texture()->target();
   gpu::gles2::TextureManager* texture_manager =
       stub_->decoder()->GetContextGroup()->texture_manager();
   DCHECK(!texture_ref->texture()->IsLevelCleared(target, 0));
   texture_manager->SetLevelCleared(texture_ref.get(), target, 0, true);
   uncleared_textures_.erase(it);
 }
 
 }  // namespace content