1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H 18 #define ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H 19 20 #include <stdint.h> 21 #include <aaudio/AAudio.h> 22 23 #include "binding/AudioEndpointParcelable.h" 24 #include "binding/AAudioServiceInterface.h" 25 #include "client/IsochronousClockModel.h" 26 #include "client/AudioEndpoint.h" 27 #include "core/AudioStream.h" 28 #include "utility/AudioClock.h" 29 30 using android::sp; 31 32 namespace aaudio { 33 34 // These are intended to be outside the range of what is normally encountered. 35 // TODO MAXes should probably be much bigger. 36 constexpr int32_t MIN_FRAMES_PER_BURST = 16; // arbitrary 37 constexpr int32_t MAX_FRAMES_PER_BURST = 16 * 1024; // arbitrary 38 constexpr int32_t MAX_BUFFER_CAPACITY_IN_FRAMES = 32 * 1024; // arbitrary 39 40 // A stream that talks to the AAudioService or directly to a HAL. 41 class AudioStreamInternal : public AudioStream { 42 43 public: 44 AudioStreamInternal(AAudioServiceInterface &serviceInterface, bool inService); 45 virtual ~AudioStreamInternal(); 46 47 aaudio_result_t getTimestamp(clockid_t clockId, 48 int64_t *framePosition, 49 int64_t *timeNanoseconds) override; 50 51 virtual aaudio_result_t updateStateMachine() override; 52 53 aaudio_result_t open(const AudioStreamBuilder &builder) override; 54 55 aaudio_result_t setBufferSize(int32_t requestedFrames) override; 56 57 int32_t getBufferSize() const override; 58 59 int32_t getBufferCapacity() const override; 60 getXRunCount()61 int32_t getXRunCount() const override { 62 return mXRunCount; 63 } 64 65 aaudio_result_t registerThread() override; 66 67 aaudio_result_t unregisterThread() override; 68 69 // Called internally from 'C' 70 virtual void *callbackLoop() = 0; 71 isMMap()72 bool isMMap() override { 73 return true; 74 } 75 76 // Calculate timeout based on framesPerBurst 77 int64_t calculateReasonableTimeout(); 78 79 aaudio_result_t startClient(const android::AudioClient& client, 80 const audio_attributes_t *attr, 81 audio_port_handle_t *clientHandle); 82 83 aaudio_result_t stopClient(audio_port_handle_t clientHandle); 84 getServiceHandle()85 aaudio_handle_t getServiceHandle() const { 86 return mServiceStreamHandle; 87 } 88 89 protected: 90 aaudio_result_t requestStart_l() REQUIRES(mStreamLock) override; 91 aaudio_result_t requestStop_l() REQUIRES(mStreamLock) override; 92 93 aaudio_result_t release_l() REQUIRES(mStreamLock) override; 94 95 aaudio_result_t processData(void *buffer, 96 int32_t numFrames, 97 int64_t timeoutNanoseconds); 98 99 /** 100 * Low level data processing that will not block. It will just read or write as much as it can. 101 * 102 * It passed back a recommended time to wake up if wakeTimePtr is not NULL. 103 * 104 * @return the number of frames processed or a negative error code. 105 */ 106 virtual aaudio_result_t processDataNow(void *buffer, 107 int32_t numFrames, 108 int64_t currentTimeNanos, 109 int64_t *wakeTimePtr) = 0; 110 111 aaudio_result_t drainTimestampsFromService(); 112 113 aaudio_result_t processCommands(); 114 115 aaudio_result_t stopCallback_l(); 116 prepareBuffersForStart()117 virtual void prepareBuffersForStart() {} 118 119 virtual void advanceClientToMatchServerPosition(int32_t serverMargin = 0) = 0; 120 onFlushFromServer()121 virtual void onFlushFromServer() {} 122 123 aaudio_result_t onEventFromServer(AAudioServiceMessage *message); 124 125 aaudio_result_t onTimestampService(AAudioServiceMessage *message); 126 127 aaudio_result_t onTimestampHardware(AAudioServiceMessage *message); 128 129 void logTimestamp(AAudioServiceMessage &message); 130 131 // Calculate timeout for an operation involving framesPerOperation. 132 int64_t calculateReasonableTimeout(int32_t framesPerOperation); 133 getDeviceChannelCount()134 int32_t getDeviceChannelCount() const { return mDeviceChannelCount; } 135 136 /** 137 * @return true if running in audio service, versus in app process 138 */ isInService()139 bool isInService() const { return mInService; } 140 141 /** 142 * Is the service FIFO position currently controlled by the AAudio service or HAL, 143 * or set based on the Clock Model. 144 * 145 * @return true if the ClockModel is currently determining the FIFO position 146 */ 147 bool isClockModelInControl() const; 148 149 IsochronousClockModel mClockModel; // timing model for chasing the HAL 150 151 std::unique_ptr<AudioEndpoint> mAudioEndpoint; // source for reads or sink for writes 152 153 aaudio_handle_t mServiceStreamHandle; // opaque handle returned from service 154 155 int32_t mXRunCount = 0; // how many underrun events? 156 157 // Offset from underlying frame position. 158 int64_t mFramesOffsetFromService = 0; // offset for timestamps 159 160 std::unique_ptr<uint8_t[]> mCallbackBuffer; 161 int32_t mCallbackFrames = 0; 162 163 // The service uses this for SHARED mode. 164 bool mInService = false; // Is this running in the client or the service? 165 166 AAudioServiceInterface &mServiceInterface; // abstract interface to the service 167 168 SimpleDoubleBuffer<Timestamp> mAtomicInternalTimestamp; 169 170 AtomicRequestor mNeedCatchUp; // Ask read() or write() to sync on first timestamp. 171 172 float mStreamVolume = 1.0f; 173 174 int64_t mLastFramesWritten = 0; 175 int64_t mLastFramesRead = 0; 176 177 private: 178 /* 179 * Asynchronous write with data conversion. 180 * @param buffer 181 * @param numFrames 182 * @return fdrames written or negative error 183 */ 184 aaudio_result_t writeNowWithConversion(const void *buffer, 185 int32_t numFrames); 186 187 // Adjust timing model based on timestamp from service. 188 void processTimestamp(uint64_t position, int64_t time); 189 190 // Thread on other side of FIFO will have wakeup jitter. 191 // By delaying slightly we can avoid waking up before other side is ready. 192 const int32_t mWakeupDelayNanos; // delay past typical wakeup jitter 193 const int32_t mMinimumSleepNanos; // minimum sleep while polling 194 int32_t mTimeOffsetNanos = 0; // add to time part of an MMAP timestamp 195 196 AudioEndpointParcelable mEndPointParcelable; // description of the buffers filled by service 197 EndpointDescriptor mEndpointDescriptor; // buffer description with resolved addresses 198 199 int64_t mServiceLatencyNanos = 0; 200 201 // Sometimes the hardware is operating with a different channel count from the app. 202 // Then we require conversion in AAudio. 203 int32_t mDeviceChannelCount = 0; 204 205 int32_t mBufferSizeInFrames = 0; // local threshold to control latency 206 int32_t mBufferCapacityInFrames = 0; 207 208 209 }; 210 211 } /* namespace aaudio */ 212 213 #endif //ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H 214