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/IAAudioService.h" 24 #include "binding/AudioEndpointParcelable.h" 25 #include "binding/AAudioServiceInterface.h" 26 #include "client/IsochronousClockModel.h" 27 #include "client/AudioEndpoint.h" 28 #include "core/AudioStream.h" 29 #include "utility/LinearRamp.h" 30 31 using android::sp; 32 using android::IAAudioService; 33 34 namespace aaudio { 35 36 // A stream that talks to the AAudioService or directly to a HAL. 37 class AudioStreamInternal : public AudioStream { 38 39 public: 40 AudioStreamInternal(AAudioServiceInterface &serviceInterface, bool inService); 41 virtual ~AudioStreamInternal(); 42 43 // =========== Begin ABSTRACT methods =========================== 44 aaudio_result_t requestStart() override; 45 46 aaudio_result_t requestPause() override; 47 48 aaudio_result_t requestFlush() override; 49 50 aaudio_result_t requestStop() override; 51 52 aaudio_result_t getTimestamp(clockid_t clockId, 53 int64_t *framePosition, 54 int64_t *timeNanoseconds) override; 55 56 virtual aaudio_result_t updateStateWhileWaiting() override; 57 // =========== End ABSTRACT methods =========================== 58 59 aaudio_result_t open(const AudioStreamBuilder &builder) override; 60 61 aaudio_result_t close() override; 62 63 aaudio_result_t setBufferSize(int32_t requestedFrames) override; 64 65 int32_t getBufferSize() const override; 66 67 int32_t getBufferCapacity() const override; 68 69 int32_t getFramesPerBurst() const override; 70 71 int32_t getXRunCount() const override { 72 return mXRunCount; 73 } 74 75 aaudio_result_t registerThread() override; 76 77 aaudio_result_t unregisterThread() override; 78 79 aaudio_result_t joinThread(void** returnArg); 80 81 // Called internally from 'C' 82 virtual void *callbackLoop() = 0; 83 84 85 bool isMMap() override { 86 return true; 87 } 88 89 // Calculate timeout based on framesPerBurst 90 int64_t calculateReasonableTimeout(); 91 92 protected: 93 94 aaudio_result_t processData(void *buffer, 95 int32_t numFrames, 96 int64_t timeoutNanoseconds); 97 98 /** 99 * Low level data processing that will not block. It will just read or write as much as it can. 100 * 101 * It passed back a recommended time to wake up if wakeTimePtr is not NULL. 102 * 103 * @return the number of frames processed or a negative error code. 104 */ 105 virtual aaudio_result_t processDataNow(void *buffer, 106 int32_t numFrames, 107 int64_t currentTimeNanos, 108 int64_t *wakeTimePtr) = 0; 109 110 aaudio_result_t processCommands(); 111 112 aaudio_result_t requestPauseInternal(); 113 aaudio_result_t requestStopInternal(); 114 115 aaudio_result_t stopCallback(); 116 117 118 void onFlushFromServer(); 119 120 aaudio_result_t onEventFromServer(AAudioServiceMessage *message); 121 122 aaudio_result_t onTimestampFromServer(AAudioServiceMessage *message); 123 124 // Calculate timeout for an operation involving framesPerOperation. 125 int64_t calculateReasonableTimeout(int32_t framesPerOperation); 126 127 aaudio_format_t mDeviceFormat = AAUDIO_FORMAT_UNSPECIFIED; 128 129 IsochronousClockModel mClockModel; // timing model for chasing the HAL 130 131 AudioEndpoint mAudioEndpoint; // source for reads or sink for writes 132 aaudio_handle_t mServiceStreamHandle; // opaque handle returned from service 133 134 int32_t mFramesPerBurst; // frames per HAL transfer 135 int32_t mXRunCount = 0; // how many underrun events? 136 137 LinearRamp mVolumeRamp; 138 139 // Offset from underlying frame position. 140 int64_t mFramesOffsetFromService = 0; // offset for timestamps 141 142 uint8_t *mCallbackBuffer = nullptr; 143 int32_t mCallbackFrames = 0; 144 145 private: 146 /* 147 * Asynchronous write with data conversion. 148 * @param buffer 149 * @param numFrames 150 * @return fdrames written or negative error 151 */ 152 aaudio_result_t writeNowWithConversion(const void *buffer, 153 int32_t numFrames); 154 155 // Adjust timing model based on timestamp from service. 156 void processTimestamp(uint64_t position, int64_t time); 157 158 AudioEndpointParcelable mEndPointParcelable; // description of the buffers filled by service 159 EndpointDescriptor mEndpointDescriptor; // buffer description with resolved addresses 160 AAudioServiceInterface &mServiceInterface; // abstract interface to the service 161 162 // The service uses this for SHARED mode. 163 bool mInService = false; // Is this running in the client or the service? 164 }; 165 166 } /* namespace aaudio */ 167 168 #endif //ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H 169
