auto import from //depot/cupcake/@135843 (89fa4ad5) · Commits · e / os / android_frameworks_av

include/media/AudioRecord.h

0 → 100644

+344 −0

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

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

		#include <media/IAudioFlinger.h>
		#include <media/IAudioRecord.h>
		#include <media/AudioTrack.h>

		#include <utils/RefBase.h>
		#include <utils/Errors.h>
		#include <utils/IInterface.h>
		#include <utils/IMemory.h>
		#include <utils/threads.h>


		namespace android {

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

		class AudioRecord
		{
		public:

		enum stream_type {
		DEFAULT_INPUT =-1,
		MIC_INPUT = 0,
		NUM_STREAM_TYPES
		};

		static const int DEFAULT_SAMPLE_RATE = 8000;

		/* Events used by AudioRecord callback function (callback_t).
		*
		* to keep in sync with frameworks/base/media/java/android/media/AudioRecord.java
		*/
		enum event_type {
		EVENT_MORE_DATA = 0, // Request to reqd more data from PCM buffer.
		EVENT_OVERRUN = 1, // PCM buffer overrun occured.
		EVENT_MARKER = 2, // Record head is at the specified marker position
		// (See setMarkerPosition()).
		EVENT_NEW_POS = 3, // Record head is at a new position
		// (See setPositionUpdatePeriod()).
		};

		/* Create Buffer on the stack and pass it to obtainBuffer()
		* and releaseBuffer().
		*/

		class Buffer
		{
		public:
		enum {
		MUTE = 0x00000001
		};
		uint32_t flags;
		int channelCount;
		int format;
		size_t frameCount;
		size_t size;
		union {
		void* raw;
		short* i16;
		int8_t* i8;
		};
		};

		/* These are static methods to control the system-wide AudioFlinger
		* only privileged processes can have access to them
		*/

		// static status_t setMasterMute(bool mute);

		/* As a convenience, if a callback is supplied, a handler thread
		* is automatically created with the appropriate priority. This thread
		* invokes the callback when a new buffer becomes ready or an overrun condition occurs.
		* Parameters:
		*
		* event: type of event notified (see enum AudioRecord::event_type).
		* user: Pointer to context for use by the callback receiver.
		* info: Pointer to optional parameter according to event type:
		* - EVENT_MORE_DATA: pointer to AudioRecord::Buffer struct. The callback must not read
		* more bytes than indicated by 'size' field and update 'size' if less bytes are
		* read.
		* - EVENT_OVERRUN: unused.
		* - EVENT_MARKER: pointer to an uin32_t containing the marker position in frames.
		* - EVENT_NEW_POS: pointer to an uin32_t containing the new position in frames.
		*/

		typedef void (callback_t)(int event, void user, void *info);

		/* Constructs an uninitialized AudioRecord. No connection with
		* AudioFlinger takes place.
		*/
		AudioRecord();

		/* Creates an AudioRecord track and registers it with AudioFlinger.
		* Once created, the track needs to be started before it can be used.
		* Unspecified values are set to the audio hardware's current
		* values.
		*
		* Parameters:
		*
		* streamType: Select the audio input to record to (e.g. AudioRecord::MIC_INPUT).
		* sampleRate: Track sampling rate in Hz.
		* format: PCM sample format (e.g AudioSystem::PCM_16_BIT for signed
		* 16 bits per sample).
		* channelCount: Number of PCM channels (e.g 2 for stereo).
		* frameCount: Total size of track PCM buffer in frames. This defines the
		* latency of the track.
		* flags: A bitmask of acoustic values from enum record_flags. It enables
		* AGC, NS, and IIR.
		* cbf: Callback function. If not null, this function is called periodically
		* to provide new PCM data.
		* notificationFrames: The callback function is called each time notificationFrames PCM
		* frames are ready in record track output buffer.
		* user Context for use by the callback receiver.
		*/

		enum record_flags {
		RECORD_AGC_ENABLE = AudioSystem::AGC_ENABLE,
		RECORD_NS_ENABLE = AudioSystem::NS_ENABLE,
		RECORD_IIR_ENABLE = AudioSystem::TX_IIR_ENABLE
		};

		AudioRecord(int streamType,
		uint32_t sampleRate = 0,
		int format = 0,
		int channelCount = 0,
		int frameCount = 0,
		uint32_t flags = 0,
		callback_t cbf = 0,
		void* user = 0,
		int notificationFrames = 0);


		/* Terminates the AudioRecord and unregisters it from AudioFlinger.
		* Also destroys all resources assotiated with the AudioRecord.
		*/
		~AudioRecord();


		/* Initialize an uninitialized AudioRecord.
		* Returned status (from utils/Errors.h) can be:
		* - NO_ERROR: successful intialization
		* - INVALID_OPERATION: AudioRecord is already intitialized or record device is already in use
		* - BAD_VALUE: invalid parameter (channelCount, format, sampleRate...)
		* - NO_INIT: audio server or audio hardware not initialized
		* - PERMISSION_DENIED: recording is not allowed for the requesting process
		* */
		status_t set(int streamType = 0,
		uint32_t sampleRate = 0,
		int format = 0,
		int channelCount = 0,
		int frameCount = 0,
		uint32_t flags = 0,
		callback_t cbf = 0,
		void* user = 0,
		int notificationFrames = 0,
		bool threadCanCallJava = false);


		/* Result of constructing the AudioRecord. This must be checked
		* before using any AudioRecord API (except for set()), using
		* an uninitialized AudioRecord produces undefined results.
		* See set() method above for possible return codes.
		*/
		status_t initCheck() const;

		/* Returns this track's latency in milliseconds.
		* This includes the latency due to AudioRecord buffer size
		* and audio hardware driver.
		*/
		uint32_t latency() const;

		/* getters, see constructor */

		uint32_t sampleRate() const;
		int format() const;
		int channelCount() const;
		uint32_t frameCount() const;
		int frameSize() const;


		/* After it's created the track is not active. Call start() to
		* make it active. If set, the callback will start being called.
		*/
		status_t start();

		/* Stop a track. If set, the callback will cease being called and
		* obtainBuffer returns STOPPED. Note that obtainBuffer() still works
		* and will fill up buffers until the pool is exhausted.
		*/
		status_t stop();
		bool stopped() const;

		/* get sample rate for this track
		*/
		uint32_t getSampleRate();

		/* Sets marker position. When record reaches the number of frames specified,
		* a callback with event type EVENT_MARKER is called. Calling setMarkerPosition
		* with marker == 0 cancels marker notification callback.
		* If the AudioRecord has been opened with no callback function associated,
		* the operation will fail.
		*
		* Parameters:
		*
		* marker: marker position expressed in frames.
		*
		* Returned status (from utils/Errors.h) can be:
		* - NO_ERROR: successful operation
		* - INVALID_OPERATION: the AudioRecord has no callback installed.
		*/
		status_t setMarkerPosition(uint32_t marker);
		status_t getMarkerPosition(uint32_t *marker);


		/* Sets position update period. Every time the number of frames specified has been recorded,
		* a callback with event type EVENT_NEW_POS is called.
		* Calling setPositionUpdatePeriod with updatePeriod == 0 cancels new position notification
		* callback.
		* If the AudioRecord has been opened with no callback function associated,
		* the operation will fail.
		*
		* Parameters:
		*
		* updatePeriod: position update notification period expressed in frames.
		*
		* Returned status (from utils/Errors.h) can be:
		* - NO_ERROR: successful operation
		* - INVALID_OPERATION: the AudioRecord has no callback installed.
		*/
		status_t setPositionUpdatePeriod(uint32_t updatePeriod);
		status_t getPositionUpdatePeriod(uint32_t *updatePeriod);


		/* Gets record head position. The position is the total number of frames
		* recorded since record start.
		*
		* Parameters:
		*
		* position: Address where to return record head position within AudioRecord buffer.
		*
		* Returned status (from utils/Errors.h) can be:
		* - NO_ERROR: successful operation
		* - BAD_VALUE: position is NULL
		*/
		status_t getPosition(uint32_t *position);



		/* obtains a buffer of "frameCount" frames. The buffer must be
		* filled entirely. If the track is stopped, obtainBuffer() returns
		* STOPPED instead of NO_ERROR as long as there are buffers availlable,
		* at which point NO_MORE_BUFFERS is returned.
		* Buffers will be returned until the pool (buffercount())
		* is exhausted, at which point obtainBuffer() will either block
		* or return WOULD_BLOCK depending on the value of the "blocking"
		* parameter.
		*/

		enum {
		NO_MORE_BUFFERS = 0x80000001,
		STOPPED = 1
		};

		status_t obtainBuffer(Buffer* audioBuffer, int32_t waitCount);
		void releaseBuffer(Buffer* audioBuffer);


		/* As a convenience we provide a read() interface to the audio buffer.
		* This is implemented on top of lockBuffer/unlockBuffer.
		*/
		ssize_t read(void* buffer, size_t size);

		private:
		/* copying audio tracks is not allowed */
		AudioRecord(const AudioRecord& other);
		AudioRecord& operator = (const AudioRecord& other);

		/* a small internal class to handle the callback */
		class ClientRecordThread : public Thread
		{
		public:
		ClientRecordThread(AudioRecord& receiver, bool bCanCallJava = false);
		private:
		friend class AudioRecord;
		virtual bool threadLoop();
		virtual status_t readyToRun() { return NO_ERROR; }
		virtual void onFirstRef() {}
		AudioRecord& mReceiver;
		Mutex mLock;
		};

		bool processAudioBuffer(const sp<ClientRecordThread>& thread);

		sp<IAudioFlinger> mAudioFlinger;
		sp<IAudioRecord> mAudioRecord;
		sp<IMemory> mCblkMemory;
		sp<ClientRecordThread> mClientRecordThread;
		Mutex mRecordThreadLock;

		uint32_t mSampleRate;
		uint32_t mFrameCount;

		audio_track_cblk_t* mCblk;
		uint8_t mFormat;
		uint8_t mChannelCount;
		uint8_t mReserved[2];
		status_t mStatus;
		uint32_t mLatency;

		volatile int32_t mActive;

		callback_t mCbf;
		void* mUserData;
		uint32_t mNotificationFrames;
		uint32_t mRemainingFrames;
		uint32_t mMarkerPosition;
		uint32_t mNewPosition;
		uint32_t mUpdatePeriod;
		};

		}; // namespace android

		#endif /AUDIORECORD_H_/

