content/common/gpu/media/gpu_video_encode_accelerator.cc

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