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

Merge changes from topic "more_in_recording_config"

Browse Source 
* changes:
  audo policy: more info in onRecordingConfigurationUpdate
  audo policy: add effects to record clients
gugelfrei
Eric Laurent 6 years ago committed by Android (Google) Code Review
parent 3c3c97ae53 a9f86651ea
commit 77a428b58b
17 changed files with 390 additions and 114 deletions
Show Stats Download Patch File Download Diff File

14
media/libaudioclient/AudioSystem.cpp
Unescape View File

@ -1388,9 +1388,14 @@ void AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(
}
void AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle) {
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source) {
record_config_callback cb = NULL;
{
Mutex::Autolock _l(AudioSystem::gLock);
@ -1398,7 +1403,8 @@ void AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(
}
if (cb != NULL) {
cb(event, clientInfo, clientConfig, deviceConfig, patchHandle);
cb(event, clientInfo, clientConfig, clientEffects,
deviceConfig, effects, patchHandle, source);
}
}

52
media/libaudioclient/IAudioPolicyServiceClient.cpp
Unescape View File

@ -52,12 +52,37 @@ inline void readRecordClientInfoFromParcel(const Parcel& data, record_client_inf
clientInfo->uid = (uid_t) data.readUint32();
clientInfo->session = (audio_session_t) data.readInt32();
clientInfo->source = (audio_source_t) data.readInt32();
data.read(&clientInfo->port_id, sizeof(audio_port_handle_t));
clientInfo->silenced = data.readBool();
}
inline void writeRecordClientInfoFromParcel(Parcel& data, const record_client_info_t *clientInfo) {
inline void writeRecordClientInfoToParcel(Parcel& data, const record_client_info_t *clientInfo) {
data.writeUint32((uint32_t) clientInfo->uid);
data.writeInt32((int32_t) clientInfo->session);
data.writeInt32((int32_t) clientInfo->source);
data.write(&clientInfo->port_id, sizeof(audio_port_handle_t));
data.writeBool(clientInfo->silenced);
}
inline void readEffectVectorFromParcel(const Parcel& data,
std::vector<effect_descriptor_t> *effects) {
int32_t numEffects = data.readInt32();
for (int32_t i = 0; i < numEffects; i++) {
effect_descriptor_t effect;
if (data.read(&effect, sizeof(effect_descriptor_t)) != NO_ERROR) {
break;
}
(*effects).push_back(effect);
}
}
inline void writeEffectVectorToParcel(Parcel& data, std::vector<effect_descriptor_t> effects) {
data.writeUint32((uint32_t) effects.size());
for (const auto& effect : effects) {
if (data.write(&effect, sizeof(effect_descriptor_t)) != NO_ERROR) {
break;
}
}
}
// ----------------------------------------------------------------------
@ -92,16 +117,24 @@ public:
remote()->transact(MIX_STATE_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);
}
void onRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle) {
void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source) {
Parcel data, reply;
data.writeInterfaceToken(IAudioPolicyServiceClient::getInterfaceDescriptor());
data.writeInt32(event);
writeRecordClientInfoFromParcel(data, clientInfo);
writeRecordClientInfoToParcel(data, clientInfo);
writeAudioConfigBaseToParcel(data, clientConfig);
writeEffectVectorToParcel(data, clientEffects);
writeAudioConfigBaseToParcel(data, deviceConfig);
writeEffectVectorToParcel(data, effects);
data.writeInt32(patchHandle);
data.writeInt32((int32_t) source);
remote()->transact(RECORDING_CONFIGURATION_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);
}
};
@ -139,10 +172,15 @@ status_t BnAudioPolicyServiceClient::onTransact(
audio_config_base_t deviceConfig;
readRecordClientInfoFromParcel(data, &clientInfo);
readAudioConfigBaseFromParcel(data, &clientConfig);
std::vector<effect_descriptor_t> clientEffects;
readEffectVectorFromParcel(data, &clientEffects);
readAudioConfigBaseFromParcel(data, &deviceConfig);
std::vector<effect_descriptor_t> effects;
readEffectVectorFromParcel(data, &effects);
audio_patch_handle_t patchHandle = (audio_patch_handle_t) data.readInt32();
onRecordingConfigurationUpdate(event, &clientInfo, &clientConfig, &deviceConfig,
patchHandle);
audio_source_t source = (audio_source_t) data.readInt32();
onRecordingConfigurationUpdate(event, &clientInfo, &clientConfig, clientEffects,
&deviceConfig, effects, patchHandle, source);
return NO_ERROR;
} break;
default:

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

