gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert "audio policy: refactor audio record APIs"

Browse Source 
This reverts commit 0f4b3c5449.

Bug: 72628781
Test: Capture several videos from camera app
Change-Id: I6bcc87c618ac9bfe5c911915cbb37de616bc727a
gugelfrei
Eric Laurent 7 years ago
parent 67651f97c9
commit e9ebcdbb05
9 changed files with 96 additions and 122 deletions
Show Stats Download Patch File Download Diff File

21
media/libaudioclient/AudioSystem.cpp
Unescape View File

@ -904,7 +904,6 @@ status_t AudioSystem::getInputForAttr(const audio_attributes_t *attr,
audio_session_t session, audio_session_t session,
pid_t pid, pid_t pid,
uid_t uid, uid_t uid,
const String16& opPackageName,
const audio_config_base_t *config, const audio_config_base_t *config,
audio_input_flags_t flags, audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId, audio_port_handle_t *selectedDeviceId,
@ -913,29 +912,35 @@ status_t AudioSystem::getInputForAttr(const audio_attributes_t *attr,
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return NO_INIT; if (aps == 0) return NO_INIT;
return aps->getInputForAttr( return aps->getInputForAttr(
attr, input, session, pid, uid, opPackageName, attr, input, session, pid, uid,
config, flags, selectedDeviceId, portId); config, flags, selectedDeviceId, portId);
} }
status_t AudioSystem::startInput(audio_port_handle_t portId, bool *silenced) status_t AudioSystem::startInput(audio_io_handle_t input,
audio_session_t session,
audio_devices_t device,
uid_t uid,
bool *silenced)
{ {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED; if (aps == 0) return PERMISSION_DENIED;
return aps->startInput(portId, silenced); return aps->startInput(input, session, device, uid, silenced);
} }
status_t AudioSystem::stopInput(audio_port_handle_t portId) status_t AudioSystem::stopInput(audio_io_handle_t input,
audio_session_t session)
{ {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED; if (aps == 0) return PERMISSION_DENIED;
return aps->stopInput(portId); return aps->stopInput(input, session);
} }
void AudioSystem::releaseInput(audio_port_handle_t portId) void AudioSystem::releaseInput(audio_io_handle_t input,
audio_session_t session)
{ {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return; if (aps == 0) return;
aps->releaseInput(portId); aps->releaseInput(input, session);
} }
status_t AudioSystem::initStreamVolume(audio_stream_type_t stream, status_t AudioSystem::initStreamVolume(audio_stream_type_t stream,

44
media/libaudioclient/IAudioPolicyService.cpp
Unescape View File

@ -285,7 +285,6 @@ public:
audio_session_t session, audio_session_t session,
pid_t pid, pid_t pid,
uid_t uid, uid_t uid,
const String16& opPackageName,
const audio_config_base_t *config, const audio_config_base_t *config,
audio_input_flags_t flags, audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId, audio_port_handle_t *selectedDeviceId,
@ -314,7 +313,6 @@ public:
data.writeInt32(session); data.writeInt32(session);
data.writeInt32(pid); data.writeInt32(pid);
data.writeInt32(uid); data.writeInt32(uid);
data.writeString16(opPackageName);
data.write(config, sizeof(audio_config_base_t)); data.write(config, sizeof(audio_config_base_t));
data.writeInt32(flags); data.writeInt32(flags);
data.writeInt32(*selectedDeviceId); data.writeInt32(*selectedDeviceId);
@ -333,12 +331,18 @@ public:
return NO_ERROR; return NO_ERROR;
} }
virtual status_t startInput(audio_port_handle_t portId, virtual status_t startInput(audio_io_handle_t input,
audio_session_t session,
audio_devices_t device,
uid_t uid,
bool *silenced) bool *silenced)
{ {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
data.writeInt32(portId); data.writeInt32(input);
data.writeInt32(session);
data.writeInt32(device);
data.writeInt32(uid);
data.writeInt32(*silenced ? 1 : 0); data.writeInt32(*silenced ? 1 : 0);
remote()->transact(START_INPUT, data, &reply); remote()->transact(START_INPUT, data, &reply);
status_t status = static_cast <status_t> (reply.readInt32()); status_t status = static_cast <status_t> (reply.readInt32());
@ -346,20 +350,24 @@ public:
return status; return status;
} }
virtual status_t stopInput(audio_port_handle_t portId) virtual status_t stopInput(audio_io_handle_t input,
audio_session_t session)
{ {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
data.writeInt32(portId); data.writeInt32(input);
data.writeInt32(session);
remote()->transact(STOP_INPUT, data, &reply); remote()->transact(STOP_INPUT, data, &reply);
return static_cast <status_t> (reply.readInt32()); return static_cast <status_t> (reply.readInt32());
} }
virtual void releaseInput(audio_port_handle_t portId) virtual void releaseInput(audio_io_handle_t input,
audio_session_t session)
{ {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
data.writeInt32(portId); data.writeInt32(input);
data.writeInt32(session);
remote()->transact(RELEASE_INPUT, data, &reply); remote()->transact(RELEASE_INPUT, data, &reply);
} }
@ -1026,7 +1034,6 @@ status_t BnAudioPolicyService::onTransact(
audio_session_t session = (audio_session_t)data.readInt32(); audio_session_t session = (audio_session_t)data.readInt32();
pid_t pid = (pid_t)data.readInt32(); pid_t pid = (pid_t)data.readInt32();
uid_t uid = (uid_t)data.readInt32(); uid_t uid = (uid_t)data.readInt32();
const String16 opPackageName = data.readString16();
audio_config_base_t config; audio_config_base_t config;
memset(&config, 0, sizeof(audio_config_base_t)); memset(&config, 0, sizeof(audio_config_base_t));
data.read(&config, sizeof(audio_config_base_t)); data.read(&config, sizeof(audio_config_base_t));
@ -1034,7 +1041,7 @@ status_t BnAudioPolicyService::onTransact(
audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32(); audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32();
audio_port_handle_t portId = (audio_port_handle_t)data.readInt32(); audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
status_t status = getInputForAttr(&attr, &input, session, pid, uid, status_t status = getInputForAttr(&attr, &input, session, pid, uid,
opPackageName, &config, &config,
flags, &selectedDeviceId, &portId); flags, &selectedDeviceId, &portId);
reply->writeInt32(status); reply->writeInt32(status);
if (status == NO_ERROR) { if (status == NO_ERROR) {
@ -1047,9 +1054,12 @@ status_t BnAudioPolicyService::onTransact(
case START_INPUT: { case START_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply); CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
audio_session_t session = static_cast <audio_session_t>(data.readInt32());
audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
uid_t uid = static_cast <uid_t>(data.readInt32());
bool silenced = data.readInt32() == 1; bool silenced = data.readInt32() == 1;
status_t status = startInput(portId, &silenced); status_t status = startInput(input, session, device, uid, &silenced);
reply->writeInt32(static_cast <uint32_t>(status)); reply->writeInt32(static_cast <uint32_t>(status));
reply->writeInt32(silenced ? 1 : 0); reply->writeInt32(silenced ? 1 : 0);
return NO_ERROR; return NO_ERROR;
@ -1057,15 +1067,17 @@ status_t BnAudioPolicyService::onTransact(
case STOP_INPUT: { case STOP_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply); CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(stopInput(portId))); audio_session_t session = static_cast <audio_session_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(stopInput(input, session)));
return NO_ERROR; return NO_ERROR;
} break; } break;
case RELEASE_INPUT: { case RELEASE_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply); CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
releaseInput(portId); audio_session_t session = static_cast <audio_session_t>(data.readInt32());
releaseInput(input, session);
return NO_ERROR; return NO_ERROR;
} break; } break;

