| // 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 "media/gpu/ipc/service/gpu_video_decode_accelerator.h" |
| |
| #include <memory> |
| #include <vector> |
| |
| #include "base/bind.h" |
| #include "base/bind_post_task.h" |
| #include "base/location.h" |
| #include "base/logging.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "build/build_config.h" |
| #include "gpu/command_buffer/common/command_buffer.h" |
| #include "gpu/config/gpu_preferences.h" |
| #include "gpu/ipc/service/gpu_channel.h" |
| #include "gpu/ipc/service/gpu_channel_manager.h" |
| #include "ipc/ipc_message_macros.h" |
| #include "ipc/ipc_message_utils.h" |
| #include "ipc/message_filter.h" |
| #include "media/base/limits.h" |
| #include "media/gpu/gpu_video_accelerator_util.h" |
| #include "media/gpu/gpu_video_decode_accelerator_factory.h" |
| #include "mojo/public/cpp/bindings/associated_receiver.h" |
| #include "ui/gfx/geometry/size.h" |
| #include "ui/gl/gl_context.h" |
| #include "ui/gl/gl_image.h" |
| |
| namespace media { |
| |
| namespace { |
| static gl::GLContext* GetGLContext( |
| const base::WeakPtr<gpu::CommandBufferStub>& stub) { |
| if (!stub) { |
| DLOG(ERROR) << "Stub is gone; no GLContext."; |
| return nullptr; |
| } |
| |
| return stub->decoder_context()->GetGLContext(); |
| } |
| |
| static bool MakeDecoderContextCurrent( |
| const base::WeakPtr<gpu::CommandBufferStub>& stub) { |
| if (!stub) { |
| DLOG(ERROR) << "Stub is gone; won't MakeCurrent()."; |
| return false; |
| } |
| |
| if (!stub->decoder_context()->MakeCurrent()) { |
| DLOG(ERROR) << "Failed to MakeCurrent()"; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static bool BindImage(const base::WeakPtr<gpu::CommandBufferStub>& stub, |
| uint32_t client_texture_id, |
| uint32_t texture_target, |
| const scoped_refptr<gl::GLImage>& image, |
| bool can_bind_to_sampler) { |
| if (!stub) { |
| DLOG(ERROR) << "Stub is gone; won't BindImage()."; |
| return false; |
| } |
| |
| gpu::DecoderContext* command_decoder = stub->decoder_context(); |
| command_decoder->BindImage(client_texture_id, texture_target, image.get(), |
| can_bind_to_sampler); |
| return true; |
| } |
| |
| static gpu::gles2::ContextGroup* GetContextGroup( |
| const base::WeakPtr<gpu::CommandBufferStub>& stub) { |
| if (!stub) { |
| DLOG(ERROR) << "Stub is gone; no DecoderContext."; |
| return nullptr; |
| } |
| |
| return stub->decoder_context()->GetContextGroup(); |
| } |
| |
| static std::unique_ptr<gpu::gles2::AbstractTexture> CreateAbstractTexture( |
| const base::WeakPtr<gpu::CommandBufferStub>& stub, |
| GLenum target, |
| GLenum internal_format, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLint border, |
| GLenum format, |
| GLenum type) { |
| if (!stub) { |
| DLOG(ERROR) << "Stub is gone; no DecoderContext."; |
| return nullptr; |
| } |
| |
| return stub->decoder_context()->CreateAbstractTexture( |
| target, internal_format, width, height, depth, border, format, type); |
| } |
| |
| } // anonymous namespace |
| |
| // DebugAutoLock works like AutoLock but only acquires the lock when |
| // DCHECK is on. |
| #if DCHECK_IS_ON() |
| typedef base::AutoLock DebugAutoLock; |
| #else |
| class DebugAutoLock { |
| public: |
| explicit DebugAutoLock(base::Lock&) {} |
| }; |
| #endif |
| |
| // Receives incoming messages for the decoder. Operates exclusively on the IO |
| // thread, since sometimes we want to do decodes directly from there. |
| class GpuVideoDecodeAccelerator::MessageFilter |
| : public mojom::GpuAcceleratedVideoDecoder { |
| public: |
| MessageFilter(GpuVideoDecodeAccelerator* owner, |
| scoped_refptr<base::SequencedTaskRunner> owner_task_runner, |
| bool decode_on_io) |
| : owner_(owner), |
| owner_task_runner_(std::move(owner_task_runner)), |
| decode_on_io_(decode_on_io) {} |
| ~MessageFilter() override = default; |
| |
| // Called from the main thread. Posts to `io_task_runner` to do the binding |
| // and waits for completion before returning. This ensures the decoder's |
| // endpoint is established before the synchronous request to establish it is |
| // acknowledged to the client. |
| bool Bind(mojo::PendingAssociatedReceiver<mojom::GpuAcceleratedVideoDecoder> |
| receiver, |
| const scoped_refptr<base::SequencedTaskRunner>& io_task_runner) { |
| base::WaitableEvent bound_event; |
| if (!io_task_runner->PostTask( |
| FROM_HERE, base::BindOnce(&MessageFilter::BindOnIoThread, |
| base::Unretained(this), |
| std::move(receiver), &bound_event))) { |
| return false; |
| } |
| bound_event.Wait(); |
| return true; |
| } |
| |
| // Must be called on the IO thread. Posts back to the owner's task runner to |
| // destroy it. |
| void RequestShutdown() { |
| if (!owner_) |
| return; |
| |
| // Must be reset here on the IO thread before `this` is destroyed. |
| receiver_.reset(); |
| |
| GpuVideoDecodeAccelerator* owner = owner_; |
| owner_ = nullptr; |
| |
| // Invalidate any IO thread WeakPtrs which may be held by the |
| // VideoDecodeAccelerator, and post to delete our owner which will in turn |
| // delete us. Note that it is unsafe to access any members of `this` once |
| // the task below is posted. |
| owner->weak_factory_for_io_.InvalidateWeakPtrs(); |
| owner_task_runner_->PostTask( |
| FROM_HERE, base::BindOnce(&GpuVideoDecodeAccelerator::DeleteSelfNow, |
| base::Unretained(owner))); |
| } |
| |
| // mojom::GpuAcceleratedVideoDecoder: |
| void Decode(BitstreamBuffer buffer) override; |
| void AssignPictureBuffers( |
| std::vector<mojom::PictureBufferAssignmentPtr> assignments) override; |
| void ReusePictureBuffer(int32_t picture_buffer_id) override; |
| void Flush(FlushCallback callback) override; |
| void Reset(ResetCallback callback) override; |
| void SetOverlayInfo(const OverlayInfo& overlay_info) override; |
| |
| private: |
| void BindOnIoThread(mojo::PendingAssociatedReceiver< |
| mojom::GpuAcceleratedVideoDecoder> receiver, |
| base::WaitableEvent* bound_event) { |
| receiver_.Bind(std::move(receiver)); |
| receiver_.set_disconnect_handler( |
| base::BindOnce(&MessageFilter::OnDisconnect, base::Unretained(this))); |
| bound_event->Signal(); |
| } |
| |
| void OnDisconnect() { |
| if (!owner_) |
| return; |
| |
| owner_task_runner_->PostTask( |
| FROM_HERE, base::BindOnce(&GpuVideoDecodeAccelerator::OnDestroy, |
| base::Unretained(owner_))); |
| } |
| |
| GpuVideoDecodeAccelerator* owner_; |
| const scoped_refptr<base::SequencedTaskRunner> owner_task_runner_; |
| const bool decode_on_io_; |
| mojo::AssociatedReceiver<mojom::GpuAcceleratedVideoDecoder> receiver_{this}; |
| }; |
| |
| void GpuVideoDecodeAccelerator::MessageFilter::Decode(BitstreamBuffer buffer) { |
| if (!owner_) |
| return; |
| |
| if (decode_on_io_) { |
| owner_->OnDecode(std::move(buffer)); |
| } else { |
| owner_task_runner_->PostTask( |
| FROM_HERE, base::BindOnce(&GpuVideoDecodeAccelerator::OnDecode, |
| base::Unretained(owner_), std::move(buffer))); |
| } |
| } |
| |
| void GpuVideoDecodeAccelerator::MessageFilter::AssignPictureBuffers( |
| std::vector<mojom::PictureBufferAssignmentPtr> assignments) { |
| if (!owner_) |
| return; |
| owner_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(&GpuVideoDecodeAccelerator::OnAssignPictureBuffers, |
| base::Unretained(owner_), std::move(assignments))); |
| } |
| |
| void GpuVideoDecodeAccelerator::MessageFilter::ReusePictureBuffer( |
| int32_t picture_buffer_id) { |
| if (!owner_) |
| return; |
| owner_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(&GpuVideoDecodeAccelerator::OnReusePictureBuffer, |
| base::Unretained(owner_), picture_buffer_id)); |
| } |
| |
| void GpuVideoDecodeAccelerator::MessageFilter::Flush(FlushCallback callback) { |
| if (!owner_) |
| return; |
| owner_task_runner_->PostTask( |
| FROM_HERE, base::BindOnce(&GpuVideoDecodeAccelerator::OnFlush, |
| base::Unretained(owner_), std::move(callback))); |
| } |
| |
| void GpuVideoDecodeAccelerator::MessageFilter::Reset(ResetCallback callback) { |
| if (!owner_) |
| return; |
| owner_task_runner_->PostTask( |
| FROM_HERE, base::BindOnce(&GpuVideoDecodeAccelerator::OnReset, |
| base::Unretained(owner_), std::move(callback))); |
| } |
| |
| void GpuVideoDecodeAccelerator::MessageFilter::SetOverlayInfo( |
| const OverlayInfo& overlay_info) { |
| if (!owner_) |
| return; |
| owner_task_runner_->PostTask( |
| FROM_HERE, base::BindOnce(&GpuVideoDecodeAccelerator::OnSetOverlayInfo, |
| base::Unretained(owner_), overlay_info)); |
| } |
| |
| GpuVideoDecodeAccelerator::GpuVideoDecodeAccelerator( |
| gpu::CommandBufferStub* stub, |
| const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner, |
| const AndroidOverlayMojoFactoryCB& overlay_factory_cb) |
| : stub_(stub), |
| texture_target_(0), |
| pixel_format_(PIXEL_FORMAT_UNKNOWN), |
| textures_per_buffer_(0), |
| child_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
| io_task_runner_(io_task_runner), |
| overlay_factory_cb_(overlay_factory_cb) { |
| DCHECK(stub_); |
| stub_->AddDestructionObserver(this); |
| gl_client_.get_context = |
| base::BindRepeating(&GetGLContext, stub_->AsWeakPtr()); |
| gl_client_.make_context_current = |
| base::BindRepeating(&MakeDecoderContextCurrent, stub_->AsWeakPtr()); |
| gl_client_.bind_image = base::BindRepeating(&BindImage, stub_->AsWeakPtr()); |
| gl_client_.get_context_group = |
| base::BindRepeating(&GetContextGroup, stub_->AsWeakPtr()); |
| gl_client_.create_abstract_texture = |
| base::BindRepeating(&CreateAbstractTexture, stub_->AsWeakPtr()); |
| gl_client_.is_passthrough = |
| stub_->decoder_context()->GetFeatureInfo()->is_passthrough_cmd_decoder(); |
| gl_client_.supports_arb_texture_rectangle = stub_->decoder_context() |
| ->GetFeatureInfo() |
| ->feature_flags() |
| .arb_texture_rectangle; |
| } |
| |
| GpuVideoDecodeAccelerator::~GpuVideoDecodeAccelerator() { |
| // This class can only be self-deleted from OnWillDestroyStub(), which means |
| // the VDA has already been destroyed in there. |
| DCHECK(!video_decode_accelerator_); |
| } |
| |
| void GpuVideoDecodeAccelerator::DeleteSelfNow() { |
| delete this; |
| } |
| |
| // static |
| gpu::VideoDecodeAcceleratorCapabilities |
| GpuVideoDecodeAccelerator::GetCapabilities( |
| const gpu::GpuPreferences& gpu_preferences, |
| const gpu::GpuDriverBugWorkarounds& workarounds) { |
| return GpuVideoDecodeAcceleratorFactory::GetDecoderCapabilities( |
| gpu_preferences, workarounds); |
| } |
| |
| void GpuVideoDecodeAccelerator::NotifyInitializationComplete(Status status) { |
| decoder_client_->OnInitializationComplete(status.is_ok()); |
| } |
| |
| void GpuVideoDecodeAccelerator::ProvidePictureBuffers( |
| uint32_t requested_num_of_buffers, |
| VideoPixelFormat format, |
| uint32_t textures_per_buffer, |
| const gfx::Size& dimensions, |
| uint32_t texture_target) { |
| if (dimensions.width() > limits::kMaxDimension || |
| dimensions.height() > limits::kMaxDimension || |
| dimensions.GetArea() > limits::kMaxCanvas) { |
| NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE); |
| return; |
| } |
| |
| texture_dimensions_ = dimensions; |
| textures_per_buffer_ = textures_per_buffer; |
| texture_target_ = texture_target; |
| pixel_format_ = format; |
| |
| decoder_client_->OnProvidePictureBuffers(requested_num_of_buffers, format, |
| textures_per_buffer, dimensions, |
| texture_target); |
| } |
| |
| void GpuVideoDecodeAccelerator::DismissPictureBuffer( |
| int32_t picture_buffer_id) { |
| // Notify client that picture buffer is now unused. |
| decoder_client_->OnDismissPictureBuffer(picture_buffer_id); |
| DebugAutoLock auto_lock(debug_uncleared_textures_lock_); |
| uncleared_textures_.erase(picture_buffer_id); |
| } |
| |
| void GpuVideoDecodeAccelerator::PictureReady(const Picture& picture) { |
| // VDA may call PictureReady on IO thread. SetTextureCleared should run on |
| // the child thread. VDA is responsible to call PictureReady on the child |
| // thread when a picture buffer is delivered the first time. |
| if (child_task_runner_->BelongsToCurrentThread()) { |
| SetTextureCleared(picture); |
| } else { |
| DCHECK(io_task_runner_->BelongsToCurrentThread()); |
| DebugAutoLock auto_lock(debug_uncleared_textures_lock_); |
| DCHECK_EQ(0u, uncleared_textures_.count(picture.picture_buffer_id())); |
| } |
| |
| auto params = mojom::PictureReadyParams::New(); |
| params->picture_buffer_id = picture.picture_buffer_id(); |
| params->bitstream_buffer_id = picture.bitstream_buffer_id(); |
| params->visible_rect = picture.visible_rect(); |
| params->color_space = picture.color_space(); |
| params->allow_overlay = picture.allow_overlay(); |
| params->read_lock_fences_enabled = picture.read_lock_fences_enabled(); |
| params->size_changed = picture.size_changed(); |
| params->surface_texture = picture.texture_owner(); |
| params->wants_promotion_hint = picture.wants_promotion_hint(); |
| decoder_client_->OnPictureReady(std::move(params)); |
| } |
| |
| void GpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer( |
| int32_t bitstream_buffer_id) { |
| decoder_client_->OnBitstreamBufferProcessed(bitstream_buffer_id); |
| } |
| |
| void GpuVideoDecodeAccelerator::NotifyFlushDone() { |
| DCHECK(!pending_flushes_.empty()); |
| std::move(pending_flushes_.front()).Run(); |
| pending_flushes_.pop_front(); |
| } |
| |
| void GpuVideoDecodeAccelerator::NotifyResetDone() { |
| DCHECK(!pending_resets_.empty()); |
| std::move(pending_resets_.front()).Run(); |
| pending_resets_.pop_front(); |
| } |
| |
| void GpuVideoDecodeAccelerator::NotifyError( |
| VideoDecodeAccelerator::Error error) { |
| decoder_client_->OnError(error); |
| } |
| |
| void GpuVideoDecodeAccelerator::OnWillDestroyStub(bool have_context) { |
| // The stub is going away, so we have to stop and destroy VDA here, before |
| // returning, because the VDA may need the GL context to run and/or do its |
| // cleanup. We cannot destroy the VDA before the IO thread message filter is |
| // removed however, since we cannot service incoming messages with VDA gone. |
| // We cannot simply check for existence of VDA on IO thread though, because |
| // we don't want to synchronize the IO thread with the ChildThread. |
| // So we have to wait for the RemoveFilter callback here instead and remove |
| // the VDA after it arrives and before returning. |
| stub_->RemoveDestructionObserver(this); |
| if (filter_) { |
| io_task_runner_->PostTask(FROM_HERE, |
| base::BindOnce(&MessageFilter::RequestShutdown, |
| base::Unretained(filter_.get()))); |
| } |
| |
| video_decode_accelerator_.reset(); |
| } |
| |
| bool GpuVideoDecodeAccelerator::Initialize( |
| const VideoDecodeAccelerator::Config& config, |
| mojo::PendingAssociatedReceiver<mojom::GpuAcceleratedVideoDecoder> receiver, |
| mojo::PendingAssociatedRemote<mojom::GpuAcceleratedVideoDecoderClient> |
| client) { |
| DCHECK(!video_decode_accelerator_); |
| |
| #if !defined(OS_WIN) |
| // Ensure we will be able to get a GL context at all before initializing |
| // non-Windows VDAs. |
| if (!gl_client_.make_context_current.Run()) |
| return false; |
| #endif |
| |
| std::unique_ptr<GpuVideoDecodeAcceleratorFactory> vda_factory = |
| GpuVideoDecodeAcceleratorFactory::Create(gl_client_); |
| if (!vda_factory) { |
| LOG(ERROR) << "Failed creating the VDA factory"; |
| return false; |
| } |
| |
| const gpu::GpuDriverBugWorkarounds& gpu_workarounds = |
| stub_->channel()->gpu_channel_manager()->gpu_driver_bug_workarounds(); |
| const gpu::GpuPreferences& gpu_preferences = |
| stub_->channel()->gpu_channel_manager()->gpu_preferences(); |
| |
| if (config.output_mode != |
| VideoDecodeAccelerator::Config::OutputMode::ALLOCATE) { |
| DLOG(ERROR) << "Only ALLOCATE mode is supported"; |
| return false; |
| } |
| |
| video_decode_accelerator_ = |
| vda_factory->CreateVDA(this, config, gpu_workarounds, gpu_preferences); |
| if (!video_decode_accelerator_) { |
| LOG(ERROR) << "HW video decode not available for profile " |
| << GetProfileName(config.profile) |
| << (config.is_encrypted() ? " with encryption" : ""); |
| return false; |
| } |
| |
| decoder_client_.Bind(std::move(client), io_task_runner_); |
| |
| // Attempt to set up performing decoding tasks on IO thread, if supported by |
| // the VDA. |
| bool decode_on_io = |
| video_decode_accelerator_->TryToSetupDecodeOnSeparateThread( |
| weak_factory_for_io_.GetWeakPtr(), io_task_runner_); |
| |
| // Bind the receiver on the IO thread. We wait here for it to be bound |
| // before returning and signaling that the decoder has been created. |
| filter_ = |
| std::make_unique<MessageFilter>(this, stub_->task_runner(), decode_on_io); |
| return filter_->Bind(std::move(receiver), io_task_runner_); |
| } |
| |
| // Runs on IO thread if VDA::TryToSetupDecodeOnSeparateThread() succeeded, |
| // otherwise on the main thread. |
| void GpuVideoDecodeAccelerator::OnDecode(BitstreamBuffer bitstream_buffer) { |
| DCHECK(video_decode_accelerator_); |
| video_decode_accelerator_->Decode(std::move(bitstream_buffer)); |
| } |
| |
| void GpuVideoDecodeAccelerator::OnAssignPictureBuffers( |
| std::vector<mojom::PictureBufferAssignmentPtr> assignments) { |
| gpu::DecoderContext* decoder_context = stub_->decoder_context(); |
| gpu::gles2::TextureManager* texture_manager = |
| stub_->decoder_context()->GetContextGroup()->texture_manager(); |
| |
| std::vector<PictureBuffer> buffers; |
| std::vector<std::vector<scoped_refptr<gpu::gles2::TextureRef>>> textures; |
| for (const auto& assignment : assignments) { |
| if (assignment->buffer_id < 0) { |
| DLOG(ERROR) << "Buffer id " << assignment->buffer_id << " out of range"; |
| NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT); |
| return; |
| } |
| std::vector<scoped_refptr<gpu::gles2::TextureRef>> current_textures; |
| PictureBuffer::TextureIds buffer_texture_ids = assignment->texture_ids; |
| 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(VideoDecodeAccelerator::INVALID_ARGUMENT); |
| return; |
| } |
| for (size_t j = 0; j < textures_per_buffer_; j++) { |
| gpu::TextureBase* texture_base = |
| decoder_context->GetTextureBase(buffer_texture_ids[j]); |
| if (!texture_base) { |
| DLOG(ERROR) << "Failed to find texture id " << buffer_texture_ids[j]; |
| NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT); |
| return; |
| } |
| |
| if (texture_base->target() != texture_target_) { |
| DLOG(ERROR) << "Texture target mismatch for texture id " |
| << buffer_texture_ids[j]; |
| NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT); |
| return; |
| } |
| |
| if (texture_manager) { |
| gpu::gles2::TextureRef* texture_ref = |
| texture_manager->GetTexture(buffer_texture_ids[j]); |
| if (texture_ref) { |
| gpu::gles2::Texture* info = texture_ref->texture(); |
| 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, GL_UNSIGNED_BYTE, 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(VideoDecodeAccelerator::INVALID_ARGUMENT); |
| return; |
| } |
| |
| // TODO(dshwang): after moving to D3D11, remove this. |
| // https://crbug.com/438691 |
| GLenum format = |
| video_decode_accelerator_->GetSurfaceInternalFormat(); |
| if (format != GL_RGBA) { |
| DCHECK(format == GL_BGRA_EXT); |
| texture_manager->SetLevelInfo(texture_ref, texture_target_, 0, |
| format, width, height, 1, 0, format, |
| GL_UNSIGNED_BYTE, gfx::Rect()); |
| } |
| } |
| current_textures.push_back(texture_ref); |
| } |
| } |
| service_ids.push_back(texture_base->service_id()); |
| } |
| textures.push_back(current_textures); |
| buffers.emplace_back(assignment->buffer_id, texture_dimensions_, |
| buffer_texture_ids, service_ids, texture_target_, |
| pixel_format_); |
| } |
| { |
| DebugAutoLock auto_lock(debug_uncleared_textures_lock_); |
| for (uint32_t i = 0; i < assignments.size(); ++i) |
| uncleared_textures_[assignments[i]->buffer_id] = textures[i]; |
| } |
| video_decode_accelerator_->AssignPictureBuffers(buffers); |
| } |
| |
| void GpuVideoDecodeAccelerator::OnReusePictureBuffer( |
| int32_t picture_buffer_id) { |
| DCHECK(video_decode_accelerator_); |
| video_decode_accelerator_->ReusePictureBuffer(picture_buffer_id); |
| } |
| |
| void GpuVideoDecodeAccelerator::OnFlush(base::OnceClosure callback) { |
| DCHECK(video_decode_accelerator_); |
| pending_flushes_.push_back( |
| base::BindPostTask(io_task_runner_, std::move(callback))); |
| video_decode_accelerator_->Flush(); |
| } |
| |
| void GpuVideoDecodeAccelerator::OnReset(base::OnceClosure callback) { |
| DCHECK(video_decode_accelerator_); |
| pending_resets_.push_back( |
| base::BindPostTask(io_task_runner_, std::move(callback))); |
| video_decode_accelerator_->Reset(); |
| } |
| |
| void GpuVideoDecodeAccelerator::OnSetOverlayInfo( |
| const OverlayInfo& overlay_info) { |
| DCHECK(video_decode_accelerator_); |
| video_decode_accelerator_->SetOverlayInfo(overlay_info); |
| } |
| |
| void GpuVideoDecodeAccelerator::OnDestroy() { |
| DCHECK(video_decode_accelerator_); |
| OnWillDestroyStub(false); |
| } |
| |
| void GpuVideoDecodeAccelerator::SetTextureCleared(const Picture& picture) { |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| DebugAutoLock auto_lock(debug_uncleared_textures_lock_); |
| auto it = uncleared_textures_.find(picture.picture_buffer_id()); |
| if (it == uncleared_textures_.end()) |
| return; // the texture has been cleared |
| |
| for (auto texture_ref : it->second) { |
| GLenum target = texture_ref->texture()->target(); |
| gpu::gles2::TextureManager* texture_manager = |
| stub_->decoder_context()->GetContextGroup()->texture_manager(); |
| texture_manager->SetLevelCleared(texture_ref.get(), target, 0, true); |
| } |
| uncleared_textures_.erase(it); |
| } |
| |
| } // namespace media |