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/renderer/pepper/ppb_audio_impl.h"
6
7 #include "base/logging.h"
8 #include "content/renderer/pepper/common.h"
9 #include "content/renderer/pepper/pepper_platform_audio_output.h"
10 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
11 #include "content/renderer/render_view_impl.h"
12 #include "media/audio/audio_output_controller.h"
13 #include "ppapi/c/pp_completion_callback.h"
14 #include "ppapi/c/ppb_audio.h"
15 #include "ppapi/c/ppb_audio_config.h"
16 #include "ppapi/shared_impl/resource_tracker.h"
17 #include "ppapi/thunk/enter.h"
18 #include "ppapi/thunk/ppb_audio_config_api.h"
19 #include "ppapi/thunk/thunk.h"
20
21 using ppapi::PpapiGlobals;
22 using ppapi::thunk::EnterResourceNoLock;
23 using ppapi::thunk::PPB_Audio_API;
24 using ppapi::thunk::PPB_AudioConfig_API;
25 using ppapi::TrackedCallback;
26
27 namespace content {
28
29 // PPB_Audio_Impl --------------------------------------------------------------
30
PPB_Audio_Impl(PP_Instance instance)31 PPB_Audio_Impl::PPB_Audio_Impl(PP_Instance instance)
32 : Resource(ppapi::OBJECT_IS_IMPL, instance),
33 audio_(NULL) {
34 }
35
~PPB_Audio_Impl()36 PPB_Audio_Impl::~PPB_Audio_Impl() {
37 // Calling ShutDown() makes sure StreamCreated cannot be called anymore and
38 // releases the audio data associated with the pointer. Note however, that
39 // until ShutDown returns, StreamCreated may still be called. This will be
40 // OK since we'll just immediately clean up the data it stored later in this
41 // destructor.
42 if (audio_) {
43 audio_->ShutDown();
44 audio_ = NULL;
45 }
46 }
47
48 // static
Create(PP_Instance instance,PP_Resource config,const ppapi::AudioCallbackCombined & audio_callback,void * user_data)49 PP_Resource PPB_Audio_Impl::Create(
50 PP_Instance instance,
51 PP_Resource config,
52 const ppapi::AudioCallbackCombined& audio_callback,
53 void* user_data) {
54 scoped_refptr<PPB_Audio_Impl> audio(new PPB_Audio_Impl(instance));
55 if (!audio->Init(config, audio_callback, user_data))
56 return 0;
57 return audio->GetReference();
58 }
59
AsPPB_Audio_API()60 PPB_Audio_API* PPB_Audio_Impl::AsPPB_Audio_API() {
61 return this;
62 }
63
Init(PP_Resource config,const ppapi::AudioCallbackCombined & callback,void * user_data)64 bool PPB_Audio_Impl::Init(PP_Resource config,
65 const ppapi::AudioCallbackCombined& callback,
66 void* user_data) {
67 // Validate the config and keep a reference to it.
68 EnterResourceNoLock<PPB_AudioConfig_API> enter(config, true);
69 if (enter.failed())
70 return false;
71 config_ = config;
72
73 if (!callback.IsValid())
74 return false;
75 SetCallback(callback, user_data);
76
77 PepperPluginInstance* instance = PepperPluginInstance::Get(pp_instance());
78 if (!instance)
79 return false;
80
81 // When the stream is created, we'll get called back on StreamCreated().
82 CHECK(!audio_);
83 audio_ = PepperPlatformAudioOutput::Create(
84 static_cast<int>(enter.object()->GetSampleRate()),
85 static_cast<int>(enter.object()->GetSampleFrameCount()),
86 instance->GetRenderView()->GetRoutingID(),
87 this);
88 return audio_ != NULL;
89 }
90
GetCurrentConfig()91 PP_Resource PPB_Audio_Impl::GetCurrentConfig() {
92 // AddRef on behalf of caller, while keeping a ref for ourselves.
93 PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(config_);
94 return config_;
95 }
96
StartPlayback()97 PP_Bool PPB_Audio_Impl::StartPlayback() {
98 if (!audio_)
99 return PP_FALSE;
100 if (playing())
101 return PP_TRUE;
102 SetStartPlaybackState();
103 return BoolToPPBool(audio_->StartPlayback());
104 }
105
StopPlayback()106 PP_Bool PPB_Audio_Impl::StopPlayback() {
107 if (!audio_)
108 return PP_FALSE;
109 if (!playing())
110 return PP_TRUE;
111 if (!audio_->StopPlayback())
112 return PP_FALSE;
113 SetStopPlaybackState();
114 return PP_TRUE;
115 }
116
Open(PP_Resource config,scoped_refptr<TrackedCallback> create_callback)117 int32_t PPB_Audio_Impl::Open(
118 PP_Resource config,
119 scoped_refptr<TrackedCallback> create_callback) {
120 // Validate the config and keep a reference to it.
121 EnterResourceNoLock<PPB_AudioConfig_API> enter(config, true);
122 if (enter.failed())
123 return PP_ERROR_FAILED;
124 config_ = config;
125
126 PepperPluginInstance* instance = PepperPluginInstance::Get(pp_instance());
127 if (!instance)
128 return PP_ERROR_FAILED;
129
130 // When the stream is created, we'll get called back on StreamCreated().
131 DCHECK(!audio_);
132 audio_ = PepperPlatformAudioOutput::Create(
133 static_cast<int>(enter.object()->GetSampleRate()),
134 static_cast<int>(enter.object()->GetSampleFrameCount()),
135 instance->GetRenderView()->GetRoutingID(),
136 this);
137 if (!audio_)
138 return PP_ERROR_FAILED;
139
140 // At this point, we are guaranteeing ownership of the completion
141 // callback. Audio promises to fire the completion callback
142 // once and only once.
143 SetCreateCallback(create_callback);
144
145 return PP_OK_COMPLETIONPENDING;
146 }
147
GetSyncSocket(int * sync_socket)148 int32_t PPB_Audio_Impl::GetSyncSocket(int* sync_socket) {
149 return GetSyncSocketImpl(sync_socket);
150 }
151
GetSharedMemory(int * shm_handle,uint32_t * shm_size)152 int32_t PPB_Audio_Impl::GetSharedMemory(int* shm_handle,
153 uint32_t* shm_size) {
154 return GetSharedMemoryImpl(shm_handle, shm_size);
155 }
156
OnSetStreamInfo(base::SharedMemoryHandle shared_memory_handle,size_t shared_memory_size,base::SyncSocket::Handle socket_handle)157 void PPB_Audio_Impl::OnSetStreamInfo(
158 base::SharedMemoryHandle shared_memory_handle,
159 size_t shared_memory_size,
160 base::SyncSocket::Handle socket_handle) {
161 EnterResourceNoLock<PPB_AudioConfig_API> enter(config_, true);
162 SetStreamInfo(pp_instance(), shared_memory_handle, shared_memory_size,
163 socket_handle, enter.object()->GetSampleRate(),
164 enter.object()->GetSampleFrameCount());
165 }
166
167 } // namespace content
168