504 lines
17 KiB
C++
504 lines
17 KiB
C++
/* //device/include/server/AudioFlinger/AudioFlinger.h
|
|
**
|
|
** 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_FLINGER_H
|
|
#define ANDROID_AUDIO_FLINGER_H
|
|
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <media/IAudioFlinger.h>
|
|
#include <media/IAudioTrack.h>
|
|
#include <media/IAudioRecord.h>
|
|
#include <media/AudioTrack.h>
|
|
|
|
#include <utils/Atomic.h>
|
|
#include <utils/Errors.h>
|
|
#include <utils/threads.h>
|
|
#include <utils/MemoryDealer.h>
|
|
#include <utils/KeyedVector.h>
|
|
#include <utils/SortedVector.h>
|
|
|
|
#include <hardware_legacy/AudioHardwareInterface.h>
|
|
|
|
#include "AudioBufferProvider.h"
|
|
|
|
namespace android {
|
|
|
|
class audio_track_cblk_t;
|
|
class AudioMixer;
|
|
class AudioBuffer;
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
|
|
#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static const nsecs_t kStandbyTimeInNsecs = seconds(3);
|
|
|
|
class AudioFlinger : public BnAudioFlinger, protected Thread
|
|
{
|
|
public:
|
|
static void instantiate();
|
|
|
|
virtual status_t dump(int fd, const Vector<String16>& args);
|
|
|
|
// Thread virtuals
|
|
virtual bool threadLoop();
|
|
virtual status_t readyToRun();
|
|
virtual void onFirstRef();
|
|
|
|
// IAudioFlinger interface
|
|
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);
|
|
|
|
virtual uint32_t sampleRate() const;
|
|
virtual int channelCount() const;
|
|
virtual int format() const;
|
|
virtual size_t frameCount() const;
|
|
virtual size_t latency() const;
|
|
|
|
virtual status_t setMasterVolume(float value);
|
|
virtual status_t setMasterMute(bool muted);
|
|
|
|
virtual float masterVolume() const;
|
|
virtual bool masterMute() const;
|
|
|
|
virtual status_t setStreamVolume(int stream, float value);
|
|
virtual status_t setStreamMute(int stream, bool muted);
|
|
|
|
virtual float streamVolume(int stream) const;
|
|
virtual bool streamMute(int stream) const;
|
|
|
|
virtual status_t setRouting(int mode, uint32_t routes, uint32_t mask);
|
|
virtual uint32_t getRouting(int mode) const;
|
|
|
|
virtual status_t setMode(int mode);
|
|
virtual int getMode() const;
|
|
|
|
virtual status_t setMicMute(bool state);
|
|
virtual bool getMicMute() const;
|
|
|
|
virtual bool isMusicActive() const;
|
|
|
|
virtual status_t setParameter(const char* key, const char* value);
|
|
|
|
enum hardware_call_state {
|
|
AUDIO_HW_IDLE = 0,
|
|
AUDIO_HW_INIT,
|
|
AUDIO_HW_OUTPUT_OPEN,
|
|
AUDIO_HW_OUTPUT_CLOSE,
|
|
AUDIO_HW_INPUT_OPEN,
|
|
AUDIO_HW_INPUT_CLOSE,
|
|
AUDIO_HW_STANDBY,
|
|
AUDIO_HW_SET_MASTER_VOLUME,
|
|
AUDIO_HW_GET_ROUTING,
|
|
AUDIO_HW_SET_ROUTING,
|
|
AUDIO_HW_GET_MODE,
|
|
AUDIO_HW_SET_MODE,
|
|
AUDIO_HW_GET_MIC_MUTE,
|
|
AUDIO_HW_SET_MIC_MUTE,
|
|
AUDIO_SET_VOICE_VOLUME,
|
|
AUDIO_SET_PARAMETER,
|
|
};
|
|
|
|
// record interface
|
|
virtual sp<IAudioRecord> openRecord(
|
|
pid_t pid,
|
|
int streamType,
|
|
uint32_t sampleRate,
|
|
int format,
|
|
int channelCount,
|
|
int frameCount,
|
|
uint32_t flags,
|
|
status_t *status);
|
|
|
|
virtual status_t onTransact(
|
|
uint32_t code,
|
|
const Parcel& data,
|
|
Parcel* reply,
|
|
uint32_t flags);
|
|
|
|
private:
|
|
AudioFlinger();
|
|
virtual ~AudioFlinger();
|
|
|
|
void setOutput(AudioStreamOut* output);
|
|
void doSetOutput(AudioStreamOut* output);
|
|
size_t getOutputFrameCount(AudioStreamOut* output);
|
|
|
|
#ifdef WITH_A2DP
|
|
static bool streamDisablesA2dp(int streamType);
|
|
inline bool isA2dpEnabled() const {
|
|
return (mRequestedOutput == mA2dpOutput ||
|
|
(mOutput && mOutput == mA2dpOutput));
|
|
}
|
|
void setA2dpEnabled(bool enable);
|
|
#endif
|
|
|
|
// Internal dump utilites.
|
|
status_t dumpPermissionDenial(int fd, const Vector<String16>& args);
|
|
status_t dumpClients(int fd, const Vector<String16>& args);
|
|
status_t dumpTracks(int fd, const Vector<String16>& args);
|
|
status_t dumpInternals(int fd, const Vector<String16>& args);
|
|
|
|
// --- Client ---
|
|
class Client : public RefBase {
|
|
public:
|
|
Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
|
|
virtual ~Client();
|
|
const sp<MemoryDealer>& heap() const;
|
|
pid_t pid() const { return mPid; }
|
|
private:
|
|
Client(const Client&);
|
|
Client& operator = (const Client&);
|
|
sp<AudioFlinger> mAudioFlinger;
|
|
sp<MemoryDealer> mMemoryDealer;
|
|
pid_t mPid;
|
|
};
|
|
|
|
|
|
// --- Track ---
|
|
class TrackHandle;
|
|
class RecordHandle;
|
|
class AudioRecordThread;
|
|
|
|
// base for record and playback
|
|
class TrackBase : public AudioBufferProvider, public RefBase {
|
|
|
|
public:
|
|
enum track_state {
|
|
IDLE,
|
|
TERMINATED,
|
|
STOPPED,
|
|
RESUMING,
|
|
ACTIVE,
|
|
PAUSING,
|
|
PAUSED
|
|
};
|
|
|
|
enum track_flags {
|
|
STEPSERVER_FAILED = 0x01 // StepServer could not acquire cblk->lock mutex
|
|
};
|
|
|
|
TrackBase( const sp<AudioFlinger>& audioFlinger,
|
|
const sp<Client>& client,
|
|
int streamType,
|
|
uint32_t sampleRate,
|
|
int format,
|
|
int channelCount,
|
|
int frameCount,
|
|
const sp<IMemory>& sharedBuffer);
|
|
~TrackBase();
|
|
|
|
virtual status_t start() = 0;
|
|
virtual void stop() = 0;
|
|
sp<IMemory> getCblk() const;
|
|
|
|
protected:
|
|
friend class AudioFlinger;
|
|
friend class RecordHandle;
|
|
friend class AudioRecordThread;
|
|
|
|
TrackBase(const TrackBase&);
|
|
TrackBase& operator = (const TrackBase&);
|
|
|
|
virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
|
|
virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
|
|
|
|
audio_track_cblk_t* cblk() const {
|
|
return mCblk;
|
|
}
|
|
|
|
int type() const {
|
|
return mStreamType;
|
|
}
|
|
|
|
int format() const {
|
|
return mFormat;
|
|
}
|
|
|
|
int channelCount() const ;
|
|
|
|
int sampleRate() const;
|
|
|
|
void* getBuffer(uint32_t offset, uint32_t frames) const;
|
|
|
|
int name() const {
|
|
return mName;
|
|
}
|
|
|
|
bool isStopped() const {
|
|
return mState == STOPPED;
|
|
}
|
|
|
|
bool isTerminated() const {
|
|
return mState == TERMINATED;
|
|
}
|
|
|
|
bool step();
|
|
void reset();
|
|
|
|
sp<AudioFlinger> mAudioFlinger;
|
|
sp<Client> mClient;
|
|
sp<IMemory> mCblkMemory;
|
|
audio_track_cblk_t* mCblk;
|
|
int mStreamType;
|
|
void* mBuffer;
|
|
void* mBufferEnd;
|
|
uint32_t mFrameCount;
|
|
int mName;
|
|
// we don't really need a lock for these
|
|
int mState;
|
|
int mClientTid;
|
|
uint8_t mFormat;
|
|
uint8_t mFlags;
|
|
};
|
|
|
|
// playback track
|
|
class Track : public TrackBase {
|
|
public:
|
|
Track( const sp<AudioFlinger>& audioFlinger,
|
|
const sp<Client>& client,
|
|
int streamType,
|
|
uint32_t sampleRate,
|
|
int format,
|
|
int channelCount,
|
|
int frameCount,
|
|
const sp<IMemory>& sharedBuffer);
|
|
~Track();
|
|
|
|
void dump(char* buffer, size_t size);
|
|
virtual status_t start();
|
|
virtual void stop();
|
|
void pause();
|
|
|
|
void flush();
|
|
void destroy();
|
|
void mute(bool);
|
|
void setVolume(float left, float right);
|
|
|
|
private:
|
|
friend class AudioFlinger;
|
|
friend class TrackHandle;
|
|
|
|
Track(const Track&);
|
|
Track& operator = (const Track&);
|
|
|
|
virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
|
|
|
|
bool isMuted() const {
|
|
return mMute;
|
|
}
|
|
|
|
bool isPausing() const {
|
|
return mState == PAUSING;
|
|
}
|
|
|
|
bool isPaused() const {
|
|
return mState == PAUSED;
|
|
}
|
|
|
|
bool isReady() const;
|
|
|
|
void setPaused() { mState = PAUSED; }
|
|
void reset();
|
|
|
|
// we don't really need a lock for these
|
|
float mVolume[2];
|
|
volatile bool mMute;
|
|
// FILLED state is used for suppressing volume ramp at begin of playing
|
|
enum {FS_FILLING, FS_FILLED, FS_ACTIVE};
|
|
mutable uint8_t mFillingUpStatus;
|
|
int8_t mRetryCount;
|
|
sp<IMemory> mSharedBuffer;
|
|
bool mResetDone;
|
|
}; // end of Track
|
|
|
|
friend class AudioBuffer;
|
|
|
|
class TrackHandle : public android::BnAudioTrack {
|
|
public:
|
|
TrackHandle(const sp<Track>& track);
|
|
virtual ~TrackHandle();
|
|
virtual status_t start();
|
|
virtual void stop();
|
|
virtual void flush();
|
|
virtual void mute(bool);
|
|
virtual void pause();
|
|
virtual void setVolume(float left, float right);
|
|
virtual sp<IMemory> getCblk() const;
|
|
virtual status_t onTransact(
|
|
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
|
|
private:
|
|
sp<Track> mTrack;
|
|
};
|
|
|
|
struct stream_type_t {
|
|
stream_type_t()
|
|
: volume(1.0f),
|
|
mute(false)
|
|
{
|
|
}
|
|
float volume;
|
|
bool mute;
|
|
};
|
|
|
|
friend class Client;
|
|
friend class Track;
|
|
|
|
|
|
void removeClient(pid_t pid);
|
|
|
|
status_t addTrack(const sp<Track>& track);
|
|
void removeTrack(wp<Track> track, int name);
|
|
void remove_track_l(wp<Track> track, int name);
|
|
void destroyTrack(const sp<Track>& track);
|
|
void addActiveTrack(const wp<Track>& track);
|
|
void removeActiveTrack(const wp<Track>& track);
|
|
|
|
AudioMixer* audioMixer() {
|
|
return mAudioMixer;
|
|
}
|
|
|
|
// record track
|
|
class RecordTrack : public TrackBase {
|
|
public:
|
|
RecordTrack( const sp<AudioFlinger>& audioFlinger,
|
|
const sp<Client>& client,
|
|
int streamType,
|
|
uint32_t sampleRate,
|
|
int format,
|
|
int channelCount,
|
|
int frameCount);
|
|
~RecordTrack();
|
|
|
|
virtual status_t start();
|
|
virtual void stop();
|
|
|
|
bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; }
|
|
bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; }
|
|
|
|
private:
|
|
friend class AudioFlinger;
|
|
friend class RecordHandle;
|
|
friend class AudioRecordThread;
|
|
|
|
RecordTrack(const Track&);
|
|
RecordTrack& operator = (const Track&);
|
|
|
|
virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
|
|
|
|
bool mOverflow;
|
|
};
|
|
|
|
class RecordHandle : public android::BnAudioRecord {
|
|
public:
|
|
RecordHandle(const sp<RecordTrack>& recordTrack);
|
|
virtual ~RecordHandle();
|
|
virtual status_t start();
|
|
virtual void stop();
|
|
virtual sp<IMemory> getCblk() const;
|
|
virtual status_t onTransact(
|
|
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
|
|
private:
|
|
sp<RecordTrack> mRecordTrack;
|
|
};
|
|
|
|
// record thread
|
|
class AudioRecordThread : public Thread
|
|
{
|
|
public:
|
|
AudioRecordThread(AudioHardwareInterface* audioHardware);
|
|
virtual ~AudioRecordThread();
|
|
virtual bool threadLoop();
|
|
virtual status_t readyToRun() { return NO_ERROR; }
|
|
virtual void onFirstRef() {}
|
|
|
|
status_t start(RecordTrack* recordTrack);
|
|
void stop(RecordTrack* recordTrack);
|
|
void exit();
|
|
|
|
private:
|
|
AudioRecordThread();
|
|
AudioHardwareInterface *mAudioHardware;
|
|
sp<RecordTrack> mRecordTrack;
|
|
Mutex mLock;
|
|
Condition mWaitWorkCV;
|
|
volatile bool mActive;
|
|
status_t mStartStatus;
|
|
};
|
|
|
|
friend class AudioRecordThread;
|
|
|
|
status_t startRecord(RecordTrack* recordTrack);
|
|
void stopRecord(RecordTrack* recordTrack);
|
|
|
|
mutable Mutex mHardwareLock;
|
|
mutable Mutex mLock;
|
|
mutable Condition mWaitWorkCV;
|
|
DefaultKeyedVector< pid_t, wp<Client> > mClients;
|
|
SortedVector< wp<Track> > mActiveTracks;
|
|
SortedVector< sp<Track> > mTracks;
|
|
float mMasterVolume;
|
|
uint32_t mMasterRouting;
|
|
bool mMasterMute;
|
|
stream_type_t mStreamTypes[AudioTrack::NUM_STREAM_TYPES];
|
|
|
|
AudioMixer* mHardwareAudioMixer;
|
|
AudioMixer* mA2dpAudioMixer;
|
|
AudioMixer* mAudioMixer;
|
|
AudioHardwareInterface* mAudioHardware;
|
|
AudioHardwareInterface* mA2dpAudioInterface;
|
|
AudioStreamOut* mHardwareOutput;
|
|
AudioStreamOut* mA2dpOutput;
|
|
AudioStreamOut* mOutput;
|
|
AudioStreamOut* mRequestedOutput;
|
|
sp<AudioRecordThread> mAudioRecordThread;
|
|
uint32_t mSampleRate;
|
|
size_t mFrameCount;
|
|
int mChannelCount;
|
|
int mFormat;
|
|
int16_t* mMixBuffer;
|
|
mutable int mHardwareStatus;
|
|
nsecs_t mLastWriteTime;
|
|
int mNumWrites;
|
|
int mNumDelayedWrites;
|
|
bool mStandby;
|
|
bool mInWrite;
|
|
int mA2dpDisableCount;
|
|
bool mA2dpSuppressed;
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
}; // namespace android
|
|
|
|
#endif // ANDROID_AUDIO_FLINGER_H
|