Home | History | Annotate | Download | only in audioflinger
      1 /*
      2 **
      3 ** Copyright 2012, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 
     18 #ifndef INCLUDING_FROM_AUDIOFLINGER_H
     19     #error This header file should only be included from AudioFlinger.h
     20 #endif
     21 
     22 // base for record and playback
     23 class TrackBase : public ExtendedAudioBufferProvider, public RefBase {
     24 
     25 public:
     26     enum track_state {
     27         IDLE,
     28         FLUSHED,        // for PlaybackTracks only
     29         STOPPED,
     30         // next 2 states are currently used for fast tracks
     31         // and offloaded tracks only
     32         STOPPING_1,     // waiting for first underrun
     33         STOPPING_2,     // waiting for presentation complete
     34         RESUMING,       // for PlaybackTracks only
     35         ACTIVE,
     36         PAUSING,
     37         PAUSED,
     38         STARTING_1,     // for RecordTrack only
     39         STARTING_2,     // for RecordTrack only
     40     };
     41 
     42     // where to allocate the data buffer
     43     enum alloc_type {
     44         ALLOC_CBLK,     // allocate immediately after control block
     45         ALLOC_READONLY, // allocate from a separate read-only heap per thread
     46         ALLOC_PIPE,     // do not allocate; use the pipe buffer
     47         ALLOC_LOCAL,    // allocate a local buffer
     48         ALLOC_NONE,     // do not allocate:use the buffer passed to TrackBase constructor
     49     };
     50 
     51     enum track_type {
     52         TYPE_DEFAULT,
     53         TYPE_OUTPUT,
     54         TYPE_PATCH,
     55     };
     56 
     57                         TrackBase(ThreadBase *thread,
     58                                 const sp<Client>& client,
     59                                 const audio_attributes_t& mAttr,
     60                                 uint32_t sampleRate,
     61                                 audio_format_t format,
     62                                 audio_channel_mask_t channelMask,
     63                                 size_t frameCount,
     64                                 void *buffer,
     65                                 size_t bufferSize,
     66                                 audio_session_t sessionId,
     67                                 pid_t creatorPid,
     68                                 uid_t uid,
     69                                 bool isOut,
     70                                 alloc_type alloc = ALLOC_CBLK,
     71                                 track_type type = TYPE_DEFAULT,
     72                                 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
     73     virtual             ~TrackBase();
     74     virtual status_t    initCheck() const;
     75 
     76     virtual status_t    start(AudioSystem::sync_event_t event,
     77                              audio_session_t triggerSession) = 0;
     78     virtual void        stop() = 0;
     79             sp<IMemory> getCblk() const { return mCblkMemory; }
     80             audio_track_cblk_t* cblk() const { return mCblk; }
     81             audio_session_t sessionId() const { return mSessionId; }
     82             uid_t       uid() const { return mUid; }
     83             pid_t       creatorPid() const { return mCreatorPid; }
     84 
     85             audio_port_handle_t portId() const { return mPortId; }
     86     virtual status_t    setSyncEvent(const sp<SyncEvent>& event);
     87 
     88             sp<IMemory> getBuffers() const { return mBufferMemory; }
     89             void*       buffer() const { return mBuffer; }
     90             size_t      bufferSize() const { return mBufferSize; }
     91     virtual bool        isFastTrack() const = 0;
     92     virtual bool        isDirect() const = 0;
     93             bool        isOutputTrack() const { return (mType == TYPE_OUTPUT); }
     94             bool        isPatchTrack() const { return (mType == TYPE_PATCH); }
     95             bool        isExternalTrack() const { return !isOutputTrack() && !isPatchTrack(); }
     96 
     97     virtual void        invalidate() { mIsInvalid = true; }
     98             bool        isInvalid() const { return mIsInvalid; }
     99 
    100             void        terminate() { mTerminated = true; }
    101             bool        isTerminated() const { return mTerminated; }
    102 
    103     audio_attributes_t  attributes() const { return mAttr; }
    104 
    105 #ifdef TEE_SINK
    106            void         dumpTee(int fd, const std::string &reason) const {
    107                                 mTee.dump(fd, reason);
    108                         }
    109 #endif
    110 
    111             /** returns the buffer contents size converted to time in milliseconds
    112              * for PCM Playback or Record streaming tracks. The return value is zero for
    113              * PCM static tracks and not defined for non-PCM tracks.
    114              *
    115              * This may be called without the thread lock.
    116              */
    117     virtual double      bufferLatencyMs() const {
    118                             return mServerProxy->framesReadySafe() * 1000 / sampleRate();
    119                         }
    120 
    121             /** returns whether the track supports server latency computation.
    122              * This is set in the constructor and constant throughout the track lifetime.
    123              */
    124 
    125             bool        isServerLatencySupported() const { return mServerLatencySupported; }
    126 
    127             /** computes the server latency for PCM Playback or Record track
    128              * to the device sink/source.  This is the time for the next frame in the track buffer
    129              * written or read from the server thread to the device source or sink.
    130              *
    131              * This may be called without the thread lock, but latencyMs and fromTrack
    132              * may be not be synchronized. For example PatchPanel may not obtain the
    133              * thread lock before calling.
    134              *
    135              * \param latencyMs on success is set to the latency in milliseconds of the
    136              *        next frame written/read by the server thread to/from the track buffer
    137              *        from the device source/sink.
    138              * \param fromTrack on success is set to true if latency was computed directly
    139              *        from the track timestamp; otherwise set to false if latency was
    140              *        estimated from the server timestamp.
    141              *        fromTrack may be nullptr or omitted if not required.
    142              *
    143              * \returns OK or INVALID_OPERATION on failure.
    144              */
    145             status_t    getServerLatencyMs(double *latencyMs, bool *fromTrack = nullptr) const {
    146                             if (!isServerLatencySupported()) {
    147                                 return INVALID_OPERATION;
    148                             }
    149 
    150                             // if no thread lock is acquired, these atomics are not
    151                             // synchronized with each other, considered a benign race.
    152 
    153                             const double serverLatencyMs = mServerLatencyMs.load();
    154                             if (serverLatencyMs == 0.) {
    155                                 return INVALID_OPERATION;
    156                             }
    157                             if (fromTrack != nullptr) {
    158                                 *fromTrack = mServerLatencyFromTrack.load();
    159                             }
    160                             *latencyMs = serverLatencyMs;
    161                             return OK;
    162                         }
    163 
    164             /** computes the total client latency for PCM Playback or Record tracks
    165              * for the next client app access to the device sink/source; i.e. the
    166              * server latency plus the buffer latency.
    167              *
    168              * This may be called without the thread lock, but latencyMs and fromTrack
    169              * may be not be synchronized. For example PatchPanel may not obtain the
    170              * thread lock before calling.
    171              *
    172              * \param latencyMs on success is set to the latency in milliseconds of the
    173              *        next frame written/read by the client app to/from the track buffer
    174              *        from the device sink/source.
    175              * \param fromTrack on success is set to true if latency was computed directly
    176              *        from the track timestamp; otherwise set to false if latency was
    177              *        estimated from the server timestamp.
    178              *        fromTrack may be nullptr or omitted if not required.
    179              *
    180              * \returns OK or INVALID_OPERATION on failure.
    181              */
    182             status_t    getTrackLatencyMs(double *latencyMs, bool *fromTrack = nullptr) const {
    183                             double serverLatencyMs;
    184                             status_t status = getServerLatencyMs(&serverLatencyMs, fromTrack);
    185                             if (status == OK) {
    186                                 *latencyMs = serverLatencyMs + bufferLatencyMs();
    187                             }
    188                             return status;
    189                         }
    190 
    191            // TODO: Consider making this external.
    192            struct FrameTime {
    193                int64_t frames;
    194                int64_t timeNs;
    195            };
    196 
    197            // KernelFrameTime is updated per "mix" period even for non-pcm tracks.
    198            void         getKernelFrameTime(FrameTime *ft) const {
    199                            *ft = mKernelFrameTime.load();
    200                         }
    201 
    202            audio_format_t format() const { return mFormat; }
    203            int id() const { return mId; }
    204 
    205 protected:
    206     DISALLOW_COPY_AND_ASSIGN(TrackBase);
    207 
    208     // AudioBufferProvider interface
    209     virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
    210     virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
    211 
    212     // ExtendedAudioBufferProvider interface is only needed for Track,
    213     // but putting it in TrackBase avoids the complexity of virtual inheritance
    214     virtual size_t  framesReady() const { return SIZE_MAX; }
    215 
    216     uint32_t channelCount() const { return mChannelCount; }
    217 
    218     audio_channel_mask_t channelMask() const { return mChannelMask; }
    219 
    220     virtual uint32_t sampleRate() const { return mSampleRate; }
    221 
    222     bool isStopped() const {
    223         return (mState == STOPPED || mState == FLUSHED);
    224     }
    225 
    226     // for fast tracks and offloaded tracks only
    227     bool isStopping() const {
    228         return mState == STOPPING_1 || mState == STOPPING_2;
    229     }
    230     bool isStopping_1() const {
    231         return mState == STOPPING_1;
    232     }
    233     bool isStopping_2() const {
    234         return mState == STOPPING_2;
    235     }
    236 
    237     // Upper case characters are final states.
    238     // Lower case characters are transitory.
    239     const char *getTrackStateString() const {
    240         if (isTerminated()) {
    241             return "T ";
    242         }
    243         switch (mState) {
    244         case IDLE:
    245             return "I ";
    246         case STOPPING_1: // for Fast and Offload
    247             return "s1";
    248         case STOPPING_2: // for Fast and Offload
    249             return "s2";
    250         case STOPPED:
    251             return "S ";
    252         case RESUMING:
    253             return "r ";
    254         case ACTIVE:
    255             return "A ";
    256         case PAUSING:
    257             return "p ";
    258         case PAUSED:
    259             return "P ";
    260         case FLUSHED:
    261             return "F ";
    262         case STARTING_1: // for RecordTrack
    263             return "r1";
    264         case STARTING_2: // for RecordTrack
    265             return "r2";
    266         default:
    267             return "? ";
    268         }
    269     }
    270 
    271     bool isOut() const { return mIsOut; }
    272                                     // true for Track, false for RecordTrack,
    273                                     // this could be a track type if needed later
    274 
    275     const wp<ThreadBase> mThread;
    276     /*const*/ sp<Client> mClient;   // see explanation at ~TrackBase() why not const
    277     sp<IMemory>         mCblkMemory;
    278     audio_track_cblk_t* mCblk;
    279     sp<IMemory>         mBufferMemory;  // currently non-0 for fast RecordTrack only
    280     void*               mBuffer;    // start of track buffer, typically in shared memory
    281                                     // except for OutputTrack when it is in local memory
    282     size_t              mBufferSize; // size of mBuffer in bytes
    283     // we don't really need a lock for these
    284     track_state         mState;
    285     const audio_attributes_t mAttr;
    286     const uint32_t      mSampleRate;    // initial sample rate only; for tracks which
    287                         // support dynamic rates, the current value is in control block
    288     const audio_format_t mFormat;
    289     const audio_channel_mask_t mChannelMask;
    290     const uint32_t      mChannelCount;
    291     const size_t        mFrameSize; // AudioFlinger's view of frame size in shared memory,
    292                                     // where for AudioTrack (but not AudioRecord),
    293                                     // 8-bit PCM samples are stored as 16-bit
    294     const size_t        mFrameCount;// size of track buffer given at createTrack() or
    295                                     // createRecord(), and then adjusted as needed
    296 
    297     const audio_session_t mSessionId;
    298     uid_t               mUid;
    299     Vector < sp<SyncEvent> >mSyncEvents;
    300     const bool          mIsOut;
    301     sp<ServerProxy>     mServerProxy;
    302     const int           mId;
    303 #ifdef TEE_SINK
    304     NBAIO_Tee           mTee;
    305 #endif
    306     bool                mTerminated;
    307     track_type          mType;      // must be one of TYPE_DEFAULT, TYPE_OUTPUT, TYPE_PATCH ...
    308     audio_io_handle_t   mThreadIoHandle; // I/O handle of the thread the track is attached to
    309     audio_port_handle_t mPortId; // unique ID for this track used by audio policy
    310     bool                mIsInvalid; // non-resettable latch, set by invalidate()
    311 
    312     bool                mServerLatencySupported = false;
    313     std::atomic<bool>   mServerLatencyFromTrack{}; // latency from track or server timestamp.
    314     std::atomic<double> mServerLatencyMs{};        // last latency pushed from server thread.
    315     std::atomic<FrameTime> mKernelFrameTime{};     // last frame time on kernel side.
    316     const pid_t         mCreatorPid;  // can be different from mclient->pid() for instance
    317                                       // when created by NuPlayer on behalf of a client
    318 };
    319 
    320 // PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord.
    321 // it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h)
    322 class PatchProxyBufferProvider
    323 {
    324 public:
    325 
    326     virtual ~PatchProxyBufferProvider() {}
    327 
    328     virtual status_t    obtainBuffer(Proxy::Buffer* buffer,
    329                                      const struct timespec *requested = NULL) = 0;
    330     virtual void        releaseBuffer(Proxy::Buffer* buffer) = 0;
    331 };
    332 
    333 class PatchTrackBase : public PatchProxyBufferProvider
    334 {
    335 public:
    336     using Timeout = std::optional<std::chrono::nanoseconds>;
    337                         PatchTrackBase(sp<ClientProxy> proxy, const ThreadBase& thread,
    338                                        const Timeout& timeout);
    339             void        setPeerTimeout(std::chrono::nanoseconds timeout);
    340             template <typename T>
    341             void        setPeerProxy(const sp<T> &proxy, bool holdReference) {
    342                             mPeerReferenceHold = holdReference ? proxy : nullptr;
    343                             mPeerProxy = proxy.get();
    344                         }
    345             void        clearPeerProxy() {
    346                             mPeerReferenceHold.clear();
    347                             mPeerProxy = nullptr;
    348                         }
    349 
    350 protected:
    351     const sp<ClientProxy>       mProxy;
    352     sp<RefBase>                 mPeerReferenceHold;   // keeps mPeerProxy alive during access.
    353     PatchProxyBufferProvider*   mPeerProxy = nullptr;
    354     struct timespec             mPeerTimeout{};
    355 
    356 };
    357