12
media/libaudioclient/include/media/AudioSystem.h
Unescape View File

@ -239,16 +239,20 @@ public:
audio_session_t session, audio_session_t session,
pid_t pid, pid_t pid,
uid_t uid, uid_t uid,
const String16& opPackageName,
const audio_config_base_t *config, const audio_config_base_t *config,
audio_input_flags_t flags, audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId, audio_port_handle_t *selectedDeviceId,
audio_port_handle_t *portId); audio_port_handle_t *portId);
static status_t startInput(audio_port_handle_t portId, static status_t startInput(audio_io_handle_t input,
audio_session_t session,
audio_devices_t device,
uid_t uid,
bool *silenced); bool *silenced);
static status_t stopInput(audio_port_handle_t portId); static status_t stopInput(audio_io_handle_t input,
static void releaseInput(audio_port_handle_t portId); audio_session_t session);
static void releaseInput(audio_io_handle_t input,
audio_session_t session);
static status_t initStreamVolume(audio_stream_type_t stream, static status_t initStreamVolume(audio_stream_type_t stream,
int indexMin, int indexMin,
int indexMax); int indexMax);

12
media/libaudioclient/include/media/IAudioPolicyService.h
Unescape View File

@ -80,15 +80,19 @@ public:
audio_session_t session, audio_session_t session,
pid_t pid, pid_t pid,
uid_t uid, uid_t uid,
const String16& opPackageName,
const audio_config_base_t *config, const audio_config_base_t *config,
audio_input_flags_t flags, audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId, audio_port_handle_t *selectedDeviceId,
audio_port_handle_t *portId) = 0; audio_port_handle_t *portId) = 0;
virtual status_t startInput(audio_port_handle_t portId, virtual status_t startInput(audio_io_handle_t input,
audio_session_t session,
audio_devices_t device,
uid_t uid,
bool *silenced) = 0; bool *silenced) = 0;
virtual status_t stopInput(audio_port_handle_t portId) = 0; virtual status_t stopInput(audio_io_handle_t input,
virtual void releaseInput(audio_port_handle_t portId) = 0; audio_session_t session) = 0;
virtual void releaseInput(audio_io_handle_t input,
audio_session_t session) = 0;
virtual status_t initStreamVolume(audio_stream_type_t stream, virtual status_t initStreamVolume(audio_stream_type_t stream,
int indexMin, int indexMin,
int indexMax) = 0; int indexMax) = 0;