include/media/AudioSystem.h

0 → 100644

+177 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 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_AUDIOSYSTEM_H_
		#define ANDROID_AUDIOSYSTEM_H_

		#include <utils/RefBase.h>
		#include <utils/threads.h>
		#include <media/IAudioFlinger.h>

		namespace android {

		typedef void (*audio_error_callback)(status_t err);

		class AudioSystem
		{
		public:

		enum stream_type {
		DEFAULT =-1,
		VOICE_CALL = 0,
		SYSTEM = 1,
		RING = 2,
		MUSIC = 3,
		ALARM = 4,
		NOTIFICATION = 5,
		BLUETOOTH_SCO = 6,
		NUM_STREAM_TYPES
		};

		enum audio_output_type {
		AUDIO_OUTPUT_DEFAULT =-1,
		AUDIO_OUTPUT_HARDWARE = 0,
		AUDIO_OUTPUT_A2DP = 1,
		NUM_AUDIO_OUTPUT_TYPES
		};

		enum audio_format {
		FORMAT_DEFAULT = 0,
		PCM_16_BIT,
		PCM_8_BIT,
		INVALID_FORMAT
		};

		enum audio_mode {
		MODE_INVALID = -2,
		MODE_CURRENT = -1,
		MODE_NORMAL = 0,
		MODE_RINGTONE,
		MODE_IN_CALL,
		NUM_MODES // not a valid entry, denotes end-of-list
		};

		enum audio_routes {
		ROUTE_EARPIECE = (1 << 0),
		ROUTE_SPEAKER = (1 << 1),
		ROUTE_BLUETOOTH_SCO = (1 << 2),
		ROUTE_HEADSET = (1 << 3),
		ROUTE_BLUETOOTH_A2DP = (1 << 4),
		ROUTE_ALL = -1UL,
		};

		enum audio_in_acoustics {
		AGC_ENABLE = 0x0001,
		AGC_DISABLE = 0,
		NS_ENABLE = 0x0002,
		NS_DISABLE = 0,
		TX_IIR_ENABLE = 0x0004,
		TX_DISABLE = 0
		};

		/* These are static methods to control the system-wide AudioFlinger
		* only privileged processes can have access to them
		*/

		// routing helper functions
		static status_t speakerphone(bool state);
		static status_t isSpeakerphoneOn(bool* state);
		static status_t bluetoothSco(bool state);
		static status_t isBluetoothScoOn(bool* state);
		static status_t muteMicrophone(bool state);
		static status_t isMicrophoneMuted(bool *state);

		static status_t setMasterVolume(float value);
		static status_t setMasterMute(bool mute);
		static status_t getMasterVolume(float* volume);
		static status_t getMasterMute(bool* mute);

		static status_t setStreamVolume(int stream, float value);
		static status_t setStreamMute(int stream, bool mute);
		static status_t getStreamVolume(int stream, float* volume);
		static status_t getStreamMute(int stream, bool* mute);

		static status_t setMode(int mode);
		static status_t getMode(int* mode);

		static status_t setRouting(int mode, uint32_t routes, uint32_t mask);
		static status_t getRouting(int mode, uint32_t* routes);

		static status_t isMusicActive(bool *state);

		// Temporary interface, do not use
		// TODO: Replace with a more generic key:value get/set mechanism
		static status_t setParameter(const char* key, const char* value);

		static void setErrorCallback(audio_error_callback cb);

		// helper function to obtain AudioFlinger service handle
		static const sp<IAudioFlinger>& get_audio_flinger();

		static float linearToLog(int volume);
		static int logToLinear(float volume);

		static status_t getOutputSamplingRate(int* samplingRate, int stream = DEFAULT);
		static status_t getOutputFrameCount(int* frameCount, int stream = DEFAULT);
		static status_t getOutputLatency(uint32_t* latency, int stream = DEFAULT);

		static bool routedToA2dpOutput(int streamType);

		static status_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount,
		size_t* buffSize);

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

		private:

		class AudioFlingerClient: public IBinder::DeathRecipient, public BnAudioFlingerClient
		{
		public:
		AudioFlingerClient() {
		}

		// DeathRecipient
		virtual void binderDied(const wp<IBinder>& who);

		// IAudioFlingerClient
		virtual void a2dpEnabledChanged(bool enabled);

		};
		static int getOutput(int streamType);

		static sp<AudioFlingerClient> gAudioFlingerClient;

		friend class AudioFlingerClient;

		static Mutex gLock;
		static sp<IAudioFlinger> gAudioFlinger;
		static audio_error_callback gAudioErrorCallback;
		static int gOutSamplingRate[NUM_AUDIO_OUTPUT_TYPES];
		static int gOutFrameCount[NUM_AUDIO_OUTPUT_TYPES];
		static uint32_t gOutLatency[NUM_AUDIO_OUTPUT_TYPES];
		static bool gA2dpEnabled;

		static size_t gInBuffSize;
		// previous parameters for recording buffer size queries
		static uint32_t gPrevInSamplingRate;
		static int gPrevInFormat;
		static int gPrevInChannelCount;

		};

		}; // namespace android

		#endif /ANDROID_AUDIOSYSTEM_H_/

