content/renderer/pepper/pepper_video_source_host.cc

   1 // Copyright (c) 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/renderer/pepper/pepper_video_source_host.h"
   6
   7 #include "base/bind.h"
   8 #include "base/numerics/safe_conversions.h"
   9 #include "content/public/renderer/renderer_ppapi_host.h"
  10 #include "content/renderer/pepper/ppb_image_data_impl.h"
  11 #include "content/renderer/render_thread_impl.h"
  12 #include "ppapi/c/pp_errors.h"
  13 #include "ppapi/host/dispatch_host_message.h"
  14 #include "ppapi/host/ppapi_host.h"
  15 #include "ppapi/proxy/host_dispatcher.h"
  16 #include "ppapi/proxy/ppapi_messages.h"
  17 #include "ppapi/proxy/ppb_image_data_proxy.h"
  18 #include "ppapi/shared_impl/scoped_pp_resource.h"
  19 #include "ppapi/thunk/enter.h"
  20 #include "ppapi/thunk/ppb_image_data_api.h"
  21 #include "third_party/libyuv/include/libyuv/convert.h"
  22 #include "third_party/libyuv/include/libyuv/scale.h"
  23 #include "third_party/skia/include/core/SkBitmap.h"
  24
  25 using ppapi::host::HostMessageContext;
  26 using ppapi::host::ReplyMessageContext;
  27
  28 namespace content {
  29
  30 PepperVideoSourceHost::FrameReceiver::FrameReceiver(
  31     const base::WeakPtr<PepperVideoSourceHost>& host)
  32     : host_(host) {}
  33
  34 PepperVideoSourceHost::FrameReceiver::~FrameReceiver() {}
  35
  36 void PepperVideoSourceHost::FrameReceiver::GotFrame(
  37     const scoped_refptr<media::VideoFrame>& frame) {
  38   DCHECK(thread_checker_.CalledOnValidThread());
  39   if (host_.get()) {
  40     // Hold a reference to the new frame and release the previous.
  41     host_->last_frame_ = frame;
  42
  43     if (host_->get_frame_pending_)
  44       host_->SendGetFrameReply();
  45   }
  46 }
  47
  48 PepperVideoSourceHost::PepperVideoSourceHost(RendererPpapiHost* host,
  49                                              PP_Instance instance,
  50                                              PP_Resource resource)
  51     : ResourceHost(host->GetPpapiHost(), instance, resource),
  52       source_handler_(new VideoSourceHandler(NULL)),
  53       get_frame_pending_(false),
  54       weak_factory_(this) {
  55   frame_receiver_ = new FrameReceiver(weak_factory_.GetWeakPtr());
  56   memset(&shared_image_desc_, 0, sizeof(shared_image_desc_));
  57 }
  58
  59 PepperVideoSourceHost::~PepperVideoSourceHost() { Close(); }
  60
  61 int32_t PepperVideoSourceHost::OnResourceMessageReceived(
  62     const IPC::Message& msg,
  63     HostMessageContext* context) {
  64   PPAPI_BEGIN_MESSAGE_MAP(PepperVideoSourceHost, msg)
  65     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoSource_Open,
  66                                       OnHostMsgOpen)
  67     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoSource_GetFrame,
  68                                         OnHostMsgGetFrame)
  69     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoSource_Close,
  70                                         OnHostMsgClose)
  71   PPAPI_END_MESSAGE_MAP()
  72   return PP_ERROR_FAILED;
  73 }
  74
  75 int32_t PepperVideoSourceHost::OnHostMsgOpen(HostMessageContext* context,
  76                                              const std::string& stream_url) {
  77   GURL gurl(stream_url);
  78   if (!gurl.is_valid())
  79     return PP_ERROR_BADARGUMENT;
  80
  81   if (!source_handler_->Open(gurl.spec(), frame_receiver_.get()))
  82     return PP_ERROR_BADARGUMENT;
  83
  84   stream_url_ = gurl.spec();
  85
  86   ReplyMessageContext reply_context = context->MakeReplyMessageContext();
  87   reply_context.params.set_result(PP_OK);
  88   host()->SendReply(reply_context, PpapiPluginMsg_VideoSource_OpenReply());
  89   return PP_OK_COMPLETIONPENDING;
  90 }
  91
  92 int32_t PepperVideoSourceHost::OnHostMsgGetFrame(HostMessageContext* context) {
  93   if (!source_handler_.get())
  94     return PP_ERROR_FAILED;
  95   if (get_frame_pending_)
  96     return PP_ERROR_INPROGRESS;
  97
  98   reply_context_ = context->MakeReplyMessageContext();
  99   get_frame_pending_ = true;
 100
 101   // If a frame is ready, try to convert it and send the reply.
 102   if (last_frame_.get())
 103     SendGetFrameReply();
 104
 105   return PP_OK_COMPLETIONPENDING;
 106 }
 107
 108 int32_t PepperVideoSourceHost::OnHostMsgClose(HostMessageContext* context) {
 109   Close();
 110   return PP_OK;
 111 }
 112
 113 void PepperVideoSourceHost::SendGetFrameReply() {
 114   DCHECK(get_frame_pending_);
 115   get_frame_pending_ = false;
 116
 117   DCHECK(last_frame_.get());
 118   const gfx::Size dst_size = last_frame_->natural_size();
 119
 120   // Note: We try to reuse the shared memory for the previous frame here. This
 121   // means that the previous frame may be overwritten and is no longer valid
 122   // after calling this function again.
 123   IPC::PlatformFileForTransit image_handle;
 124   uint32_t byte_count;
 125   if (shared_image_.get() && dst_size.width() == shared_image_->width() &&
 126       dst_size.height() == shared_image_->height()) {
 127     // We have already allocated the correct size in shared memory. We need to
 128     // duplicate the handle for IPC however, which will close down the
 129     // duplicated handle when it's done.
 130     int local_fd = 0;
 131     if (shared_image_->GetSharedMemory(&local_fd, &byte_count) != PP_OK) {
 132       SendGetFrameErrorReply(PP_ERROR_FAILED);
 133       return;
 134     }
 135
 136     ppapi::proxy::HostDispatcher* dispatcher =
 137         ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
 138     if (!dispatcher) {
 139       SendGetFrameErrorReply(PP_ERROR_FAILED);
 140       return;
 141     }
 142
 143 #if defined(OS_WIN)
 144     image_handle = dispatcher->ShareHandleWithRemote(
 145         reinterpret_cast<HANDLE>(static_cast<intptr_t>(local_fd)), false);
 146 #elif defined(OS_POSIX)
 147     image_handle = dispatcher->ShareHandleWithRemote(local_fd, false);
 148 #else
 149 #error Not implemented.
 150 #endif
 151   } else {
 152     // We need to allocate new shared memory.
 153     shared_image_ = NULL;  // Release any previous image.
 154
 155     ppapi::ScopedPPResource resource(
 156         ppapi::ScopedPPResource::PassRef(),
 157         ppapi::proxy::PPB_ImageData_Proxy::CreateImageData(
 158             pp_instance(),
 159             ppapi::PPB_ImageData_Shared::SIMPLE,
 160             PP_IMAGEDATAFORMAT_BGRA_PREMUL,
 161             PP_MakeSize(dst_size.width(), dst_size.height()),
 162             false /* init_to_zero */,
 163             &shared_image_desc_,
 164             &image_handle,
 165             &byte_count));
 166     if (!resource) {
 167       SendGetFrameErrorReply(PP_ERROR_FAILED);
 168       return;
 169     }
 170
 171     ppapi::thunk::EnterResourceNoLock<ppapi::thunk::PPB_ImageData_API>
 172         enter_resource(resource, false);
 173     if (enter_resource.failed()) {
 174       SendGetFrameErrorReply(PP_ERROR_FAILED);
 175       return;
 176     }
 177
 178     shared_image_ = static_cast<PPB_ImageData_Impl*>(enter_resource.object());
 179     if (!shared_image_.get()) {
 180       SendGetFrameErrorReply(PP_ERROR_FAILED);
 181       return;
 182     }
 183
 184     DCHECK(!shared_image_->IsMapped());  // New memory should not be mapped.
 185     if (!shared_image_->Map() || !shared_image_->GetMappedBitmap() ||
 186         !shared_image_->GetMappedBitmap()->getPixels()) {
 187       shared_image_ = NULL;
 188       SendGetFrameErrorReply(PP_ERROR_FAILED);
 189       return;
 190     }
 191   }
 192
 193   const SkBitmap* bitmap = shared_image_->GetMappedBitmap();
 194   if (!bitmap) {
 195     SendGetFrameErrorReply(PP_ERROR_FAILED);
 196     return;
 197   }
 198
 199   uint8_t* bitmap_pixels = static_cast<uint8_t*>(bitmap->getPixels());
 200   if (!bitmap_pixels) {
 201     SendGetFrameErrorReply(PP_ERROR_FAILED);
 202     return;
 203   }
 204
 205   // Calculate the portion of the |last_frame_| that should be copied into
 206   // |bitmap|. If |last_frame_| is lazily scaled, then
 207   // last_frame_->visible_rect()._size() != last_frame_.natural_size().
 208   scoped_refptr<media::VideoFrame> frame;
 209   if (dst_size == last_frame_->visible_rect().size()) {
 210     // No scaling is needed, convert directly from last_frame_.
 211     frame = last_frame_;
 212     // Frame resolution doesn't change frequently, so don't keep any unnecessary
 213     // buffers around.
 214     scaled_frame_ = NULL;
 215   } else {
 216     // We need to create an intermediate scaled frame. Make sure we have
 217     // allocated one of correct size.
 218     if (!scaled_frame_.get() || scaled_frame_->coded_size() != dst_size) {
 219       scaled_frame_ = media::VideoFrame::CreateFrame(
 220           media::VideoFrame::I420, dst_size, gfx::Rect(dst_size), dst_size,
 221           last_frame_->timestamp());
 222       if (!scaled_frame_.get()) {
 223         LOG(ERROR) << "Failed to allocate a media::VideoFrame";
 224         SendGetFrameErrorReply(PP_ERROR_FAILED);
 225         return;
 226       }
 227     }
 228     scaled_frame_->set_timestamp(last_frame_->timestamp());
 229     libyuv::I420Scale(last_frame_->visible_data(media::VideoFrame::kYPlane),
 230                       last_frame_->stride(media::VideoFrame::kYPlane),
 231                       last_frame_->visible_data(media::VideoFrame::kUPlane),
 232                       last_frame_->stride(media::VideoFrame::kUPlane),
 233                       last_frame_->visible_data(media::VideoFrame::kVPlane),
 234                       last_frame_->stride(media::VideoFrame::kVPlane),
 235                       last_frame_->visible_rect().width(),
 236                       last_frame_->visible_rect().height(),
 237                       scaled_frame_->data(media::VideoFrame::kYPlane),
 238                       scaled_frame_->stride(media::VideoFrame::kYPlane),
 239                       scaled_frame_->data(media::VideoFrame::kUPlane),
 240                       scaled_frame_->stride(media::VideoFrame::kUPlane),
 241                       scaled_frame_->data(media::VideoFrame::kVPlane),
 242                       scaled_frame_->stride(media::VideoFrame::kVPlane),
 243                       dst_size.width(),
 244                       dst_size.height(),
 245                       libyuv::kFilterBilinear);
 246     frame = scaled_frame_;
 247   }
 248   last_frame_ = NULL;
 249
 250   libyuv::I420ToARGB(frame->visible_data(media::VideoFrame::kYPlane),
 251                      frame->stride(media::VideoFrame::kYPlane),
 252                      frame->visible_data(media::VideoFrame::kUPlane),
 253                      frame->stride(media::VideoFrame::kUPlane),
 254                      frame->visible_data(media::VideoFrame::kVPlane),
 255                      frame->stride(media::VideoFrame::kVPlane),
 256                      bitmap_pixels,
 257                      bitmap->rowBytes(),
 258                      dst_size.width(),
 259                      dst_size.height());
 260
 261   ppapi::HostResource host_resource;
 262   host_resource.SetHostResource(pp_instance(), shared_image_->GetReference());
 263
 264   // Convert a video timestamp to a PP_TimeTicks (a double, in seconds).
 265   const PP_TimeTicks timestamp = frame->timestamp().InSecondsF();
 266
 267   ppapi::proxy::SerializedHandle serialized_handle;
 268   serialized_handle.set_shmem(image_handle, byte_count);
 269   reply_context_.params.AppendHandle(serialized_handle);
 270
 271   host()->SendReply(reply_context_,
 272                     PpapiPluginMsg_VideoSource_GetFrameReply(
 273                         host_resource, shared_image_desc_, timestamp));
 274
 275   reply_context_ = ppapi::host::ReplyMessageContext();
 276 }
 277
 278 void PepperVideoSourceHost::SendGetFrameErrorReply(int32_t error) {
 279   reply_context_.params.set_result(error);
 280   host()->SendReply(
 281       reply_context_,
 282       PpapiPluginMsg_VideoSource_GetFrameReply(
 283           ppapi::HostResource(), PP_ImageDataDesc(), 0.0 /* timestamp */));
 284   reply_context_ = ppapi::host::ReplyMessageContext();
 285 }
 286
 287 void PepperVideoSourceHost::Close() {
 288   if (source_handler_.get() && !stream_url_.empty())
 289     source_handler_->Close(frame_receiver_.get());
 290
 291   source_handler_.reset(NULL);
 292   stream_url_.clear();
 293
 294   shared_image_ = NULL;
 295 }
 296
 297 }  // namespace content