You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
450 lines
19 KiB
450 lines
19 KiB
/*
|
|
**
|
|
** Copyright 2012, 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 INCLUDING_FROM_AUDIOFLINGER_H
|
|
#error This header file should only be included from AudioFlinger.h
|
|
#endif
|
|
|
|
// base for record and playback
|
|
class TrackBase : public ExtendedAudioBufferProvider, public RefBase {
|
|
|
|
public:
|
|
enum track_state {
|
|
IDLE,
|
|
FLUSHED, // for PlaybackTracks only
|
|
STOPPED,
|
|
// next 2 states are currently used for fast tracks
|
|
// and offloaded tracks only
|
|
STOPPING_1, // waiting for first underrun
|
|
STOPPING_2, // waiting for presentation complete
|
|
RESUMING, // for PlaybackTracks only
|
|
ACTIVE,
|
|
PAUSING,
|
|
PAUSED,
|
|
STARTING_1, // for RecordTrack only
|
|
STARTING_2, // for RecordTrack only
|
|
};
|
|
|
|
// where to allocate the data buffer
|
|
enum alloc_type {
|
|
ALLOC_CBLK, // allocate immediately after control block
|
|
ALLOC_READONLY, // allocate from a separate read-only heap per thread
|
|
ALLOC_PIPE, // do not allocate; use the pipe buffer
|
|
ALLOC_LOCAL, // allocate a local buffer
|
|
ALLOC_NONE, // do not allocate:use the buffer passed to TrackBase constructor
|
|
};
|
|
|
|
enum track_type {
|
|
TYPE_DEFAULT,
|
|
TYPE_OUTPUT,
|
|
TYPE_PATCH,
|
|
};
|
|
|
|
TrackBase(ThreadBase *thread,
|
|
const sp<Client>& client,
|
|
const audio_attributes_t& mAttr,
|
|
uint32_t sampleRate,
|
|
audio_format_t format,
|
|
audio_channel_mask_t channelMask,
|
|
size_t frameCount,
|
|
void *buffer,
|
|
size_t bufferSize,
|
|
audio_session_t sessionId,
|
|
pid_t creatorPid,
|
|
uid_t uid,
|
|
bool isOut,
|
|
alloc_type alloc = ALLOC_CBLK,
|
|
track_type type = TYPE_DEFAULT,
|
|
audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
|
|
std::string metricsId = {});
|
|
virtual ~TrackBase();
|
|
virtual status_t initCheck() const;
|
|
|
|
virtual status_t start(AudioSystem::sync_event_t event,
|
|
audio_session_t triggerSession) = 0;
|
|
virtual void stop() = 0;
|
|
sp<IMemory> getCblk() const { return mCblkMemory; }
|
|
audio_track_cblk_t* cblk() const { return mCblk; }
|
|
audio_session_t sessionId() const { return mSessionId; }
|
|
uid_t uid() const { return mUid; }
|
|
pid_t creatorPid() const { return mCreatorPid; }
|
|
|
|
audio_port_handle_t portId() const { return mPortId; }
|
|
virtual status_t setSyncEvent(const sp<SyncEvent>& event);
|
|
|
|
sp<IMemory> getBuffers() const { return mBufferMemory; }
|
|
void* buffer() const { return mBuffer; }
|
|
size_t bufferSize() const { return mBufferSize; }
|
|
virtual bool isFastTrack() const = 0;
|
|
virtual bool isDirect() const = 0;
|
|
bool isOutputTrack() const { return (mType == TYPE_OUTPUT); }
|
|
bool isPatchTrack() const { return (mType == TYPE_PATCH); }
|
|
bool isExternalTrack() const { return !isOutputTrack() && !isPatchTrack(); }
|
|
|
|
virtual void invalidate() {
|
|
if (mIsInvalid) return;
|
|
mTrackMetrics.logInvalidate();
|
|
mIsInvalid = true;
|
|
}
|
|
bool isInvalid() const { return mIsInvalid; }
|
|
|
|
void terminate() { mTerminated = true; }
|
|
bool isTerminated() const { return mTerminated; }
|
|
|
|
audio_attributes_t attributes() const { return mAttr; }
|
|
|
|
#ifdef TEE_SINK
|
|
void dumpTee(int fd, const std::string &reason) const {
|
|
mTee.dump(fd, reason);
|
|
}
|
|
#endif
|
|
|
|
/** returns the buffer contents size converted to time in milliseconds
|
|
* for PCM Playback or Record streaming tracks. The return value is zero for
|
|
* PCM static tracks and not defined for non-PCM tracks.
|
|
*
|
|
* This may be called without the thread lock.
|
|
*/
|
|
virtual double bufferLatencyMs() const {
|
|
return mServerProxy->framesReadySafe() * 1000 / sampleRate();
|
|
}
|
|
|
|
/** returns whether the track supports server latency computation.
|
|
* This is set in the constructor and constant throughout the track lifetime.
|
|
*/
|
|
|
|
bool isServerLatencySupported() const { return mServerLatencySupported; }
|
|
|
|
/** computes the server latency for PCM Playback or Record track
|
|
* to the device sink/source. This is the time for the next frame in the track buffer
|
|
* written or read from the server thread to the device source or sink.
|
|
*
|
|
* This may be called without the thread lock, but latencyMs and fromTrack
|
|
* may be not be synchronized. For example PatchPanel may not obtain the
|
|
* thread lock before calling.
|
|
*
|
|
* \param latencyMs on success is set to the latency in milliseconds of the
|
|
* next frame written/read by the server thread to/from the track buffer
|
|
* from the device source/sink.
|
|
* \param fromTrack on success is set to true if latency was computed directly
|
|
* from the track timestamp; otherwise set to false if latency was
|
|
* estimated from the server timestamp.
|
|
* fromTrack may be nullptr or omitted if not required.
|
|
*
|
|
* \returns OK or INVALID_OPERATION on failure.
|
|
*/
|
|
status_t getServerLatencyMs(double *latencyMs, bool *fromTrack = nullptr) const {
|
|
if (!isServerLatencySupported()) {
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
// if no thread lock is acquired, these atomics are not
|
|
// synchronized with each other, considered a benign race.
|
|
|
|
const double serverLatencyMs = mServerLatencyMs.load();
|
|
if (serverLatencyMs == 0.) {
|
|
return INVALID_OPERATION;
|
|
}
|
|
if (fromTrack != nullptr) {
|
|
*fromTrack = mServerLatencyFromTrack.load();
|
|
}
|
|
*latencyMs = serverLatencyMs;
|
|
return OK;
|
|
}
|
|
|
|
/** computes the total client latency for PCM Playback or Record tracks
|
|
* for the next client app access to the device sink/source; i.e. the
|
|
* server latency plus the buffer latency.
|
|
*
|
|
* This may be called without the thread lock, but latencyMs and fromTrack
|
|
* may be not be synchronized. For example PatchPanel may not obtain the
|
|
* thread lock before calling.
|
|
*
|
|
* \param latencyMs on success is set to the latency in milliseconds of the
|
|
* next frame written/read by the client app to/from the track buffer
|
|
* from the device sink/source.
|
|
* \param fromTrack on success is set to true if latency was computed directly
|
|
* from the track timestamp; otherwise set to false if latency was
|
|
* estimated from the server timestamp.
|
|
* fromTrack may be nullptr or omitted if not required.
|
|
*
|
|
* \returns OK or INVALID_OPERATION on failure.
|
|
*/
|
|
status_t getTrackLatencyMs(double *latencyMs, bool *fromTrack = nullptr) const {
|
|
double serverLatencyMs;
|
|
status_t status = getServerLatencyMs(&serverLatencyMs, fromTrack);
|
|
if (status == OK) {
|
|
*latencyMs = serverLatencyMs + bufferLatencyMs();
|
|
}
|
|
return status;
|
|
}
|
|
|
|
// TODO: Consider making this external.
|
|
struct FrameTime {
|
|
int64_t frames;
|
|
int64_t timeNs;
|
|
};
|
|
|
|
// KernelFrameTime is updated per "mix" period even for non-pcm tracks.
|
|
void getKernelFrameTime(FrameTime *ft) const {
|
|
*ft = mKernelFrameTime.load();
|
|
}
|
|
|
|
audio_format_t format() const { return mFormat; }
|
|
int id() const { return mId; }
|
|
|
|
const char *getTrackStateAsString() const {
|
|
if (isTerminated()) {
|
|
return "TERMINATED";
|
|
}
|
|
switch (mState) {
|
|
case IDLE:
|
|
return "IDLE";
|
|
case STOPPING_1: // for Fast and Offload
|
|
return "STOPPING_1";
|
|
case STOPPING_2: // for Fast and Offload
|
|
return "STOPPING_2";
|
|
case STOPPED:
|
|
return "STOPPED";
|
|
case RESUMING:
|
|
return "RESUMING";
|
|
case ACTIVE:
|
|
return "ACTIVE";
|
|
case PAUSING:
|
|
return "PAUSING";
|
|
case PAUSED:
|
|
return "PAUSED";
|
|
case FLUSHED:
|
|
return "FLUSHED";
|
|
case STARTING_1: // for RecordTrack
|
|
return "STARTING_1";
|
|
case STARTING_2: // for RecordTrack
|
|
return "STARTING_2";
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
// Called by the PlaybackThread to indicate that the track is becoming active
|
|
// and a new interval should start with a given device list.
|
|
void logBeginInterval(const std::string& devices) {
|
|
mTrackMetrics.logBeginInterval(devices);
|
|
}
|
|
|
|
// Called by the PlaybackThread to indicate the track is no longer active.
|
|
void logEndInterval() {
|
|
mTrackMetrics.logEndInterval();
|
|
}
|
|
|
|
// Called to tally underrun frames in playback.
|
|
virtual void tallyUnderrunFrames(size_t /* frames */) {}
|
|
|
|
audio_channel_mask_t channelMask() const { return mChannelMask; }
|
|
|
|
/** @return true if the track has changed (metadata or volume) since
|
|
* the last time this function was called,
|
|
* true if this function was never called since the track creation,
|
|
* false otherwise.
|
|
* Thread safe.
|
|
*/
|
|
bool readAndClearHasChanged() { return !mChangeNotified.test_and_set(); }
|
|
|
|
/** Set that a metadata has changed and needs to be notified to backend. Thread safe. */
|
|
void setMetadataHasChanged() { mChangeNotified.clear(); }
|
|
|
|
protected:
|
|
DISALLOW_COPY_AND_ASSIGN(TrackBase);
|
|
|
|
void releaseCblk() {
|
|
if (mCblk != nullptr) {
|
|
mCblk->~audio_track_cblk_t(); // destroy our shared-structure.
|
|
if (mClient == 0) {
|
|
free(mCblk);
|
|
}
|
|
mCblk = nullptr;
|
|
}
|
|
}
|
|
|
|
// AudioBufferProvider interface
|
|
virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
|
|
virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
|
|
|
|
// ExtendedAudioBufferProvider interface is only needed for Track,
|
|
// but putting it in TrackBase avoids the complexity of virtual inheritance
|
|
virtual size_t framesReady() const { return SIZE_MAX; }
|
|
|
|
uint32_t channelCount() const { return mChannelCount; }
|
|
|
|
size_t frameSize() const { return mFrameSize; }
|
|
|
|
virtual uint32_t sampleRate() const { return mSampleRate; }
|
|
|
|
bool isStopped() const {
|
|
return (mState == STOPPED || mState == FLUSHED);
|
|
}
|
|
|
|
// for fast tracks and offloaded tracks only
|
|
bool isStopping() const {
|
|
return mState == STOPPING_1 || mState == STOPPING_2;
|
|
}
|
|
bool isStopping_1() const {
|
|
return mState == STOPPING_1;
|
|
}
|
|
bool isStopping_2() const {
|
|
return mState == STOPPING_2;
|
|
}
|
|
|
|
// Upper case characters are final states.
|
|
// Lower case characters are transitory.
|
|
const char *getTrackStateAsCodedString() const {
|
|
if (isTerminated()) {
|
|
return "T ";
|
|
}
|
|
switch (mState) {
|
|
case IDLE:
|
|
return "I ";
|
|
case STOPPING_1: // for Fast and Offload
|
|
return "s1";
|
|
case STOPPING_2: // for Fast and Offload
|
|
return "s2";
|
|
case STOPPED:
|
|
return "S ";
|
|
case RESUMING:
|
|
return "r ";
|
|
case ACTIVE:
|
|
return "A ";
|
|
case PAUSING:
|
|
return "p ";
|
|
case PAUSED:
|
|
return "P ";
|
|
case FLUSHED:
|
|
return "F ";
|
|
case STARTING_1: // for RecordTrack
|
|
return "r1";
|
|
case STARTING_2: // for RecordTrack
|
|
return "r2";
|
|
default:
|
|
return "? ";
|
|
}
|
|
}
|
|
|
|
bool isOut() const { return mIsOut; }
|
|
// true for Track, false for RecordTrack,
|
|
// this could be a track type if needed later
|
|
|
|
const wp<ThreadBase> mThread;
|
|
/*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const
|
|
sp<IMemory> mCblkMemory;
|
|
audio_track_cblk_t* mCblk;
|
|
sp<IMemory> mBufferMemory; // currently non-0 for fast RecordTrack only
|
|
void* mBuffer; // start of track buffer, typically in shared memory
|
|
// except for OutputTrack when it is in local memory
|
|
size_t mBufferSize; // size of mBuffer in bytes
|
|
// we don't really need a lock for these
|
|
track_state mState;
|
|
const audio_attributes_t mAttr;
|
|
const uint32_t mSampleRate; // initial sample rate only; for tracks which
|
|
// support dynamic rates, the current value is in control block
|
|
const audio_format_t mFormat;
|
|
const audio_channel_mask_t mChannelMask;
|
|
const uint32_t mChannelCount;
|
|
const size_t mFrameSize; // AudioFlinger's view of frame size in shared memory,
|
|
// where for AudioTrack (but not AudioRecord),
|
|
// 8-bit PCM samples are stored as 16-bit
|
|
const size_t mFrameCount;// size of track buffer given at createTrack() or
|
|
// createRecord(), and then adjusted as needed
|
|
|
|
const audio_session_t mSessionId;
|
|
uid_t mUid;
|
|
Vector < sp<SyncEvent> >mSyncEvents;
|
|
const bool mIsOut;
|
|
sp<ServerProxy> mServerProxy;
|
|
const int mId;
|
|
#ifdef TEE_SINK
|
|
NBAIO_Tee mTee;
|
|
#endif
|
|
bool mTerminated;
|
|
track_type mType; // must be one of TYPE_DEFAULT, TYPE_OUTPUT, TYPE_PATCH ...
|
|
audio_io_handle_t mThreadIoHandle; // I/O handle of the thread the track is attached to
|
|
audio_port_handle_t mPortId; // unique ID for this track used by audio policy
|
|
bool mIsInvalid; // non-resettable latch, set by invalidate()
|
|
|
|
// It typically takes 5 threadloop mix iterations for latency to stabilize.
|
|
// However, this can be 12+ iterations for BT.
|
|
// To be sure, we wait for latency to dip (it usually increases at the start)
|
|
// to assess stability and then log to MediaMetrics.
|
|
// Rapid start / pause calls may cause inaccurate numbers.
|
|
static inline constexpr int32_t LOG_START_COUNTDOWN = 12;
|
|
int32_t mLogStartCountdown = 0; // Mixer period countdown
|
|
int64_t mLogStartTimeNs = 0; // Monotonic time at start()
|
|
int64_t mLogStartFrames = 0; // Timestamp frames at start()
|
|
double mLogLatencyMs = 0.; // Track the last log latency
|
|
|
|
TrackMetrics mTrackMetrics;
|
|
|
|
bool mServerLatencySupported = false;
|
|
std::atomic<bool> mServerLatencyFromTrack{}; // latency from track or server timestamp.
|
|
std::atomic<double> mServerLatencyMs{}; // last latency pushed from server thread.
|
|
std::atomic<FrameTime> mKernelFrameTime{}; // last frame time on kernel side.
|
|
const pid_t mCreatorPid; // can be different from mclient->pid() for instance
|
|
// when created by NuPlayer on behalf of a client
|
|
|
|
// If the last track change was notified to the client with readAndClearHasChanged
|
|
std::atomic_flag mChangeNotified = ATOMIC_FLAG_INIT;
|
|
};
|
|
|
|
// PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord.
|
|
// it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h)
|
|
class PatchProxyBufferProvider
|
|
{
|
|
public:
|
|
|
|
virtual ~PatchProxyBufferProvider() {}
|
|
|
|
virtual bool producesBufferOnDemand() const = 0;
|
|
virtual status_t obtainBuffer(Proxy::Buffer* buffer,
|
|
const struct timespec *requested = NULL) = 0;
|
|
virtual void releaseBuffer(Proxy::Buffer* buffer) = 0;
|
|
};
|
|
|
|
class PatchTrackBase : public PatchProxyBufferProvider
|
|
{
|
|
public:
|
|
using Timeout = std::optional<std::chrono::nanoseconds>;
|
|
PatchTrackBase(sp<ClientProxy> proxy, const ThreadBase& thread,
|
|
const Timeout& timeout);
|
|
void setPeerTimeout(std::chrono::nanoseconds timeout);
|
|
template <typename T>
|
|
void setPeerProxy(const sp<T> &proxy, bool holdReference) {
|
|
mPeerReferenceHold = holdReference ? proxy : nullptr;
|
|
mPeerProxy = proxy.get();
|
|
}
|
|
void clearPeerProxy() {
|
|
mPeerReferenceHold.clear();
|
|
mPeerProxy = nullptr;
|
|
}
|
|
|
|
bool producesBufferOnDemand() const override { return false; }
|
|
|
|
protected:
|
|
const sp<ClientProxy> mProxy;
|
|
sp<RefBase> mPeerReferenceHold; // keeps mPeerProxy alive during access.
|
|
PatchProxyBufferProvider* mPeerProxy = nullptr;
|
|
struct timespec mPeerTimeout{};
|
|
|
|
};
|