1 /*
2 **
3 ** Copyright 2011, 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 ANDROID_AUDIO_OUTPUT_H
19 #define ANDROID_AUDIO_OUTPUT_H
20 
21 #include <semaphore.h>
22 #include <tinyalsa/asoundlib.h>
23 #include <utils/LinearTransform.h>
24 #include <utils/String16.h>
25 #include <utils/String8.h>
26 #include <utils/threads.h>
27 #include <utils/Vector.h>
28 
29 namespace android {
30 
31 class AudioStreamOut;
32 
33 class AudioOutput : public RefBase {
34   public:
35 
36     // Audio ouput state machine states.
37     enum State {
38         // Ouput not yet started or synchronized.
39         OUT_OF_SYNC,
40 
41         // Silence primed to output to start DMA.
42         PRIMED,
43 
44         // DMA started, ready to align to other inputs.
45         DMA_START,
46 
47         // DMA active.
48         ACTIVE,
49 
50         // Fatal, unrecoverable error.
51         FATAL,
52     };
53 
54                         AudioOutput(const char* alsa_name,
55                                     enum pcm_format alsa_pcm_format);
56     virtual            ~AudioOutput();
57 
58     virtual status_t    initCheck();
59     virtual status_t    setupForStream(const AudioStreamOut& stream) = 0;
60 
61     // State machine transition functions.
getState()62     State               getState() { return mState; };
hasFatalError()63     bool                hasFatalError() { return mState == FATAL; }
64 
65     // Prime data to output device, go to PRIMED state.
66     void                primeOutput(bool hasActiveOutputs);
67 
68     // Adjust for write timestamp difference, go to ACTIVE state.
69     void                adjustDelay(int32_t nFrames);
70 
71     // Send one chunk of data to ALSA, if state machine permits. This is called
72     // for every chunk sent down, regardless of the state of the output.
73     void                processOneChunk(const uint8_t* data, size_t len,
74                                         bool hasActiveOutputs);
75 
76     status_t            getNextWriteTimestamp(int64_t* timestamp,
77                                               bool* discon);
78     bool                getLastNextWriteTSValid() const;
79     int64_t             getLastNextWriteTS() const;
80 
81     uint32_t            getExternalDelay_uSec() const;
82     void                setExternalDelay_uSec(uint32_t delay);
83     void                setDelayComp_uSec(uint32_t delay_usec);
84 
85     void                setVolume(float vol);
86     void                setMute(bool mute);
87     void                setOutputIsFixed(bool fixed);
88     void                setFixedOutputLevel(float level);
89 
getVolume()90     float               getVolume()           const { return mVolume; }
getMute()91     bool                getMute()             const { return mMute; }
getOutputIsFixed()92     bool                getOutputIsFixed()    const { return mOutputFixed; }
getFixedOutputLevel()93     float               getFixedOutputLevel() const { return mFixedLvl; }
94 
95     int                 getHardwareTimestamp(unsigned int *pAvail,
96                                 struct timespec *pTimestamp);
getKernelBufferSize()97     uint32_t            getKernelBufferSize() { return mFramesPerChunk * mBufferChunks; }
98 
99     virtual void        dump(String8& result) = 0;
100 
101     virtual const char* getOutputName() = 0;
102     virtual uint32_t    devMask() const = 0;
103 
104     virtual void        cleanupResources();
105 
106     static const uint32_t kMaxDelayCompensationMSec;
107     static const uint32_t kPrimeTimeoutChunks;
108 
109   protected:
110 
111     void                pushSilence(uint32_t nFrames);
112     // Take nBytes of chunkData, convert to output format and write at
113     // sbuf. sbuf WILL point to enough space to convert from 16 to 32 bit
114     // if needed.
115     virtual void        stageChunk(const uint8_t* chunkData,
116                                    uint8_t* sbuf,
117                                    uint32_t inBytesPerSample,
118                                    uint32_t nSamples);
119     virtual void        openPCMDevice();
120     virtual void        reset();
121     virtual status_t    getDMAStartData(int64_t* dma_start_time,
122                                         int64_t* frames_queued_to_driver);
123     void                doPCMWrite(const uint8_t* data, size_t len);
124     void                setupInternal();
125 
126     // Current state machine state.
127     State               mState;
128 
129     // Output format
130     uint32_t            mFramesPerChunk;
131     uint32_t            mFramesPerSec;
132     uint32_t            mBufferChunks;
133     uint32_t            mChannelCnt;
134     const char*         mALSAName;
135     enum pcm_format     mALSAFormat;
136 
137     // These numbers are relative to the ALSA output.
138     uint32_t            mBytesPerSample;
139     uint32_t            mBytesPerFrame;
140     uint32_t            mBytesPerChunk;
141     uint8_t*            mStagingBuf;
142 
143     // Get next write time stuff.
144     bool                mLastNextWriteTimeValid;
145     int64_t             mLastNextWriteTime;
146     int64_t             mLastDMAStartTime;
147 
148     // External delay compensation.
149     uint32_t            mMaxDelayCompFrames;
150     uint32_t            mExternalDelayUSec;
151     uint32_t            mExternalDelayLocalTicks;
152 
153     LinearTransform     mFramesToLocalTime;
154 
155     // ALSA device stuff.
156     Mutex               mDeviceLock;
157     struct pcm*         mDevice;
158     int                 mDeviceExtFd;
159     int                 mALSACardID;
160     uint64_t            mFramesQueuedToDriver;
161     uint32_t            mPrimeTimeoutChunks;
162 
163     // Volume stuff
164     Mutex               mVolumeLock;
165     float               mVolume;
166     float               mFixedLvl;
167     bool                mMute;
168     bool                mOutputFixed;
169     bool                mVolParamsDirty;
170     virtual void        applyPendingVolParams() = 0;
171 };
172 
173 typedef Vector< sp<AudioOutput> > AudioOutputList;
174 
175 }  // namespace android
176 #endif  // ANDROID_AUDIO_OUTPUT_H
177