ppapi/proxy/media_stream_audio_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_audio_track_resource.h"
   6
   7 #include "ppapi/proxy/audio_buffer_resource.h"
   8 #include "ppapi/proxy/ppapi_messages.h"
   9 #include "ppapi/shared_impl/media_stream_audio_track_shared.h"
  10 #include "ppapi/shared_impl/media_stream_buffer.h"
  11 #include "ppapi/shared_impl/var.h"
  12
  13 namespace ppapi {
  14 namespace proxy {
  15
  16 MediaStreamAudioTrackResource::MediaStreamAudioTrackResource(
  17     Connection connection,
  18     PP_Instance instance,
  19     int pending_renderer_id,
  20     const std::string& id)
  21     : MediaStreamTrackResourceBase(
  22         connection, instance, pending_renderer_id, id),
  23       get_buffer_output_(NULL) {
  24 }
  25
  26 MediaStreamAudioTrackResource::~MediaStreamAudioTrackResource() {
  27   Close();
  28 }
  29
  30 thunk::PPB_MediaStreamAudioTrack_API*
  31 MediaStreamAudioTrackResource::AsPPB_MediaStreamAudioTrack_API() {
  32   return this;
  33 }
  34
  35 PP_Var MediaStreamAudioTrackResource::GetId() {
  36   return StringVar::StringToPPVar(id());
  37 }
  38
  39 PP_Bool MediaStreamAudioTrackResource::HasEnded() {
  40   return PP_FromBool(has_ended());
  41 }
  42
  43 int32_t MediaStreamAudioTrackResource::Configure(
  44     const int32_t attrib_list[],
  45     scoped_refptr<TrackedCallback> callback) {
  46   if (has_ended())
  47     return PP_ERROR_FAILED;
  48
  49   if (TrackedCallback::IsPending(configure_callback_) ||
  50       TrackedCallback::IsPending(get_buffer_callback_)) {
  51     return PP_ERROR_INPROGRESS;
  52   }
  53
  54   // Do not support configure if audio buffers are held by plugin.
  55   if (!buffers_.empty())
  56     return PP_ERROR_INPROGRESS;
  57
  58   MediaStreamAudioTrackShared::Attributes attributes;
  59   int i = 0;
  60   for (; attrib_list[i] != PP_MEDIASTREAMAUDIOTRACK_ATTRIB_NONE; i += 2) {
  61     switch (attrib_list[i]) {
  62       case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_BUFFERS:
  63         attributes.buffers = attrib_list[i + 1];
  64         break;
  65       case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_SAMPLE_RATE:
  66       case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_SAMPLE_SIZE:
  67       case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_CHANNELS:
  68       case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_DURATION:
  69         return PP_ERROR_NOTSUPPORTED;
  70       default:
  71         return PP_ERROR_BADARGUMENT;
  72     }
  73   }
  74
  75   if (!MediaStreamAudioTrackShared::VerifyAttributes(attributes))
  76     return PP_ERROR_BADARGUMENT;
  77
  78   configure_callback_ = callback;
  79   Call<PpapiPluginMsg_MediaStreamAudioTrack_ConfigureReply>(
  80       RENDERER,
  81       PpapiHostMsg_MediaStreamAudioTrack_Configure(attributes),
  82       base::Bind(&MediaStreamAudioTrackResource::OnPluginMsgConfigureReply,
  83                  base::Unretained(this)),
  84       callback);
  85   return PP_OK_COMPLETIONPENDING;
  86 }
  87
  88 int32_t MediaStreamAudioTrackResource::GetAttrib(
  89     PP_MediaStreamAudioTrack_Attrib attrib,
  90     int32_t* value) {
  91   // TODO(penghuang): Implement this function.
  92   return PP_ERROR_NOTSUPPORTED;
  93 }
  94
  95 int32_t MediaStreamAudioTrackResource::GetBuffer(
  96     PP_Resource* buffer,
  97     scoped_refptr<TrackedCallback> callback) {
  98   if (has_ended())
  99     return PP_ERROR_FAILED;
 100
 101   if (TrackedCallback::IsPending(configure_callback_) ||
 102       TrackedCallback::IsPending(get_buffer_callback_))
 103     return PP_ERROR_INPROGRESS;
 104
 105   *buffer = GetAudioBuffer();
 106   if (*buffer)
 107     return PP_OK;
 108
 109   // TODO(penghuang): Use the callback as hints to determine which thread will
 110   // use the resource, so we could deliver buffers to the target thread directly
 111   // for better performance.
 112   get_buffer_output_ = buffer;
 113   get_buffer_callback_ = callback;
 114   return PP_OK_COMPLETIONPENDING;
 115 }
 116
 117 int32_t MediaStreamAudioTrackResource::RecycleBuffer(PP_Resource buffer) {
 118   BufferMap::iterator it = buffers_.find(buffer);
 119   if (it == buffers_.end())
 120     return PP_ERROR_BADRESOURCE;
 121
 122   scoped_refptr<AudioBufferResource> buffer_resource = it->second;
 123   buffers_.erase(it);
 124
 125   if (has_ended())
 126     return PP_OK;
 127
 128   DCHECK_GE(buffer_resource->GetBufferIndex(), 0);
 129
 130   SendEnqueueBufferMessageToHost(buffer_resource->GetBufferIndex());
 131   buffer_resource->Invalidate();
 132   return PP_OK;
 133 }
 134
 135 void MediaStreamAudioTrackResource::Close() {
 136   if (has_ended())
 137     return;
 138
 139   if (TrackedCallback::IsPending(get_buffer_callback_)) {
 140     *get_buffer_output_ = 0;
 141     get_buffer_callback_->PostAbort();
 142     get_buffer_callback_ = NULL;
 143     get_buffer_output_ = 0;
 144   }
 145
 146   ReleaseBuffers();
 147   MediaStreamTrackResourceBase::CloseInternal();
 148 }
 149
 150 void MediaStreamAudioTrackResource::OnNewBufferEnqueued() {
 151   if (!TrackedCallback::IsPending(get_buffer_callback_))
 152     return;
 153
 154   *get_buffer_output_ = GetAudioBuffer();
 155   int32_t result = *get_buffer_output_ ? PP_OK : PP_ERROR_FAILED;
 156   get_buffer_output_ = NULL;
 157   scoped_refptr<TrackedCallback> callback;
 158   callback.swap(get_buffer_callback_);
 159   callback->Run(result);
 160 }
 161
 162 PP_Resource MediaStreamAudioTrackResource::GetAudioBuffer() {
 163   int32_t index = buffer_manager()->DequeueBuffer();
 164   if (index < 0)
 165       return 0;
 166
 167   MediaStreamBuffer* buffer = buffer_manager()->GetBufferPointer(index);
 168   DCHECK(buffer);
 169   scoped_refptr<AudioBufferResource> resource =
 170       new AudioBufferResource(pp_instance(), index, buffer);
 171   // Add |pp_resource()| and |resource| into |buffers_|.
 172   // |buffers_| uses scoped_ptr<> to hold a ref of |resource|. It keeps the
 173   // resource alive.
 174   buffers_.insert(BufferMap::value_type(resource->pp_resource(), resource));
 175   return resource->GetReference();
 176 }
 177
 178 void MediaStreamAudioTrackResource::ReleaseBuffers() {
 179   for (BufferMap::iterator it = buffers_.begin(); it != buffers_.end(); ++it) {
 180     // Just invalidate and release VideoBufferResorce, but keep PP_Resource.
 181     // So plugin can still use |RecycleBuffer()|.
 182     it->second->Invalidate();
 183     it->second = NULL;
 184   }
 185 }
 186
 187 void MediaStreamAudioTrackResource::OnPluginMsgConfigureReply(
 188     const ResourceMessageReplyParams& params) {
 189   if (TrackedCallback::IsPending(configure_callback_)) {
 190     scoped_refptr<TrackedCallback> callback;
 191     callback.swap(configure_callback_);
 192     callback->Run(params.result());
 193   }
 194 }
 195
 196 }  // namespace proxy
 197 }  // namespace ppapi