Home | History | Annotate | Download | only in oboeservice 
      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 "AAudioService"
     18 //#define LOG_NDEBUG 0
     19 #include <utils/Log.h>
     20 
     21 #include <atomic>
     22 #include <stdint.h>
     23 
     24 #include <utils/String16.h>
     25 #include <media/nbaio/AudioStreamOutSink.h>
     26 #include <media/MmapStreamInterface.h>
     27 
     28 #include "AAudioServiceStreamBase.h"
     29 #include "AAudioServiceStreamMMAP.h"
     30 #include "binding/AudioEndpointParcelable.h"
     31 #include "SharedMemoryProxy.h"
     32 #include "utility/AAudioUtilities.h"
     33 
     34 using namespace android;
     35 using namespace aaudio;
     36 
     37 #define AAUDIO_BUFFER_CAPACITY_MIN    4 * 512
     38 #define AAUDIO_SAMPLE_RATE_DEFAULT    48000
     39 
     40 /**
     41  * Stream that uses an MMAP buffer.
     42  */
     43 
     44 AAudioServiceStreamMMAP::AAudioServiceStreamMMAP()
     45         : AAudioServiceStreamBase()
     46         , mMmapStreamCallback(new MyMmapStreamCallback(*this))
     47         , mPreviousFrameCounter(0)
     48         , mMmapStream(nullptr) {
     49 }
     50 
     51 AAudioServiceStreamMMAP::~AAudioServiceStreamMMAP() {
     52     close();
     53 }
     54 
     55 aaudio_result_t AAudioServiceStreamMMAP::close() {
     56     mMmapStream.clear(); // TODO review. Is that all we have to do?
     57     // Apparently the above close is asynchronous. An attempt to open a new device
     58     // right after a close can fail. Also some callbacks may still be in flight!
     59     // FIXME Make closing synchronous.
     60     AudioClock::sleepForNanos(100 * AAUDIO_NANOS_PER_MILLISECOND);
     61 
     62     if (mAudioDataFileDescriptor != -1) {
     63         ::close(mAudioDataFileDescriptor);
     64         mAudioDataFileDescriptor = -1;
     65     }
     66 
     67     return AAudioServiceStreamBase::close();
     68 }
     69 
     70 // Open stream on HAL and pass information about the shared memory buffer back to the client.
     71 aaudio_result_t AAudioServiceStreamMMAP::open(const aaudio::AAudioStreamRequest &request,
     72                                        aaudio::AAudioStreamConfiguration &configurationOutput) {
     73     const audio_attributes_t attributes = {
     74         .content_type = AUDIO_CONTENT_TYPE_MUSIC,
     75         .usage = AUDIO_USAGE_MEDIA,
     76         .source = AUDIO_SOURCE_VOICE_RECOGNITION,
     77         .flags = AUDIO_FLAG_LOW_LATENCY,
     78         .tags = ""
     79     };
     80     audio_config_base_t config;
     81 
     82     aaudio_result_t result = AAudioServiceStreamBase::open(request, configurationOutput);
     83     if (result != AAUDIO_OK) {
     84         ALOGE("AAudioServiceStreamBase open returned %d", result);
     85         return result;
     86     }
     87 
     88     const AAudioStreamConfiguration &configurationInput = request.getConstantConfiguration();
     89     audio_port_handle_t deviceId = configurationInput.getDeviceId();
     90 
     91     mMmapClient.clientUid = request.getUserId();
     92     mMmapClient.clientPid = request.getProcessId();
     93     aaudio_direction_t direction = request.getDirection();
     94 
     95     // Fill in config
     96     aaudio_format_t aaudioFormat = configurationInput.getAudioFormat();
     97     if (aaudioFormat == AAUDIO_UNSPECIFIED || aaudioFormat == AAUDIO_FORMAT_PCM_FLOAT) {
     98         aaudioFormat = AAUDIO_FORMAT_PCM_I16;
     99     }
    100     config.format = AAudioConvert_aaudioToAndroidDataFormat(aaudioFormat);
    101 
    102     int32_t aaudioSampleRate = configurationInput.getSampleRate();
    103     if (aaudioSampleRate == AAUDIO_UNSPECIFIED) {
    104         aaudioSampleRate = AAUDIO_SAMPLE_RATE_DEFAULT;
    105     }
    106     config.sample_rate = aaudioSampleRate;
    107 
    108     int32_t aaudioSamplesPerFrame = configurationInput.getSamplesPerFrame();
    109 
    110     if (direction == AAUDIO_DIRECTION_OUTPUT) {
    111         config.channel_mask = (aaudioSamplesPerFrame == AAUDIO_UNSPECIFIED)
    112                             ? AUDIO_CHANNEL_OUT_STEREO
    113                             : audio_channel_out_mask_from_count(aaudioSamplesPerFrame);
    114     } else if (direction == AAUDIO_DIRECTION_INPUT) {
    115         config.channel_mask =  (aaudioSamplesPerFrame == AAUDIO_UNSPECIFIED)
    116                             ? AUDIO_CHANNEL_IN_STEREO
    117                             : audio_channel_in_mask_from_count(aaudioSamplesPerFrame);
    118     } else {
    119         ALOGE("openMmapStream - invalid direction = %d", direction);
    120         return AAUDIO_ERROR_ILLEGAL_ARGUMENT;
    121     }
    122 
    123     mMmapClient.packageName.setTo(String16("aaudio_service")); // FIXME what should we do here?
    124 
    125     MmapStreamInterface::stream_direction_t streamDirection = (direction == AAUDIO_DIRECTION_OUTPUT)
    126         ? MmapStreamInterface::DIRECTION_OUTPUT : MmapStreamInterface::DIRECTION_INPUT;
    127 
    128     // Open HAL stream.
    129     status_t status = MmapStreamInterface::openMmapStream(streamDirection,
    130                                                           &attributes,
    131                                                           &config,
    132                                                           mMmapClient,
    133                                                           &deviceId,
    134                                                           mMmapStreamCallback,
    135                                                           mMmapStream);
    136     if (status != OK) {
    137         ALOGE("openMmapStream returned status %d", status);
    138         return AAUDIO_ERROR_UNAVAILABLE;
    139     }
    140 
    141     // Create MMAP/NOIRQ buffer.
    142     int32_t minSizeFrames = configurationInput.getBufferCapacity();
    143     if (minSizeFrames == 0) { // zero will get rejected
    144         minSizeFrames = AAUDIO_BUFFER_CAPACITY_MIN;
    145     }
    146     status = mMmapStream->createMmapBuffer(minSizeFrames, &mMmapBufferinfo);
    147     if (status != OK) {
    148         ALOGE("%s: createMmapBuffer() returned status %d, return AAUDIO_ERROR_UNAVAILABLE",
    149               __FILE__, status);
    150         return AAUDIO_ERROR_UNAVAILABLE;
    151     } else {
    152         ALOGD("createMmapBuffer status %d shared_address = %p buffer_size %d burst_size %d",
    153               status, mMmapBufferinfo.shared_memory_address,
    154               mMmapBufferinfo.buffer_size_frames,
    155               mMmapBufferinfo.burst_size_frames);
    156     }
    157 
    158     // Get information about the stream and pass it back to the caller.
    159     mSamplesPerFrame = (direction == AAUDIO_DIRECTION_OUTPUT)
    160                            ? audio_channel_count_from_out_mask(config.channel_mask)
    161                            : audio_channel_count_from_in_mask(config.channel_mask);
    162 
    163     mAudioDataFileDescriptor = mMmapBufferinfo.shared_memory_fd;
    164     mFramesPerBurst = mMmapBufferinfo.burst_size_frames;
    165     mCapacityInFrames = mMmapBufferinfo.buffer_size_frames;
    166     mAudioFormat = AAudioConvert_androidToAAudioDataFormat(config.format);
    167     mSampleRate = config.sample_rate;
    168 
    169     // Scale up the burst size to meet the minimum equivalent in microseconds.
    170     // This is to avoid waking the CPU too often when the HW burst is very small
    171     // or at high sample rates.
    172     int32_t burstMinMicros = AAudioProperty_getHardwareBurstMinMicros();
    173     int32_t burstMicros = 0;
    174     do {
    175         if (burstMicros > 0) {  // skip first loop
    176             mFramesPerBurst *= 2;
    177         }
    178         burstMicros = mFramesPerBurst * static_cast<int64_t>(1000000) / mSampleRate;
    179     } while (burstMicros < burstMinMicros);
    180 
    181     ALOGD("AAudioServiceStreamMMAP::open() original burst = %d, minMicros = %d, final burst = %d\n",
    182           mMmapBufferinfo.burst_size_frames, burstMinMicros, mFramesPerBurst);
    183 
    184     // Fill in AAudioStreamConfiguration
    185     configurationOutput.setSampleRate(mSampleRate);
    186     configurationOutput.setSamplesPerFrame(mSamplesPerFrame);
    187     configurationOutput.setAudioFormat(mAudioFormat);
    188     configurationOutput.setDeviceId(deviceId);
    189 
    190     return AAUDIO_OK;
    191 }
    192 
    193 /**
    194  * Start the flow of data.
    195  */
    196 aaudio_result_t AAudioServiceStreamMMAP::start() {
    197     if (mMmapStream == nullptr) return AAUDIO_ERROR_NULL;
    198     aaudio_result_t result;
    199     status_t status = mMmapStream->start(mMmapClient, &mPortHandle);
    200     if (status != OK) {
    201         ALOGE("AAudioServiceStreamMMAP::start() mMmapStream->start() returned %d", status);
    202         processError();
    203         result = AAudioConvert_androidToAAudioResult(status);
    204     } else {
    205         result = AAudioServiceStreamBase::start();
    206     }
    207     return result;
    208 }
    209 
    210 /**
    211  * Stop the flow of data such that start() can resume with loss of data.
    212  */
    213 aaudio_result_t AAudioServiceStreamMMAP::pause() {
    214     if (mMmapStream == nullptr) return AAUDIO_ERROR_NULL;
    215 
    216     aaudio_result_t result1 = AAudioServiceStreamBase::pause();
    217     status_t status = mMmapStream->stop(mPortHandle);
    218     mFramesRead.reset32();
    219     return (result1 != AAUDIO_OK) ? result1 : AAudioConvert_androidToAAudioResult(status);
    220 }
    221 
    222 aaudio_result_t AAudioServiceStreamMMAP::stop() {
    223     if (mMmapStream == nullptr) return AAUDIO_ERROR_NULL;
    224 
    225     aaudio_result_t result1 = AAudioServiceStreamBase::stop();
    226     aaudio_result_t status = mMmapStream->stop(mPortHandle);
    227     mFramesRead.reset32();
    228     return (result1 != AAUDIO_OK) ? result1 :  AAudioConvert_androidToAAudioResult(status);
    229 }
    230 
    231 /**
    232  *  Discard any data held by the underlying HAL or Service.
    233  */
    234 aaudio_result_t AAudioServiceStreamMMAP::flush() {
    235     if (mMmapStream == nullptr) return AAUDIO_ERROR_NULL;
    236     // TODO how do we flush an MMAP/NOIRQ buffer? sync pointers?
    237     sendServiceEvent(AAUDIO_SERVICE_EVENT_FLUSHED);
    238     mState = AAUDIO_STREAM_STATE_FLUSHED;
    239     return AAudioServiceStreamBase::flush();;
    240 }
    241 
    242 
    243 aaudio_result_t AAudioServiceStreamMMAP::getFreeRunningPosition(int64_t *positionFrames,
    244                                                                 int64_t *timeNanos) {
    245     struct audio_mmap_position position;
    246     if (mMmapStream == nullptr) {
    247         processError();
    248         return AAUDIO_ERROR_NULL;
    249     }
    250     status_t status = mMmapStream->getMmapPosition(&position);
    251     if (status != OK) {
    252         ALOGE("sendCurrentTimestamp(): getMmapPosition() returned %d", status);
    253         processError();
    254         return AAudioConvert_androidToAAudioResult(status);
    255     } else {
    256         mFramesRead.update32(position.position_frames);
    257         *positionFrames = mFramesRead.get();
    258         *timeNanos = position.time_nanoseconds;
    259     }
    260     return AAUDIO_OK;
    261 }
    262 
    263 void AAudioServiceStreamMMAP::onTearDown() {
    264     ALOGE("AAudioServiceStreamMMAP::onTearDown() called - TODO");
    265 };
    266 
    267 void AAudioServiceStreamMMAP::onVolumeChanged(audio_channel_mask_t channels,
    268                      android::Vector<float> values) {
    269     // TODO do we really need a different volume for each channel?
    270     float volume = values[0];
    271     ALOGD("AAudioServiceStreamMMAP::onVolumeChanged() volume[0] = %f", volume);
    272     sendServiceEvent(AAUDIO_SERVICE_EVENT_VOLUME, volume);
    273 };
    274 
    275 void AAudioServiceStreamMMAP::onRoutingChanged(audio_port_handle_t deviceId) {
    276     ALOGD("AAudioServiceStreamMMAP::onRoutingChanged() called with %d, old = %d",
    277           deviceId, mPortHandle);
    278     if (mPortHandle > 0 && mPortHandle != deviceId) {
    279         sendServiceEvent(AAUDIO_SERVICE_EVENT_DISCONNECTED);
    280     }
    281     mPortHandle = deviceId;
    282 };
    283 
    284 /**
    285  * Get an immutable description of the data queue from the HAL.
    286  */
    287 aaudio_result_t AAudioServiceStreamMMAP::getDownDataDescription(AudioEndpointParcelable &parcelable)
    288 {
    289     // Gather information on the data queue based on HAL info.
    290     int32_t bytesPerFrame = calculateBytesPerFrame();
    291     int32_t capacityInBytes = mCapacityInFrames * bytesPerFrame;
    292     int fdIndex = parcelable.addFileDescriptor(mAudioDataFileDescriptor, capacityInBytes);
    293     parcelable.mDownDataQueueParcelable.setupMemory(fdIndex, 0, capacityInBytes);
    294     parcelable.mDownDataQueueParcelable.setBytesPerFrame(bytesPerFrame);
    295     parcelable.mDownDataQueueParcelable.setFramesPerBurst(mFramesPerBurst);
    296     parcelable.mDownDataQueueParcelable.setCapacityInFrames(mCapacityInFrames);
    297     return AAUDIO_OK;
    298 }