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 AAUDIO_AAUDIO_SERVICE_STREAM_BASE_H 18 #define AAUDIO_AAUDIO_SERVICE_STREAM_BASE_H 19 20 #include <assert.h> 21 #include <mutex> 22 23 #include <media/AudioClient.h> 24 #include <utils/RefBase.h> 25 26 #include "fifo/FifoBuffer.h" 27 #include "binding/IAAudioService.h" 28 #include "binding/AudioEndpointParcelable.h" 29 #include "binding/AAudioServiceMessage.h" 30 #include "utility/AAudioUtilities.h" 31 #include "utility/AudioClock.h" 32 33 #include "SharedRingBuffer.h" 34 #include "AAudioThread.h" 35 36 namespace android { 37 class AAudioService; 38 } 39 40 namespace aaudio { 41 42 class AAudioServiceEndpoint; 43 44 // We expect the queue to only have a few commands. 45 // This should be way more than we need. 46 #define QUEUE_UP_CAPACITY_COMMANDS (128) 47 48 /** 49 * Each instance of AAudioServiceStreamBase corresponds to a client stream. 50 * It uses a subclass of AAudioServiceEndpoint to communicate with the underlying device or port. 51 */ 52 class AAudioServiceStreamBase 53 : public virtual android::RefBase 54 , public AAudioStreamParameters 55 , public Runnable { 56 57 public: 58 AAudioServiceStreamBase(android::AAudioService &aAudioService); 59 60 virtual ~AAudioServiceStreamBase(); 61 62 enum { 63 ILLEGAL_THREAD_ID = 0 64 }; 65 66 static std::string dumpHeader(); 67 68 // does not include EOL 69 virtual std::string dump() const; 70 71 // ------------------------------------------------------------------- 72 /** 73 * Open the device. 74 */ 75 virtual aaudio_result_t open(const aaudio::AAudioStreamRequest &request) = 0; 76 77 virtual aaudio_result_t close(); 78 79 /** 80 * Start the flow of audio data. 81 * 82 * This is not guaranteed to be synchronous but it currently is. 83 * An AAUDIO_SERVICE_EVENT_STARTED will be sent to the client when complete. 84 */ 85 virtual aaudio_result_t start(); 86 87 /** 88 * Stop the flow of data so that start() can resume without loss of data. 89 * 90 * This is not guaranteed to be synchronous but it currently is. 91 * An AAUDIO_SERVICE_EVENT_PAUSED will be sent to the client when complete. 92 */ 93 virtual aaudio_result_t pause(); 94 95 /** 96 * Stop the flow of data after the currently queued data has finished playing. 97 * 98 * This is not guaranteed to be synchronous but it currently is. 99 * An AAUDIO_SERVICE_EVENT_STOPPED will be sent to the client when complete. 100 * 101 */ 102 virtual aaudio_result_t stop(); 103 104 aaudio_result_t stopTimestampThread(); 105 106 /** 107 * Discard any data held by the underlying HAL or Service. 108 * 109 * An AAUDIO_SERVICE_EVENT_FLUSHED will be sent to the client when complete. 110 */ 111 virtual aaudio_result_t flush(); 112 113 114 virtual aaudio_result_t startClient(const android::AudioClient& client __unused, 115 audio_port_handle_t *clientHandle __unused) { 116 ALOGD("AAudioServiceStreamBase::startClient(%p, ...) AAUDIO_ERROR_UNAVAILABLE", &client); 117 return AAUDIO_ERROR_UNAVAILABLE; 118 } 119 120 virtual aaudio_result_t stopClient(audio_port_handle_t clientHandle __unused) { 121 ALOGD("AAudioServiceStreamBase::stopClient(%d) AAUDIO_ERROR_UNAVAILABLE", clientHandle); 122 return AAUDIO_ERROR_UNAVAILABLE; 123 } 124 125 bool isRunning() const { 126 return mState == AAUDIO_STREAM_STATE_STARTED; 127 } 128 129 // ------------------------------------------------------------------- 130 131 /** 132 * Send a message to the client. 133 */ 134 aaudio_result_t sendServiceEvent(aaudio_service_event_t event, 135 double dataDouble = 0.0, 136 int64_t dataLong = 0); 137 138 /** 139 * Fill in a parcelable description of stream. 140 */ 141 aaudio_result_t getDescription(AudioEndpointParcelable &parcelable); 142 143 144 void setRegisteredThread(pid_t pid) { 145 mRegisteredClientThread = pid; 146 } 147 148 pid_t getRegisteredThread() const { 149 return mRegisteredClientThread; 150 } 151 152 int32_t getFramesPerBurst() const { 153 return mFramesPerBurst; 154 } 155 156 void run() override; // to implement Runnable 157 158 void disconnect(); 159 160 const android::AudioClient &getAudioClient() { 161 return mMmapClient; 162 } 163 164 uid_t getOwnerUserId() const { 165 return mMmapClient.clientUid; 166 } 167 168 pid_t getOwnerProcessId() const { 169 return mMmapClient.clientPid; 170 } 171 172 aaudio_handle_t getHandle() const { 173 return mHandle; 174 } 175 void setHandle(aaudio_handle_t handle) { 176 mHandle = handle; 177 } 178 179 aaudio_stream_state_t getState() const { 180 return mState; 181 } 182 183 void onVolumeChanged(float volume); 184 185 protected: 186 187 /** 188 * Open the device. 189 */ 190 aaudio_result_t open(const aaudio::AAudioStreamRequest &request, 191 aaudio_sharing_mode_t sharingMode); 192 193 void setState(aaudio_stream_state_t state) { 194 mState = state; 195 } 196 197 /** 198 * Device specific startup. 199 * @return AAUDIO_OK or negative error. 200 */ 201 virtual aaudio_result_t startDevice(); 202 203 aaudio_result_t writeUpMessageQueue(AAudioServiceMessage *command); 204 205 aaudio_result_t sendCurrentTimestamp(); 206 207 /** 208 * @param positionFrames 209 * @param timeNanos 210 * @return AAUDIO_OK or AAUDIO_ERROR_UNAVAILABLE or other negative error 211 */ 212 virtual aaudio_result_t getFreeRunningPosition(int64_t *positionFrames, int64_t *timeNanos) = 0; 213 214 virtual aaudio_result_t getHardwareTimestamp(int64_t *positionFrames, int64_t *timeNanos) = 0; 215 216 virtual aaudio_result_t getAudioDataDescription(AudioEndpointParcelable &parcelable) = 0; 217 218 aaudio_stream_state_t mState = AAUDIO_STREAM_STATE_UNINITIALIZED; 219 220 pid_t mRegisteredClientThread = ILLEGAL_THREAD_ID; 221 222 SharedRingBuffer* mUpMessageQueue; 223 std::mutex mUpMessageQueueLock; 224 225 AAudioThread mTimestampThread; 226 // This is used by one thread to tell another thread to exit. So it must be atomic. 227 std::atomic<bool> mThreadEnabled{false}; 228 229 int32_t mFramesPerBurst = 0; 230 android::AudioClient mMmapClient; // set in open, used in MMAP start() 231 audio_port_handle_t mClientHandle = AUDIO_PORT_HANDLE_NONE; 232 233 SimpleDoubleBuffer<Timestamp> mAtomicTimestamp; 234 235 android::AAudioService &mAudioService; 236 android::sp<AAudioServiceEndpoint> mServiceEndpoint; 237 238 private: 239 aaudio_handle_t mHandle = -1; 240 }; 241 242 } /* namespace aaudio */ 243 244 #endif //AAUDIO_AAUDIO_SERVICE_STREAM_BASE_H 245
