Merge "AudioFlinger: call SPDIF wrapper from AudioFlinger" (ae971047) · Commits · e / os / android_frameworks_av

services/audioflinger/Android.mk

+4 −0

Original line number	Diff line number	Diff line
		@@ -39,6 +39,9 @@ LOCAL_SRC_FILES:= \
		AudioFlinger.cpp \
		Threads.cpp \
		Tracks.cpp \
		AudioHwDevice.cpp \
		AudioStreamOut.cpp \
		SpdifStreamOut.cpp \
		Effects.cpp \
		AudioMixer.cpp.arm \
		PatchPanel.cpp
		@@ -52,6 +55,7 @@ LOCAL_C_INCLUDES := \

		LOCAL_SHARED_LIBRARIES := \
		libaudioresampler \
		libaudiospdif \
		libaudioutils \
		libcommon_time_client \
		libcutils \

services/audioflinger/AudioFlinger.cpp

+11 −20

Original line number	Diff line number	Diff line
		@@ -272,7 +272,7 @@ static const char * const audio_interfaces[] = {
		};
		#define ARRAY_SIZE(x) (sizeof((x))/sizeof(((x)[0])))

		AudioFlinger::AudioHwDevice* AudioFlinger::findSuitableHwDev_l(
		AudioHwDevice* AudioFlinger::findSuitableHwDev_l(
		audio_module_handle_t module,
		audio_devices_t devices)
		{
		@@ -1716,8 +1716,6 @@ sp<AudioFlinger::PlaybackThread> AudioFlinger::openOutput_l(audio_module_handle_

		mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;

		audio_stream_out_t *outStream = NULL;

		// FOR TESTING ONLY:
		// This if statement allows overriding the audio policy settings
		// and forcing a specific format or channel mask to the HAL/Sink device for testing.
		@@ -1739,25 +1737,18 @@ sp<AudioFlinger::PlaybackThread> AudioFlinger::openOutput_l(audio_module_handle_
		}
		}

		status_t status = hwDevHal->open_output_stream(hwDevHal,
		AudioStreamOut *outputStream = NULL;
		status_t status = outHwDev->openOutputStream(
		&outputStream,
		*output,
		devices,
		flags,
		config,
		&outStream,
		address.string());

		mHardwareStatus = AUDIO_HW_IDLE;
		ALOGV("openOutput_l() openOutputStream returned output %p, sampleRate %d, Format %#x, "
		"channelMask %#x, status %d",
		outStream,
		config->sample_rate,
		config->format,
		config->channel_mask,
		status);

		if (status == NO_ERROR && outStream != NULL) {
		AudioStreamOut *outputStream = new AudioStreamOut(outHwDev, outStream, flags);
		if (status == NO_ERROR) {

		PlaybackThread *thread;
		if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
		@@ -1787,7 +1778,7 @@ status_t AudioFlinger::openOutput(audio_module_handle_t module,
		uint32_t *latencyMs,
		audio_output_flags_t flags)
		{
		ALOGV("openOutput(), module %d Device %x, SamplingRate %d, Format %#08x, Channels %x, flags %x",
		ALOGI("openOutput(), module %d Device %x, SamplingRate %d, Format %#08x, Channels %x, flags %x",
		module,
		(devices != NULL) ? *devices : 0,
		config->sample_rate,

services/audioflinger/AudioFlinger.h

+5 −49

Original line number	Diff line number	Diff line
		@@ -56,6 +56,9 @@
		#include <media/nbaio/NBAIO.h>
		#include "AudioWatchdog.h"
		#include "AudioMixer.h"
		#include "AudioStreamOut.h"
		#include "SpdifStreamOut.h"
		#include "AudioHwDevice.h"

		#include <powermanager/IPowerManager.h>

		@@ -311,7 +314,6 @@ public:
		wp<RefBase> cookie);

		private:
		class AudioHwDevice; // fwd declaration for findSuitableHwDev_l

		audio_mode_t getMode() const { return mMode; }

		@@ -449,7 +451,7 @@ private:
		class EffectModule;
		class EffectHandle;
		class EffectChain;
		struct AudioStreamOut;

		struct AudioStreamIn;

		struct stream_type_t {
		@@ -586,57 +588,11 @@ private:
		// Return true if the effect was found in mOrphanEffectChains, false otherwise.
		bool updateOrphanEffectChains(const sp<EffectModule>& effect);

		class AudioHwDevice {
		public:
		enum Flags {
		AHWD_CAN_SET_MASTER_VOLUME = 0x1,
		AHWD_CAN_SET_MASTER_MUTE = 0x2,
		};

		AudioHwDevice(audio_module_handle_t handle,
		const char *moduleName,
		audio_hw_device_t *hwDevice,
		Flags flags)
		: mHandle(handle), mModuleName(strdup(moduleName))
		, mHwDevice(hwDevice)
		, mFlags(flags) { }
		/virtual/ ~AudioHwDevice() { free((void *)mModuleName); }

		bool canSetMasterVolume() const {
		return (0 != (mFlags & AHWD_CAN_SET_MASTER_VOLUME));
		}

		bool canSetMasterMute() const {
		return (0 != (mFlags & AHWD_CAN_SET_MASTER_MUTE));
		}

		audio_module_handle_t handle() const { return mHandle; }
		const char *moduleName() const { return mModuleName; }
		audio_hw_device_t *hwDevice() const { return mHwDevice; }
		uint32_t version() const { return mHwDevice->common.version; }

		private:
		const audio_module_handle_t mHandle;
		const char * const mModuleName;
		audio_hw_device_t * const mHwDevice;
		const Flags mFlags;
		};

		// AudioStreamOut and AudioStreamIn are immutable, so their fields are const.
		// AudioStreamIn is immutable, so their fields are const.
		// For emphasis, we could also make all pointers to them be "const *",
		// but that would clutter the code unnecessarily.

		struct AudioStreamOut {
		AudioHwDevice* const audioHwDev;
		audio_stream_out_t* const stream;
		const audio_output_flags_t flags;

		audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }

		AudioStreamOut(AudioHwDevice dev, audio_stream_out_t out, audio_output_flags_t flags) :
		audioHwDev(dev), stream(out), flags(flags) {}
		};

		struct AudioStreamIn {
		AudioHwDevice* const audioHwDev;
		audio_stream_in_t* const stream;

services/audioflinger/AudioHwDevice.cpp

0 → 100644

+94 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2007, 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.
		*/

		#define LOG_TAG "AudioHwDevice"
		//#define LOG_NDEBUG 0

		#include <hardware/audio.h>
		#include <utils/Log.h>

		#include <audio_utils/spdif/SPDIFEncoder.h>

		#include "AudioHwDevice.h"
		#include "AudioStreamOut.h"
		#include "SpdifStreamOut.h"

		namespace android {

		// ----------------------------------------------------------------------------

		status_t AudioHwDevice::openOutputStream(
		AudioStreamOut **ppStreamOut,
		audio_io_handle_t handle,
		audio_devices_t devices,
		audio_output_flags_t flags,
		struct audio_config *config,
		const char *address)
		{

		struct audio_config originalConfig = *config;
		AudioStreamOut *outputStream = new AudioStreamOut(this, flags);

		// Try to open the HAL first using the current format.
		ALOGV("AudioHwDevice::openOutputStream(), try "
		" sampleRate %d, Format %#x, "
		"channelMask %#x",
		config->sample_rate,
		config->format,
		config->channel_mask);
		status_t status = outputStream->open(handle, devices, config, address);

		if (status != NO_ERROR) {
		delete outputStream;
		outputStream = NULL;

		// FIXME Look at any modification to the config.
		// The HAL might modify the config to suggest a wrapped format.
		// Log this so we can see what the HALs are doing.
		ALOGI("AudioHwDevice::openOutputStream(), HAL returned"
		" sampleRate %d, Format %#x, "
		"channelMask %#x, status %d",
		config->sample_rate,
		config->format,
		config->channel_mask,
		status);

		// If the data is encoded then try again using wrapped PCM.
		bool wrapperNeeded = !audio_is_linear_pcm(originalConfig.format)
		&& ((flags & AUDIO_OUTPUT_FLAG_DIRECT) != 0)
		&& ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0);

		// FIXME - Add isEncodingSupported() query to SPDIF wrapper then
		// call it from here.
		if (wrapperNeeded) {
		outputStream = new SpdifStreamOut(this, flags);
		status = outputStream->open(handle, devices, &originalConfig, address);
		if (status != NO_ERROR) {
		ALOGE("ERROR - AudioHwDevice::openOutputStream(), SPDIF open returned %d",
		status);
		delete outputStream;
		outputStream = NULL;
		}
		}
		}

		*ppStreamOut = outputStream;
		return status;
		}


		}; // namespace android

services/audioflinger/AudioHwDevice.h

0 → 100644

+88 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2007, 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.
		*/

		#ifndef ANDROID_AUDIO_HW_DEVICE_H
		#define ANDROID_AUDIO_HW_DEVICE_H

		#include <stdint.h>
		#include <stdlib.h>
		#include <sys/types.h>

		#include <hardware/audio.h>
		#include <utils/Errors.h>
		#include <system/audio.h>


		namespace android {

		class AudioStreamOut;

		class AudioHwDevice {
		public:
		enum Flags {
		AHWD_CAN_SET_MASTER_VOLUME = 0x1,
		AHWD_CAN_SET_MASTER_MUTE = 0x2,
		};

		AudioHwDevice(audio_module_handle_t handle,
		const char *moduleName,
		audio_hw_device_t *hwDevice,
		Flags flags)
		: mHandle(handle)
		, mModuleName(strdup(moduleName))
		, mHwDevice(hwDevice)
		, mFlags(flags) { }
		virtual ~AudioHwDevice() { free((void *)mModuleName); }

		bool canSetMasterVolume() const {
		return (0 != (mFlags & AHWD_CAN_SET_MASTER_VOLUME));
		}

		bool canSetMasterMute() const {
		return (0 != (mFlags & AHWD_CAN_SET_MASTER_MUTE));
		}

		audio_module_handle_t handle() const { return mHandle; }
		const char *moduleName() const { return mModuleName; }
		audio_hw_device_t *hwDevice() const { return mHwDevice; }
		uint32_t version() const { return mHwDevice->common.version; }

		/** This method creates and opens the audio hardware output stream.
		* The "address" parameter qualifies the "devices" audio device type if needed.
		* The format format depends on the device type:
		* - Bluetooth devices use the MAC address of the device in the form "00:11:22:AA:BB:CC"
		* - USB devices use the ALSA card and device numbers in the form "card=X;device=Y"
		* - Other devices may use a number or any other string.
		*/
		status_t openOutputStream(
		AudioStreamOut **ppStreamOut,
		audio_io_handle_t handle,
		audio_devices_t devices,
		audio_output_flags_t flags,
		struct audio_config *config,
		const char *address);

		private:
		const audio_module_handle_t mHandle;
		const char * const mModuleName;
		audio_hw_device_t * const mHwDevice;
		const Flags mFlags;
		};

		} // namespace android

		#endif // ANDROID_AUDIO_HW_DEVICE_H