@ -35,9 +35,14 @@ namespace android {
typedef void (*audio_error_callback)(status_t err);
typedef void (*dynamic_policy_callback)(int event, String8 regId, int val);
typedef void (*record_config_callback)(int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle);
typedef void (*record_config_callback)(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
class IAudioFlinger;
class IAudioPolicyService;
@ -448,9 +453,13 @@ private:
virtual void onAudioPatchListUpdate();
virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state);
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle);
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
private:
Mutex mLock;

9
media/libaudioclient/include/media/IAudioPolicyServiceClient.h
Unescape View File

@ -17,10 +17,12 @@
#ifndef ANDROID_IAUDIOPOLICYSERVICECLIENT_H
#define ANDROID_IAUDIOPOLICYSERVICECLIENT_H
#include <vector>
#include <utils/RefBase.h>
#include <binder/IInterface.h>
#include <system/audio.h>
#include <system/audio_effect.h>
namespace android {
@ -30,6 +32,8 @@ struct record_client_info {
uid_t uid;
audio_session_t session;
audio_source_t source;
audio_port_handle_t port_id;
bool silenced;
};
typedef struct record_client_info record_client_info_t;
@ -51,8 +55,11 @@ public:
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle) = 0;
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source) = 0;
};

11
services/audiopolicy/AudioPolicyInterface.h
Unescape View File

@ -332,10 +332,13 @@ public:
virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state) = 0;
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const struct audio_config_base *clientConfig,
const struct audio_config_base *deviceConfig,
audio_patch_handle_t patchHandle) = 0;
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source) = 0;
};
extern "C" AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface);

12
services/audiopolicy/common/managerdefinitions/include/AudioInputDescriptor.h
Unescape View File

@ -23,6 +23,7 @@
#include "AudioIODescriptorInterface.h"
#include "AudioPort.h"
#include "ClientDescriptor.h"
#include "EffectDescriptor.h"
namespace android {
@ -62,7 +63,8 @@ public:
bool isSoundTrigger() const;
void setClientActive(const sp<RecordClientDescriptor>& client, bool active);
int32_t activeCount() { return mGlobalActiveCount; }
void trackEffectEnabled(const sp<EffectDescriptor> &effect, bool enabled);
EffectDescriptorCollection getEnabledEffects() const;
// implementation of AudioIODescriptorInterface
audio_config_base_t getConfig() const override;
audio_patch_handle_t getPatchHandle() const override;
@ -86,6 +88,11 @@ public:
RecordClientVector clientsList(bool activeOnly = false,
audio_source_t source = AUDIO_SOURCE_DEFAULT, bool preferredDeviceOnly = false) const;
void setAppState(uid_t uid, app_state_t state);
// implementation of ClientMapHandler<RecordClientDescriptor>
void addClient(const sp<RecordClientDescriptor> &client) override;
private:
void updateClientRecordingConfiguration(int event, const sp<RecordClientDescriptor>& client);
@ -101,6 +108,7 @@ public:
SortedVector<audio_session_t> mPreemptedSessions;
AudioPolicyClientInterface * const mClientInterface;
int32_t mGlobalActiveCount = 0; // non-client-specific activity ref count
EffectDescriptorCollection mEnabledEffects;
};
class AudioInputCollection :
@ -126,6 +134,8 @@ public:
sp<AudioInputDescriptor> getInputForClient(audio_port_handle_t portId);
void trackEffectEnabled(const sp<EffectDescriptor> &effect, bool enabled);
void dump(String8 *dst) const;
};

7
services/audiopolicy/common/managerdefinitions/include/ClientDescriptor.h
Unescape View File