8
services/audioflinger/AudioFlinger.cpp
Unescape View File

@ -321,7 +321,6 @@ status_t AudioFlinger::openMmapStream(MmapStreamInterface::stream_direction_t di
actualSessionId, actualSessionId,
client.clientPid, client.clientPid,
client.clientUid, client.clientUid,
client.packageName,
config, config,
AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId); AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId);
} }
@ -341,7 +340,7 @@ status_t AudioFlinger::openMmapStream(MmapStreamInterface::stream_direction_t di
if (direction == MmapStreamInterface::DIRECTION_OUTPUT) { if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
AudioSystem::releaseOutput(io, streamType, actualSessionId); AudioSystem::releaseOutput(io, streamType, actualSessionId);
} else { } else {
AudioSystem::releaseInput(portId); AudioSystem::releaseInput(io, actualSessionId);
} }
ret = NO_INIT; ret = NO_INIT;
} }
@ -1664,7 +1663,7 @@ sp<media::IAudioRecord> AudioFlinger::createRecord(const CreateRecordInput& inpu
// release previously opened input if retrying. // release previously opened input if retrying.
if (output.inputId != AUDIO_IO_HANDLE_NONE) { if (output.inputId != AUDIO_IO_HANDLE_NONE) {
recordTrack.clear(); recordTrack.clear();
AudioSystem::releaseInput(portId); AudioSystem::releaseInput(output.inputId, sessionId);
output.inputId = AUDIO_IO_HANDLE_NONE; output.inputId = AUDIO_IO_HANDLE_NONE;
} }
lStatus = AudioSystem::getInputForAttr(&input.attr, &output.inputId, lStatus = AudioSystem::getInputForAttr(&input.attr, &output.inputId,
@ -1672,7 +1671,6 @@ sp<media::IAudioRecord> AudioFlinger::createRecord(const CreateRecordInput& inpu
// FIXME compare to AudioTrack // FIXME compare to AudioTrack
clientPid, clientPid,
clientUid, clientUid,
input.opPackageName,
&input.config, &input.config,
output.flags, &output.selectedDeviceId, &portId); output.flags, &output.selectedDeviceId, &portId);
@ -1741,7 +1739,7 @@ Exit:
} }
recordTrack.clear(); recordTrack.clear();
if (output.inputId != AUDIO_IO_HANDLE_NONE) { if (output.inputId != AUDIO_IO_HANDLE_NONE) {
AudioSystem::releaseInput(portId); AudioSystem::releaseInput(output.inputId, sessionId);
} }
} }

16
services/audioflinger/Threads.cpp
Unescape View File

