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/binding/AAudioServiceDefinitions.h b/media/libaaudio/src/binding/AAudioServiceDefinitions.h
index ca637ef..b58d170 100644
--- a/media/libaaudio/src/binding/AAudioServiceDefinitions.h
+++ b/media/libaaudio/src/binding/AAudioServiceDefinitions.h
@@ -44,6 +44,10 @@
namespace aaudio {
+typedef int32_t aaudio_handle_t;
+
+#define AAUDIO_HANDLE_INVALID ((aaudio_handle_t) -1)
+
enum aaudio_commands_t {
OPEN_STREAM = IBinder::FIRST_CALL_TRANSACTION,
CLOSE_STREAM,
@@ -57,9 +61,9 @@
// TODO Expand this to include all the open parameters.
typedef struct AAudioServiceStreamInfo_s {
- int32_t deviceId;
- int32_t samplesPerFrame; // number of channels
- aaudio_sample_rate_t sampleRate;
+ int32_t deviceId;
+ int32_t samplesPerFrame; // number of channels
+ int32_t sampleRate;
aaudio_audio_format_t audioFormat;
} AAudioServiceStreamInfo;
diff --git a/media/libaaudio/src/binding/AAudioServiceMessage.h b/media/libaaudio/src/binding/AAudioServiceMessage.h
index 16cb5eb..cc77d59 100644
--- a/media/libaaudio/src/binding/AAudioServiceMessage.h
+++ b/media/libaaudio/src/binding/AAudioServiceMessage.h
@@ -23,12 +23,12 @@
namespace aaudio {
-// TODO move this an "include" folder for the service.
+// TODO move this to an "include" folder for the service.
struct AAudioMessageTimestamp {
- aaudio_position_frames_t position;
- int64_t deviceOffset; // add to client position to get device position
- aaudio_nanoseconds_t timestamp;
+ int64_t position;
+ int64_t deviceOffset; // add to client position to get device position
+ int64_t timestamp;
};
typedef enum aaudio_service_event_e : uint32_t {
@@ -41,8 +41,8 @@
struct AAudioMessageEvent {
aaudio_service_event_t event;
- int32_t data1;
- int64_t data2;
+ int32_t data1;
+ int64_t data2;
};
typedef struct AAudioServiceMessage_s {
diff --git a/media/libaaudio/src/binding/AAudioStreamConfiguration.h b/media/libaaudio/src/binding/AAudioStreamConfiguration.h
index efcdae8..57b1c59 100644
--- a/media/libaaudio/src/binding/AAudioStreamConfiguration.h
+++ b/media/libaaudio/src/binding/AAudioStreamConfiguration.h
@@ -34,19 +34,19 @@
AAudioStreamConfiguration();
virtual ~AAudioStreamConfiguration();
- aaudio_device_id_t getDeviceId() const {
+ int32_t getDeviceId() const {
return mDeviceId;
}
- void setDeviceId(aaudio_device_id_t deviceId) {
+ void setDeviceId(int32_t deviceId) {
mDeviceId = deviceId;
}
- aaudio_sample_rate_t getSampleRate() const {
+ int32_t getSampleRate() const {
return mSampleRate;
}
- void setSampleRate(aaudio_sample_rate_t sampleRate) {
+ void setSampleRate(int32_t sampleRate) {
mSampleRate = sampleRate;
}
@@ -66,11 +66,11 @@
mAudioFormat = audioFormat;
}
- aaudio_size_frames_t getBufferCapacity() const {
+ int32_t getBufferCapacity() const {
return mBufferCapacity;
}
- void setBufferCapacity(aaudio_size_frames_t frames) {
+ void setBufferCapacity(int32_t frames) {
mBufferCapacity = frames;
}
@@ -83,11 +83,11 @@
void dump();
protected:
- aaudio_device_id_t mDeviceId = AAUDIO_DEVICE_UNSPECIFIED;
- aaudio_sample_rate_t mSampleRate = AAUDIO_UNSPECIFIED;
+ int32_t mDeviceId = AAUDIO_DEVICE_UNSPECIFIED;
+ int32_t mSampleRate = AAUDIO_UNSPECIFIED;
int32_t mSamplesPerFrame = AAUDIO_UNSPECIFIED;
aaudio_audio_format_t mAudioFormat = AAUDIO_FORMAT_UNSPECIFIED;
- aaudio_size_frames_t mBufferCapacity = AAUDIO_UNSPECIFIED;
+ int32_t mBufferCapacity = AAUDIO_UNSPECIFIED;
};
} /* namespace aaudio */
diff --git a/media/libaaudio/src/binding/IAAudioService.cpp b/media/libaaudio/src/binding/IAAudioService.cpp
index 899ebc0..c21033e 100644
--- a/media/libaaudio/src/binding/IAAudioService.cpp
+++ b/media/libaaudio/src/binding/IAAudioService.cpp
@@ -18,12 +18,15 @@
#include "binding/AudioEndpointParcelable.h"
#include "binding/AAudioStreamRequest.h"
+#include "binding/AAudioServiceDefinitions.h"
#include "binding/AAudioStreamConfiguration.h"
#include "binding/IAAudioService.h"
#include "utility/AAudioUtilities.h"
namespace android {
+using aaudio::aaudio_handle_t;
+
/**
* This is used by the AAudio Client to talk to the AAudio Service.
*
@@ -137,7 +140,7 @@
}
virtual aaudio_result_t registerAudioThread(aaudio_handle_t streamHandle, pid_t clientThreadId,
- aaudio_nanoseconds_t periodNanoseconds)
+ int64_t periodNanoseconds)
override {
Parcel data, reply;
// send command
@@ -182,11 +185,11 @@
status_t BnAAudioService::onTransact(uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags) {
- AAudioStream stream;
+ aaudio_handle_t stream;
aaudio::AAudioStreamRequest request;
aaudio::AAudioStreamConfiguration configuration;
pid_t pid;
- aaudio_nanoseconds_t nanoseconds;
+ int64_t nanoseconds;
aaudio_result_t result;
ALOGV("BnAAudioService::onTransact(%i) %i", code, flags);
data.checkInterface(this);
diff --git a/media/libaaudio/src/binding/IAAudioService.h b/media/libaaudio/src/binding/IAAudioService.h
index f3b297e..53c3b45 100644
--- a/media/libaaudio/src/binding/IAAudioService.h
+++ b/media/libaaudio/src/binding/IAAudioService.h
@@ -29,7 +29,6 @@
#include "binding/AAudioStreamRequest.h"
#include "binding/AAudioStreamConfiguration.h"
-
namespace android {
// Interface (our AIDL) - Shared by server and client
@@ -43,39 +42,39 @@
* @param configuration contains information about the created stream
* @return handle to the stream or a negative error
*/
- virtual aaudio_handle_t openStream(aaudio::AAudioStreamRequest &request,
+ virtual aaudio::aaudio_handle_t openStream(aaudio::AAudioStreamRequest &request,
aaudio::AAudioStreamConfiguration &configuration) = 0;
- virtual aaudio_result_t closeStream(aaudio_handle_t streamHandle) = 0;
+ virtual aaudio_result_t closeStream(aaudio::aaudio_handle_t streamHandle) = 0;
/* Get an immutable description of the in-memory queues
* used to communicate with the underlying HAL or Service.
*/
- virtual aaudio_result_t getStreamDescription(aaudio_handle_t streamHandle,
+ virtual aaudio_result_t getStreamDescription(aaudio::aaudio_handle_t streamHandle,
aaudio::AudioEndpointParcelable &parcelable) = 0;
/**
* Start the flow of data.
*/
- virtual aaudio_result_t startStream(aaudio_handle_t streamHandle) = 0;
+ virtual aaudio_result_t startStream(aaudio::aaudio_handle_t streamHandle) = 0;
/**
* Stop the flow of data such that start() can resume without loss of data.
*/
- virtual aaudio_result_t pauseStream(aaudio_handle_t streamHandle) = 0;
+ virtual aaudio_result_t pauseStream(aaudio::aaudio_handle_t streamHandle) = 0;
/**
* Discard any data held by the underlying HAL or Service.
*/
- virtual aaudio_result_t flushStream(aaudio_handle_t streamHandle) = 0;
+ virtual aaudio_result_t flushStream(aaudio::aaudio_handle_t streamHandle) = 0;
/**
* Manage the specified thread as a low latency audio thread.
*/
- virtual aaudio_result_t registerAudioThread(aaudio_handle_t streamHandle, pid_t clientThreadId,
- aaudio_nanoseconds_t periodNanoseconds) = 0;
+ virtual aaudio_result_t registerAudioThread(aaudio::aaudio_handle_t streamHandle, pid_t clientThreadId,
+ int64_t periodNanoseconds) = 0;
- virtual aaudio_result_t unregisterAudioThread(aaudio_handle_t streamHandle,
+ virtual aaudio_result_t unregisterAudioThread(aaudio::aaudio_handle_t streamHandle,
pid_t clientThreadId) = 0;
};
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();
};
diff --git a/media/libaaudio/src/core/AAudioAudio.cpp b/media/libaaudio/src/core/AAudioAudio.cpp
index 04dbda1..1208f66 100644
--- a/media/libaaudio/src/core/AAudioAudio.cpp
+++ b/media/libaaudio/src/core/AAudioAudio.cpp
@@ -32,18 +32,11 @@
using namespace aaudio;
-// This is not the maximum theoretic possible number of handles that the HandlerTracker
-// class could support; instead it is the maximum number of handles that we are configuring
-// for our HandleTracker instance (sHandleTracker).
-#define AAUDIO_MAX_HANDLES 64
// Macros for common code that includes a return.
// TODO Consider using do{}while(0) construct. I tried but it hung AndroidStudio
#define CONVERT_BUILDER_HANDLE_OR_RETURN() \
- convertAAudioBuilderToStreamBuilder(builder); \
- if (streamBuilder == nullptr) { \
- return AAUDIO_ERROR_INVALID_HANDLE; \
- }
+ convertAAudioBuilderToStreamBuilder(builder);
#define COMMON_GET_FROM_BUILDER_OR_RETURN(resultPtr) \
CONVERT_BUILDER_HANDLE_OR_RETURN() \
@@ -51,31 +44,6 @@
return AAUDIO_ERROR_NULL; \
}
-#define CONVERT_STREAM_HANDLE_OR_RETURN() \
- convertAAudioStreamToAudioStream(stream); \
- if (audioStream == nullptr) { \
- return AAUDIO_ERROR_INVALID_HANDLE; \
- }
-
-#define COMMON_GET_FROM_STREAM_OR_RETURN(resultPtr) \
- CONVERT_STREAM_HANDLE_OR_RETURN(); \
- if ((resultPtr) == nullptr) { \
- return AAUDIO_ERROR_NULL; \
- }
-
-// Static data.
-// TODO static constructors are discouraged, alternatives?
-static HandleTracker sHandleTracker(AAUDIO_MAX_HANDLES);
-
-typedef enum
-{
- AAUDIO_HANDLE_TYPE_STREAM,
- AAUDIO_HANDLE_TYPE_STREAM_BUILDER,
- AAUDIO_HANDLE_TYPE_COUNT
-} aaudio_handle_type_t;
-static_assert(AAUDIO_HANDLE_TYPE_COUNT <= HANDLE_TRACKER_MAX_TYPES, "Too many handle types.");
-
-
#define AAUDIO_CASE_ENUM(name) case name: return #name
AAUDIO_API const char * AAudio_convertResultToText(aaudio_result_t returnCode) {
@@ -104,6 +72,7 @@
AAUDIO_API const char * AAudio_convertStreamStateToText(aaudio_stream_state_t state) {
switch (state) {
AAUDIO_CASE_ENUM(AAUDIO_STREAM_STATE_UNINITIALIZED);
+ AAUDIO_CASE_ENUM(AAUDIO_STREAM_STATE_UNKNOWN);
AAUDIO_CASE_ENUM(AAUDIO_STREAM_STATE_OPEN);
AAUDIO_CASE_ENUM(AAUDIO_STREAM_STATE_STARTING);
AAUDIO_CASE_ENUM(AAUDIO_STREAM_STATE_STARTED);
@@ -123,157 +92,73 @@
static AudioStream *convertAAudioStreamToAudioStream(AAudioStream stream)
{
- return (AudioStream *) sHandleTracker.get(AAUDIO_HANDLE_TYPE_STREAM,
- (aaudio_handle_t) stream);
+ return (AudioStream *) stream;
}
static AudioStreamBuilder *convertAAudioBuilderToStreamBuilder(AAudioStreamBuilder builder)
{
- return (AudioStreamBuilder *) sHandleTracker.get(AAUDIO_HANDLE_TYPE_STREAM_BUILDER,
- (aaudio_handle_t) builder);
+ return (AudioStreamBuilder *) builder;
}
AAUDIO_API aaudio_result_t AAudio_createStreamBuilder(AAudioStreamBuilder *builder)
{
ALOGD("AAudio_createStreamBuilder(): check sHandleTracker.isInitialized ()");
- if (!sHandleTracker.isInitialized()) {
- return AAUDIO_ERROR_NO_MEMORY;
- }
AudioStreamBuilder *audioStreamBuilder = new AudioStreamBuilder();
if (audioStreamBuilder == nullptr) {
return AAUDIO_ERROR_NO_MEMORY;
}
- ALOGD("AAudio_createStreamBuilder(): created AudioStreamBuilder = %p", audioStreamBuilder);
- // TODO protect the put() with a Mutex
- AAudioStreamBuilder handle = sHandleTracker.put(AAUDIO_HANDLE_TYPE_STREAM_BUILDER,
- audioStreamBuilder);
- if (handle < 0) {
- delete audioStreamBuilder;
- return static_cast<aaudio_result_t>(handle);
- } else {
- *builder = handle;
- }
+ *builder = (AAudioStreamBuilder) audioStreamBuilder;
return AAUDIO_OK;
}
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_setDeviceId(AAudioStreamBuilder builder,
- aaudio_device_id_t deviceId)
+AAUDIO_API void AAudioStreamBuilder_setDeviceId(AAudioStreamBuilder builder,
+ int32_t deviceId)
{
- AudioStreamBuilder *streamBuilder = CONVERT_BUILDER_HANDLE_OR_RETURN();
+ AudioStreamBuilder *streamBuilder = convertAAudioBuilderToStreamBuilder(builder);;
streamBuilder->setDeviceId(deviceId);
- return AAUDIO_OK;
}
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_getDeviceId(AAudioStreamBuilder builder,
- aaudio_device_id_t *deviceId)
+AAUDIO_API void AAudioStreamBuilder_setSampleRate(AAudioStreamBuilder builder,
+ int32_t sampleRate)
{
- AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(deviceId);
- *deviceId = streamBuilder->getDeviceId();
- return AAUDIO_OK;
-}
-
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_setSampleRate(AAudioStreamBuilder builder,
- aaudio_sample_rate_t sampleRate)
-{
- AudioStreamBuilder *streamBuilder = CONVERT_BUILDER_HANDLE_OR_RETURN();
+ AudioStreamBuilder *streamBuilder = convertAAudioBuilderToStreamBuilder(builder);;
streamBuilder->setSampleRate(sampleRate);
- return AAUDIO_OK;
}
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_getSampleRate(AAudioStreamBuilder builder,
- aaudio_sample_rate_t *sampleRate)
-{
- AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(sampleRate);
- *sampleRate = streamBuilder->getSampleRate();
- return AAUDIO_OK;
-}
-
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_setSamplesPerFrame(AAudioStreamBuilder builder,
+AAUDIO_API void AAudioStreamBuilder_setSamplesPerFrame(AAudioStreamBuilder builder,
int32_t samplesPerFrame)
{
- AudioStreamBuilder *streamBuilder = CONVERT_BUILDER_HANDLE_OR_RETURN();
+ AudioStreamBuilder *streamBuilder = convertAAudioBuilderToStreamBuilder(builder);;
streamBuilder->setSamplesPerFrame(samplesPerFrame);
- return AAUDIO_OK;
}
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_getSamplesPerFrame(AAudioStreamBuilder builder,
- int32_t *samplesPerFrame)
-{
- AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(samplesPerFrame);
- *samplesPerFrame = streamBuilder->getSamplesPerFrame();
- return AAUDIO_OK;
-}
-
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_setDirection(AAudioStreamBuilder builder,
+AAUDIO_API void AAudioStreamBuilder_setDirection(AAudioStreamBuilder builder,
aaudio_direction_t direction)
{
- AudioStreamBuilder *streamBuilder = CONVERT_BUILDER_HANDLE_OR_RETURN();
+ AudioStreamBuilder *streamBuilder = convertAAudioBuilderToStreamBuilder(builder);;
streamBuilder->setDirection(direction);
- return AAUDIO_OK;
}
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_getDirection(AAudioStreamBuilder builder,
- aaudio_direction_t *direction)
-{
- AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(direction);
- *direction = streamBuilder->getDirection();
- return AAUDIO_OK;
-}
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_setFormat(AAudioStreamBuilder builder,
+AAUDIO_API void AAudioStreamBuilder_setFormat(AAudioStreamBuilder builder,
aaudio_audio_format_t format)
{
- AudioStreamBuilder *streamBuilder = CONVERT_BUILDER_HANDLE_OR_RETURN();
+ AudioStreamBuilder *streamBuilder = convertAAudioBuilderToStreamBuilder(builder);;
streamBuilder->setFormat(format);
- return AAUDIO_OK;
}
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_getFormat(AAudioStreamBuilder builder,
- aaudio_audio_format_t *format)
-{
- AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(format);
- *format = streamBuilder->getFormat();
- return AAUDIO_OK;
-}
-
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_setSharingMode(AAudioStreamBuilder builder,
+AAUDIO_API void AAudioStreamBuilder_setSharingMode(AAudioStreamBuilder builder,
aaudio_sharing_mode_t sharingMode)
{
- AudioStreamBuilder *streamBuilder = CONVERT_BUILDER_HANDLE_OR_RETURN();
- if ((sharingMode < 0) || (sharingMode >= AAUDIO_SHARING_MODE_COUNT)) {
- return AAUDIO_ERROR_ILLEGAL_ARGUMENT;
- } else {
- streamBuilder->setSharingMode(sharingMode);
- return AAUDIO_OK;
- }
+ AudioStreamBuilder *streamBuilder = convertAAudioBuilderToStreamBuilder(builder);;
+ streamBuilder->setSharingMode(sharingMode);
}
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_getSharingMode(AAudioStreamBuilder builder,
- aaudio_sharing_mode_t *sharingMode)
+AAUDIO_API void AAudioStreamBuilder_setBufferCapacityInFrames(AAudioStreamBuilder builder,
+ int32_t frames)
{
- AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(sharingMode);
- *sharingMode = streamBuilder->getSharingMode();
- return AAUDIO_OK;
-}
-
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_setBufferCapacity(AAudioStreamBuilder builder,
- aaudio_size_frames_t frames)
-{
- AudioStreamBuilder *streamBuilder = CONVERT_BUILDER_HANDLE_OR_RETURN();
- if (frames < 0) {
- return AAUDIO_ERROR_ILLEGAL_ARGUMENT;
- } else {
- streamBuilder->setBufferCapacity(frames);
- return AAUDIO_OK;
- }
-}
-
-AAUDIO_API aaudio_result_t AAudioStreamBuilder_getBufferCapacity(AAudioStreamBuilder builder,
- aaudio_size_frames_t *frames)
-{
- AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(frames);
- *frames = streamBuilder->getBufferCapacity();
- return AAUDIO_OK;
+ AudioStreamBuilder *streamBuilder = convertAAudioBuilderToStreamBuilder(builder);;
+ streamBuilder->setBufferCapacity(frames);
}
static aaudio_result_t AAudioInternal_openStream(AudioStreamBuilder *streamBuilder,
@@ -284,14 +169,7 @@
if (result != AAUDIO_OK) {
return result;
} else {
- // Create a handle for referencing the object.
- // TODO protect the put() with a Mutex
- AAudioStream handle = sHandleTracker.put(AAUDIO_HANDLE_TYPE_STREAM, audioStream);
- if (handle < 0) {
- delete audioStream;
- return static_cast<aaudio_result_t>(handle);
- }
- *streamPtr = handle;
+ *streamPtr = (AAudioStream) audioStream;
return AAUDIO_OK;
}
}
@@ -299,15 +177,14 @@
AAUDIO_API aaudio_result_t AAudioStreamBuilder_openStream(AAudioStreamBuilder builder,
AAudioStream *streamPtr)
{
- ALOGD("AAudioStreamBuilder_openStream(): builder = 0x%08X", builder);
+ ALOGD("AAudioStreamBuilder_openStream(): builder = %p", builder);
AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(streamPtr);
return AAudioInternal_openStream(streamBuilder, streamPtr);
}
AAUDIO_API aaudio_result_t AAudioStreamBuilder_delete(AAudioStreamBuilder builder)
{
- AudioStreamBuilder *streamBuilder = (AudioStreamBuilder *)
- sHandleTracker.remove(AAUDIO_HANDLE_TYPE_STREAM_BUILDER, builder);
+ AudioStreamBuilder *streamBuilder = convertAAudioBuilderToStreamBuilder(builder);
if (streamBuilder != nullptr) {
delete streamBuilder;
return AAUDIO_OK;
@@ -317,9 +194,8 @@
AAUDIO_API aaudio_result_t AAudioStream_close(AAudioStream stream)
{
- AudioStream *audioStream = (AudioStream *)
- sHandleTracker.remove(AAUDIO_HANDLE_TYPE_STREAM, (aaudio_handle_t)stream);
- ALOGD("AAudioStream_close(0x%08X), audioStream = %p", stream, audioStream);
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ ALOGD("AAudioStream_close(%p)", stream);
if (audioStream != nullptr) {
audioStream->close();
delete audioStream;
@@ -330,39 +206,39 @@
AAUDIO_API aaudio_result_t AAudioStream_requestStart(AAudioStream stream)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
- ALOGD("AAudioStream_requestStart(0x%08X), audioStream = %p", stream, audioStream);
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ ALOGD("AAudioStream_requestStart(%p)", stream);
return audioStream->requestStart();
}
AAUDIO_API aaudio_result_t AAudioStream_requestPause(AAudioStream stream)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
- ALOGD("AAudioStream_requestPause(0x%08X), audioStream = %p", stream, audioStream);
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ ALOGD("AAudioStream_requestPause(%p)", stream);
return audioStream->requestPause();
}
AAUDIO_API aaudio_result_t AAudioStream_requestFlush(AAudioStream stream)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
- ALOGD("AAudioStream_requestFlush(0x%08X), audioStream = %p", stream, audioStream);
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ ALOGD("AAudioStream_requestFlush(%p)", stream);
return audioStream->requestFlush();
}
AAUDIO_API aaudio_result_t AAudioStream_requestStop(AAudioStream stream)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
- ALOGD("AAudioStream_requestStop(0x%08X), audioStream = %p", stream, audioStream);
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ ALOGD("AAudioStream_requestStop(%p)", stream);
return audioStream->requestStop();
}
AAUDIO_API aaudio_result_t AAudioStream_waitForStateChange(AAudioStream stream,
aaudio_stream_state_t inputState,
aaudio_stream_state_t *nextState,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int64_t timeoutNanoseconds)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
return audioStream->waitForStateChange(inputState, nextState, timeoutNanoseconds);
}
@@ -372,10 +248,10 @@
AAUDIO_API aaudio_result_t AAudioStream_read(AAudioStream stream,
void *buffer,
- aaudio_size_frames_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int32_t numFrames,
+ int64_t timeoutNanoseconds)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
if (buffer == nullptr) {
return AAUDIO_ERROR_NULL;
}
@@ -393,10 +269,10 @@
AAUDIO_API aaudio_result_t AAudioStream_write(AAudioStream stream,
const void *buffer,
- aaudio_size_frames_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int32_t numFrames,
+ int64_t timeoutNanoseconds)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
if (buffer == nullptr) {
return AAUDIO_ERROR_NULL;
}
@@ -417,18 +293,18 @@
// ============================================================
AAUDIO_API aaudio_result_t AAudioStream_createThread(AAudioStream stream,
- aaudio_nanoseconds_t periodNanoseconds,
+ int64_t periodNanoseconds,
aaudio_audio_thread_proc_t *threadProc, void *arg)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
return audioStream->createThread(periodNanoseconds, threadProc, arg);
}
AAUDIO_API aaudio_result_t AAudioStream_joinThread(AAudioStream stream,
void **returnArg,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int64_t timeoutNanoseconds)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
return audioStream->joinThread(returnArg, timeoutNanoseconds);
}
@@ -436,147 +312,104 @@
// Stream - queries
// ============================================================
-// TODO Use aaudio_clockid_t all the way down through the C++ streams.
-static clockid_t AAudioConvert_fromAAudioClockId(aaudio_clockid_t clockid)
+AAUDIO_API int32_t AAudioStream_getSampleRate(AAudioStream stream)
{
- clockid_t hostClockId;
- switch (clockid) {
- case AAUDIO_CLOCK_MONOTONIC:
- hostClockId = CLOCK_MONOTONIC;
- break;
- case AAUDIO_CLOCK_BOOTTIME:
- hostClockId = CLOCK_BOOTTIME;
- break;
- default:
- hostClockId = 0; // TODO review
- }
- return hostClockId;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getSampleRate();
}
-aaudio_nanoseconds_t AAudio_getNanoseconds(aaudio_clockid_t clockid)
+AAUDIO_API int32_t AAudioStream_getSamplesPerFrame(AAudioStream stream)
{
- clockid_t hostClockId = AAudioConvert_fromAAudioClockId(clockid);
- return AudioClock::getNanoseconds(hostClockId);
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getSamplesPerFrame();
}
-AAUDIO_API aaudio_result_t AAudioStream_getSampleRate(AAudioStream stream, aaudio_sample_rate_t *sampleRate)
+AAUDIO_API aaudio_stream_state_t AAudioStream_getState(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(sampleRate);
- *sampleRate = audioStream->getSampleRate();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getState();
}
-AAUDIO_API aaudio_result_t AAudioStream_getSamplesPerFrame(AAudioStream stream, int32_t *samplesPerFrame)
+AAUDIO_API aaudio_audio_format_t AAudioStream_getFormat(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(samplesPerFrame);
- *samplesPerFrame = audioStream->getSamplesPerFrame();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getFormat();
}
-AAUDIO_API aaudio_result_t AAudioStream_getState(AAudioStream stream, aaudio_stream_state_t *state)
+AAUDIO_API aaudio_result_t AAudioStream_setBufferSizeInFrames(AAudioStream stream,
+ int32_t requestedFrames)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(state);
- *state = audioStream->getState();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->setBufferSize(requestedFrames);
}
-AAUDIO_API aaudio_result_t AAudioStream_getFormat(AAudioStream stream, aaudio_audio_format_t *format)
+AAUDIO_API int32_t AAudioStream_getBufferSizeInFrames(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(format);
- *format = audioStream->getFormat();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getBufferSize();
}
-AAUDIO_API aaudio_result_t AAudioStream_setBufferSize(AAudioStream stream,
- aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames)
+AAUDIO_API aaudio_direction_t AAudioStream_getDirection(AAudioStream stream)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
- return audioStream->setBufferSize(requestedFrames, actualFrames);
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getDirection();
}
-AAUDIO_API aaudio_result_t AAudioStream_getBufferSize(AAudioStream stream, aaudio_size_frames_t *frames)
+AAUDIO_API int32_t AAudioStream_getFramesPerBurst(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(frames);
- *frames = audioStream->getBufferSize();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getFramesPerBurst();
}
-AAUDIO_API aaudio_result_t AAudioStream_getDirection(AAudioStream stream, int32_t *direction)
+AAUDIO_API int32_t AAudioStream_getBufferCapacityInFrames(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(direction);
- *direction = audioStream->getDirection();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getBufferCapacity();
}
-AAUDIO_API aaudio_result_t AAudioStream_getFramesPerBurst(AAudioStream stream,
- aaudio_size_frames_t *framesPerBurst)
+AAUDIO_API int32_t AAudioStream_getXRunCount(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(framesPerBurst);
- *framesPerBurst = audioStream->getFramesPerBurst();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getXRunCount();
}
-AAUDIO_API aaudio_result_t AAudioStream_getBufferCapacity(AAudioStream stream,
- aaudio_size_frames_t *capacity)
+AAUDIO_API int32_t AAudioStream_getDeviceId(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(capacity);
- *capacity = audioStream->getBufferCapacity();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getDeviceId();
}
-AAUDIO_API aaudio_result_t AAudioStream_getXRunCount(AAudioStream stream, int32_t *xRunCount)
+AAUDIO_API aaudio_sharing_mode_t AAudioStream_getSharingMode(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(xRunCount);
- *xRunCount = audioStream->getXRunCount();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getSharingMode();
}
-AAUDIO_API aaudio_result_t AAudioStream_getDeviceId(AAudioStream stream,
- aaudio_device_id_t *deviceId)
+AAUDIO_API int64_t AAudioStream_getFramesWritten(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(deviceId);
- *deviceId = audioStream->getDeviceId();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getFramesWritten();
}
-AAUDIO_API aaudio_result_t AAudioStream_getSharingMode(AAudioStream stream,
- aaudio_sharing_mode_t *sharingMode)
+AAUDIO_API int64_t AAudioStream_getFramesRead(AAudioStream stream)
{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(sharingMode);
- *sharingMode = audioStream->getSharingMode();
- return AAUDIO_OK;
-}
-
-AAUDIO_API aaudio_result_t AAudioStream_getFramesWritten(AAudioStream stream,
- aaudio_position_frames_t *frames)
-{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(frames);
- *frames = audioStream->getFramesWritten();
- return AAUDIO_OK;
-}
-
-AAUDIO_API aaudio_result_t AAudioStream_getFramesRead(AAudioStream stream, aaudio_position_frames_t *frames)
-{
- AudioStream *audioStream = COMMON_GET_FROM_STREAM_OR_RETURN(frames);
- *frames = audioStream->getFramesRead();
- return AAUDIO_OK;
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
+ return audioStream->getFramesRead();
}
AAUDIO_API aaudio_result_t AAudioStream_getTimestamp(AAudioStream stream,
- aaudio_clockid_t clockid,
- aaudio_position_frames_t *framePosition,
- aaudio_nanoseconds_t *timeNanoseconds)
+ clockid_t clockid,
+ int64_t *framePosition,
+ int64_t *timeNanoseconds)
{
- AudioStream *audioStream = CONVERT_STREAM_HANDLE_OR_RETURN();
+ AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
if (framePosition == nullptr) {
return AAUDIO_ERROR_NULL;
} else if (timeNanoseconds == nullptr) {
return AAUDIO_ERROR_NULL;
- } else if (clockid != AAUDIO_CLOCK_MONOTONIC && clockid != AAUDIO_CLOCK_BOOTTIME) {
+ } else if (clockid != CLOCK_MONOTONIC && clockid != CLOCK_BOOTTIME) {
return AAUDIO_ERROR_ILLEGAL_ARGUMENT;
}
- clockid_t hostClockId = AAudioConvert_fromAAudioClockId(clockid);
- return audioStream->getTimestamp(hostClockId, framePosition, timeNanoseconds);
+ return audioStream->getTimestamp(clockid, framePosition, timeNanoseconds);
}
diff --git a/media/libaaudio/src/core/AudioStream.cpp b/media/libaaudio/src/core/AudioStream.cpp
index 77d3cc0..c4962ee 100644
--- a/media/libaaudio/src/core/AudioStream.cpp
+++ b/media/libaaudio/src/core/AudioStream.cpp
@@ -52,7 +52,7 @@
aaudio_result_t AudioStream::waitForStateTransition(aaudio_stream_state_t startingState,
aaudio_stream_state_t endingState,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int64_t timeoutNanoseconds)
{
aaudio_stream_state_t state = getState();
aaudio_stream_state_t nextState = state;
@@ -73,10 +73,10 @@
aaudio_result_t AudioStream::waitForStateChange(aaudio_stream_state_t currentState,
aaudio_stream_state_t *nextState,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int64_t timeoutNanoseconds)
{
// TODO replace this when similar functionality added to AudioTrack.cpp
- aaudio_nanoseconds_t durationNanos = 20 * AAUDIO_NANOS_PER_MILLISECOND;
+ int64_t durationNanos = 20 * AAUDIO_NANOS_PER_MILLISECOND;
aaudio_stream_state_t state = getState();
while (state == currentState && timeoutNanoseconds > 0) {
if (durationNanos > timeoutNanoseconds) {
@@ -120,7 +120,7 @@
return audioStream->wrapUserThread();
}
-aaudio_result_t AudioStream::createThread(aaudio_nanoseconds_t periodNanoseconds,
+aaudio_result_t AudioStream::createThread(int64_t periodNanoseconds,
aaudio_audio_thread_proc_t *threadProc,
void* threadArg)
{
@@ -144,7 +144,7 @@
}
}
-aaudio_result_t AudioStream::joinThread(void** returnArg, aaudio_nanoseconds_t timeoutNanoseconds)
+aaudio_result_t AudioStream::joinThread(void** returnArg, int64_t timeoutNanoseconds)
{
if (!mHasThread) {
return AAUDIO_ERROR_INVALID_STATE;
diff --git a/media/libaaudio/src/core/AudioStream.h b/media/libaaudio/src/core/AudioStream.h
index acfed97..f5f9d28 100644
--- a/media/libaaudio/src/core/AudioStream.h
+++ b/media/libaaudio/src/core/AudioStream.h
@@ -52,8 +52,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) = 0;
+ int64_t *framePosition,
+ int64_t *timeNanoseconds) = 0;
virtual aaudio_result_t updateState() = 0;
@@ -63,7 +63,7 @@
virtual aaudio_result_t waitForStateChange(aaudio_stream_state_t currentState,
aaudio_stream_state_t *nextState,
- aaudio_nanoseconds_t timeoutNanoseconds);
+ int64_t timeoutNanoseconds);
/**
* Open the stream using the parameters in the builder.
@@ -79,16 +79,15 @@
return AAUDIO_OK;
}
- virtual aaudio_result_t setBufferSize(aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames) {
+ virtual aaudio_result_t setBufferSize(int32_t requestedFrames) {
return AAUDIO_ERROR_UNIMPLEMENTED;
}
- virtual aaudio_result_t createThread(aaudio_nanoseconds_t periodNanoseconds,
+ virtual aaudio_result_t createThread(int64_t periodNanoseconds,
aaudio_audio_thread_proc_t *threadProc,
void *threadArg);
- virtual aaudio_result_t joinThread(void **returnArg, aaudio_nanoseconds_t timeoutNanoseconds);
+ virtual aaudio_result_t joinThread(void **returnArg, int64_t timeoutNanoseconds);
virtual aaudio_result_t registerThread() {
return AAUDIO_OK;
@@ -106,19 +105,19 @@
// ============== Queries ===========================
- virtual aaudio_stream_state_t getState() const {
+ aaudio_stream_state_t getState() const {
return mState;
}
- virtual aaudio_size_frames_t getBufferSize() const {
+ virtual int32_t getBufferSize() const {
return AAUDIO_ERROR_UNIMPLEMENTED;
}
- virtual aaudio_size_frames_t getBufferCapacity() const {
+ virtual int32_t getBufferCapacity() const {
return AAUDIO_ERROR_UNIMPLEMENTED;
}
- virtual aaudio_size_frames_t getFramesPerBurst() const {
+ virtual int32_t getFramesPerBurst() const {
return AAUDIO_ERROR_UNIMPLEMENTED;
}
@@ -142,7 +141,7 @@
return mSamplesPerFrame;
}
- aaudio_device_id_t getDeviceId() const {
+ int32_t getDeviceId() const {
return mDeviceId;
}
@@ -154,19 +153,19 @@
return mDirection;
}
- aaudio_size_bytes_t getBytesPerFrame() const {
+ int32_t getBytesPerFrame() const {
return mSamplesPerFrame * getBytesPerSample();
}
- aaudio_size_bytes_t getBytesPerSample() const {
+ int32_t getBytesPerSample() const {
return AAudioConvert_formatToSizeInBytes(mFormat);
}
- virtual aaudio_position_frames_t getFramesWritten() {
+ virtual int64_t getFramesWritten() {
return mFramesWritten.get();
}
- virtual aaudio_position_frames_t getFramesRead() {
+ virtual int64_t getFramesRead() {
return mFramesRead.get();
}
@@ -174,25 +173,25 @@
// ============== I/O ===========================
// A Stream will only implement read() or write() depending on its direction.
virtual aaudio_result_t write(const void *buffer,
- aaudio_size_frames_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds) {
+ int32_t numFrames,
+ int64_t timeoutNanoseconds) {
return AAUDIO_ERROR_UNIMPLEMENTED;
}
virtual aaudio_result_t read(void *buffer,
- aaudio_size_frames_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds) {
+ int32_t numFrames,
+ int64_t timeoutNanoseconds) {
return AAUDIO_ERROR_UNIMPLEMENTED;
}
protected:
- virtual aaudio_position_frames_t incrementFramesWritten(aaudio_size_frames_t frames) {
- return static_cast<aaudio_position_frames_t>(mFramesWritten.increment(frames));
+ virtual int64_t incrementFramesWritten(int32_t frames) {
+ return static_cast<int64_t>(mFramesWritten.increment(frames));
}
- virtual aaudio_position_frames_t incrementFramesRead(aaudio_size_frames_t frames) {
- return static_cast<aaudio_position_frames_t>(mFramesRead.increment(frames));
+ virtual int64_t incrementFramesRead(int32_t frames) {
+ return static_cast<int64_t>(mFramesRead.increment(frames));
}
/**
@@ -202,13 +201,13 @@
* or AAUDIO_ERROR_TIMEOUT
*/
virtual aaudio_result_t waitForStateTransition(aaudio_stream_state_t startingState,
- aaudio_stream_state_t endingState,
- aaudio_nanoseconds_t timeoutNanoseconds);
+ aaudio_stream_state_t endingState,
+ int64_t timeoutNanoseconds);
/**
* This should not be called after the open() call.
*/
- void setSampleRate(aaudio_sample_rate_t sampleRate) {
+ void setSampleRate(int32_t sampleRate) {
mSampleRate = sampleRate;
}
@@ -243,33 +242,33 @@
MonotonicCounter mFramesWritten;
MonotonicCounter mFramesRead;
- void setPeriodNanoseconds(aaudio_nanoseconds_t periodNanoseconds) {
+ void setPeriodNanoseconds(int64_t periodNanoseconds) {
mPeriodNanoseconds.store(periodNanoseconds, std::memory_order_release);
}
- aaudio_nanoseconds_t getPeriodNanoseconds() {
+ int64_t getPeriodNanoseconds() {
return mPeriodNanoseconds.load(std::memory_order_acquire);
}
private:
// These do not change after open().
- int32_t mSamplesPerFrame = AAUDIO_UNSPECIFIED;
- aaudio_sample_rate_t mSampleRate = AAUDIO_UNSPECIFIED;
- aaudio_stream_state_t mState = AAUDIO_STREAM_STATE_UNINITIALIZED;
- aaudio_device_id_t mDeviceId = AAUDIO_UNSPECIFIED;
+ int32_t mSamplesPerFrame = AAUDIO_UNSPECIFIED;
+ int32_t mSampleRate = AAUDIO_UNSPECIFIED;
+ int32_t mDeviceId = AAUDIO_UNSPECIFIED;
aaudio_sharing_mode_t mSharingMode = AAUDIO_SHARING_MODE_SHARED;
aaudio_audio_format_t mFormat = AAUDIO_FORMAT_UNSPECIFIED;
aaudio_direction_t mDirection = AAUDIO_DIRECTION_OUTPUT;
+ aaudio_stream_state_t mState = AAUDIO_STREAM_STATE_UNINITIALIZED;
// background thread ----------------------------------
- bool mHasThread = false;
- pthread_t mThread; // initialized in constructor
+ bool mHasThread = false;
+ pthread_t mThread; // initialized in constructor
// These are set by the application thread and then read by the audio pthread.
- std::atomic<aaudio_nanoseconds_t> mPeriodNanoseconds; // for tuning SCHED_FIFO threads
+ std::atomic<int64_t> mPeriodNanoseconds; // for tuning SCHED_FIFO threads
// TODO make atomic?
aaudio_audio_thread_proc_t* mThreadProc = nullptr;
- void* mThreadArg = nullptr;
+ void* mThreadArg = nullptr;
aaudio_result_t mThreadRegistrationResult = AAUDIO_OK;
diff --git a/media/libaaudio/src/core/AudioStreamBuilder.h b/media/libaaudio/src/core/AudioStreamBuilder.h
index f366688..7b5f35c 100644
--- a/media/libaaudio/src/core/AudioStreamBuilder.h
+++ b/media/libaaudio/src/core/AudioStreamBuilder.h
@@ -56,11 +56,11 @@
return this;
}
- aaudio_sample_rate_t getSampleRate() const {
+ int32_t getSampleRate() const {
return mSampleRate;
}
- AudioStreamBuilder* setSampleRate(aaudio_sample_rate_t sampleRate) {
+ AudioStreamBuilder* setSampleRate(int32_t sampleRate) {
mSampleRate = sampleRate;
return this;
}
@@ -83,20 +83,20 @@
return this;
}
- aaudio_size_frames_t getBufferCapacity() const {
+ int32_t getBufferCapacity() const {
return mBufferCapacity;
}
- AudioStreamBuilder* setBufferCapacity(aaudio_size_frames_t frames) {
+ AudioStreamBuilder* setBufferCapacity(int32_t frames) {
mBufferCapacity = frames;
return this;
}
- aaudio_device_id_t getDeviceId() const {
+ int32_t getDeviceId() const {
return mDeviceId;
}
- AudioStreamBuilder* setDeviceId(aaudio_device_id_t deviceId) {
+ AudioStreamBuilder* setDeviceId(int32_t deviceId) {
mDeviceId = deviceId;
return this;
}
@@ -105,12 +105,12 @@
private:
int32_t mSamplesPerFrame = AAUDIO_UNSPECIFIED;
- aaudio_sample_rate_t mSampleRate = AAUDIO_UNSPECIFIED;
- aaudio_device_id_t mDeviceId = AAUDIO_DEVICE_UNSPECIFIED;
+ int32_t mSampleRate = AAUDIO_UNSPECIFIED;
+ int32_t mDeviceId = AAUDIO_DEVICE_UNSPECIFIED;
aaudio_sharing_mode_t mSharingMode = AAUDIO_SHARING_MODE_SHARED;
aaudio_audio_format_t mFormat = AAUDIO_FORMAT_UNSPECIFIED;
aaudio_direction_t mDirection = AAUDIO_DIRECTION_OUTPUT;
- aaudio_size_frames_t mBufferCapacity = AAUDIO_UNSPECIFIED;
+ int32_t mBufferCapacity = AAUDIO_UNSPECIFIED;
};
} /* namespace aaudio */
diff --git a/media/libaaudio/src/legacy/AudioStreamRecord.cpp b/media/libaaudio/src/legacy/AudioStreamRecord.cpp
index 17d0a54..dd040a0 100644
--- a/media/libaaudio/src/legacy/AudioStreamRecord.cpp
+++ b/media/libaaudio/src/legacy/AudioStreamRecord.cpp
@@ -177,11 +177,11 @@
}
aaudio_result_t AudioStreamRecord::read(void *buffer,
- aaudio_size_frames_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int32_t numFrames,
+ int64_t timeoutNanoseconds)
{
- aaudio_size_frames_t bytesPerFrame = getBytesPerFrame();
- aaudio_size_bytes_t numBytes;
+ int32_t bytesPerFrame = getBytesPerFrame();
+ int32_t numBytes;
aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
if (result != AAUDIO_OK) {
return result;
@@ -195,25 +195,23 @@
} else if (bytesRead < 0) {
return AAudioConvert_androidToAAudioResult(bytesRead);
}
- aaudio_size_frames_t framesRead = (aaudio_size_frames_t)(bytesRead / bytesPerFrame);
+ int32_t framesRead = (int32_t)(bytesRead / bytesPerFrame);
return (aaudio_result_t) framesRead;
}
-aaudio_result_t AudioStreamRecord::setBufferSize(aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames)
+aaudio_result_t AudioStreamRecord::setBufferSize(int32_t requestedFrames)
{
- *actualFrames = getBufferCapacity();
- return AAUDIO_OK;
+ return getBufferSize();
}
-aaudio_size_frames_t AudioStreamRecord::getBufferSize() const
+int32_t AudioStreamRecord::getBufferSize() const
{
return getBufferCapacity(); // TODO implement in AudioRecord?
}
-aaudio_size_frames_t AudioStreamRecord::getBufferCapacity() const
+int32_t AudioStreamRecord::getBufferCapacity() const
{
- return static_cast<aaudio_size_frames_t>(mAudioRecord->frameCount());
+ return static_cast<int32_t>(mAudioRecord->frameCount());
}
int32_t AudioStreamRecord::getXRunCount() const
@@ -221,7 +219,7 @@
return AAUDIO_ERROR_UNIMPLEMENTED; // TODO implement when AudioRecord supports it
}
-aaudio_size_frames_t AudioStreamRecord::getFramesPerBurst() const
+int32_t AudioStreamRecord::getFramesPerBurst() const
{
return 192; // TODO add query to AudioRecord.cpp
}
diff --git a/media/libaaudio/src/legacy/AudioStreamRecord.h b/media/libaaudio/src/legacy/AudioStreamRecord.h
index a2ac9f3..c8d389b 100644
--- a/media/libaaudio/src/legacy/AudioStreamRecord.h
+++ b/media/libaaudio/src/legacy/AudioStreamRecord.h
@@ -44,25 +44,24 @@
virtual aaudio_result_t requestStop() override;
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 {
return AAUDIO_ERROR_UNIMPLEMENTED; // TODO
}
virtual aaudio_result_t read(void *buffer,
- aaudio_size_frames_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds) override;
+ int32_t numFrames,
+ 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 int32_t getXRunCount() const override;
- virtual aaudio_size_frames_t getFramesPerBurst() const override;
+ virtual int32_t getFramesPerBurst() const override;
virtual aaudio_result_t updateState() override;
@@ -70,7 +69,7 @@
android::sp<android::AudioRecord> mAudioRecord;
// TODO add 64-bit position reporting to AudioRecord and use it.
aaudio_wrapping_frames_t mPositionWhenStarting = 0;
- android::String16 mOpPackageName;
+ android::String16 mOpPackageName;
};
} /* namespace aaudio */
diff --git a/media/libaaudio/src/legacy/AudioStreamTrack.cpp b/media/libaaudio/src/legacy/AudioStreamTrack.cpp
index b7d8664..e0a04c3 100644
--- a/media/libaaudio/src/legacy/AudioStreamTrack.cpp
+++ b/media/libaaudio/src/legacy/AudioStreamTrack.cpp
@@ -221,11 +221,11 @@
}
aaudio_result_t AudioStreamTrack::write(const void *buffer,
- aaudio_size_frames_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds)
+ int32_t numFrames,
+ int64_t timeoutNanoseconds)
{
- aaudio_size_frames_t bytesPerFrame = getBytesPerFrame();
- aaudio_size_bytes_t numBytes;
+ int32_t bytesPerFrame = getBytesPerFrame();
+ int32_t numBytes;
aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
if (result != AAUDIO_OK) {
return result;
@@ -240,31 +240,29 @@
ALOGE("invalid write, returned %d", (int)bytesWritten);
return AAudioConvert_androidToAAudioResult(bytesWritten);
}
- aaudio_size_frames_t framesWritten = (aaudio_size_frames_t)(bytesWritten / bytesPerFrame);
+ int32_t framesWritten = (int32_t)(bytesWritten / bytesPerFrame);
incrementFramesWritten(framesWritten);
return framesWritten;
}
-aaudio_result_t AudioStreamTrack::setBufferSize(aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames)
+aaudio_result_t AudioStreamTrack::setBufferSize(int32_t requestedFrames)
{
ssize_t result = mAudioTrack->setBufferSizeInFrames(requestedFrames);
- if (result != OK) {
+ if (result < 0) {
return AAudioConvert_androidToAAudioResult(result);
} else {
- *actualFrames = result;
- return AAUDIO_OK;
+ return result;
}
}
-aaudio_size_frames_t AudioStreamTrack::getBufferSize() const
+int32_t AudioStreamTrack::getBufferSize() const
{
- return static_cast<aaudio_size_frames_t>(mAudioTrack->getBufferSizeInFrames());
+ return static_cast<int32_t>(mAudioTrack->getBufferSizeInFrames());
}
-aaudio_size_frames_t AudioStreamTrack::getBufferCapacity() const
+int32_t AudioStreamTrack::getBufferCapacity() const
{
- return static_cast<aaudio_size_frames_t>(mAudioTrack->frameCount());
+ return static_cast<int32_t>(mAudioTrack->frameCount());
}
int32_t AudioStreamTrack::getXRunCount() const
@@ -277,7 +275,7 @@
return 192; // TODO add query to AudioTrack.cpp
}
-aaudio_position_frames_t AudioStreamTrack::getFramesRead() {
+int64_t AudioStreamTrack::getFramesRead() {
aaudio_wrapping_frames_t position;
status_t result;
switch (getState()) {
diff --git a/media/libaaudio/src/legacy/AudioStreamTrack.h b/media/libaaudio/src/legacy/AudioStreamTrack.h
index 73d0cac..1de07ce 100644
--- a/media/libaaudio/src/legacy/AudioStreamTrack.h
+++ b/media/libaaudio/src/legacy/AudioStreamTrack.h
@@ -46,31 +46,30 @@
virtual aaudio_result_t requestStop() override;
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 {
return AAUDIO_ERROR_UNIMPLEMENTED; // TODO call getTimestamp(ExtendedTimestamp *timestamp);
}
virtual aaudio_result_t write(const void *buffer,
- aaudio_size_frames_t numFrames,
- aaudio_nanoseconds_t timeoutNanoseconds) override;
+ int32_t numFrames,
+ int64_t timeoutNanoseconds) override;
- virtual aaudio_result_t setBufferSize(aaudio_size_frames_t requestedFrames,
- aaudio_size_frames_t *actualFrames) override;
- virtual aaudio_size_frames_t getBufferSize() const override;
- virtual aaudio_size_frames_t getBufferCapacity() const override;
- virtual aaudio_size_frames_t getFramesPerBurst()const override;
+ virtual aaudio_result_t setBufferSize(int32_t requestedFrames) override;
+ virtual int32_t getBufferSize() const override;
+ virtual int32_t getBufferCapacity() const override;
+ virtual int32_t getFramesPerBurst()const override;
virtual int32_t getXRunCount() const override;
- virtual aaudio_position_frames_t getFramesRead() override;
+ virtual int64_t getFramesRead() override;
virtual aaudio_result_t updateState() override;
private:
android::sp<android::AudioTrack> mAudioTrack;
// TODO add 64-bit position reporting to AudioRecord and use it.
- aaudio_wrapping_frames_t mPositionWhenStarting = 0;
- aaudio_wrapping_frames_t mPositionWhenPausing = 0;
+ aaudio_wrapping_frames_t mPositionWhenStarting = 0;
+ aaudio_wrapping_frames_t mPositionWhenPausing = 0;
};
} /* namespace aaudio */
diff --git a/media/libaaudio/src/utility/AAudioUtilities.cpp b/media/libaaudio/src/utility/AAudioUtilities.cpp
index 34c1ae4..26fa75d 100644
--- a/media/libaaudio/src/utility/AAudioUtilities.cpp
+++ b/media/libaaudio/src/utility/AAudioUtilities.cpp
@@ -27,8 +27,8 @@
using namespace android;
-aaudio_size_bytes_t AAudioConvert_formatToSizeInBytes(aaudio_audio_format_t format) {
- aaudio_size_bytes_t size = AAUDIO_ERROR_ILLEGAL_ARGUMENT;
+int32_t AAudioConvert_formatToSizeInBytes(aaudio_audio_format_t format) {
+ int32_t size = AAUDIO_ERROR_ILLEGAL_ARGUMENT;
switch (format) {
case AAUDIO_FORMAT_PCM_I16:
size = sizeof(int16_t);
@@ -172,12 +172,12 @@
return aaudioFormat;
}
-aaudio_size_bytes_t AAudioConvert_framesToBytes(aaudio_size_frames_t numFrames,
- aaudio_size_bytes_t bytesPerFrame,
- aaudio_size_bytes_t *sizeInBytes) {
+int32_t AAudioConvert_framesToBytes(int32_t numFrames,
+ int32_t bytesPerFrame,
+ int32_t *sizeInBytes) {
// TODO implement more elegantly
const int32_t maxChannels = 256; // ridiculously large
- const aaudio_size_frames_t maxBytesPerFrame = maxChannels * sizeof(float);
+ const int32_t maxBytesPerFrame = maxChannels * sizeof(float);
// Prevent overflow by limiting multiplicands.
if (bytesPerFrame > maxBytesPerFrame || numFrames > (0x3FFFFFFF / maxBytesPerFrame)) {
ALOGE("size overflow, numFrames = %d, frameSize = %zd", numFrames, bytesPerFrame);
diff --git a/media/libaaudio/src/utility/AAudioUtilities.h b/media/libaaudio/src/utility/AAudioUtilities.h
index 38696df..d3b5ffe 100644
--- a/media/libaaudio/src/utility/AAudioUtilities.h
+++ b/media/libaaudio/src/utility/AAudioUtilities.h
@@ -46,9 +46,9 @@
* @param sizeInBytes total size in bytes
* @return AAUDIO_OK or negative error, eg. AAUDIO_ERROR_OUT_OF_RANGE
*/
-aaudio_size_bytes_t AAudioConvert_framesToBytes(aaudio_size_frames_t numFrames,
- aaudio_size_bytes_t bytesPerFrame,
- aaudio_size_bytes_t *sizeInBytes);
+int32_t AAudioConvert_framesToBytes(int32_t numFrames,
+ int32_t bytesPerFrame,
+ int32_t *sizeInBytes);
audio_format_t AAudioConvert_aaudioToAndroidDataFormat(aaudio_audio_format_t aaudio_format);
@@ -57,6 +57,6 @@
/**
* @return the size of a sample of the given format in bytes or AAUDIO_ERROR_ILLEGAL_ARGUMENT
*/
-aaudio_size_bytes_t AAudioConvert_formatToSizeInBytes(aaudio_audio_format_t format);
+int32_t AAudioConvert_formatToSizeInBytes(aaudio_audio_format_t format);
#endif //UTILITY_AAUDIO_UTILITIES_H
diff --git a/media/libaaudio/src/utility/AudioClock.h b/media/libaaudio/src/utility/AudioClock.h
index 9ac21d3..952c7b8 100644
--- a/media/libaaudio/src/utility/AudioClock.h
+++ b/media/libaaudio/src/utility/AudioClock.h
@@ -22,9 +22,15 @@
#include <aaudio/AAudioDefinitions.h>
+// Time conversion constants.
+#define AAUDIO_NANOS_PER_MICROSECOND ((int64_t)1000)
+#define AAUDIO_NANOS_PER_MILLISECOND (AAUDIO_NANOS_PER_MICROSECOND * 1000)
+#define AAUDIO_MILLIS_PER_SECOND 1000
+#define AAUDIO_NANOS_PER_SECOND (AAUDIO_NANOS_PER_MILLISECOND * AAUDIO_MILLIS_PER_SECOND)
+
class AudioClock {
public:
- static aaudio_nanoseconds_t getNanoseconds(clockid_t clockId = CLOCK_MONOTONIC) {
+ static int64_t getNanoseconds(clockid_t clockId = CLOCK_MONOTONIC) {
struct timespec time;
int result = clock_gettime(clockId, &time);
if (result < 0) {
@@ -42,7 +48,7 @@
* @param clockId CLOCK_MONOTONIC is default
* @return 0, a negative error, or 1 if the call is interrupted by a signal handler (EINTR)
*/
- static int sleepUntilNanoTime(aaudio_nanoseconds_t nanoTime,
+ static int sleepUntilNanoTime(int64_t nanoTime,
clockid_t clockId = CLOCK_MONOTONIC) {
if (nanoTime > 0) {
struct timespec time;
@@ -72,7 +78,7 @@
* @param clockId CLOCK_MONOTONIC is default
* @return 0, a negative error, or 1 if the call is interrupted by a signal handler (EINTR)
*/
- static int sleepForNanos(aaudio_nanoseconds_t nanoseconds, clockid_t clockId = CLOCK_MONOTONIC) {
+ static int sleepForNanos(int64_t nanoseconds, clockid_t clockId = CLOCK_MONOTONIC) {
if (nanoseconds > 0) {
struct timespec time;
time.tv_sec = nanoseconds / AAUDIO_NANOS_PER_SECOND;
diff --git a/media/libaaudio/src/utility/HandleTracker.h b/media/libaaudio/src/utility/HandleTracker.h
index c80860c..23a73ed 100644
--- a/media/libaaudio/src/utility/HandleTracker.h
+++ b/media/libaaudio/src/utility/HandleTracker.h
@@ -20,6 +20,7 @@
#include <stdint.h>
#include <utils/Mutex.h>
+typedef int32_t aaudio_handle_t;
typedef int32_t handle_tracker_type_t; // what kind of handle
typedef int32_t handle_tracker_slot_t; // index in allocation table
typedef int32_t handle_tracker_generation_t; // incremented when slot used