1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/common/gpu/media/gpu_video_encode_accelerator.h"
6
7 #include "base/callback.h"
8 #include "base/logging.h"
9 #include "base/memory/shared_memory.h"
10 #include "base/message_loop/message_loop_proxy.h"
11 #include "build/build_config.h"
12 #include "content/common/gpu/gpu_channel.h"
13 #include "content/common/gpu/gpu_messages.h"
14 #include "ipc/ipc_message_macros.h"
15 #include "media/base/limits.h"
16 #include "media/base/video_frame.h"
17
18 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
19 #include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
20 #elif defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
21 #include "content/common/gpu/media/android_video_encode_accelerator.h"
22 #endif
23
24 namespace content {
25
MakeDecoderContextCurrent(const base::WeakPtr<GpuCommandBufferStub> stub)26 static bool MakeDecoderContextCurrent(
27 const base::WeakPtr<GpuCommandBufferStub> stub) {
28 if (!stub) {
29 DLOG(ERROR) << "Stub is gone; won't MakeCurrent().";
30 return false;
31 }
32
33 if (!stub->decoder()->MakeCurrent()) {
34 DLOG(ERROR) << "Failed to MakeCurrent()";
35 return false;
36 }
37
38 return true;
39 }
40
GpuVideoEncodeAccelerator(int32 host_route_id,GpuCommandBufferStub * stub)41 GpuVideoEncodeAccelerator::GpuVideoEncodeAccelerator(int32 host_route_id,
42 GpuCommandBufferStub* stub)
43 : host_route_id_(host_route_id),
44 stub_(stub),
45 input_format_(media::VideoFrame::UNKNOWN),
46 output_buffer_size_(0),
47 weak_this_factory_(this) {
48 stub_->AddDestructionObserver(this);
49 make_context_current_ =
50 base::Bind(&MakeDecoderContextCurrent, stub_->AsWeakPtr());
51 }
52
~GpuVideoEncodeAccelerator()53 GpuVideoEncodeAccelerator::~GpuVideoEncodeAccelerator() {
54 // This class can only be self-deleted from OnWillDestroyStub(), which means
55 // the VEA has already been destroyed in there.
56 DCHECK(!encoder_);
57 }
58
Initialize(media::VideoFrame::Format input_format,const gfx::Size & input_visible_size,media::VideoCodecProfile output_profile,uint32 initial_bitrate,IPC::Message * init_done_msg)59 void GpuVideoEncodeAccelerator::Initialize(
60 media::VideoFrame::Format input_format,
61 const gfx::Size& input_visible_size,
62 media::VideoCodecProfile output_profile,
63 uint32 initial_bitrate,
64 IPC::Message* init_done_msg) {
65 DVLOG(2) << "GpuVideoEncodeAccelerator::Initialize(): "
66 "input_format=" << input_format
67 << ", input_visible_size=" << input_visible_size.ToString()
68 << ", output_profile=" << output_profile
69 << ", initial_bitrate=" << initial_bitrate;
70 DCHECK(!encoder_);
71
72 if (!stub_->channel()->AddRoute(host_route_id_, this)) {
73 DLOG(ERROR) << "GpuVideoEncodeAccelerator::Initialize(): "
74 "failed to add route";
75 SendCreateEncoderReply(init_done_msg, false);
76 return;
77 }
78
79 if (input_visible_size.width() > media::limits::kMaxDimension ||
80 input_visible_size.height() > media::limits::kMaxDimension ||
81 input_visible_size.GetArea() > media::limits::kMaxCanvas) {
82 DLOG(ERROR) << "GpuVideoEncodeAccelerator::Initialize(): "
83 "input_visible_size " << input_visible_size.ToString()
84 << " too large";
85 SendCreateEncoderReply(init_done_msg, false);
86 return;
87 }
88
89 CreateEncoder();
90 if (!encoder_) {
91 DLOG(ERROR)
92 << "GpuVideoEncodeAccelerator::Initialize(): VEA creation failed";
93 SendCreateEncoderReply(init_done_msg, false);
94 return;
95 }
96 if (!encoder_->Initialize(input_format,
97 input_visible_size,
98 output_profile,
99 initial_bitrate,
100 this)) {
101 DLOG(ERROR)
102 << "GpuVideoEncodeAccelerator::Initialize(): VEA initialization failed";
103 SendCreateEncoderReply(init_done_msg, false);
104 return;
105 }
106 input_format_ = input_format;
107 input_visible_size_ = input_visible_size;
108 SendCreateEncoderReply(init_done_msg, true);
109 }
110
OnMessageReceived(const IPC::Message & message)111 bool GpuVideoEncodeAccelerator::OnMessageReceived(const IPC::Message& message) {
112 bool handled = true;
113 IPC_BEGIN_MESSAGE_MAP(GpuVideoEncodeAccelerator, message)
114 IPC_MESSAGE_HANDLER(AcceleratedVideoEncoderMsg_Encode, OnEncode)
115 IPC_MESSAGE_HANDLER(AcceleratedVideoEncoderMsg_UseOutputBitstreamBuffer,
116 OnUseOutputBitstreamBuffer)
117 IPC_MESSAGE_HANDLER(
118 AcceleratedVideoEncoderMsg_RequestEncodingParametersChange,
119 OnRequestEncodingParametersChange)
120 IPC_MESSAGE_HANDLER(AcceleratedVideoEncoderMsg_Destroy, OnDestroy)
121 IPC_MESSAGE_UNHANDLED(handled = false)
122 IPC_END_MESSAGE_MAP()
123 return handled;
124 }
125
RequireBitstreamBuffers(unsigned int input_count,const gfx::Size & input_coded_size,size_t output_buffer_size)126 void GpuVideoEncodeAccelerator::RequireBitstreamBuffers(
127 unsigned int input_count,
128 const gfx::Size& input_coded_size,
129 size_t output_buffer_size) {
130 Send(new AcceleratedVideoEncoderHostMsg_RequireBitstreamBuffers(
131 host_route_id_, input_count, input_coded_size, output_buffer_size));
132 input_coded_size_ = input_coded_size;
133 output_buffer_size_ = output_buffer_size;
134 }
135
BitstreamBufferReady(int32 bitstream_buffer_id,size_t payload_size,bool key_frame)136 void GpuVideoEncodeAccelerator::BitstreamBufferReady(int32 bitstream_buffer_id,
137 size_t payload_size,
138 bool key_frame) {
139 Send(new AcceleratedVideoEncoderHostMsg_BitstreamBufferReady(
140 host_route_id_, bitstream_buffer_id, payload_size, key_frame));
141 }
142
NotifyError(media::VideoEncodeAccelerator::Error error)143 void GpuVideoEncodeAccelerator::NotifyError(
144 media::VideoEncodeAccelerator::Error error) {
145 Send(new AcceleratedVideoEncoderHostMsg_NotifyError(host_route_id_, error));
146 }
147
OnWillDestroyStub()148 void GpuVideoEncodeAccelerator::OnWillDestroyStub() {
149 DCHECK(stub_);
150 stub_->channel()->RemoveRoute(host_route_id_);
151 stub_->RemoveDestructionObserver(this);
152 encoder_.reset();
153 delete this;
154 }
155
156 // static
157 std::vector<media::VideoEncodeAccelerator::SupportedProfile>
GetSupportedProfiles()158 GpuVideoEncodeAccelerator::GetSupportedProfiles() {
159 std::vector<media::VideoEncodeAccelerator::SupportedProfile> profiles;
160
161 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
162 profiles = V4L2VideoEncodeAccelerator::GetSupportedProfiles();
163 #elif defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
164 profiles = AndroidVideoEncodeAccelerator::GetSupportedProfiles();
165 #endif
166
167 // TODO(sheu): return platform-specific profiles.
168 return profiles;
169 }
170
CreateEncoder()171 void GpuVideoEncodeAccelerator::CreateEncoder() {
172 DCHECK(!encoder_);
173 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
174 scoped_ptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
175 if (!device.get())
176 return;
177
178 encoder_.reset(new V4L2VideoEncodeAccelerator(device.Pass()));
179 #elif defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
180 encoder_.reset(new AndroidVideoEncodeAccelerator());
181 #endif
182 }
183
OnEncode(int32 frame_id,base::SharedMemoryHandle buffer_handle,uint32 buffer_size,bool force_keyframe)184 void GpuVideoEncodeAccelerator::OnEncode(int32 frame_id,
185 base::SharedMemoryHandle buffer_handle,
186 uint32 buffer_size,
187 bool force_keyframe) {
188 DVLOG(3) << "GpuVideoEncodeAccelerator::OnEncode(): frame_id=" << frame_id
189 << ", buffer_size=" << buffer_size
190 << ", force_keyframe=" << force_keyframe;
191 if (!encoder_)
192 return;
193 if (frame_id < 0) {
194 DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): invalid frame_id="
195 << frame_id;
196 NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
197 return;
198 }
199
200 scoped_ptr<base::SharedMemory> shm(
201 new base::SharedMemory(buffer_handle, true));
202 if (!shm->Map(buffer_size)) {
203 DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): "
204 "could not map frame_id=" << frame_id;
205 NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
206 return;
207 }
208
209 uint8* shm_memory = reinterpret_cast<uint8*>(shm->memory());
210 scoped_refptr<media::VideoFrame> frame =
211 media::VideoFrame::WrapExternalPackedMemory(
212 input_format_,
213 input_coded_size_,
214 gfx::Rect(input_visible_size_),
215 input_visible_size_,
216 shm_memory,
217 buffer_size,
218 buffer_handle,
219 base::TimeDelta(),
220 // It's turtles all the way down...
221 base::Bind(base::IgnoreResult(&base::MessageLoopProxy::PostTask),
222 base::MessageLoopProxy::current(),
223 FROM_HERE,
224 base::Bind(&GpuVideoEncodeAccelerator::EncodeFrameFinished,
225 weak_this_factory_.GetWeakPtr(),
226 frame_id,
227 base::Passed(&shm))));
228
229 if (!frame) {
230 DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): "
231 "could not create VideoFrame for frame_id=" << frame_id;
232 NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
233 return;
234 }
235
236 encoder_->Encode(frame, force_keyframe);
237 }
238
OnUseOutputBitstreamBuffer(int32 buffer_id,base::SharedMemoryHandle buffer_handle,uint32 buffer_size)239 void GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(
240 int32 buffer_id,
241 base::SharedMemoryHandle buffer_handle,
242 uint32 buffer_size) {
243 DVLOG(3) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
244 "buffer_id=" << buffer_id
245 << ", buffer_size=" << buffer_size;
246 if (!encoder_)
247 return;
248 if (buffer_id < 0) {
249 DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
250 "invalid buffer_id=" << buffer_id;
251 NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
252 return;
253 }
254 if (buffer_size < output_buffer_size_) {
255 DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
256 "buffer too small for buffer_id=" << buffer_id;
257 NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
258 return;
259 }
260 encoder_->UseOutputBitstreamBuffer(
261 media::BitstreamBuffer(buffer_id, buffer_handle, buffer_size));
262 }
263
OnDestroy()264 void GpuVideoEncodeAccelerator::OnDestroy() {
265 DVLOG(2) << "GpuVideoEncodeAccelerator::OnDestroy()";
266 OnWillDestroyStub();
267 }
268
OnRequestEncodingParametersChange(uint32 bitrate,uint32 framerate)269 void GpuVideoEncodeAccelerator::OnRequestEncodingParametersChange(
270 uint32 bitrate,
271 uint32 framerate) {
272 DVLOG(2) << "GpuVideoEncodeAccelerator::OnRequestEncodingParametersChange(): "
273 "bitrate=" << bitrate
274 << ", framerate=" << framerate;
275 if (!encoder_)
276 return;
277 encoder_->RequestEncodingParametersChange(bitrate, framerate);
278 }
279
EncodeFrameFinished(int32 frame_id,scoped_ptr<base::SharedMemory> shm)280 void GpuVideoEncodeAccelerator::EncodeFrameFinished(
281 int32 frame_id,
282 scoped_ptr<base::SharedMemory> shm) {
283 Send(new AcceleratedVideoEncoderHostMsg_NotifyInputDone(host_route_id_,
284 frame_id));
285 // Just let shm fall out of scope.
286 }
287
Send(IPC::Message * message)288 void GpuVideoEncodeAccelerator::Send(IPC::Message* message) {
289 stub_->channel()->Send(message);
290 }
291
SendCreateEncoderReply(IPC::Message * message,bool succeeded)292 void GpuVideoEncodeAccelerator::SendCreateEncoderReply(IPC::Message* message,
293 bool succeeded) {
294 GpuCommandBufferMsg_CreateVideoEncoder::WriteReplyParams(message, succeeded);
295 Send(message);
296 }
297
298 } // namespace content
299