Merge changes from topic 'mmap_no_irq' (7863c791) · Commits · e / os / android_frameworks_av

include/media/MmapStreamCallback.h

0 → 100644

+60 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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_MMAP_STREAM_CALLBACK_H
		#define ANDROID_AUDIO_MMAP_STREAM_CALLBACK_H

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

		namespace android {


		class MmapStreamCallback : public virtual RefBase {
		public:

		/**
		* The mmap stream should be torn down because conditions that permitted its creation with
		* the requested parameters have changed and do not allow it to operate with the requested
		* constraints any more.
		*/
		virtual void onTearDown() = 0;

		/**
		* The volume to be applied to the use case specified when opening the stream has changed
		* \param[in] channels a channel mask containing all channels the volume should be applied to.
		* \param[in] values the volume values to be applied to each channel. The size of the vector
		* should correspond to the channel count retrieved with
		* audio_channel_count_from_in_mask() or audio_channel_count_from_out_mask()
		*/
		virtual void onVolumeChanged(audio_channel_mask_t channels, Vector<float> values) = 0;

		/**
		* The device the stream is routed to/from has changed
		* \param[in] onRoutingChanged the unique device ID of the new device.
		*/
		virtual void onRoutingChanged(audio_port_handle_t deviceId) = 0;

		protected:
		MmapStreamCallback() {}
		virtual ~MmapStreamCallback() {}
		};


		} // namespace android

		#endif // ANDROID_AUDIO_MMAP_STREAM_CALLBACK_H

include/media/MmapStreamInterface.h

0 → 100644

+133 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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_MMAP_STREAM_INTERFACE_H
		#define ANDROID_AUDIO_MMAP_STREAM_INTERFACE_H

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

		namespace android {

		class MmapStreamCallback;

		class MmapStreamInterface : public virtual RefBase
		{
		public:

		/**
		* Values for direction argument passed to openMmapStream()
		*/
		typedef enum {
		DIRECTION_OUTPUT = 0, /*< open a playback mmap stream /
		DIRECTION_INPUT, /*< open a capture mmap stream /
		} stream_direction_t;

		class Client {
		public:
		uid_t clientUid;
		pid_t clientPid;
		String16 packageName;
		};
		/**
		* Open a playback or capture stream in MMAP mode at the audio HAL.
		*
		* \note This method is implemented by AudioFlinger
		*
		* \param[in] direction open a playback or capture stream.
		* \param[in] attr audio attributes defining the main use case for this stream
		* \param[in,out] config audio parameters (sampling rate, format ...) for the stream.
		* Requested parameters as input,
		* Actual parameters as output
		* \param[in] client a Client struct describing the first client using this stream.
		* \param[in,out] deviceId audio device the stream should preferably be routed to/from
		* Requested as input,
		* Actual as output
		* \param[in] callback the MmapStreamCallback interface used by AudioFlinger to notify
		* condition changes affecting the stream operation
		* \param[out] interface the MmapStreamInterface interface controlling the created stream
		* \return OK if the stream was successfully created.
		* NO_INIT if AudioFlinger is not properly initialized
		* BAD_VALUE if the stream cannot be opened because of invalid arguments
		* INVALID_OPERATION if the stream cannot be opened because of platform limitations
		*/
		static status_t openMmapStream(stream_direction_t direction,
		const audio_attributes_t *attr,
		audio_config_base_t *config,
		const Client& client,
		audio_port_handle_t *deviceId,
		const sp<MmapStreamCallback>& callback,
		sp<MmapStreamInterface>& interface);

		/**
		* Retrieve information on the mmap buffer used for audio samples transfer.
		*
		* \param[in] min_size_frames minimum buffer size requested. The actual buffer
		* size returned in struct audio_mmap_buffer_info can be larger.
		* \param[out] info address at which the mmap buffer information should be returned.
		*
		* \return OK if the buffer was allocated.
		* NO_INIT in case of initialization error
		* BAD_VALUE if the requested buffer size is too large
		* INVALID_OPERATION if called out of sequence (e.g. buffer already allocated)
		*/
		virtual status_t createMmapBuffer(int32_t minSizeFrames,
		struct audio_mmap_buffer_info *info) = 0;

		/**
		* Read current read/write position in the mmap buffer with associated time stamp.
		*
		* \param[out] position address at which the mmap read/write position should be returned.
		*
		* \return OK if the position is successfully returned.
		* NOT_ENOUGH_DATA if the position cannot be retrieved
		* INVALID_OPERATION if called before createMmapBuffer()
		*/
		virtual status_t getMmapPosition(struct audio_mmap_position *position) = 0;

		/**
		* Start a stream operating in mmap mode.
		* createMmapBuffer() must be called before calling start()
		*
		* \param[in] client a Client struct describing the client starting on this stream.
		* \param[out] handle unique handle for this instance. Used with stop().
		* \return OK in case of success.
		* INVALID_OPERATION if called out of sequence
		*/
		virtual status_t start(const Client& client, audio_port_handle_t *handle) = 0;

		/**
		* Stop a stream operating in mmap mode.
		* Must be called after start()
		*
		* \param[in] handle unique handle allocated by start().
		* \return OK in case of success.
		* INVALID_OPERATION if called out of sequence
		*/
		virtual status_t stop(audio_port_handle_t handle) = 0;

		protected:
		// Subclasses can not be constructed directly by clients.
		MmapStreamInterface() {}

		// The destructor automatically closes the stream.
		virtual ~MmapStreamInterface() {}
		};

		} // namespace android

		#endif // ANDROID_AUDIO_MMAP_STREAM_INTERFACE_H

media/libmedia/TypeConverter.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -111,6 +111,7 @@ const OutputFlagConverter::Table OutputFlagConverter::mTable[] = {
		MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_SYNC),
		MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO),
		MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_DIRECT_PCM),
		MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ),
		TERMINATOR
		};

		@@ -122,6 +123,7 @@ const InputFlagConverter::Table InputFlagConverter::mTable[] = {
		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),
		MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_MMAP_NOIRQ),
		TERMINATOR
		};

