libaaudio: changes for API council
Removed typedefs like aaudio_sample_rate_t
Removed use of handles. Just pass back opaque pointers.
Simplified gettersi in Stream.
Removed getters from Builder.
Update libaaudio.map.txt
Test: CTS test_aaudio.cpp
Change-Id: I63eaec3e5a8ecc516cfc1f950f4b4f54df1bd518
Signed-off-by: Phil Burk <philburk@google.com>
diff --git a/media/libaaudio/src/client/AudioEndpoint.cpp b/media/libaaudio/src/client/AudioEndpoint.cpp
index 5cd9782..47c4774 100644
--- a/media/libaaudio/src/client/AudioEndpoint.cpp
+++ b/media/libaaudio/src/client/AudioEndpoint.cpp
@@ -167,8 +167,8 @@
return mDownDataQueue->getWriteCounter();
}
-aaudio_size_frames_t AudioEndpoint::setBufferSizeInFrames(aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames)
+int32_t AudioEndpoint::setBufferSizeInFrames(int32_t requestedFrames,
+ int32_t *actualFrames)
{
if (requestedFrames < ENDPOINT_DATA_QUEUE_SIZE_MIN) {
requestedFrames = ENDPOINT_DATA_QUEUE_SIZE_MIN;
diff --git a/media/libaaudio/src/client/AudioEndpoint.h b/media/libaaudio/src/client/AudioEndpoint.h
index e786513..caee488 100644
--- a/media/libaaudio/src/client/AudioEndpoint.h
+++ b/media/libaaudio/src/client/AudioEndpoint.h
@@ -71,13 +71,13 @@
*/
bool isOutputFreeRunning() const { return mOutputFreeRunning; }
- int32_t setBufferSizeInFrames(aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames);
- aaudio_size_frames_t getBufferSizeInFrames() const;
+ int32_t setBufferSizeInFrames(int32_t requestedFrames,
+ int32_t *actualFrames);
+ int32_t getBufferSizeInFrames() const;
- aaudio_size_frames_t getBufferCapacityInFrames() const;
+ int32_t getBufferCapacityInFrames() const;
- aaudio_size_frames_t getFullFramesAvailable();
+ int32_t getFullFramesAvailable();
private:
FifoBuffer * mUpCommandQueue;
diff --git a/media/libaaudio/src/client/AudioStreamInternal.cpp b/media/libaaudio/src/client/AudioStreamInternal.cpp
index 19f2300..54f4870 100644
--- a/media/libaaudio/src/client/AudioStreamInternal.cpp
+++ b/media/libaaudio/src/client/AudioStreamInternal.cpp
@@ -172,14 +172,14 @@
aaudio_result_t AudioStreamInternal::requestStart()
{
- aaudio_nanoseconds_t startTime;
+ int64_t startTime;
ALOGD("AudioStreamInternal(): start()");
if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
return AAUDIO_ERROR_INVALID_STATE;
}
const sp<IAAudioService>& aaudioService = getAAudioService();
if (aaudioService == 0) return AAUDIO_ERROR_NO_SERVICE;
- startTime = AAudio_getNanoseconds(AAUDIO_CLOCK_MONOTONIC);
+ startTime = AudioClock::getNanoseconds();
mClockModel.start(startTime);
processTimestamp(0, startTime);
setState(AAUDIO_STREAM_STATE_STARTING);
@@ -194,7 +194,7 @@
}
const sp<IAAudioService>& aaudioService = getAAudioService();
if (aaudioService == 0) return AAUDIO_ERROR_NO_SERVICE;
- mClockModel.stop(AAudio_getNanoseconds(AAUDIO_CLOCK_MONOTONIC));
+ mClockModel.stop(AudioClock::getNanoseconds());
setState(AAUDIO_STREAM_STATE_PAUSING);
return aaudioService->pauseStream(mServiceStreamHandle);
}
@@ -212,10 +212,10 @@
void AudioStreamInternal::onFlushFromServer() {
ALOGD("AudioStreamInternal(): onFlushFromServer()");
- aaudio_position_frames_t readCounter = mAudioEndpoint.getDownDataReadCounter();
- aaudio_position_frames_t writeCounter = mAudioEndpoint.getDownDataWriteCounter();
+ int64_t readCounter = mAudioEndpoint.getDownDataReadCounter();
+ int64_t writeCounter = mAudioEndpoint.getDownDataWriteCounter();
// Bump offset so caller does not see the retrograde motion in getFramesRead().
- aaudio_position_frames_t framesFlushed = writeCounter - readCounter;
+ int64_t framesFlushed = writeCounter - readCounter;
mFramesOffsetFromService += framesFlushed;
// Flush written frames by forcing writeCounter to readCounter.
// This is because we cannot move the read counter in the hardware.
@@ -262,10 +262,10 @@
// TODO use aaudio_clockid_t all the way down to AudioClock
aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t clockId,
- aaudio_position_frames_t *framePosition,
- aaudio_nanoseconds_t *timeNanoseconds) {
+ int64_t *framePosition,
+ int64_t *timeNanoseconds) {
// TODO implement using real HAL
- aaudio_nanoseconds_t time = AudioClock::getNanoseconds();
+ int64_t time = AudioClock::getNanoseconds();
*framePosition = mClockModel.convertTimeToPosition(time);
*timeNanoseconds = time + (10 * AAUDIO_NANOS_PER_MILLISECOND); // Fake hardware delay
return AAUDIO_OK;
@@ -278,9 +278,9 @@
#if LOG_TIMESTAMPS
static void AudioStreamInternal_LogTimestamp(AAudioServiceMessage &command) {
static int64_t oldPosition = 0;
- static aaudio_nanoseconds_t oldTime = 0;
+ static int64_t oldTime = 0;
int64_t framePosition = command.timestamp.position;
- aaudio_nanoseconds_t nanoTime = command.timestamp.timestamp;
+ int64_t nanoTime = command.timestamp.timestamp;
ALOGD("AudioStreamInternal() timestamp says framePosition = %08lld at nanoTime %llu",
(long long) framePosition,
(long long) nanoTime);
@@ -298,7 +298,7 @@
#endif
aaudio_result_t AudioStreamInternal::onTimestampFromServer(AAudioServiceMessage *message) {
- aaudio_position_frames_t framePosition = 0;
+ int64_t framePosition = 0;
#if LOG_TIMESTAMPS
AudioStreamInternal_LogTimestamp(command);
#endif
@@ -370,12 +370,12 @@
// Write the data, block if needed and timeoutMillis > 0
aaudio_result_t AudioStreamInternal::write(const void *buffer, int32_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int64_t timeoutNanoseconds)
{
aaudio_result_t result = AAUDIO_OK;
uint8_t* source = (uint8_t*)buffer;
- aaudio_nanoseconds_t currentTimeNanos = AudioClock::getNanoseconds();
- aaudio_nanoseconds_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
+ int64_t currentTimeNanos = AudioClock::getNanoseconds();
+ int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
int32_t framesLeft = numFrames;
// ALOGD("AudioStreamInternal::write(%p, %d) at time %08llu , mState = %d ------------------",
// buffer, numFrames, (unsigned long long) currentTimeNanos, mState);
@@ -383,7 +383,7 @@
// Write until all the data has been written or until a timeout occurs.
while (framesLeft > 0) {
// The call to writeNow() will not block. It will just write as much as it can.
- aaudio_nanoseconds_t wakeTimeNanos = 0;
+ int64_t wakeTimeNanos = 0;
aaudio_result_t framesWritten = writeNow(source, framesLeft,
currentTimeNanos, &wakeTimeNanos);
// ALOGD("AudioStreamInternal::write() writeNow() framesLeft = %d --> framesWritten = %d", framesLeft, framesWritten);
@@ -422,7 +422,7 @@
// Write as much data as we can without blocking.
aaudio_result_t AudioStreamInternal::writeNow(const void *buffer, int32_t numFrames,
- aaudio_nanoseconds_t currentNanoTime, aaudio_nanoseconds_t *wakeTimePtr) {
+ int64_t currentNanoTime, int64_t *wakeTimePtr) {
{
aaudio_result_t result = processCommands();
if (result != AAUDIO_OK) {
@@ -452,7 +452,7 @@
// Calculate an ideal time to wake up.
if (wakeTimePtr != nullptr && framesWritten >= 0) {
// By default wake up a few milliseconds from now. // TODO review
- aaudio_nanoseconds_t wakeTime = currentNanoTime + (2 * AAUDIO_NANOS_PER_MILLISECOND);
+ int64_t wakeTime = currentNanoTime + (2 * AAUDIO_NANOS_PER_MILLISECOND);
switch (getState()) {
case AAUDIO_STREAM_STATE_OPEN:
case AAUDIO_STREAM_STATE_STARTING:
@@ -487,7 +487,7 @@
aaudio_result_t AudioStreamInternal::waitForStateChange(aaudio_stream_state_t currentState,
aaudio_stream_state_t *nextState,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int64_t timeoutNanoseconds)
{
aaudio_result_t result = processCommands();
@@ -522,33 +522,38 @@
}
-void AudioStreamInternal::processTimestamp(uint64_t position, aaudio_nanoseconds_t time) {
+void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
mClockModel.processTimestamp( position, time);
}
-aaudio_result_t AudioStreamInternal::setBufferSize(aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames) {
- return mAudioEndpoint.setBufferSizeInFrames(requestedFrames, actualFrames);
+aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
+ int32_t actualFrames = 0;
+ aaudio_result_t result = mAudioEndpoint.setBufferSizeInFrames(requestedFrames, &actualFrames);
+ if (result < 0) {
+ return result;
+ } else {
+ return (aaudio_result_t) actualFrames;
+ }
}
-aaudio_size_frames_t AudioStreamInternal::getBufferSize() const
+int32_t AudioStreamInternal::getBufferSize() const
{
return mAudioEndpoint.getBufferSizeInFrames();
}
-aaudio_size_frames_t AudioStreamInternal::getBufferCapacity() const
+int32_t AudioStreamInternal::getBufferCapacity() const
{
return mAudioEndpoint.getBufferCapacityInFrames();
}
-aaudio_size_frames_t AudioStreamInternal::getFramesPerBurst() const
+int32_t AudioStreamInternal::getFramesPerBurst() const
{
return mEndpointDescriptor.downDataQueueDescriptor.framesPerBurst;
}
-aaudio_position_frames_t AudioStreamInternal::getFramesRead()
+int64_t AudioStreamInternal::getFramesRead()
{
- aaudio_position_frames_t framesRead =
+ int64_t framesRead =
mClockModel.convertTimeToPosition(AudioClock::getNanoseconds())
+ mFramesOffsetFromService;
// Prevent retrograde motion.
diff --git a/media/libaaudio/src/client/AudioStreamInternal.h b/media/libaaudio/src/client/AudioStreamInternal.h
index 666df3a..6f3a7ac 100644
--- a/media/libaaudio/src/client/AudioStreamInternal.h
+++ b/media/libaaudio/src/client/AudioStreamInternal.h
@@ -49,8 +49,8 @@
// TODO use aaudio_clockid_t all the way down to AudioClock
virtual aaudio_result_t getTimestamp(clockid_t clockId,
- aaudio_position_frames_t *framePosition,
- aaudio_nanoseconds_t *timeNanoseconds) override;
+ int64_t *framePosition,
+ int64_t *timeNanoseconds) override;
virtual aaudio_result_t updateState() override;
@@ -62,22 +62,21 @@
virtual aaudio_result_t write(const void *buffer,
int32_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds) override;
+ int64_t timeoutNanoseconds) override;
virtual aaudio_result_t waitForStateChange(aaudio_stream_state_t currentState,
aaudio_stream_state_t *nextState,
- aaudio_nanoseconds_t timeoutNanoseconds) override;
+ int64_t timeoutNanoseconds) override;
- virtual aaudio_result_t setBufferSize(aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames) override;
+ virtual aaudio_result_t setBufferSize(int32_t requestedFrames) override;
- virtual aaudio_size_frames_t getBufferSize() const override;
+ virtual int32_t getBufferSize() const override;
- virtual aaudio_size_frames_t getBufferCapacity() const override;
+ virtual int32_t getBufferCapacity() const override;
- virtual aaudio_size_frames_t getFramesPerBurst() const override;
+ virtual int32_t getFramesPerBurst() const override;
- virtual aaudio_position_frames_t getFramesRead() override;
+ virtual int64_t getFramesRead() override;
virtual int32_t getXRunCount() const override {
return mXRunCount;
@@ -100,8 +99,8 @@
*/
virtual aaudio_result_t writeNow(const void *buffer,
int32_t numFrames,
- aaudio_nanoseconds_t currentTimeNanos,
- aaudio_nanoseconds_t *wakeTimePtr);
+ int64_t currentTimeNanos,
+ int64_t *wakeTimePtr);
void onFlushFromServer();
@@ -112,15 +111,15 @@
private:
IsochronousClockModel mClockModel;
AudioEndpoint mAudioEndpoint;
- aaudio_handle_t mServiceStreamHandle;
+ aaudio_handle_t mServiceStreamHandle;
EndpointDescriptor mEndpointDescriptor;
// Offset from underlying frame position.
- aaudio_position_frames_t mFramesOffsetFromService = 0;
- aaudio_position_frames_t mLastFramesRead = 0;
- aaudio_size_frames_t mFramesPerBurst;
+ int64_t mFramesOffsetFromService = 0;
+ int64_t mLastFramesRead = 0;
+ int32_t mFramesPerBurst;
int32_t mXRunCount = 0;
- void processTimestamp(uint64_t position, aaudio_nanoseconds_t time);
+ void processTimestamp(uint64_t position, int64_t time);
};
} /* namespace aaudio */
diff --git a/media/libaaudio/src/client/IsochronousClockModel.cpp b/media/libaaudio/src/client/IsochronousClockModel.cpp
index bdb491d..4c8aabc 100644
--- a/media/libaaudio/src/client/IsochronousClockModel.cpp
+++ b/media/libaaudio/src/client/IsochronousClockModel.cpp
@@ -21,6 +21,7 @@
#include <stdint.h>
#include <aaudio/AAudioDefinitions.h>
+#include "utility/AudioClock.h"
#include "IsochronousClockModel.h"
#define MIN_LATENESS_NANOS (10 * AAUDIO_NANOS_PER_MICROSECOND)
@@ -29,11 +30,11 @@
using namespace aaudio;
IsochronousClockModel::IsochronousClockModel()
- : mSampleRate(48000)
+ : mMarkerFramePosition(0)
+ , mMarkerNanoTime(0)
+ , mSampleRate(48000)
, mFramesPerBurst(64)
, mMaxLatenessInNanos(0)
- , mMarkerFramePosition(0)
- , mMarkerNanoTime(0)
, mState(STATE_STOPPED)
{
}
@@ -41,21 +42,21 @@
IsochronousClockModel::~IsochronousClockModel() {
}
-void IsochronousClockModel::start(aaudio_nanoseconds_t nanoTime)
+void IsochronousClockModel::start(int64_t nanoTime)
{
mMarkerNanoTime = nanoTime;
mState = STATE_STARTING;
}
-void IsochronousClockModel::stop(aaudio_nanoseconds_t nanoTime)
+void IsochronousClockModel::stop(int64_t nanoTime)
{
mMarkerNanoTime = nanoTime;
mMarkerFramePosition = convertTimeToPosition(nanoTime); // TODO should we do this?
mState = STATE_STOPPED;
}
-void IsochronousClockModel::processTimestamp(aaudio_position_frames_t framePosition,
- aaudio_nanoseconds_t nanoTime) {
+void IsochronousClockModel::processTimestamp(int64_t framePosition,
+ int64_t nanoTime) {
int64_t framesDelta = framePosition - mMarkerFramePosition;
int64_t nanosDelta = nanoTime - mMarkerNanoTime;
if (nanosDelta < 1000) {
@@ -115,7 +116,6 @@
default:
break;
}
- ++mTimestampCount;
}
void IsochronousClockModel::setSampleRate(int32_t sampleRate) {
@@ -133,41 +133,41 @@
mMaxLatenessInNanos = (nanosLate > MIN_LATENESS_NANOS) ? nanosLate : MIN_LATENESS_NANOS;
}
-aaudio_nanoseconds_t IsochronousClockModel::convertDeltaPositionToTime(
- aaudio_position_frames_t framesDelta) const {
+int64_t IsochronousClockModel::convertDeltaPositionToTime(
+ int64_t framesDelta) const {
return (AAUDIO_NANOS_PER_SECOND * framesDelta) / mSampleRate;
}
-int64_t IsochronousClockModel::convertDeltaTimeToPosition(aaudio_nanoseconds_t nanosDelta) const {
+int64_t IsochronousClockModel::convertDeltaTimeToPosition(int64_t nanosDelta) const {
return (mSampleRate * nanosDelta) / AAUDIO_NANOS_PER_SECOND;
}
-aaudio_nanoseconds_t IsochronousClockModel::convertPositionToTime(
- aaudio_position_frames_t framePosition) const {
+int64_t IsochronousClockModel::convertPositionToTime(
+ int64_t framePosition) const {
if (mState == STATE_STOPPED) {
return mMarkerNanoTime;
}
- aaudio_position_frames_t nextBurstIndex = (framePosition + mFramesPerBurst - 1) / mFramesPerBurst;
- aaudio_position_frames_t nextBurstPosition = mFramesPerBurst * nextBurstIndex;
- aaudio_position_frames_t framesDelta = nextBurstPosition - mMarkerFramePosition;
- aaudio_nanoseconds_t nanosDelta = convertDeltaPositionToTime(framesDelta);
- aaudio_nanoseconds_t time = (aaudio_nanoseconds_t) (mMarkerNanoTime + nanosDelta);
+ int64_t nextBurstIndex = (framePosition + mFramesPerBurst - 1) / mFramesPerBurst;
+ int64_t nextBurstPosition = mFramesPerBurst * nextBurstIndex;
+ int64_t framesDelta = nextBurstPosition - mMarkerFramePosition;
+ int64_t nanosDelta = convertDeltaPositionToTime(framesDelta);
+ int64_t time = (int64_t) (mMarkerNanoTime + nanosDelta);
// ALOGI("IsochronousClockModel::convertPositionToTime: pos = %llu --> time = %llu",
// (unsigned long long)framePosition,
// (unsigned long long)time);
return time;
}
-aaudio_position_frames_t IsochronousClockModel::convertTimeToPosition(
- aaudio_nanoseconds_t nanoTime) const {
+int64_t IsochronousClockModel::convertTimeToPosition(
+ int64_t nanoTime) const {
if (mState == STATE_STOPPED) {
return mMarkerFramePosition;
}
- aaudio_nanoseconds_t nanosDelta = nanoTime - mMarkerNanoTime;
- aaudio_position_frames_t framesDelta = convertDeltaTimeToPosition(nanosDelta);
- aaudio_position_frames_t nextBurstPosition = mMarkerFramePosition + framesDelta;
- aaudio_position_frames_t nextBurstIndex = nextBurstPosition / mFramesPerBurst;
- aaudio_position_frames_t position = nextBurstIndex * mFramesPerBurst;
+ int64_t nanosDelta = nanoTime - mMarkerNanoTime;
+ int64_t framesDelta = convertDeltaTimeToPosition(nanosDelta);
+ int64_t nextBurstPosition = mMarkerFramePosition + framesDelta;
+ int64_t nextBurstIndex = nextBurstPosition / mFramesPerBurst;
+ int64_t position = nextBurstIndex * mFramesPerBurst;
// ALOGI("IsochronousClockModel::convertTimeToPosition: time = %llu --> pos = %llu",
// (unsigned long long)nanoTime,
// (unsigned long long)position);
diff --git a/media/libaaudio/src/client/IsochronousClockModel.h b/media/libaaudio/src/client/IsochronousClockModel.h
index b188a3d..524c286 100644
--- a/media/libaaudio/src/client/IsochronousClockModel.h
+++ b/media/libaaudio/src/client/IsochronousClockModel.h
@@ -34,17 +34,17 @@
IsochronousClockModel();
virtual ~IsochronousClockModel();
- void start(aaudio_nanoseconds_t nanoTime);
- void stop(aaudio_nanoseconds_t nanoTime);
+ void start(int64_t nanoTime);
+ void stop(int64_t nanoTime);
- void processTimestamp(aaudio_position_frames_t framePosition, aaudio_nanoseconds_t nanoTime);
+ void processTimestamp(int64_t framePosition, int64_t nanoTime);
/**
* @param sampleRate rate of the stream in frames per second
*/
- void setSampleRate(aaudio_sample_rate_t sampleRate);
+ void setSampleRate(int32_t sampleRate);
- aaudio_sample_rate_t getSampleRate() const {
+ int32_t getSampleRate() const {
return mSampleRate;
}
@@ -53,9 +53,9 @@
*
* @param framesPerBurst number of frames that stream advance at one time.
*/
- void setFramesPerBurst(aaudio_size_frames_t framesPerBurst);
+ void setFramesPerBurst(int32_t framesPerBurst);
- aaudio_size_frames_t getFramesPerBurst() const {
+ int32_t getFramesPerBurst() const {
return mFramesPerBurst;
}
@@ -65,7 +65,7 @@
* @param framePosition position of the stream in frames
* @return time in nanoseconds
*/
- aaudio_nanoseconds_t convertPositionToTime(aaudio_position_frames_t framePosition) const;
+ int64_t convertPositionToTime(int64_t framePosition) const;
/**
* Calculate an estimated position where the stream will be at the specified time.
@@ -73,19 +73,19 @@
* @param nanoTime time of interest
* @return position in frames
*/
- aaudio_position_frames_t convertTimeToPosition(aaudio_nanoseconds_t nanoTime) const;
+ int64_t convertTimeToPosition(int64_t nanoTime) const;
/**
* @param framesDelta difference in frames
* @return duration in nanoseconds
*/
- aaudio_nanoseconds_t convertDeltaPositionToTime(aaudio_position_frames_t framesDelta) const;
+ int64_t convertDeltaPositionToTime(int64_t framesDelta) const;
/**
* @param nanosDelta duration in nanoseconds
* @return frames that stream will advance in that time
*/
- aaudio_position_frames_t convertDeltaTimeToPosition(aaudio_nanoseconds_t nanosDelta) const;
+ int64_t convertDeltaTimeToPosition(int64_t nanosDelta) const;
private:
enum clock_model_state_t {
@@ -95,13 +95,12 @@
STATE_RUNNING
};
- aaudio_sample_rate_t mSampleRate;
- aaudio_size_frames_t mFramesPerBurst;
- int32_t mMaxLatenessInNanos;
- aaudio_position_frames_t mMarkerFramePosition;
- aaudio_nanoseconds_t mMarkerNanoTime;
- int32_t mTimestampCount;
- clock_model_state_t mState;
+ int64_t mMarkerFramePosition;
+ int64_t mMarkerNanoTime;
+ int32_t mSampleRate;
+ int32_t mFramesPerBurst;
+ int32_t mMaxLatenessInNanos;
+ clock_model_state_t mState;
void update();
};