Lines Matching defs:outputDesc
500 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
501 ALOG_ASSERT(!outputDesc->isDuplicated(),
503 outputDesc->toAudioPortConfig(&patch.sources[1]);
704 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
705 audio_devices_t newDevice = getNewOutputDevice(outputDesc, true /*fromCache*/);
706 if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (outputDesc != mPrimaryOutput)) {
707 waitMs = setOutputDevice(outputDesc, newDevice, (newDevice != AUDIO_DEVICE_NONE),
711 applyStreamVolumes(outputDesc, newDevice, waitMs, true);
976 sp<SwAudioOutputDescriptor> outputDesc =
983 status = outputDesc->open(config, device, address, stream, *flags, &output);
987 (config->sample_rate != 0 && config->sample_rate != outputDesc->mSamplingRate) ||
988 (config->format != AUDIO_FORMAT_DEFAULT && config->format != outputDesc->mFormat) ||
989 (config->channel_mask != 0 && config->channel_mask != outputDesc->mChannelMask)) {
992 outputDesc->mSamplingRate, config->format, outputDesc->mFormat,
993 config->channel_mask, outputDesc->mChannelMask);
995 outputDesc->close();
1004 outputDesc->mRefCount[stream] = 0;
1005 outputDesc->mStopTime[stream] = 0;
1006 outputDesc->mDirectOpenCount = 1;
1007 outputDesc->mDirectClientSession = session;
1009 addOutput(output, outputDesc);
1072 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
1073 if (!outputDesc->isDuplicated()) {
1076 if (outputDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
1077 if (format != outputDesc->mFormat) {
1084 outputDesc->mFormat, bestFormat, format)) {
1086 bestFormat = outputDesc->mFormat;
1090 int commonFlags = popcount(outputDesc->mProfile->getFlags() & flags);
1095 outputDesc->mFormat, bestFormatForFlags, format)) {
1097 bestFormatForFlags = outputDesc->mFormat;
1102 bestFormatForFlags = outputDesc->mFormat;
1106 if (outputDesc->mProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
1137 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(index);
1139 status_t status = outputDesc->start();
1150 if (outputDesc->mPolicyMix != NULL) {
1151 policyMix = outputDesc->mPolicyMix;
1159 newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
1160 if (newDevice != outputDesc->device()) {
1169 status = startSource(outputDesc, stream, newDevice, address, &delayMs);
1173 outputDesc->stop();
1193 status_t AudioPolicyManager::startSource(const sp<AudioOutputDescriptor>& outputDesc,
1217 bool force = !outputDesc->isActive() &&
1218 (outputDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE);
1223 const uint32_t outputLatencyMs = outputDesc->latency();
1224 bool requiresMuteCheck = outputDesc->isActive(outputLatencyMs * 2); // account for drain
1229 outputDesc->changeRefCount(stream, 1);
1235 if (outputDesc->mRefCount[stream] == 1 || device != AUDIO_DEVICE_NONE) {
1238 device = getNewOutputDevice(outputDesc, false /*fromCache*/);
1248 if (desc != outputDesc) {
1252 const bool sharedDevice = outputDesc->sharesHwModuleWith(desc)
1286 setOutputDevice(outputDesc, device, force, 0, NULL, address, requiresMuteCheck);
1295 mVolumeCurves->getVolumeIndex(stream, outputDesc->device()),
1296 outputDesc,
1297 outputDesc->device());
1323 setStrategyMute(STRATEGY_SONIFICATION, true, outputDesc);
1341 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(index);
1343 if (outputDesc->mRefCount[stream] == 1) {
1346 if (audio_is_remote_submix_device(outputDesc->mDevice) &&
1347 outputDesc->mPolicyMix != NULL &&
1348 outputDesc->mPolicyMix->mMixType == MIX_TYPE_RECORDERS) {
1351 outputDesc->mPolicyMix->mDeviceAddress,
1358 if (outputDesc->mRefCount[stream] > 0) {
1367 status_t status = stopSource(outputDesc, stream, forceDeviceUpdate);
1370 outputDesc->stop();
1375 status_t AudioPolicyManager::stopSource(const sp<AudioOutputDescriptor>& outputDesc,
1387 if (outputDesc->mRefCount[stream] > 0) {
1389 outputDesc->changeRefCount(stream, -1);
1392 if (outputDesc->mRefCount[stream] == 0 || forceDeviceUpdate) {
1393 outputDesc->mStopTime[stream] = systemTime();
1394 audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
1400 setOutputDevice(outputDesc, newDevice, false, outputDesc->latency()*2);
1404 uint32_t delayMs = outputDesc->latency()*2;
1407 if (desc != outputDesc &&
1409 outputDesc->sharesHwModuleWith(desc) &&
1430 setStrategyMute(STRATEGY_SONIFICATION, false, outputDesc);
2900 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
2901 if (outputDesc == NULL) {
2905 ALOG_ASSERT(!outputDesc->isDuplicated(),"duplicated output %d in source in ports",
2906 outputDesc->mIoHandle);
2929 if (!outputDesc->mProfile->isCompatibleProfile(devDesc->type(),
2950 devices.types(), outputDesc->mIoHandle);
2951 setOutputDevice(outputDesc, devices.types(), true, 0, handle);
3064 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
3065 if (outputDesc->isDuplicated()) {
3068 outputDesc->toAudioPortConfig(&newPatch.sources[1], &patch->sources[0]);
3131 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
3132 if (outputDesc == NULL) {
3137 setOutputDevice(outputDesc,
3138 getNewOutputDevice(outputDesc, true /*fromCache*/),
3196 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(config->id);
3197 if (outputDesc == NULL) {
3200 ALOG_ASSERT(!outputDesc->isDuplicated(),
3202 outputDesc->mIoHandle);
3203 audioPortConfig = outputDesc;
3270 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(j);
3271 if (!isStrategyActive(outputDesc, (routing_strategy)strategy)) {
3284 audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
3285 setOutputDevice(outputDesc, newDevice, false);
3426 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
3427 if (outputDesc->isDuplicated()) {
3431 status_t status = outputDesc->start();
3444 outputDesc->toAudioPortConfig(&patch->sources[1], NULL);
3457 status = startSource(outputDesc, stream, sinkDevice, NULL, &delayMs);
3463 sourceDesc->mSwOutput = outputDesc;
3737 sp<SwAudioOutputDescriptor> outputDesc;
3859 sp<SwAudioOutputDescriptor> outputDesc = sourceDesc->mSwOutput.promote();
3860 if (sourceStrategy == strategy && outputDesc != 0 && outputDesc->mIoHandle == output) {
4021 sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
4028 status_t status = outputDesc->open(nullptr, profileType, address,
4033 outputDesc->mDevice,
4045 mPrimaryOutput = outputDesc;
4047 addOutput(output, outputDesc);
4048 setOutputDevice(outputDesc,
4186 const sp<SwAudioOutputDescriptor>& outputDesc)
4188 mOutputs.add(output, outputDesc);
4189 applyStreamVolumes(outputDesc, AUDIO_DEVICE_NONE, 0 /* delayMs */, true /* force */);
4584 sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
4585 if (outputDesc == NULL) {
4589 mPolicyMixes.closeOutput(outputDesc);
4595 (dupOutputDesc->mOutput1 == outputDesc ||
4596 dupOutputDesc->mOutput2 == outputDesc)) {
4598 if (dupOutputDesc->mOutput1 == outputDesc) {
4627 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
4635 outputDesc->close();
4827 audio_devices_t AudioPolicyManager::getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
4832 ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
4837 outputDesc->device(), outputDesc->getPatchHandle());
4838 return outputDesc->device();
4845 if (outputDesc->isStreamActive((audio_stream_type_t)stream)) {
4875 if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE) &&
4879 isStrategyActive(outputDesc, STRATEGY_PHONE)) {
4881 } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION)) {
4883 } else if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE)) {
4885 } else if (isStrategyActive(outputDesc, STRATEGY_ACCESSIBILITY)) {
4887 } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION_RESPECTFUL)) {
4889 } else if (isStrategyActive(outputDesc, STRATEGY_MEDIA)) {
4891 } else if (isStrategyActive(outputDesc, STRATEGY_DTMF)) {
4893 } else if (isStrategyActive(outputDesc, STRATEGY_TRANSMITTED_THROUGH_SPEAKER)) {
4895 } else if (isStrategyActive(outputDesc, STRATEGY_REROUTING)) {
4955 sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
4956 if (outputDesc->isStreamActive((audio_stream_type_t)curStream)) {
4957 curDevices |= outputDesc->device();
5092 uint32_t AudioPolicyManager::checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc,
5099 if (outputDesc->isDuplicated()) {
5104 audio_devices_t device = outputDesc->device();
5105 bool shouldMute = outputDesc->isActive() && (popcount(device) >= 2);
5109 curDevice = curDevice & outputDesc->supportedDevices();
5113 if (mute && !outputDesc->mStrategyMutedByDevice[i]) {
5115 outputDesc->mStrategyMutedByDevice[i] = true;
5116 } else if (!mute && outputDesc->mStrategyMutedByDevice[i]){
5118 outputDesc->mStrategyMutedByDevice[i] = false;
5124 if ((desc->supportedDevices() & outputDesc->supportedDevices())
5149 if (outputDesc->isActive() && (device != prevDevice)) {
5150 uint32_t tempMuteWaitMs = outputDesc->latency() * 2;
5152 uint32_t tempMuteDurationMs = outputDesc->latency() * 4;
5158 if (isStrategyActive(outputDesc, (routing_strategy)i)) {
5161 setStrategyMute((routing_strategy)i, true, outputDesc, delayMs);
5162 setStrategyMute((routing_strategy)i, false, outputDesc,
5177 uint32_t AudioPolicyManager::setOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
5189 if (outputDesc->isDuplicated()) {
5190 muteWaitMs = setOutputDevice(outputDesc->subOutput1(), device, force, delayMs,
5192 muteWaitMs += setOutputDevice(outputDesc->subOutput2(), device, force, delayMs,
5199 ((device & outputDesc->supportedDevices()) == AUDIO_DEVICE_NONE)) {
5204 device = (audio_devices_t)(device & outputDesc->supportedDevices());
5206 audio_devices_t prevDevice = outputDesc->mDevice;
5211 outputDesc->mDevice = device;
5216 muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevice, delayMs);
5230 outputDesc->getPatchHandle() != 0) {
5239 resetOutputDevice(outputDesc, delayMs, NULL);
5250 outputDesc->toAudioPortConfig(&patch.sources[0]);
5261 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
5287 outputDesc->setPatchHandle(patchDesc->mHandle);
5309 applyStreamVolumes(outputDesc, device, delayMs);
5314 status_t AudioPolicyManager::resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
5322 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
5330 outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
5616 const sp<AudioOutputDescriptor>& outputDesc,
5622 if (outputDesc->mMuteCount[stream] != 0) {
5624 stream, outputDesc->mMuteCount[stream]);
5638 device = outputDesc->device();
5642 if (outputDesc->isFixedVolume(device) ||
5649 outputDesc->setVolume(volumeDb, stream, device, delayMs, force);
5670 void AudioPolicyManager::applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc,
5680 outputDesc,
5689 const sp<AudioOutputDescriptor>& outputDesc,
5694 strategy, on, outputDesc->getId());
5697 setStreamMute((audio_stream_type_t)stream, on, outputDesc, delayMs, device);
5704 const sp<AudioOutputDescriptor>& outputDesc,
5709 device = outputDesc->device();
5713 stream, on, outputDesc->mMuteCount[stream], device);
5716 if (outputDesc->mMuteCount[stream] == 0) {
5720 checkAndSetVolume(stream, 0, outputDesc, device, delayMs);
5724 outputDesc->mMuteCount[stream]++;
5726 if (outputDesc->mMuteCount[stream] == 0) {
5730 if (--outputDesc->mMuteCount[stream] == 0) {
5733 outputDesc,
5756 sp<SwAudioOutputDescriptor> outputDesc = mPrimaryOutput;
5758 stream, starting, outputDesc->mDevice, stateChange);
5759 if (outputDesc->mRefCount[stream]) {
5762 muteCount = outputDesc->mRefCount[stream];
5771 if (outputDesc->device() &
5870 bool AudioPolicyManager::isStrategyActive(const sp<AudioOutputDescriptor>& outputDesc,
5880 outputDesc->isStreamActive((audio_stream_type_t)i, inPastMs, sysTime)) {