1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
// 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.
#ifndef CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_DECODE_ACCELERATOR_H_
#define CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_DECODE_ACCELERATOR_H_
#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 {
public:
// 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.
GpuVideoDecodeAccelerator(
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);
private:
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_;
DISALLOW_IMPLICIT_CONSTRUCTORS(GpuVideoDecodeAccelerator);
};
} // namespace content
#endif // CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_DECODE_ACCELERATOR_H_
|
