services/oboeservice/AAudioServiceStreamShared.cpp

   1 /*
   2  * Copyright (C) 2017 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 #define LOG_TAG "AAudioServiceStreamShared"
  18 //#define LOG_NDEBUG 0
  19 #include <utils/Log.h>
  20
  21 #include <iomanip>
  22 #include <iostream>
  23 #include <mutex>
  24
  25 #include <aaudio/AAudio.h>
  26
  27 #include "binding/IAAudioService.h"
  28
  29 #include "binding/AAudioServiceMessage.h"
  30 #include "AAudioServiceStreamBase.h"
  31 #include "AAudioServiceStreamShared.h"
  32 #include "AAudioEndpointManager.h"
  33 #include "AAudioService.h"
  34 #include "AAudioServiceEndpoint.h"
  35
  36 using namespace android;
  37 using namespace aaudio;
  38
  39 #define MIN_BURSTS_PER_BUFFER       2
  40 #define DEFAULT_BURSTS_PER_BUFFER   16
  41 // This is an arbitrary range. TODO review.
  42 #define MAX_FRAMES_PER_BUFFER       (32 * 1024)
  43
  44 AAudioServiceStreamShared::AAudioServiceStreamShared(AAudioService &audioService)
  45     : AAudioServiceStreamBase(audioService)
  46     , mTimestampPositionOffset(0)
  47     , mXRunCount(0) {
  48 }
  49
  50 std::string AAudioServiceStreamShared::dumpHeader() {
  51     std::stringstream result;
  52     result << AAudioServiceStreamBase::dumpHeader();
  53     result << "    Write#     Read#   Avail   XRuns";
  54     return result.str();
  55 }
  56
  57 std::string AAudioServiceStreamShared::dump() const {
  58     std::stringstream result;
  59
  60     result << AAudioServiceStreamBase::dump();
  61
  62     auto fifo = mAudioDataQueue->getFifoBuffer();
  63     int32_t readCounter = fifo->getReadCounter();
  64     int32_t writeCounter = fifo->getWriteCounter();
  65     result << std::setw(10) << writeCounter;
  66     result << std::setw(10) << readCounter;
  67     result << std::setw(8) << (writeCounter - readCounter);
  68     result << std::setw(8) << getXRunCount();
  69
  70     return result.str();
  71 }
  72
  73 int32_t AAudioServiceStreamShared::calculateBufferCapacity(int32_t requestedCapacityFrames,
  74                                                            int32_t framesPerBurst) {
  75
  76     if (requestedCapacityFrames > MAX_FRAMES_PER_BUFFER) {
  77         ALOGE("AAudioServiceStreamShared::calculateBufferCapacity() requested capacity %d > max %d",
  78               requestedCapacityFrames, MAX_FRAMES_PER_BUFFER);
  79         return AAUDIO_ERROR_OUT_OF_RANGE;
  80     }
  81
  82     // Determine how many bursts will fit in the buffer.
  83     int32_t numBursts;
  84     if (requestedCapacityFrames == AAUDIO_UNSPECIFIED) {
  85         // Use fewer bursts if default is too many.
  86         if ((DEFAULT_BURSTS_PER_BUFFER * framesPerBurst) > MAX_FRAMES_PER_BUFFER) {
  87             numBursts = MAX_FRAMES_PER_BUFFER / framesPerBurst;
  88         } else {
  89             numBursts = DEFAULT_BURSTS_PER_BUFFER;
  90         }
  91     } else {
  92         // round up to nearest burst boundary
  93         numBursts = (requestedCapacityFrames + framesPerBurst - 1) / framesPerBurst;
  94     }
  95
  96     // Clip to bare minimum.
  97     if (numBursts < MIN_BURSTS_PER_BUFFER) {
  98         numBursts = MIN_BURSTS_PER_BUFFER;
  99     }
 100     // Check for numeric overflow.
 101     if (numBursts > 0x8000 || framesPerBurst > 0x8000) {
 102         ALOGE("AAudioServiceStreamShared::calculateBufferCapacity() overflow, capacity = %d * %d",
 103               numBursts, framesPerBurst);
 104         return AAUDIO_ERROR_OUT_OF_RANGE;
 105     }
 106     int32_t capacityInFrames = numBursts * framesPerBurst;
 107
 108     // Final sanity check.
 109     if (capacityInFrames > MAX_FRAMES_PER_BUFFER) {
 110         ALOGE("AAudioServiceStreamShared::calculateBufferCapacity() calc capacity %d > max %d",
 111               capacityInFrames, MAX_FRAMES_PER_BUFFER);
 112         return AAUDIO_ERROR_OUT_OF_RANGE;
 113     }
 114     ALOGD("AAudioServiceStreamShared::calculateBufferCapacity() requested %d frames, actual = %d",
 115           requestedCapacityFrames, capacityInFrames);
 116     return capacityInFrames;
 117 }
 118
 119 aaudio_result_t AAudioServiceStreamShared::open(const aaudio::AAudioStreamRequest &request)  {
 120
 121     sp<AAudioServiceStreamShared> keep(this);
 122
 123     aaudio_result_t result = AAudioServiceStreamBase::open(request, AAUDIO_SHARING_MODE_SHARED);
 124     if (result != AAUDIO_OK) {
 125         ALOGE("AAudioServiceStreamBase open() returned %d", result);
 126         return result;
 127     }
 128
 129     const AAudioStreamConfiguration &configurationInput = request.getConstantConfiguration();
 130
 131     sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
 132     if (endpoint == nullptr) {
 133         result = AAUDIO_ERROR_INVALID_STATE;
 134         goto error;
 135     }
 136
 137     // Is the request compatible with the shared endpoint?
 138     setFormat(configurationInput.getFormat());
 139     if (getFormat() == AAUDIO_FORMAT_UNSPECIFIED) {
 140         setFormat(AAUDIO_FORMAT_PCM_FLOAT);
 141     } else if (getFormat() != AAUDIO_FORMAT_PCM_FLOAT) {
 142         ALOGE("AAudioServiceStreamShared::open() mAudioFormat = %d, need FLOAT", getFormat());
 143         result = AAUDIO_ERROR_INVALID_FORMAT;
 144         goto error;
 145     }
 146
 147     setSampleRate(configurationInput.getSampleRate());
 148     if (getSampleRate() == AAUDIO_UNSPECIFIED) {
 149         setSampleRate(endpoint->getSampleRate());
 150     } else if (getSampleRate() != endpoint->getSampleRate()) {
 151         ALOGE("AAudioServiceStreamShared::open() mSampleRate = %d, need %d",
 152               getSampleRate(), endpoint->getSampleRate());
 153         result = AAUDIO_ERROR_INVALID_RATE;
 154         goto error;
 155     }
 156
 157     setSamplesPerFrame(configurationInput.getSamplesPerFrame());
 158     if (getSamplesPerFrame() == AAUDIO_UNSPECIFIED) {
 159         setSamplesPerFrame(endpoint->getSamplesPerFrame());
 160     } else if (getSamplesPerFrame() != endpoint->getSamplesPerFrame()) {
 161         ALOGE("AAudioServiceStreamShared::open() mSamplesPerFrame = %d, need %d",
 162               getSamplesPerFrame(), endpoint->getSamplesPerFrame());
 163         result = AAUDIO_ERROR_OUT_OF_RANGE;
 164         goto error;
 165     }
 166
 167     setBufferCapacity(calculateBufferCapacity(configurationInput.getBufferCapacity(),
 168                                      mFramesPerBurst));
 169     if (getBufferCapacity() < 0) {
 170         result = getBufferCapacity(); // negative error code
 171         setBufferCapacity(0);
 172         goto error;
 173     }
 174
 175     {
 176         std::lock_guard<std::mutex> lock(mAudioDataQueueLock);
 177         // Create audio data shared memory buffer for client.
 178         mAudioDataQueue = new SharedRingBuffer();
 179         result = mAudioDataQueue->allocate(calculateBytesPerFrame(), getBufferCapacity());
 180         if (result != AAUDIO_OK) {
 181             ALOGE("AAudioServiceStreamShared::open() could not allocate FIFO with %d frames",
 182                   getBufferCapacity());
 183             result = AAUDIO_ERROR_NO_MEMORY;
 184             goto error;
 185         }
 186     }
 187
 188     ALOGD("AAudioServiceStreamShared::open() actual rate = %d, channels = %d, deviceId = %d",
 189           getSampleRate(), getSamplesPerFrame(), endpoint->getDeviceId());
 190
 191     result = endpoint->registerStream(keep);
 192     if (result != AAUDIO_OK) {
 193         goto error;
 194     }
 195
 196     setState(AAUDIO_STREAM_STATE_OPEN);
 197     return AAUDIO_OK;
 198
 199 error:
 200     close();
 201     return result;
 202 }
 203
 204
 205 aaudio_result_t AAudioServiceStreamShared::close()  {
 206     aaudio_result_t result = AAudioServiceStreamBase::close();
 207
 208     {
 209         std::lock_guard<std::mutex> lock(mAudioDataQueueLock);
 210         delete mAudioDataQueue;
 211         mAudioDataQueue = nullptr;
 212     }
 213
 214     return result;
 215 }
 216
 217 /**
 218  * Get an immutable description of the data queue created by this service.
 219  */
 220 aaudio_result_t AAudioServiceStreamShared::getAudioDataDescription(
 221         AudioEndpointParcelable &parcelable)
 222 {
 223     std::lock_guard<std::mutex> lock(mAudioDataQueueLock);
 224     if (mAudioDataQueue == nullptr) {
 225         ALOGE("getAudioDataDescription(): mUpMessageQueue null! - stream not open");
 226         return AAUDIO_ERROR_NULL;
 227     }
 228     // Gather information on the data queue.
 229     mAudioDataQueue->fillParcelable(parcelable,
 230                                     parcelable.mDownDataQueueParcelable);
 231     parcelable.mDownDataQueueParcelable.setFramesPerBurst(getFramesPerBurst());
 232     return AAUDIO_OK;
 233 }
 234
 235 void AAudioServiceStreamShared::markTransferTime(Timestamp &timestamp) {
 236     mAtomicTimestamp.write(timestamp);
 237 }
 238
 239 // Get timestamp that was written by mixer or distributor.
 240 aaudio_result_t AAudioServiceStreamShared::getFreeRunningPosition(int64_t *positionFrames,
 241                                                                   int64_t *timeNanos) {
 242     // TODO Get presentation timestamp from the HAL
 243     if (mAtomicTimestamp.isValid()) {
 244         Timestamp timestamp = mAtomicTimestamp.read();
 245         *positionFrames = timestamp.getPosition();
 246         *timeNanos = timestamp.getNanoseconds();
 247         return AAUDIO_OK;
 248     } else {
 249         return AAUDIO_ERROR_UNAVAILABLE;
 250     }
 251 }
 252
 253 // Get timestamp from lower level service.
 254 aaudio_result_t AAudioServiceStreamShared::getHardwareTimestamp(int64_t *positionFrames,
 255                                                                 int64_t *timeNanos) {
 256
 257     int64_t position = 0;
 258     sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
 259     if (endpoint == nullptr) {
 260         ALOGE("%s() has no endpoint", __func__);
 261         return AAUDIO_ERROR_INVALID_STATE;
 262     }
 263
 264     aaudio_result_t result = endpoint->getTimestamp(&position, timeNanos);
 265     if (result == AAUDIO_OK) {
 266         int64_t offset = mTimestampPositionOffset.load();
 267         // TODO, do not go below starting value
 268         position -= offset; // Offset from shared MMAP stream
 269         ALOGV("getHardwareTimestamp() %8lld = %8lld - %8lld",
 270               (long long) position, (long long) (position + offset), (long long) offset);
 271     }
 272     *positionFrames = position;
 273     return result;
 274 }