services/audioflinger/AudioFlinger.cpp

+411 −212

File changed.

Preview size limit exceeded, changes collapsed.

services/audioflinger/AudioFlinger.h

+41 −2

Original line number	Diff line number	Diff line
		@@ -34,6 +34,8 @@
		#include <media/IAudioRecord.h>
		#include <media/AudioSystem.h>
		#include <media/AudioTrack.h>
		#include <media/MmapStreamInterface.h>
		#include <media/MmapStreamCallback.h>

		#include <utils/Atomic.h>
		#include <utils/Errors.h>
		@@ -100,6 +102,7 @@ class AudioFlinger :
		public BnAudioFlinger
		{
		friend class BinderService<AudioFlinger>; // for AudioFlinger()

		public:
		static const char* getServiceName() ANDROID_API { return "media.audio_flinger"; }

		@@ -283,6 +286,14 @@ public:
		sp<NBLog::Writer> newWriter_l(size_t size, const char *name);
		void unregisterWriter(const sp<NBLog::Writer>& writer);
		sp<EffectsFactoryHalInterface> getEffectsFactory();

		status_t openMmapStream(MmapStreamInterface::stream_direction_t direction,
		const audio_attributes_t *attr,
		audio_config_base_t *config,
		const MmapStreamInterface::Client& client,
		audio_port_handle_t *deviceId,
		const sp<MmapStreamCallback>& callback,
		sp<MmapStreamInterface>& interface);
		private:
		static const size_t kLogMemorySize = 40 * 1024;
		sp<MemoryDealer> mLogMemoryDealer; // == 0 when NBLog is disabled
		@@ -290,6 +301,7 @@ private:
		// for as long as possible. The memory is only freed when it is needed for another log writer.
		Vector< sp<NBLog::Writer> > mUnregisteredWriters;
		Mutex mUnregisteredWritersLock;

		public:

		class SyncEvent;
		@@ -533,19 +545,40 @@ private:
		void stop_nonvirtual();
		};

		// Mmap stream control interface implementation. Each MmapThreadHandle controls one
		// MmapPlaybackThread or MmapCaptureThread instance.
		class MmapThreadHandle : public MmapStreamInterface {
		public:
		explicit MmapThreadHandle(const sp<MmapThread>& thread);
		virtual ~MmapThreadHandle();

		// MmapStreamInterface virtuals
		virtual status_t createMmapBuffer(int32_t minSizeFrames,
		struct audio_mmap_buffer_info *info);
		virtual status_t getMmapPosition(struct audio_mmap_position *position);
		virtual status_t start(const MmapStreamInterface::Client& client, audio_port_handle_t *handle);
		virtual status_t stop(audio_port_handle_t handle);

		private:
		sp<MmapThread> mThread;
		};

		ThreadBase *checkThread_l(audio_io_handle_t ioHandle) const;
		PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
		MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
		RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
		sp<RecordThread> openInput_l(audio_module_handle_t module,
		MmapThread *checkMmapThread_l(audio_io_handle_t io) const;
		VolumeInterface *getVolumeInterface_l(audio_io_handle_t output) const;
		Vector <VolumeInterface *> getAllVolumeInterfaces_l() const;

		sp<ThreadBase> openInput_l(audio_module_handle_t module,
		audio_io_handle_t *input,
		audio_config_t *config,
		audio_devices_t device,
		const String8& address,
		audio_source_t source,
		audio_input_flags_t flags);
		sp<PlaybackThread> openOutput_l(audio_module_handle_t module,
		sp<ThreadBase> openOutput_l(audio_module_handle_t module,
		audio_io_handle_t *output,
		audio_config_t *config,
		audio_devices_t devices,
		@@ -722,6 +755,12 @@ private:

		// list of sessions for which a valid HW A/V sync ID was retrieved from the HAL
		DefaultKeyedVector< audio_session_t , audio_hw_sync_t >mHwAvSyncIds;

		// list of MMAP stream control threads. Those threads allow for wake lock, routing
		// and volume control for activity on the associated MMAP stream at the HAL.
		// Audio data transfer is directly handled by the client creating the MMAP stream
		DefaultKeyedVector< audio_io_handle_t, sp<MmapThread> > mMmapThreads;

		private:
		sp<Client> registerPid(pid_t pid); // always returns non-0