media/gpu/ipc/service/picture_buffer_manager.cc - chromium/src - Git at Google

 // Copyright 2018 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 "media/gpu/ipc/service/picture_buffer_manager.h"

 #include <map>
 #include <set>
 #include <utility>

 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"

 namespace media {

 namespace {

 // Generates nonnegative picture buffer IDs, which are assumed to be unique.
 int32_t NextID(int32_t* counter) {
   int32_t value = *counter;
   *counter = (*counter + 1) & 0x3FFFFFFF;
   return value;
 }

 class PictureBufferManagerImpl : public PictureBufferManager {
  public:
   explicit PictureBufferManagerImpl(
       ReusePictureBufferCB reuse_picture_buffer_cb)
       : reuse_picture_buffer_cb_(std::move(reuse_picture_buffer_cb)) {
     DVLOG(1) << __func__;
   }

   void Initialize(
       scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
       scoped_refptr<CommandBufferHelper> command_buffer_helper) override {
     DVLOG(1) << __func__;
     DCHECK(!gpu_task_runner_);

     gpu_task_runner_ = std::move(gpu_task_runner);
     command_buffer_helper_ = std::move(command_buffer_helper);
   }

   bool CanReadWithoutStalling() override {
     DVLOG(3) << __func__;

     base::AutoLock lock(picture_buffers_lock_);

     // If there are no assigned picture buffers, predict that the VDA will
     // request some.
     if (picture_buffers_.empty())
       return true;

     // Predict that the VDA can output a picture if at least one picture buffer
     // is not in use as an output.
     for (const auto& it : picture_buffers_) {
       if (it.second.state != PictureBufferState::OUTPUT)
         return true;
     }

     return false;
   }

   std::vector<PictureBuffer> CreatePictureBuffers(
       uint32_t count,
       VideoPixelFormat pixel_format,
       uint32_t planes,
       gfx::Size texture_size,
       uint32_t texture_target) override {
     DVLOG(2) << __func__;
     DCHECK(gpu_task_runner_);
     DCHECK(gpu_task_runner_->BelongsToCurrentThread());
     DCHECK(count);
     DCHECK(planes);
     DCHECK_LE(planes, VideoFrame::kMaxPlanes);

     // TODO(sandersd): Consider requiring that CreatePictureBuffers() is called
     // with the context current.
     if (!command_buffer_helper_->MakeContextCurrent()) {
       DVLOG(1) << "Failed to make context current";
       return std::vector<PictureBuffer>();
     }

     std::vector<PictureBuffer> picture_buffers;
     for (uint32_t i = 0; i < count; i++) {
       PictureBuffer::TextureIds service_ids;
       PictureBufferData picture_data = {PictureBufferState::AVAILABLE,
                                         pixel_format, texture_size};

       for (uint32_t j = 0; j < planes; j++) {
         // Create a texture for this plane.
         GLuint service_id = command_buffer_helper_->CreateTexture(
             texture_target, GL_RGBA, texture_size.width(),
             texture_size.height(), GL_RGBA, GL_UNSIGNED_BYTE);
         DCHECK(service_id);
         service_ids.push_back(service_id);

         // The texture is not cleared yet, but it will be before the VDA outputs
         // it. Rather than requiring output to happen on the GPU thread, mark
         // the texture as cleared immediately.
         command_buffer_helper_->SetCleared(service_id);

         // Generate a mailbox while we are still on the GPU thread.
         picture_data.mailbox_holders[j] = gpu::MailboxHolder(
             command_buffer_helper_->CreateMailbox(service_id), gpu::SyncToken(),
             texture_target);
       }

       // Generate a picture buffer ID and record the picture buffer.
       int32_t picture_buffer_id = NextID(&picture_buffer_id_);
       {
         base::AutoLock lock(picture_buffers_lock_);
         DCHECK(!picture_buffers_.count(picture_buffer_id));
         picture_buffers_[picture_buffer_id] = picture_data;
       }

       // Since our textures have no client IDs, we reuse the service IDs as
       // convenient unique identifiers.
       //
       // TODO(sandersd): Refactor the bind image callback to use service IDs so
       // that we can get rid of the client IDs altogether.
       picture_buffers.emplace_back(picture_buffer_id, texture_size, service_ids,
                                    service_ids, texture_target, pixel_format);

       // Record the textures used by the picture buffer.
       picture_buffer_textures_[picture_buffer_id] = std::move(service_ids);
     }
     return picture_buffers;
   }

   bool DismissPictureBuffer(int32_t picture_buffer_id) override {
     DVLOG(2) << __func__ << "(" << picture_buffer_id << ")";
     DCHECK(gpu_task_runner_);
     DCHECK(gpu_task_runner_->BelongsToCurrentThread());

     base::AutoLock lock(picture_buffers_lock_);

     // Check the state of the picture buffer.
     const auto& it = picture_buffers_.find(picture_buffer_id);
     if (it == picture_buffers_.end()) {
       DVLOG(1) << "Unknown picture buffer " << picture_buffer_id;
       return false;
     }

     bool is_available = it->second.state == PictureBufferState::AVAILABLE;

     // Destroy the picture buffer data.
     picture_buffers_.erase(it);

     // If the picture was available, we can destroy its textures immediately.
     if (is_available) {
       gpu_task_runner_->PostTask(
           FROM_HERE,
           base::BindOnce(
               &PictureBufferManagerImpl::DestroyPictureBufferTextures, this,
               picture_buffer_id));
     }

     return true;
   }

   scoped_refptr<VideoFrame> CreateVideoFrame(Picture picture,
                                              base::TimeDelta timestamp,
                                              gfx::Rect visible_rect,
                                              gfx::Size natural_size) override {
     DVLOG(2) << __func__ << "(" << picture.picture_buffer_id() << ")";
     DCHECK(!picture.size_changed());
     DCHECK(!picture.surface_texture());
     DCHECK(!picture.wants_promotion_hint());

     base::AutoLock lock(picture_buffers_lock_);

     int32_t picture_buffer_id = picture.picture_buffer_id();

     // Verify that the picture buffer is available.
     const auto& it = picture_buffers_.find(picture_buffer_id);
     if (it == picture_buffers_.end()) {
       DVLOG(1) << "Unknown picture buffer " << picture_buffer_id;
       return nullptr;
     }

     PictureBufferData& picture_buffer_data = it->second;
     if (picture_buffer_data.state != PictureBufferState::AVAILABLE) {
       DLOG(ERROR) << "Picture buffer " << picture_buffer_id
                   << " is not available";
       return nullptr;
     }

     // Verify that the picture buffer is large enough.
     if (!gfx::Rect(picture_buffer_data.texture_size).Contains(visible_rect)) {
       DLOG(ERROR) << "visible_rect " << visible_rect.ToString()
                   << " exceeds coded_size "
                   << picture_buffer_data.texture_size.ToString();
       return nullptr;
     }

     // Mark the picture as an output.
     picture_buffer_data.state = PictureBufferState::OUTPUT;

     // Create and return a VideoFrame for the picture buffer.
     scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTextures(
         picture_buffer_data.pixel_format, picture_buffer_data.mailbox_holders,
         base::BindRepeating(&PictureBufferManagerImpl::OnVideoFrameDestroyed,
                             this, picture_buffer_id),
         picture_buffer_data.texture_size, visible_rect, natural_size,
         timestamp);

     frame->set_color_space(picture.color_space());

     if (picture.allow_overlay())
       frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);

     // TODO(sandersd): Provide an API for VDAs to control this.
     frame->metadata()->SetBoolean(VideoFrameMetadata::POWER_EFFICIENT, true);

     return frame;
   }

  private:
   ~PictureBufferManagerImpl() override { DVLOG(1) << __func__; }

   void OnVideoFrameDestroyed(int32_t picture_buffer_id,
                              const gpu::SyncToken& sync_token) {
     DVLOG(3) << __func__ << "(" << picture_buffer_id << ")";

     base::AutoLock lock(picture_buffers_lock_);

     // If the picture buffer is still assigned, mark it as unreleased.
     const auto& it = picture_buffers_.find(picture_buffer_id);
     if (it != picture_buffers_.end()) {
       DCHECK_EQ(it->second.state, PictureBufferState::OUTPUT);
       it->second.state = PictureBufferState::WAITING_FOR_SYNCTOKEN;
     }

     // Wait for the SyncToken release.
     gpu_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(
             &CommandBufferHelper::WaitForSyncToken, command_buffer_helper_,
             sync_token,
             base::BindOnce(&PictureBufferManagerImpl::OnSyncTokenReleased, this,
                            picture_buffer_id)));
   }

   void OnSyncTokenReleased(int32_t picture_buffer_id) {
     DVLOG(3) << __func__ << "(" << picture_buffer_id << ")";
     DCHECK(gpu_task_runner_);
     DCHECK(gpu_task_runner_->BelongsToCurrentThread());

     // If the picture buffer is still assigned, mark it as available.
     bool is_assigned = false;
     {
       base::AutoLock lock(picture_buffers_lock_);
       const auto& it = picture_buffers_.find(picture_buffer_id);
       if (it != picture_buffers_.end()) {
         DCHECK_EQ(it->second.state, PictureBufferState::WAITING_FOR_SYNCTOKEN);
         it->second.state = PictureBufferState::AVAILABLE;
         is_assigned = true;
       }
     }

     // If the picture buffer is still assigned, it is ready to be reused.
     // Otherwise it has been dismissed and we can now delete its textures.
     // Neither of these operations should be done while holding the lock.
     if (is_assigned) {
       reuse_picture_buffer_cb_.Run(picture_buffer_id);
     } else {
       DestroyPictureBufferTextures(picture_buffer_id);
     }
   }

   void DestroyPictureBufferTextures(int32_t picture_buffer_id) {
     DVLOG(3) << __func__ << "(" << picture_buffer_id << ")";
     DCHECK(gpu_task_runner_);
     DCHECK(gpu_task_runner_->BelongsToCurrentThread());

     if (!command_buffer_helper_->MakeContextCurrent())
       return;

     const auto& it = picture_buffer_textures_.find(picture_buffer_id);
     DCHECK(it != picture_buffer_textures_.end());
     for (GLuint service_id : it->second)
       command_buffer_helper_->DestroyTexture(service_id);
     picture_buffer_textures_.erase(it);
   }

   ReusePictureBufferCB reuse_picture_buffer_cb_;

   scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner_;
   scoped_refptr<CommandBufferHelper> command_buffer_helper_;

   int32_t picture_buffer_id_ = 0;
   // Includes picture puffers that have been dismissed if their textures have
   // not been deleted yet.
   std::map<int32_t, std::vector<GLuint>> picture_buffer_textures_;

   base::Lock picture_buffers_lock_;
   enum class PictureBufferState {
     // Available for use by the VDA.
     AVAILABLE,
     // Output by the VDA, still bound to a VideoFrame.
     OUTPUT,
     // Waiting on a SyncToken before being reused.
     WAITING_FOR_SYNCTOKEN,
   };
   struct PictureBufferData {
     PictureBufferState state;
     VideoPixelFormat pixel_format;
     gfx::Size texture_size;
     gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
   };
   // Pictures buffers that are assigned to the VDA.
   std::map<int32_t, PictureBufferData> picture_buffers_;

   DISALLOW_COPY_AND_ASSIGN(PictureBufferManagerImpl);
 };

 }  // namespace

 // static
 scoped_refptr<PictureBufferManager> PictureBufferManager::Create(
     ReusePictureBufferCB reuse_picture_buffer_cb) {
   return base::MakeRefCounted<PictureBufferManagerImpl>(
       std::move(reuse_picture_buffer_cb));
 }

 }  // namespace media
	// Copyright 2018 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 "media/gpu/ipc/service/picture_buffer_manager.h"

	#include <map>
	#include <set>
	#include <utility>

	#include "base/bind.h"
	#include "base/location.h"
	#include "base/logging.h"
	#include "base/synchronization/lock.h"
	#include "gpu/command_buffer/common/mailbox_holder.h"

	namespace media {

	namespace {

	// Generates nonnegative picture buffer IDs, which are assumed to be unique.
	int32_t NextID(int32_t* counter) {
	int32_t value = *counter;
	counter = (counter + 1) & 0x3FFFFFFF;
	return value;
	}

	class PictureBufferManagerImpl : public PictureBufferManager {
	public:
	explicit PictureBufferManagerImpl(
	ReusePictureBufferCB reuse_picture_buffer_cb)
	: reuse_picture_buffer_cb_(std::move(reuse_picture_buffer_cb)) {
	DVLOG(1) << __func__;
	}

	void Initialize(
	scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
	scoped_refptr<CommandBufferHelper> command_buffer_helper) override {
	DVLOG(1) << __func__;
	DCHECK(!gpu_task_runner_);

	gpu_task_runner_ = std::move(gpu_task_runner);
	command_buffer_helper_ = std::move(command_buffer_helper);
	}

	bool CanReadWithoutStalling() override {
	DVLOG(3) << __func__;

	base::AutoLock lock(picture_buffers_lock_);

	// If there are no assigned picture buffers, predict that the VDA will
	// request some.
	if (picture_buffers_.empty())
	return true;

	// Predict that the VDA can output a picture if at least one picture buffer
	// is not in use as an output.
	for (const auto& it : picture_buffers_) {
	if (it.second.state != PictureBufferState::OUTPUT)
	return true;
	}

	return false;
	}

	std::vector<PictureBuffer> CreatePictureBuffers(
	uint32_t count,
	VideoPixelFormat pixel_format,
	uint32_t planes,
	gfx::Size texture_size,
	uint32_t texture_target) override {
	DVLOG(2) << __func__;
	DCHECK(gpu_task_runner_);
	DCHECK(gpu_task_runner_->BelongsToCurrentThread());
	DCHECK(count);
	DCHECK(planes);
	DCHECK_LE(planes, VideoFrame::kMaxPlanes);

	// TODO(sandersd): Consider requiring that CreatePictureBuffers() is called
	// with the context current.
	if (!command_buffer_helper_->MakeContextCurrent()) {
	DVLOG(1) << "Failed to make context current";
	return std::vector<PictureBuffer>();
	}

	std::vector<PictureBuffer> picture_buffers;
	for (uint32_t i = 0; i < count; i++) {
	PictureBuffer::TextureIds service_ids;
	PictureBufferData picture_data = {PictureBufferState::AVAILABLE,
	pixel_format, texture_size};

	for (uint32_t j = 0; j < planes; j++) {
	// Create a texture for this plane.
	GLuint service_id = command_buffer_helper_->CreateTexture(
	texture_target, GL_RGBA, texture_size.width(),
	texture_size.height(), GL_RGBA, GL_UNSIGNED_BYTE);
	DCHECK(service_id);
	service_ids.push_back(service_id);

	// The texture is not cleared yet, but it will be before the VDA outputs
	// it. Rather than requiring output to happen on the GPU thread, mark
	// the texture as cleared immediately.
	command_buffer_helper_->SetCleared(service_id);

	// Generate a mailbox while we are still on the GPU thread.
	picture_data.mailbox_holders[j] = gpu::MailboxHolder(
	command_buffer_helper_->CreateMailbox(service_id), gpu::SyncToken(),
	texture_target);
	}

	// Generate a picture buffer ID and record the picture buffer.
	int32_t picture_buffer_id = NextID(&picture_buffer_id_);
	{
	base::AutoLock lock(picture_buffers_lock_);
	DCHECK(!picture_buffers_.count(picture_buffer_id));
	picture_buffers_[picture_buffer_id] = picture_data;
	}

	// Since our textures have no client IDs, we reuse the service IDs as
	// convenient unique identifiers.
	//
	// TODO(sandersd): Refactor the bind image callback to use service IDs so
	// that we can get rid of the client IDs altogether.
	picture_buffers.emplace_back(picture_buffer_id, texture_size, service_ids,
	service_ids, texture_target, pixel_format);

	// Record the textures used by the picture buffer.
	picture_buffer_textures_[picture_buffer_id] = std::move(service_ids);
	}
	return picture_buffers;
	}

	bool DismissPictureBuffer(int32_t picture_buffer_id) override {
	DVLOG(2) << __func__ << "(" << picture_buffer_id << ")";
	DCHECK(gpu_task_runner_);
	DCHECK(gpu_task_runner_->BelongsToCurrentThread());

	base::AutoLock lock(picture_buffers_lock_);

	// Check the state of the picture buffer.
	const auto& it = picture_buffers_.find(picture_buffer_id);
	if (it == picture_buffers_.end()) {
	DVLOG(1) << "Unknown picture buffer " << picture_buffer_id;
	return false;
	}

	bool is_available = it->second.state == PictureBufferState::AVAILABLE;

	// Destroy the picture buffer data.
	picture_buffers_.erase(it);

	// If the picture was available, we can destroy its textures immediately.
	if (is_available) {
	gpu_task_runner_->PostTask(
	FROM_HERE,
	base::BindOnce(
	&PictureBufferManagerImpl::DestroyPictureBufferTextures, this,
	picture_buffer_id));
	}

	return true;
	}

	scoped_refptr<VideoFrame> CreateVideoFrame(Picture picture,
	base::TimeDelta timestamp,
	gfx::Rect visible_rect,
	gfx::Size natural_size) override {
	DVLOG(2) << __func__ << "(" << picture.picture_buffer_id() << ")";
	DCHECK(!picture.size_changed());
	DCHECK(!picture.surface_texture());
	DCHECK(!picture.wants_promotion_hint());

	base::AutoLock lock(picture_buffers_lock_);

	int32_t picture_buffer_id = picture.picture_buffer_id();

	// Verify that the picture buffer is available.
	const auto& it = picture_buffers_.find(picture_buffer_id);
	if (it == picture_buffers_.end()) {
	DVLOG(1) << "Unknown picture buffer " << picture_buffer_id;
	return nullptr;
	}

	PictureBufferData& picture_buffer_data = it->second;
	if (picture_buffer_data.state != PictureBufferState::AVAILABLE) {
	DLOG(ERROR) << "Picture buffer " << picture_buffer_id
	<< " is not available";
	return nullptr;
	}

	// Verify that the picture buffer is large enough.
	if (!gfx::Rect(picture_buffer_data.texture_size).Contains(visible_rect)) {
	DLOG(ERROR) << "visible_rect " << visible_rect.ToString()
	<< " exceeds coded_size "
	<< picture_buffer_data.texture_size.ToString();
	return nullptr;
	}

	// Mark the picture as an output.
	picture_buffer_data.state = PictureBufferState::OUTPUT;

	// Create and return a VideoFrame for the picture buffer.
	scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTextures(
	picture_buffer_data.pixel_format, picture_buffer_data.mailbox_holders,
	base::BindRepeating(&PictureBufferManagerImpl::OnVideoFrameDestroyed,
	this, picture_buffer_id),
	picture_buffer_data.texture_size, visible_rect, natural_size,
	timestamp);

	frame->set_color_space(picture.color_space());

	if (picture.allow_overlay())
	frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);

	// TODO(sandersd): Provide an API for VDAs to control this.
	frame->metadata()->SetBoolean(VideoFrameMetadata::POWER_EFFICIENT, true);

	return frame;
	}

	private:
	~PictureBufferManagerImpl() override { DVLOG(1) << __func__; }

	void OnVideoFrameDestroyed(int32_t picture_buffer_id,
	const gpu::SyncToken& sync_token) {
	DVLOG(3) << __func__ << "(" << picture_buffer_id << ")";

	base::AutoLock lock(picture_buffers_lock_);

	// If the picture buffer is still assigned, mark it as unreleased.
	const auto& it = picture_buffers_.find(picture_buffer_id);
	if (it != picture_buffers_.end()) {
	DCHECK_EQ(it->second.state, PictureBufferState::OUTPUT);
	it->second.state = PictureBufferState::WAITING_FOR_SYNCTOKEN;
	}

	// Wait for the SyncToken release.
	gpu_task_runner_->PostTask(
	FROM_HERE,
	base::BindOnce(
	&CommandBufferHelper::WaitForSyncToken, command_buffer_helper_,
	sync_token,
	base::BindOnce(&PictureBufferManagerImpl::OnSyncTokenReleased, this,
	picture_buffer_id)));
	}

	void OnSyncTokenReleased(int32_t picture_buffer_id) {
	DVLOG(3) << __func__ << "(" << picture_buffer_id << ")";
	DCHECK(gpu_task_runner_);
	DCHECK(gpu_task_runner_->BelongsToCurrentThread());

	// If the picture buffer is still assigned, mark it as available.
	bool is_assigned = false;
	{
	base::AutoLock lock(picture_buffers_lock_);
	const auto& it = picture_buffers_.find(picture_buffer_id);
	if (it != picture_buffers_.end()) {
	DCHECK_EQ(it->second.state, PictureBufferState::WAITING_FOR_SYNCTOKEN);
	it->second.state = PictureBufferState::AVAILABLE;
	is_assigned = true;
	}
	}

	// If the picture buffer is still assigned, it is ready to be reused.
	// Otherwise it has been dismissed and we can now delete its textures.
	// Neither of these operations should be done while holding the lock.
	if (is_assigned) {
	reuse_picture_buffer_cb_.Run(picture_buffer_id);
	} else {
	DestroyPictureBufferTextures(picture_buffer_id);
	}
	}

	void DestroyPictureBufferTextures(int32_t picture_buffer_id) {
	DVLOG(3) << __func__ << "(" << picture_buffer_id << ")";
	DCHECK(gpu_task_runner_);
	DCHECK(gpu_task_runner_->BelongsToCurrentThread());

	if (!command_buffer_helper_->MakeContextCurrent())
	return;

	const auto& it = picture_buffer_textures_.find(picture_buffer_id);
	DCHECK(it != picture_buffer_textures_.end());
	for (GLuint service_id : it->second)
	command_buffer_helper_->DestroyTexture(service_id);
	picture_buffer_textures_.erase(it);
	}

	ReusePictureBufferCB reuse_picture_buffer_cb_;

	scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner_;
	scoped_refptr<CommandBufferHelper> command_buffer_helper_;

	int32_t picture_buffer_id_ = 0;
	// Includes picture puffers that have been dismissed if their textures have
	// not been deleted yet.
	std::map<int32_t, std::vector<GLuint>> picture_buffer_textures_;

	base::Lock picture_buffers_lock_;
	enum class PictureBufferState {
	// Available for use by the VDA.
	AVAILABLE,
	// Output by the VDA, still bound to a VideoFrame.
	OUTPUT,
	// Waiting on a SyncToken before being reused.
	WAITING_FOR_SYNCTOKEN,
	};
	struct PictureBufferData {
	PictureBufferState state;
	VideoPixelFormat pixel_format;
	gfx::Size texture_size;
	gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
	};
	// Pictures buffers that are assigned to the VDA.
	std::map<int32_t, PictureBufferData> picture_buffers_;

	DISALLOW_COPY_AND_ASSIGN(PictureBufferManagerImpl);
	};

	} // namespace

	// static
	scoped_refptr<PictureBufferManager> PictureBufferManager::Create(
	ReusePictureBufferCB reuse_picture_buffer_cb) {
	return base::MakeRefCounted<PictureBufferManagerImpl>(
	std::move(reuse_picture_buffer_cb));
	}

	} // namespace media