| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ppapi/proxy/media_stream_audio_track_resource.h" |
| |
| #include "ppapi/proxy/audio_buffer_resource.h" |
| #include "ppapi/proxy/ppapi_messages.h" |
| #include "ppapi/shared_impl/media_stream_audio_track_shared.h" |
| #include "ppapi/shared_impl/media_stream_buffer.h" |
| #include "ppapi/shared_impl/var.h" |
| |
| namespace ppapi { |
| namespace proxy { |
| |
| MediaStreamAudioTrackResource::MediaStreamAudioTrackResource( |
| Connection connection, |
| PP_Instance instance, |
| int pending_renderer_id, |
| const std::string& id) |
| : MediaStreamTrackResourceBase( |
| connection, instance, pending_renderer_id, id), |
| get_buffer_output_(NULL) { |
| } |
| |
| MediaStreamAudioTrackResource::~MediaStreamAudioTrackResource() { |
| Close(); |
| } |
| |
| thunk::PPB_MediaStreamAudioTrack_API* |
| MediaStreamAudioTrackResource::AsPPB_MediaStreamAudioTrack_API() { |
| return this; |
| } |
| |
| PP_Var MediaStreamAudioTrackResource::GetId() { |
| return StringVar::StringToPPVar(id()); |
| } |
| |
| PP_Bool MediaStreamAudioTrackResource::HasEnded() { |
| return PP_FromBool(has_ended()); |
| } |
| |
| int32_t MediaStreamAudioTrackResource::Configure( |
| const int32_t attrib_list[], |
| scoped_refptr<TrackedCallback> callback) { |
| if (has_ended()) |
| return PP_ERROR_FAILED; |
| |
| if (TrackedCallback::IsPending(configure_callback_) || |
| TrackedCallback::IsPending(get_buffer_callback_)) { |
| return PP_ERROR_INPROGRESS; |
| } |
| |
| // Do not support configure if audio buffers are held by plugin. |
| if (!buffers_.empty()) |
| return PP_ERROR_INPROGRESS; |
| |
| MediaStreamAudioTrackShared::Attributes attributes; |
| int i = 0; |
| for (; attrib_list[i] != PP_MEDIASTREAMAUDIOTRACK_ATTRIB_NONE; i += 2) { |
| switch (attrib_list[i]) { |
| case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_BUFFERS: |
| attributes.buffers = attrib_list[i + 1]; |
| break; |
| case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_DURATION: |
| attributes.duration = attrib_list[i + 1]; |
| break; |
| case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_SAMPLE_RATE: |
| case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_SAMPLE_SIZE: |
| case PP_MEDIASTREAMAUDIOTRACK_ATTRIB_CHANNELS: |
| return PP_ERROR_NOTSUPPORTED; |
| default: |
| return PP_ERROR_BADARGUMENT; |
| } |
| } |
| |
| if (!MediaStreamAudioTrackShared::VerifyAttributes(attributes)) |
| return PP_ERROR_BADARGUMENT; |
| |
| configure_callback_ = callback; |
| Call<PpapiPluginMsg_MediaStreamAudioTrack_ConfigureReply>( |
| RENDERER, |
| PpapiHostMsg_MediaStreamAudioTrack_Configure(attributes), |
| base::Bind(&MediaStreamAudioTrackResource::OnPluginMsgConfigureReply, |
| base::Unretained(this)), |
| callback); |
| return PP_OK_COMPLETIONPENDING; |
| } |
| |
| int32_t MediaStreamAudioTrackResource::GetAttrib( |
| PP_MediaStreamAudioTrack_Attrib attrib, |
| int32_t* value) { |
| // TODO(penghuang): Implement this function. |
| return PP_ERROR_NOTSUPPORTED; |
| } |
| |
| int32_t MediaStreamAudioTrackResource::GetBuffer( |
| PP_Resource* buffer, |
| scoped_refptr<TrackedCallback> callback) { |
| if (has_ended()) |
| return PP_ERROR_FAILED; |
| |
| if (TrackedCallback::IsPending(configure_callback_) || |
| TrackedCallback::IsPending(get_buffer_callback_)) |
| return PP_ERROR_INPROGRESS; |
| |
| *buffer = GetAudioBuffer(); |
| if (*buffer) |
| return PP_OK; |
| |
| // TODO(penghuang): Use the callback as hints to determine which thread will |
| // use the resource, so we could deliver buffers to the target thread directly |
| // for better performance. |
| get_buffer_output_ = buffer; |
| get_buffer_callback_ = callback; |
| return PP_OK_COMPLETIONPENDING; |
| } |
| |
| int32_t MediaStreamAudioTrackResource::RecycleBuffer(PP_Resource buffer) { |
| BufferMap::iterator it = buffers_.find(buffer); |
| if (it == buffers_.end()) |
| return PP_ERROR_BADRESOURCE; |
| |
| scoped_refptr<AudioBufferResource> buffer_resource = it->second; |
| buffers_.erase(it); |
| |
| if (has_ended()) |
| return PP_OK; |
| |
| DCHECK_GE(buffer_resource->GetBufferIndex(), 0); |
| |
| SendEnqueueBufferMessageToHost(buffer_resource->GetBufferIndex()); |
| buffer_resource->Invalidate(); |
| return PP_OK; |
| } |
| |
| void MediaStreamAudioTrackResource::Close() { |
| if (has_ended()) |
| return; |
| |
| if (TrackedCallback::IsPending(get_buffer_callback_)) { |
| *get_buffer_output_ = 0; |
| get_buffer_callback_->PostAbort(); |
| get_buffer_callback_ = NULL; |
| get_buffer_output_ = 0; |
| } |
| |
| ReleaseBuffers(); |
| MediaStreamTrackResourceBase::CloseInternal(); |
| } |
| |
| void MediaStreamAudioTrackResource::OnNewBufferEnqueued() { |
| if (!TrackedCallback::IsPending(get_buffer_callback_)) |
| return; |
| |
| *get_buffer_output_ = GetAudioBuffer(); |
| int32_t result = *get_buffer_output_ ? PP_OK : PP_ERROR_FAILED; |
| get_buffer_output_ = NULL; |
| scoped_refptr<TrackedCallback> callback; |
| callback.swap(get_buffer_callback_); |
| callback->Run(result); |
| } |
| |
| PP_Resource MediaStreamAudioTrackResource::GetAudioBuffer() { |
| int32_t index = buffer_manager()->DequeueBuffer(); |
| if (index < 0) |
| return 0; |
| |
| MediaStreamBuffer* buffer = buffer_manager()->GetBufferPointer(index); |
| DCHECK(buffer); |
| scoped_refptr<AudioBufferResource> resource = |
| new AudioBufferResource(pp_instance(), index, buffer); |
| // Add |pp_resource()| and |resource| into |buffers_|. |
| // |buffers_| uses std::unique_ptr<> to hold a ref of |resource|. It keeps the |
| // resource alive. |
| buffers_.insert(BufferMap::value_type(resource->pp_resource(), resource)); |
| return resource->GetReference(); |
| } |
| |
| void MediaStreamAudioTrackResource::ReleaseBuffers() { |
| for (BufferMap::iterator it = buffers_.begin(); it != buffers_.end(); ++it) { |
| // Just invalidate and release VideoBufferResorce, but keep PP_Resource. |
| // So plugin can still use |RecycleBuffer()|. |
| it->second->Invalidate(); |
| it->second = NULL; |
| } |
| } |
| |
| void MediaStreamAudioTrackResource::OnPluginMsgConfigureReply( |
| const ResourceMessageReplyParams& params) { |
| if (TrackedCallback::IsPending(configure_callback_)) { |
| scoped_refptr<TrackedCallback> callback; |
| callback.swap(configure_callback_); |
| callback->Run(params.result()); |
| } |
| } |
| |
| } // namespace proxy |
| } // namespace ppapi |