Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[media]: refactoring AudioSystem.cpp to C++ style am: 4b107fa0fa

Browse Source 
Original change: https://android-review.googlesource.com/c/platform/frameworks/base/+/2619399

Change-Id: Ieb302e86f413d006dc9189f64a1f9cb2f372a461
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Anton Utkin
2023-07-12 18:48:48 +00:00
committed by Automerger Merge Worker
parent 17991ab920 4b107fa0fa
commit b685cd58f3
1 changed files with 211 additions and 344 deletions
Download Patch File Download Diff File Expand all files Collapse all files

543
core/jni/android_media_AudioSystem.cpp
View File

@@ -29,6 +29,7 @@
#include <media/AudioSystem.h> #include <media/AudioSystem.h>
#include <nativehelper/JNIHelp.h> #include <nativehelper/JNIHelp.h>
#include <nativehelper/ScopedLocalRef.h> #include <nativehelper/ScopedLocalRef.h>
#include <nativehelper/ScopedPrimitiveArray.h>
#include <system/audio.h> #include <system/audio.h>
#include <system/audio_policy.h> #include <system/audio_policy.h>
#include <utils/Log.h> #include <utils/Log.h>
@@ -1023,22 +1024,18 @@ static jint convertAudioPortConfigToNativeWithDevicePort(JNIEnv *env,
return jStatus; return jStatus;
} }
static jint convertAudioPortConfigFromNative(JNIEnv *env, static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRef<jobject> *jAudioPort,
jobject jAudioPort, ScopedLocalRef<jobject> *jAudioPortConfig,
jobject *jAudioPortConfig, const struct audio_port_config *nAudioPortConfig) {
const struct audio_port_config *nAudioPortConfig)
{
jint jStatus = AUDIO_JAVA_SUCCESS;
jobject jAudioGainConfig = NULL;
jobject jAudioGain = NULL;
jintArray jGainValues; jintArray jGainValues;
bool audioportCreated = false; bool audioportCreated = false;
ALOGV("convertAudioPortConfigFromNative jAudioPort %p", jAudioPort); ALOGV("convertAudioPortConfigFromNative jAudioPort %p", jAudioPort);
if (jAudioPort == NULL) { if (*jAudioPort == nullptr) {
jobject jHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor, ScopedLocalRef<jobject> jHandle(env,
nAudioPortConfig->id); env->NewObject(gAudioHandleClass, gAudioHandleCstor,
nAudioPortConfig->id));
ALOGV("convertAudioPortConfigFromNative handle %d is a %s", nAudioPortConfig->id, ALOGV("convertAudioPortConfigFromNative handle %d is a %s", nAudioPortConfig->id,
nAudioPortConfig->type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix"); nAudioPortConfig->type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix");
@@ -1050,17 +1047,17 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env,
// and configuration data. The actual AudioPortConfig objects will be // and configuration data. The actual AudioPortConfig objects will be
// constructed by java code with correct class type (device, mix etc...) // constructed by java code with correct class type (device, mix etc...)
// and reference to AudioPort instance in this client // and reference to AudioPort instance in this client
jAudioPort = env->NewObject(gAudioPortClass, gAudioPortCstor, jAudioPort->reset(env->NewObject(gAudioPortClass, gAudioPortCstor,
jHandle, // handle jHandle.get(), // handle
0, // role 0, // role
NULL, // name NULL, // name
NULL, // samplingRates NULL, // samplingRates
NULL, // channelMasks NULL, // channelMasks
NULL, // channelIndexMasks NULL, // channelIndexMasks
NULL, // formats NULL, // formats
NULL); // gains NULL)); // gains
env->DeleteLocalRef(jHandle);
if (jAudioPort == NULL) { if (*jAudioPort == nullptr) {
return (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
} }
ALOGV("convertAudioPortConfigFromNative jAudioPort created for handle %d", ALOGV("convertAudioPortConfigFromNative jAudioPort created for handle %d",
@@ -1069,6 +1066,9 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env,
audioportCreated = true; audioportCreated = true;
} }
ScopedLocalRef<jobject> jAudioGainConfig(env, nullptr);
ScopedLocalRef<jobject> jAudioGain(env, nullptr);
bool useInMask = audio_port_config_has_input_direction(nAudioPortConfig); bool useInMask = audio_port_config_has_input_direction(nAudioPortConfig);
audio_channel_mask_t nMask; audio_channel_mask_t nMask;
@@ -1082,36 +1082,26 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env,
gainIndex, nAudioPortConfig->gain.mode); gainIndex, nAudioPortConfig->gain.mode);
if (audioportCreated) { if (audioportCreated) {
ALOGV("convertAudioPortConfigFromNative creating gain"); ALOGV("convertAudioPortConfigFromNative creating gain");
jAudioGain = env->NewObject(gAudioGainClass, gAudioGainCstor, jAudioGain.reset(env->NewObject(gAudioGainClass, gAudioGainCstor, gainIndex, 0, 0, 0, 0,
gainIndex, 0, 0, 0, 0));
0,
0,
0,
0,
0,
0,
0,
0);
if (jAudioGain == NULL) { if (jAudioGain == NULL) {
ALOGV("convertAudioPortConfigFromNative creating gain FAILED"); ALOGV("convertAudioPortConfigFromNative creating gain FAILED");
jStatus = (jint)AUDIO_JAVA_ERROR; return AUDIO_JAVA_ERROR;
goto exit;
} }
} else { } else {
ALOGV("convertAudioPortConfigFromNative reading gain from port"); ALOGV("convertAudioPortConfigFromNative reading gain from port");
jobjectArray jGains = (jobjectArray)env->GetObjectField(jAudioPort, ScopedLocalRef<jobjectArray> jGains(env,
gAudioPortFields.mGains); (jobjectArray)env
->GetObjectField(jAudioPort->get(),
gAudioPortFields.mGains));
if (jGains == NULL) { if (jGains == NULL) {
ALOGV("convertAudioPortConfigFromNative could not get gains from port"); ALOGV("convertAudioPortConfigFromNative could not get gains from port");
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
jAudioGain = env->GetObjectArrayElement(jGains, gainIndex); jAudioGain.reset(env->GetObjectArrayElement(jGains.get(), gainIndex));
env->DeleteLocalRef(jGains);
if (jAudioGain == NULL) { if (jAudioGain == NULL) {
ALOGV("convertAudioPortConfigFromNative could not get gain at index %d", gainIndex); ALOGV("convertAudioPortConfigFromNative could not get gain at index %d", gainIndex);
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
} }
int numValues; int numValues;
@@ -1123,8 +1113,7 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env,
jGainValues = env->NewIntArray(numValues); jGainValues = env->NewIntArray(numValues);
if (jGainValues == NULL) { if (jGainValues == NULL) {
ALOGV("convertAudioPortConfigFromNative could not create gain values %d", numValues); ALOGV("convertAudioPortConfigFromNative could not create gain values %d", numValues);
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
env->SetIntArrayRegion(jGainValues, 0, numValues, env->SetIntArrayRegion(jGainValues, 0, numValues,
nAudioPortConfig->gain.values); nAudioPortConfig->gain.values);
@@ -1138,19 +1127,14 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env,
ALOGV("convertAudioPortConfigFromNative OUT mask java %x native %x", jMask, nMask); ALOGV("convertAudioPortConfigFromNative OUT mask java %x native %x", jMask, nMask);
} }
jAudioGainConfig = env->NewObject(gAudioGainConfigClass, jAudioGainConfig.reset(env->NewObject(gAudioGainConfigClass, gAudioGainConfigCstor,
gAudioGainConfigCstor, gainIndex, jAudioGain.get(),
gainIndex, nAudioPortConfig->gain.mode, jMask, jGainValues,
jAudioGain, nAudioPortConfig->gain.ramp_duration_ms));
nAudioPortConfig->gain.mode,
jMask,
jGainValues,
nAudioPortConfig->gain.ramp_duration_ms);
env->DeleteLocalRef(jGainValues); env->DeleteLocalRef(jGainValues);
if (jAudioGainConfig == NULL) { if (jAudioGainConfig == NULL) {
ALOGV("convertAudioPortConfigFromNative could not create gain config"); ALOGV("convertAudioPortConfigFromNative could not create gain config");
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
} }
jclass clazz; jclass clazz;
@@ -1160,17 +1144,16 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env,
methodID = gAudioPortConfigCstor; methodID = gAudioPortConfigCstor;
ALOGV("convertAudioPortConfigFromNative building a generic port config"); ALOGV("convertAudioPortConfigFromNative building a generic port config");
} else { } else {
if (env->IsInstanceOf(jAudioPort, gAudioDevicePortClass)) { if (env->IsInstanceOf(jAudioPort->get(), gAudioDevicePortClass)) {
clazz = gAudioDevicePortConfigClass; clazz = gAudioDevicePortConfigClass;
methodID = gAudioDevicePortConfigCstor; methodID = gAudioDevicePortConfigCstor;
ALOGV("convertAudioPortConfigFromNative building a device config"); ALOGV("convertAudioPortConfigFromNative building a device config");
} else if (env->IsInstanceOf(jAudioPort, gAudioMixPortClass)) { } else if (env->IsInstanceOf(jAudioPort->get(), gAudioMixPortClass)) {
clazz = gAudioMixPortConfigClass; clazz = gAudioMixPortConfigClass;
methodID = gAudioMixPortConfigCstor; methodID = gAudioMixPortConfigCstor;
ALOGV("convertAudioPortConfigFromNative building a mix config"); ALOGV("convertAudioPortConfigFromNative building a mix config");
} else { } else {
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
} }
nMask = (nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) nMask = (nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK)
@@ -1184,8 +1167,8 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env,
ALOGV("convertAudioPortConfigFromNative OUT mask java %x native %x", jMask, nMask); ALOGV("convertAudioPortConfigFromNative OUT mask java %x native %x", jMask, nMask);
} }
*jAudioPortConfig = jAudioPortConfig->reset(
env->NewObject(clazz, methodID, jAudioPort, env->NewObject(clazz, methodID, jAudioPort->get(),
(nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) (nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE)
? nAudioPortConfig->sample_rate ? nAudioPortConfig->sample_rate
: AUDIO_CONFIG_BASE_INITIALIZER.sample_rate, : AUDIO_CONFIG_BASE_INITIALIZER.sample_rate,
@@ -1194,31 +1177,14 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env,
(nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_FORMAT) (nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_FORMAT)
? nAudioPortConfig->format ? nAudioPortConfig->format
: AUDIO_CONFIG_BASE_INITIALIZER.format), : AUDIO_CONFIG_BASE_INITIALIZER.format),
jAudioGainConfig); jAudioGainConfig.get()));
if (*jAudioPortConfig == NULL) { if (*jAudioPortConfig == NULL) {
ALOGV("convertAudioPortConfigFromNative could not create new port config"); ALOGV("convertAudioPortConfigFromNative could not create new port config");
jStatus = (jint)AUDIO_JAVA_ERROR; return AUDIO_JAVA_ERROR;
} else { } else {
ALOGV("convertAudioPortConfigFromNative OK"); ALOGV("convertAudioPortConfigFromNative OK");
} }
return AUDIO_JAVA_SUCCESS;
exit:
if (audioportCreated) {
env->DeleteLocalRef(jAudioPort);
if (jAudioGain != NULL) {
env->DeleteLocalRef(jAudioGain);
}
}
if (jAudioGainConfig != NULL) {
env->DeleteLocalRef(jAudioGainConfig);
}
return jStatus;
}
// TODO: pull out to separate file
template <typename T, size_t N>
static constexpr size_t array_size(const T (&)[N]) {
return N;
} }
static jintArray convertEncapsulationInfoFromNative(JNIEnv *env, uint32_t encapsulationInfo) { static jintArray convertEncapsulationInfoFromNative(JNIEnv *env, uint32_t encapsulationInfo) {
@@ -1240,8 +1206,8 @@ static bool isAudioPortArrayCountOutOfBounds(const struct audio_port_v7 *nAudioP
std::stringstream &ss) { std::stringstream &ss) {
ss << " num_audio_profiles " << nAudioPort->num_audio_profiles << " num_gains " ss << " num_audio_profiles " << nAudioPort->num_audio_profiles << " num_gains "
<< nAudioPort->num_gains; << nAudioPort->num_gains;
if (nAudioPort->num_audio_profiles > array_size(nAudioPort->audio_profiles) || if (nAudioPort->num_audio_profiles > std::size(nAudioPort->audio_profiles) ||
nAudioPort->num_gains > array_size(nAudioPort->gains)) { nAudioPort->num_gains > std::size(nAudioPort->gains)) {
return true; return true;
} }
for (size_t i = 0; i < nAudioPort->num_audio_profiles; ++i) { for (size_t i = 0; i < nAudioPort->num_audio_profiles; ++i) {
@@ -1249,9 +1215,9 @@ static bool isAudioPortArrayCountOutOfBounds(const struct audio_port_v7 *nAudioP
<< " num_sample_rates " << nAudioPort->audio_profiles[i].num_sample_rates << " num_sample_rates " << nAudioPort->audio_profiles[i].num_sample_rates
<< " num_channel_masks " << nAudioPort->audio_profiles[i].num_channel_masks; << " num_channel_masks " << nAudioPort->audio_profiles[i].num_channel_masks;
if (nAudioPort->audio_profiles[i].num_sample_rates > if (nAudioPort->audio_profiles[i].num_sample_rates >
array_size(nAudioPort->audio_profiles[i].sample_rates) || std::size(nAudioPort->audio_profiles[i].sample_rates) ||
nAudioPort->audio_profiles[i].num_channel_masks > nAudioPort->audio_profiles[i].num_channel_masks >
array_size(nAudioPort->audio_profiles[i].channel_masks)) { std::size(nAudioPort->audio_profiles[i].channel_masks)) {
return true; return true;
} }
} }
@@ -1322,18 +1288,8 @@ static jint convertAudioProfileFromNative(JNIEnv *env, jobject *jAudioProfile,
return AUDIO_JAVA_SUCCESS; return AUDIO_JAVA_SUCCESS;
} }
static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort, static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef<jobject> *jAudioPort,
const struct audio_port_v7 *nAudioPort) { const struct audio_port_v7 *nAudioPort) {
jint jStatus = (jint)AUDIO_JAVA_SUCCESS;
jintArray jEncapsulationModes = NULL;
jintArray jEncapsulationMetadataTypes = NULL;
jobjectArray jGains = NULL;
jobject jHandle = NULL;
jobject jAudioPortConfig = NULL;
jstring jDeviceName = NULL;
jobject jAudioProfiles = NULL;
jobject jAudioDescriptors = nullptr;
ScopedLocalRef<jobject> jPcmFloatProfileFromExtendedInteger(env, nullptr);
bool hasFloat = false; bool hasFloat = false;
bool useInMask; bool useInMask;
@@ -1357,19 +1313,21 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort,
} else { } else {
ALOGE("%s", s.c_str()); ALOGE("%s", s.c_str());
} }
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
useInMask = audio_has_input_direction(nAudioPort->type, nAudioPort->role); useInMask = audio_has_input_direction(nAudioPort->type, nAudioPort->role);
jAudioProfiles = env->NewObject(gArrayListClass, gArrayListMethods.cstor); ScopedLocalRef<jobject> jAudioProfiles(env,
env->NewObject(gArrayListClass,
gArrayListMethods.cstor));
if (jAudioProfiles == nullptr) { if (jAudioProfiles == nullptr) {
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
ScopedLocalRef<jobject> jPcmFloatProfileFromExtendedInteger(env, nullptr);
for (size_t i = 0; i < nAudioPort->num_audio_profiles; ++i) { for (size_t i = 0; i < nAudioPort->num_audio_profiles; ++i) {
jobject jAudioProfile = nullptr; jobject jAudioProfile = nullptr;
jint jStatus = AUDIO_JAVA_SUCCESS;
jStatus = convertAudioProfileFromNative(env, &jAudioProfile, &nAudioPort->audio_profiles[i], jStatus = convertAudioProfileFromNative(env, &jAudioProfile, &nAudioPort->audio_profiles[i],
useInMask); useInMask);
if (jStatus == AUDIO_JAVA_BAD_VALUE) { if (jStatus == AUDIO_JAVA_BAD_VALUE) {
@@ -1377,10 +1335,9 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort,
continue; continue;
} }
if (jStatus != NO_ERROR) { if (jStatus != NO_ERROR) {
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
env->CallBooleanMethod(jAudioProfiles, gArrayListMethods.add, jAudioProfile); env->CallBooleanMethod(jAudioProfiles.get(), gArrayListMethods.add, jAudioProfile);
if (nAudioPort->audio_profiles[i].format == AUDIO_FORMAT_PCM_FLOAT) { if (nAudioPort->audio_profiles[i].format == AUDIO_FORMAT_PCM_FLOAT) {
hasFloat = true; hasFloat = true;
@@ -1421,14 +1378,15 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort,
// (replacing the zero pad). This ensures pre-S apps that look // (replacing the zero pad). This ensures pre-S apps that look
// for ENCODING_PCM_FLOAT continue to see that encoding if the device supports // for ENCODING_PCM_FLOAT continue to see that encoding if the device supports
// extended precision integers. // extended precision integers.
env->CallBooleanMethod(jAudioProfiles, gArrayListMethods.add, env->CallBooleanMethod(jAudioProfiles.get(), gArrayListMethods.add,
jPcmFloatProfileFromExtendedInteger.get()); jPcmFloatProfileFromExtendedInteger.get());
} }
jAudioDescriptors = env->NewObject(gArrayListClass, gArrayListMethods.cstor); ScopedLocalRef<jobject> jAudioDescriptors(env,
env->NewObject(gArrayListClass,
gArrayListMethods.cstor));
if (jAudioDescriptors == nullptr) { if (jAudioDescriptors == nullptr) {
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
for (size_t i = 0; i < nAudioPort->num_extra_audio_descriptors; ++i) { for (size_t i = 0; i < nAudioPort->num_extra_audio_descriptors; ++i) {
const auto &extraAudioDescriptor = nAudioPort->extra_audio_descriptors[i]; const auto &extraAudioDescriptor = nAudioPort->extra_audio_descriptors[i];
@@ -1458,15 +1416,16 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort,
env->NewObject(gAudioDescriptorClass, gAudioDescriptorCstor, env->NewObject(gAudioDescriptorClass, gAudioDescriptorCstor,
standard, encapsulationType, standard, encapsulationType,
jDescriptor.get())); jDescriptor.get()));
env->CallBooleanMethod(jAudioDescriptors, gArrayListMethods.add, jAudioDescriptor.get()); env->CallBooleanMethod(jAudioDescriptors.get(), gArrayListMethods.add,
jAudioDescriptor.get());
} }
// gains // gains
jGains = env->NewObjectArray(nAudioPort->num_gains, ScopedLocalRef<jobjectArray> jGains(env,
gAudioGainClass, NULL); env->NewObjectArray(nAudioPort->num_gains, gAudioGainClass,
if (jGains == NULL) { NULL));
jStatus = (jint)AUDIO_JAVA_ERROR; if (jGains == nullptr) {
goto exit; return (jint)AUDIO_JAVA_ERROR;
} }
for (size_t j = 0; j < nAudioPort->num_gains; j++) { for (size_t j = 0; j < nAudioPort->num_gains; j++) {
@@ -1491,88 +1450,71 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort,
nAudioPort->gains[j].min_ramp_ms, nAudioPort->gains[j].min_ramp_ms,
nAudioPort->gains[j].max_ramp_ms); nAudioPort->gains[j].max_ramp_ms);
if (jGain == NULL) { if (jGain == NULL) {
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
env->SetObjectArrayElement(jGains, j, jGain); env->SetObjectArrayElement(jGains.get(), j, jGain);
env->DeleteLocalRef(jGain); env->DeleteLocalRef(jGain);
} }
jHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor, ScopedLocalRef<jobject> jHandle(env,
nAudioPort->id); env->NewObject(gAudioHandleClass, gAudioHandleCstor,
if (jHandle == NULL) { nAudioPort->id));
jStatus = (jint)AUDIO_JAVA_ERROR; if (jHandle == nullptr) {
goto exit; return (jint)AUDIO_JAVA_ERROR;
} }
jDeviceName = env->NewStringUTF(nAudioPort->name); ScopedLocalRef<jstring> jDeviceName(env, env->NewStringUTF(nAudioPort->name));
if (nAudioPort->type == AUDIO_PORT_TYPE_DEVICE) { if (nAudioPort->type == AUDIO_PORT_TYPE_DEVICE) {
ALOGV("convertAudioPortFromNative is a device %08x", nAudioPort->ext.device.type); ScopedLocalRef<jintArray> jEncapsulationModes(
jstring jAddress = env->NewStringUTF(nAudioPort->ext.device.address); env,
jEncapsulationModes = convertEncapsulationInfoFromNative(env,
convertEncapsulationInfoFromNative(env, nAudioPort->ext.device.encapsulation_modes); nAudioPort->ext.device.encapsulation_modes));
jEncapsulationMetadataTypes = ScopedLocalRef<jintArray> jEncapsulationMetadataTypes(
env,
convertEncapsulationInfoFromNative(env, convertEncapsulationInfoFromNative(env,
nAudioPort->ext.device nAudioPort->ext.device
.encapsulation_metadata_types); .encapsulation_metadata_types));
*jAudioPort = ALOGV("convertAudioPortFromNative is a device %08x", nAudioPort->ext.device.type);
env->NewObject(gAudioDevicePortClass, gAudioDevicePortCstor, jHandle, jDeviceName, jstring jAddress = env->NewStringUTF(nAudioPort->ext.device.address);
jAudioProfiles, jGains, nAudioPort->ext.device.type, jAddress, jAudioPort->reset(
jEncapsulationModes, jEncapsulationMetadataTypes, jAudioDescriptors); env->NewObject(gAudioDevicePortClass, gAudioDevicePortCstor, jHandle.get(),
jDeviceName.get(), jAudioProfiles.get(), jGains.get(),
nAudioPort->ext.device.type, jAddress, jEncapsulationModes.get(),
jEncapsulationMetadataTypes.get(), jAudioDescriptors.get()));
env->DeleteLocalRef(jAddress); env->DeleteLocalRef(jAddress);
} else if (nAudioPort->type == AUDIO_PORT_TYPE_MIX) { } else if (nAudioPort->type == AUDIO_PORT_TYPE_MIX) {
ALOGV("convertAudioPortFromNative is a mix"); ALOGV("convertAudioPortFromNative is a mix");
*jAudioPort = env->NewObject(gAudioMixPortClass, gAudioMixPortCstor, jHandle, jAudioPort->reset(env->NewObject(gAudioMixPortClass, gAudioMixPortCstor, jHandle.get(),
nAudioPort->ext.mix.handle, nAudioPort->role, jDeviceName, nAudioPort->ext.mix.handle, nAudioPort->role,
jAudioProfiles, jGains); jDeviceName.get(), jAudioProfiles.get(), jGains.get()));
} else { } else {
ALOGE("convertAudioPortFromNative unknown nAudioPort type %d", nAudioPort->type); ALOGE("convertAudioPortFromNative unknown nAudioPort type %d", nAudioPort->type);
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
if (*jAudioPort == NULL) { if (*jAudioPort == NULL) {
jStatus = (jint)AUDIO_JAVA_ERROR; return (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
jStatus = convertAudioPortConfigFromNative(env, ScopedLocalRef<jobject> jAudioPortConfig(env, nullptr);
*jAudioPort,
&jAudioPortConfig, if (int jStatus = convertAudioPortConfigFromNative(env, jAudioPort, &jAudioPortConfig,
&nAudioPort->active_config); &nAudioPort->active_config);
if (jStatus != AUDIO_JAVA_SUCCESS) { jStatus != AUDIO_JAVA_SUCCESS) {
goto exit;
}
env->SetObjectField(*jAudioPort, gAudioPortFields.mActiveConfig, jAudioPortConfig);
exit:
if (jDeviceName != NULL) {
env->DeleteLocalRef(jDeviceName);
}
if (jEncapsulationModes != NULL) {
env->DeleteLocalRef(jEncapsulationModes);
}
if (jEncapsulationMetadataTypes != NULL) {
env->DeleteLocalRef(jEncapsulationMetadataTypes);
}
if (jAudioProfiles != NULL) {
env->DeleteLocalRef(jAudioProfiles);
}
if (jGains != NULL) {
env->DeleteLocalRef(jGains);
}
if (jHandle != NULL) {
env->DeleteLocalRef(jHandle);
}
if (jAudioPortConfig != NULL) {
env->DeleteLocalRef(jAudioPortConfig);
}
if (jAudioDescriptors != nullptr) {
env->DeleteLocalRef(jAudioDescriptors);
}
return jStatus; return jStatus;
}
env->SetObjectField(jAudioPort->get(), gAudioPortFields.mActiveConfig, jAudioPortConfig.get());
return AUDIO_JAVA_SUCCESS;
}
static bool setGeneration(JNIEnv *env, jintArray jGeneration, unsigned int generation1) {
ScopedIntArrayRW nGeneration(env, jGeneration);
if (nGeneration.get() == nullptr) {
return false;
} else {
nGeneration[0] = generation1;
return true;
}
} }
static jint static jint
@@ -1598,8 +1540,7 @@ android_media_AudioSystem_listAudioPorts(JNIEnv *env, jobject clazz,
unsigned int generation1; unsigned int generation1;
unsigned int generation; unsigned int generation;
unsigned int numPorts; unsigned int numPorts;
jint *nGeneration; std::vector<audio_port_v7> nPorts;
struct audio_port_v7 *nPorts = nullptr;
int attempts = MAX_PORT_GENERATION_SYNC_ATTEMPTS; int attempts = MAX_PORT_GENERATION_SYNC_ATTEMPTS;
jint jStatus; jint jStatus;
@@ -1618,43 +1559,39 @@ android_media_AudioSystem_listAudioPorts(JNIEnv *env, jobject clazz,
break; break;
} }
if (numPorts == 0) { if (numPorts == 0) {
jStatus = (jint)AUDIO_JAVA_SUCCESS; return setGeneration(env, jGeneration, generation1) ? AUDIO_JAVA_SUCCESS
goto exit; : AUDIO_JAVA_ERROR;
} }
nPorts = (struct audio_port_v7 *)realloc(nPorts, numPorts * sizeof(struct audio_port_v7)); nPorts.resize(numPorts);
status = AudioSystem::listAudioPorts(AUDIO_PORT_ROLE_NONE, AUDIO_PORT_TYPE_NONE, &numPorts, status = AudioSystem::listAudioPorts(AUDIO_PORT_ROLE_NONE, AUDIO_PORT_TYPE_NONE, &numPorts,
nPorts, &generation); &nPorts[0], &generation);
ALOGV("listAudioPorts AudioSystem::listAudioPorts numPorts %d generation %d generation1 %d", ALOGV("listAudioPorts AudioSystem::listAudioPorts numPorts %d generation %d generation1 %d",
numPorts, generation, generation1); numPorts, generation, generation1);
} while (generation1 != generation && status == NO_ERROR); } while (generation1 != generation && status == NO_ERROR);
jStatus = nativeToJavaStatus(status); jStatus = nativeToJavaStatus(status);
if (jStatus != AUDIO_JAVA_SUCCESS) { if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit; if (!setGeneration(env, jGeneration, generation1)) {
jStatus = AUDIO_JAVA_ERROR;
}
return jStatus;
} }
for (size_t i = 0; i < numPorts; i++) { for (size_t i = 0; i < numPorts; i++) {
jobject jAudioPort = NULL; ScopedLocalRef<jobject> jAudioPort(env, nullptr);
jStatus = convertAudioPortFromNative(env, &jAudioPort, &nPorts[i]); jStatus = convertAudioPortFromNative(env, &jAudioPort, &nPorts[i]);
if (jStatus != AUDIO_JAVA_SUCCESS) { if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit; if (!setGeneration(env, jGeneration, generation1)) {
jStatus = AUDIO_JAVA_ERROR;
} }
env->CallBooleanMethod(jPorts, gArrayListMethods.add, jAudioPort); return jStatus;
if (jAudioPort != NULL) {
env->DeleteLocalRef(jAudioPort);
} }
env->CallBooleanMethod(jPorts, gArrayListMethods.add, jAudioPort.get());
} }
if (!setGeneration(env, jGeneration, generation1)) {
exit: jStatus = AUDIO_JAVA_ERROR;
nGeneration = env->GetIntArrayElements(jGeneration, NULL);
if (nGeneration == NULL) {
jStatus = (jint)AUDIO_JAVA_ERROR;
} else {
nGeneration[0] = generation1;
env->ReleaseIntArrayElements(jGeneration, nGeneration, 0);
} }
free(nPorts);
return jStatus; return jStatus;
} }
@@ -1684,47 +1621,38 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz,
} }
audio_patch_handle_t handle = (audio_patch_handle_t)0; audio_patch_handle_t handle = (audio_patch_handle_t)0;
jobject jPatch = env->GetObjectArrayElement(jPatches, 0); ScopedLocalRef<jobject> jPatch(env, env->GetObjectArrayElement(jPatches, 0));
jobject jPatchHandle = NULL; ScopedLocalRef<jobject> jPatchHandle(env, nullptr);
if (jPatch != NULL) { if (jPatch != NULL) {
if (!env->IsInstanceOf(jPatch, gAudioPatchClass)) { if (!env->IsInstanceOf(jPatch.get(), gAudioPatchClass)) {
return (jint)AUDIO_JAVA_BAD_VALUE; return (jint)AUDIO_JAVA_BAD_VALUE;
} }
jPatchHandle = env->GetObjectField(jPatch, gAudioPatchFields.mHandle); jPatchHandle.reset(env->GetObjectField(jPatch.get(), gAudioPatchFields.mHandle));
handle = (audio_patch_handle_t)env->GetIntField(jPatchHandle, gAudioHandleFields.mId); handle = (audio_patch_handle_t)env->GetIntField(jPatchHandle.get(), gAudioHandleFields.mId);
} }
struct audio_patch nPatch = { .id = handle }; struct audio_patch nPatch = { .id = handle };
jobject jSource = NULL;
jobject jSink = NULL;
for (jint i = 0; i < numSources; i++) { for (jint i = 0; i < numSources; i++) {
jSource = env->GetObjectArrayElement(jSources, i); ScopedLocalRef<jobject> jSource(env, env->GetObjectArrayElement(jSources, i));
if (!env->IsInstanceOf(jSource, gAudioPortConfigClass)) { if (!env->IsInstanceOf(jSource.get(), gAudioPortConfigClass)) {
jStatus = (jint)AUDIO_JAVA_BAD_VALUE; return (jint)AUDIO_JAVA_BAD_VALUE;
goto exit;
} }
jStatus = convertAudioPortConfigToNative(env, &nPatch.sources[i], jSource, false); jStatus = convertAudioPortConfigToNative(env, &nPatch.sources[i], jSource.get(), false);
env->DeleteLocalRef(jSource);
jSource = NULL;
if (jStatus != AUDIO_JAVA_SUCCESS) { if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit; return jStatus;
} }
nPatch.num_sources++; nPatch.num_sources++;
} }
for (jint i = 0; i < numSinks; i++) { for (jint i = 0; i < numSinks; i++) {
jSink = env->GetObjectArrayElement(jSinks, i); ScopedLocalRef<jobject> jSink(env, env->GetObjectArrayElement(jSinks, i));
if (!env->IsInstanceOf(jSink, gAudioPortConfigClass)) { if (!env->IsInstanceOf(jSink.get(), gAudioPortConfigClass)) {
jStatus = (jint)AUDIO_JAVA_BAD_VALUE; return (jint)AUDIO_JAVA_BAD_VALUE;
goto exit;
} }
jStatus = convertAudioPortConfigToNative(env, &nPatch.sinks[i], jSink, false); jStatus = convertAudioPortConfigToNative(env, &nPatch.sinks[i], jSink.get(), false);
env->DeleteLocalRef(jSink);
jSink = NULL;
if (jStatus != AUDIO_JAVA_SUCCESS) { if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit; return jStatus;
} }
nPatch.num_sinks++; nPatch.num_sinks++;
} }
@@ -1735,38 +1663,22 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz,
jStatus = nativeToJavaStatus(status); jStatus = nativeToJavaStatus(status);
if (jStatus != AUDIO_JAVA_SUCCESS) { if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit; return jStatus;
} }
if (jPatchHandle == NULL) { if (jPatchHandle == nullptr) {
jPatchHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor, jPatchHandle.reset(env->NewObject(gAudioHandleClass, gAudioHandleCstor, handle));
handle); if (jPatchHandle == nullptr) {
if (jPatchHandle == NULL) { return (jint)AUDIO_JAVA_ERROR;
jStatus = (jint)AUDIO_JAVA_ERROR;
goto exit;
} }
jPatch = env->NewObject(gAudioPatchClass, gAudioPatchCstor, jPatchHandle, jSources, jSinks); jPatch.reset(env->NewObject(gAudioPatchClass, gAudioPatchCstor, jPatchHandle.get(),
if (jPatch == NULL) { jSources, jSinks));
jStatus = (jint)AUDIO_JAVA_ERROR; if (jPatch == nullptr) {
goto exit; return (jint)AUDIO_JAVA_ERROR;
} }
env->SetObjectArrayElement(jPatches, 0, jPatch); env->SetObjectArrayElement(jPatches, 0, jPatch.get());
} else { } else {
env->SetIntField(jPatchHandle, gAudioHandleFields.mId, handle); env->SetIntField(jPatchHandle.get(), gAudioHandleFields.mId, handle);
}
exit:
if (jPatchHandle != NULL) {
env->DeleteLocalRef(jPatchHandle);
}
if (jPatch != NULL) {
env->DeleteLocalRef(jPatch);
}
if (jSource != NULL) {
env->DeleteLocalRef(jSource);
}
if (jSink != NULL) {
env->DeleteLocalRef(jSink);
} }
return jStatus; return jStatus;
} }
@@ -1818,13 +1730,7 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz,
unsigned int generation1; unsigned int generation1;
unsigned int generation; unsigned int generation;
unsigned int numPatches; unsigned int numPatches;
jint *nGeneration; std::vector<audio_patch> nPatches;
struct audio_patch *nPatches = NULL;
jobjectArray jSources = NULL;
jobject jSource = NULL;
jobjectArray jSinks = NULL;
jobject jSink = NULL;
jobject jPatch = NULL;
int attempts = MAX_PORT_GENERATION_SYNC_ATTEMPTS; int attempts = MAX_PORT_GENERATION_SYNC_ATTEMPTS;
jint jStatus; jint jStatus;
@@ -1845,15 +1751,13 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz,
break; break;
} }
if (numPatches == 0) { if (numPatches == 0) {
jStatus = (jint)AUDIO_JAVA_SUCCESS; return setGeneration(env, jGeneration, generation1) ? AUDIO_JAVA_SUCCESS
goto exit; : AUDIO_JAVA_ERROR;
} }
nPatches = (struct audio_patch *)realloc(nPatches, numPatches * sizeof(struct audio_patch)); nPatches.resize(numPatches);
status = AudioSystem::listAudioPatches(&numPatches, status = AudioSystem::listAudioPatches(&numPatches, &nPatches[0], &generation);
nPatches,
&generation);
ALOGV("listAudioPatches AudioSystem::listAudioPatches numPatches %d generation %d generation1 %d", ALOGV("listAudioPatches AudioSystem::listAudioPatches numPatches %d generation %d generation1 %d",
numPatches, generation, generation1); numPatches, generation, generation1);
@@ -1861,15 +1765,21 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz,
jStatus = nativeToJavaStatus(status); jStatus = nativeToJavaStatus(status);
if (jStatus != AUDIO_JAVA_SUCCESS) { if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit; if (!setGeneration(env, jGeneration, generation1)) {
jStatus = AUDIO_JAVA_ERROR;
}
return jStatus;
} }
for (size_t i = 0; i < numPatches; i++) { for (size_t i = 0; i < numPatches; i++) {
ScopedLocalRef<jobject> jPatch(env, nullptr);
ScopedLocalRef<jobjectArray> jSources(env, nullptr);
ScopedLocalRef<jobjectArray> jSinks(env, nullptr);
jobject patchHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor, jobject patchHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor,
nPatches[i].id); nPatches[i].id);
if (patchHandle == NULL) { if (patchHandle == NULL) {
jStatus = AUDIO_JAVA_ERROR; setGeneration(env, jGeneration, generation1);
goto exit; return AUDIO_JAVA_ERROR;
} }
ALOGV("listAudioPatches patch %zu num_sources %d num_sinks %d", ALOGV("listAudioPatches patch %zu num_sources %d num_sinks %d",
i, nPatches[i].num_sources, nPatches[i].num_sinks); i, nPatches[i].num_sources, nPatches[i].num_sinks);
@@ -1877,96 +1787,67 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz,
env->SetIntField(patchHandle, gAudioHandleFields.mId, nPatches[i].id); env->SetIntField(patchHandle, gAudioHandleFields.mId, nPatches[i].id);
// load sources // load sources
jSources = env->NewObjectArray(nPatches[i].num_sources, jSources.reset(env->NewObjectArray(nPatches[i].num_sources, gAudioPortConfigClass, NULL));
gAudioPortConfigClass, NULL); if (jSources == nullptr) {
if (jSources == NULL) { setGeneration(env, jGeneration, generation1);
jStatus = AUDIO_JAVA_ERROR; return AUDIO_JAVA_ERROR;
goto exit;
} }
for (size_t j = 0; j < nPatches[i].num_sources; j++) { for (size_t j = 0; j < nPatches[i].num_sources; j++) {
jStatus = convertAudioPortConfigFromNative(env, ScopedLocalRef<jobject> jSource(env, nullptr);
NULL, ScopedLocalRef<jobject> jAudioPort(env, nullptr);
&jSource, jStatus = convertAudioPortConfigFromNative(env, &jAudioPort, &jSource,
&nPatches[i].sources[j]); &nPatches[i].sources[j]);
if (jStatus != AUDIO_JAVA_SUCCESS) { if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit; if (!setGeneration(env, jGeneration, generation1)) {
jStatus = AUDIO_JAVA_ERROR;
} }
env->SetObjectArrayElement(jSources, j, jSource); return jStatus;
env->DeleteLocalRef(jSource); }
jSource = NULL; env->SetObjectArrayElement(jSources.get(), j, jSource.get());
ALOGV("listAudioPatches patch %zu source %zu is a %s handle %d", ALOGV("listAudioPatches patch %zu source %zu is a %s handle %d",
i, j, i, j,
nPatches[i].sources[j].type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix", nPatches[i].sources[j].type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix",
nPatches[i].sources[j].id); nPatches[i].sources[j].id);
} }
// load sinks // load sinks
jSinks = env->NewObjectArray(nPatches[i].num_sinks, jSinks.reset(env->NewObjectArray(nPatches[i].num_sinks, gAudioPortConfigClass, NULL));
gAudioPortConfigClass, NULL); if (jSinks == nullptr) {
if (jSinks == NULL) { setGeneration(env, jGeneration, generation1);
jStatus = AUDIO_JAVA_ERROR; return AUDIO_JAVA_ERROR;
goto exit;
} }
for (size_t j = 0; j < nPatches[i].num_sinks; j++) { for (size_t j = 0; j < nPatches[i].num_sinks; j++) {
jStatus = convertAudioPortConfigFromNative(env, ScopedLocalRef<jobject> jSink(env, nullptr);
NULL, ScopedLocalRef<jobject> jAudioPort(env, nullptr);
&jSink, jStatus = convertAudioPortConfigFromNative(env, &jAudioPort, &jSink,
&nPatches[i].sinks[j]); &nPatches[i].sinks[j]);
if (jStatus != AUDIO_JAVA_SUCCESS) { if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit; if (!setGeneration(env, jGeneration, generation1)) {
jStatus = AUDIO_JAVA_ERROR;
} }
env->SetObjectArrayElement(jSinks, j, jSink); return jStatus;
env->DeleteLocalRef(jSink); }
jSink = NULL; env->SetObjectArrayElement(jSinks.get(), j, jSink.get());
ALOGV("listAudioPatches patch %zu sink %zu is a %s handle %d", ALOGV("listAudioPatches patch %zu sink %zu is a %s handle %d",
i, j, i, j,
nPatches[i].sinks[j].type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix", nPatches[i].sinks[j].type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix",
nPatches[i].sinks[j].id); nPatches[i].sinks[j].id);
} }
jPatch = env->NewObject(gAudioPatchClass, gAudioPatchCstor, jPatch.reset(env->NewObject(gAudioPatchClass, gAudioPatchCstor, patchHandle, jSources.get(),
patchHandle, jSources, jSinks); jSinks.get()));
env->DeleteLocalRef(jSources); if (jPatch == nullptr) {
jSources = NULL;
env->DeleteLocalRef(jSinks);
jSinks = NULL;
if (jPatch == NULL) {
jStatus = AUDIO_JAVA_ERROR; jStatus = AUDIO_JAVA_ERROR;
goto exit; setGeneration(env, jGeneration, generation1);
return AUDIO_JAVA_ERROR;
} }
env->CallBooleanMethod(jPatches, gArrayListMethods.add, jPatch); env->CallBooleanMethod(jPatches, gArrayListMethods.add, jPatch.get());
env->DeleteLocalRef(jPatch);
jPatch = NULL;
} }
if (!setGeneration(env, jGeneration, generation1)) {
exit:
nGeneration = env->GetIntArrayElements(jGeneration, NULL);
if (nGeneration == NULL) {
jStatus = AUDIO_JAVA_ERROR; jStatus = AUDIO_JAVA_ERROR;
} else {
nGeneration[0] = generation1;
env->ReleaseIntArrayElements(jGeneration, nGeneration, 0);
} }
if (jSources != NULL) {
env->DeleteLocalRef(jSources);
}
if (jSource != NULL) {
env->DeleteLocalRef(jSource);
}
if (jSinks != NULL) {
env->DeleteLocalRef(jSinks);
}
if (jSink != NULL) {
env->DeleteLocalRef(jSink);
}
if (jPatch != NULL) {
env->DeleteLocalRef(jPatch);
}
free(nPatches);
return jStatus; return jStatus;
} }
@@ -2207,21 +2088,16 @@ android_media_AudioSystem_registerPolicyMixes(JNIEnv *env, jobject clazz,
} }
status_t status; status_t status;
jint jStatus;
jobject jAudioMix = NULL;
Vector <AudioMix> mixes; Vector <AudioMix> mixes;
for (jint i = 0; i < numMixes; i++) { for (jint i = 0; i < numMixes; i++) {
jAudioMix = env->GetObjectArrayElement(jMixes, i); ScopedLocalRef<jobject> jAudioMix(env, env->GetObjectArrayElement(jMixes, i));
if (!env->IsInstanceOf(jAudioMix, gAudioMixClass)) { if (!env->IsInstanceOf(jAudioMix.get(), gAudioMixClass)) {
jStatus = (jint)AUDIO_JAVA_BAD_VALUE; return (jint)AUDIO_JAVA_BAD_VALUE;
goto exit;
} }
AudioMix mix; AudioMix mix;
jStatus = convertAudioMixToNative(env, &mix, jAudioMix); if (jint jStatus = convertAudioMixToNative(env, &mix, jAudioMix.get());
env->DeleteLocalRef(jAudioMix); jStatus != AUDIO_JAVA_SUCCESS) {
jAudioMix = NULL; return jStatus;
if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit;
} }
mixes.add(mix); mixes.add(mix);
} }
@@ -2230,16 +2106,7 @@ android_media_AudioSystem_registerPolicyMixes(JNIEnv *env, jobject clazz,
status = AudioSystem::registerPolicyMixes(mixes, registration); status = AudioSystem::registerPolicyMixes(mixes, registration);
ALOGV("AudioSystem::registerPolicyMixes() returned %d", status); ALOGV("AudioSystem::registerPolicyMixes() returned %d", status);
jStatus = nativeToJavaStatus(status); return nativeToJavaStatus(status);
if (jStatus != AUDIO_JAVA_SUCCESS) {
goto exit;
}
exit:
if (jAudioMix != NULL) {
env->DeleteLocalRef(jAudioMix);
}
return jStatus;
} }
static jint android_media_AudioSystem_setUidDeviceAffinities(JNIEnv *env, jobject clazz, static jint android_media_AudioSystem_setUidDeviceAffinities(JNIEnv *env, jobject clazz,