Tim Yao | 87d2f5a | 2020-12-26 17:03:58 -0800 | [diff] [blame] | 1 | #include <stdio.h> |
| 2 | #include <execinfo.h> |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 3 | #include <sys/types.h> |
| 4 | #include <unistd.h> |
| 5 | #include <sys/stat.h> |
| 6 | #include <fcntl.h> |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 7 | #include <grp.h> |
| 8 | #include <sys/un.h> |
| 9 | #include <sys/socket.h> |
| 10 | #include <sys/stat.h> |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 11 | |
| 12 | #include <boost/interprocess/managed_shared_memory.hpp> |
| 13 | #include <cstdlib> |
| 14 | #include <iomanip> |
| 15 | #include <mutex> |
Tim Yao | 031950f | 2020-12-16 11:36:20 -0800 | [diff] [blame] | 16 | #include <chrono> |
| 17 | #include <condition_variable> |
| 18 | #include <thread> |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 19 | #include <signal.h> |
| 20 | |
| 21 | #define LOG_TAG "audio_server" |
| 22 | #include <cutils/log.h> |
| 23 | |
| 24 | #include <grpc/grpc.h> |
| 25 | #include <grpcpp/server.h> |
| 26 | #include <grpcpp/server_builder.h> |
| 27 | #include <grpcpp/server_context.h> |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 28 | #include <grpcpp/server_posix.h> |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 29 | #include <grpcpp/security/server_credentials.h> |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 30 | #include <IpcBuffer/audio_server_shmem.h> |
| 31 | #include <IpcBuffer/IpcBuffer.h> |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 32 | #include "audio_if.h" |
| 33 | #include "audio_service.grpc.pb.h" |
cheng tong | 7d90788 | 2020-09-04 18:53:04 +0800 | [diff] [blame] | 34 | #include "audio_effect_if.h" |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 35 | |
| 36 | using grpc::Server; |
| 37 | using grpc::ServerBuilder; |
| 38 | using grpc::ServerContext; |
| 39 | using grpc::ServerReader; |
| 40 | using grpc::ServerReaderWriter; |
| 41 | using grpc::ServerWriter; |
| 42 | using grpc::Status; |
| 43 | using audio_service::StatusReturn; |
| 44 | using audio_service::Volume; |
| 45 | using audio_service::Mode; |
| 46 | using audio_service::Mute; |
| 47 | using audio_service::Kv_pairs; |
| 48 | using audio_service::Keys; |
| 49 | using audio_service::Handle; |
| 50 | using audio_service::OpenOutputStream; |
| 51 | using audio_service::Stream; |
| 52 | using audio_service::OpenInputStream; |
| 53 | using audio_service::CreateAudioPatch; |
| 54 | using audio_service::AudioPortConfig; |
| 55 | using audio_service::AudioGainConfig; |
| 56 | using audio_service::AudioPortConfigDeviceExt; |
| 57 | using audio_service::AudioPortConfigMixExt; |
| 58 | using audio_service::AudioPortConfigSessionExt; |
| 59 | using audio_service::StreamSetParameters; |
| 60 | using audio_service::StreamGetParameters; |
| 61 | using audio_service::StreamAudioEffect; |
| 62 | using audio_service::StreamOutSetVolume; |
| 63 | using audio_service::StreamReadWrite; |
| 64 | using audio_service::GetFrameTimestampReturn; |
| 65 | using audio_service::StreamGain; |
cheng tong | 7d90788 | 2020-09-04 18:53:04 +0800 | [diff] [blame] | 66 | using audio_service::EffectParameters; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 67 | using google::protobuf::Empty; |
| 68 | |
| 69 | using namespace boost::interprocess; |
| 70 | using namespace audio_service; |
| 71 | |
| 72 | //#define DEBUG__ |
| 73 | |
| 74 | #ifdef DEBUG__ |
| 75 | #define TRACE_ENTRY() ALOGI("%s enter\n", __func__) |
| 76 | #define TRACE_EXIT() ALOGI("%s exit\n", __func__) |
| 77 | #else |
| 78 | #define TRACE_ENTRY() |
| 79 | #define TRACE_EXIT() |
| 80 | #endif |
| 81 | |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 82 | typedef std::pair<IpcBuffer *, struct audio_stream_out *> streamout_map_t; |
| 83 | typedef std::pair<IpcBuffer *, struct audio_stream_in *> streamin_map_t; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 84 | |
| 85 | class AudioServiceImpl final : public AudioService::Service |
| 86 | { |
| 87 | public: |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 88 | explicit AudioServiceImpl() |
| 89 | : shm_(audio_server_shmem::getInstance(true)), |
Tim Yao | b414f48 | 2021-02-17 17:59:46 -0800 | [diff] [blame] | 90 | gc_runner_stop_(false), |
Tim Yao | 031950f | 2020-12-16 11:36:20 -0800 | [diff] [blame] | 91 | gc_runner_(std::thread([this] { |
| 92 | while (!gc_runner_stop_) { |
| 93 | streamout_gc_(); |
| 94 | streamin_gc_(); |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 95 | patch_gc_(); |
Tim Yao | 031950f | 2020-12-16 11:36:20 -0800 | [diff] [blame] | 96 | std::unique_lock<std::mutex> lock(gc_mutex_); |
| 97 | gc_cv_.wait_for(lock, std::chrono::milliseconds(500), [this]() { return gc_runner_stop_; }); |
| 98 | } |
| 99 | })) { |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 100 | if (audio_hw_load_interface(&dev_) == 0) { |
cheng tong | 7d90788 | 2020-09-04 18:53:04 +0800 | [diff] [blame] | 101 | if (dev_) { |
| 102 | effect_ = (audio_effect_t *)dev_->common.reserved[0]; |
| 103 | } |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 104 | //ALOGI(__func__, "[AudioServer] Get audio hal interface successfully.\n"); |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | ~AudioServiceImpl() { |
Tim Yao | 031950f | 2020-12-16 11:36:20 -0800 | [diff] [blame] | 109 | { |
| 110 | std::lock_guard<std::mutex> lock(gc_mutex_); |
| 111 | gc_runner_stop_ = true; |
| 112 | } |
| 113 | gc_cv_.notify_one(); |
| 114 | gc_runner_.join(); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 115 | if (dev_) { |
cheng tong | 7d90788 | 2020-09-04 18:53:04 +0800 | [diff] [blame] | 116 | if (effect_) { |
| 117 | effect_ = nullptr; |
| 118 | } |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 119 | audio_hw_unload_interface(dev_); |
| 120 | dev_ = nullptr; |
| 121 | } |
| 122 | } |
| 123 | |
| 124 | Status Device_common_close(ServerContext* context, const Empty* empty, StatusReturn* response) { |
| 125 | TRACE_ENTRY(); |
| 126 | if (!dev_) return Status::CANCELLED; |
| 127 | |
| 128 | response->set_ret(dev_->common.close(&dev_->common)); |
| 129 | return Status::OK; |
| 130 | } |
| 131 | |
| 132 | Status Device_init_check(ServerContext* context, const Empty* empty, StatusReturn* response) { |
| 133 | TRACE_ENTRY(); |
| 134 | if (!dev_) return Status::CANCELLED; |
| 135 | |
| 136 | response->set_ret(dev_->init_check(dev_)); |
| 137 | return Status::OK; |
| 138 | } |
| 139 | |
| 140 | Status Device_set_voice_volume(ServerContext* context, const Volume* request, StatusReturn* response) { |
| 141 | TRACE_ENTRY(); |
| 142 | if (!dev_) return Status::CANCELLED; |
| 143 | |
| 144 | response->set_ret(dev_->set_voice_volume(dev_, request->vol())); |
| 145 | return Status::OK; |
| 146 | } |
| 147 | |
| 148 | Status Device_set_master_volume(ServerContext* context, const Volume* request, StatusReturn* response) { |
| 149 | TRACE_ENTRY(); |
| 150 | if (!dev_) return Status::CANCELLED; |
| 151 | |
| 152 | response->set_ret(dev_->set_master_volume(dev_, request->vol())); |
| 153 | return Status::OK; |
| 154 | } |
| 155 | |
| 156 | Status Device_get_master_volume(ServerContext* context, const Empty* request, StatusReturn* response) { |
| 157 | TRACE_ENTRY(); |
| 158 | if (!dev_) return Status::CANCELLED; |
| 159 | |
| 160 | float vol = 0.0; |
| 161 | response->set_ret(dev_->get_master_volume(dev_, &vol)); |
| 162 | response->set_status_float(vol); |
| 163 | return Status::OK; |
| 164 | } |
| 165 | |
| 166 | Status Device_set_mode(ServerContext* context, const Mode* request, StatusReturn* response) { |
| 167 | TRACE_ENTRY(); |
| 168 | if (!dev_) return Status::CANCELLED; |
| 169 | |
| 170 | response->set_ret(dev_->set_mode(dev_, (audio_mode_t)(request->mode()))); |
| 171 | return Status::OK; |
| 172 | } |
| 173 | |
| 174 | Status Device_set_mic_mute(ServerContext* context, const Mute* request, StatusReturn* response) { |
| 175 | TRACE_ENTRY(); |
| 176 | if (!dev_) return Status::CANCELLED; |
| 177 | |
| 178 | response->set_ret(dev_->set_mic_mute(dev_, request->mute())); |
| 179 | return Status::OK; |
| 180 | } |
| 181 | |
| 182 | Status Device_get_mic_mute(ServerContext* context, const Empty* request, StatusReturn* response) { |
| 183 | TRACE_ENTRY(); |
| 184 | if (!dev_) return Status::CANCELLED; |
| 185 | |
| 186 | bool mute = false; |
| 187 | response->set_ret(dev_->get_mic_mute(dev_, &mute)); |
| 188 | response->set_status_bool(mute); |
| 189 | return Status::OK; |
| 190 | } |
| 191 | |
| 192 | Status Device_set_parameters(ServerContext* context, const Kv_pairs* request, StatusReturn* response) { |
| 193 | TRACE_ENTRY(); |
| 194 | if (!dev_) return Status::CANCELLED; |
| 195 | |
| 196 | response->set_ret(dev_->set_parameters(dev_, request->params().c_str())); |
| 197 | return Status::OK; |
| 198 | } |
| 199 | |
| 200 | Status Device_get_parameters(ServerContext* context, const Keys* request, StatusReturn* response) { |
| 201 | TRACE_ENTRY(); |
| 202 | if (!dev_) return Status::CANCELLED; |
| 203 | |
| 204 | char *param = dev_->get_parameters(dev_, request->keys().c_str()); |
| 205 | response->set_ret(param ? 0 : -1); |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 206 | if (param) { |
| 207 | response->set_status_string(std::string(param)); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 208 | |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 209 | // param is heap allocated and need free in behalf of client |
| 210 | free(param); |
| 211 | } |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 212 | |
| 213 | return Status::OK; |
| 214 | } |
| 215 | |
| 216 | Status Device_get_input_buffer_size(ServerContext* context, const AudioConfig* request, StatusReturn* response) { |
| 217 | TRACE_ENTRY(); |
| 218 | if (!dev_) return Status::CANCELLED; |
| 219 | |
| 220 | struct audio_config config; |
| 221 | config.sample_rate = request->sample_rate(); |
| 222 | config.channel_mask = request->channel_mask(); |
| 223 | config.format = (audio_format_t)(request->format()); |
| 224 | config.frame_count = request->frame_count(); |
| 225 | |
| 226 | response->set_ret(dev_->get_input_buffer_size(dev_, &config)); |
| 227 | return Status::OK; |
| 228 | } |
| 229 | |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 230 | Status Device_open_output_stream(ServerContext* context, const OpenOutputStream* request, DeviceOpenStreamReturn* response) { |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 231 | TRACE_ENTRY(); |
| 232 | if (!dev_) return Status::CANCELLED; |
| 233 | |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 234 | int vpid, seq; |
| 235 | if (sscanf(request->name().c_str(), "%d-%d", &vpid, &seq) != 2) { |
| 236 | response->set_client_id(-1); |
| 237 | return Status::CANCELLED; |
| 238 | } |
| 239 | int client_id = get_client_pid_(context); |
| 240 | if (client_id < 0) { |
| 241 | response->set_client_id(-1); |
| 242 | return Status::CANCELLED; |
| 243 | } |
| 244 | char buf[32]; |
| 245 | snprintf(buf, sizeof(buf), "%d-%d", client_id, seq); |
| 246 | std::string stream_id(buf); |
| 247 | |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 248 | struct audio_stream_out *stream = nullptr; |
| 249 | struct audio_config config; |
| 250 | config.sample_rate = request->config().sample_rate(); |
| 251 | config.channel_mask = request->config().channel_mask(); |
| 252 | config.format = (audio_format_t)(request->config().format()); |
| 253 | config.frame_count = request->config().frame_count(); |
| 254 | |
| 255 | streamout_gc_(); |
| 256 | |
| 257 | response->set_ret(dev_->open_output_stream(dev_, |
| 258 | (audio_io_handle_t)(request->handle()), |
| 259 | (audio_devices_t)(request->devices()), |
| 260 | (audio_output_flags_t)(request->flags()), |
| 261 | &config, |
| 262 | &stream, |
| 263 | request->address().c_str())); |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 264 | response->set_client_id(client_id); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 265 | |
| 266 | if (stream) { |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 267 | IpcBuffer * cb = shm_->find<IpcBuffer>(stream_id.c_str()).first; |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 268 | if (cb == nullptr) { |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 269 | cb = shm_->construct<IpcBuffer>(stream_id.c_str())(stream_id.c_str(), request->size()); |
| 270 | std::cout << "[AudioServer] open stream pid-seq " << stream_id.c_str() << std::endl; |
| 271 | ALOGI("%s pid-seq %s\n", __func__, stream_id.c_str()); |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 272 | } |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 273 | |
| 274 | std::lock_guard<std::mutex> lock(map_out_mutex_); |
| 275 | streamout_map_.insert( |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 276 | std::pair<const std::string, streamout_map_t>(stream_id, streamout_map_t(cb, stream))); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 277 | } |
| 278 | |
| 279 | return Status::OK; |
| 280 | } |
| 281 | |
| 282 | Status Device_close_output_stream(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 283 | TRACE_ENTRY(); |
| 284 | if (!dev_) return Status::CANCELLED; |
| 285 | |
| 286 | std::map<const std::string, streamout_map_t >::iterator it = streamout_map_.find(request->name()); |
| 287 | if (it == streamout_map_.end()) return Status::CANCELLED; |
| 288 | |
wei.du | 1e60c12 | 2021-11-04 11:01:16 +0800 | [diff] [blame] | 289 | std::cout << "[AudioServer] close stream pid-seq " << request->name().c_str() << std::endl; |
| 290 | ALOGI("%s pid-seq %s\n", __func__, request->name().c_str()); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 291 | dev_->close_output_stream(dev_, it->second.second); |
| 292 | |
| 293 | if (it->second.first) { |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 294 | shm_->destroy<IpcBuffer>(request->name().c_str()); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 295 | } |
| 296 | |
| 297 | std::lock_guard<std::mutex> lock(map_out_mutex_); |
| 298 | streamout_map_.erase(it); |
| 299 | |
| 300 | TRACE_EXIT(); |
| 301 | |
| 302 | return Status::OK; |
| 303 | } |
| 304 | |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 305 | Status Device_open_input_stream(ServerContext* context, const OpenInputStream* request, DeviceOpenStreamReturn* response) { |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 306 | TRACE_ENTRY(); |
| 307 | if (!dev_) return Status::CANCELLED; |
| 308 | |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 309 | int vpid, seq; |
| 310 | if (sscanf(request->name().c_str(), "%d-%d", &vpid, &seq) != 2) { |
| 311 | return Status::CANCELLED; |
| 312 | } |
| 313 | int client_id = get_client_pid_(context); |
| 314 | if (client_id < 0) { |
| 315 | return Status::CANCELLED; |
| 316 | } |
| 317 | char buf[32]; |
| 318 | snprintf(buf, sizeof(buf), "%d-%d", client_id, seq); |
| 319 | std::string stream_id(buf); |
| 320 | |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 321 | struct audio_stream_in *stream = nullptr; |
| 322 | struct audio_config config; |
| 323 | config.sample_rate = request->config().sample_rate(); |
| 324 | config.channel_mask = request->config().channel_mask(); |
| 325 | config.format = (audio_format_t)(request->config().format()); |
| 326 | config.frame_count = request->config().frame_count(); |
| 327 | |
| 328 | streamin_gc_(); |
| 329 | |
| 330 | response->set_ret(dev_->open_input_stream(dev_, |
| 331 | (audio_io_handle_t)(request->handle()), |
| 332 | (audio_devices_t)(request->devices()), |
| 333 | &config, |
| 334 | &stream, |
| 335 | (audio_input_flags_t)(request->flags()), |
| 336 | request->address().c_str(), |
| 337 | (audio_source_t)(request->source()))); |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 338 | response->set_client_id(client_id); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 339 | |
| 340 | if (stream) { |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 341 | IpcBuffer * cb = shm_->find<IpcBuffer>(stream_id.c_str()).first; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 342 | if (cb == nullptr) |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 343 | cb = shm_->construct<IpcBuffer>(stream_id.c_str())(request->name().c_str(), request->size()); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 344 | |
| 345 | std::lock_guard<std::mutex> lock(map_in_mutex_); |
| 346 | streamin_map_.insert( |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 347 | std::pair<const std::string, streamin_map_t>(stream_id, streamin_map_t(cb, stream))); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 348 | } |
| 349 | |
| 350 | return Status::OK; |
| 351 | } |
| 352 | |
| 353 | Status Device_close_input_stream(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 354 | TRACE_ENTRY(); |
| 355 | if (!dev_) return Status::CANCELLED; |
| 356 | |
| 357 | std::map<const std::string, streamin_map_t >::iterator it = streamin_map_.find(request->name()); |
| 358 | if (it == streamin_map_.end()) return Status::CANCELLED; |
| 359 | |
| 360 | dev_->close_input_stream(dev_, it->second.second); |
| 361 | |
| 362 | if (it->second.first) { |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 363 | shm_->destroy<IpcBuffer>(request->name().c_str()); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 364 | } |
| 365 | |
| 366 | std::lock_guard<std::mutex> lock(map_in_mutex_); |
| 367 | streamin_map_.erase(it); |
| 368 | |
| 369 | return Status::OK; |
| 370 | } |
| 371 | |
| 372 | Status Device_dump(ServerContext* context, const Empty* request, StatusReturn* response) { |
| 373 | TRACE_ENTRY(); |
| 374 | if (!dev_) return Status::CANCELLED; |
| 375 | |
Tim Yao | ab2a3a6 | 2020-10-29 15:33:55 -0700 | [diff] [blame] | 376 | char *param = dev_->dump(dev_, 0); |
| 377 | response->set_ret(param ? 0 : -1); |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 378 | if (param) { |
| 379 | response->set_status_string(std::string(param)); |
Tim Yao | ab2a3a6 | 2020-10-29 15:33:55 -0700 | [diff] [blame] | 380 | |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 381 | // param is heap allocated and need free |
| 382 | free(param); |
| 383 | } |
Tim Yao | ab2a3a6 | 2020-10-29 15:33:55 -0700 | [diff] [blame] | 384 | |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 385 | return Status::OK; |
| 386 | } |
| 387 | |
| 388 | Status Device_set_master_mute(ServerContext* context, const Mute* request, StatusReturn* response) { |
| 389 | TRACE_ENTRY(); |
| 390 | if (!dev_) return Status::CANCELLED; |
| 391 | |
| 392 | response->set_ret(dev_->set_master_mute(dev_, request->mute())); |
| 393 | return Status::OK; |
| 394 | } |
| 395 | |
| 396 | Status Device_get_master_mute(ServerContext* context, const Empty* request, StatusReturn* response) { |
| 397 | TRACE_ENTRY(); |
| 398 | if (!dev_) return Status::CANCELLED; |
| 399 | |
| 400 | bool mute = false; |
| 401 | response->set_ret(dev_->get_master_mute(dev_, &mute)); |
| 402 | response->set_status_bool(mute); |
| 403 | return Status::OK; |
| 404 | } |
| 405 | |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 406 | Status Device_create_audio_patch(ServerContext* context, const CreateAudioPatch* request, DeviceCreatePatchReturn* response) { |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 407 | TRACE_ENTRY(); |
| 408 | if (!dev_) return Status::CANCELLED; |
| 409 | |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 410 | int vpid, seq; |
| 411 | if (sscanf(request->name().c_str(), "%d-%d", &vpid, &seq) != 2) { |
| 412 | response->set_client_id(-1); |
| 413 | return Status::CANCELLED; |
| 414 | } |
| 415 | int client_id = get_client_pid_(context); |
| 416 | if (client_id < 0) { |
| 417 | response->set_client_id(-1); |
| 418 | return Status::CANCELLED; |
| 419 | } |
| 420 | char buf[32]; |
| 421 | snprintf(buf, sizeof(buf), "%d-%d", client_id, seq); |
| 422 | std::string patch_id(buf); |
| 423 | |
| 424 | ALOGI("%s [AudioServer] create patch pid-seq %s, vpid:%d, seq:%d, client_id:%d \n", __func__, request->name().c_str(), vpid, seq, client_id); |
| 425 | |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 426 | struct audio_port_config *sources, *sinks; |
| 427 | unsigned int num_sources = request->sources_size(); |
| 428 | unsigned int num_sinks = request->sinks_size(); |
| 429 | |
| 430 | struct audio_port_config *configs = new struct audio_port_config[num_sources + num_sinks]; |
| 431 | |
| 432 | streamout_gc_(); |
| 433 | streamin_gc_(); |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 434 | patch_gc_(); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 435 | |
| 436 | for (int i = 0; i < num_sources + num_sinks; i++) { |
| 437 | const AudioPortConfig &config = (i < num_sources) ? |
| 438 | request->sources(i) : request->sinks(i - num_sources); |
| 439 | configs[i].id = config.id(); |
| 440 | configs[i].role = (audio_port_role_t)config.role(); |
| 441 | configs[i].type = (audio_port_type_t)config.type(); |
| 442 | configs[i].config_mask = config.config_mask(); |
| 443 | configs[i].sample_rate = config.sample_rate(); |
| 444 | configs[i].channel_mask = config.channel_mask(); |
| 445 | configs[i].format = (audio_format_t)config.format(); |
| 446 | |
| 447 | // gain |
| 448 | configs[i].gain.index = config.gain().index(); |
| 449 | configs[i].gain.mode = (audio_gain_mode_t)config.gain().mode(); |
| 450 | configs[i].gain.channel_mask = (audio_channel_mask_t)config.gain().channel_mask(); |
| 451 | for (int j = 0; j < config.gain().values_size(); j++) |
| 452 | configs[i].gain.values[j] = config.gain().values(j); |
| 453 | configs[i].gain.ramp_duration_ms = config.gain().ramp_duration_ms(); |
| 454 | |
| 455 | if (configs[i].type == AUDIO_PORT_TYPE_DEVICE) { |
| 456 | // AudioPortConfigDeviceExt |
| 457 | configs[i].ext.device.hw_module = (audio_module_handle_t)config.device().hw_module(); |
| 458 | configs[i].ext.device.type = (audio_devices_t)config.device().type(); |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 459 | strncpy(configs[i].ext.device.address, config.device().address().c_str(), AUDIO_DEVICE_MAX_ADDRESS_LEN - 1); |
| 460 | configs[i].ext.device.address[AUDIO_DEVICE_MAX_ADDRESS_LEN - 1] = '\0'; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 461 | } else if (configs[i].type == AUDIO_PORT_TYPE_MIX) { |
| 462 | // AudioPortConfigMixExt |
| 463 | configs[i].ext.mix.hw_module = (audio_module_handle_t)config.mix().hw_module(); |
| 464 | configs[i].ext.mix.handle = (audio_io_handle_t)config.mix().handle(); |
| 465 | configs[i].ext.mix.usecase.stream = (audio_stream_type_t)config.mix().stream_source(); |
| 466 | } else if (configs[i].type == AUDIO_PORT_TYPE_SESSION) { |
| 467 | // AudioPortConfigSessionExt |
| 468 | configs[i].ext.session.session = (audio_session_t)config.session().session(); |
| 469 | } |
| 470 | } |
| 471 | |
| 472 | audio_patch_handle_t handle = (audio_patch_handle_t)(-1); |
| 473 | response->set_ret(dev_->create_audio_patch(dev_, num_sources, |
| 474 | configs, num_sinks, &configs[num_sources], &handle)); |
| 475 | response->set_status_32((uint32_t)handle); |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 476 | response->set_client_id(client_id); |
| 477 | |
| 478 | if (-1 != handle) { |
| 479 | std::lock_guard<std::mutex> lock(map_patch_mutex_); |
| 480 | patch_map_.insert( |
| 481 | std::pair<const std::string, audio_patch_handle_t>(patch_id, handle)); |
| 482 | } |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 483 | |
| 484 | delete [] configs; |
| 485 | |
| 486 | return Status::OK; |
| 487 | } |
| 488 | |
| 489 | Status Device_release_audio_patch(ServerContext* context, const Handle* request, StatusReturn* response) { |
| 490 | TRACE_ENTRY(); |
| 491 | if (!dev_) return Status::CANCELLED; |
| 492 | |
| 493 | audio_patch_handle_t handle = (audio_patch_handle_t)(request->handle()); |
| 494 | response->set_ret(dev_->release_audio_patch(dev_, handle)); |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 495 | int client_id = get_client_pid_(context); |
| 496 | std::lock_guard<std::mutex> lock(map_patch_mutex_); |
| 497 | for (std::map<const std::string, audio_patch_handle_t >::iterator it = patch_map_.begin(); it != patch_map_.end(); it++) { |
| 498 | int pid, seq; |
| 499 | if (sscanf(it->first.c_str(), "%d-%d", &pid, &seq) == 2) { |
| 500 | if ((pid == client_id) && (handle == it->second)) { |
| 501 | patch_map_.erase(it); |
| 502 | break; |
| 503 | } |
| 504 | } |
| 505 | } |
| 506 | |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 507 | return Status::OK; |
| 508 | } |
| 509 | |
| 510 | Status Device_set_audio_port_config(ServerContext* context, const AudioPortConfig* request, StatusReturn* response) { |
| 511 | TRACE_ENTRY(); |
| 512 | if (!dev_) return Status::CANCELLED; |
| 513 | |
| 514 | struct audio_port_config config; |
| 515 | |
| 516 | config.id = request->id(); |
| 517 | config.role = (audio_port_role_t)request->role(); |
| 518 | config.type = (audio_port_type_t)request->type(); |
| 519 | config.config_mask = request->config_mask(); |
| 520 | config.sample_rate = request->sample_rate(); |
| 521 | config.channel_mask = request->channel_mask(); |
| 522 | config.format = (audio_format_t)request->format(); |
| 523 | |
| 524 | // gain |
| 525 | config.gain.index = request->gain().index(); |
| 526 | config.gain.mode = (audio_gain_mode_t)request->gain().mode(); |
| 527 | config.gain.channel_mask = (audio_channel_mask_t)request->gain().channel_mask(); |
| 528 | for (int j = 0; j < request->gain().values_size(); j++) |
| 529 | config.gain.values[j] = request->gain().values(j); |
| 530 | config.gain.ramp_duration_ms = request->gain().ramp_duration_ms(); |
| 531 | |
| 532 | if (config.type == AUDIO_PORT_TYPE_DEVICE) { |
| 533 | // AudioPortConfigDeviceExt |
| 534 | config.ext.device.hw_module = (audio_module_handle_t)request->device().hw_module(); |
| 535 | config.ext.device.type = (audio_devices_t)request->device().type(); |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 536 | strncpy(config.ext.device.address, request->device().address().c_str(), AUDIO_DEVICE_MAX_ADDRESS_LEN - 1); |
| 537 | config.ext.device.address[AUDIO_DEVICE_MAX_ADDRESS_LEN - 1] = '\0'; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 538 | } else if (config.type == AUDIO_PORT_TYPE_MIX) { |
| 539 | // AudioPortConfigMixExt |
| 540 | config.ext.mix.hw_module = (audio_module_handle_t)request->mix().hw_module(); |
| 541 | config.ext.mix.handle = (audio_io_handle_t)request->mix().handle(); |
| 542 | config.ext.mix.usecase.stream = (audio_stream_type_t)request->mix().stream_source(); |
| 543 | } else if (config.type == AUDIO_PORT_TYPE_SESSION) { |
| 544 | // AudioPortConfigSessionExt |
| 545 | config.ext.session.session = (audio_session_t)request->session().session(); |
| 546 | } |
| 547 | |
| 548 | response->set_ret(dev_->set_audio_port_config(dev_, &config)); |
| 549 | return Status::OK; |
| 550 | } |
| 551 | |
| 552 | Status Stream_get_sample_rate(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 553 | TRACE_ENTRY(); |
| 554 | if (!dev_) return Status::CANCELLED; |
| 555 | |
| 556 | struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_); |
| 557 | if (stream == nullptr) return Status::CANCELLED; |
| 558 | |
| 559 | response->set_ret(stream->get_sample_rate(stream)); |
| 560 | return Status::OK; |
| 561 | } |
| 562 | |
| 563 | Status Stream_get_buffer_size(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 564 | TRACE_ENTRY(); |
| 565 | if (!dev_) return Status::CANCELLED; |
| 566 | |
| 567 | struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_); |
| 568 | if (stream == nullptr) return Status::CANCELLED; |
| 569 | |
| 570 | response->set_ret(stream->get_buffer_size(stream)); |
| 571 | return Status::OK; |
| 572 | } |
| 573 | |
| 574 | Status Stream_get_channels(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 575 | TRACE_ENTRY(); |
| 576 | if (!dev_) return Status::CANCELLED; |
| 577 | |
| 578 | struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_); |
| 579 | if (stream == nullptr) return Status::CANCELLED; |
| 580 | |
| 581 | response->set_ret((uint32_t)stream->get_channels(stream)); |
| 582 | return Status::OK; |
| 583 | } |
| 584 | |
| 585 | Status Stream_get_format(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 586 | TRACE_ENTRY(); |
| 587 | if (!dev_) return Status::CANCELLED; |
| 588 | |
| 589 | struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_); |
| 590 | if (stream == nullptr) return Status::CANCELLED; |
| 591 | |
| 592 | response->set_ret((uint32_t)stream->get_format(stream)); |
| 593 | return Status::OK; |
| 594 | } |
| 595 | |
| 596 | Status Stream_standby(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 597 | TRACE_ENTRY(); |
| 598 | if (!dev_) return Status::CANCELLED; |
| 599 | |
| 600 | struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_); |
| 601 | if (stream == nullptr) return Status::CANCELLED; |
| 602 | |
| 603 | response->set_ret((uint32_t)stream->standby(stream)); |
| 604 | return Status::OK; |
| 605 | } |
| 606 | |
| 607 | Status Stream_get_device(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 608 | TRACE_ENTRY(); |
| 609 | if (!dev_) return Status::CANCELLED; |
| 610 | |
| 611 | struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_); |
| 612 | if (stream == nullptr) return Status::CANCELLED; |
| 613 | |
| 614 | response->set_ret((uint32_t)stream->get_device(stream)); |
| 615 | return Status::OK; |
| 616 | } |
| 617 | |
| 618 | Status Stream_set_parameters(ServerContext* context, const StreamSetParameters* request, StatusReturn* response) { |
| 619 | TRACE_ENTRY(); |
| 620 | if (!dev_) return Status::CANCELLED; |
| 621 | |
| 622 | struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_); |
| 623 | if (stream == nullptr) return Status::CANCELLED; |
| 624 | |
| 625 | const char *kv_pairs = request->kv_pairs().c_str(); |
| 626 | response->set_ret(stream->set_parameters(stream, kv_pairs)); |
| 627 | return Status::OK; |
| 628 | } |
| 629 | |
| 630 | Status Stream_get_parameters(ServerContext* context, const StreamGetParameters* request, StatusReturn* response) { |
| 631 | TRACE_ENTRY(); |
| 632 | if (!dev_) return Status::CANCELLED; |
| 633 | |
| 634 | struct audio_stream *stream = find_stream(request->name(), streamout_map_, streamin_map_); |
| 635 | if (stream == nullptr) return Status::CANCELLED; |
| 636 | |
| 637 | char *param = stream->get_parameters(stream, request->keys().c_str()); |
| 638 | response->set_ret(param ? 0 : -1); |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 639 | if (param) { |
| 640 | response->set_status_string(std::string(param)); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 641 | |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 642 | // param is heap allocated and need free in behalf of client |
| 643 | free(param); |
| 644 | } |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 645 | |
| 646 | return Status::OK; |
| 647 | } |
| 648 | |
| 649 | Status StreamOut_get_latency(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 650 | TRACE_ENTRY(); |
| 651 | if (!dev_) return Status::CANCELLED; |
| 652 | |
| 653 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 654 | if (stream == nullptr) return Status::CANCELLED; |
| 655 | |
| 656 | response->set_ret(stream->get_latency(stream)); |
| 657 | return Status::OK; |
| 658 | } |
| 659 | |
| 660 | Status StreamOut_set_volume(ServerContext* context, const StreamOutSetVolume* request, StatusReturn* response) { |
| 661 | TRACE_ENTRY(); |
| 662 | if (!dev_) return Status::CANCELLED; |
| 663 | |
| 664 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 665 | if (stream == nullptr) return Status::CANCELLED; |
| 666 | |
| 667 | response->set_ret(stream->set_volume(stream, request->left(), request->right())); |
| 668 | return Status::OK; |
| 669 | } |
| 670 | |
| 671 | Status StreamOut_write(ServerContext* context, const StreamReadWrite* request, StatusReturn* response) { |
| 672 | TRACE_ENTRY(); |
| 673 | if (!dev_) return Status::CANCELLED; |
| 674 | |
| 675 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 676 | if (stream == nullptr) return Status::CANCELLED; |
| 677 | |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 678 | IpcBuffer *cb = shm_->find<IpcBuffer>(request->name().c_str()).first; |
| 679 | response->set_ret(stream->write(stream, cb->start_ptr(), request->size())); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 680 | return Status::OK; |
| 681 | } |
| 682 | |
| 683 | Status StreamOut_get_render_position(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 684 | TRACE_ENTRY(); |
| 685 | if (!dev_) return Status::CANCELLED; |
| 686 | |
| 687 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 688 | if (stream == nullptr) return Status::CANCELLED; |
| 689 | |
| 690 | uint32_t dsp_frames = 0; |
| 691 | response->set_ret(stream->get_render_position(stream, &dsp_frames)); |
| 692 | response->set_status_32(dsp_frames); |
| 693 | return Status::OK; |
| 694 | } |
| 695 | |
| 696 | Status StreamOut_get_next_write_timestamp(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 697 | TRACE_ENTRY(); |
| 698 | if (!dev_) return Status::CANCELLED; |
| 699 | |
| 700 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 701 | if (stream == nullptr) return Status::CANCELLED; |
| 702 | |
| 703 | int64_t timestamp = 0; |
| 704 | response->set_ret(stream->get_next_write_timestamp(stream, ×tamp)); |
| 705 | response->set_status_64(timestamp); |
| 706 | return Status::OK; |
| 707 | } |
| 708 | |
| 709 | Status StreamOut_pause(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 710 | TRACE_ENTRY(); |
| 711 | if (!dev_) return Status::CANCELLED; |
| 712 | |
| 713 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 714 | if (stream == nullptr) return Status::CANCELLED; |
| 715 | |
| 716 | response->set_ret(stream->pause(stream)); |
| 717 | return Status::OK; |
| 718 | } |
| 719 | |
| 720 | Status StreamOut_resume(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 721 | TRACE_ENTRY(); |
| 722 | if (!dev_) return Status::CANCELLED; |
| 723 | |
| 724 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 725 | if (stream == nullptr) return Status::CANCELLED; |
| 726 | |
| 727 | response->set_ret(stream->resume(stream)); |
| 728 | return Status::OK; |
| 729 | } |
| 730 | |
| 731 | Status StreamOut_flush(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 732 | TRACE_ENTRY(); |
| 733 | if (!dev_) return Status::CANCELLED; |
| 734 | |
| 735 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 736 | if (stream == nullptr) return Status::CANCELLED; |
| 737 | |
| 738 | response->set_ret(stream->flush(stream)); |
| 739 | return Status::OK; |
| 740 | } |
| 741 | |
| 742 | Status StreamOut_get_presentation_position(ServerContext* context, const Stream* request, GetFrameTimestampReturn* response) { |
| 743 | TRACE_ENTRY(); |
| 744 | if (!dev_) return Status::CANCELLED; |
| 745 | |
| 746 | struct audio_stream_out *stream = find_streamout(request->name(), streamout_map_); |
| 747 | if (stream == nullptr) return Status::CANCELLED; |
| 748 | |
| 749 | uint64_t frames = 0; |
| 750 | struct timespec timestamp; |
| 751 | response->set_ret(stream->get_presentation_position(stream, &frames, ×tamp)); |
| 752 | response->set_frames(frames); |
| 753 | response->mutable_timestamp()->set_seconds((int64_t)timestamp.tv_sec); |
| 754 | response->mutable_timestamp()->set_nanos(timestamp.tv_nsec); |
| 755 | return Status::OK; |
| 756 | } |
| 757 | |
| 758 | Status StreamIn_set_gain(ServerContext* context, const StreamGain* request, StatusReturn* response) { |
| 759 | TRACE_ENTRY(); |
| 760 | if (!dev_) return Status::CANCELLED; |
| 761 | |
| 762 | struct audio_stream_in *stream = find_streamin(request->name(), streamin_map_); |
| 763 | if (stream == nullptr) return Status::CANCELLED; |
| 764 | |
| 765 | response->set_ret(stream->set_gain(stream, request->gain())); |
| 766 | return Status::OK; |
| 767 | } |
| 768 | |
| 769 | Status StreamIn_read(ServerContext* context, const StreamReadWrite* request, StatusReturn* response) { |
| 770 | TRACE_ENTRY(); |
| 771 | if (!dev_) return Status::CANCELLED; |
| 772 | |
| 773 | struct audio_stream_in *stream = find_streamin(request->name(), streamin_map_); |
| 774 | if (stream == nullptr) return Status::CANCELLED; |
| 775 | |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 776 | IpcBuffer *cb = shm_->find<IpcBuffer>(request->name().c_str()).first; |
Blance Tang | 4c7ceb9 | 2021-03-05 17:12:40 +0800 | [diff] [blame] | 777 | response->set_ret(stream->read(stream, cb->start_ptr(), std::min((size_t) request->size(), cb->capacity()))); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 778 | return Status::OK; |
| 779 | } |
| 780 | |
| 781 | Status StreamIn_get_input_frames_lost(ServerContext* context, const Stream* request, StatusReturn* response) { |
| 782 | TRACE_ENTRY(); |
| 783 | if (!dev_) return Status::CANCELLED; |
| 784 | |
| 785 | struct audio_stream_in *stream = find_streamin(request->name(), streamin_map_); |
| 786 | if (stream == nullptr) return Status::CANCELLED; |
| 787 | |
| 788 | response->set_ret(stream->get_input_frames_lost(stream)); |
| 789 | return Status::OK; |
| 790 | } |
| 791 | |
| 792 | Status StreamIn_get_capture_position(ServerContext* context, const Stream* request, GetCapturePositionReturn* response) { |
| 793 | TRACE_ENTRY(); |
| 794 | if (!dev_) return Status::CANCELLED; |
| 795 | |
| 796 | struct audio_stream_in *stream = find_streamin(request->name(), streamin_map_); |
| 797 | if (stream == nullptr) return Status::CANCELLED; |
| 798 | |
| 799 | int64_t frames = 0; |
| 800 | int64_t time = 0; |
| 801 | response->set_ret(stream->get_capture_position(stream, &frames, &time)); |
| 802 | response->set_frames(frames); |
| 803 | response->set_time(time); |
| 804 | |
| 805 | return Status::OK; |
| 806 | } |
| 807 | |
| 808 | Status Service_ping(ServerContext* context, const Empty* empty, StatusReturn* response) { |
| 809 | TRACE_ENTRY(); |
| 810 | response->set_status_32(0); |
| 811 | return Status::OK; |
| 812 | } |
| 813 | |
cheng tong | 7d90788 | 2020-09-04 18:53:04 +0800 | [diff] [blame] | 814 | Status Effect_set_parameters(ServerContext* context, const EffectParameters* request, StatusReturn* response) { |
| 815 | TRACE_ENTRY(); |
| 816 | if (!dev_ || !effect_) return Status::CANCELLED; |
| 817 | |
| 818 | aml_audio_effect_type_e type = (aml_audio_effect_type_e)request->type(); |
| 819 | uint32_t cmdSize = request->cmd_size(); |
| 820 | void *pCmdData = (void *)request->cmd_data().data(); |
| 821 | uint32_t replySize = request->reply_size(); |
| 822 | uint32_t pReplyData = 0; |
| 823 | |
| 824 | response->set_ret(effect_->set_parameters(type, cmdSize, pCmdData, &replySize, &pReplyData)); |
| 825 | response->set_status_32(pReplyData); |
| 826 | return Status::OK; |
| 827 | } |
| 828 | |
| 829 | Status Effect_get_parameters(ServerContext* context, const EffectParameters* request, StatusReturn* response) { |
| 830 | TRACE_ENTRY(); |
| 831 | if (!dev_ || !effect_) return Status::CANCELLED; |
| 832 | |
| 833 | aml_audio_effect_type_e type = (aml_audio_effect_type_e)request->type(); |
| 834 | uint32_t cmdSize = request->cmd_size(); |
| 835 | void *pCmdData = (void *)request->cmd_data().data(); |
| 836 | uint32_t replySize = request->reply_size(); |
| 837 | void * pReplyData = malloc(replySize); |
| 838 | |
| 839 | response->set_ret(effect_->get_parameters(type, cmdSize, pCmdData, &replySize, pReplyData)); |
| 840 | response->set_status_bytes(pReplyData, replySize); |
| 841 | free(pReplyData); |
| 842 | pReplyData = nullptr; |
| 843 | return Status::OK; |
| 844 | } |
| 845 | |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 846 | private: |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 847 | static int get_client_pid_(grpc::ServerContext* context) |
| 848 | { |
| 849 | ALOGI("peer %s", context->peer().c_str()); |
| 850 | |
| 851 | // get the client socket fd |
| 852 | int socketFd = -1; |
| 853 | if ((sscanf(context->peer().c_str(), "fd:%d", &socketFd) != 1) || (socketFd < 0)) { |
| 854 | ALOGE("Error: failed to get fd of the client"); |
| 855 | return -1; |
| 856 | } |
| 857 | |
| 858 | // sanity check it's an actual fd by dup'ing it |
| 859 | int duppedFd = fcntl(socketFd, F_DUPFD_CLOEXEC, 3); |
| 860 | if (duppedFd < 0) { |
| 861 | ALOGE("Error: failed to dup client socket fd (%d - %s)", errno, strerror(errno)); |
| 862 | return -1; |
| 863 | } |
| 864 | |
| 865 | struct ucred cred; |
| 866 | socklen_t credLen = sizeof(cred); |
| 867 | if (getsockopt(duppedFd, SOL_SOCKET, SO_PEERCRED, &cred, &credLen) < 0) { |
| 868 | ALOGE("Error: failed to get creds from client socket (%d - %s)", errno, strerror(errno)); |
| 869 | cred.pid = -1; |
| 870 | } |
| 871 | |
| 872 | if (close(duppedFd) != 0) { |
| 873 | ALOGE("Error: failed to close dup'd socket (%d - %s)", errno, strerror(errno)); |
| 874 | } |
| 875 | |
| 876 | return cred.pid; |
| 877 | } |
| 878 | |
| 879 | |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 880 | void streamout_gc_() |
| 881 | { |
| 882 | std::lock_guard<std::mutex> lock_out(map_out_mutex_); |
| 883 | for (std::map<const std::string, streamout_map_t >::iterator it = streamout_map_.begin(); it != streamout_map_.end(); ) { |
| 884 | int pid, seq; |
| 885 | bool need_close = false; |
| 886 | |
| 887 | if (sscanf(it->first.c_str(), "%d-%d", &pid, &seq) == 2) { |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 888 | // Garbage collect streams when PID does not exists. |
| 889 | // It happens when client side crashed, or the client |
| 890 | // side does not have the right sequence to close opened streams. |
| 891 | if ((kill(pid, 0) == -1) && (errno == ESRCH)) { |
| 892 | need_close = true; |
| 893 | } |
| 894 | } |
| 895 | if (need_close) { |
Tim Yao | 031950f | 2020-12-16 11:36:20 -0800 | [diff] [blame] | 896 | ALOGI("Close disconnected output stream from PID %d", pid); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 897 | dev_->close_output_stream(dev_, it->second.second); |
| 898 | if (it->second.first) { |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 899 | shm_->destroy<IpcBuffer>(it->first.c_str()); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 900 | } |
| 901 | streamout_map_.erase(it++); |
| 902 | } else { |
| 903 | ++it; |
| 904 | } |
| 905 | } |
| 906 | } |
| 907 | |
| 908 | void streamin_gc_() |
| 909 | { |
| 910 | std::lock_guard<std::mutex> lock_out(map_in_mutex_); |
| 911 | for (std::map<const std::string, streamin_map_t >::iterator it = streamin_map_.begin(); it != streamin_map_.end(); ) { |
| 912 | int pid, seq; |
| 913 | bool need_close = false; |
| 914 | |
| 915 | if (sscanf(it->first.c_str(), "%d-%d", &pid, &seq) == 2) { |
| 916 | // Garbage collect streams when PID does not exists. |
| 917 | // It happens when client side crashed, or the client |
| 918 | // side does not have the right sequence to close opened streams. |
| 919 | if (kill(pid, 0) == ESRCH) { |
| 920 | need_close = true; |
| 921 | } |
| 922 | } |
| 923 | if (need_close) { |
| 924 | dev_->close_input_stream(dev_, it->second.second); |
| 925 | streamin_map_.erase(it++); |
| 926 | } else { |
| 927 | ++it; |
| 928 | } |
| 929 | } |
| 930 | } |
| 931 | |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 932 | void patch_gc_() |
| 933 | { |
| 934 | std::lock_guard<std::mutex> lock_out(map_patch_mutex_); |
| 935 | for (std::map<const std::string, audio_patch_handle_t >::iterator it = patch_map_.begin(); it != patch_map_.end(); ) { |
| 936 | int pid, seq; |
| 937 | bool need_close = false; |
| 938 | |
| 939 | if (sscanf(it->first.c_str(), "%d-%d", &pid, &seq) == 2) { |
| 940 | // Garbage collect patch when PID does not exists. |
| 941 | // It happens when client side crashed, or the client |
| 942 | // side does not have the right sequence to close opened streams. |
| 943 | if ((kill(pid, 0) == -1) && (errno == ESRCH)) { |
| 944 | need_close = true; |
| 945 | } |
| 946 | } |
| 947 | if (need_close) { |
| 948 | ALOGI("Close disconnected patch from PID %d, handle:%d", pid, it->second); |
| 949 | dev_->release_audio_patch(dev_, it->second); |
| 950 | patch_map_.erase(it++); |
| 951 | } else { |
| 952 | ++it; |
| 953 | } |
| 954 | } |
| 955 | } |
| 956 | |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 957 | struct audio_stream *find_stream(std::string name, |
| 958 | std::map<const std::string, streamout_map_t> &map_out, |
| 959 | std::map<const std::string, streamin_map_t> &map_in) |
| 960 | { |
| 961 | std::lock_guard<std::mutex> lock_out(map_out_mutex_); |
| 962 | std::map<const std::string, streamout_map_t >::iterator it_out = map_out.find(name); |
| 963 | if (it_out != map_out.end()) { |
| 964 | return &it_out->second.second->common; |
| 965 | } |
| 966 | |
| 967 | std::lock_guard<std::mutex> lock_in(map_in_mutex_); |
| 968 | std::map<const std::string, streamin_map_t >::iterator it_in = map_in.find(name); |
| 969 | if (it_in != map_in.end()) { |
| 970 | return &it_in->second.second->common; |
| 971 | } |
| 972 | |
| 973 | return nullptr; |
| 974 | } |
| 975 | |
| 976 | struct audio_stream_out *find_streamout(std::string name, |
| 977 | std::map<const std::string, streamout_map_t> &map_out) |
| 978 | { |
| 979 | std::lock_guard<std::mutex> lock(map_out_mutex_); |
| 980 | std::map<const std::string, streamout_map_t >::iterator it = map_out.find(name); |
| 981 | if (it != map_out.end()) { |
| 982 | return it->second.second; |
| 983 | } |
| 984 | |
| 985 | return nullptr; |
| 986 | } |
| 987 | |
| 988 | struct audio_stream_in *find_streamin(std::string name, |
| 989 | std::map<const std::string, streamin_map_t> &map_in) |
| 990 | { |
| 991 | std::lock_guard<std::mutex> lock(map_in_mutex_); |
| 992 | std::map<const std::string, streamin_map_t >::iterator it = map_in.find(name); |
| 993 | if (it != map_in.end()) { |
| 994 | return it->second.second; |
| 995 | } |
| 996 | |
| 997 | return nullptr; |
| 998 | } |
| 999 | |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 1000 | managed_shared_memory *shm_; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1001 | |
| 1002 | /* audio hal interface */ |
| 1003 | struct audio_hw_device *dev_; |
cheng tong | 7d90788 | 2020-09-04 18:53:04 +0800 | [diff] [blame] | 1004 | audio_effect_t *effect_; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1005 | static std::mutex map_in_mutex_; |
| 1006 | static std::mutex map_out_mutex_; |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 1007 | static std::mutex map_patch_mutex_; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1008 | std::map<const std::string, streamout_map_t > streamout_map_; |
| 1009 | std::map<const std::string, streamin_map_t > streamin_map_; |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 1010 | std::map<const std::string, audio_patch_handle_t > patch_map_; |
Tim Yao | 031950f | 2020-12-16 11:36:20 -0800 | [diff] [blame] | 1011 | |
| 1012 | /* gc thread to close dead streams */ |
| 1013 | bool gc_runner_stop_; |
| 1014 | std::mutex gc_mutex_; |
| 1015 | std::condition_variable gc_cv_; |
| 1016 | std::thread gc_runner_; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1017 | }; |
| 1018 | |
| 1019 | std::mutex AudioServiceImpl::map_out_mutex_; |
| 1020 | std::mutex AudioServiceImpl::map_in_mutex_; |
xingri.gao | 826841b | 2024-07-03 19:17:40 +0800 | [diff] [blame] | 1021 | std::mutex AudioServiceImpl::map_patch_mutex_; |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1022 | |
wei.du | c64b06a | 2022-01-17 16:51:12 +0800 | [diff] [blame] | 1023 | static void SetAudioPermissions(const char* file_path){ |
| 1024 | struct stat buf; |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 1025 | /*coverity[toctou]: The file_path status will not change after stat check*/ |
wei.du | c64b06a | 2022-01-17 16:51:12 +0800 | [diff] [blame] | 1026 | if (stat(file_path, &buf) != 0) |
| 1027 | return; |
| 1028 | |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 1029 | int ret = chmod(file_path, (buf.st_mode & 0711) | 0066); |
| 1030 | if (-1 == ret) { |
| 1031 | ALOGE("Error:chmod, need check!!"); |
| 1032 | } |
wei.du | c64b06a | 2022-01-17 16:51:12 +0800 | [diff] [blame] | 1033 | } |
| 1034 | |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 1035 | static bool runListenerLoop(const std::unique_ptr<grpc::Server> &server, const std::string &address) |
| 1036 | { |
| 1037 | if (address.find("unix://") != 0) { |
| 1038 | ALOGE("Error: must be an 'unix://' server address"); |
| 1039 | return false; |
| 1040 | } |
| 1041 | |
| 1042 | std::string socketPath = address.substr(strlen("unix://")); |
| 1043 | |
| 1044 | struct stat st; |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 1045 | /*coverity[toctou]*/ |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 1046 | if ((stat(socketPath.c_str(), &st) == 0) && ((st.st_mode & S_IFMT) == S_IFSOCK)) { |
| 1047 | unlink(socketPath.c_str()); |
| 1048 | } |
| 1049 | |
| 1050 | int serverSock = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); |
| 1051 | if (serverSock < 0) { |
| 1052 | ALOGE("Error: failed to create unix socket (%d - %s)", errno, strerror(errno)); |
| 1053 | return false; |
| 1054 | } |
| 1055 | |
| 1056 | struct sockaddr_un serverAddr; |
| 1057 | memset(&serverAddr, 0, sizeof(serverAddr)); |
| 1058 | serverAddr.sun_family = AF_UNIX; |
| 1059 | strncpy(serverAddr.sun_path, socketPath.c_str(), sizeof(serverAddr.sun_path) - 1); |
| 1060 | |
| 1061 | if (bind(serverSock, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) != 0) { |
| 1062 | ALOGE("Error: failed to bind to unix socket @ '%s' (%d - %s)", |
| 1063 | socketPath.c_str(), errno, strerror(errno)); |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 1064 | close(serverSock); |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 1065 | return false; |
| 1066 | } |
| 1067 | |
| 1068 | SetAudioPermissions(socketPath.c_str()); |
| 1069 | |
| 1070 | if (listen(serverSock, 5) == -1) { |
| 1071 | ALOGE("Error: failed to set socket to listening mode (%d - %s)", |
| 1072 | errno, strerror(errno)); |
| 1073 | return false; |
| 1074 | } |
| 1075 | |
| 1076 | for (;;) { |
| 1077 | struct sockaddr_un clientAddr; |
| 1078 | socklen_t clientAddrLen = sizeof(clientAddr); |
| 1079 | int clientSock = TEMP_FAILURE_RETRY(accept4(serverSock,(struct sockaddr *) &clientAddr, &clientAddrLen, SOCK_NONBLOCK | SOCK_CLOEXEC)); |
| 1080 | if (clientSock < 0) { |
| 1081 | ALOGE("Error: accepting new connection (%d - %s)", errno, strerror(errno)); |
| 1082 | continue; |
| 1083 | } |
| 1084 | |
| 1085 | struct ucred cred; |
| 1086 | socklen_t credLen = sizeof(cred); |
| 1087 | if (getsockopt(clientSock, SOL_SOCKET, SO_PEERCRED, &cred, &credLen) < 0) { |
| 1088 | ALOGE("Error: failed to get creds from client socket (%d - %s)", |
| 1089 | errno, strerror(errno)); |
| 1090 | close(clientSock); |
| 1091 | continue; |
| 1092 | } |
| 1093 | |
| 1094 | grpc::AddInsecureChannelFromFd(server.get(), clientSock); |
| 1095 | } |
| 1096 | |
| 1097 | return true; |
| 1098 | } |
| 1099 | |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 1100 | void RunServer() |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1101 | { |
Tim Yao | 1b84e36 | 2020-08-24 12:51:36 -0700 | [diff] [blame] | 1102 | const char *url = std::getenv("AUDIO_SERVER_SOCKET"); |
wei.du | c64b06a | 2022-01-17 16:51:12 +0800 | [diff] [blame] | 1103 | std::string socket_location("/tmp/audio_socket"); |
| 1104 | std::string server_address("unix://" + socket_location); |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 1105 | AudioServiceImpl service; |
Tim Yao | 1b84e36 | 2020-08-24 12:51:36 -0700 | [diff] [blame] | 1106 | if (url) { |
| 1107 | server_address = url; |
| 1108 | } |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1109 | ServerBuilder builder; |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 1110 | //builder.AddListeningPort(server_address, grpc::InsecureServerCredentials()); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1111 | builder.RegisterService(&service); |
| 1112 | std::unique_ptr<Server> server(builder.BuildAndStart()); |
wei.du | c64b06a | 2022-01-17 16:51:12 +0800 | [diff] [blame] | 1113 | SetAudioPermissions(socket_location.c_str()); |
| 1114 | SetAudioPermissions("/dev/shm/AudioServiceShmem"); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1115 | std::cout << "[AudioServer] listening on " << server_address << std::endl; |
Tim Yao | 41ac587 | 2022-12-11 13:07:32 -0800 | [diff] [blame] | 1116 | runListenerLoop(server, server_address); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1117 | server->Wait(); |
| 1118 | } |
| 1119 | |
| 1120 | static int daemonize() |
| 1121 | { |
| 1122 | int fd_pid; |
| 1123 | const char pidfile[] = "/var/run/audio_server.pid"; |
| 1124 | char pid[10]; |
| 1125 | |
| 1126 | fd_pid = open(pidfile, O_RDWR|O_CREAT, 0600); |
| 1127 | if (fd_pid == -1) { |
| 1128 | fprintf(stderr, "Unable to open PID lock file\n"); |
| 1129 | return -1; |
| 1130 | } |
| 1131 | |
| 1132 | if (lockf(fd_pid, F_TLOCK, 0) == -1) { |
| 1133 | fprintf(stderr, "Unable to lock PID file, daemon is existing.\n"); |
| 1134 | return -2; |
| 1135 | } |
| 1136 | |
| 1137 | snprintf(pid, sizeof(pid), "%d", getpid()); |
| 1138 | write(fd_pid, pid, strlen(pid)); |
| 1139 | |
| 1140 | return 0; |
| 1141 | } |
| 1142 | |
Tim Yao | 87d2f5a | 2020-12-26 17:03:58 -0800 | [diff] [blame] | 1143 | void handler(int sig) |
| 1144 | { |
wei.du | c2dbbd8 | 2023-05-04 09:13:03 +0000 | [diff] [blame] | 1145 | void *array[100]; |
| 1146 | size_t size, i = 0; |
| 1147 | char ** trace; |
Tim Yao | 87d2f5a | 2020-12-26 17:03:58 -0800 | [diff] [blame] | 1148 | |
| 1149 | // get void*'s for all entries on the stack |
wei.du | c2dbbd8 | 2023-05-04 09:13:03 +0000 | [diff] [blame] | 1150 | size = backtrace(array, 100); |
Tim Yao | 87d2f5a | 2020-12-26 17:03:58 -0800 | [diff] [blame] | 1151 | |
| 1152 | // print out all the frames to stderr |
wei.du | c2dbbd8 | 2023-05-04 09:13:03 +0000 | [diff] [blame] | 1153 | fprintf(stderr, "Error: signal %d, size %d\n", sig, size); |
| 1154 | ALOGE("Error: signal %d, size %d", sig, size); |
| 1155 | trace = backtrace_symbols(array, size); |
| 1156 | |
| 1157 | if (trace) { |
| 1158 | for (i = 0; i < size; i++) { |
| 1159 | ALOGE("%s", trace[i]); |
| 1160 | fprintf(stderr, "%s\n", trace[i]); |
| 1161 | } |
| 1162 | } else { |
| 1163 | fprintf(stderr, "backtrace symbols error!!!\n"); |
| 1164 | ALOGE("backtrace symbols error!!!"); |
| 1165 | } |
| 1166 | |
Tim Yao | 87d2f5a | 2020-12-26 17:03:58 -0800 | [diff] [blame] | 1167 | exit(1); |
| 1168 | } |
| 1169 | |
yuliang.hu | 19fdc8d | 2024-07-29 17:42:10 +0800 | [diff] [blame] | 1170 | /*coverity[UNCAUGHT_EXCEPT]: Do not catch exceptions in order to generate coredumps*/ |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1171 | int main(int argc, char** argv) |
| 1172 | { |
| 1173 | int r = daemonize(); |
| 1174 | if (r < 0) |
| 1175 | return r; |
| 1176 | |
yuliang.hu | 181f103 | 2024-04-25 07:41:48 +0000 | [diff] [blame] | 1177 | //signal(SIGSEGV, handler); |
| 1178 | //signal(SIGABRT, handler); |
| 1179 | //signal(SIGFPE, handler); |
Tim Yao | 87d2f5a | 2020-12-26 17:03:58 -0800 | [diff] [blame] | 1180 | |
Tim Yao | aaa3bc5 | 2020-12-30 17:40:14 -0800 | [diff] [blame] | 1181 | RunServer(); |
Tim Yao | e8c0d4a | 2019-11-27 14:47:35 -0800 | [diff] [blame] | 1182 | return 0; |
| 1183 | } |