blob: 3badb0be41c4de61756df77e6cb948c9dc19f590 [file] [log] [blame]
/*
* Copyright (C) 2017 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_NDEBUG 0
#include <utils/Log.h>
#define ATRACE_TAG ATRACE_TAG_AUDIO
#include <media/MediaMetricsItem.h>
#include <utils/Trace.h>
#include "client/AudioStreamInternalPlay.h"
#include "utility/AudioClock.h"
// We do this after the #includes because if a header uses ALOG.
// it would fail on the reference to mInService.
#undef LOG_TAG
// This file is used in both client and server processes.
// This is needed to make sense of the logs more easily.
#define LOG_TAG (mInService ? "AudioStreamInternalPlay_Service" \
: "AudioStreamInternalPlay_Client")
using android::status_t;
using android::WrappingBuffer;
using namespace aaudio;
AudioStreamInternalPlay::AudioStreamInternalPlay(AAudioServiceInterface &serviceInterface,
bool inService)
: AudioStreamInternal(serviceInterface, inService) {
}
constexpr int kRampMSec = 10; // time to apply a change in volume
aaudio_result_t AudioStreamInternalPlay::open(const AudioStreamBuilder &builder) {
aaudio_result_t result = AudioStreamInternal::open(builder);
const bool useVolumeRamps = (getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE);
if (result == AAUDIO_OK) {
result = mFlowGraph.configure(getFormat(),
getSamplesPerFrame(),
getSampleRate(),
getDeviceFormat(),
getDeviceSamplesPerFrame(),
getDeviceSampleRate(),
getRequireMonoBlend(),
useVolumeRamps,
getAudioBalance(),
aaudio::resampler::MultiChannelResampler::Quality::Medium);
if (result != AAUDIO_OK) {
safeReleaseClose();
}
// Sample rate is constrained to common values by now and should not overflow.
int32_t numFrames = kRampMSec * getSampleRate() / AAUDIO_MILLIS_PER_SECOND;
mFlowGraph.setRampLengthInFrames(numFrames);
}
return result;
}
// This must be called under mStreamLock.
aaudio_result_t AudioStreamInternalPlay::requestPause_l()
{
aaudio_result_t result = stopCallback_l();
if (result != AAUDIO_OK) {
return result;
}
if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
ALOGW("%s() mServiceStreamHandle invalid", __func__);
return AAUDIO_ERROR_INVALID_STATE;
}
mClockModel.stop(AudioClock::getNanoseconds());
setState(AAUDIO_STREAM_STATE_PAUSING);
mAtomicInternalTimestamp.clear();
return mServiceInterface.pauseStream(mServiceStreamHandleInfo);
}
aaudio_result_t AudioStreamInternalPlay::requestFlush_l() {
if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
ALOGW("%s() mServiceStreamHandle invalid", __func__);
return AAUDIO_ERROR_INVALID_STATE;
}
setState(AAUDIO_STREAM_STATE_FLUSHING);
return mServiceInterface.flushStream(mServiceStreamHandleInfo);
}
void AudioStreamInternalPlay::prepareBuffersForStart() {
// Prevent stale data from being played.
mAudioEndpoint->eraseDataMemory();
}
void AudioStreamInternalPlay::advanceClientToMatchServerPosition(int32_t serverMargin) {
int64_t readCounter = mAudioEndpoint->getDataReadCounter() + serverMargin;
int64_t writeCounter = mAudioEndpoint->getDataWriteCounter();
// Bump offset so caller does not see the retrograde motion in getFramesRead().
int64_t offset = writeCounter - readCounter;
mFramesOffsetFromService += offset;
ALOGV("%s() readN = %lld, writeN = %lld, offset = %lld", __func__,
(long long)readCounter, (long long)writeCounter, (long long)mFramesOffsetFromService);
// Force writeCounter to match readCounter.
// This is because we cannot change the read counter in the hardware.
mAudioEndpoint->setDataWriteCounter(readCounter);
}
void AudioStreamInternalPlay::onFlushFromServer() {
advanceClientToMatchServerPosition(0 /*serverMargin*/);
}
// Write the data, block if needed and timeoutMillis > 0
aaudio_result_t AudioStreamInternalPlay::write(const void *buffer, int32_t numFrames,
int64_t timeoutNanoseconds) {
return processData((void *)buffer, numFrames, timeoutNanoseconds);
}
// Write as much data as we can without blocking.
aaudio_result_t AudioStreamInternalPlay::processDataNow(void *buffer, int32_t numFrames,
int64_t currentNanoTime, int64_t *wakeTimePtr) {
aaudio_result_t result = processCommands();
if (result != AAUDIO_OK) {
return result;
}
const char *traceName = "aaWrNow";
ATRACE_BEGIN(traceName);
if (mClockModel.isStarting()) {
// Still haven't got any timestamps from server.
// Keep waiting until we get some valid timestamps then start writing to the
// current buffer position.
ALOGV("%s() wait for valid timestamps", __func__);
// Sleep very briefly and hope we get a timestamp soon.
*wakeTimePtr = currentNanoTime + (2000 * AAUDIO_NANOS_PER_MICROSECOND);
ATRACE_END();
return 0;
}
// If we have gotten this far then we have at least one timestamp from server.
// If a DMA channel or DSP is reading the other end then we have to update the readCounter.
if (mAudioEndpoint->isFreeRunning()) {
// Update data queue based on the timing model.
int64_t estimatedReadCounter = mClockModel.convertTimeToPosition(currentNanoTime);
// ALOGD("AudioStreamInternal::processDataNow() - estimatedReadCounter = %d", (int)estimatedReadCounter);
mAudioEndpoint->setDataReadCounter(estimatedReadCounter);
}
if (mNeedCatchUp.isRequested()) {
// Catch an MMAP pointer that is already advancing.
// This will avoid initial underruns caused by a slow cold start.
// We add a one burst margin in case the DSP advances before we can write the data.
// This can help prevent the beginning of the stream from being skipped.
advanceClientToMatchServerPosition(getFramesPerBurst());
mNeedCatchUp.acknowledge();
}
// If the read index passed the write index then consider it an underrun.
// For shared streams, the xRunCount is passed up from the service.
if (mAudioEndpoint->isFreeRunning() && mAudioEndpoint->getFullFramesAvailable() < 0) {
mXRunCount++;
if (ATRACE_ENABLED()) {
ATRACE_INT("aaUnderRuns", mXRunCount);
}
}
// Write some data to the buffer.
//ALOGD("AudioStreamInternal::processDataNow() - writeNowWithConversion(%d)", numFrames);
int32_t framesWritten = writeNowWithConversion(buffer, numFrames);
//ALOGD("AudioStreamInternal::processDataNow() - tried to write %d frames, wrote %d",
// numFrames, framesWritten);
if (ATRACE_ENABLED()) {
ATRACE_INT("aaWrote", framesWritten);
}
// Sleep if there is too much data in the buffer.
// Calculate an ideal time to wake up.
if (wakeTimePtr != nullptr
&& (mAudioEndpoint->getFullFramesAvailable() >= getDeviceBufferSize())) {
// By default wake up a few milliseconds from now. // TODO review
int64_t wakeTime = currentNanoTime + (1 * AAUDIO_NANOS_PER_MILLISECOND);
aaudio_stream_state_t state = getState();
//ALOGD("AudioStreamInternal::processDataNow() - wakeTime based on %s",
// AAudio_convertStreamStateToText(state));
switch (state) {
case AAUDIO_STREAM_STATE_OPEN:
case AAUDIO_STREAM_STATE_STARTING:
if (framesWritten != 0) {
// Don't wait to write more data. Just prime the buffer.
wakeTime = currentNanoTime;
}
break;
case AAUDIO_STREAM_STATE_STARTED:
{
// Calculate when there will be room available to write to the buffer.
// If the appBufferSize is smaller than the endpointBufferSize then
// we will have room to write data beyond the appBufferSize.
// That is a technique used to reduce glitches without adding latency.
const int64_t appBufferSize = getDeviceBufferSize();
// The endpoint buffer size is set to the maximum that can be written.
// If we use it then we must carve out some room to write data when we wake up.
const int64_t endBufferSize = mAudioEndpoint->getBufferSizeInFrames()
- getDeviceFramesPerBurst();
const int64_t bestBufferSize = std::min(appBufferSize, endBufferSize);
int64_t targetReadPosition = mAudioEndpoint->getDataWriteCounter() - bestBufferSize;
wakeTime = mClockModel.convertPositionToTime(targetReadPosition);
}
break;
default:
break;
}
*wakeTimePtr = wakeTime;
}
ATRACE_END();
return framesWritten;
}
aaudio_result_t AudioStreamInternalPlay::writeNowWithConversion(const void *buffer,
int32_t numFrames) {
WrappingBuffer wrappingBuffer;
uint8_t *byteBuffer = (uint8_t *) buffer;
int32_t framesLeftInByteBuffer = numFrames;
mAudioEndpoint->getEmptyFramesAvailable(&wrappingBuffer);
// Write data in one or two parts.
int partIndex = 0;
int framesWrittenToAudioEndpoint = 0;
while (framesLeftInByteBuffer > 0 && partIndex < WrappingBuffer::SIZE) {
int32_t framesAvailableInWrappingBuffer = wrappingBuffer.numFrames[partIndex];
uint8_t *currentWrappingBuffer = (uint8_t *) wrappingBuffer.data[partIndex];
if (framesAvailableInWrappingBuffer > 0) {
// Pull data from the flowgraph in case there is residual data.
const int32_t framesActuallyWrittenToWrappingBuffer = mFlowGraph.pull(
(void*) currentWrappingBuffer,
framesAvailableInWrappingBuffer);
const int32_t numBytesActuallyWrittenToWrappingBuffer =
framesActuallyWrittenToWrappingBuffer * getBytesPerDeviceFrame();
currentWrappingBuffer += numBytesActuallyWrittenToWrappingBuffer;
framesAvailableInWrappingBuffer -= framesActuallyWrittenToWrappingBuffer;
framesWrittenToAudioEndpoint += framesActuallyWrittenToWrappingBuffer;
} else {
break;
}
// Put data from byteBuffer into the flowgraph one buffer (8 frames) at a time.
// Continuously pull as much data as possible from the flowgraph into the wrapping buffer.
// The return value of mFlowGraph.process is the number of frames actually pulled.
while (framesAvailableInWrappingBuffer > 0 && framesLeftInByteBuffer > 0) {
int32_t framesToWriteFromByteBuffer = std::min(flowgraph::kDefaultBufferSize,
framesLeftInByteBuffer);
// If the wrapping buffer is running low, write one frame at a time.
if (framesAvailableInWrappingBuffer < flowgraph::kDefaultBufferSize) {
framesToWriteFromByteBuffer = 1;
}
const int32_t numBytesToWriteFromByteBuffer = getBytesPerFrame() *
framesToWriteFromByteBuffer;
//ALOGD("%s() framesLeftInByteBuffer %d, framesAvailableInWrappingBuffer %d"
// "framesToWriteFromByteBuffer %d, numBytesToWriteFromByteBuffer %d"
// , __func__, framesLeftInByteBuffer, framesAvailableInWrappingBuffer,
// framesToWriteFromByteBuffer, numBytesToWriteFromByteBuffer);
const int32_t framesActuallyWrittenToWrappingBuffer = mFlowGraph.process(
(void *)byteBuffer,
framesToWriteFromByteBuffer,
(void *)currentWrappingBuffer,
framesAvailableInWrappingBuffer);
byteBuffer += numBytesToWriteFromByteBuffer;
framesLeftInByteBuffer -= framesToWriteFromByteBuffer;
const int32_t numBytesActuallyWrittenToWrappingBuffer =
framesActuallyWrittenToWrappingBuffer * getBytesPerDeviceFrame();
currentWrappingBuffer += numBytesActuallyWrittenToWrappingBuffer;
framesAvailableInWrappingBuffer -= framesActuallyWrittenToWrappingBuffer;
framesWrittenToAudioEndpoint += framesActuallyWrittenToWrappingBuffer;
//ALOGD("%s() numBytesActuallyWrittenToWrappingBuffer %d, framesLeftInByteBuffer %d"
// "framesActuallyWrittenToWrappingBuffer %d, numBytesToWriteFromByteBuffer %d"
// "framesWrittenToAudioEndpoint %d"
// , __func__, numBytesActuallyWrittenToWrappingBuffer, framesLeftInByteBuffer,
// framesActuallyWrittenToWrappingBuffer, numBytesToWriteFromByteBuffer,
// framesWrittenToAudioEndpoint);
}
partIndex++;
}
//ALOGD("%s() framesWrittenToAudioEndpoint %d, numFrames %d"
// "framesLeftInByteBuffer %d"
// , __func__, framesWrittenToAudioEndpoint, numFrames,
// framesLeftInByteBuffer);
// The audio endpoint should reference the number of frames written to the wrapping buffer.
mAudioEndpoint->advanceWriteIndex(framesWrittenToAudioEndpoint);
// The internal code should use the number of frames read from the app.
return numFrames - framesLeftInByteBuffer;
}
int64_t AudioStreamInternalPlay::getFramesRead() {
if (mAudioEndpoint) {
const int64_t framesReadHardware = isClockModelInControl()
? mClockModel.convertTimeToPosition(AudioClock::getNanoseconds())
: mAudioEndpoint->getDataReadCounter();
// Add service offset and prevent retrograde motion.
mLastFramesRead = std::max(mLastFramesRead, framesReadHardware + mFramesOffsetFromService);
}
return mLastFramesRead;
}
int64_t AudioStreamInternalPlay::getFramesWritten() {
if (mAudioEndpoint) {
mLastFramesWritten = mAudioEndpoint->getDataWriteCounter()
+ mFramesOffsetFromService;
}
return mLastFramesWritten;
}
// Render audio in the application callback and then write the data to the stream.
void *AudioStreamInternalPlay::callbackLoop() {
ALOGD("%s() entering >>>>>>>>>>>>>>>", __func__);
aaudio_result_t result = AAUDIO_OK;
aaudio_data_callback_result_t callbackResult = AAUDIO_CALLBACK_RESULT_CONTINUE;
if (!isDataCallbackSet()) return nullptr;
int64_t timeoutNanos = calculateReasonableTimeout(mCallbackFrames);
// result might be a frame count
while (mCallbackEnabled.load() && isActive() && (result >= 0)) {
// Call application using the AAudio callback interface.
callbackResult = maybeCallDataCallback(mCallbackBuffer.get(), mCallbackFrames);
if (callbackResult == AAUDIO_CALLBACK_RESULT_CONTINUE) {
// Write audio data to stream. This is a BLOCKING WRITE!
result = write(mCallbackBuffer.get(), mCallbackFrames, timeoutNanos);
if ((result != mCallbackFrames)) {
if (result >= 0) {
// Only wrote some of the frames requested. Must have timed out.
result = AAUDIO_ERROR_TIMEOUT;
}
maybeCallErrorCallback(result);
break;
}
} else if (callbackResult == AAUDIO_CALLBACK_RESULT_STOP) {
ALOGD("%s(): callback returned AAUDIO_CALLBACK_RESULT_STOP", __func__);
result = systemStopInternal();
break;
}
}
ALOGD("%s() exiting, result = %d, isActive() = %d <<<<<<<<<<<<<<",
__func__, result, (int) isActive());
return nullptr;
}
//------------------------------------------------------------------------------
// Implementation of PlayerBase
status_t AudioStreamInternalPlay::doSetVolume() {
float combinedVolume = mStreamVolume * getDuckAndMuteVolume();
ALOGD("%s() mStreamVolume * duckAndMuteVolume = %f * %f = %f",
__func__, mStreamVolume, getDuckAndMuteVolume(), combinedVolume);
mFlowGraph.setTargetVolume(combinedVolume);
return android::NO_ERROR;
}