1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef AUDIO_HAL_VERSION 18 #error "AUDIO_HAL_VERSION must be set before including this file." 19 #endif 20 21 #include <common/all-versions/VersionUtils.h> 22 #include <string.h> 23 24 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioChannelMask; 25 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioDevice; 26 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioFormat; 27 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioGainMode; 28 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioMixLatencyClass; 29 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioPortConfigMask; 30 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioPortRole; 31 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioPortType; 32 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioSource; 33 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioStreamType; 34 using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioUsage; 35 36 using ::android::hardware::audio::common::utils::mkEnumConverter; 37 38 namespace android { 39 namespace hardware { 40 namespace audio { 41 namespace common { 42 namespace AUDIO_HAL_VERSION { 43 44 void HidlUtils::audioConfigFromHal(const audio_config_t& halConfig, AudioConfig* config) { 45 config->sampleRateHz = halConfig.sample_rate; 46 config->channelMask = mkEnumConverter<AudioChannelMask>(halConfig.channel_mask); 47 config->format = AudioFormat(halConfig.format); 48 audioOffloadInfoFromHal(halConfig.offload_info, &config->offloadInfo); 49 config->frameCount = halConfig.frame_count; 50 } 51 52 void HidlUtils::audioConfigToHal(const AudioConfig& config, audio_config_t* halConfig) { 53 memset(halConfig, 0, sizeof(audio_config_t)); 54 halConfig->sample_rate = config.sampleRateHz; 55 halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask); 56 halConfig->format = static_cast<audio_format_t>(config.format); 57 audioOffloadInfoToHal(config.offloadInfo, &halConfig->offload_info); 58 halConfig->frame_count = config.frameCount; 59 } 60 61 void HidlUtils::audioGainConfigFromHal(const struct audio_gain_config& halConfig, 62 AudioGainConfig* config) { 63 config->index = halConfig.index; 64 config->mode = mkEnumConverter<AudioGainMode>(halConfig.mode); 65 config->channelMask = mkEnumConverter<AudioChannelMask>(halConfig.channel_mask); 66 for (size_t i = 0; i < sizeof(audio_channel_mask_t) * 8; ++i) { 67 config->values[i] = halConfig.values[i]; 68 } 69 config->rampDurationMs = halConfig.ramp_duration_ms; 70 } 71 72 void HidlUtils::audioGainConfigToHal(const AudioGainConfig& config, 73 struct audio_gain_config* halConfig) { 74 halConfig->index = config.index; 75 halConfig->mode = static_cast<audio_gain_mode_t>(config.mode); 76 halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask); 77 memset(halConfig->values, 0, sizeof(halConfig->values)); 78 for (size_t i = 0; i < sizeof(audio_channel_mask_t) * 8; ++i) { 79 halConfig->values[i] = config.values[i]; 80 } 81 halConfig->ramp_duration_ms = config.rampDurationMs; 82 } 83 84 void HidlUtils::audioGainFromHal(const struct audio_gain& halGain, AudioGain* gain) { 85 gain->mode = mkEnumConverter<AudioGainMode>(halGain.mode); 86 gain->channelMask = mkEnumConverter<AudioChannelMask>(halGain.channel_mask); 87 gain->minValue = halGain.min_value; 88 gain->maxValue = halGain.max_value; 89 gain->defaultValue = halGain.default_value; 90 gain->stepValue = halGain.step_value; 91 gain->minRampMs = halGain.min_ramp_ms; 92 gain->maxRampMs = halGain.max_ramp_ms; 93 } 94 95 void HidlUtils::audioGainToHal(const AudioGain& gain, struct audio_gain* halGain) { 96 halGain->mode = static_cast<audio_gain_mode_t>(gain.mode); 97 halGain->channel_mask = static_cast<audio_channel_mask_t>(gain.channelMask); 98 halGain->min_value = gain.minValue; 99 halGain->max_value = gain.maxValue; 100 halGain->default_value = gain.defaultValue; 101 halGain->step_value = gain.stepValue; 102 halGain->min_ramp_ms = gain.minRampMs; 103 halGain->max_ramp_ms = gain.maxRampMs; 104 } 105 106 AudioUsage HidlUtils::audioUsageFromHal(const audio_usage_t halUsage) { 107 switch (halUsage) { 108 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST: 109 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT: 110 case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED: 111 case AUDIO_USAGE_NOTIFICATION_EVENT: 112 return AudioUsage::NOTIFICATION; 113 default: 114 return static_cast<AudioUsage>(halUsage); 115 } 116 } 117 118 audio_usage_t HidlUtils::audioUsageToHal(const AudioUsage usage) { 119 return static_cast<audio_usage_t>(usage); 120 } 121 122 void HidlUtils::audioOffloadInfoFromHal(const audio_offload_info_t& halOffload, 123 AudioOffloadInfo* offload) { 124 offload->sampleRateHz = halOffload.sample_rate; 125 offload->channelMask = mkEnumConverter<AudioChannelMask>(halOffload.channel_mask); 126 offload->format = AudioFormat(halOffload.format); 127 offload->streamType = AudioStreamType(halOffload.stream_type); 128 offload->bitRatePerSecond = halOffload.bit_rate; 129 offload->durationMicroseconds = halOffload.duration_us; 130 offload->hasVideo = halOffload.has_video; 131 offload->isStreaming = halOffload.is_streaming; 132 offload->bitWidth = halOffload.bit_width; 133 offload->bufferSize = halOffload.offload_buffer_size; 134 offload->usage = audioUsageFromHal(halOffload.usage); 135 } 136 137 void HidlUtils::audioOffloadInfoToHal(const AudioOffloadInfo& offload, 138 audio_offload_info_t* halOffload) { 139 *halOffload = AUDIO_INFO_INITIALIZER; 140 halOffload->sample_rate = offload.sampleRateHz; 141 halOffload->channel_mask = static_cast<audio_channel_mask_t>(offload.channelMask); 142 halOffload->format = static_cast<audio_format_t>(offload.format); 143 halOffload->stream_type = static_cast<audio_stream_type_t>(offload.streamType); 144 halOffload->bit_rate = offload.bitRatePerSecond; 145 halOffload->duration_us = offload.durationMicroseconds; 146 halOffload->has_video = offload.hasVideo; 147 halOffload->is_streaming = offload.isStreaming; 148 halOffload->bit_width = offload.bitWidth; 149 halOffload->offload_buffer_size = offload.bufferSize; 150 halOffload->usage = audioUsageToHal(offload.usage); 151 } 152 153 void HidlUtils::audioPortConfigFromHal(const struct audio_port_config& halConfig, 154 AudioPortConfig* config) { 155 config->id = halConfig.id; 156 config->role = AudioPortRole(halConfig.role); 157 config->type = AudioPortType(halConfig.type); 158 config->configMask = mkEnumConverter<AudioPortConfigMask>(halConfig.config_mask); 159 config->sampleRateHz = halConfig.sample_rate; 160 config->channelMask = mkEnumConverter<AudioChannelMask>(halConfig.channel_mask); 161 config->format = AudioFormat(halConfig.format); 162 audioGainConfigFromHal(halConfig.gain, &config->gain); 163 switch (halConfig.type) { 164 case AUDIO_PORT_TYPE_NONE: 165 break; 166 case AUDIO_PORT_TYPE_DEVICE: { 167 config->ext.device.hwModule = halConfig.ext.device.hw_module; 168 config->ext.device.type = AudioDevice(halConfig.ext.device.type); 169 memcpy(config->ext.device.address.data(), halConfig.ext.device.address, 170 AUDIO_DEVICE_MAX_ADDRESS_LEN); 171 break; 172 } 173 case AUDIO_PORT_TYPE_MIX: { 174 config->ext.mix.hwModule = halConfig.ext.mix.hw_module; 175 config->ext.mix.ioHandle = halConfig.ext.mix.handle; 176 if (halConfig.role == AUDIO_PORT_ROLE_SOURCE) { 177 config->ext.mix.useCase.source = AudioSource(halConfig.ext.mix.usecase.source); 178 } else if (halConfig.role == AUDIO_PORT_ROLE_SINK) { 179 config->ext.mix.useCase.stream = AudioStreamType(halConfig.ext.mix.usecase.stream); 180 } 181 break; 182 } 183 case AUDIO_PORT_TYPE_SESSION: { 184 config->ext.session.session = halConfig.ext.session.session; 185 break; 186 } 187 } 188 } 189 190 void HidlUtils::audioPortConfigToHal(const AudioPortConfig& config, 191 struct audio_port_config* halConfig) { 192 memset(halConfig, 0, sizeof(audio_port_config)); 193 halConfig->id = config.id; 194 halConfig->role = static_cast<audio_port_role_t>(config.role); 195 halConfig->type = static_cast<audio_port_type_t>(config.type); 196 halConfig->config_mask = static_cast<unsigned int>(config.configMask); 197 halConfig->sample_rate = config.sampleRateHz; 198 halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask); 199 halConfig->format = static_cast<audio_format_t>(config.format); 200 audioGainConfigToHal(config.gain, &halConfig->gain); 201 switch (config.type) { 202 case AudioPortType::NONE: 203 break; 204 case AudioPortType::DEVICE: { 205 halConfig->ext.device.hw_module = config.ext.device.hwModule; 206 halConfig->ext.device.type = static_cast<audio_devices_t>(config.ext.device.type); 207 memcpy(halConfig->ext.device.address, config.ext.device.address.data(), 208 AUDIO_DEVICE_MAX_ADDRESS_LEN); 209 break; 210 } 211 case AudioPortType::MIX: { 212 halConfig->ext.mix.hw_module = config.ext.mix.hwModule; 213 halConfig->ext.mix.handle = config.ext.mix.ioHandle; 214 if (config.role == AudioPortRole::SOURCE) { 215 halConfig->ext.mix.usecase.source = 216 static_cast<audio_source_t>(config.ext.mix.useCase.source); 217 } else if (config.role == AudioPortRole::SINK) { 218 halConfig->ext.mix.usecase.stream = 219 static_cast<audio_stream_type_t>(config.ext.mix.useCase.stream); 220 } 221 break; 222 } 223 case AudioPortType::SESSION: { 224 halConfig->ext.session.session = 225 static_cast<audio_session_t>(config.ext.session.session); 226 break; 227 } 228 } 229 } 230 231 void HidlUtils::audioPortConfigsFromHal(unsigned int numHalConfigs, 232 const struct audio_port_config* halConfigs, 233 hidl_vec<AudioPortConfig>* configs) { 234 configs->resize(numHalConfigs); 235 for (unsigned int i = 0; i < numHalConfigs; ++i) { 236 audioPortConfigFromHal(halConfigs[i], &(*configs)[i]); 237 } 238 } 239 240 std::unique_ptr<audio_port_config[]> HidlUtils::audioPortConfigsToHal( 241 const hidl_vec<AudioPortConfig>& configs) { 242 std::unique_ptr<audio_port_config[]> halConfigs(new audio_port_config[configs.size()]); 243 for (size_t i = 0; i < configs.size(); ++i) { 244 audioPortConfigToHal(configs[i], &halConfigs[i]); 245 } 246 return halConfigs; 247 } 248 249 void HidlUtils::audioPortFromHal(const struct audio_port& halPort, AudioPort* port) { 250 port->id = halPort.id; 251 port->role = AudioPortRole(halPort.role); 252 port->type = AudioPortType(halPort.type); 253 port->name.setToExternal(halPort.name, strlen(halPort.name)); 254 port->sampleRates.resize(halPort.num_sample_rates); 255 for (size_t i = 0; i < halPort.num_sample_rates; ++i) { 256 port->sampleRates[i] = halPort.sample_rates[i]; 257 } 258 port->channelMasks.resize(halPort.num_channel_masks); 259 for (size_t i = 0; i < halPort.num_channel_masks; ++i) { 260 port->channelMasks[i] = mkEnumConverter<AudioChannelMask>(halPort.channel_masks[i]); 261 } 262 port->formats.resize(halPort.num_formats); 263 for (size_t i = 0; i < halPort.num_formats; ++i) { 264 port->formats[i] = AudioFormat(halPort.formats[i]); 265 } 266 port->gains.resize(halPort.num_gains); 267 for (size_t i = 0; i < halPort.num_gains; ++i) { 268 audioGainFromHal(halPort.gains[i], &port->gains[i]); 269 } 270 audioPortConfigFromHal(halPort.active_config, &port->activeConfig); 271 switch (halPort.type) { 272 case AUDIO_PORT_TYPE_NONE: 273 break; 274 case AUDIO_PORT_TYPE_DEVICE: { 275 port->ext.device.hwModule = halPort.ext.device.hw_module; 276 port->ext.device.type = AudioDevice(halPort.ext.device.type); 277 memcpy(port->ext.device.address.data(), halPort.ext.device.address, 278 AUDIO_DEVICE_MAX_ADDRESS_LEN); 279 break; 280 } 281 case AUDIO_PORT_TYPE_MIX: { 282 port->ext.mix.hwModule = halPort.ext.mix.hw_module; 283 port->ext.mix.ioHandle = halPort.ext.mix.handle; 284 port->ext.mix.latencyClass = AudioMixLatencyClass(halPort.ext.mix.latency_class); 285 break; 286 } 287 case AUDIO_PORT_TYPE_SESSION: { 288 port->ext.session.session = halPort.ext.session.session; 289 break; 290 } 291 } 292 } 293 294 void HidlUtils::audioPortToHal(const AudioPort& port, struct audio_port* halPort) { 295 memset(halPort, 0, sizeof(audio_port)); 296 halPort->id = port.id; 297 halPort->role = static_cast<audio_port_role_t>(port.role); 298 halPort->type = static_cast<audio_port_type_t>(port.type); 299 strncpy(halPort->name, port.name.c_str(), AUDIO_PORT_MAX_NAME_LEN); 300 halPort->name[AUDIO_PORT_MAX_NAME_LEN - 1] = '\0'; 301 halPort->num_sample_rates = 302 std::min(port.sampleRates.size(), static_cast<size_t>(AUDIO_PORT_MAX_SAMPLING_RATES)); 303 for (size_t i = 0; i < halPort->num_sample_rates; ++i) { 304 halPort->sample_rates[i] = port.sampleRates[i]; 305 } 306 halPort->num_channel_masks = 307 std::min(port.channelMasks.size(), static_cast<size_t>(AUDIO_PORT_MAX_CHANNEL_MASKS)); 308 for (size_t i = 0; i < halPort->num_channel_masks; ++i) { 309 halPort->channel_masks[i] = static_cast<audio_channel_mask_t>(port.channelMasks[i]); 310 } 311 halPort->num_formats = 312 std::min(port.formats.size(), static_cast<size_t>(AUDIO_PORT_MAX_FORMATS)); 313 for (size_t i = 0; i < halPort->num_formats; ++i) { 314 halPort->formats[i] = static_cast<audio_format_t>(port.formats[i]); 315 } 316 halPort->num_gains = std::min(port.gains.size(), static_cast<size_t>(AUDIO_PORT_MAX_GAINS)); 317 for (size_t i = 0; i < halPort->num_gains; ++i) { 318 audioGainToHal(port.gains[i], &halPort->gains[i]); 319 } 320 audioPortConfigToHal(port.activeConfig, &halPort->active_config); 321 switch (port.type) { 322 case AudioPortType::NONE: 323 break; 324 case AudioPortType::DEVICE: { 325 halPort->ext.device.hw_module = port.ext.device.hwModule; 326 halPort->ext.device.type = static_cast<audio_devices_t>(port.ext.device.type); 327 memcpy(halPort->ext.device.address, port.ext.device.address.data(), 328 AUDIO_DEVICE_MAX_ADDRESS_LEN); 329 break; 330 } 331 case AudioPortType::MIX: { 332 halPort->ext.mix.hw_module = port.ext.mix.hwModule; 333 halPort->ext.mix.handle = port.ext.mix.ioHandle; 334 halPort->ext.mix.latency_class = 335 static_cast<audio_mix_latency_class_t>(port.ext.mix.latencyClass); 336 break; 337 } 338 case AudioPortType::SESSION: { 339 halPort->ext.session.session = static_cast<audio_session_t>(port.ext.session.session); 340 break; 341 } 342 } 343 } 344 345 void HidlUtils::uuidFromHal(const audio_uuid_t& halUuid, Uuid* uuid) { 346 uuid->timeLow = halUuid.timeLow; 347 uuid->timeMid = halUuid.timeMid; 348 uuid->versionAndTimeHigh = halUuid.timeHiAndVersion; 349 uuid->variantAndClockSeqHigh = halUuid.clockSeq; 350 memcpy(uuid->node.data(), halUuid.node, uuid->node.size()); 351 } 352 353 void HidlUtils::uuidToHal(const Uuid& uuid, audio_uuid_t* halUuid) { 354 halUuid->timeLow = uuid.timeLow; 355 halUuid->timeMid = uuid.timeMid; 356 halUuid->timeHiAndVersion = uuid.versionAndTimeHigh; 357 halUuid->clockSeq = uuid.variantAndClockSeqHigh; 358 memcpy(halUuid->node, uuid.node.data(), uuid.node.size()); 359 } 360 361 } // namespace AUDIO_HAL_VERSION 362 } // namespace common 363 } // namespace audio 364 } // namespace hardware 365 } // namespace android 366
