blob: 05d9fb0a1b9322f1c905d31b0a7a2226cf273b3c [file] [log] [blame]
// 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 <map>
#include <vector>
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/shared_memory.h"
#include "base/synchronization/waitable_event.h"
#include "content/common/gpu/gpu_command_buffer_stub.h"
#include "gpu/command_buffer/service/texture_manager.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_sender.h"
#include "media/video/video_decode_accelerator.h"
#include "ui/gfx/size.h"
namespace base {
class MessageLoopProxy;
namespace content {
class GpuVideoDecodeAccelerator
: public IPC::Listener,
public IPC::Sender,
public media::VideoDecodeAccelerator::Client,
public GpuCommandBufferStub::DestructionObserver {
// Each of the arguments to the constructor must outlive this object.
// |stub->decoder()| will be made current around any operation that touches
// the underlying VDA so that it can make GL calls safely.
int32 host_route_id,
GpuCommandBufferStub* stub,
const scoped_refptr<base::MessageLoopProxy>& io_message_loop);
// IPC::Listener implementation.
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
// media::VideoDecodeAccelerator::Client implementation.
virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
const gfx::Size& dimensions,
uint32 texture_target) OVERRIDE;
virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
virtual void PictureReady(const media::Picture& picture) OVERRIDE;
virtual void NotifyError(media::VideoDecodeAccelerator::Error error) OVERRIDE;
virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id) OVERRIDE;
virtual void NotifyFlushDone() OVERRIDE;
virtual void NotifyResetDone() OVERRIDE;
// GpuCommandBufferStub::DestructionObserver implementation.
virtual void OnWillDestroyStub() OVERRIDE;
// Function to delegate sending to actual sender.
virtual bool Send(IPC::Message* message) OVERRIDE;
// Initialize the accelerator with the given profile and send the
// |init_done_msg| when done.
void Initialize(const media::VideoCodecProfile profile,
IPC::Message* init_done_msg);
class MessageFilter;
// We only allow self-delete, from OnWillDestroyStub(), after cleanup there.
virtual ~GpuVideoDecodeAccelerator();
// Handlers for IPC messages.
void OnDecode(base::SharedMemoryHandle handle, int32 id, uint32 size);
void OnAssignPictureBuffers(const std::vector<int32>& buffer_ids,
const std::vector<uint32>& texture_ids);
void OnReusePictureBuffer(int32 picture_buffer_id);
void OnFlush();
void OnReset();
void OnDestroy();
// Called on IO thread when |filter_| has been removed.
void OnFilterRemoved();
// Sets the texture to cleared.
void SetTextureCleared(const media::Picture& picture);
// Helper for replying to the creation request.
void SendCreateDecoderReply(IPC::Message* message, bool succeeded);
// Route ID to communicate with the host.
int32 host_route_id_;
// Unowned pointer to the underlying GpuCommandBufferStub. |this| is
// registered as a DestuctionObserver of |stub_| and will self-delete when
// |stub_| is destroyed.
GpuCommandBufferStub* stub_;
// The underlying VideoDecodeAccelerator.
scoped_ptr<media::VideoDecodeAccelerator> video_decode_accelerator_;
// Callback for making the relevant context current for GL calls.
// Returns false if failed.
base::Callback<bool(void)> make_context_current_;
// The texture dimensions as requested by ProvidePictureBuffers().
gfx::Size texture_dimensions_;
// The texture target as requested by ProvidePictureBuffers().
uint32 texture_target_;
// The message filter to run VDA::Decode on IO thread if VDA supports it.
scoped_refptr<MessageFilter> filter_;
// Used to wait on for |filter_| to be removed, before we can safely
// destroy the VDA.
base::WaitableEvent filter_removed_;
// GPU child message loop.
scoped_refptr<base::MessageLoopProxy> child_message_loop_;
// GPU IO message loop.
scoped_refptr<base::MessageLoopProxy> io_message_loop_;
// Weak pointers will be invalidated on IO thread.
base::WeakPtrFactory<Client> weak_factory_for_io_;
// Protects |uncleared_textures_| when DCHECK is on. This is for debugging
// only. We don't want to hold a lock on IO thread. When DCHECK is off,
// |uncleared_textures_| is only accessed from the child thread.
base::Lock debug_uncleared_textures_lock_;
// A map from picture buffer ID to TextureRef that have not been cleared.
std::map<int32, scoped_refptr<gpu::gles2::TextureRef> > uncleared_textures_;
} // namespace content