services/oboeservice/AAudioServiceStreamBase.h

   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
 237     // The mServiceEndpoint variable can be accessed by multiple threads.
 238     // So we access it by locally promoting a weak pointer to a smart pointer,
 239     // which is thread-safe.
 240     android::sp<AAudioServiceEndpoint> mServiceEndpoint;
 241     android::wp<AAudioServiceEndpoint> mServiceEndpointWeak;
 242
 243 private:
 244     aaudio_handle_t         mHandle = -1;
 245 };
 246
 247 } /* namespace aaudio */
 248
 249 #endif //AAUDIO_AAUDIO_SERVICE_STREAM_BASE_H