Merge "libaudiohal: extract the offload metadata from the parameters" am: 1cfcf0b74e am: 6eb188e8ba (fdb3ca4f) · Commits · e / os / android_frameworks_av

media/libaudiohal/impl/StreamHalAidl.cpp

+96 −1

Original line number	Original line	Diff line number	Diff line
	@@ -21,8 +21,11 @@
	#include <cstdint>		#include <cstdint>

	#include <audio_utils/clock.h>		#include <audio_utils/clock.h>
			#include <media/AidlConversionCppNdk.h>
	#include <media/AidlConversionUtil.h>		#include <media/AidlConversionUtil.h>
			#include <media/AudioParameter.h>
	#include <mediautils/TimeCheck.h>		#include <mediautils/TimeCheck.h>
			#include <system/audio.h>
	#include <utils/Log.h>		#include <utils/Log.h>

	#include "DeviceHalAidl.h"		#include "DeviceHalAidl.h"
	@@ -33,6 +36,7 @@ using ::aidl::android::hardware::audio::core::IStreamCommon;
	using ::aidl::android::hardware::audio::core::IStreamIn;		using ::aidl::android::hardware::audio::core::IStreamIn;
	using ::aidl::android::hardware::audio::core::IStreamOut;		using ::aidl::android::hardware::audio::core::IStreamOut;
	using ::aidl::android::hardware::audio::core::StreamDescriptor;		using ::aidl::android::hardware::audio::core::StreamDescriptor;
			using ::aidl::android::legacy2aidl_audio_channel_mask_t_AudioChannelLayout;

	namespace android {		namespace android {

	@@ -483,7 +487,13 @@ StreamOutHalAidl::StreamOutHalAidl(
	const std::shared_ptr<IStreamOut>& stream, const sp<CallbackBroker>& callbackBroker)		const std::shared_ptr<IStreamOut>& stream, const sp<CallbackBroker>& callbackBroker)
	: StreamHalAidl("StreamOutHalAidl", false /isInput/, config, nominalLatency,		: StreamHalAidl("StreamOutHalAidl", false /isInput/, config, nominalLatency,
	std::move(context), getStreamCommon(stream)),		std::move(context), getStreamCommon(stream)),
	mStream(stream), mCallbackBroker(callbackBroker) {}		mStream(stream), mCallbackBroker(callbackBroker) {
			// Initialize the offload metadata
			mOffloadMetadata.sampleRate = static_cast<int32_t>(config.sample_rate);
			mOffloadMetadata.channelMask = VALUE_OR_FATAL(
			legacy2aidl_audio_channel_mask_t_AudioChannelLayout(config.channel_mask, false));
			mOffloadMetadata.averageBitRatePerSecond = static_cast<int32_t>(config.offload_info.bit_rate);
			}

	StreamOutHalAidl::~StreamOutHalAidl() {		StreamOutHalAidl::~StreamOutHalAidl() {
	if (auto broker = mCallbackBroker.promote(); broker != nullptr) {		if (auto broker = mCallbackBroker.promote(); broker != nullptr) {
	@@ -491,6 +501,19 @@ StreamOutHalAidl::~StreamOutHalAidl() {
	}		}
	}		}

			status_t StreamOutHalAidl::setParameters(const String8& kvPairs) {
			if (!mStream) return NO_INIT;

			AudioParameter parameters(kvPairs);
			ALOGD("%s parameters: %s", __func__, parameters.toString().c_str());

			if (filterAndUpdateOffloadMetadata(parameters) != OK) {
			ALOGW("%s filtering or updating offload metadata gets failed", __func__);
			}

			return StreamHalAidl::setParameters(parameters.toString());
			}

	status_t StreamOutHalAidl::getLatency(uint32_t *latency) {		status_t StreamOutHalAidl::getLatency(uint32_t *latency) {
	return StreamHalAidl::getLatency(latency);		return StreamHalAidl::getLatency(latency);
	}		}
	@@ -693,6 +716,78 @@ status_t StreamOutHalAidl::exit() {
	return StreamHalAidl::exit();		return StreamHalAidl::exit();
	}		}

			status_t StreamOutHalAidl::filterAndUpdateOffloadMetadata(AudioParameter &parameters) {
			TIME_CHECK();

			if (parameters.containsKey(String8(AudioParameter::keyOffloadCodecAverageBitRate)) \|\|
			parameters.containsKey(String8(AudioParameter::keyOffloadCodecSampleRate)) \|\|
			parameters.containsKey(String8(AudioParameter::keyOffloadCodecChannels)) \|\|
			parameters.containsKey(String8(AudioParameter::keyOffloadCodecDelaySamples)) \|\|
			parameters.containsKey(String8(AudioParameter::keyOffloadCodecPaddingSamples))) {
			int value = 0;
			if (parameters.getInt(String8(AudioParameter::keyOffloadCodecAverageBitRate), value)
			== NO_ERROR) {
			if (value <= 0) {
			return BAD_VALUE;
			}
			mOffloadMetadata.averageBitRatePerSecond = value;
			parameters.remove(String8(AudioParameter::keyOffloadCodecAverageBitRate));
			}

			if (parameters.getInt(String8(AudioParameter::keyOffloadCodecSampleRate), value)
			== NO_ERROR) {
			if (value <= 0) {
			return BAD_VALUE;
			}
			mOffloadMetadata.sampleRate = value;
			parameters.remove(String8(AudioParameter::keyOffloadCodecSampleRate));
			}

			if (parameters.getInt(String8(AudioParameter::keyOffloadCodecChannels), value)
			== NO_ERROR) {
			if (value <= 0) {
			return BAD_VALUE;
			}
			audio_channel_mask_t channel_mask =
			audio_channel_out_mask_from_count(static_cast<uint32_t>(value));
			if (channel_mask == AUDIO_CHANNEL_INVALID) {
			return BAD_VALUE;
			}
			mOffloadMetadata.channelMask =
			VALUE_OR_RETURN_STATUS(legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
			channel_mask, false));
			parameters.remove(String8(AudioParameter::keyOffloadCodecChannels));
			}

			// The legacy keys are misnamed. The delay and padding are in frame.
			if (parameters.getInt(String8(AudioParameter::keyOffloadCodecDelaySamples), value)
			== NO_ERROR) {
			if (value < 0) {
			return BAD_VALUE;
			}
			mOffloadMetadata.delayFrames = value;
			parameters.remove(String8(AudioParameter::keyOffloadCodecDelaySamples));
			}

			if (parameters.getInt(String8(AudioParameter::keyOffloadCodecPaddingSamples), value)
			== NO_ERROR) {
			if (value < 0) {
			return BAD_VALUE;
			}
			mOffloadMetadata.paddingFrames = value;
			parameters.remove(String8(AudioParameter::keyOffloadCodecPaddingSamples));
			}

			ALOGD("%s set offload metadata %s", __func__, mOffloadMetadata.toString().c_str());
			status_t status = statusTFromBinderStatus(mStream->updateOffloadMetadata(mOffloadMetadata));
			if (status != OK) {
			ALOGE("%s: updateOffloadMetadata failed %d", __func__, status);
			return status;
			}
			}
			return OK;
			}

	StreamInHalAidl::StreamInHalAidl(		StreamInHalAidl::StreamInHalAidl(
	const audio_config& config, StreamContextAidl&& context, int32_t nominalLatency,		const audio_config& config, StreamContextAidl&& context, int32_t nominalLatency,
	const std::shared_ptr<IStreamIn>& stream)		const std::shared_ptr<IStreamIn>& stream)

