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 "ppapi/shared_impl/ppb_audio_shared.h" 6 7 #include "base/logging.h" 8 #include "media/audio/shared_memory_util.h" 9 #include "ppapi/shared_impl/ppapi_globals.h" 10 #include "ppapi/shared_impl/proxy_lock.h" 11 12 // Hard coded values from PepperPlatformAudioOutputImpl. 13 // TODO(dalecurtis): PPAPI shouldn't hard code these values for all clients. 14 enum { kChannels = 2, kBytesPerSample = 2 }; 15 16 namespace ppapi { 17 18 #if defined(OS_NACL) 19 namespace { 20 // Because this is static, the function pointers will be NULL initially. 21 PP_ThreadFunctions thread_functions; 22 } 23 #endif // defined(OS_NACL) 24 25 PPB_Audio_Shared::PPB_Audio_Shared() 26 : playing_(false), 27 shared_memory_size_(0), 28 #if defined(OS_NACL) 29 thread_id_(0), 30 thread_active_(false), 31 #endif 32 callback_(NULL), 33 user_data_(NULL), 34 client_buffer_size_bytes_(0) { 35 } 36 37 PPB_Audio_Shared::~PPB_Audio_Shared() { 38 // Shut down the socket to escape any hanging |Receive|s. 39 if (socket_.get()) 40 socket_->Shutdown(); 41 StopThread(); 42 } 43 44 void PPB_Audio_Shared::SetCallback(PPB_Audio_Callback callback, 45 void* user_data) { 46 callback_ = callback; 47 user_data_ = user_data; 48 } 49 50 void PPB_Audio_Shared::SetStartPlaybackState() { 51 DCHECK(!playing_); 52 #if !defined(OS_NACL) 53 DCHECK(!audio_thread_.get()); 54 #else 55 DCHECK(!thread_active_); 56 #endif 57 // If the socket doesn't exist, that means that the plugin has started before 58 // the browser has had a chance to create all the shared memory info and 59 // notify us. This is a common case. In this case, we just set the playing_ 60 // flag and the playback will automatically start when that data is available 61 // in SetStreamInfo. 62 playing_ = true; 63 StartThread(); 64 } 65 66 void PPB_Audio_Shared::SetStopPlaybackState() { 67 DCHECK(playing_); 68 StopThread(); 69 playing_ = false; 70 } 71 72 void PPB_Audio_Shared::SetStreamInfo( 73 PP_Instance instance, 74 base::SharedMemoryHandle shared_memory_handle, 75 size_t shared_memory_size, 76 base::SyncSocket::Handle socket_handle, 77 int sample_frame_count) { 78 socket_.reset(new base::CancelableSyncSocket(socket_handle)); 79 shared_memory_.reset(new base::SharedMemory(shared_memory_handle, false)); 80 shared_memory_size_ = shared_memory_size; 81 82 if (!shared_memory_->Map( 83 media::TotalSharedMemorySizeInBytes(shared_memory_size_))) { 84 PpapiGlobals::Get()->LogWithSource( 85 instance, 86 PP_LOGLEVEL_WARNING, 87 std::string(), 88 "Failed to map shared memory for PPB_Audio_Shared."); 89 } else { 90 audio_bus_ = media::AudioBus::WrapMemory( 91 kChannels, sample_frame_count, shared_memory_->memory()); 92 // Setup integer audio buffer for user audio data. 93 client_buffer_size_bytes_ = 94 audio_bus_->frames() * audio_bus_->channels() * kBytesPerSample; 95 client_buffer_.reset(new uint8_t[client_buffer_size_bytes_]); 96 } 97 98 StartThread(); 99 } 100 101 void PPB_Audio_Shared::StartThread() { 102 // Don't start the thread unless all our state is set up correctly. 103 if (!playing_ || !callback_ || !socket_.get() || !shared_memory_->memory() || 104 !audio_bus_.get() || !client_buffer_.get()) 105 return; 106 // Clear contents of shm buffer before starting audio thread. This will 107 // prevent a burst of static if for some reason the audio thread doesn't 108 // start up quickly enough. 109 memset(shared_memory_->memory(), 0, shared_memory_size_); 110 memset(client_buffer_.get(), 0, client_buffer_size_bytes_); 111 #if !defined(OS_NACL) 112 DCHECK(!audio_thread_.get()); 113 audio_thread_.reset(new base::DelegateSimpleThread( 114 this, "plugin_audio_thread")); 115 audio_thread_->Start(); 116 #else 117 // Use NaCl's special API for IRT code that creates threads that call back 118 // into user code. 119 if (NULL == thread_functions.thread_create || 120 NULL == thread_functions.thread_join) 121 return; 122 123 int result = thread_functions.thread_create(&thread_id_, CallRun, this); 124 DCHECK_EQ(result, 0); 125 thread_active_ = true; 126 #endif 127 } 128 129 void PPB_Audio_Shared::StopThread() { 130 #if !defined(OS_NACL) 131 if (audio_thread_.get()) { 132 // In general, the audio thread should not do Pepper calls, but it might 133 // anyway (for example, our Audio test does CallOnMainThread). If it did 134 // a pepper call which acquires the lock (most of them do), and we try to 135 // shut down the thread and Join it while holding the lock, we would 136 // deadlock. So we give up the lock here so that the thread at least _can_ 137 // make Pepper calls without causing deadlock. 138 CallWhileUnlocked(base::Bind(&base::DelegateSimpleThread::Join, 139 base::Unretained(audio_thread_.get()))); 140 audio_thread_.reset(); 141 } 142 #else 143 if (thread_active_) { 144 // See comment above about why we unlock here. 145 int result = CallWhileUnlocked(thread_functions.thread_join, thread_id_); 146 DCHECK_EQ(0, result); 147 thread_active_ = false; 148 } 149 #endif 150 } 151 152 #if defined(OS_NACL) 153 // static 154 void PPB_Audio_Shared::SetThreadFunctions( 155 const struct PP_ThreadFunctions* functions) { 156 DCHECK(thread_functions.thread_create == NULL); 157 DCHECK(thread_functions.thread_join == NULL); 158 thread_functions = *functions; 159 } 160 161 // static 162 void PPB_Audio_Shared::CallRun(void* self) { 163 PPB_Audio_Shared* audio = static_cast<PPB_Audio_Shared*>(self); 164 audio->Run(); 165 } 166 #endif 167 168 void PPB_Audio_Shared::Run() { 169 int pending_data; 170 const int bytes_per_frame = 171 sizeof(*audio_bus_->channel(0)) * audio_bus_->channels(); 172 173 while (sizeof(pending_data) == 174 socket_->Receive(&pending_data, sizeof(pending_data)) && 175 pending_data != media::kPauseMark) { 176 callback_(client_buffer_.get(), client_buffer_size_bytes_, user_data_); 177 178 // Deinterleave the audio data into the shared memory as float. 179 audio_bus_->FromInterleaved( 180 client_buffer_.get(), audio_bus_->frames(), kBytesPerSample); 181 182 // Let the host know we are done. 183 // TODO(dalecurtis): Technically this is not the exact size. Due to channel 184 // padding for alignment, there may be more data available than this. We're 185 // relying on AudioSyncReader::Read() to parse this with that in mind. 186 // Rename these methods to Set/GetActualFrameCount(). 187 media::SetActualDataSizeInBytes( 188 shared_memory_.get(), shared_memory_size_, 189 audio_bus_->frames() * bytes_per_frame); 190 } 191 } 192 193 } // namespace ppapi 194