content/common/gpu/client/gpu_video_decode_accelerator_host.cc

   1 // Copyright (c) 2012 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/client/gpu_video_decode_accelerator_host.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "content/common/gpu/client/gpu_channel_host.h"
  11 #include "content/common/gpu/gpu_messages.h"
  12 #include "content/common/view_messages.h"
  13 #include "ipc/ipc_message_macros.h"
  14 #include "ipc/ipc_message_utils.h"
  15
  16 #if defined(OS_WIN)
  17 #include "content/public/common/sandbox_init.h"
  18 #endif  // OS_WIN
  19
  20 using media::VideoDecodeAccelerator;
  21 namespace content {
  22
  23 GpuVideoDecodeAcceleratorHost::GpuVideoDecodeAcceleratorHost(
  24     GpuChannelHost* channel,
  25     CommandBufferProxyImpl* impl)
  26     : channel_(channel),
  27       decoder_route_id_(MSG_ROUTING_NONE),
  28       client_(NULL),
  29       impl_(impl),
  30       weak_this_factory_(this) {
  31   DCHECK(channel_);
  32   DCHECK(impl_);
  33   impl_->AddDeletionObserver(this);
  34 }
  35
  36 GpuVideoDecodeAcceleratorHost::~GpuVideoDecodeAcceleratorHost() {
  37   DCHECK(CalledOnValidThread());
  38
  39   if (channel_ && decoder_route_id_ != MSG_ROUTING_NONE)
  40     channel_->RemoveRoute(decoder_route_id_);
  41   if (impl_)
  42     impl_->RemoveDeletionObserver(this);
  43 }
  44
  45 bool GpuVideoDecodeAcceleratorHost::OnMessageReceived(const IPC::Message& msg) {
  46   DCHECK(CalledOnValidThread());
  47   bool handled = true;
  48   IPC_BEGIN_MESSAGE_MAP(GpuVideoDecodeAcceleratorHost, msg)
  49     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed,
  50                         OnBitstreamBufferProcessed)
  51     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers,
  52                         OnProvidePictureBuffer)
  53     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderHostMsg_PictureReady,
  54                         OnPictureReady)
  55     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderHostMsg_FlushDone,
  56                         OnFlushDone)
  57     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderHostMsg_ResetDone,
  58                         OnResetDone)
  59     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderHostMsg_ErrorNotification,
  60                         OnNotifyError)
  61     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderHostMsg_DismissPictureBuffer,
  62                         OnDismissPictureBuffer)
  63     IPC_MESSAGE_UNHANDLED(handled = false)
  64   IPC_END_MESSAGE_MAP()
  65   DCHECK(handled);
  66   // See OnNotifyError for why |this| mustn't be used after OnNotifyError might
  67   // have been called above.
  68   return handled;
  69 }
  70
  71 void GpuVideoDecodeAcceleratorHost::OnChannelError() {
  72   DCHECK(CalledOnValidThread());
  73   if (channel_) {
  74     if (decoder_route_id_ != MSG_ROUTING_NONE)
  75       channel_->RemoveRoute(decoder_route_id_);
  76     channel_ = NULL;
  77   }
  78   DLOG(ERROR) << "OnChannelError()";
  79   PostNotifyError(PLATFORM_FAILURE);
  80 }
  81
  82 bool GpuVideoDecodeAcceleratorHost::Initialize(media::VideoCodecProfile profile,
  83                                                Client* client) {
  84   DCHECK(CalledOnValidThread());
  85   client_ = client;
  86
  87   if (!impl_)
  88     return false;
  89
  90   int32 route_id = channel_->GenerateRouteID();
  91   channel_->AddRoute(route_id, weak_this_factory_.GetWeakPtr());
  92
  93   bool succeeded = false;
  94   Send(new GpuCommandBufferMsg_CreateVideoDecoder(
  95       impl_->GetRouteID(), profile, route_id, &succeeded));
  96
  97   if (!succeeded) {
  98     DLOG(ERROR) << "Send(GpuCommandBufferMsg_CreateVideoDecoder()) failed";
  99     PostNotifyError(PLATFORM_FAILURE);
 100     channel_->RemoveRoute(route_id);
 101     return false;
 102   }
 103   decoder_route_id_ = route_id;
 104   return true;
 105 }
 106
 107 void GpuVideoDecodeAcceleratorHost::Decode(
 108     const media::BitstreamBuffer& bitstream_buffer) {
 109   DCHECK(CalledOnValidThread());
 110   if (!channel_)
 111     return;
 112
 113   base::SharedMemoryHandle handle = channel_->ShareToGpuProcess(
 114       bitstream_buffer.handle());
 115   if (!base::SharedMemory::IsHandleValid(handle)) {
 116     NOTREACHED() << "Failed to duplicate buffer handler";
 117     return;
 118   }
 119
 120   Send(new AcceleratedVideoDecoderMsg_Decode(
 121       decoder_route_id_, handle, bitstream_buffer.id(),
 122       bitstream_buffer.size()));
 123 }
 124
 125 void GpuVideoDecodeAcceleratorHost::AssignPictureBuffers(
 126     const std::vector<media::PictureBuffer>& buffers) {
 127   DCHECK(CalledOnValidThread());
 128   if (!channel_)
 129     return;
 130   // Rearrange data for IPC command.
 131   std::vector<int32> buffer_ids;
 132   std::vector<uint32> texture_ids;
 133   for (uint32 i = 0; i < buffers.size(); i++) {
 134     const media::PictureBuffer& buffer = buffers[i];
 135     if (buffer.size() != picture_buffer_dimensions_) {
 136       DLOG(ERROR) << "buffer.size() invalid: expected "
 137                   << picture_buffer_dimensions_.ToString()
 138                   << ", got " << buffer.size().ToString();
 139       PostNotifyError(INVALID_ARGUMENT);
 140       return;
 141     }
 142     texture_ids.push_back(buffer.texture_id());
 143     buffer_ids.push_back(buffer.id());
 144   }
 145   Send(new AcceleratedVideoDecoderMsg_AssignPictureBuffers(
 146       decoder_route_id_, buffer_ids, texture_ids));
 147 }
 148
 149 void GpuVideoDecodeAcceleratorHost::ReusePictureBuffer(
 150     int32 picture_buffer_id) {
 151   DCHECK(CalledOnValidThread());
 152   if (!channel_)
 153     return;
 154   Send(new AcceleratedVideoDecoderMsg_ReusePictureBuffer(
 155       decoder_route_id_, picture_buffer_id));
 156 }
 157
 158 void GpuVideoDecodeAcceleratorHost::Flush() {
 159   DCHECK(CalledOnValidThread());
 160   if (!channel_)
 161     return;
 162   Send(new AcceleratedVideoDecoderMsg_Flush(decoder_route_id_));
 163 }
 164
 165 void GpuVideoDecodeAcceleratorHost::Reset() {
 166   DCHECK(CalledOnValidThread());
 167   if (!channel_)
 168     return;
 169   Send(new AcceleratedVideoDecoderMsg_Reset(decoder_route_id_));
 170 }
 171
 172 void GpuVideoDecodeAcceleratorHost::Destroy() {
 173   DCHECK(CalledOnValidThread());
 174   if (channel_)
 175     Send(new AcceleratedVideoDecoderMsg_Destroy(decoder_route_id_));
 176   client_ = NULL;
 177   delete this;
 178 }
 179
 180 void GpuVideoDecodeAcceleratorHost::OnWillDeleteImpl() {
 181   DCHECK(CalledOnValidThread());
 182   impl_ = NULL;
 183
 184   // The CommandBufferProxyImpl is going away; error out this VDA.
 185   OnChannelError();
 186 }
 187
 188 void GpuVideoDecodeAcceleratorHost::PostNotifyError(Error error) {
 189   DCHECK(CalledOnValidThread());
 190   DVLOG(2) << "PostNotifyError(): error=" << error;
 191   base::MessageLoopProxy::current()->PostTask(
 192       FROM_HERE,
 193       base::Bind(&GpuVideoDecodeAcceleratorHost::OnNotifyError,
 194                  weak_this_factory_.GetWeakPtr(),
 195                  error));
 196 }
 197
 198 void GpuVideoDecodeAcceleratorHost::Send(IPC::Message* message) {
 199   DCHECK(CalledOnValidThread());
 200   uint32 message_type = message->type();
 201   if (!channel_->Send(message)) {
 202     DLOG(ERROR) << "Send(" << message_type << ") failed";
 203     PostNotifyError(PLATFORM_FAILURE);
 204   }
 205 }
 206
 207 void GpuVideoDecodeAcceleratorHost::OnBitstreamBufferProcessed(
 208     int32 bitstream_buffer_id) {
 209   DCHECK(CalledOnValidThread());
 210   if (client_)
 211     client_->NotifyEndOfBitstreamBuffer(bitstream_buffer_id);
 212 }
 213
 214 void GpuVideoDecodeAcceleratorHost::OnProvidePictureBuffer(
 215     uint32 num_requested_buffers,
 216     const gfx::Size& dimensions,
 217     uint32 texture_target) {
 218   DCHECK(CalledOnValidThread());
 219   picture_buffer_dimensions_ = dimensions;
 220   if (client_) {
 221     client_->ProvidePictureBuffers(
 222         num_requested_buffers, dimensions, texture_target);
 223   }
 224 }
 225
 226 void GpuVideoDecodeAcceleratorHost::OnDismissPictureBuffer(
 227     int32 picture_buffer_id) {
 228   DCHECK(CalledOnValidThread());
 229   if (client_)
 230     client_->DismissPictureBuffer(picture_buffer_id);
 231 }
 232
 233 void GpuVideoDecodeAcceleratorHost::OnPictureReady(
 234     int32 picture_buffer_id, int32 bitstream_buffer_id) {
 235   DCHECK(CalledOnValidThread());
 236   if (!client_)
 237     return;
 238   media::Picture picture(picture_buffer_id, bitstream_buffer_id);
 239   client_->PictureReady(picture);
 240 }
 241
 242 void GpuVideoDecodeAcceleratorHost::OnFlushDone() {
 243   DCHECK(CalledOnValidThread());
 244   if (client_)
 245     client_->NotifyFlushDone();
 246 }
 247
 248 void GpuVideoDecodeAcceleratorHost::OnResetDone() {
 249   DCHECK(CalledOnValidThread());
 250   if (client_)
 251     client_->NotifyResetDone();
 252 }
 253
 254 void GpuVideoDecodeAcceleratorHost::OnNotifyError(uint32 error) {
 255   DCHECK(CalledOnValidThread());
 256   if (!client_)
 257     return;
 258   weak_this_factory_.InvalidateWeakPtrs();
 259
 260   // Client::NotifyError() may Destroy() |this|, so calling it needs to be the
 261   // last thing done on this stack!
 262   media::VideoDecodeAccelerator::Client* client = NULL;
 263   std::swap(client, client_);
 264   client->NotifyError(static_cast<media::VideoDecodeAccelerator::Error>(error));
 265 }
 266
 267 }  // namespace content