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         TERMINATED,
     29         FLUSHED,
     30         STOPPED,
     31         // next 2 states are currently used for fast 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     uint32_t sampleRate() const; // FIXME inline after cblk sr moved
     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 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 mState == TERMINATED;
    105     }
    106 
    107     bool step();    // mStepCount is an implicit input
    108     void reset();
    109 
    110     bool isOut() const { return mIsOut; }
    111                                     // true for Track and TimedTrack, false for RecordTrack,
    112                                     // this could be a track type if needed later
    113 
    114     const wp<ThreadBase> mThread;
    115     /*const*/ sp<Client> mClient;   // see explanation at ~TrackBase() why not const
    116     sp<IMemory>         mCblkMemory;
    117     audio_track_cblk_t* mCblk;
    118     void*               mBuffer;    // start of track buffer, typically in shared memory
    119                                     // except for OutputTrack when it is in local memory
    120     void*               mBufferEnd; // &mBuffer[mFrameCount * frameSize], where frameSize
    121                                     //   is based on mChannelCount and 16-bit samples
    122     uint32_t            mStepCount; // saves AudioBufferProvider::Buffer::frameCount as of
    123                                     // time of releaseBuffer() for later use by step()
    124     // we don't really need a lock for these
    125     track_state         mState;
    126     const uint32_t      mSampleRate;    // initial sample rate only; for tracks which
    127                         // support dynamic rates, the current value is in control block
    128     const audio_format_t mFormat;
    129     const audio_channel_mask_t mChannelMask;
    130     const uint8_t       mChannelCount;
    131     const size_t        mFrameSize; // AudioFlinger's view of frame size in shared memory,
    132                                     // where for AudioTrack (but not AudioRecord),
    133                                     // 8-bit PCM samples are stored as 16-bit
    134     const size_t        mFrameCount;// size of track buffer given at createTrack() or
    135                                     // openRecord(), and then adjusted as needed
    136 
    137     bool                mStepServerFailed;
    138     const int           mSessionId;
    139     Vector < sp<SyncEvent> >mSyncEvents;
    140     const bool          mIsOut;
    141     ServerProxy*        mServerProxy;
    142     const int           mId;
    143     sp<NBAIO_Sink>      mTeeSink;
    144     sp<NBAIO_Source>    mTeeSource;
    145 };
    146