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 #include <string.h> 18 19 #include "HidlUtils.h" 20 21 using ::android::hardware::audio::common::V2_0::AudioChannelMask; 22 using ::android::hardware::audio::common::V2_0::AudioDevice; 23 using ::android::hardware::audio::common::V2_0::AudioFormat; 24 using ::android::hardware::audio::common::V2_0::AudioGainMode; 25 using ::android::hardware::audio::common::V2_0::AudioMixLatencyClass; 26 using ::android::hardware::audio::common::V2_0::AudioPortConfigMask; 27 using ::android::hardware::audio::common::V2_0::AudioPortRole; 28 using ::android::hardware::audio::common::V2_0::AudioPortType; 29 using ::android::hardware::audio::common::V2_0::AudioSource; 30 using ::android::hardware::audio::common::V2_0::AudioStreamType; 31 using ::android::hardware::audio::common::V2_0::AudioUsage; 32 33 namespace android { 34 35 void HidlUtils::audioConfigFromHal(const audio_config_t& halConfig, AudioConfig* config) { 36 config->sampleRateHz = halConfig.sample_rate; 37 config->channelMask = AudioChannelMask(halConfig.channel_mask); 38 config->format = AudioFormat(halConfig.format); 39 audioOffloadInfoFromHal(halConfig.offload_info, &config->offloadInfo); 40 config->frameCount = halConfig.frame_count; 41 } 42 43 void HidlUtils::audioConfigToHal(const AudioConfig& config, audio_config_t* halConfig) { 44 memset(halConfig, 0, sizeof(audio_config_t)); 45 halConfig->sample_rate = config.sampleRateHz; 46 halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask); 47 halConfig->format = static_cast<audio_format_t>(config.format); 48 audioOffloadInfoToHal(config.offloadInfo, &halConfig->offload_info); 49 halConfig->frame_count = config.frameCount; 50 } 51 52 void HidlUtils::audioGainConfigFromHal( 53 const struct audio_gain_config& halConfig, AudioGainConfig* config) { 54 config->index = halConfig.index; 55 config->mode = AudioGainMode(halConfig.mode); 56 config->channelMask = AudioChannelMask(halConfig.channel_mask); 57 for (size_t i = 0; i < sizeof(audio_channel_mask_t) * 8; ++i) { 58 config->values[i] = halConfig.values[i]; 59 } 60 config->rampDurationMs = halConfig.ramp_duration_ms; 61 } 62 63 void HidlUtils::audioGainConfigToHal( 64 const AudioGainConfig& config, struct audio_gain_config* halConfig) { 65 halConfig->index = config.index; 66 halConfig->mode = static_cast<audio_gain_mode_t>(config.mode); 67 halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask); 68 memset(halConfig->values, 0, sizeof(halConfig->values)); 69 for (size_t i = 0; i < sizeof(audio_channel_mask_t) * 8; ++i) { 70 halConfig->values[i] = config.values[i]; 71 } 72 halConfig->ramp_duration_ms = config.rampDurationMs; 73 } 74 75 void HidlUtils::audioGainFromHal(const struct audio_gain& halGain, AudioGain* gain) { 76 gain->mode = AudioGainMode(halGain.mode); 77 gain->channelMask = AudioChannelMask(halGain.channel_mask); 78 gain->minValue = halGain.min_value; 79 gain->maxValue = halGain.max_value; 80 gain->defaultValue = halGain.default_value; 81 gain->stepValue = halGain.step_value; 82 gain->minRampMs = halGain.min_ramp_ms; 83 gain->maxRampMs = halGain.max_ramp_ms; 84 } 85 86 void HidlUtils::audioGainToHal(const AudioGain& gain, struct audio_gain* halGain) { 87 halGain->mode = static_cast<audio_gain_mode_t>(gain.mode); 88 halGain->channel_mask = static_cast<audio_channel_mask_t>(gain.channelMask); 89 halGain->min_value = gain.minValue; 90 halGain->max_value = gain.maxValue; 91 halGain->default_value = gain.defaultValue; 92 halGain->step_value = gain.stepValue; 93 halGain->min_ramp_ms = gain.minRampMs; 94 halGain->max_ramp_ms = gain.maxRampMs; 95 } 96 97 void HidlUtils::audioOffloadInfoFromHal( 98 const audio_offload_info_t& halOffload, AudioOffloadInfo* offload) { 99 offload->sampleRateHz = halOffload.sample_rate; 100 offload->channelMask = AudioChannelMask(halOffload.channel_mask); 101 offload->format = AudioFormat(halOffload.format); 102 offload->streamType = AudioStreamType(halOffload.stream_type); 103 offload->bitRatePerSecond = halOffload.bit_rate; 104 offload->durationMicroseconds = halOffload.duration_us; 105 offload->hasVideo = halOffload.has_video; 106 offload->isStreaming = halOffload.is_streaming; 107 offload->bitWidth = halOffload.bit_width; 108 offload->bufferSize = halOffload.offload_buffer_size; 109 offload->usage = static_cast<AudioUsage>(halOffload.usage); 110 } 111 112 void HidlUtils::audioOffloadInfoToHal( 113 const AudioOffloadInfo& offload, audio_offload_info_t* halOffload) { 114 *halOffload = AUDIO_INFO_INITIALIZER; 115 halOffload->sample_rate = offload.sampleRateHz; 116 halOffload->channel_mask = static_cast<audio_channel_mask_t>(offload.channelMask); 117 halOffload->format = static_cast<audio_format_t>(offload.format); 118 halOffload->stream_type = static_cast<audio_stream_type_t>(offload.streamType); 119 halOffload->bit_rate = offload.bitRatePerSecond; 120 halOffload->duration_us = offload.durationMicroseconds; 121 halOffload->has_video = offload.hasVideo; 122 halOffload->is_streaming = offload.isStreaming; 123 halOffload->bit_width = offload.bitWidth; 124 halOffload->offload_buffer_size = offload.bufferSize; 125 halOffload->usage = static_cast<audio_usage_t>(offload.usage); 126 } 127 128 void HidlUtils::audioPortConfigFromHal( 129 const struct audio_port_config& halConfig, AudioPortConfig* config) { 130 config->id = halConfig.id; 131 config->role = AudioPortRole(halConfig.role); 132 config->type = AudioPortType(halConfig.type); 133 config->configMask = AudioPortConfigMask(halConfig.config_mask); 134 config->sampleRateHz = halConfig.sample_rate; 135 config->channelMask = AudioChannelMask(halConfig.channel_mask); 136 config->format = AudioFormat(halConfig.format); 137 audioGainConfigFromHal(halConfig.gain, &config->gain); 138 switch (halConfig.type) { 139 case AUDIO_PORT_TYPE_NONE: break; 140 case AUDIO_PORT_TYPE_DEVICE: { 141 config->ext.device.hwModule = halConfig.ext.device.hw_module; 142 config->ext.device.type = AudioDevice(halConfig.ext.device.type); 143 memcpy(config->ext.device.address.data(), 144 halConfig.ext.device.address, 145 AUDIO_DEVICE_MAX_ADDRESS_LEN); 146 break; 147 } 148 case AUDIO_PORT_TYPE_MIX: { 149 config->ext.mix.hwModule = halConfig.ext.mix.hw_module; 150 config->ext.mix.ioHandle = halConfig.ext.mix.handle; 151 if (halConfig.role == AUDIO_PORT_ROLE_SOURCE) { 152 config->ext.mix.useCase.source = AudioSource(halConfig.ext.mix.usecase.source); 153 } else if (halConfig.role == AUDIO_PORT_ROLE_SINK) { 154 config->ext.mix.useCase.stream = AudioStreamType(halConfig.ext.mix.usecase.stream); 155 } 156 break; 157 } 158 case AUDIO_PORT_TYPE_SESSION: { 159 config->ext.session.session = halConfig.ext.session.session; 160 break; 161 } 162 } 163 } 164 165 void HidlUtils::audioPortConfigToHal( 166 const AudioPortConfig& config, struct audio_port_config* halConfig) { 167 memset(halConfig, 0, sizeof(audio_port_config)); 168 halConfig->id = config.id; 169 halConfig->role = static_cast<audio_port_role_t>(config.role); 170 halConfig->type = static_cast<audio_port_type_t>(config.type); 171 halConfig->config_mask = static_cast<unsigned int>(config.configMask); 172 halConfig->sample_rate = config.sampleRateHz; 173 halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask); 174 halConfig->format = static_cast<audio_format_t>(config.format); 175 audioGainConfigToHal(config.gain, &halConfig->gain); 176 switch (config.type) { 177 case AudioPortType::NONE: break; 178 case AudioPortType::DEVICE: { 179 halConfig->ext.device.hw_module = config.ext.device.hwModule; 180 halConfig->ext.device.type = static_cast<audio_devices_t>(config.ext.device.type); 181 memcpy(halConfig->ext.device.address, 182 config.ext.device.address.data(), 183 AUDIO_DEVICE_MAX_ADDRESS_LEN); 184 break; 185 } 186 case AudioPortType::MIX: { 187 halConfig->ext.mix.hw_module = config.ext.mix.hwModule; 188 halConfig->ext.mix.handle = config.ext.mix.ioHandle; 189 if (config.role == AudioPortRole::SOURCE) { 190 halConfig->ext.mix.usecase.source = 191 static_cast<audio_source_t>(config.ext.mix.useCase.source); 192 } else if (config.role == AudioPortRole::SINK) { 193 halConfig->ext.mix.usecase.stream = 194 static_cast<audio_stream_type_t>(config.ext.mix.useCase.stream); 195 } 196 break; 197 } 198 case AudioPortType::SESSION: { 199 halConfig->ext.session.session = 200 static_cast<audio_session_t>(config.ext.session.session); 201 break; 202 } 203 } 204 } 205 206 void HidlUtils::audioPortConfigsFromHal( 207 unsigned int numHalConfigs, const struct audio_port_config *halConfigs, 208 hidl_vec<AudioPortConfig> *configs) { 209 configs->resize(numHalConfigs); 210 for (unsigned int i = 0; i < numHalConfigs; ++i) { 211 audioPortConfigFromHal(halConfigs[i], &(*configs)[i]); 212 } 213 } 214 215 std::unique_ptr<audio_port_config[]> HidlUtils::audioPortConfigsToHal( 216 const hidl_vec<AudioPortConfig>& configs) { 217 std::unique_ptr<audio_port_config[]> halConfigs(new audio_port_config[configs.size()]); 218 for (size_t i = 0; i < configs.size(); ++i) { 219 audioPortConfigToHal(configs[i], &halConfigs[i]); 220 } 221 return halConfigs; 222 } 223 224 void HidlUtils::audioPortFromHal(const struct audio_port& halPort, AudioPort* port) { 225 port->id = halPort.id; 226 port->role = AudioPortRole(halPort.role); 227 port->type = AudioPortType(halPort.type); 228 port->name.setToExternal(halPort.name, strlen(halPort.name)); 229 port->sampleRates.resize(halPort.num_sample_rates); 230 for (size_t i = 0; i < halPort.num_sample_rates; ++i) { 231 port->sampleRates[i] = halPort.sample_rates[i]; 232 } 233 port->channelMasks.resize(halPort.num_channel_masks); 234 for (size_t i = 0; i < halPort.num_channel_masks; ++i) { 235 port->channelMasks[i] = AudioChannelMask(halPort.channel_masks[i]); 236 } 237 port->formats.resize(halPort.num_formats); 238 for (size_t i = 0; i < halPort.num_formats; ++i) { 239 port->formats[i] = AudioFormat(halPort.formats[i]); 240 } 241 port->gains.resize(halPort.num_gains); 242 for (size_t i = 0; i < halPort.num_gains; ++i) { 243 audioGainFromHal(halPort.gains[i], &port->gains[i]); 244 } 245 audioPortConfigFromHal(halPort.active_config, &port->activeConfig); 246 switch (halPort.type) { 247 case AUDIO_PORT_TYPE_NONE: break; 248 case AUDIO_PORT_TYPE_DEVICE: { 249 port->ext.device.hwModule = halPort.ext.device.hw_module; 250 port->ext.device.type = AudioDevice(halPort.ext.device.type); 251 memcpy(port->ext.device.address.data(), 252 halPort.ext.device.address, 253 AUDIO_DEVICE_MAX_ADDRESS_LEN); 254 break; 255 } 256 case AUDIO_PORT_TYPE_MIX: { 257 port->ext.mix.hwModule = halPort.ext.mix.hw_module; 258 port->ext.mix.ioHandle = halPort.ext.mix.handle; 259 port->ext.mix.latencyClass = AudioMixLatencyClass(halPort.ext.mix.latency_class); 260 break; 261 } 262 case AUDIO_PORT_TYPE_SESSION: { 263 port->ext.session.session = halPort.ext.session.session; 264 break; 265 } 266 } 267 } 268 269 void HidlUtils::audioPortToHal(const AudioPort& port, struct audio_port* halPort) { 270 memset(halPort, 0, sizeof(audio_port)); 271 halPort->id = port.id; 272 halPort->role = static_cast<audio_port_role_t>(port.role); 273 halPort->type = static_cast<audio_port_type_t>(port.type); 274 memcpy(halPort->name, 275 port.name.c_str(), 276 std::min(port.name.size(), static_cast<size_t>(AUDIO_PORT_MAX_NAME_LEN))); 277 halPort->num_sample_rates = 278 std::min(port.sampleRates.size(), static_cast<size_t>(AUDIO_PORT_MAX_SAMPLING_RATES)); 279 for (size_t i = 0; i < halPort->num_sample_rates; ++i) { 280 halPort->sample_rates[i] = port.sampleRates[i]; 281 } 282 halPort->num_channel_masks = 283 std::min(port.channelMasks.size(), static_cast<size_t>(AUDIO_PORT_MAX_CHANNEL_MASKS)); 284 for (size_t i = 0; i < halPort->num_channel_masks; ++i) { 285 halPort->channel_masks[i] = static_cast<audio_channel_mask_t>(port.channelMasks[i]); 286 } 287 halPort->num_formats = 288 std::min(port.formats.size(), static_cast<size_t>(AUDIO_PORT_MAX_FORMATS)); 289 for (size_t i = 0; i < halPort->num_formats; ++i) { 290 halPort->formats[i] = static_cast<audio_format_t>(port.formats[i]); 291 } 292 halPort->num_gains = std::min(port.gains.size(), static_cast<size_t>(AUDIO_PORT_MAX_GAINS)); 293 for (size_t i = 0; i < halPort->num_gains; ++i) { 294 audioGainToHal(port.gains[i], &halPort->gains[i]); 295 } 296 audioPortConfigToHal(port.activeConfig, &halPort->active_config); 297 switch (port.type) { 298 case AudioPortType::NONE: break; 299 case AudioPortType::DEVICE: { 300 halPort->ext.device.hw_module = port.ext.device.hwModule; 301 halPort->ext.device.type = static_cast<audio_devices_t>(port.ext.device.type); 302 memcpy(halPort->ext.device.address, 303 port.ext.device.address.data(), 304 AUDIO_DEVICE_MAX_ADDRESS_LEN); 305 break; 306 } 307 case AudioPortType::MIX: { 308 halPort->ext.mix.hw_module = port.ext.mix.hwModule; 309 halPort->ext.mix.handle = port.ext.mix.ioHandle; 310 halPort->ext.mix.latency_class = 311 static_cast<audio_mix_latency_class_t>(port.ext.mix.latencyClass); 312 break; 313 } 314 case AudioPortType::SESSION: { 315 halPort->ext.session.session = static_cast<audio_session_t>(port.ext.session.session); 316 break; 317 } 318 } 319 } 320 321 void HidlUtils::uuidFromHal(const audio_uuid_t& halUuid, Uuid* uuid) { 322 uuid->timeLow = halUuid.timeLow; 323 uuid->timeMid = halUuid.timeMid; 324 uuid->versionAndTimeHigh = halUuid.timeHiAndVersion; 325 uuid->variantAndClockSeqHigh = halUuid.clockSeq; 326 memcpy(uuid->node.data(), halUuid.node, uuid->node.size()); 327 } 328 329 void HidlUtils::uuidToHal(const Uuid& uuid, audio_uuid_t* halUuid) { 330 halUuid->timeLow = uuid.timeLow; 331 halUuid->timeMid = uuid.timeMid; 332 halUuid->timeHiAndVersion = uuid.versionAndTimeHigh; 333 halUuid->clockSeq = uuid.variantAndClockSeqHigh; 334 memcpy(halUuid->node, uuid.node.data(), uuid.node.size()); 335 } 336 337 } // namespace android 338