media/libaudiohal/impl/StreamHalAidl.h

+13 −0

Original line number	Original line	Diff line number	Diff line
	@@ -21,16 +21,20 @@
	#include <mutex>		#include <mutex>
	#include <string_view>		#include <string_view>

			#include <aidl/android/hardware/audio/common/AudioOffloadMetadata.h>
	#include <aidl/android/hardware/audio/core/BpStreamCommon.h>		#include <aidl/android/hardware/audio/core/BpStreamCommon.h>
	#include <aidl/android/hardware/audio/core/BpStreamIn.h>		#include <aidl/android/hardware/audio/core/BpStreamIn.h>
	#include <aidl/android/hardware/audio/core/BpStreamOut.h>		#include <aidl/android/hardware/audio/core/BpStreamOut.h>
	#include <fmq/AidlMessageQueue.h>		#include <fmq/AidlMessageQueue.h>
	#include <media/audiohal/EffectHalInterface.h>		#include <media/audiohal/EffectHalInterface.h>
	#include <media/audiohal/StreamHalInterface.h>		#include <media/audiohal/StreamHalInterface.h>
			#include <media/AudioParameter.h>

	#include "ConversionHelperAidl.h"		#include "ConversionHelperAidl.h"
	#include "StreamPowerLog.h"		#include "StreamPowerLog.h"

			using ::aidl::android::hardware::audio::common::AudioOffloadMetadata;

	namespace android {		namespace android {

	class StreamContextAidl {		class StreamContextAidl {
	@@ -230,6 +234,9 @@ class CallbackBroker;

	class StreamOutHalAidl : public StreamOutHalInterface, public StreamHalAidl {		class StreamOutHalAidl : public StreamOutHalInterface, public StreamHalAidl {
	public:		public:
			// Extract the output stream parameters and set by AIDL APIs.
			status_t setParameters(const String8& kvPairs) override;

	// Return the audio hardware driver estimated latency in milliseconds.		// Return the audio hardware driver estimated latency in milliseconds.
	status_t getLatency(uint32_t *latency) override;		status_t getLatency(uint32_t *latency) override;

	@@ -309,6 +316,8 @@ class StreamOutHalAidl : public StreamOutHalInterface, public StreamHalAidl {
	const std::shared_ptr<::aidl::android::hardware::audio::core::IStreamOut> mStream;		const std::shared_ptr<::aidl::android::hardware::audio::core::IStreamOut> mStream;
	const wp<CallbackBroker> mCallbackBroker;		const wp<CallbackBroker> mCallbackBroker;

			AudioOffloadMetadata mOffloadMetadata;

	// Can not be constructed directly by clients.		// Can not be constructed directly by clients.
	StreamOutHalAidl(		StreamOutHalAidl(
	const audio_config& config, StreamContextAidl&& context, int32_t nominalLatency,		const audio_config& config, StreamContextAidl&& context, int32_t nominalLatency,
	@@ -316,6 +325,10 @@ class StreamOutHalAidl : public StreamOutHalInterface, public StreamHalAidl {
	const sp<CallbackBroker>& callbackBroker);		const sp<CallbackBroker>& callbackBroker);

	~StreamOutHalAidl() override;		~StreamOutHalAidl() override;

			// Filter and update the offload metadata. The parameters which are related to the offload
			// metadata will be removed after filtering.
			status_t filterAndUpdateOffloadMetadata(AudioParameter &parameters);
	};		};

	class StreamInHalAidl : public StreamInHalInterface, public StreamHalAidl {		class StreamInHalAidl : public StreamInHalInterface, public StreamHalAidl {

media/libmediahelper/AudioParameter.cpp

+11 −0

Original line number	Original line	Diff line number	Diff line
	@@ -61,6 +61,12 @@ const char * const AudioParameter::keyAdditionalOutputDeviceDelay =
	AUDIO_PARAMETER_DEVICE_ADDITIONAL_OUTPUT_DELAY;		AUDIO_PARAMETER_DEVICE_ADDITIONAL_OUTPUT_DELAY;
	const char * const AudioParameter::keyMaxAdditionalOutputDeviceDelay =		const char * const AudioParameter::keyMaxAdditionalOutputDeviceDelay =
	AUDIO_PARAMETER_DEVICE_MAX_ADDITIONAL_OUTPUT_DELAY;		AUDIO_PARAMETER_DEVICE_MAX_ADDITIONAL_OUTPUT_DELAY;
			const char * const AudioParameter::keyOffloadCodecAverageBitRate = AUDIO_OFFLOAD_CODEC_AVG_BIT_RATE;
			const char * const AudioParameter::keyOffloadCodecSampleRate = AUDIO_OFFLOAD_CODEC_SAMPLE_RATE;
			const char * const AudioParameter::keyOffloadCodecChannels = AUDIO_OFFLOAD_CODEC_NUM_CHANNEL;
			const char * const AudioParameter::keyOffloadCodecDelaySamples = AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES;
			const char * const AudioParameter::keyOffloadCodecPaddingSamples =
			AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES;

	AudioParameter::AudioParameter(const String8& keyValuePairs)		AudioParameter::AudioParameter(const String8& keyValuePairs)
	{		{
	@@ -226,4 +232,9 @@ status_t AudioParameter::getAt(size_t index, String8& key, String8& value) const
	}		}
	}		}

			bool AudioParameter::containsKey(const String8& key) const
			{
			return mParameters.indexOfKey(key) >= 0;
			}

	} // namespace android		} // namespace android

media/libmediahelper/include/media/AudioParameter.h

+7 −0

Original line number	Original line	Diff line number	Diff line
	@@ -107,6 +107,12 @@ public:
	static const char * const keyAdditionalOutputDeviceDelay;		static const char * const keyAdditionalOutputDeviceDelay;
	static const char * const keyMaxAdditionalOutputDeviceDelay;		static const char * const keyMaxAdditionalOutputDeviceDelay;

			static const char * const keyOffloadCodecAverageBitRate;
			static const char * const keyOffloadCodecSampleRate;
			static const char * const keyOffloadCodecChannels;
			static const char * const keyOffloadCodecDelaySamples;
			static const char * const keyOffloadCodecPaddingSamples;

	String8 toString() const { return toStringImpl(true); }		String8 toString() const { return toStringImpl(true); }
	String8 keysToString() const { return toStringImpl(false); }		String8 keysToString() const { return toStringImpl(false); }

	@@ -125,6 +131,7 @@ public:

	size_t size() const { return mParameters.size(); }		size_t size() const { return mParameters.size(); }

			bool containsKey(const String8& key) const;
	private:		private:
	String8 mKeyValuePairs;		String8 mKeyValuePairs;
	KeyedVector <String8, String8> mParameters;		KeyedVector <String8, String8> mParameters;