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,
     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,
     35         ACTIVE,
     36         PAUSING,
     37         PAUSED
     38     };
     39 
     40                         TrackBase(ThreadBase *thread,
     41                                 const sp<Client>& client,
     42                                 uint32_t sampleRate,
     43                                 audio_format_t format,
     44                                 audio_channel_mask_t channelMask,
     45                                 size_t frameCount,
     46                                 const sp<IMemory>& sharedBuffer,
     47                                 int sessionId,
     48                                 bool isOut);
     49     virtual             ~TrackBase();
     50 
     51     virtual status_t    start(AudioSystem::sync_event_t event,
     52                              int triggerSession) = 0;
     53     virtual void        stop() = 0;
     54             sp<IMemory> getCblk() const { return mCblkMemory; }
     55             audio_track_cblk_t* cblk() const { return mCblk; }
     56             int         sessionId() const { return mSessionId; }
     57     virtual status_t    setSyncEvent(const sp<SyncEvent>& event);
     58 
     59 protected:
     60                         TrackBase(const TrackBase&);
     61                         TrackBase& operator = (const TrackBase&);
     62 
     63     // AudioBufferProvider interface
     64     virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0;
     65     virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
     66 
     67     // ExtendedAudioBufferProvider interface is only needed for Track,
     68     // but putting it in TrackBase avoids the complexity of virtual inheritance
     69     virtual size_t  framesReady() const { return SIZE_MAX; }
     70 
     71     audio_format_t format() const { return mFormat; }
     72 
     73     uint32_t channelCount() const { return mChannelCount; }
     74 
     75     audio_channel_mask_t channelMask() const { return mChannelMask; }
     76 
     77     virtual uint32_t sampleRate() const { return mSampleRate; }
     78 
     79     // Return a pointer to the start of a contiguous slice of the track buffer.
     80     // Parameter 'offset' is the requested start position, expressed in
     81     // monotonically increasing frame units relative to the track epoch.
     82     // Parameter 'frames' is the requested length, also in frame units.
     83     // Always returns non-NULL.  It is the caller's responsibility to
     84     // verify that this will be successful; the result of calling this
     85     // function with invalid 'offset' or 'frames' is undefined.
     86     void* getBuffer(uint32_t offset, uint32_t frames) const;
     87 
     88     bool isStopped() const {
     89         return (mState == STOPPED || mState == FLUSHED);
     90     }
     91 
     92     // for fast tracks and offloaded tracks only
     93     bool isStopping() const {
     94         return mState == STOPPING_1 || mState == STOPPING_2;
     95     }
     96     bool isStopping_1() const {
     97         return mState == STOPPING_1;
     98     }
     99     bool isStopping_2() const {
    100         return mState == STOPPING_2;
    101     }
    102 
    103     bool isTerminated() const {
    104         return mTerminated;
    105     }
    106 
    107     void terminate() {
    108         mTerminated = true;
    109     }
    110 
    111     bool isOut() const { return mIsOut; }
    112                                     // true for Track and TimedTrack, false for RecordTrack,
    113                                     // this could be a track type if needed later
    114 
    115     const wp<ThreadBase> mThread;
    116     /*const*/ sp<Client> mClient;   // see explanation at ~TrackBase() why not const
    117     sp<IMemory>         mCblkMemory;
    118     audio_track_cblk_t* mCblk;
    119     void*               mBuffer;    // start of track buffer, typically in shared memory
    120                                     // except for OutputTrack when it is in local memory
    121     // we don't really need a lock for these
    122     track_state         mState;
    123     const uint32_t      mSampleRate;    // initial sample rate only; for tracks which
    124                         // support dynamic rates, the current value is in control block
    125     const audio_format_t mFormat;
    126     const audio_channel_mask_t mChannelMask;
    127     const uint32_t      mChannelCount;
    128     const size_t        mFrameSize; // AudioFlinger's view of frame size in shared memory,
    129                                     // where for AudioTrack (but not AudioRecord),
    130                                     // 8-bit PCM samples are stored as 16-bit
    131     const size_t        mFrameCount;// size of track buffer given at createTrack() or
    132                                     // openRecord(), and then adjusted as needed
    133 
    134     const int           mSessionId;
    135     Vector < sp<SyncEvent> >mSyncEvents;
    136     const bool          mIsOut;
    137     ServerProxy*        mServerProxy;
    138     const int           mId;
    139     sp<NBAIO_Sink>      mTeeSink;
    140     sp<NBAIO_Source>    mTeeSource;
    141     bool                mTerminated;
    142 };
    143