Move TypeConverter into a shared library
This will be needed for the default implementation of the audio HAL
in TREBLE for parsing supported formats etc. provided by HAL in
a form of string literals.
As a bonus, remove some hand-written type conversions in AudioFlinger
used in dumps.
Example changes in the dump output:
HAL format: 0x1 (pcm16) ==> HAL format: 0x1 (AUDIO_FORMAT_PCM_16_BIT)
Processing format: 0x5 (pcmfloat) ==> Processing format: 0x5 (AUDIO_FORMAT_PCM_FLOAT)
Output device: 0x2 (SPEAKER) ==> Output device: 0x2 (AUDIO_DEVICE_OUT_SPEAKER)
Input device: 0 (NONE) ==> Input device: 0 (AUDIO_DEVICE_NONE)
AudioStreamOut: 0x... flags 0x6 (PRIMARY|FAST) ==>
AudioStreamOut: 0x... flags 0x6 (AUDIO_OUTPUT_FLAG_PRIMARY|AUDIO_OUTPUT_FLAG_FAST)
Test: make & run
Change-Id: I9cde640e6827b7aa6d62e9caade9e738227e299f
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 7e10e48..4d2049e 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -35,6 +35,7 @@
#include <media/audiohal/DevicesFactoryHalInterface.h>
#include <media/audiohal/EffectsFactoryHalInterface.h>
#include <media/AudioParameter.h>
+#include <media/TypeConverter.h>
#include <memunreachable/memunreachable.h>
#include <utils/String16.h>
#include <utils/threads.h>
@@ -113,38 +114,10 @@
// ----------------------------------------------------------------------------
-const char *formatToString(audio_format_t format) {
- switch (audio_get_main_format(format)) {
- case AUDIO_FORMAT_PCM:
- switch (format) {
- case AUDIO_FORMAT_PCM_16_BIT: return "pcm16";
- case AUDIO_FORMAT_PCM_8_BIT: return "pcm8";
- case AUDIO_FORMAT_PCM_32_BIT: return "pcm32";
- case AUDIO_FORMAT_PCM_8_24_BIT: return "pcm8.24";
- case AUDIO_FORMAT_PCM_FLOAT: return "pcmfloat";
- case AUDIO_FORMAT_PCM_24_BIT_PACKED: return "pcm24";
- default:
- break;
- }
- break;
- case AUDIO_FORMAT_MP3: return "mp3";
- case AUDIO_FORMAT_AMR_NB: return "amr-nb";
- case AUDIO_FORMAT_AMR_WB: return "amr-wb";
- case AUDIO_FORMAT_AAC: return "aac";
- case AUDIO_FORMAT_HE_AAC_V1: return "he-aac-v1";
- case AUDIO_FORMAT_HE_AAC_V2: return "he-aac-v2";
- case AUDIO_FORMAT_VORBIS: return "vorbis";
- case AUDIO_FORMAT_OPUS: return "opus";
- case AUDIO_FORMAT_AC3: return "ac-3";
- case AUDIO_FORMAT_E_AC3: return "e-ac-3";
- case AUDIO_FORMAT_IEC61937: return "iec61937";
- case AUDIO_FORMAT_DTS: return "dts";
- case AUDIO_FORMAT_DTS_HD: return "dts-hd";
- case AUDIO_FORMAT_DOLBY_TRUEHD: return "dolby-truehd";
- default:
- break;
- }
- return "unknown";
+std::string formatToString(audio_format_t format) {
+ std::string result;
+ FormatConverter::toString(format, result);
+ return result;
}
// ----------------------------------------------------------------------------
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index 6c58613..e9c0f93 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -773,10 +773,10 @@
#undef INCLUDING_FROM_AUDIOFLINGER_H
-const char *formatToString(audio_format_t format);
-String8 inputFlagsToString(audio_input_flags_t flags);
-String8 outputFlagsToString(audio_output_flags_t flags);
-String8 devicesToString(audio_devices_t devices);
+std::string formatToString(audio_format_t format);
+std::string inputFlagsToString(audio_input_flags_t flags);
+std::string outputFlagsToString(audio_output_flags_t flags);
+std::string devicesToString(audio_devices_t devices);
const char *sourceToString(audio_source_t source);
// ----------------------------------------------------------------------------
diff --git a/services/audioflinger/Effects.cpp b/services/audioflinger/Effects.cpp
index 96d9f97..b03141c 100644
--- a/services/audioflinger/Effects.cpp
+++ b/services/audioflinger/Effects.cpp
@@ -1047,7 +1047,7 @@
mConfig.inputCfg.samplingRate,
mConfig.inputCfg.channels,
mConfig.inputCfg.format,
- formatToString((audio_format_t)mConfig.inputCfg.format),
+ formatToString((audio_format_t)mConfig.inputCfg.format).c_str(),
mConfig.inputCfg.buffer.raw);
result.append(buffer);
@@ -1059,7 +1059,7 @@
mConfig.outputCfg.samplingRate,
mConfig.outputCfg.channels,
mConfig.outputCfg.format,
- formatToString((audio_format_t)mConfig.outputCfg.format));
+ formatToString((audio_format_t)mConfig.outputCfg.format).c_str());
result.append(buffer);
snprintf(buffer, SIZE, "\t\t%zu Clients:\n", mHandles.size());
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 4ae5a02..5376540 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -29,6 +29,7 @@
#include <cutils/properties.h>
#include <media/AudioParameter.h>
#include <media/AudioResamplerPublic.h>
+#include <media/TypeConverter.h>
#include <utils/Log.h>
#include <utils/Trace.h>
@@ -449,168 +450,28 @@
}
}
-String8 devicesToString(audio_devices_t devices)
+std::string devicesToString(audio_devices_t devices)
{
- static const struct mapping {
- audio_devices_t mDevices;
- const char * mString;
- } mappingsOut[] = {
- {AUDIO_DEVICE_OUT_EARPIECE, "EARPIECE"},
- {AUDIO_DEVICE_OUT_SPEAKER, "SPEAKER"},
- {AUDIO_DEVICE_OUT_WIRED_HEADSET, "WIRED_HEADSET"},
- {AUDIO_DEVICE_OUT_WIRED_HEADPHONE, "WIRED_HEADPHONE"},
- {AUDIO_DEVICE_OUT_BLUETOOTH_SCO, "BLUETOOTH_SCO"},
- {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET, "BLUETOOTH_SCO_HEADSET"},
- {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT, "BLUETOOTH_SCO_CARKIT"},
- {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP, "BLUETOOTH_A2DP"},
- {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES,"BLUETOOTH_A2DP_HEADPHONES"},
- {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, "BLUETOOTH_A2DP_SPEAKER"},
- {AUDIO_DEVICE_OUT_AUX_DIGITAL, "AUX_DIGITAL"},
- {AUDIO_DEVICE_OUT_HDMI, "HDMI"},
- {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET,"ANLG_DOCK_HEADSET"},
- {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET,"DGTL_DOCK_HEADSET"},
- {AUDIO_DEVICE_OUT_USB_ACCESSORY, "USB_ACCESSORY"},
- {AUDIO_DEVICE_OUT_USB_DEVICE, "USB_DEVICE"},
- {AUDIO_DEVICE_OUT_TELEPHONY_TX, "TELEPHONY_TX"},
- {AUDIO_DEVICE_OUT_LINE, "LINE"},
- {AUDIO_DEVICE_OUT_HDMI_ARC, "HDMI_ARC"},
- {AUDIO_DEVICE_OUT_SPDIF, "SPDIF"},
- {AUDIO_DEVICE_OUT_FM, "FM"},
- {AUDIO_DEVICE_OUT_AUX_LINE, "AUX_LINE"},
- {AUDIO_DEVICE_OUT_SPEAKER_SAFE, "SPEAKER_SAFE"},
- {AUDIO_DEVICE_OUT_IP, "IP"},
- {AUDIO_DEVICE_OUT_BUS, "BUS"},
- {AUDIO_DEVICE_NONE, "NONE"}, // must be last
- }, mappingsIn[] = {
- {AUDIO_DEVICE_IN_COMMUNICATION, "COMMUNICATION"},
- {AUDIO_DEVICE_IN_AMBIENT, "AMBIENT"},
- {AUDIO_DEVICE_IN_BUILTIN_MIC, "BUILTIN_MIC"},
- {AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, "BLUETOOTH_SCO_HEADSET"},
- {AUDIO_DEVICE_IN_WIRED_HEADSET, "WIRED_HEADSET"},
- {AUDIO_DEVICE_IN_AUX_DIGITAL, "AUX_DIGITAL"},
- {AUDIO_DEVICE_IN_VOICE_CALL, "VOICE_CALL"},
- {AUDIO_DEVICE_IN_TELEPHONY_RX, "TELEPHONY_RX"},
- {AUDIO_DEVICE_IN_BACK_MIC, "BACK_MIC"},
- {AUDIO_DEVICE_IN_REMOTE_SUBMIX, "REMOTE_SUBMIX"},
- {AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET, "ANLG_DOCK_HEADSET"},
- {AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET, "DGTL_DOCK_HEADSET"},
- {AUDIO_DEVICE_IN_USB_ACCESSORY, "USB_ACCESSORY"},
- {AUDIO_DEVICE_IN_USB_DEVICE, "USB_DEVICE"},
- {AUDIO_DEVICE_IN_FM_TUNER, "FM_TUNER"},
- {AUDIO_DEVICE_IN_TV_TUNER, "TV_TUNER"},
- {AUDIO_DEVICE_IN_LINE, "LINE"},
- {AUDIO_DEVICE_IN_SPDIF, "SPDIF"},
- {AUDIO_DEVICE_IN_BLUETOOTH_A2DP, "BLUETOOTH_A2DP"},
- {AUDIO_DEVICE_IN_LOOPBACK, "LOOPBACK"},
- {AUDIO_DEVICE_IN_IP, "IP"},
- {AUDIO_DEVICE_IN_BUS, "BUS"},
- {AUDIO_DEVICE_NONE, "NONE"}, // must be last
- };
- String8 result;
- audio_devices_t allDevices = AUDIO_DEVICE_NONE;
- const mapping *entry;
+ std::string result;
if (devices & AUDIO_DEVICE_BIT_IN) {
- devices &= ~AUDIO_DEVICE_BIT_IN;
- entry = mappingsIn;
+ InputDeviceConverter::maskToString(devices, result);
} else {
- entry = mappingsOut;
- }
- for ( ; entry->mDevices != AUDIO_DEVICE_NONE; entry++) {
- allDevices = (audio_devices_t) (allDevices | entry->mDevices);
- if (devices & entry->mDevices) {
- if (!result.isEmpty()) {
- result.append("|");
- }
- result.append(entry->mString);
- }
- }
- if (devices & ~allDevices) {
- if (!result.isEmpty()) {
- result.append("|");
- }
- result.appendFormat("0x%X", devices & ~allDevices);
- }
- if (result.isEmpty()) {
- result.append(entry->mString);
+ OutputDeviceConverter::maskToString(devices, result);
}
return result;
}
-String8 inputFlagsToString(audio_input_flags_t flags)
+std::string inputFlagsToString(audio_input_flags_t flags)
{
- static const struct mapping {
- audio_input_flags_t mFlag;
- const char * mString;
- } mappings[] = {
- {AUDIO_INPUT_FLAG_FAST, "FAST"},
- {AUDIO_INPUT_FLAG_HW_HOTWORD, "HW_HOTWORD"},
- {AUDIO_INPUT_FLAG_RAW, "RAW"},
- {AUDIO_INPUT_FLAG_SYNC, "SYNC"},
- {AUDIO_INPUT_FLAG_NONE, "NONE"}, // must be last
- };
- String8 result;
- audio_input_flags_t allFlags = AUDIO_INPUT_FLAG_NONE;
- const mapping *entry;
- for (entry = mappings; entry->mFlag != AUDIO_INPUT_FLAG_NONE; entry++) {
- allFlags = (audio_input_flags_t) (allFlags | entry->mFlag);
- if (flags & entry->mFlag) {
- if (!result.isEmpty()) {
- result.append("|");
- }
- result.append(entry->mString);
- }
- }
- if (flags & ~allFlags) {
- if (!result.isEmpty()) {
- result.append("|");
- }
- result.appendFormat("0x%X", flags & ~allFlags);
- }
- if (result.isEmpty()) {
- result.append(entry->mString);
- }
+ std::string result;
+ InputFlagConverter::maskToString(flags, result);
return result;
}
-String8 outputFlagsToString(audio_output_flags_t flags)
+std::string outputFlagsToString(audio_output_flags_t flags)
{
- static const struct mapping {
- audio_output_flags_t mFlag;
- const char * mString;
- } mappings[] = {
- {AUDIO_OUTPUT_FLAG_DIRECT, "DIRECT"},
- {AUDIO_OUTPUT_FLAG_PRIMARY, "PRIMARY"},
- {AUDIO_OUTPUT_FLAG_FAST, "FAST"},
- {AUDIO_OUTPUT_FLAG_DEEP_BUFFER, "DEEP_BUFFER"},
- {AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD,"COMPRESS_OFFLOAD"},
- {AUDIO_OUTPUT_FLAG_NON_BLOCKING, "NON_BLOCKING"},
- {AUDIO_OUTPUT_FLAG_HW_AV_SYNC, "HW_AV_SYNC"},
- {AUDIO_OUTPUT_FLAG_RAW, "RAW"},
- {AUDIO_OUTPUT_FLAG_SYNC, "SYNC"},
- {AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO, "IEC958_NONAUDIO"},
- {AUDIO_OUTPUT_FLAG_NONE, "NONE"}, // must be last
- };
- String8 result;
- audio_output_flags_t allFlags = AUDIO_OUTPUT_FLAG_NONE;
- const mapping *entry;
- for (entry = mappings; entry->mFlag != AUDIO_OUTPUT_FLAG_NONE; entry++) {
- allFlags = (audio_output_flags_t) (allFlags | entry->mFlag);
- if (flags & entry->mFlag) {
- if (!result.isEmpty()) {
- result.append("|");
- }
- result.append(entry->mString);
- }
- }
- if (flags & ~allFlags) {
- if (!result.isEmpty()) {
- result.append("|");
- }
- result.appendFormat("0x%X", flags & ~allFlags);
- }
- if (result.isEmpty()) {
- result.append(entry->mString);
- }
+ std::string result;
+ OutputFlagConverter::maskToString(flags, result);
return result;
}
@@ -944,12 +805,12 @@
dprintf(fd, " Standby: %s\n", mStandby ? "yes" : "no");
dprintf(fd, " Sample rate: %u Hz\n", mSampleRate);
dprintf(fd, " HAL frame count: %zu\n", mFrameCount);
- dprintf(fd, " HAL format: 0x%x (%s)\n", mHALFormat, formatToString(mHALFormat));
+ dprintf(fd, " HAL format: 0x%x (%s)\n", mHALFormat, formatToString(mHALFormat).c_str());
dprintf(fd, " HAL buffer size: %zu bytes\n", mBufferSize);
dprintf(fd, " Channel count: %u\n", mChannelCount);
dprintf(fd, " Channel mask: 0x%08x (%s)\n", mChannelMask,
channelMaskToString(mChannelMask, mType != RECORD).string());
- dprintf(fd, " Processing format: 0x%x (%s)\n", mFormat, formatToString(mFormat));
+ dprintf(fd, " Processing format: 0x%x (%s)\n", mFormat, formatToString(mFormat).c_str());
dprintf(fd, " Processing frame size: %zu bytes\n", mFrameSize);
dprintf(fd, " Pending config events:");
size_t numConfig = mConfigEvents.size();
@@ -962,8 +823,8 @@
} else {
dprintf(fd, " none\n");
}
- dprintf(fd, " Output device: %#x (%s)\n", mOutDevice, devicesToString(mOutDevice).string());
- dprintf(fd, " Input device: %#x (%s)\n", mInDevice, devicesToString(mInDevice).string());
+ dprintf(fd, " Output device: %#x (%s)\n", mOutDevice, devicesToString(mOutDevice).c_str());
+ dprintf(fd, " Input device: %#x (%s)\n", mInDevice, devicesToString(mInDevice).c_str());
dprintf(fd, " Audio source: %d (%s)\n", mAudioSource, sourceToString(mAudioSource));
if (locked) {
@@ -1833,8 +1694,8 @@
dprintf(fd, " Standby delay ns=%lld\n", (long long)mStandbyDelayNs);
AudioStreamOut *output = mOutput;
audio_output_flags_t flags = output != NULL ? output->flags : AUDIO_OUTPUT_FLAG_NONE;
- String8 flagsAsString = outputFlagsToString(flags);
- dprintf(fd, " AudioStreamOut: %p flags %#x (%s)\n", output, flags, flagsAsString.string());
+ dprintf(fd, " AudioStreamOut: %p flags %#x (%s)\n",
+ output, flags, outputFlagsToString(flags).c_str());
dprintf(fd, " Frames written: %lld\n", (long long)mFramesWritten);
dprintf(fd, " Suspended frames: %lld\n", (long long)mSuspendedFrames);
if (mPipeSink.get() != nullptr) {
@@ -6879,6 +6740,10 @@
dumpBase(fd, args);
+ AudioStreamIn *input = mInput;
+ audio_input_flags_t flags = input != NULL ? input->flags : AUDIO_INPUT_FLAG_NONE;
+ dprintf(fd, " AudioStreamIn: %p flags %#x (%s)\n",
+ input, flags, inputFlagsToString(flags).c_str());
if (mActiveTracks.size() == 0) {
dprintf(fd, " No active record clients\n");
}
diff --git a/services/audiopolicy/Android.mk b/services/audiopolicy/Android.mk
index 91cc3d2..932c2bb 100644
--- a/services/audiopolicy/Android.mk
+++ b/services/audiopolicy/Android.mk
@@ -90,9 +90,10 @@
$(TOPDIR)frameworks/av/services/audiopolicy/utilities
LOCAL_STATIC_LIBRARIES := \
- libmedia_helper \
libaudiopolicycomponents
+LOCAL_WHOLE_STATIC_LIBRARIES := libmedia_helper
+
ifeq ($(USE_XML_AUDIO_POLICY_CONF), 1)
LOCAL_STATIC_LIBRARIES += libxml2
diff --git a/services/audiopolicy/common/managerdefinitions/include/TypeConverter.h b/services/audiopolicy/common/managerdefinitions/include/TypeConverter.h
index 8e3dbad..84e3a36 100644
--- a/services/audiopolicy/common/managerdefinitions/include/TypeConverter.h
+++ b/services/audiopolicy/common/managerdefinitions/include/TypeConverter.h
@@ -16,201 +16,19 @@
#pragma once
+#include <media/TypeConverter.h>
+
#include "policy.h"
#include <Volume.h>
-#include <media/AudioParameter.h>
-#include <system/audio.h>
-#include <convert/convert.h>
-#include <utils/Log.h>
-#include <string>
-#include <utils/Vector.h>
-#include <utils/SortedVector.h>
namespace android {
-struct SampleRateTraits
-{
- typedef uint32_t Type;
- typedef SortedVector<Type> Collection;
-};
-struct DeviceTraits
-{
- typedef audio_devices_t Type;
- typedef Vector<Type> Collection;
-};
-struct OutputFlagTraits
-{
- typedef audio_output_flags_t Type;
- typedef Vector<Type> Collection;
-};
-struct InputFlagTraits
-{
- typedef audio_input_flags_t Type;
- typedef Vector<Type> Collection;
-};
-struct FormatTraits
-{
- typedef audio_format_t Type;
- typedef Vector<Type> Collection;
-};
-struct ChannelTraits
-{
- typedef audio_channel_mask_t Type;
- typedef SortedVector<Type> Collection;
-};
-struct OutputChannelTraits : public ChannelTraits {};
-struct InputChannelTraits : public ChannelTraits {};
-struct ChannelIndexTraits : public ChannelTraits {};
-struct GainModeTraits
-{
- typedef audio_gain_mode_t Type;
- typedef Vector<Type> Collection;
-};
-struct StreamTraits
-{
- typedef audio_stream_type_t Type;
- typedef Vector<Type> Collection;
-};
struct DeviceCategoryTraits
{
typedef device_category Type;
typedef Vector<Type> Collection;
};
-struct AudioModeTraits
-{
- typedef audio_mode_t Type;
- typedef Vector<Type> Collection;
-};
-template <typename T>
-struct DefaultTraits
-{
- typedef T Type;
- typedef Vector<Type> Collection;
-};
-template <class Traits>
-static void collectionFromString(const std::string &str, typename Traits::Collection &collection,
- const char *del = AudioParameter::valueListSeparator)
-{
- char *literal = strdup(str.c_str());
- for (const char *cstr = strtok(literal, del); cstr != NULL; cstr = strtok(NULL, del)) {
- typename Traits::Type value;
- if (utilities::convertTo<std::string, typename Traits::Type >(cstr, value)) {
- collection.add(value);
- }
- }
- free(literal);
-}
-
-template <class Traits>
-class TypeConverter
-{
-public:
- static bool toString(const typename Traits::Type &value, std::string &str);
-
- static bool fromString(const std::string &str, typename Traits::Type &result);
-
- static void collectionFromString(const std::string &str,
- typename Traits::Collection &collection,
- const char *del = AudioParameter::valueListSeparator);
-
- static uint32_t maskFromString(
- const std::string &str, const char *del = AudioParameter::valueListSeparator);
-
- static void maskToString(
- uint32_t mask, std::string &str, const char *del = AudioParameter::valueListSeparator);
-
-protected:
- struct Table {
- const char *literal;
- typename Traits::Type value;
- };
-
- static const Table mTable[];
-};
-
-typedef TypeConverter<DeviceTraits> DeviceConverter;
-typedef TypeConverter<OutputFlagTraits> OutputFlagConverter;
-typedef TypeConverter<InputFlagTraits> InputFlagConverter;
-typedef TypeConverter<FormatTraits> FormatConverter;
-typedef TypeConverter<OutputChannelTraits> OutputChannelConverter;
-typedef TypeConverter<InputChannelTraits> InputChannelConverter;
-typedef TypeConverter<ChannelIndexTraits> ChannelIndexConverter;
-typedef TypeConverter<GainModeTraits> GainModeConverter;
-typedef TypeConverter<StreamTraits> StreamTypeConverter;
typedef TypeConverter<DeviceCategoryTraits> DeviceCategoryConverter;
-typedef TypeConverter<AudioModeTraits> AudioModeConverter;
-
-inline
-static SampleRateTraits::Collection samplingRatesFromString(
- const std::string &samplingRates, const char *del = AudioParameter::valueListSeparator)
-{
- SampleRateTraits::Collection samplingRateCollection;
- collectionFromString<SampleRateTraits>(samplingRates, samplingRateCollection, del);
- return samplingRateCollection;
-}
-
-inline
-static FormatTraits::Collection formatsFromString(
- const std::string &formats, const char *del = AudioParameter::valueListSeparator)
-{
- FormatTraits::Collection formatCollection;
- FormatConverter::collectionFromString(formats, formatCollection, del);
- return formatCollection;
-}
-
-inline
-static audio_format_t formatFromString(const std::string &literalFormat)
-{
- audio_format_t format;
- if (literalFormat.empty()) {
- return gDynamicFormat;
- }
- FormatConverter::fromString(literalFormat, format);
- return format;
-}
-
-inline
-static audio_channel_mask_t channelMaskFromString(const std::string &literalChannels)
-{
- audio_channel_mask_t channels;
- if (!OutputChannelConverter::fromString(literalChannels, channels) ||
- !InputChannelConverter::fromString(literalChannels, channels)) {
- return AUDIO_CHANNEL_INVALID;
- }
- return channels;
-}
-
-inline
-static ChannelTraits::Collection channelMasksFromString(
- const std::string &channels, const char *del = AudioParameter::valueListSeparator)
-{
- ChannelTraits::Collection channelMaskCollection;
- OutputChannelConverter::collectionFromString(channels, channelMaskCollection, del);
- InputChannelConverter::collectionFromString(channels, channelMaskCollection, del);
- ChannelIndexConverter::collectionFromString(channels, channelMaskCollection, del);
- return channelMaskCollection;
-}
-
-inline
-static InputChannelTraits::Collection inputChannelMasksFromString(
- const std::string &inChannels, const char *del = AudioParameter::valueListSeparator)
-{
- InputChannelTraits::Collection inputChannelMaskCollection;
- InputChannelConverter::collectionFromString(inChannels, inputChannelMaskCollection, del);
- ChannelIndexConverter::collectionFromString(inChannels, inputChannelMaskCollection, del);
- return inputChannelMaskCollection;
-}
-
-inline
-static OutputChannelTraits::Collection outputChannelMasksFromString(
- const std::string &outChannels, const char *del = AudioParameter::valueListSeparator)
-{
- OutputChannelTraits::Collection outputChannelMaskCollection;
- OutputChannelConverter::collectionFromString(outChannels, outputChannelMaskCollection, del);
- ChannelIndexConverter::collectionFromString(outChannels, outputChannelMaskCollection, del);
- return outputChannelMaskCollection;
-}
}; // namespace android
-
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioPatch.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioPatch.cpp
index f382dec..0daae6c 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioPatch.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioPatch.cpp
@@ -54,7 +54,7 @@
for (size_t i = 0; i < mPatch.num_sources; i++) {
if (mPatch.sources[i].type == AUDIO_PORT_TYPE_DEVICE) {
std::string device;
- DeviceConverter::toString(mPatch.sources[i].ext.device.type, device);
+ deviceToString(mPatch.sources[i].ext.device.type, device);
snprintf(buffer, SIZE, "%*s- Device ID %d %s\n", spaces + 2, "",
mPatch.sources[i].id,
device.c_str());
@@ -69,7 +69,7 @@
for (size_t i = 0; i < mPatch.num_sinks; i++) {
if (mPatch.sinks[i].type == AUDIO_PORT_TYPE_DEVICE) {
std::string device;
- DeviceConverter::toString(mPatch.sinks[i].ext.device.type, device);
+ deviceToString(mPatch.sinks[i].ext.device.type, device);
snprintf(buffer, SIZE, "%*s- Device ID %d %s\n", spaces + 2, "",
mPatch.sinks[i].id,
device.c_str());
diff --git a/services/audiopolicy/common/managerdefinitions/src/ConfigParsingUtils.cpp b/services/audiopolicy/common/managerdefinitions/src/ConfigParsingUtils.cpp
index d751f07..e5888e2 100644
--- a/services/audiopolicy/common/managerdefinitions/src/ConfigParsingUtils.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/ConfigParsingUtils.cpp
@@ -18,12 +18,11 @@
//#define LOG_NDEBUG 0
#include "ConfigParsingUtils.h"
-#include <convert/convert.h>
#include "AudioGain.h"
#include "IOProfile.h"
-#include "TypeConverter.h"
#include <system/audio.h>
#include <media/AudioParameter.h>
+#include <media/TypeConverter.h>
#include <utils/Log.h>
#include <cutils/misc.h>
@@ -106,7 +105,7 @@
audio_devices_t type = AUDIO_DEVICE_NONE;
while (node) {
if (strcmp(node->name, APM_DEVICE_TYPE) == 0) {
- DeviceConverter::fromString(node->value, type);
+ deviceFromString(node->value, type);
break;
}
node = node->next;
@@ -294,7 +293,7 @@
while (devTag != NULL) {
if (strlen(devTag) != 0) {
audio_devices_t type;
- if (DeviceConverter::fromString(devTag, type)) {
+ if (deviceFromString(devTag, type)) {
uint32_t inBit = type & AUDIO_DEVICE_BIT_IN;
type &= ~AUDIO_DEVICE_BIT_IN;
while (type) {
@@ -341,7 +340,7 @@
config.addAvailableOutputDevices(availableOutputDevices);
} else if (strcmp(DEFAULT_OUTPUT_DEVICE_TAG, node->name) == 0) {
audio_devices_t device = AUDIO_DEVICE_NONE;
- DeviceConverter::fromString(node->value, device);
+ deviceFromString(node->value, device);
if (device != AUDIO_DEVICE_NONE) {
sp<DeviceDescriptor> defaultOutputDevice = new DeviceDescriptor(device);
config.setDefaultOutputDevice(defaultOutputDevice);
diff --git a/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
index ba2b9e3..f0e48b6 100644
--- a/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
@@ -285,7 +285,7 @@
result.append(buffer);
}
std::string deviceLiteral;
- if (DeviceConverter::toString(mDeviceType, deviceLiteral)) {
+ if (deviceToString(mDeviceType, deviceLiteral)) {
snprintf(buffer, SIZE, "%*s- type: %-48s\n", spaces, "", deviceLiteral.c_str());
result.append(buffer);
}
@@ -302,7 +302,7 @@
void DeviceDescriptor::log() const
{
std::string device;
- DeviceConverter::toString(mDeviceType, device);
+ deviceToString(mDeviceType, device);
ALOGI("Device id:%d type:0x%X:%s, addr:%s", mId, mDeviceType, device.c_str(),
mAddress.string());
diff --git a/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp b/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
index 44f382b..818da72 100644
--- a/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
@@ -18,7 +18,7 @@
//#define LOG_NDEBUG 0
#include "Serializer.h"
-#include <convert/convert.h>
+#include <media/convert.h>
#include "TypeConverter.h"
#include <libxml/parser.h>
#include <libxml/xinclude.h>
@@ -199,7 +199,8 @@
string format = getXmlAttribute(root, Attributes::format);
string channels = getXmlAttribute(root, Attributes::channelMasks);
- profile = new Element(formatFromString(format), channelMasksFromString(channels, ","),
+ profile = new Element(formatFromString(format, gDynamicFormat),
+ channelMasksFromString(channels, ","),
samplingRatesFromString(samplingRates, ","));
profile->setDynamicFormat(profile->getFormat() == gDynamicFormat);
@@ -300,7 +301,7 @@
AUDIO_PORT_ROLE_SOURCE : AUDIO_PORT_ROLE_SINK;
audio_devices_t type = AUDIO_DEVICE_NONE;
- if (!DeviceConverter::fromString(typeName, type) ||
+ if (!deviceFromString(typeName, type) ||
(!audio_is_input_device(type) && portRole == AUDIO_PORT_ROLE_SOURCE) ||
(!audio_is_output_devices(type) && portRole == AUDIO_PORT_ROLE_SINK)) {
ALOGW("%s: bad type %08x", __FUNCTION__, type);
diff --git a/services/audiopolicy/common/managerdefinitions/src/TypeConverter.cpp b/services/audiopolicy/common/managerdefinitions/src/TypeConverter.cpp
index cfc0985..4839683 100644
--- a/services/audiopolicy/common/managerdefinitions/src/TypeConverter.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/TypeConverter.cpp
@@ -19,282 +19,17 @@
namespace android {
#define MAKE_STRING_FROM_ENUM(string) { #string, string }
-
-template <>
-const DeviceConverter::Table DeviceConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_EARPIECE),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_SPEAKER),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_SPEAKER_SAFE),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_WIRED_HEADSET),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_WIRED_HEADPHONE),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_BLUETOOTH_SCO),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_ALL_SCO),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_ALL_A2DP),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_AUX_DIGITAL),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_HDMI),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_USB_ACCESSORY),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_USB_DEVICE),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_ALL_USB),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_REMOTE_SUBMIX),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_TELEPHONY_TX),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_LINE),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_HDMI_ARC),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_SPDIF),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_FM),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_AUX_LINE),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_IP),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_BUS),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_STUB),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_AMBIENT),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BUILTIN_MIC),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_ALL_SCO),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_WIRED_HEADSET),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_AUX_DIGITAL),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_HDMI),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_TELEPHONY_RX),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_VOICE_CALL),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BACK_MIC),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_REMOTE_SUBMIX),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_USB_ACCESSORY),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_USB_DEVICE),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_FM_TUNER),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_TV_TUNER),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_LINE),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_SPDIF),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BLUETOOTH_A2DP),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_LOOPBACK),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_IP),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BUS),
- MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_STUB),
-};
-
-
-template <>
-const OutputFlagConverter::Table OutputFlagConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_DIRECT),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_PRIMARY),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_FAST),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_DEEP_BUFFER),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_NON_BLOCKING),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_HW_AV_SYNC),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_TTS),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_RAW),
- MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_SYNC),
-};
-
-
-template <>
-const InputFlagConverter::Table InputFlagConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_FAST),
- MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_HW_HOTWORD),
- MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_RAW),
- MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_SYNC),
-};
-
-
-template <>
-const FormatConverter::Table FormatConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_PCM_16_BIT),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_PCM_8_BIT),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_PCM_32_BIT),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_PCM_8_24_BIT),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_PCM_FLOAT),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_PCM_24_BIT_PACKED),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_MP3),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_MAIN),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_LC),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_SSR),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_LTP),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_HE_V1),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_SCALABLE),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_ERLC),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_LD),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_HE_V2),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AAC_ELD),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_VORBIS),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_HE_AAC_V1),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_HE_AAC_V2),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_OPUS),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_AC3),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_E_AC3),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_DTS),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_DTS_HD),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_IEC61937),
- MAKE_STRING_FROM_ENUM(AUDIO_FORMAT_DOLBY_TRUEHD),
-};
-
-
-template <>
-const OutputChannelConverter::Table OutputChannelConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_CHANNEL_OUT_MONO),
- MAKE_STRING_FROM_ENUM(AUDIO_CHANNEL_OUT_STEREO),
- MAKE_STRING_FROM_ENUM(AUDIO_CHANNEL_OUT_QUAD),
- MAKE_STRING_FROM_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
- MAKE_STRING_FROM_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
-};
-
-
-template <>
-const InputChannelConverter::Table InputChannelConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_CHANNEL_IN_MONO),
- MAKE_STRING_FROM_ENUM(AUDIO_CHANNEL_IN_STEREO),
- MAKE_STRING_FROM_ENUM(AUDIO_CHANNEL_IN_FRONT_BACK),
-};
-
-template <>
-const ChannelIndexConverter::Table ChannelIndexConverter::mTable[] = {
- {"AUDIO_CHANNEL_INDEX_MASK_1", static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_INDEX_MASK_1)},
- {"AUDIO_CHANNEL_INDEX_MASK_2", static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_INDEX_MASK_2)},
- {"AUDIO_CHANNEL_INDEX_MASK_3", static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_INDEX_MASK_3)},
- {"AUDIO_CHANNEL_INDEX_MASK_4", static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_INDEX_MASK_4)},
- {"AUDIO_CHANNEL_INDEX_MASK_5", static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_INDEX_MASK_5)},
- {"AUDIO_CHANNEL_INDEX_MASK_6", static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_INDEX_MASK_6)},
- {"AUDIO_CHANNEL_INDEX_MASK_7", static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_INDEX_MASK_7)},
- {"AUDIO_CHANNEL_INDEX_MASK_8", static_cast<audio_channel_mask_t>(AUDIO_CHANNEL_INDEX_MASK_8)},
-};
-
-
-template <>
-const GainModeConverter::Table GainModeConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_GAIN_MODE_JOINT),
- MAKE_STRING_FROM_ENUM(AUDIO_GAIN_MODE_CHANNELS),
- MAKE_STRING_FROM_ENUM(AUDIO_GAIN_MODE_RAMP),
-};
-
+#define TERMINATOR { .literal = nullptr }
template <>
const DeviceCategoryConverter::Table DeviceCategoryConverter::mTable[] = {
MAKE_STRING_FROM_ENUM(DEVICE_CATEGORY_HEADSET),
MAKE_STRING_FROM_ENUM(DEVICE_CATEGORY_SPEAKER),
MAKE_STRING_FROM_ENUM(DEVICE_CATEGORY_EARPIECE),
- MAKE_STRING_FROM_ENUM(DEVICE_CATEGORY_EXT_MEDIA)
+ MAKE_STRING_FROM_ENUM(DEVICE_CATEGORY_EXT_MEDIA),
+ TERMINATOR
};
-
-template <>
-const StreamTypeConverter::Table StreamTypeConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_VOICE_CALL),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_SYSTEM),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_RING),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_MUSIC),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_ALARM),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_NOTIFICATION),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_BLUETOOTH_SCO ),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_ENFORCED_AUDIBLE),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_DTMF),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_TTS),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_ACCESSIBILITY),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_REROUTING),
- MAKE_STRING_FROM_ENUM(AUDIO_STREAM_PATCH),
-};
-
-
-template<>
-const AudioModeConverter::Table AudioModeConverter::mTable[] = {
- MAKE_STRING_FROM_ENUM(AUDIO_MODE_INVALID),
- MAKE_STRING_FROM_ENUM(AUDIO_MODE_CURRENT),
- MAKE_STRING_FROM_ENUM(AUDIO_MODE_NORMAL),
- MAKE_STRING_FROM_ENUM(AUDIO_MODE_RINGTONE),
- MAKE_STRING_FROM_ENUM(AUDIO_MODE_IN_CALL),
- MAKE_STRING_FROM_ENUM(AUDIO_MODE_IN_COMMUNICATION),
-};
-
-
-template <class Traits>
-bool TypeConverter<Traits>::toString(const typename Traits::Type &value, std::string &str)
-{
- for (size_t i = 0; i < sizeof(mTable) / sizeof(mTable[0]); i++) {
- if (mTable[i].value == value) {
- str = mTable[i].literal;
- return true;
- }
- }
- char result[64];
- snprintf(result, sizeof(result), "Unknown enum value %d", value);
- str = result;
- return false;
-}
-
-template <class Traits>
-bool TypeConverter<Traits>::fromString(const std::string &str, typename Traits::Type &result)
-{
- for (size_t i = 0; i < sizeof(mTable) / sizeof(mTable[0]); i++) {
- if (strcmp(mTable[i].literal, str.c_str()) == 0) {
- ALOGV("stringToEnum() found %s", mTable[i].literal);
- result = mTable[i].value;
- return true;
- }
- }
- return false;
-}
-
-template <class Traits>
-void TypeConverter<Traits>::collectionFromString(const std::string &str,
- typename Traits::Collection &collection,
- const char *del)
-{
- char *literal = strdup(str.c_str());
-
- for (const char *cstr = strtok(literal, del); cstr != NULL; cstr = strtok(NULL, del)) {
- typename Traits::Type value;
- if (fromString(cstr, value)) {
- collection.add(value);
- }
- }
- free(literal);
-}
-
-template <class Traits>
-uint32_t TypeConverter<Traits>::maskFromString(const std::string &str, const char *del)
-{
- char *literal = strdup(str.c_str());
- uint32_t value = 0;
- for (const char *cstr = strtok(literal, del); cstr != NULL; cstr = strtok(NULL, del)) {
- typename Traits::Type type;
- if (fromString(cstr, type)) {
- value |= static_cast<uint32_t>(type);
- }
- }
- free(literal);
- return value;
-}
-
-template <class Traits>
-void TypeConverter<Traits>::maskToString(uint32_t mask, std::string &str, const char *del)
-{
- bool first_flag = true;
- for (size_t i = 0; i < sizeof(mTable) / sizeof(mTable[0]); i++) {
- if ((mask & mTable[i].value) == mTable[i].value) {
- if (!first_flag) str += del;
- first_flag = false;
- str += mTable[i].literal;
- }
- }
-}
-
-template class TypeConverter<DeviceTraits>;
-template class TypeConverter<OutputFlagTraits>;
-template class TypeConverter<InputFlagTraits>;
-template class TypeConverter<FormatTraits>;
-template class TypeConverter<OutputChannelTraits>;
-template class TypeConverter<InputChannelTraits>;
-template class TypeConverter<ChannelIndexTraits>;
-template class TypeConverter<GainModeTraits>;
-template class TypeConverter<StreamTraits>;
template class TypeConverter<DeviceCategoryTraits>;
-template class TypeConverter<AudioModeTraits>;
}; // namespace android
-
diff --git a/services/audiopolicy/engineconfigurable/Android.mk b/services/audiopolicy/engineconfigurable/Android.mk
index 6dba75b..6b18921 100644
--- a/services/audiopolicy/engineconfigurable/Android.mk
+++ b/services/audiopolicy/engineconfigurable/Android.mk
@@ -39,8 +39,10 @@
LOCAL_MODULE := libaudiopolicyengineconfigurable
LOCAL_MODULE_TAGS := optional
+
+LOCAL_WHOLE_STATIC_LIBRARIES := libmedia_helper
+
LOCAL_STATIC_LIBRARIES := \
- libmedia_helper \
libaudiopolicypfwwrapper \
libaudiopolicycomponents \
libxml2
@@ -48,6 +50,7 @@
LOCAL_SHARED_LIBRARIES := \
libcutils \
libutils \
+ liblog \
libaudioutils \
libparameter
diff --git a/services/audiopolicy/engineconfigurable/wrapper/Android.mk b/services/audiopolicy/engineconfigurable/wrapper/Android.mk
index f4283a8..3cc112f 100644
--- a/services/audiopolicy/engineconfigurable/wrapper/Android.mk
+++ b/services/audiopolicy/engineconfigurable/wrapper/Android.mk
@@ -15,8 +15,7 @@
LOCAL_SRC_FILES:= ParameterManagerWrapper.cpp
-LOCAL_STATIC_LIBRARIES := \
- libmedia_helper \
+LOCAL_WHOLE_STATIC_LIBRARIES := libmedia_helper
LOCAL_MULTILIB := $(AUDIOSERVER_MULTILIB)
diff --git a/services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp b/services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp
index 6872e52..8d51293 100644
--- a/services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp
+++ b/services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp
@@ -22,7 +22,7 @@
#include <ParameterMgrPlatformConnector.h>
#include <SelectionCriterionTypeInterface.h>
#include <SelectionCriterionInterface.h>
-#include <convert.h>
+#include <media/convert.h>
#include <algorithm>
#include <cutils/config_utils.h>
#include <cutils/misc.h>
diff --git a/services/audiopolicy/enginedefault/Android.mk b/services/audiopolicy/enginedefault/Android.mk
index e6de8ae..c1bb3fb 100644
--- a/services/audiopolicy/enginedefault/Android.mk
+++ b/services/audiopolicy/enginedefault/Android.mk
@@ -34,8 +34,9 @@
LOCAL_MODULE := libaudiopolicyenginedefault
LOCAL_MODULE_TAGS := optional
+LOCAL_WHOLE_STATIC_LIBRARIES := libmedia_helper
+
LOCAL_STATIC_LIBRARIES := \
- libmedia_helper \
libaudiopolicycomponents \
libxml2
diff --git a/services/audiopolicy/utilities/convert/convert.h b/services/audiopolicy/utilities/convert/convert.h
deleted file mode 100644
index 980b5d5..0000000
--- a/services/audiopolicy/utilities/convert/convert.h
+++ /dev/null
@@ -1,383 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <limits>
-#include <sstream>
-#include <string>
-#include <vector>
-#include <stdint.h>
-#include <cmath>
-
-namespace android
-{
-
-namespace utilities
-{
-
-/**
- * Convert a given source type to a given destination type.
- *
- * String conversion to T reads the value of the type T in the given string.
- * The function does not allow to have white spaces around the value to parse
- * and tries to parse the whole string, which means that if some bytes were not
- * read in the string, the function fails.
- * Hexadecimal representation (ie. numbers starting with 0x) is supported only
- * for integral types conversions.
- *
- * Numeric conversion to string formats the source value to decimal space.
- *
- * Vector to vector conversion calls convertTo on each element.
- *
- * @tparam srcType source type, default value is string type
- * @tparam dstType destination type
- * @param[in] input The source to convert from.
- * @param[out] result Converted value if success, undefined on failure.
- *
- * @return true if conversion was successful, false otherwise.
- */
-template <typename srcType, typename dstType>
-static inline bool convertTo(const srcType &input, dstType &result);
-
-/* details namespace is here to hide implementation details to header end user. It
- * is NOT intended to be used outside. */
-namespace details
-{
-
-/** Helper class to limit instantiation of templates */
-template <typename T>
-struct ConversionFromStringAllowed;
-template <typename T>
-struct ConversionToStringAllowed;
-
-/* List of allowed types for conversion */
-template <>
-struct ConversionFromStringAllowed<bool> {};
-template <>
-struct ConversionFromStringAllowed<uint64_t> {};
-template <>
-struct ConversionFromStringAllowed<int64_t> {};
-template <>
-struct ConversionFromStringAllowed<uint32_t> {};
-template <>
-struct ConversionFromStringAllowed<int32_t> {};
-template <>
-struct ConversionFromStringAllowed<uint16_t> {};
-template <>
-struct ConversionFromStringAllowed<int16_t> {};
-template <>
-struct ConversionFromStringAllowed<float> {};
-template <>
-struct ConversionFromStringAllowed<double> {};
-
-template <>
-struct ConversionToStringAllowed<int64_t> {};
-template <>
-struct ConversionToStringAllowed<uint64_t> {};
-template <>
-struct ConversionToStringAllowed<uint32_t> {};
-template <>
-struct ConversionToStringAllowed<int32_t> {};
-template <>
-struct ConversionToStringAllowed<double> {};
-template <>
-struct ConversionToStringAllowed<float> {};
-
-/**
- * Set the decimal precision to 10 digits.
- * Note that this setting is aligned with Android Audio Parameter
- * policy concerning float storage into string.
- */
-static const uint32_t gFloatPrecision = 10;
-
-template <typename T>
-static inline bool fromString(const std::string &str, T &result)
-{
- /* Check that conversion to that type is allowed.
- * If this fails, this means that this template was not intended to be used
- * with this type, thus that the result is undefined. */
- ConversionFromStringAllowed<T>();
-
- if (str.find_first_of(std::string("\r\n\t\v ")) != std::string::npos) {
- return false;
- }
-
- /* Check for a '-' in string. If type is unsigned and a - is found, the
- * parsing fails. This is made necessary because "-1" is read as 65535 for
- * uint16_t, for example */
- if (str.find("-") != std::string::npos
- && !std::numeric_limits<T>::is_signed) {
- return false;
- }
-
- std::stringstream ss(str);
-
- /* Sadly, the stream conversion does not handle hexadecimal format, thus
- * check is done manually */
- if (str.substr(0, 2) == "0x") {
- if (std::numeric_limits<T>::is_integer) {
- ss >> std::hex >> result;
- } else {
- /* Conversion undefined for non integers */
- return false;
- }
- } else {
- ss >> result;
- }
-
- return ss.eof() && !ss.fail() && !ss.bad();
-}
-
-template <typename T>
-static inline bool toString(const T &value, std::string &str)
-{
- /* Check that conversion from that type is allowed.
- * If this fails, this means that this template was not intended to be used
- * with this type, thus that the result is undefined. */
- ConversionToStringAllowed<T>();
-
- std::stringstream oss;
- oss.precision(gFloatPrecision);
- oss << value;
- str = oss.str();
- return !oss.fail() && !oss.bad();
-}
-
-template <typename srcType, typename dstType>
-class Converter;
-
-template <typename dstType>
-class Converter<std::string, dstType>
-{
-public:
- static inline bool run(const std::string &str, dstType &result)
- {
- return fromString<dstType>(str, result);
- }
-};
-
-template <typename srcType>
-class Converter<srcType, std::string>
-{
-public:
- static inline bool run(const srcType &str, std::string &result)
- {
- return toString<srcType>(str, result);
- }
-};
-
-/** Convert a vector by applying convertTo on each element.
- *
- * @tparam SrcElem Type of the src elements.
- * @tparam DstElem Type of the destination elements.
- */
-template <typename SrcElem, typename DstElem>
-class Converter<std::vector<SrcElem>, std::vector<DstElem> >
-{
-public:
- typedef const std::vector<SrcElem> Src;
- typedef std::vector<DstElem> Dst;
-
- static inline bool run(Src &src, Dst &dst)
- {
- typedef typename Src::const_iterator SrcIt;
- dst.clear();
- dst.reserve(src.size());
- for (SrcIt it = src.begin(); it != src.end(); ++it) {
- DstElem dstElem;
- if (not convertTo(*it, dstElem)) {
- return false;
- }
- dst.push_back(dstElem);
- }
- return true;
- }
-};
-
-} // namespace details
-
-template <typename srcType, typename dstType>
-static inline bool convertTo(const srcType &input, dstType &result)
-{
- return details::Converter<srcType, dstType>::run(input, result);
-}
-
-/**
- * Specialization for int16_t of convertTo template function.
- *
- * This function follows the same paradigm than it's generic version.
- *
- * The specific implementation is made necessary because the stlport version of
- * string streams is bugged and does not fail when giving overflowed values.
- * This specialisation can be safely removed when stlport behaviour is fixed.
- *
- * @param[in] str the string to parse.
- * @param[out] result reference to object where to store the result.
- *
- * @return true if conversion was successful, false otherwise.
- */
-template <>
-inline bool convertTo<std::string, int16_t>(const std::string &str, int16_t &result)
-{
- int64_t res;
-
- if (!convertTo<std::string, int64_t>(str, res)) {
- return false;
- }
-
- if (res > std::numeric_limits<int16_t>::max() || res < std::numeric_limits<int16_t>::min()) {
- return false;
- }
-
- result = static_cast<int16_t>(res);
- return true;
-}
-
-/**
- * Specialization for float of convertTo template function.
- *
- * This function follows the same paradigm than it's generic version and is
- * based on it but makes furthers checks on the returned value.
- *
- * The specific implementation is made necessary because the stlport conversion
- * from string to float behaves differently than GNU STL: overflow produce
- * +/-Infinity rather than an error.
- *
- * @param[in] str the string to parse.
- * @param[out] result reference to object where to store the result.
- *
- * @return true if conversion was successful, false otherwise.
- */
-template <>
-inline bool convertTo<std::string, float>(const std::string &str, float &result)
-{
- if (!details::Converter<std::string, float>::run(str, result)) {
- return false;
- }
-
- if (std::abs(result) == std::numeric_limits<float>::infinity() ||
- result == std::numeric_limits<float>::quiet_NaN()) {
- return false;
- }
-
- return true;
-}
-
-/**
- * Specialization for double of convertTo template function.
- *
- * This function follows the same paradigm than it's generic version and is
- * based on it but makes furthers checks on the returned value.
- *
- * The specific implementation is made necessary because the stlport conversion
- * from string to double behaves differently than GNU STL: overflow produce
- * +/-Infinity rather than an error.
- *
- * @param[in] str the string to parse.
- * @param[out] result reference to object where to store the result.
- *
- * @return true if conversion was successful, false otherwise.
- */
-template <>
-inline bool convertTo<std::string, double>(const std::string &str, double &result)
-{
- if (!details::Converter<std::string, double>::run(str, result)) {
- return false;
- }
-
- if (std::abs(result) == std::numeric_limits<double>::infinity() ||
- result == std::numeric_limits<double>::quiet_NaN()) {
- return false;
- }
-
- return true;
-}
-
-/**
- * Specialization for boolean of convertTo template function.
- *
- * This function follows the same paradigm than it's generic version.
- * This function accepts to parse boolean as "0/1" or "false/true" or
- * "FALSE/TRUE".
- * The specific implementation is made necessary because the behaviour of
- * string streams when parsing boolean values is not sufficient to fit our
- * requirements. Indeed, parsing "true" will correctly parse the value, but the
- * end of stream is not reached which makes the ss.eof() fails in the generic
- * implementation.
- *
- * @param[in] str the string to parse.
- * @param[out] result reference to object where to store the result.
- *
- * @return true if conversion was successful, false otherwise.
- */
-template <>
-inline bool convertTo<std::string, bool>(const std::string &str, bool &result)
-{
- if (str == "0" || str == "FALSE" || str == "false") {
- result = false;
- return true;
- }
-
- if (str == "1" || str == "TRUE" || str == "true") {
- result = true;
- return true;
- }
-
- return false;
-}
-
-/**
- * Specialization for boolean to string of convertTo template function.
- *
- * This function follows the same paradigm than it's generic version.
- * This function arbitrarily decides to return "false/true".
- * It is compatible with the specialization from string to boolean.
- *
- * @param[in] isSet boolean to convert to a string.
- * @param[out] result reference to object where to store the result.
- *
- * @return true if conversion was successful, false otherwise.
- */
-template <>
-inline bool convertTo<bool, std::string>(const bool &isSet, std::string &result)
-{
- result = isSet ? "true" : "false";
- return true;
-}
-
-/**
- * Specialization for string to string of convertTo template function.
- *
- * This function is a dummy conversion from string to string.
- * In case of clients using template as well, this implementation avoids adding extra
- * specialization to bypass the conversion from string to string.
- *
- * @param[in] str the string to parse.
- * @param[out] result reference to object where to store the result.
- *
- * @return true if conversion was successful, false otherwise.
- */
-template <>
-inline bool convertTo<std::string, std::string>(const std::string &str, std::string &result)
-{
- result = str;
- return true;
-}
-
-} // namespace utilities
-
-} // namespace android