services/oboeservice/AAudioServiceStreamBase.cpp - LeafOS-Project/android_frameworks_av - Gitiles

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "AAudioServiceStreamBase"
 //#define LOG_NDEBUG 0
 #include <utils/Log.h>

 #include <iomanip>
 #include <iostream>
 #include <mutex>

 #include "binding/IAAudioService.h"
 #include "binding/AAudioServiceMessage.h"
 #include "utility/AudioClock.h"

 #include "AAudioEndpointManager.h"
 #include "AAudioService.h"
 #include "AAudioServiceEndpoint.h"
 #include "AAudioServiceStreamBase.h"
 #include "TimestampScheduler.h"

 using namespace android;  // TODO just import names needed
 using namespace aaudio;   // TODO just import names needed

 /**
  * Base class for streams in the service.
  * @return
  */

 AAudioServiceStreamBase::AAudioServiceStreamBase(AAudioService &audioService)
         : mUpMessageQueue(nullptr)
         , mTimestampThread("AATime")
         , mAtomicStreamTimestamp()
         , mAudioService(audioService) {
     mMmapClient.clientUid = -1;
     mMmapClient.clientPid = -1;
     mMmapClient.packageName = String16("");
 }

 AAudioServiceStreamBase::~AAudioServiceStreamBase() {
     // If the stream is deleted when OPEN or in use then audio resources will leak.
     // This would indicate an internal error. So we want to find this ASAP.
     LOG_ALWAYS_FATAL_IF(!(getState() == AAUDIO_STREAM_STATE_CLOSED
                         || getState() == AAUDIO_STREAM_STATE_UNINITIALIZED
                         || getState() == AAUDIO_STREAM_STATE_DISCONNECTED),
                         "service stream %p still open, state = %d",
                         this, getState());
 }

 std::string AAudioServiceStreamBase::dumpHeader() {
     return std::string("    T   Handle   UId   Port Run State Format Burst Chan Capacity");
 }

 std::string AAudioServiceStreamBase::dump() const {
     std::stringstream result;

     result << "    0x" << std::setfill('0') << std::setw(8) << std::hex << mHandle
            << std::dec << std::setfill(' ') ;
     result << std::setw(6) << mMmapClient.clientUid;
     result << std::setw(7) << mClientHandle;
     result << std::setw(4) << (isRunning() ? "yes" : " no");
     result << std::setw(6) << getState();
     result << std::setw(7) << getFormat();
     result << std::setw(6) << mFramesPerBurst;
     result << std::setw(5) << getSamplesPerFrame();
     result << std::setw(9) << getBufferCapacity();

     return result.str();
 }

 aaudio_result_t AAudioServiceStreamBase::open(const aaudio::AAudioStreamRequest &request) {
     AAudioEndpointManager &mEndpointManager = AAudioEndpointManager::getInstance();
     aaudio_result_t result = AAUDIO_OK;

     mMmapClient.clientUid = request.getUserId();
     mMmapClient.clientPid = request.getProcessId();
     mMmapClient.packageName.setTo(String16("")); // TODO What should we do here?

     // Limit scope of lock to avoid recursive lock in close().
     {
         std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
         if (mUpMessageQueue != nullptr) {
             ALOGE("%s() called twice", __func__);
             return AAUDIO_ERROR_INVALID_STATE;
         }

         mUpMessageQueue = new SharedRingBuffer();
         result = mUpMessageQueue->allocate(sizeof(AAudioServiceMessage),
                                            QUEUE_UP_CAPACITY_COMMANDS);
         if (result != AAUDIO_OK) {
             goto error;
         }

         // This is not protected by a lock because the stream cannot be
         // referenced until the service returns a handle to the client.
         // So only one thread can open a stream.
         mServiceEndpoint = mEndpointManager.openEndpoint(mAudioService,
                                                          request);
         if (mServiceEndpoint == nullptr) {
             result = AAUDIO_ERROR_UNAVAILABLE;
             goto error;
         }
         // Save a weak pointer that we will use to access the endpoint.
         mServiceEndpointWeak = mServiceEndpoint;

         mFramesPerBurst = mServiceEndpoint->getFramesPerBurst();
         copyFrom(*mServiceEndpoint);
     }
     return result;

 error:
     close();
     return result;
 }

 aaudio_result_t AAudioServiceStreamBase::close() {
     if (getState() == AAUDIO_STREAM_STATE_CLOSED) {
         return AAUDIO_OK;
     }

     stop();

     aaudio_result_t result = AAUDIO_OK;
     sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
     if (endpoint == nullptr) {
         result = AAUDIO_ERROR_INVALID_STATE;
     } else {
         endpoint->unregisterStream(this);
         AAudioEndpointManager &endpointManager = AAudioEndpointManager::getInstance();
         endpointManager.closeEndpoint(endpoint);

         // AAudioService::closeStream() prevents two threads from closing at the same time.
         mServiceEndpoint.clear(); // endpoint will hold the pointer until this method returns.
     }

     {
         std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
         stopTimestampThread();
         delete mUpMessageQueue;
         mUpMessageQueue = nullptr;
     }

     setState(AAUDIO_STREAM_STATE_CLOSED);
     return result;
 }

 aaudio_result_t AAudioServiceStreamBase::startDevice() {
     mClientHandle = AUDIO_PORT_HANDLE_NONE;
     sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
     if (endpoint == nullptr) {
         ALOGE("%s() has no endpoint", __func__);
         return AAUDIO_ERROR_INVALID_STATE;
     }
     return endpoint->startStream(this, &mClientHandle);
 }

 /**
  * Start the flow of audio data.
  *
  * An AAUDIO_SERVICE_EVENT_STARTED will be sent to the client when complete.
  */
 aaudio_result_t AAudioServiceStreamBase::start() {
     aaudio_result_t result = AAUDIO_OK;

     if (isRunning()) {
         return AAUDIO_OK;
     }

     setFlowing(false);
     setSuspended(false);

     // Start with fresh presentation timestamps.
     mAtomicStreamTimestamp.clear();

     mClientHandle = AUDIO_PORT_HANDLE_NONE;
     result = startDevice();
     if (result != AAUDIO_OK) goto error;

     // This should happen at the end of the start.
     sendServiceEvent(AAUDIO_SERVICE_EVENT_STARTED);
     setState(AAUDIO_STREAM_STATE_STARTED);
     mThreadEnabled.store(true);
     result = mTimestampThread.start(this);
     if (result != AAUDIO_OK) goto error;

     return result;

 error:
     disconnect();
     return result;
 }

 aaudio_result_t AAudioServiceStreamBase::pause() {
     aaudio_result_t result = AAUDIO_OK;
     if (!isRunning()) {
         return result;
     }

     // Send it now because the timestamp gets rounded up when stopStream() is called below.
     // Also we don't need the timestamps while we are shutting down.
     sendCurrentTimestamp();

     result = stopTimestampThread();
     if (result != AAUDIO_OK) {
         disconnect();
         return result;
     }

     sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
     if (endpoint == nullptr) {
         ALOGE("%s() has no endpoint", __func__);
         return AAUDIO_ERROR_INVALID_STATE;
     }
     result = endpoint->stopStream(this, mClientHandle);
     if (result != AAUDIO_OK) {
         ALOGE("%s() mServiceEndpoint returned %d, %s", __func__, result, getTypeText());
         disconnect(); // TODO should we return or pause Base first?
     }

     sendServiceEvent(AAUDIO_SERVICE_EVENT_PAUSED);
     setState(AAUDIO_STREAM_STATE_PAUSED);
     return result;
 }

 aaudio_result_t AAudioServiceStreamBase::stop() {
     aaudio_result_t result = AAUDIO_OK;
     if (!isRunning()) {
         return result;
     }

     setState(AAUDIO_STREAM_STATE_STOPPING);

     // Send it now because the timestamp gets rounded up when stopStream() is called below.
     // Also we don't need the timestamps while we are shutting down.
     sendCurrentTimestamp(); // warning - this calls a virtual function
     result = stopTimestampThread();
     if (result != AAUDIO_OK) {
         disconnect();
         return result;
     }

     sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
     if (endpoint == nullptr) {
         ALOGE("%s() has no endpoint", __func__);
         return AAUDIO_ERROR_INVALID_STATE;
     }
     // TODO wait for data to be played out
     result = endpoint->stopStream(this, mClientHandle);
     if (result != AAUDIO_OK) {
         ALOGE("%s() stopStream returned %d, %s", __func__, result, getTypeText());
         disconnect();
         // TODO what to do with result here?
     }

     sendServiceEvent(AAUDIO_SERVICE_EVENT_STOPPED);
     setState(AAUDIO_STREAM_STATE_STOPPED);
     return result;
 }

 aaudio_result_t AAudioServiceStreamBase::stopTimestampThread() {
     aaudio_result_t result = AAUDIO_OK;
     // clear flag that tells thread to loop
     if (mThreadEnabled.exchange(false)) {
         result = mTimestampThread.stop();
     }
     return result;
 }

 aaudio_result_t AAudioServiceStreamBase::flush() {
     aaudio_result_t result = AAudio_isFlushAllowed(getState());
     if (result != AAUDIO_OK) {
         return result;
     }

     // Data will get flushed when the client receives the FLUSHED event.
     sendServiceEvent(AAUDIO_SERVICE_EVENT_FLUSHED);
     setState(AAUDIO_STREAM_STATE_FLUSHED);
     return AAUDIO_OK;
 }

 // implement Runnable, periodically send timestamps to client
 __attribute__((no_sanitize("integer")))
 void AAudioServiceStreamBase::run() {
     ALOGD("%s() %s entering >>>>>>>>>>>>>> TIMESTAMPS", __func__, getTypeText());
     TimestampScheduler timestampScheduler;
     timestampScheduler.setBurstPeriod(mFramesPerBurst, getSampleRate());
     timestampScheduler.start(AudioClock::getNanoseconds());
     int64_t nextTime = timestampScheduler.nextAbsoluteTime();
     int32_t loopCount = 0;
     while(mThreadEnabled.load()) {
         loopCount++;
         if (AudioClock::getNanoseconds() >= nextTime) {
             aaudio_result_t result = sendCurrentTimestamp();
             if (result != AAUDIO_OK) {
                 ALOGE("%s() timestamp thread got result = %d", __func__, result);
                 break;
             }
             nextTime = timestampScheduler.nextAbsoluteTime();
         } else  {
             // Sleep until it is time to send the next timestamp.
             // TODO Wait for a signal with a timeout so that we can stop more quickly.
             AudioClock::sleepUntilNanoTime(nextTime);
         }
     }
     ALOGD("%s() %s exiting after %d loops <<<<<<<<<<<<<< TIMESTAMPS",
           __func__, getTypeText(), loopCount);
 }

 void AAudioServiceStreamBase::disconnect() {
     if (getState() != AAUDIO_STREAM_STATE_DISCONNECTED) {
         sendServiceEvent(AAUDIO_SERVICE_EVENT_DISCONNECTED);
         setState(AAUDIO_STREAM_STATE_DISCONNECTED);
     }
 }

 aaudio_result_t AAudioServiceStreamBase::sendServiceEvent(aaudio_service_event_t event,
                                                           double  dataDouble) {
     AAudioServiceMessage command;
     command.what = AAudioServiceMessage::code::EVENT;
     command.event.event = event;
     command.event.dataDouble = dataDouble;
     return writeUpMessageQueue(&command);
 }

 aaudio_result_t AAudioServiceStreamBase::sendServiceEvent(aaudio_service_event_t event,
                                                           int64_t dataLong) {
     AAudioServiceMessage command;
     command.what = AAudioServiceMessage::code::EVENT;
     command.event.event = event;
     command.event.dataLong = dataLong;
     return writeUpMessageQueue(&command);
 }

 bool AAudioServiceStreamBase::isUpMessageQueueBusy() {
     std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
     if (mUpMessageQueue == nullptr) {
         ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
         return true;
     }
     int32_t framesAvailable = mUpMessageQueue->getFifoBuffer()
         ->getFullFramesAvailable();
     int32_t capacity = mUpMessageQueue->getFifoBuffer()
         ->getBufferCapacityInFrames();
     // Is it half full or more
     return framesAvailable >= (capacity / 2);
 }

 aaudio_result_t AAudioServiceStreamBase::writeUpMessageQueue(AAudioServiceMessage *command) {
     std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
     if (mUpMessageQueue == nullptr) {
         ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
         return AAUDIO_ERROR_NULL;
     }
     int32_t count = mUpMessageQueue->getFifoBuffer()->write(command, 1);
     if (count != 1) {
         ALOGW("%s(): Queue full. Did client stop? Suspending stream. what = %u, %s",
               __func__, command->what, getTypeText());
         setSuspended(true);
         return AAUDIO_ERROR_WOULD_BLOCK;
     } else {
         return AAUDIO_OK;
     }
 }

 aaudio_result_t AAudioServiceStreamBase::sendXRunCount(int32_t xRunCount) {
     return sendServiceEvent(AAUDIO_SERVICE_EVENT_XRUN, (int64_t) xRunCount);
 }

 aaudio_result_t AAudioServiceStreamBase::sendCurrentTimestamp() {
     AAudioServiceMessage command;
     // It is not worth filling up the queue with timestamps.
     // That can cause the stream to get suspended.
     // So just drop the timestamp if the queue is getting full.
     if (isUpMessageQueueBusy()) {
         return AAUDIO_OK;
     }

     // Send a timestamp for the clock model.
     aaudio_result_t result = getFreeRunningPosition(&command.timestamp.position,
                                                     &command.timestamp.timestamp);
     if (result == AAUDIO_OK) {
         ALOGV("%s() SERVICE  %8lld at %lld", __func__,
               (long long) command.timestamp.position,
               (long long) command.timestamp.timestamp);
         command.what = AAudioServiceMessage::code::TIMESTAMP_SERVICE;
         result = writeUpMessageQueue(&command);

         if (result == AAUDIO_OK) {
             // Send a hardware timestamp for presentation time.
             result = getHardwareTimestamp(&command.timestamp.position,
                                           &command.timestamp.timestamp);
             if (result == AAUDIO_OK) {
                 ALOGV("%s() HARDWARE %8lld at %lld", __func__,
                       (long long) command.timestamp.position,
                       (long long) command.timestamp.timestamp);
                 command.what = AAudioServiceMessage::code::TIMESTAMP_HARDWARE;
                 result = writeUpMessageQueue(&command);
             }
         }
     }

     if (result == AAUDIO_ERROR_UNAVAILABLE) { // TODO review best error code
         result = AAUDIO_OK; // just not available yet, try again later
     }
     return result;
 }

 /**
  * Get an immutable description of the in-memory queues
  * used to communicate with the underlying HAL or Service.
  */
 aaudio_result_t AAudioServiceStreamBase::getDescription(AudioEndpointParcelable &parcelable) {
     {
         std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
         if (mUpMessageQueue == nullptr) {
             ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
             return AAUDIO_ERROR_NULL;
         }
         // Gather information on the message queue.
         mUpMessageQueue->fillParcelable(parcelable,
                                         parcelable.mUpMessageQueueParcelable);
     }
     return getAudioDataDescription(parcelable);
 }

 void AAudioServiceStreamBase::onVolumeChanged(float volume) {
     sendServiceEvent(AAUDIO_SERVICE_EVENT_VOLUME, volume);
 }

 int32_t AAudioServiceStreamBase::incrementServiceReferenceCount_l() {
     return ++mCallingCount;
 }

 int32_t AAudioServiceStreamBase::decrementServiceReferenceCount_l() {
     int32_t count = --mCallingCount;
     // Each call to increment should be balanced with one call to decrement.
     assert(count >= 0);
     return count;
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "AAudioServiceStreamBase"
	//#define LOG_NDEBUG 0
	#include <utils/Log.h>

	#include <iomanip>
	#include <iostream>
	#include <mutex>

	#include "binding/IAAudioService.h"
	#include "binding/AAudioServiceMessage.h"
	#include "utility/AudioClock.h"

	#include "AAudioEndpointManager.h"
	#include "AAudioService.h"
	#include "AAudioServiceEndpoint.h"
	#include "AAudioServiceStreamBase.h"
	#include "TimestampScheduler.h"

	using namespace android; // TODO just import names needed
	using namespace aaudio; // TODO just import names needed

	/**
	* Base class for streams in the service.
	* @return
	*/

	AAudioServiceStreamBase::AAudioServiceStreamBase(AAudioService &audioService)
	: mUpMessageQueue(nullptr)
	, mTimestampThread("AATime")
	, mAtomicStreamTimestamp()
	, mAudioService(audioService) {
	mMmapClient.clientUid = -1;
	mMmapClient.clientPid = -1;
	mMmapClient.packageName = String16("");
	}

	AAudioServiceStreamBase::~AAudioServiceStreamBase() {
	// If the stream is deleted when OPEN or in use then audio resources will leak.
	// This would indicate an internal error. So we want to find this ASAP.
	LOG_ALWAYS_FATAL_IF(!(getState() == AAUDIO_STREAM_STATE_CLOSED
	\|\| getState() == AAUDIO_STREAM_STATE_UNINITIALIZED
	\|\| getState() == AAUDIO_STREAM_STATE_DISCONNECTED),
	"service stream %p still open, state = %d",
	this, getState());
	}

	std::string AAudioServiceStreamBase::dumpHeader() {
	return std::string(" T Handle UId Port Run State Format Burst Chan Capacity");
	}

	std::string AAudioServiceStreamBase::dump() const {
	std::stringstream result;

	result << " 0x" << std::setfill('0') << std::setw(8) << std::hex << mHandle
	<< std::dec << std::setfill(' ') ;
	result << std::setw(6) << mMmapClient.clientUid;
	result << std::setw(7) << mClientHandle;
	result << std::setw(4) << (isRunning() ? "yes" : " no");
	result << std::setw(6) << getState();
	result << std::setw(7) << getFormat();
	result << std::setw(6) << mFramesPerBurst;
	result << std::setw(5) << getSamplesPerFrame();
	result << std::setw(9) << getBufferCapacity();

	return result.str();
	}

	aaudio_result_t AAudioServiceStreamBase::open(const aaudio::AAudioStreamRequest &request) {
	AAudioEndpointManager &mEndpointManager = AAudioEndpointManager::getInstance();
	aaudio_result_t result = AAUDIO_OK;

	mMmapClient.clientUid = request.getUserId();
	mMmapClient.clientPid = request.getProcessId();
	mMmapClient.packageName.setTo(String16("")); // TODO What should we do here?

	// Limit scope of lock to avoid recursive lock in close().
	{
	std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
	if (mUpMessageQueue != nullptr) {
	ALOGE("%s() called twice", __func__);
	return AAUDIO_ERROR_INVALID_STATE;
	}

	mUpMessageQueue = new SharedRingBuffer();
	result = mUpMessageQueue->allocate(sizeof(AAudioServiceMessage),
	QUEUE_UP_CAPACITY_COMMANDS);
	if (result != AAUDIO_OK) {
	goto error;
	}

	// This is not protected by a lock because the stream cannot be
	// referenced until the service returns a handle to the client.
	// So only one thread can open a stream.
	mServiceEndpoint = mEndpointManager.openEndpoint(mAudioService,
	request);
	if (mServiceEndpoint == nullptr) {
	result = AAUDIO_ERROR_UNAVAILABLE;
	goto error;
	}
	// Save a weak pointer that we will use to access the endpoint.
	mServiceEndpointWeak = mServiceEndpoint;

	mFramesPerBurst = mServiceEndpoint->getFramesPerBurst();
	copyFrom(*mServiceEndpoint);
	}
	return result;

	error:
	close();
	return result;
	}

	aaudio_result_t AAudioServiceStreamBase::close() {
	if (getState() == AAUDIO_STREAM_STATE_CLOSED) {
	return AAUDIO_OK;
	}

	stop();

	aaudio_result_t result = AAUDIO_OK;
	sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
	if (endpoint == nullptr) {
	result = AAUDIO_ERROR_INVALID_STATE;
	} else {
	endpoint->unregisterStream(this);
	AAudioEndpointManager &endpointManager = AAudioEndpointManager::getInstance();
	endpointManager.closeEndpoint(endpoint);

	// AAudioService::closeStream() prevents two threads from closing at the same time.
	mServiceEndpoint.clear(); // endpoint will hold the pointer until this method returns.
	}

	{
	std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
	stopTimestampThread();
	delete mUpMessageQueue;
	mUpMessageQueue = nullptr;
	}

	setState(AAUDIO_STREAM_STATE_CLOSED);
	return result;
	}

	aaudio_result_t AAudioServiceStreamBase::startDevice() {
	mClientHandle = AUDIO_PORT_HANDLE_NONE;
	sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
	if (endpoint == nullptr) {
	ALOGE("%s() has no endpoint", __func__);
	return AAUDIO_ERROR_INVALID_STATE;
	}
	return endpoint->startStream(this, &mClientHandle);
	}

	/**
	* Start the flow of audio data.
	*
	* An AAUDIO_SERVICE_EVENT_STARTED will be sent to the client when complete.
	*/
	aaudio_result_t AAudioServiceStreamBase::start() {
	aaudio_result_t result = AAUDIO_OK;

	if (isRunning()) {
	return AAUDIO_OK;
	}

	setFlowing(false);
	setSuspended(false);

	// Start with fresh presentation timestamps.
	mAtomicStreamTimestamp.clear();

	mClientHandle = AUDIO_PORT_HANDLE_NONE;
	result = startDevice();
	if (result != AAUDIO_OK) goto error;

	// This should happen at the end of the start.
	sendServiceEvent(AAUDIO_SERVICE_EVENT_STARTED);
	setState(AAUDIO_STREAM_STATE_STARTED);
	mThreadEnabled.store(true);
	result = mTimestampThread.start(this);
	if (result != AAUDIO_OK) goto error;

	return result;

	error:
	disconnect();
	return result;
	}

	aaudio_result_t AAudioServiceStreamBase::pause() {
	aaudio_result_t result = AAUDIO_OK;
	if (!isRunning()) {
	return result;
	}

	// Send it now because the timestamp gets rounded up when stopStream() is called below.
	// Also we don't need the timestamps while we are shutting down.
	sendCurrentTimestamp();

	result = stopTimestampThread();
	if (result != AAUDIO_OK) {
	disconnect();
	return result;
	}

	sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
	if (endpoint == nullptr) {
	ALOGE("%s() has no endpoint", __func__);
	return AAUDIO_ERROR_INVALID_STATE;
	}
	result = endpoint->stopStream(this, mClientHandle);
	if (result != AAUDIO_OK) {
	ALOGE("%s() mServiceEndpoint returned %d, %s", __func__, result, getTypeText());
	disconnect(); // TODO should we return or pause Base first?
	}

	sendServiceEvent(AAUDIO_SERVICE_EVENT_PAUSED);
	setState(AAUDIO_STREAM_STATE_PAUSED);
	return result;
	}

	aaudio_result_t AAudioServiceStreamBase::stop() {
	aaudio_result_t result = AAUDIO_OK;
	if (!isRunning()) {
	return result;
	}

	setState(AAUDIO_STREAM_STATE_STOPPING);

	// Send it now because the timestamp gets rounded up when stopStream() is called below.
	// Also we don't need the timestamps while we are shutting down.
	sendCurrentTimestamp(); // warning - this calls a virtual function
	result = stopTimestampThread();
	if (result != AAUDIO_OK) {
	disconnect();
	return result;
	}

	sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
	if (endpoint == nullptr) {
	ALOGE("%s() has no endpoint", __func__);
	return AAUDIO_ERROR_INVALID_STATE;
	}
	// TODO wait for data to be played out
	result = endpoint->stopStream(this, mClientHandle);
	if (result != AAUDIO_OK) {
	ALOGE("%s() stopStream returned %d, %s", __func__, result, getTypeText());
	disconnect();
	// TODO what to do with result here?
	}

	sendServiceEvent(AAUDIO_SERVICE_EVENT_STOPPED);
	setState(AAUDIO_STREAM_STATE_STOPPED);
	return result;
	}

	aaudio_result_t AAudioServiceStreamBase::stopTimestampThread() {
	aaudio_result_t result = AAUDIO_OK;
	// clear flag that tells thread to loop
	if (mThreadEnabled.exchange(false)) {
	result = mTimestampThread.stop();
	}
	return result;
	}

	aaudio_result_t AAudioServiceStreamBase::flush() {
	aaudio_result_t result = AAudio_isFlushAllowed(getState());
	if (result != AAUDIO_OK) {
	return result;
	}

	// Data will get flushed when the client receives the FLUSHED event.
	sendServiceEvent(AAUDIO_SERVICE_EVENT_FLUSHED);
	setState(AAUDIO_STREAM_STATE_FLUSHED);
	return AAUDIO_OK;
	}

	// implement Runnable, periodically send timestamps to client
	__attribute__((no_sanitize("integer")))
	void AAudioServiceStreamBase::run() {
	ALOGD("%s() %s entering >>>>>>>>>>>>>> TIMESTAMPS", __func__, getTypeText());
	TimestampScheduler timestampScheduler;
	timestampScheduler.setBurstPeriod(mFramesPerBurst, getSampleRate());
	timestampScheduler.start(AudioClock::getNanoseconds());
	int64_t nextTime = timestampScheduler.nextAbsoluteTime();
	int32_t loopCount = 0;
	while(mThreadEnabled.load()) {
	loopCount++;
	if (AudioClock::getNanoseconds() >= nextTime) {
	aaudio_result_t result = sendCurrentTimestamp();
	if (result != AAUDIO_OK) {
	ALOGE("%s() timestamp thread got result = %d", __func__, result);
	break;
	}
	nextTime = timestampScheduler.nextAbsoluteTime();
	} else {
	// Sleep until it is time to send the next timestamp.
	// TODO Wait for a signal with a timeout so that we can stop more quickly.
	AudioClock::sleepUntilNanoTime(nextTime);
	}
	}
	ALOGD("%s() %s exiting after %d loops <<<<<<<<<<<<<< TIMESTAMPS",
	__func__, getTypeText(), loopCount);
	}

	void AAudioServiceStreamBase::disconnect() {
	if (getState() != AAUDIO_STREAM_STATE_DISCONNECTED) {
	sendServiceEvent(AAUDIO_SERVICE_EVENT_DISCONNECTED);
	setState(AAUDIO_STREAM_STATE_DISCONNECTED);
	}
	}

	aaudio_result_t AAudioServiceStreamBase::sendServiceEvent(aaudio_service_event_t event,
	double dataDouble) {
	AAudioServiceMessage command;
	command.what = AAudioServiceMessage::code::EVENT;
	command.event.event = event;
	command.event.dataDouble = dataDouble;
	return writeUpMessageQueue(&command);
	}

	aaudio_result_t AAudioServiceStreamBase::sendServiceEvent(aaudio_service_event_t event,
	int64_t dataLong) {
	AAudioServiceMessage command;
	command.what = AAudioServiceMessage::code::EVENT;
	command.event.event = event;
	command.event.dataLong = dataLong;
	return writeUpMessageQueue(&command);
	}

	bool AAudioServiceStreamBase::isUpMessageQueueBusy() {
	std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
	if (mUpMessageQueue == nullptr) {
	ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
	return true;
	}
	int32_t framesAvailable = mUpMessageQueue->getFifoBuffer()
	->getFullFramesAvailable();
	int32_t capacity = mUpMessageQueue->getFifoBuffer()
	->getBufferCapacityInFrames();
	// Is it half full or more
	return framesAvailable >= (capacity / 2);
	}

	aaudio_result_t AAudioServiceStreamBase::writeUpMessageQueue(AAudioServiceMessage *command) {
	std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
	if (mUpMessageQueue == nullptr) {
	ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
	return AAUDIO_ERROR_NULL;
	}
	int32_t count = mUpMessageQueue->getFifoBuffer()->write(command, 1);
	if (count != 1) {
	ALOGW("%s(): Queue full. Did client stop? Suspending stream. what = %u, %s",
	__func__, command->what, getTypeText());
	setSuspended(true);
	return AAUDIO_ERROR_WOULD_BLOCK;
	} else {
	return AAUDIO_OK;
	}
	}

	aaudio_result_t AAudioServiceStreamBase::sendXRunCount(int32_t xRunCount) {
	return sendServiceEvent(AAUDIO_SERVICE_EVENT_XRUN, (int64_t) xRunCount);
	}

	aaudio_result_t AAudioServiceStreamBase::sendCurrentTimestamp() {
	AAudioServiceMessage command;
	// It is not worth filling up the queue with timestamps.
	// That can cause the stream to get suspended.
	// So just drop the timestamp if the queue is getting full.
	if (isUpMessageQueueBusy()) {
	return AAUDIO_OK;
	}

	// Send a timestamp for the clock model.
	aaudio_result_t result = getFreeRunningPosition(&command.timestamp.position,
	&command.timestamp.timestamp);
	if (result == AAUDIO_OK) {
	ALOGV("%s() SERVICE %8lld at %lld", __func__,
	(long long) command.timestamp.position,
	(long long) command.timestamp.timestamp);
	command.what = AAudioServiceMessage::code::TIMESTAMP_SERVICE;
	result = writeUpMessageQueue(&command);

	if (result == AAUDIO_OK) {
	// Send a hardware timestamp for presentation time.
	result = getHardwareTimestamp(&command.timestamp.position,
	&command.timestamp.timestamp);
	if (result == AAUDIO_OK) {
	ALOGV("%s() HARDWARE %8lld at %lld", __func__,
	(long long) command.timestamp.position,
	(long long) command.timestamp.timestamp);
	command.what = AAudioServiceMessage::code::TIMESTAMP_HARDWARE;
	result = writeUpMessageQueue(&command);
	}
	}
	}

	if (result == AAUDIO_ERROR_UNAVAILABLE) { // TODO review best error code
	result = AAUDIO_OK; // just not available yet, try again later
	}
	return result;
	}

	/**
	* Get an immutable description of the in-memory queues
	* used to communicate with the underlying HAL or Service.
	*/
	aaudio_result_t AAudioServiceStreamBase::getDescription(AudioEndpointParcelable &parcelable) {
	{
	std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
	if (mUpMessageQueue == nullptr) {
	ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
	return AAUDIO_ERROR_NULL;
	}
	// Gather information on the message queue.
	mUpMessageQueue->fillParcelable(parcelable,
	parcelable.mUpMessageQueueParcelable);
	}
	return getAudioDataDescription(parcelable);
	}

	void AAudioServiceStreamBase::onVolumeChanged(float volume) {
	sendServiceEvent(AAUDIO_SERVICE_EVENT_VOLUME, volume);
	}

	int32_t AAudioServiceStreamBase::incrementServiceReferenceCount_l() {
	return ++mCallingCount;
	}

	int32_t AAudioServiceStreamBase::decrementServiceReferenceCount_l() {
	int32_t count = --mCallingCount;
	// Each call to increment should be balanced with one call to decrement.
	assert(count >= 0);
	return count;
	}