@ -6936,7 +6936,8 @@ status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrac
if (recordTrack->isExternalTrack()) { if (recordTrack->isExternalTrack()) {
mLock.unlock(); mLock.unlock();
bool silenced; bool silenced;
status = AudioSystem::startInput(recordTrack->portId(), &silenced); status = AudioSystem::startInput(mId, recordTrack->sessionId(),
mInDevice, recordTrack->uid(), &silenced);
mLock.lock(); mLock.lock();
// FIXME should verify that recordTrack is still in mActiveTracks // FIXME should verify that recordTrack is still in mActiveTracks
if (status != NO_ERROR) { if (status != NO_ERROR) {
@ -6968,7 +6969,7 @@ status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrac
startError: startError:
if (recordTrack->isExternalTrack()) { if (recordTrack->isExternalTrack()) {
AudioSystem::stopInput(recordTrack->portId()); AudioSystem::stopInput(mId, recordTrack->sessionId());
} }
recordTrack->clearSyncStartEvent(); recordTrack->clearSyncStartEvent();
// FIXME I wonder why we do not reset the state here? // FIXME I wonder why we do not reset the state here?
@ -7741,7 +7742,7 @@ void AudioFlinger::MmapThread::disconnect()
if (isOutput()) { if (isOutput()) {
AudioSystem::releaseOutput(mId, streamType(), mSessionId); AudioSystem::releaseOutput(mId, streamType(), mSessionId);
} else { } else {
AudioSystem::releaseInput(mPortId); AudioSystem::releaseInput(mId, mSessionId);
} }
} }
@ -7836,7 +7837,6 @@ status_t AudioFlinger::MmapThread::start(const AudioClient& client,
mSessionId, mSessionId,
client.clientPid, client.clientPid,
client.clientUid, client.clientUid,
client.packageName,
&config, &config,
AUDIO_INPUT_FLAG_MMAP_NOIRQ, AUDIO_INPUT_FLAG_MMAP_NOIRQ,
&deviceId, &deviceId,
@ -7855,7 +7855,7 @@ status_t AudioFlinger::MmapThread::start(const AudioClient& client,
} else { } else {
// TODO: Block recording for idle UIDs (b/72134552) // TODO: Block recording for idle UIDs (b/72134552)
bool silenced; bool silenced;
ret = AudioSystem::startInput(portId, &silenced); ret = AudioSystem::startInput(mId, mSessionId, mInDevice, client.clientUid, &silenced);
} }
// abort if start is rejected by audio policy manager // abort if start is rejected by audio policy manager
@ -7865,7 +7865,7 @@ status_t AudioFlinger::MmapThread::start(const AudioClient& client,
if (isOutput()) { if (isOutput()) {
AudioSystem::releaseOutput(mId, streamType(), mSessionId); AudioSystem::releaseOutput(mId, streamType(), mSessionId);
} else { } else {
AudioSystem::releaseInput(portId); AudioSystem::releaseInput(mId, mSessionId);
} }
} else { } else {
mHalStream->stop(); mHalStream->stop();
@ -7922,8 +7922,8 @@ status_t AudioFlinger::MmapThread::stop(audio_port_handle_t handle)
AudioSystem::stopOutput(mId, streamType(), track->sessionId()); AudioSystem::stopOutput(mId, streamType(), track->sessionId());
AudioSystem::releaseOutput(mId, streamType(), track->sessionId()); AudioSystem::releaseOutput(mId, streamType(), track->sessionId());
} else { } else {
AudioSystem::stopInput(track->portId()); AudioSystem::stopInput(mId, track->sessionId());
AudioSystem::releaseInput(track->portId()); AudioSystem::releaseInput(mId, track->sessionId());
} }
sp<EffectChain> chain = getEffectChain_l(track->sessionId()); sp<EffectChain> chain = getEffectChain_l(track->sessionId());

6
services/audioflinger/Tracks.cpp
Unescape View File

@ -1687,7 +1687,7 @@ void AudioFlinger::RecordThread::RecordTrack::stop()
if (thread != 0) { if (thread != 0) {
RecordThread *recordThread = (RecordThread *)thread.get(); RecordThread *recordThread = (RecordThread *)thread.get();
if (recordThread->stop(this) && isExternalTrack()) { if (recordThread->stop(this) && isExternalTrack()) {
AudioSystem::stopInput(mPortId); AudioSystem::stopInput(mThreadIoHandle, mSessionId);
} }
} }
} }
@ -1699,9 +1699,9 @@ void AudioFlinger::RecordThread::RecordTrack::destroy()
{ {
if (isExternalTrack()) { if (isExternalTrack()) {
if (mState == ACTIVE || mState == RESUMING) { if (mState == ACTIVE || mState == RESUMING) {
AudioSystem::stopInput(mPortId); AudioSystem::stopInput(mThreadIoHandle, mSessionId);
} }
AudioSystem::releaseInput(mPortId); AudioSystem::releaseInput(mThreadIoHandle, mSessionId);
} }
sp<ThreadBase> thread = mThread.promote(); sp<ThreadBase> thread = mThread.promote();
if (thread != 0) { if (thread != 0) {

61
services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
Unescape View File

@ -287,7 +287,6 @@ status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
audio_session_t session, audio_session_t session,
pid_t pid, pid_t pid,
uid_t uid, uid_t uid,
const String16& opPackageName,
const audio_config_base_t *config, const audio_config_base_t *config,
audio_input_flags_t flags, audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId, audio_port_handle_t *selectedDeviceId,
@ -368,13 +367,6 @@ status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
} }
return status; return status;
} }
sp<AudioRecordClient> client =
new AudioRecordClient(*attr, *input, uid, pid, opPackageName, session);
client->active = false;
client->isConcurrent = false;
client->isVirtualDevice = false; //TODO : update from APM->getInputForAttr()
mAudioRecordClients.add(*portId, client);
} }
if (audioPolicyEffects != 0) { if (audioPolicyEffects != 0) {
@ -387,28 +379,23 @@ status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
return NO_ERROR; return NO_ERROR;
} }
status_t AudioPolicyService::startInput(audio_port_handle_t portId, bool *silenced) status_t AudioPolicyService::startInput(audio_io_handle_t input,
audio_session_t session,
audio_devices_t device,
uid_t uid,
bool *silenced)
{ {
// If UID inactive it records silence until becoming active
*silenced = !mUidPolicy->isUidActive(uid) && !is_virtual_input_device(device);
if (mAudioPolicyManager == NULL) { if (mAudioPolicyManager == NULL) {
return NO_INIT; return NO_INIT;
} }
Mutex::Autolock _l(mLock); Mutex::Autolock _l(mLock);
ssize_t index = mAudioRecordClients.indexOfKey(portId);
if (index < 0) {
return INVALID_OPERATION;
}
sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
// If UID inactive it records silence until becoming active
*silenced = !mUidPolicy->isUidActive(client->uid) && !client->isVirtualDevice;
AudioPolicyInterface::concurrency_type__mask_t concurrency = AudioPolicyInterface::concurrency_type__mask_t concurrency =
AudioPolicyInterface::API_INPUT_CONCURRENCY_NONE; AudioPolicyInterface::API_INPUT_CONCURRENCY_NONE;
status_t status = mAudioPolicyManager->startInput(input, session, *silenced, &concurrency);
status_t status = mAudioPolicyManager->startInput(
client->input, client->session, *silenced, &concurrency);
if (status == NO_ERROR) { if (status == NO_ERROR) {
LOG_ALWAYS_FATAL_IF(concurrency & ~AudioPolicyInterface::API_INPUT_CONCURRENCY_ALL, LOG_ALWAYS_FATAL_IF(concurrency & ~AudioPolicyInterface::API_INPUT_CONCURRENCY_ALL,
@ -426,52 +413,38 @@ status_t AudioPolicyService::startInput(audio_port_handle_t portId, bool *silenc
return status; return status;
} }
status_t AudioPolicyService::stopInput(audio_port_handle_t portId) status_t AudioPolicyService::stopInput(audio_io_handle_t input,
audio_session_t session)
{ {
if (mAudioPolicyManager == NULL) { if (mAudioPolicyManager == NULL) {
return NO_INIT; return NO_INIT;
} }
Mutex::Autolock _l(mLock); Mutex::Autolock _l(mLock);
ssize_t index = mAudioRecordClients.indexOfKey(portId); return mAudioPolicyManager->stopInput(input, session);
if (index < 0) {
return INVALID_OPERATION;
}
sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
return mAudioPolicyManager->stopInput(client->input, client->session);
} }
void AudioPolicyService::releaseInput(audio_port_handle_t portId) void AudioPolicyService::releaseInput(audio_io_handle_t input,
audio_session_t session)
{ {
if (mAudioPolicyManager == NULL) { if (mAudioPolicyManager == NULL) {
return; return;
} }
sp<AudioPolicyEffects>audioPolicyEffects; sp<AudioPolicyEffects>audioPolicyEffects;
sp<AudioRecordClient> client;
{ {
Mutex::Autolock _l(mLock); Mutex::Autolock _l(mLock);
audioPolicyEffects = mAudioPolicyEffects; audioPolicyEffects = mAudioPolicyEffects;
ssize_t index = mAudioRecordClients.indexOfKey(portId);
if (index < 0) {
return;
}
client = mAudioRecordClients.valueAt(index);
mAudioRecordClients.removeItem(portId);
}
if (client == 0) {
return;
} }
if (audioPolicyEffects != 0) { if (audioPolicyEffects != 0) {
// release audio processors from the input // release audio processors from the input
status_t status = audioPolicyEffects->releaseInputEffects(client->input, client->session); status_t status = audioPolicyEffects->releaseInputEffects(input, session);
if(status != NO_ERROR) { if(status != NO_ERROR) {
ALOGW("Failed to release effects on input %d", client->input); ALOGW("Failed to release effects on input %d", input);
} }
} }
{ {
Mutex::Autolock _l(mLock); Mutex::Autolock _l(mLock);
mAudioPolicyManager->releaseInput(client->input, client->session); mAudioPolicyManager->releaseInput(input, session);
} }
} }

38
services/audiopolicy/service/AudioPolicyService.h
Unescape View File

@ -98,15 +98,19 @@ public:
audio_session_t session, audio_session_t session,
pid_t pid, pid_t pid,
uid_t uid, uid_t uid,
const String16& opPackageName,
const audio_config_base_t *config, const audio_config_base_t *config,
audio_input_flags_t flags, audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId = NULL, audio_port_handle_t *selectedDeviceId = NULL,
audio_port_handle_t *portId = NULL); audio_port_handle_t *portId = NULL);
virtual status_t startInput(audio_port_handle_t portId, virtual status_t startInput(audio_io_handle_t input,
audio_session_t session,
audio_devices_t device,
uid_t uid,
bool *silenced); bool *silenced);
virtual status_t stopInput(audio_port_handle_t portId); virtual status_t stopInput(audio_io_handle_t input,
virtual void releaseInput(audio_port_handle_t portId); audio_session_t session);
virtual void releaseInput(audio_io_handle_t input,
audio_session_t session);
virtual status_t initStreamVolume(audio_stream_type_t stream, virtual status_t initStreamVolume(audio_stream_type_t stream,
int indexMin, int indexMin,
int indexMax); int indexMax);
@ -607,31 +611,6 @@ private:
bool mAudioPortCallbacksEnabled; bool mAudioPortCallbacksEnabled;
}; };
// --- AudioRecordClient ---
// Information about each registered AudioRecord client
// (between calls to getInputForAttr() and releaseInput())
class AudioRecordClient : public RefBase {
public:
AudioRecordClient(const audio_attributes_t attributes,
const audio_io_handle_t input, uid_t uid, pid_t pid,
const String16& opPackageName, const audio_session_t session) :
attributes(attributes),
input(input), uid(uid), pid(pid),
opPackageName(opPackageName), session(session),
active(false), isConcurrent(false), isVirtualDevice(false) {}
virtual ~AudioRecordClient() {}
const audio_attributes_t attributes; // source, flags ...
const audio_io_handle_t input; // audio HAL input IO handle
const uid_t uid; // client UID
const pid_t pid; // client PID
const String16 opPackageName; // client package name
const audio_session_t session; // audio session ID
bool active; // Capture is active or inactive
bool isConcurrent; // is allowed to concurrent capture
bool isVirtualDevice; // uses vitual device: updated by APM::getInputForAttr()
};
// Internal dump utilities. // Internal dump utilities.
status_t dumpPermissionDenial(int fd); status_t dumpPermissionDenial(int fd);
@ -657,7 +636,6 @@ private:
audio_mode_t mPhoneState; audio_mode_t mPhoneState;
sp<UidPolicy> mUidPolicy; sp<UidPolicy> mUidPolicy;
DefaultKeyedVector< audio_port_handle_t, sp<AudioRecordClient> > mAudioRecordClients;
}; };
} // namespace android } // namespace android

Write Preview
Loading…
Cancel
Save