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