include/media/AudioTrack.h

0 → 100644

+419 −0

File added.

Preview size limit exceeded, changes collapsed.

include/media/IAudioFlinger.h

0 → 100644

+141 −0

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

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

		#include <utils/RefBase.h>
		#include <utils/Errors.h>
		#include <utils/IInterface.h>
		#include <media/IAudioTrack.h>
		#include <media/IAudioRecord.h>
		#include <media/IAudioFlingerClient.h>


		namespace android {

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

		class IAudioFlinger : public IInterface
		{
		public:
		DECLARE_META_INTERFACE(AudioFlinger);

		/* create an audio track and registers it with AudioFlinger.
		* return null if the track cannot be created.
		*/
		virtual sp<IAudioTrack> createTrack(
		pid_t pid,
		int streamType,
		uint32_t sampleRate,
		int format,
		int channelCount,
		int frameCount,
		uint32_t flags,
		const sp<IMemory>& sharedBuffer,
		status_t *status) = 0;

		virtual sp<IAudioRecord> openRecord(
		pid_t pid,
		int streamType,
		uint32_t sampleRate,
		int format,
		int channelCount,
		int frameCount,
		uint32_t flags,
		status_t *status) = 0;

		/* query the audio hardware state. This state never changes,
		* and therefore can be cached.
		*/
		virtual uint32_t sampleRate(int output) const = 0;
		virtual int channelCount(int output) const = 0;
		virtual int format(int output) const = 0;
		virtual size_t frameCount(int output) const = 0;
		virtual uint32_t latency(int output) const = 0;

		/* set/get the audio hardware state. This will probably be used by
		* the preference panel, mostly.
		*/
		virtual status_t setMasterVolume(float value) = 0;
		virtual status_t setMasterMute(bool muted) = 0;

		virtual float masterVolume() const = 0;
		virtual bool masterMute() const = 0;

		/* set/get stream type state. This will probably be used by
		* the preference panel, mostly.
		*/
		virtual status_t setStreamVolume(int stream, float value) = 0;
		virtual status_t setStreamMute(int stream, bool muted) = 0;

		virtual float streamVolume(int stream) const = 0;
		virtual bool streamMute(int stream) const = 0;

		// set/get audio routing
		virtual status_t setRouting(int mode, uint32_t routes, uint32_t mask) = 0;
		virtual uint32_t getRouting(int mode) const = 0;

		// set/get audio mode
		virtual status_t setMode(int mode) = 0;
		virtual int getMode() const = 0;

		// mic mute/state
		virtual status_t setMicMute(bool state) = 0;
		virtual bool getMicMute() const = 0;

		// is a music stream active?
		virtual bool isMusicActive() const = 0;

		// pass a generic configuration parameter to libaudio
		// Temporary interface, do not use
		// TODO: Replace with a more generic key:value get/set mechanism
		virtual status_t setParameter(const char* key, const char* value) = 0;

		// register a current process for audio output change notifications
		virtual void registerClient(const sp<IAudioFlingerClient>& client) = 0;

		// retrieve the audio recording buffer size
		virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount) = 0;

		// force AudioFlinger thread out of standby
		virtual void wakeUp() = 0;

		// is A2DP output enabled
		virtual bool isA2dpEnabled() const = 0;
		};


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

		class BnAudioFlinger : public BnInterface<IAudioFlinger>
		{
		public:
		virtual status_t onTransact( uint32_t code,
		const Parcel& data,
		Parcel* reply,
		uint32_t flags = 0);
		};

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

		}; // namespace android

		#endif // ANDROID_IAUDIOFLINGER_H

include/media/IAudioFlingerClient.h

0 → 100644

+55 −0

File added.

Preview size limit exceeded, changes collapsed.