audio: add implementation for TV related API
1. TunerConfiguration.
2. AudioDescriptionMixLevel getter/setter.
3. DualMonoMode getter/setter.
4. PlaybackRate getter/setter.
Test: TIS player with instrumented HAL
Test: atest AudioTrackTest#testTunerConfiguration
Test: atest AudioTrackTest#testDualMonoMode
Test: atest AudioTrackTest#testAudioDescriptionMixLevel
Test: atest AudioManagerTest#testGetAdditionalOutputDeviceDelay
Bug: 173482792
Merged-In: Idb22ce6714fa240b2b4b3b8637b16d3a51228fa1
Change-Id: Idb22ce6714fa240b2b4b3b8637b16d3a51228fa1
diff --git a/media/libaudioclient/AudioTrack.cpp b/media/libaudioclient/AudioTrack.cpp
index 2c40fbb..19d1d1a 100644
--- a/media/libaudioclient/AudioTrack.cpp
+++ b/media/libaudioclient/AudioTrack.cpp
@@ -1075,6 +1075,40 @@
return mOriginalSampleRate;
}
+status_t AudioTrack::setDualMonoMode(audio_dual_mono_mode_t mode)
+{
+ AutoMutex lock(mLock);
+ return setDualMonoMode_l(mode);
+}
+
+status_t AudioTrack::setDualMonoMode_l(audio_dual_mono_mode_t mode)
+{
+ return mAudioTrack->setDualMonoMode(mode);
+}
+
+status_t AudioTrack::getDualMonoMode(audio_dual_mono_mode_t* mode) const
+{
+ AutoMutex lock(mLock);
+ return mAudioTrack->getDualMonoMode(mode);
+}
+
+status_t AudioTrack::setAudioDescriptionMixLevel(float leveldB)
+{
+ AutoMutex lock(mLock);
+ return setAudioDescriptionMixLevel_l(leveldB);
+}
+
+status_t AudioTrack::setAudioDescriptionMixLevel_l(float leveldB)
+{
+ return mAudioTrack->setAudioDescriptionMixLevel(leveldB);
+}
+
+status_t AudioTrack::getAudioDescriptionMixLevel(float* leveldB) const
+{
+ AutoMutex lock(mLock);
+ return mAudioTrack->getAudioDescriptionMixLevel(leveldB);
+}
+
status_t AudioTrack::setPlaybackRate(const AudioPlaybackRate &playbackRate)
{
AutoMutex lock(mLock);
@@ -1082,7 +1116,11 @@
return NO_ERROR;
}
if (isOffloadedOrDirect_l()) {
- return INVALID_OPERATION;
+ status_t status = mAudioTrack->setPlaybackRateParameters(playbackRate);
+ if (status == NO_ERROR) {
+ mPlaybackRate = playbackRate;
+ }
+ return status;
}
if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
return INVALID_OPERATION;
@@ -1147,9 +1185,16 @@
return NO_ERROR;
}
-const AudioPlaybackRate& AudioTrack::getPlaybackRate() const
+const AudioPlaybackRate& AudioTrack::getPlaybackRate()
{
AutoMutex lock(mLock);
+ if (isOffloadedOrDirect_l()) {
+ audio_playback_rate_t playbackRateTemp;
+ const status_t status = mAudioTrack->getPlaybackRateParameters(&playbackRateTemp);
+ if (status == NO_ERROR) { // update local version if changed.
+ mPlaybackRate = playbackRateTemp;
+ }
+ }
return mPlaybackRate;
}
@@ -1745,6 +1790,13 @@
mProxy->setPlaybackRate(playbackRateTemp);
mProxy->setMinimum(mNotificationFramesAct);
+ if (mDualMonoMode != AUDIO_DUAL_MONO_MODE_OFF) {
+ setDualMonoMode_l(mDualMonoMode);
+ }
+ if (mAudioDescriptionMixLeveldB != -std::numeric_limits<float>::infinity()) {
+ setAudioDescriptionMixLevel_l(mAudioDescriptionMixLeveldB);
+ }
+
mDeathNotifier = new DeathNotifier(this);
IInterface::asBinder(mAudioTrack)->linkToDeath(mDeathNotifier, this);
diff --git a/media/libaudioclient/IAudioTrack.cpp b/media/libaudioclient/IAudioTrack.cpp
index 6219e7a..6fcf300 100644
--- a/media/libaudioclient/IAudioTrack.cpp
+++ b/media/libaudioclient/IAudioTrack.cpp
@@ -44,6 +44,12 @@
SIGNAL,
APPLY_VOLUME_SHAPER,
GET_VOLUME_SHAPER_STATE,
+ SET_DUAL_MONO_MODE,
+ GET_DUAL_MONO_MODE,
+ SET_AUDIO_DESCRIPTION_MIX_LEVEL,
+ GET_AUDIO_DESCRIPTION_MIX_LEVEL,
+ SET_PLAYBACK_RATE_PARAMETERS,
+ GET_PLAYBACK_RATE_PARAMETERS,
};
class BpAudioTrack : public BpInterface<IAudioTrack>
@@ -207,6 +213,92 @@
}
return state;
}
+
+ status_t getDualMonoMode(audio_dual_mono_mode_t* mode) override {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
+ status_t status = remote()->transact(GET_DUAL_MONO_MODE, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = (status_t)reply.readInt32();
+ if (status != NO_ERROR) {
+ return status;
+ }
+ *mode = (audio_dual_mono_mode_t)reply.readInt32();
+ return NO_ERROR;
+ }
+
+ status_t setDualMonoMode(audio_dual_mono_mode_t mode) override {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
+ data.writeInt32((int32_t)mode);
+ status_t status = remote()->transact(SET_DUAL_MONO_MODE, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ return reply.readInt32();
+ }
+
+ status_t getAudioDescriptionMixLevel(float* leveldB) override {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
+ status_t status = remote()->transact(GET_AUDIO_DESCRIPTION_MIX_LEVEL, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = (status_t)reply.readInt32();
+ if (status != NO_ERROR) {
+ return status;
+ }
+ *leveldB = reply.readFloat();
+ return NO_ERROR;
+ }
+
+ status_t setAudioDescriptionMixLevel(float leveldB) override {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
+ data.writeFloat(leveldB);
+ status_t status = remote()->transact(SET_AUDIO_DESCRIPTION_MIX_LEVEL, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ return reply.readInt32();
+ }
+
+ status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) override {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
+ status_t status = remote()->transact(GET_PLAYBACK_RATE_PARAMETERS, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = (status_t)reply.readInt32();
+ if (status != NO_ERROR) {
+ return status;
+ }
+ playbackRate->mSpeed = reply.readFloat();
+ playbackRate->mPitch = reply.readFloat();
+ playbackRate->mStretchMode =
+ static_cast<audio_timestretch_stretch_mode_t>(reply.readInt32());
+ playbackRate->mFallbackMode =
+ static_cast<audio_timestretch_fallback_mode_t>(reply.readInt32());
+ return NO_ERROR;
+ }
+
+ status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) override {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
+ data.writeFloat(playbackRate.mSpeed);
+ data.writeFloat(playbackRate.mPitch);
+ data.writeInt32(playbackRate.mStretchMode);
+ data.writeInt32(playbackRate.mFallbackMode);
+ status_t status = remote()->transact(SET_PLAYBACK_RATE_PARAMETERS, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ return reply.readInt32();
+ }
};
IMPLEMENT_META_INTERFACE(AudioTrack, "android.media.IAudioTrack");
@@ -309,6 +401,59 @@
}
return NO_ERROR;
} break;
+ case SET_DUAL_MONO_MODE: {
+ CHECK_INTERFACE(IAudioTrack, data, reply);
+ reply->writeInt32( setDualMonoMode((audio_dual_mono_mode_t)data.readInt32()) );
+ return NO_ERROR;
+ } break;
+ case GET_DUAL_MONO_MODE: {
+ CHECK_INTERFACE(IAudioTrack, data, reply);
+ audio_dual_mono_mode_t mode;
+ const status_t status = getDualMonoMode(&mode);
+ reply->writeInt32((int32_t)status);
+ if (status == NO_ERROR) {
+ reply->writeInt32(mode);
+ }
+ return NO_ERROR;
+ } break;
+ case SET_AUDIO_DESCRIPTION_MIX_LEVEL: {
+ CHECK_INTERFACE(IAudioTrack, data, reply);
+ reply->writeInt32( setAudioDescriptionMixLevel(data.readFloat()) );
+ return NO_ERROR;
+ } break;
+ case GET_AUDIO_DESCRIPTION_MIX_LEVEL: {
+ CHECK_INTERFACE(IAudioTrack, data, reply);
+ float f;
+ const status_t status = getAudioDescriptionMixLevel(&f);
+ reply->writeInt32((int32_t)status);
+ if (status == NO_ERROR) {
+ reply->writeFloat(f);
+ }
+ return NO_ERROR;
+ } break;
+ case SET_PLAYBACK_RATE_PARAMETERS: {
+ CHECK_INTERFACE(IAudioTrack, data, reply);
+ audio_playback_rate_t playbackRate = {
+ data.readFloat(),
+ data.readFloat(),
+ static_cast<audio_timestretch_stretch_mode_t>(data.readInt32()),
+ static_cast<audio_timestretch_fallback_mode_t>(data.readInt32())};
+ reply->writeInt32( setPlaybackRateParameters(playbackRate) );
+ return NO_ERROR;
+ } break;
+ case GET_PLAYBACK_RATE_PARAMETERS: {
+ CHECK_INTERFACE(IAudioTrack, data, reply);
+ audio_playback_rate_t playbackRate;
+ const status_t status = getPlaybackRateParameters(&playbackRate);
+ reply->writeInt32((int32_t)status);
+ if (status == NO_ERROR) {
+ reply->writeFloat(playbackRate.mSpeed);
+ reply->writeFloat(playbackRate.mPitch);
+ reply->writeInt32(playbackRate.mStretchMode);
+ reply->writeInt32(playbackRate.mFallbackMode);
+ }
+ return NO_ERROR;
+ } break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/media/libaudioclient/include/media/AudioTrack.h b/media/libaudioclient/include/media/AudioTrack.h
index de183d8..fac4c83 100644
--- a/media/libaudioclient/include/media/AudioTrack.h
+++ b/media/libaudioclient/include/media/AudioTrack.h
@@ -513,6 +513,18 @@
*/
uint32_t getOriginalSampleRate() const;
+ /* Sets the Dual Mono mode presentation on the output device. */
+ status_t setDualMonoMode(audio_dual_mono_mode_t mode);
+
+ /* Returns the Dual Mono mode presentation setting. */
+ status_t getDualMonoMode(audio_dual_mono_mode_t* mode) const;
+
+ /* Sets the Audio Description Mix level in dB. */
+ status_t setAudioDescriptionMixLevel(float leveldB);
+
+ /* Returns the Audio Description Mix level in dB. */
+ status_t getAudioDescriptionMixLevel(float* leveldB) const;
+
/* Set source playback rate for timestretch
* 1.0 is normal speed: < 1.0 is slower, > 1.0 is faster
* 1.0 is normal pitch: < 1.0 is lower pitch, > 1.0 is higher pitch
@@ -526,7 +538,7 @@
status_t setPlaybackRate(const AudioPlaybackRate &playbackRate);
/* Return current playback rate */
- const AudioPlaybackRate& getPlaybackRate() const;
+ const AudioPlaybackRate& getPlaybackRate();
/* Enables looping and sets the start and end points of looping.
* Only supported for static buffer mode.
@@ -1070,6 +1082,12 @@
void updateRoutedDeviceId_l();
+ /* Sets the Dual Mono mode presentation on the output device. */
+ status_t setDualMonoMode_l(audio_dual_mono_mode_t mode);
+
+ /* Sets the Audio Description Mix level in dB. */
+ status_t setAudioDescriptionMixLevel_l(float leveldB);
+
// Next 4 fields may be changed if IAudioTrack is re-created, but always != 0
sp<IAudioTrack> mAudioTrack;
sp<IMemory> mCblkMemory;
@@ -1282,6 +1300,10 @@
wp<AudioSystem::AudioDeviceCallback> mDeviceCallback;
+ // Cached values to restore along with the AudioTrack.
+ audio_dual_mono_mode_t mDualMonoMode = AUDIO_DUAL_MONO_MODE_OFF;
+ float mAudioDescriptionMixLeveldB = -std::numeric_limits<float>::infinity();
+
private:
class MediaMetrics {
public:
diff --git a/media/libaudioclient/include/media/IAudioTrack.h b/media/libaudioclient/include/media/IAudioTrack.h
index 06e786d..dbbbf35 100644
--- a/media/libaudioclient/include/media/IAudioTrack.h
+++ b/media/libaudioclient/include/media/IAudioTrack.h
@@ -27,6 +27,7 @@
#include <utils/String8.h>
#include <media/AudioTimestamp.h>
#include <media/VolumeShaper.h>
+#include <system/audio.h>
namespace android {
@@ -86,6 +87,24 @@
/* gets the volume shaper state */
virtual sp<media::VolumeShaper::State> getVolumeShaperState(int id) = 0;
+
+ /* Returns the Dual Mono mode presentation setting. */
+ virtual status_t getDualMonoMode(audio_dual_mono_mode_t* mode) = 0;
+
+ /* Sets the Dual Mono mode presentation on the output device. */
+ virtual status_t setDualMonoMode(audio_dual_mono_mode_t mode) = 0;
+
+ /* Returns the Audio Description Mix level in dB. */
+ virtual status_t getAudioDescriptionMixLevel(float* leveldB) = 0;
+
+ /* Sets the Audio Description Mix level in dB. */
+ virtual status_t setAudioDescriptionMixLevel(float leveldB) = 0;
+
+ /* Retrieves current playback rate parameters. */
+ virtual status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) = 0;
+
+ /* Sets the playback rate parameters that control playback behavior. */
+ virtual status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) = 0;
};
// ----------------------------------------------------------------------------
diff --git a/media/libaudiohal/impl/ConversionHelperHidl.cpp b/media/libaudiohal/impl/ConversionHelperHidl.cpp
index ebed5fd..cf07a47 100644
--- a/media/libaudiohal/impl/ConversionHelperHidl.cpp
+++ b/media/libaudiohal/impl/ConversionHelperHidl.cpp
@@ -50,12 +50,20 @@
halKeys.get(String8(AUDIO_PARAMETER_DEVICE_SUP_ENCAPSULATION_METADATA_TYPES),
value) == NO_ERROR;
+ const bool keepDelayValue =
+ halKeys.get(String8(AUDIO_PARAMETER_DEVICE_ADDITIONAL_OUTPUT_DELAY),
+ value) == NO_ERROR ||
+ halKeys.get(String8(AUDIO_PARAMETER_DEVICE_MAX_ADDITIONAL_OUTPUT_DELAY),
+ value) == NO_ERROR;
+
for (size_t i = 0; i < halKeys.size(); ++i) {
String8 key;
status_t status = halKeys.getAt(i, key);
if (status != OK) return status;
if ((keepFormatValue && key == AudioParameter::keyFormat) ||
- (keepRoutingValue && key == AudioParameter::keyRouting)) {
+ (keepRoutingValue && key == AudioParameter::keyRouting) ||
+ (keepDelayValue && key == AUDIO_PARAMETER_DEVICE_ADDITIONAL_OUTPUT_DELAY) ||
+ (keepDelayValue && key == AUDIO_PARAMETER_DEVICE_MAX_ADDITIONAL_OUTPUT_DELAY)) {
AudioParameter keepValueParam;
halKeys.getAt(i, key, value);
keepValueParam.add(key, value);
diff --git a/media/libaudiohal/impl/StreamHalHidl.cpp b/media/libaudiohal/impl/StreamHalHidl.cpp
index 09a7c1c..8a9eec3 100644
--- a/media/libaudiohal/impl/StreamHalHidl.cpp
+++ b/media/libaudiohal/impl/StreamHalHidl.cpp
@@ -636,6 +636,32 @@
#endif
#if MAJOR_VERSION < 6
+status_t StreamOutHalHidl::getDualMonoMode(audio_dual_mono_mode_t* mode __unused) {
+ return INVALID_OPERATION;
+}
+
+status_t StreamOutHalHidl::setDualMonoMode(audio_dual_mono_mode_t mode __unused) {
+ return INVALID_OPERATION;
+}
+
+status_t StreamOutHalHidl::getAudioDescriptionMixLevel(float* leveldB __unused) {
+ return INVALID_OPERATION;
+}
+
+status_t StreamOutHalHidl::setAudioDescriptionMixLevel(float leveldB __unused) {
+ return INVALID_OPERATION;
+}
+
+status_t StreamOutHalHidl::getPlaybackRateParameters(
+ audio_playback_rate_t* playbackRate __unused) {
+ return INVALID_OPERATION;
+}
+
+status_t StreamOutHalHidl::setPlaybackRateParameters(
+ const audio_playback_rate_t& playbackRate __unused) {
+ return INVALID_OPERATION;
+}
+
status_t StreamOutHalHidl::setEventCallback(
const sp<StreamOutHalInterfaceEventCallback>& callback __unused) {
// Codec format callback is supported starting from audio HAL V6.0
@@ -643,6 +669,73 @@
}
#else
+status_t StreamOutHalHidl::getDualMonoMode(audio_dual_mono_mode_t* mode) {
+ if (mStream == 0) return NO_INIT;
+ Result retval;
+ Return<void> ret = mStream->getDualMonoMode(
+ [&](Result r, DualMonoMode hidlMode) {
+ retval = r;
+ if (retval == Result::OK) {
+ *mode = static_cast<audio_dual_mono_mode_t>(hidlMode);
+ }
+ });
+ return processReturn("getDualMonoMode", ret, retval);
+}
+
+status_t StreamOutHalHidl::setDualMonoMode(audio_dual_mono_mode_t mode) {
+ if (mStream == 0) return NO_INIT;
+ return processReturn(
+ "setDualMonoMode", mStream->setDualMonoMode(static_cast<DualMonoMode>(mode)));
+}
+
+status_t StreamOutHalHidl::getAudioDescriptionMixLevel(float* leveldB) {
+ if (mStream == 0) return NO_INIT;
+ Result retval;
+ Return<void> ret = mStream->getAudioDescriptionMixLevel(
+ [&](Result r, float hidlLeveldB) {
+ retval = r;
+ if (retval == Result::OK) {
+ *leveldB = hidlLeveldB;
+ }
+ });
+ return processReturn("getAudioDescriptionMixLevel", ret, retval);
+}
+
+status_t StreamOutHalHidl::setAudioDescriptionMixLevel(float leveldB) {
+ if (mStream == 0) return NO_INIT;
+ return processReturn(
+ "setAudioDescriptionMixLevel", mStream->setAudioDescriptionMixLevel(leveldB));
+}
+
+status_t StreamOutHalHidl::getPlaybackRateParameters(audio_playback_rate_t* playbackRate) {
+ if (mStream == 0) return NO_INIT;
+ Result retval;
+ Return<void> ret = mStream->getPlaybackRateParameters(
+ [&](Result r, PlaybackRate hidlPlaybackRate) {
+ retval = r;
+ if (retval == Result::OK) {
+ playbackRate->mSpeed = hidlPlaybackRate.speed;
+ playbackRate->mPitch = hidlPlaybackRate.pitch;
+ playbackRate->mStretchMode =
+ static_cast<audio_timestretch_stretch_mode_t>(
+ hidlPlaybackRate.timestretchMode);
+ playbackRate->mFallbackMode =
+ static_cast<audio_timestretch_fallback_mode_t>(
+ hidlPlaybackRate.fallbackMode);
+ }
+ });
+ return processReturn("getPlaybackRateParameters", ret, retval);
+}
+
+status_t StreamOutHalHidl::setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) {
+ if (mStream == 0) return NO_INIT;
+ return processReturn(
+ "setPlaybackRateParameters", mStream->setPlaybackRateParameters(
+ PlaybackRate{playbackRate.mSpeed, playbackRate.mPitch,
+ static_cast<TimestretchMode>(playbackRate.mStretchMode),
+ static_cast<TimestretchFallbackMode>(playbackRate.mFallbackMode)}));
+}
+
#include PATH(android/hardware/audio/FILE_VERSION/IStreamOutEventCallback.h)
namespace {
diff --git a/media/libaudiohal/impl/StreamHalHidl.h b/media/libaudiohal/impl/StreamHalHidl.h
index 88f8587..2db4973 100644
--- a/media/libaudiohal/impl/StreamHalHidl.h
+++ b/media/libaudiohal/impl/StreamHalHidl.h
@@ -173,6 +173,24 @@
void onDrainReady();
void onError();
+ // Returns the Dual Mono mode presentation setting.
+ status_t getDualMonoMode(audio_dual_mono_mode_t* mode) override;
+
+ // Sets the Dual Mono mode presentation on the output device.
+ status_t setDualMonoMode(audio_dual_mono_mode_t mode) override;
+
+ // Returns the Audio Description Mix level in dB.
+ status_t getAudioDescriptionMixLevel(float* leveldB) override;
+
+ // Sets the Audio Description Mix level in dB.
+ status_t setAudioDescriptionMixLevel(float leveldB) override;
+
+ // Retrieves current playback rate parameters.
+ status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) override;
+
+ // Sets the playback rate parameters that control playback behavior.
+ status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) override;
+
status_t setEventCallback(const sp<StreamOutHalInterfaceEventCallback>& callback) override;
// Methods used by StreamCodecFormatCallback (HIDL).
diff --git a/media/libaudiohal/impl/StreamHalLocal.cpp b/media/libaudiohal/impl/StreamHalLocal.cpp
index f544e06..a3f2fb4 100644
--- a/media/libaudiohal/impl/StreamHalLocal.cpp
+++ b/media/libaudiohal/impl/StreamHalLocal.cpp
@@ -311,6 +311,36 @@
return mStream->get_mmap_position(mStream, position);
}
+status_t StreamOutHalLocal::getDualMonoMode(audio_dual_mono_mode_t* mode) {
+ if (mStream->get_dual_mono_mode == nullptr) return INVALID_OPERATION;
+ return mStream->get_dual_mono_mode(mStream, mode);
+}
+
+status_t StreamOutHalLocal::setDualMonoMode(audio_dual_mono_mode_t mode) {
+ if (mStream->set_dual_mono_mode == nullptr) return INVALID_OPERATION;
+ return mStream->set_dual_mono_mode(mStream, mode);
+}
+
+status_t StreamOutHalLocal::getAudioDescriptionMixLevel(float* leveldB) {
+ if (mStream->get_audio_description_mix_level == nullptr) return INVALID_OPERATION;
+ return mStream->get_audio_description_mix_level(mStream, leveldB);
+}
+
+status_t StreamOutHalLocal::setAudioDescriptionMixLevel(float leveldB) {
+ if (mStream->set_audio_description_mix_level == nullptr) return INVALID_OPERATION;
+ return mStream->set_audio_description_mix_level(mStream, leveldB);
+}
+
+status_t StreamOutHalLocal::getPlaybackRateParameters(audio_playback_rate_t* playbackRate) {
+ if (mStream->get_playback_rate_parameters == nullptr) return INVALID_OPERATION;
+ return mStream->get_playback_rate_parameters(mStream, playbackRate);
+}
+
+status_t StreamOutHalLocal::setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) {
+ if (mStream->set_playback_rate_parameters == nullptr) return INVALID_OPERATION;
+ return mStream->set_playback_rate_parameters(mStream, &playbackRate);
+}
+
status_t StreamOutHalLocal::setEventCallback(
const sp<StreamOutHalInterfaceEventCallback>& callback) {
if (mStream->set_event_callback == nullptr) {
diff --git a/media/libaudiohal/impl/StreamHalLocal.h b/media/libaudiohal/impl/StreamHalLocal.h
index 8e5180f..e228104 100644
--- a/media/libaudiohal/impl/StreamHalLocal.h
+++ b/media/libaudiohal/impl/StreamHalLocal.h
@@ -156,6 +156,24 @@
// Called when the metadata of the stream's source has been changed.
status_t updateSourceMetadata(const SourceMetadata& sourceMetadata) override;
+ // Returns the Dual Mono mode presentation setting.
+ status_t getDualMonoMode(audio_dual_mono_mode_t* mode) override;
+
+ // Sets the Dual Mono mode presentation on the output device.
+ status_t setDualMonoMode(audio_dual_mono_mode_t mode) override;
+
+ // Returns the Audio Description Mix level in dB.
+ status_t getAudioDescriptionMixLevel(float* leveldB) override;
+
+ // Sets the Audio Description Mix level in dB.
+ status_t setAudioDescriptionMixLevel(float leveldB) override;
+
+ // Retrieves current playback rate parameters.
+ status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) override;
+
+ // Sets the playback rate parameters that control playback behavior.
+ status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) override;
+
status_t setEventCallback(const sp<StreamOutHalInterfaceEventCallback>& callback) override;
private:
diff --git a/media/libaudiohal/include/media/audiohal/StreamHalInterface.h b/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
index 523705e..097e9a2 100644
--- a/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
+++ b/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
@@ -160,12 +160,31 @@
struct SourceMetadata {
std::vector<playback_track_metadata_v7_t> tracks;
};
+
/**
* Called when the metadata of the stream's source has been changed.
* @param sourceMetadata Description of the audio that is played by the clients.
*/
virtual status_t updateSourceMetadata(const SourceMetadata& sourceMetadata) = 0;
+ // Returns the Dual Mono mode presentation setting.
+ virtual status_t getDualMonoMode(audio_dual_mono_mode_t* mode) = 0;
+
+ // Sets the Dual Mono mode presentation on the output device.
+ virtual status_t setDualMonoMode(audio_dual_mono_mode_t mode) = 0;
+
+ // Returns the Audio Description Mix level in dB.
+ virtual status_t getAudioDescriptionMixLevel(float* leveldB) = 0;
+
+ // Sets the Audio Description Mix level in dB.
+ virtual status_t setAudioDescriptionMixLevel(float leveldB) = 0;
+
+ // Retrieves current playback rate parameters.
+ virtual status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) = 0;
+
+ // Sets the playback rate parameters that control playback behavior.
+ virtual status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) = 0;
+
virtual status_t setEventCallback(const sp<StreamOutHalInterfaceEventCallback>& callback) = 0;
protected:
diff --git a/media/libmediahelper/AudioParameter.cpp b/media/libmediahelper/AudioParameter.cpp
index fc8306c..73c1e41 100644
--- a/media/libmediahelper/AudioParameter.cpp
+++ b/media/libmediahelper/AudioParameter.cpp
@@ -57,6 +57,10 @@
// AUDIO_PARAMETER_DEVICE_SUP_ENCAPSULATION_MODES;
// const char * const AudioParameter::keyDeviceSupportedEncapsulationMetadataTypes =
// AUDIO_PARAMETER_DEVICE_SUP_ENCAPSULATION_METADATA_TYPES;
+// const char * const AudioParameter::keyAdditionalOutputDeviceDelay =
+// AUDIO_PARAMETER_DEVICE_ADDITIONAL_OUTPUT_DELAY;
+// const char * const AudioParameter::keyMaxAdditionalOutputDeviceDelay =
+// AUDIO_PARAMETER_DEVICE_MAX_ADDITIONAL_OUTPUT_DELAY;
AudioParameter::AudioParameter(const String8& keyValuePairs)
{
diff --git a/media/libmediahelper/include/media/AudioParameter.h b/media/libmediahelper/include/media/AudioParameter.h
index 66d8dfb..b72d0d5 100644
--- a/media/libmediahelper/include/media/AudioParameter.h
+++ b/media/libmediahelper/include/media/AudioParameter.h
@@ -104,6 +104,9 @@
// static const char * const keyDeviceSupportedEncapsulationModes;
// static const char * const keyDeviceSupportedEncapsulationMetadataTypes;
+ // static const char * const keyAdditionalOutputDeviceDelay;
+ // static const char * const keyMaxAdditionalOutputDeviceDelay;
+
String8 toString() const { return toStringImpl(true); }
String8 keysToString() const { return toStringImpl(false); }