@ -28,6 +28,7 @@
#include <utils/RefBase.h>
#include <utils/String8.h>
#include "AudioPatch.h"
#include "EffectDescriptor.h"
#include "RoutingStrategy.h"
namespace android {
@ -119,13 +120,15 @@ public:
void setAppState(app_state_t appState) { mAppState = appState; }
app_state_t appState() { return mAppState; }
bool isSilenced() const { return mAppState == APP_STATE_IDLE; }
void trackEffectEnabled(const sp<EffectDescriptor> &effect, bool enabled);
EffectDescriptorCollection getEnabledEffects() const { return mEnabledEffects; }
private:
const audio_source_t mSource;
const audio_input_flags_t mFlags;
const bool mIsSoundTrigger;
app_state_t mAppState;
EffectDescriptorCollection mEnabledEffects;
};
class SourceClientDescriptor: public TrackClientDescriptor
@ -172,7 +175,7 @@ public:
virtual ~ClientMapHandler() = default;
// Track client management
void addClient(const sp<T> &client) {
virtual void addClient(const sp<T> &client) {
const audio_port_handle_t portId = client->portId();
LOG_ALWAYS_FATAL_IF(!mClients.emplace(portId, client).second,
"%s(%d): attempting to add client that already exists", __func__, portId);

10
services/audiopolicy/common/managerdefinitions/include/EffectDescriptor.h
Unescape View File

@ -25,12 +25,12 @@
namespace android {
class EffectDescriptor : public RefBase
{
public:
void dump(String8 *dst) const;
void dump(String8 *dst, int spaces = 0) const;
int mId; // effect unique ID
int mIo; // io the effect is attached to
routing_strategy mStrategy; // routing strategy the effect is associated to
int mSession; // audio session the effect is on
@ -46,12 +46,14 @@ public:
status_t registerEffect(const effect_descriptor_t *desc, audio_io_handle_t io,
uint32_t strategy, int session, int id);
status_t unregisterEffect(int id);
sp<EffectDescriptor> getEffect(int id) const;
status_t setEffectEnabled(int id, bool enabled);
bool isEffectEnabled(int id) const;
uint32_t getMaxEffectsCpuLoad() const;
uint32_t getMaxEffectsMemory() const;
bool isNonOffloadableEffectEnabled();
bool isNonOffloadableEffectEnabled() const;
void dump(String8 *dst) const;
void dump(String8 *dst, int spaces = 0, bool verbose = true) const;
private:
status_t setEffectEnabled(const sp<EffectDescriptor> &effectDesc, bool enabled);

92
services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp
Unescape View File

@ -269,6 +269,16 @@ void AudioInputDescriptor::close()
}
}
void AudioInputDescriptor::addClient(const sp<RecordClientDescriptor> &client) {
ClientMapHandler<RecordClientDescriptor>::addClient(client);
for (size_t i = 0; i < mEnabledEffects.size(); i++) {
if (mEnabledEffects.valueAt(i)->mSession == client->session()) {
client->trackEffectEnabled(mEnabledEffects.valueAt(i), true);
}
}
}
void AudioInputDescriptor::setClientActive(const sp<RecordClientDescriptor>& client, bool active)
{
LOG_ALWAYS_FATAL_IF(getClient(client->portId()) == nullptr,
@ -312,11 +322,26 @@ void AudioInputDescriptor::updateClientRecordingConfiguration(
int event, const sp<RecordClientDescriptor>& client)
{
const audio_config_base_t sessionConfig = client->config();
const record_client_info_t recordClientInfo{client->uid(), client->session(), client->source()};
const record_client_info_t recordClientInfo{client->uid(), client->session(),
client->source(), client->portId(),
client->isSilenced()};
const audio_config_base_t config = getConfig();
mClientInterface->onRecordingConfigurationUpdate(event,
&recordClientInfo, &sessionConfig,
&config, mPatchHandle);
std::vector<effect_descriptor_t> clientEffects;
EffectDescriptorCollection effectsList = client->getEnabledEffects();
for (size_t i = 0; i < effectsList.size(); i++) {
clientEffects.push_back(effectsList.valueAt(i)->mDesc);
}
std::vector<effect_descriptor_t> effects;
effectsList = getEnabledEffects();
for (size_t i = 0; i < effectsList.size(); i++) {
effects.push_back(effectsList.valueAt(i)->mDesc);
}
mClientInterface->onRecordingConfigurationUpdate(event, &recordClientInfo, &sessionConfig,
clientEffects, &config, effects,
mPatchHandle, source());
}
RecordClientVector AudioInputDescriptor::getClientsForSession(
@ -345,6 +370,53 @@ RecordClientVector AudioInputDescriptor::clientsList(bool activeOnly, audio_sour
return clients;
}
void AudioInputDescriptor::trackEffectEnabled(const sp<EffectDescriptor> &effect,
bool enabled)
{
if (enabled) {
mEnabledEffects.replaceValueFor(effect->mId, effect);
} else {
mEnabledEffects.removeItem(effect->mId);
}
RecordClientVector clients = getClientsForSession((audio_session_t)effect->mSession);
for (const auto& client : clients) {
sp<EffectDescriptor> clientEffect = client->getEnabledEffects().getEffect(effect->mId);
bool changed = (enabled && clientEffect == nullptr)
|| (!enabled && clientEffect != nullptr);
client->trackEffectEnabled(effect, enabled);
if (changed && client->active()) {
updateClientRecordingConfiguration(RECORD_CONFIG_EVENT_START, client);
}
}
}
EffectDescriptorCollection AudioInputDescriptor::getEnabledEffects() const
{
EffectDescriptorCollection enabledEffects;
// report effects for highest priority active source as applied to all clients
RecordClientVector clients =
clientsList(true /*activeOnly*/, source(), false /*preferredDeviceOnly*/);
if (clients.size() > 0) {
enabledEffects = clients[0]->getEnabledEffects();
}
return enabledEffects;
}
void AudioInputDescriptor::setAppState(uid_t uid, app_state_t state) {
RecordClientVector clients = clientsList(false /*activeOnly*/);
for (const auto& client : clients) {
if (uid == client->uid()) {
bool wasSilenced = client->isSilenced();
client->setAppState(state);
if (client->active() && wasSilenced != client->isSilenced()) {
updateClientRecordingConfiguration(RECORD_CONFIG_EVENT_START, client);
}
}
}
}
void AudioInputDescriptor::dump(String8 *dst) const
{
dst->appendFormat(" ID: %d\n", getId());
@ -352,6 +424,7 @@ void AudioInputDescriptor::dump(String8 *dst) const
dst->appendFormat(" Format: %d\n", mFormat);
dst->appendFormat(" Channels: %08x\n", mChannelMask);
dst->appendFormat(" Devices %08x\n", mDevice);
getEnabledEffects().dump(dst, 1 /*spaces*/, false /*verbose*/);
dst->append(" AudioRecord Clients:\n");
ClientMapHandler<RecordClientDescriptor>::dump(dst);
dst->append("\n");
@ -424,6 +497,17 @@ sp<AudioInputDescriptor> AudioInputCollection::getInputForClient(audio_port_hand
return 0;
}
void AudioInputCollection::trackEffectEnabled(const sp<EffectDescriptor> &effect,
bool enabled)
{
for (size_t i = 0; i < size(); i++) {
sp<AudioInputDescriptor> inputDesc = valueAt(i);
if (inputDesc->mIoHandle == effect->mIo) {
return inputDesc->trackEffectEnabled(effect, enabled);
}
}
}
void AudioInputCollection::dump(String8 *dst) const
{
dst->append("\nInputs dump:\n");

10
services/audiopolicy/common/managerdefinitions/src/ClientDescriptor.cpp
Unescape View File

@ -63,10 +63,20 @@ std::string TrackClientDescriptor::toShortString() const
return ss.str();
}
void RecordClientDescriptor::trackEffectEnabled(const sp<EffectDescriptor> &effect, bool enabled)
{
if (enabled) {
mEnabledEffects.replaceValueFor(effect->mId, effect);
} else {
mEnabledEffects.removeItem(effect->mId);
}
}
void RecordClientDescriptor::dump(String8 *dst, int spaces, int index) const
{
ClientDescriptor::dump(dst, spaces, index);
dst->appendFormat("%*s- Source: %d flags: %08x\n", spaces, "", mSource, mFlags);
mEnabledEffects.dump(dst, spaces + 2 /*spaces*/, false /*verbose*/);
}
SourceClientDescriptor::SourceClientDescriptor(audio_port_handle_t portId, uid_t uid,

65
services/audiopolicy/common/managerdefinitions/src/EffectDescriptor.cpp
Unescape View File

@ -22,13 +22,13 @@
namespace android {
void EffectDescriptor::dump(String8 *dst) const
void EffectDescriptor::dump(String8 *dst, int spaces) const
{
dst->appendFormat(" I/O: %d\n", mIo);
dst->appendFormat(" Strategy: %d\n", mStrategy);
dst->appendFormat(" Session: %d\n", mSession);
dst->appendFormat(" Name: %s\n", mDesc.name);
dst->appendFormat(" %s\n", mEnabled ? "Enabled" : "Disabled");
dst->appendFormat("%*sI/O: %d\n", spaces, "", mIo);
dst->appendFormat("%*sStrategy: %d\n", spaces, "", mStrategy);
dst->appendFormat("%*sSession: %d\n", spaces, "", mSession);
dst->appendFormat("%*sName: %s\n", spaces, "", mDesc.name);
dst->appendFormat("%*s%s\n", spaces, "", mEnabled ? "Enabled" : "Disabled");
}
EffectDescriptorCollection::EffectDescriptorCollection() :
@ -45,6 +45,11 @@ status_t EffectDescriptorCollection::registerEffect(const effect_descriptor_t *d
int session,
int id)
{
if (getEffect(id) != nullptr) {
ALOGW("%s effect %s already registered", __FUNCTION__, desc->name);
return INVALID_OPERATION;
}
if (mTotalEffectsMemory + desc->memoryUsage > getMaxEffectsMemory()) {
ALOGW("registerEffect() memory limit exceeded for Fx %s, Memory %d KB",
desc->name, desc->memoryUsage);
@ -60,6 +65,7 @@ status_t EffectDescriptorCollection::registerEffect(const effect_descriptor_t *d
sp<EffectDescriptor> effectDesc = new EffectDescriptor();
memcpy (&effectDesc->mDesc, desc, sizeof(effect_descriptor_t));
effectDesc->mId = id;
effectDesc->mIo = io;
effectDesc->mStrategy = static_cast<routing_strategy>(strategy);
effectDesc->mSession = session;
@ -70,17 +76,22 @@ status_t EffectDescriptorCollection::registerEffect(const effect_descriptor_t *d
return NO_ERROR;
}
status_t EffectDescriptorCollection::unregisterEffect(int id)
sp<EffectDescriptor> EffectDescriptorCollection::getEffect(int id) const
{
ssize_t index = indexOfKey(id);
if (index < 0) {
ALOGW("unregisterEffect() unknown effect ID %d", id);
return INVALID_OPERATION;
return nullptr;
}
return valueAt(index);
}
sp<EffectDescriptor> effectDesc = valueAt(index);
setEffectEnabled(effectDesc, false);
status_t EffectDescriptorCollection::unregisterEffect(int id)
{
sp<EffectDescriptor> effectDesc = getEffect(id);
if (effectDesc == nullptr) {
ALOGW("%s unknown effect ID %d", __FUNCTION__, id);
return INVALID_OPERATION;
}
if (mTotalEffectsMemory < effectDesc->mDesc.memoryUsage) {
ALOGW("unregisterEffect() memory %d too big for total %d",
@ -107,6 +118,14 @@ status_t EffectDescriptorCollection::setEffectEnabled(int id, bool enabled)
return setEffectEnabled(valueAt(index), enabled);
}
bool EffectDescriptorCollection::isEffectEnabled(int id) const
{
ssize_t index = indexOfKey(id);
if (index < 0) {
return false;
}
return valueAt(index)->mEnabled;
}
status_t EffectDescriptorCollection::setEffectEnabled(const sp<EffectDescriptor> &effectDesc,
bool enabled)
@ -138,7 +157,7 @@ status_t EffectDescriptorCollection::setEffectEnabled(const sp<EffectDescriptor>
return NO_ERROR;
}
bool EffectDescriptorCollection::isNonOffloadableEffectEnabled()
bool EffectDescriptorCollection::isNonOffloadableEffectEnabled() const
{
for (size_t i = 0; i < size(); i++) {
sp<EffectDescriptor> effectDesc = valueAt(i);
@ -162,15 +181,21 @@ uint32_t EffectDescriptorCollection::getMaxEffectsMemory() const
return MAX_EFFECTS_MEMORY;
}
void EffectDescriptorCollection::dump(String8 *dst) const
void EffectDescriptorCollection::dump(String8 *dst, int spaces, bool verbose) const
{
dst->appendFormat(
"\nTotal Effects CPU: %f MIPS, Total Effects memory: %d KB, Max memory used: %d KB\n",
(float)mTotalEffectsCpuLoad/10, mTotalEffectsMemory, mTotalEffectsMemoryMaxUsed);
dst->append("Registered effects:\n");
if (verbose) {
dst->appendFormat(
"\n%*sTotal Effects CPU: %f MIPS, "
"Total Effects memory: %d KB, Max memory used: %d KB\n",
spaces, "",
(float) mTotalEffectsCpuLoad / 10,
mTotalEffectsMemory,
mTotalEffectsMemoryMaxUsed);
}
dst->appendFormat("%*sEffects:\n", spaces, "");
for (size_t i = 0; i < size(); i++) {
dst->appendFormat("- Effect %d dump:\n", keyAt(i));
valueAt(i)->dump(dst);
dst->appendFormat("%*s- Effect %d:\n", spaces, "", keyAt(i));
valueAt(i)->dump(dst, spaces + 2);
}
}

35
services/audiopolicy/managerdefault/AudioPolicyManager.cpp
Unescape View File

@ -2423,6 +2423,33 @@ status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc,
return mEffects.registerEffect(desc, io, strategy, session, id);
}
status_t AudioPolicyManager::unregisterEffect(int id)
{
if (mEffects.getEffect(id) == nullptr) {
return INVALID_OPERATION;
}
if (mEffects.isEffectEnabled(id)) {
ALOGW("%s effect %d enabled", __FUNCTION__, id);
setEffectEnabled(id, false);
}
return mEffects.unregisterEffect(id);
}
status_t AudioPolicyManager::setEffectEnabled(int id, bool enabled)
{
sp<EffectDescriptor> effect = mEffects.getEffect(id);
if (effect == nullptr) {
return INVALID_OPERATION;
}
status_t status = mEffects.setEffectEnabled(id, enabled);
if (status == NO_ERROR) {
mInputs.trackEffectEnabled(effect, enabled);
}
return status;
}
bool AudioPolicyManager::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
{
bool active = false;
@ -3706,13 +3733,11 @@ status_t AudioPolicyManager::setSurroundFormatEnabled(audio_format_t audioFormat
void AudioPolicyManager::setAppState(uid_t uid, app_state_t state)
{
Vector<sp<AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs();
ALOGV("%s(uid:%d, state:%d)", __func__, uid, state);
for (size_t i = 0; i < activeInputs.size(); i++) {
sp<AudioInputDescriptor> activeDesc = activeInputs[i];
RecordClientVector clients = activeDesc->clientsList(true /*activeOnly*/);
for (size_t i = 0; i < mInputs.size(); i++) {
sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
RecordClientVector clients = inputDesc->clientsList(false /*activeOnly*/);
for (const auto& client : clients) {
if (uid == client->uid()) {
client->setAppState(state);

10
services/audiopolicy/managerdefault/AudioPolicyManager.h
Unescape View File

@ -164,14 +164,8 @@ public:
uint32_t strategy,
int session,
int id);
virtual status_t unregisterEffect(int id)
{
return mEffects.unregisterEffect(id);
}
virtual status_t setEffectEnabled(int id, bool enabled)
{
return mEffects.setEffectEnabled(id, enabled);
}
virtual status_t unregisterEffect(int id);
virtual status_t setEffectEnabled(int id, bool enabled);
virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
// return whether a stream is playing remotely, override to change the definition of

13
services/audiopolicy/service/AudioPolicyClientImpl.cpp
Unescape View File

@ -209,12 +209,17 @@ void AudioPolicyService::AudioPolicyClient::onDynamicPolicyMixStateUpdate(
}
void AudioPolicyService::AudioPolicyClient::onRecordingConfigurationUpdate(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle)
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
mAudioPolicyService->onRecordingConfigurationUpdate(event, clientInfo,
clientConfig, deviceConfig, patchHandle);
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId(audio_unique_id_use_t use)

64
services/audiopolicy/service/AudioPolicyService.cpp
Unescape View File

@ -215,22 +215,34 @@ void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, i
}
}
void AudioPolicyService::onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo, const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle)
void AudioPolicyService::onRecordingConfigurationUpdate(
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
clientConfig, deviceConfig, patchHandle);
}
void AudioPolicyService::doOnRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo, const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle)
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
void AudioPolicyService::doOnRecordingConfigurationUpdate(
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
Mutex::Autolock _l(mNotificationClientsLock);
for (size_t i = 0; i < mNotificationClients.size(); i++) {
mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
clientConfig, deviceConfig, patchHandle);
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
}
@ -298,13 +310,18 @@ void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
}
void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle)
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
mAudioPolicyServiceClient->onRecordingConfigurationUpdate(event, clientInfo,
clientConfig, deviceConfig, patchHandle);
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
}
@ -1071,8 +1088,9 @@ bool AudioPolicyService::AudioCommandThread::threadLoop()
}
mLock.unlock();
svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
&data->mClientConfig, &data->mDeviceConfig,
data->mPatchHandle);
&data->mClientConfig, data->mClientEffects,
&data->mDeviceConfig, data->mEffects,
data->mPatchHandle, data->mSource);
mLock.lock();
} break;
default:
@ -1307,9 +1325,14 @@ void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
}
void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle)
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
sp<AudioCommand>command = new AudioCommand();
command->mCommand = RECORDING_CONFIGURATION_UPDATE;
@ -1317,8 +1340,11 @@ void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand
data->mEvent = event;
data->mClientInfo = *clientInfo;
data->mClientConfig = *clientConfig;
data->mClientEffects = clientEffects;
data->mDeviceConfig = *deviceConfig;
data->mEffects = effects;
data->mPatchHandle = patchHandle;
data->mSource = source;
command->mParam = data;
ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
event, clientInfo->source, clientInfo->uid);

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

@ -240,12 +240,22 @@ public:
void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
void onRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle);
void doOnRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle);
void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
void doOnRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
private:
AudioPolicyService() ANDROID_API;
@ -409,13 +419,17 @@ private:
void updateAudioPatchListCommand();
status_t setAudioPortConfigCommand(const struct audio_port_config *config,
int delayMs);
void dynamicPolicyMixStateUpdateCommand(const String8& regId, int32_t state);
void dynamicPolicyMixStateUpdateCommand(const String8& regId,
int32_t state);
void recordingConfigurationUpdateCommand(
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle);
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
void insertCommand_l(AudioCommand *command, int delayMs = 0);
private:
class AudioCommandData;
@ -500,8 +514,11 @@ private:
int mEvent;
record_client_info_t mClientInfo;
struct audio_config_base mClientConfig;
std::vector<effect_descriptor_t> mClientEffects;
struct audio_config_base mDeviceConfig;
std::vector<effect_descriptor_t> mEffects;
audio_patch_handle_t mPatchHandle;
audio_source_t mSource;
};
Mutex mLock;
@ -605,9 +622,13 @@ private:
virtual void onAudioPatchListUpdate();
virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state);
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle);
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use);
@ -625,12 +646,17 @@ private:
void onAudioPortListUpdate();
void onAudioPatchListUpdate();
void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
void onDynamicPolicyMixStateUpdate(const String8& regId,
int32_t state);
void onRecordingConfigurationUpdate(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle);
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
void setAudioPortCallbacksEnabled(bool enabled);
uid_t uid() {

13
services/audiopolicy/tests/AudioPolicyTestClient.h
Unescape View File

@ -75,11 +75,14 @@ public:
void onAudioPatchListUpdate() override { }
audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t /*use*/) override { return 0; }
void onDynamicPolicyMixStateUpdate(String8 /*regId*/, int32_t /*state*/) override { }
void onRecordingConfigurationUpdate(int /*event*/,
const record_client_info_t* /*clientInfo*/,
const struct audio_config_base* /*clientConfig*/,
const struct audio_config_base* /*deviceConfig*/,
audio_patch_handle_t /*patchHandle*/) override { }
void onRecordingConfigurationUpdate(int event __unused,
const record_client_info_t *clientInfo __unused,
const audio_config_base_t *clientConfig __unused,
std::vector<effect_descriptor_t> clientEffects __unused,
const audio_config_base_t *deviceConfig __unused,
std::vector<effect_descriptor_t> effects __unused,
audio_patch_handle_t patchHandle __unused,
audio_source_t source __unused) override { }
};
} // namespace android

Write Preview
Loading…
Cancel
Save