ppapi/proxy/media_stream_video_track_resource.cc

   1 // Copyright 2014 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 "ppapi/proxy/media_stream_video_track_resource.h"
   6
   7 #include "base/logging.h"
   8 #include "ppapi/proxy/video_frame_resource.h"
   9 #include "ppapi/shared_impl/media_stream_frame.h"
  10 #include "ppapi/shared_impl/var.h"
  11
  12 namespace ppapi {
  13 namespace proxy {
  14
  15 MediaStreamVideoTrackResource::MediaStreamVideoTrackResource(
  16     Connection connection,
  17     PP_Instance instance,
  18     int pending_renderer_id,
  19     const std::string& id)
  20     : MediaStreamTrackResourceBase(
  21         connection, instance, pending_renderer_id, id),
  22       get_frame_output_(NULL) {
  23 }
  24
  25 MediaStreamVideoTrackResource::~MediaStreamVideoTrackResource() {
  26   Close();
  27 }
  28
  29 thunk::PPB_MediaStreamVideoTrack_API*
  30 MediaStreamVideoTrackResource::AsPPB_MediaStreamVideoTrack_API() {
  31   return this;
  32 }
  33
  34 PP_Var MediaStreamVideoTrackResource::GetId() {
  35   return StringVar::StringToPPVar(id());
  36 }
  37
  38 PP_Bool MediaStreamVideoTrackResource::HasEnded() {
  39   return PP_FromBool(has_ended());
  40 }
  41
  42
  43 int32_t MediaStreamVideoTrackResource::Configure(
  44     const int32_t attrib_list[],
  45     scoped_refptr<TrackedCallback> callback) {
  46   // TODO(penghuang): redesign and implement Configure() to support format,
  47   // size, etc.
  48   return PP_ERROR_NOTSUPPORTED;
  49 }
  50
  51 int32_t MediaStreamVideoTrackResource::GetAttrib(
  52     PP_MediaStreamVideoTrack_Attrib attrib,
  53     int32_t* value) {
  54   // TODO(penghuang): implement this function.
  55   return PP_ERROR_NOTSUPPORTED;
  56 }
  57
  58 int32_t MediaStreamVideoTrackResource::GetFrame(
  59     PP_Resource* frame,
  60     scoped_refptr<TrackedCallback> callback) {
  61   if (has_ended())
  62     return PP_ERROR_FAILED;
  63
  64   if (TrackedCallback::IsPending(get_frame_callback_))
  65     return PP_ERROR_INPROGRESS;
  66
  67   *frame = GetVideoFrame();
  68   if (*frame)
  69     return PP_OK;
  70
  71   get_frame_output_ = frame;
  72   get_frame_callback_ = callback;
  73   return PP_OK_COMPLETIONPENDING;
  74 }
  75
  76 int32_t MediaStreamVideoTrackResource::RecycleFrame(PP_Resource frame) {
  77   FrameMap::iterator it = frames_.find(frame);
  78   if (it == frames_.end())
  79     return PP_ERROR_BADRESOURCE;
  80
  81   scoped_refptr<VideoFrameResource> frame_resource = it->second;
  82   frames_.erase(it);
  83
  84   if (has_ended())
  85     return PP_OK;
  86
  87   DCHECK_GE(frame_resource->GetFrameBufferIndex(), 0);
  88
  89   SendEnqueueFrameMessageToHost(frame_resource->GetFrameBufferIndex());
  90   frame_resource->Invalidate();
  91   return PP_OK;
  92 }
  93
  94 void MediaStreamVideoTrackResource::Close() {
  95   if (has_ended())
  96     return;
  97
  98   if (TrackedCallback::IsPending(get_frame_callback_)) {
  99     *get_frame_output_ = 0;
 100     get_frame_callback_->PostAbort();
 101     get_frame_callback_ = NULL;
 102     get_frame_output_ = 0;
 103   }
 104
 105   ReleaseFrames();
 106   MediaStreamTrackResourceBase::CloseInternal();
 107 }
 108
 109 void MediaStreamVideoTrackResource::OnNewFrameEnqueued() {
 110   if (TrackedCallback::IsPending(get_frame_callback_)) {
 111     *get_frame_output_ = GetVideoFrame();
 112     get_frame_output_ = NULL;
 113     scoped_refptr<TrackedCallback> callback;
 114     callback.swap(get_frame_callback_);
 115     callback->Run(PP_OK);
 116   }
 117 }
 118
 119 PP_Resource MediaStreamVideoTrackResource::GetVideoFrame() {
 120   int32_t index = frame_buffer()->DequeueFrame();
 121   if (index < 0)
 122     return 0;
 123   MediaStreamFrame* frame = frame_buffer()->GetFramePointer(index);
 124   scoped_refptr<VideoFrameResource> resource =
 125       new VideoFrameResource(pp_instance(), index, frame);
 126   // Add |pp_resource()| and |resource| into |frames_|.
 127   // |frames_| uses scoped_ptr<> to hold a ref of |resource|. It keeps the
 128   // resource alive.
 129   frames_.insert(FrameMap::value_type(resource->pp_resource(), resource));
 130   return resource->GetReference();
 131 }
 132
 133 void MediaStreamVideoTrackResource::ReleaseFrames() {
 134   FrameMap::iterator it = frames_.begin();
 135   while (it != frames_.end()) {
 136     // Just invalidate and release VideoFrameResorce, but keep PP_Resource.
 137     // So plugin can still use |RecycleFrame()|.
 138     it->second->Invalidate();
 139     it->second = NULL;
 140   }
 141 }
 142
 143 }  // namespace proxy
 144 }  // namespace ppapi