liboboe: rename Oboe to AAudio
All of the edits were done using scripts in media/liboboe/scripts.
The conversion is done using SED, which is called from
convert_oboe_aaudio.sh
The conversion can be reverted when debugging using revert_all_aaudio.sh
The string substitutions are in oboe_to_aaudio.sed
Bug: 34749573
Test: cts/tests/tests/nativemedia/aaudio
Change-Id: Ia10b34472a90df2652b87607c99156e9084e57aa
Signed-off-by: Phil Burk <philburk@google.com>
diff --git a/media/liboboe/src/legacy/OboeLegacy.h b/media/liboboe/src/legacy/AAudioLegacy.h
similarity index 83%
rename from media/liboboe/src/legacy/OboeLegacy.h
rename to media/liboboe/src/legacy/AAudioLegacy.h
index 6803837..2ceb7d4 100644
--- a/media/liboboe/src/legacy/OboeLegacy.h
+++ b/media/liboboe/src/legacy/AAudioLegacy.h
@@ -14,17 +14,17 @@
* limitations under the License.
*/
-#ifndef OBOE_LEGACY_H
-#define OBOE_LEGACY_H
+#ifndef AAUDIO_LEGACY_H
+#define AAUDIO_LEGACY_H
#include <stdint.h>
-#include <oboe/OboeAudio.h>
+#include <aaudio/AAudio.h>
/**
* Common code for legacy classes.
*/
/* AudioTrack uses a 32-bit frame counter that can wrap around in about a day. */
-typedef uint32_t oboe_wrapping_frames_t;
+typedef uint32_t aaudio_wrapping_frames_t;
-#endif /* OBOE_LEGACY_H */
+#endif /* AAUDIO_LEGACY_H */
diff --git a/media/liboboe/src/legacy/AudioStreamRecord.cpp b/media/liboboe/src/legacy/AudioStreamRecord.cpp
index bf4bd36..2d1785f 100644
--- a/media/liboboe/src/legacy/AudioStreamRecord.cpp
+++ b/media/liboboe/src/legacy/AudioStreamRecord.cpp
@@ -21,13 +21,13 @@
#include <stdint.h>
#include <utils/String16.h>
#include <media/AudioRecord.h>
-#include <oboe/OboeAudio.h>
+#include <aaudio/AAudio.h>
#include "AudioClock.h"
#include "AudioStreamRecord.h"
using namespace android;
-using namespace oboe;
+using namespace aaudio;
AudioStreamRecord::AudioStreamRecord()
: AudioStream()
@@ -36,24 +36,24 @@
AudioStreamRecord::~AudioStreamRecord()
{
- const oboe_stream_state_t state = getState();
- bool bad = !(state == OBOE_STREAM_STATE_UNINITIALIZED || state == OBOE_STREAM_STATE_CLOSED);
+ const aaudio_stream_state_t state = getState();
+ bool bad = !(state == AAUDIO_STREAM_STATE_UNINITIALIZED || state == AAUDIO_STREAM_STATE_CLOSED);
ALOGE_IF(bad, "stream not closed, in state %d", state);
}
-oboe_result_t AudioStreamRecord::open(const AudioStreamBuilder& builder)
+aaudio_result_t AudioStreamRecord::open(const AudioStreamBuilder& builder)
{
- oboe_result_t result = OBOE_OK;
+ aaudio_result_t result = AAUDIO_OK;
result = AudioStream::open(builder);
- if (result != OBOE_OK) {
+ if (result != AAUDIO_OK) {
return result;
}
// Try to create an AudioRecord
// TODO Support UNSPECIFIED in AudioTrack. For now, use stereo if unspecified.
- int32_t samplesPerFrame = (getSamplesPerFrame() == OBOE_UNSPECIFIED)
+ int32_t samplesPerFrame = (getSamplesPerFrame() == AAUDIO_UNSPECIFIED)
? 2 : getSamplesPerFrame();
audio_channel_mask_t channelMask = audio_channel_in_mask_from_count(samplesPerFrame);
@@ -61,9 +61,9 @@
audio_input_flags_t flags = (audio_input_flags_t) AUDIO_INPUT_FLAG_NONE;
// TODO implement an unspecified Android format then use that.
- audio_format_t format = (getFormat() == OBOE_UNSPECIFIED)
+ audio_format_t format = (getFormat() == AAUDIO_UNSPECIFIED)
? AUDIO_FORMAT_PCM_FLOAT
- : OboeConvert_oboeToAndroidDataFormat(getFormat());
+ : AAudioConvert_aaudioToAndroidDataFormat(getFormat());
mAudioRecord = new AudioRecord(
AUDIO_SOURCE_DEFAULT,
@@ -90,84 +90,84 @@
if (status != OK) {
close();
ALOGE("AudioStreamRecord::open(), initCheck() returned %d", status);
- return OboeConvert_androidToOboeResult(status);
+ return AAudioConvert_androidToAAudioResult(status);
}
// Get the actual rate.
setSampleRate(mAudioRecord->getSampleRate());
setSamplesPerFrame(mAudioRecord->channelCount());
- setFormat(OboeConvert_androidToOboeDataFormat(mAudioRecord->format()));
+ setFormat(AAudioConvert_androidToAAudioDataFormat(mAudioRecord->format()));
- setState(OBOE_STREAM_STATE_OPEN);
+ setState(AAUDIO_STREAM_STATE_OPEN);
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamRecord::close()
+aaudio_result_t AudioStreamRecord::close()
{
// TODO add close() or release() to AudioRecord API then call it from here
- if (getState() != OBOE_STREAM_STATE_CLOSED) {
+ if (getState() != AAUDIO_STREAM_STATE_CLOSED) {
mAudioRecord.clear();
- setState(OBOE_STREAM_STATE_CLOSED);
+ setState(AAUDIO_STREAM_STATE_CLOSED);
}
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamRecord::requestStart()
+aaudio_result_t AudioStreamRecord::requestStart()
{
if (mAudioRecord.get() == nullptr) {
- return OBOE_ERROR_INVALID_STATE;
+ return AAUDIO_ERROR_INVALID_STATE;
}
// Get current position so we can detect when the track is playing.
status_t err = mAudioRecord->getPosition(&mPositionWhenStarting);
if (err != OK) {
- return OboeConvert_androidToOboeResult(err);
+ return AAudioConvert_androidToAAudioResult(err);
}
err = mAudioRecord->start();
if (err != OK) {
- return OboeConvert_androidToOboeResult(err);
+ return AAudioConvert_androidToAAudioResult(err);
} else {
- setState(OBOE_STREAM_STATE_STARTING);
+ setState(AAUDIO_STREAM_STATE_STARTING);
}
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamRecord::requestPause()
+aaudio_result_t AudioStreamRecord::requestPause()
{
- return OBOE_ERROR_UNIMPLEMENTED;
+ return AAUDIO_ERROR_UNIMPLEMENTED;
}
-oboe_result_t AudioStreamRecord::requestFlush() {
- return OBOE_ERROR_UNIMPLEMENTED;
+aaudio_result_t AudioStreamRecord::requestFlush() {
+ return AAUDIO_ERROR_UNIMPLEMENTED;
}
-oboe_result_t AudioStreamRecord::requestStop() {
+aaudio_result_t AudioStreamRecord::requestStop() {
if (mAudioRecord.get() == nullptr) {
- return OBOE_ERROR_INVALID_STATE;
+ return AAUDIO_ERROR_INVALID_STATE;
}
- setState(OBOE_STREAM_STATE_STOPPING);
+ setState(AAUDIO_STREAM_STATE_STOPPING);
mAudioRecord->stop();
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamRecord::updateState()
+aaudio_result_t AudioStreamRecord::updateState()
{
- oboe_result_t result = OBOE_OK;
- oboe_wrapping_frames_t position;
+ aaudio_result_t result = AAUDIO_OK;
+ aaudio_wrapping_frames_t position;
status_t err;
switch (getState()) {
// TODO add better state visibility to AudioRecord
- case OBOE_STREAM_STATE_STARTING:
+ case AAUDIO_STREAM_STATE_STARTING:
err = mAudioRecord->getPosition(&position);
if (err != OK) {
- result = OboeConvert_androidToOboeResult(err);
+ result = AAudioConvert_androidToAAudioResult(err);
} else if (position != mPositionWhenStarting) {
- setState(OBOE_STREAM_STATE_STARTED);
+ setState(AAUDIO_STREAM_STATE_STARTED);
}
break;
- case OBOE_STREAM_STATE_STOPPING:
+ case AAUDIO_STREAM_STATE_STOPPING:
if (mAudioRecord->stopped()) {
- setState(OBOE_STREAM_STATE_STOPPED);
+ setState(AAUDIO_STREAM_STATE_STOPPED);
}
break;
default:
@@ -176,14 +176,14 @@
return result;
}
-oboe_result_t AudioStreamRecord::read(void *buffer,
- oboe_size_frames_t numFrames,
- oboe_nanoseconds_t timeoutNanoseconds)
+aaudio_result_t AudioStreamRecord::read(void *buffer,
+ aaudio_size_frames_t numFrames,
+ aaudio_nanoseconds_t timeoutNanoseconds)
{
- oboe_size_frames_t bytesPerFrame = getBytesPerFrame();
- oboe_size_bytes_t numBytes;
- oboe_result_t result = OboeConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
- if (result != OBOE_OK) {
+ aaudio_size_frames_t bytesPerFrame = getBytesPerFrame();
+ aaudio_size_bytes_t numBytes;
+ aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
+ if (result != AAUDIO_OK) {
return result;
}
@@ -193,35 +193,35 @@
if (bytesRead == WOULD_BLOCK) {
return 0;
} else if (bytesRead < 0) {
- return OboeConvert_androidToOboeResult(bytesRead);
+ return AAudioConvert_androidToAAudioResult(bytesRead);
}
- oboe_size_frames_t framesRead = (oboe_size_frames_t)(bytesRead / bytesPerFrame);
- return (oboe_result_t) framesRead;
+ aaudio_size_frames_t framesRead = (aaudio_size_frames_t)(bytesRead / bytesPerFrame);
+ return (aaudio_result_t) framesRead;
}
-oboe_result_t AudioStreamRecord::setBufferSize(oboe_size_frames_t requestedFrames,
- oboe_size_frames_t *actualFrames)
+aaudio_result_t AudioStreamRecord::setBufferSize(aaudio_size_frames_t requestedFrames,
+ aaudio_size_frames_t *actualFrames)
{
*actualFrames = getBufferCapacity();
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_size_frames_t AudioStreamRecord::getBufferSize() const
+aaudio_size_frames_t AudioStreamRecord::getBufferSize() const
{
return getBufferCapacity(); // TODO implement in AudioRecord?
}
-oboe_size_frames_t AudioStreamRecord::getBufferCapacity() const
+aaudio_size_frames_t AudioStreamRecord::getBufferCapacity() const
{
- return static_cast<oboe_size_frames_t>(mAudioRecord->frameCount());
+ return static_cast<aaudio_size_frames_t>(mAudioRecord->frameCount());
}
int32_t AudioStreamRecord::getXRunCount() const
{
- return OBOE_ERROR_UNIMPLEMENTED; // TODO implement when AudioRecord supports it
+ return AAUDIO_ERROR_UNIMPLEMENTED; // TODO implement when AudioRecord supports it
}
-oboe_size_frames_t AudioStreamRecord::getFramesPerBurst() const
+aaudio_size_frames_t AudioStreamRecord::getFramesPerBurst() const
{
return 192; // TODO add query to AudioRecord.cpp
}
diff --git a/media/liboboe/src/legacy/AudioStreamRecord.h b/media/liboboe/src/legacy/AudioStreamRecord.h
index a884ed2..a2ac9f3 100644
--- a/media/liboboe/src/legacy/AudioStreamRecord.h
+++ b/media/liboboe/src/legacy/AudioStreamRecord.h
@@ -18,13 +18,13 @@
#define LEGACY_AUDIO_STREAM_RECORD_H
#include <media/AudioRecord.h>
-#include <oboe/OboeAudio.h>
+#include <aaudio/AAudio.h>
#include "AudioStreamBuilder.h"
#include "AudioStream.h"
-#include "OboeLegacy.h"
+#include "AAudioLegacy.h"
-namespace oboe {
+namespace aaudio {
/**
* Internal stream that uses the legacy AudioTrack path.
@@ -35,44 +35,44 @@
virtual ~AudioStreamRecord();
- virtual oboe_result_t open(const AudioStreamBuilder & builder) override;
- virtual oboe_result_t close() override;
+ virtual aaudio_result_t open(const AudioStreamBuilder & builder) override;
+ virtual aaudio_result_t close() override;
- virtual oboe_result_t requestStart() override;
- virtual oboe_result_t requestPause() override;
- virtual oboe_result_t requestFlush() override;
- virtual oboe_result_t requestStop() override;
+ virtual aaudio_result_t requestStart() override;
+ virtual aaudio_result_t requestPause() override;
+ virtual aaudio_result_t requestFlush() override;
+ virtual aaudio_result_t requestStop() override;
- virtual oboe_result_t getTimestamp(clockid_t clockId,
- oboe_position_frames_t *framePosition,
- oboe_nanoseconds_t *timeNanoseconds) override {
- return OBOE_ERROR_UNIMPLEMENTED; // TODO
+ virtual aaudio_result_t getTimestamp(clockid_t clockId,
+ aaudio_position_frames_t *framePosition,
+ aaudio_nanoseconds_t *timeNanoseconds) override {
+ return AAUDIO_ERROR_UNIMPLEMENTED; // TODO
}
- virtual oboe_result_t read(void *buffer,
- oboe_size_frames_t numFrames,
- oboe_nanoseconds_t timeoutNanoseconds) override;
+ virtual aaudio_result_t read(void *buffer,
+ aaudio_size_frames_t numFrames,
+ aaudio_nanoseconds_t timeoutNanoseconds) override;
- virtual oboe_result_t setBufferSize(oboe_size_frames_t requestedFrames,
- oboe_size_frames_t *actualFrames) override;
+ virtual aaudio_result_t setBufferSize(aaudio_size_frames_t requestedFrames,
+ aaudio_size_frames_t *actualFrames) override;
- virtual oboe_size_frames_t getBufferSize() const override;
+ virtual aaudio_size_frames_t getBufferSize() const override;
- virtual oboe_size_frames_t getBufferCapacity() const override;
+ virtual aaudio_size_frames_t getBufferCapacity() const override;
virtual int32_t getXRunCount() const override;
- virtual oboe_size_frames_t getFramesPerBurst() const override;
+ virtual aaudio_size_frames_t getFramesPerBurst() const override;
- virtual oboe_result_t updateState() override;
+ virtual aaudio_result_t updateState() override;
private:
android::sp<android::AudioRecord> mAudioRecord;
// TODO add 64-bit position reporting to AudioRecord and use it.
- oboe_wrapping_frames_t mPositionWhenStarting = 0;
+ aaudio_wrapping_frames_t mPositionWhenStarting = 0;
android::String16 mOpPackageName;
};
-} /* namespace oboe */
+} /* namespace aaudio */
#endif /* LEGACY_AUDIO_STREAM_RECORD_H */
diff --git a/media/liboboe/src/legacy/AudioStreamTrack.cpp b/media/liboboe/src/legacy/AudioStreamTrack.cpp
index 291e56c..a60b5b4 100644
--- a/media/liboboe/src/legacy/AudioStreamTrack.cpp
+++ b/media/liboboe/src/legacy/AudioStreamTrack.cpp
@@ -21,13 +21,13 @@
#include <stdint.h>
#include <media/AudioTrack.h>
-#include <oboe/OboeAudio.h>
+#include <aaudio/AAudio.h>
#include "AudioClock.h"
#include "AudioStreamTrack.h"
using namespace android;
-using namespace oboe;
+using namespace aaudio;
/*
* Create a stream that uses the AudioTrack.
@@ -39,14 +39,14 @@
AudioStreamTrack::~AudioStreamTrack()
{
- const oboe_stream_state_t state = getState();
- bool bad = !(state == OBOE_STREAM_STATE_UNINITIALIZED || state == OBOE_STREAM_STATE_CLOSED);
+ const aaudio_stream_state_t state = getState();
+ bool bad = !(state == AAUDIO_STREAM_STATE_UNINITIALIZED || state == AAUDIO_STREAM_STATE_CLOSED);
ALOGE_IF(bad, "stream not closed, in state %d", state);
}
-oboe_result_t AudioStreamTrack::open(const AudioStreamBuilder& builder)
+aaudio_result_t AudioStreamTrack::open(const AudioStreamBuilder& builder)
{
- oboe_result_t result = OBOE_OK;
+ aaudio_result_t result = AAUDIO_OK;
result = AudioStream::open(builder);
if (result != OK) {
@@ -55,7 +55,7 @@
// Try to create an AudioTrack
// TODO Support UNSPECIFIED in AudioTrack. For now, use stereo if unspecified.
- int32_t samplesPerFrame = (getSamplesPerFrame() == OBOE_UNSPECIFIED)
+ int32_t samplesPerFrame = (getSamplesPerFrame() == AAUDIO_UNSPECIFIED)
? 2 : getSamplesPerFrame();
audio_channel_mask_t channelMask = audio_channel_out_mask_from_count(samplesPerFrame);
ALOGD("AudioStreamTrack::open(), samplesPerFrame = %d, channelMask = 0x%08x",
@@ -66,9 +66,9 @@
audio_output_flags_t flags = (audio_output_flags_t) AUDIO_OUTPUT_FLAG_FAST;
size_t frameCount = 0;
// TODO implement an unspecified AudioTrack format then use that.
- audio_format_t format = (getFormat() == OBOE_UNSPECIFIED)
+ audio_format_t format = (getFormat() == AAUDIO_UNSPECIFIED)
? AUDIO_FORMAT_PCM_FLOAT
- : OboeConvert_oboeToAndroidDataFormat(getFormat());
+ : AAudioConvert_aaudioToAndroidDataFormat(getFormat());
mAudioTrack = new AudioTrack(
(audio_stream_type_t) AUDIO_STREAM_MUSIC,
@@ -90,143 +90,143 @@
if (status != NO_ERROR) {
close();
ALOGE("AudioStreamTrack::open(), initCheck() returned %d", status);
- return OboeConvert_androidToOboeResult(status);
+ return AAudioConvert_androidToAAudioResult(status);
}
// Get the actual values from the AudioTrack.
setSamplesPerFrame(mAudioTrack->channelCount());
setSampleRate(mAudioTrack->getSampleRate());
- setFormat(OboeConvert_androidToOboeDataFormat(mAudioTrack->format()));
+ setFormat(AAudioConvert_androidToAAudioDataFormat(mAudioTrack->format()));
- setState(OBOE_STREAM_STATE_OPEN);
+ setState(AAUDIO_STREAM_STATE_OPEN);
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamTrack::close()
+aaudio_result_t AudioStreamTrack::close()
{
// TODO maybe add close() or release() to AudioTrack API then call it from here
- if (getState() != OBOE_STREAM_STATE_CLOSED) {
+ if (getState() != AAUDIO_STREAM_STATE_CLOSED) {
mAudioTrack.clear(); // TODO is this right?
- setState(OBOE_STREAM_STATE_CLOSED);
+ setState(AAUDIO_STREAM_STATE_CLOSED);
}
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamTrack::requestStart()
+aaudio_result_t AudioStreamTrack::requestStart()
{
if (mAudioTrack.get() == nullptr) {
- return OBOE_ERROR_INVALID_STATE;
+ return AAUDIO_ERROR_INVALID_STATE;
}
// Get current position so we can detect when the track is playing.
status_t err = mAudioTrack->getPosition(&mPositionWhenStarting);
if (err != OK) {
- return OboeConvert_androidToOboeResult(err);
+ return AAudioConvert_androidToAAudioResult(err);
}
err = mAudioTrack->start();
if (err != OK) {
- return OboeConvert_androidToOboeResult(err);
+ return AAudioConvert_androidToAAudioResult(err);
} else {
- setState(OBOE_STREAM_STATE_STARTING);
+ setState(AAUDIO_STREAM_STATE_STARTING);
}
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamTrack::requestPause()
+aaudio_result_t AudioStreamTrack::requestPause()
{
if (mAudioTrack.get() == nullptr) {
- return OBOE_ERROR_INVALID_STATE;
- } else if (getState() != OBOE_STREAM_STATE_STARTING
- && getState() != OBOE_STREAM_STATE_STARTED) {
- ALOGE("requestPause(), called when state is %s", Oboe_convertStreamStateToText(getState()));
- return OBOE_ERROR_INVALID_STATE;
+ return AAUDIO_ERROR_INVALID_STATE;
+ } else if (getState() != AAUDIO_STREAM_STATE_STARTING
+ && getState() != AAUDIO_STREAM_STATE_STARTED) {
+ ALOGE("requestPause(), called when state is %s", AAudio_convertStreamStateToText(getState()));
+ return AAUDIO_ERROR_INVALID_STATE;
}
- setState(OBOE_STREAM_STATE_PAUSING);
+ setState(AAUDIO_STREAM_STATE_PAUSING);
mAudioTrack->pause();
status_t err = mAudioTrack->getPosition(&mPositionWhenPausing);
if (err != OK) {
- return OboeConvert_androidToOboeResult(err);
+ return AAudioConvert_androidToAAudioResult(err);
}
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamTrack::requestFlush() {
+aaudio_result_t AudioStreamTrack::requestFlush() {
if (mAudioTrack.get() == nullptr) {
- return OBOE_ERROR_INVALID_STATE;
- } else if (getState() != OBOE_STREAM_STATE_PAUSED) {
- return OBOE_ERROR_INVALID_STATE;
+ return AAUDIO_ERROR_INVALID_STATE;
+ } else if (getState() != AAUDIO_STREAM_STATE_PAUSED) {
+ return AAUDIO_ERROR_INVALID_STATE;
}
- setState(OBOE_STREAM_STATE_FLUSHING);
+ setState(AAUDIO_STREAM_STATE_FLUSHING);
incrementFramesRead(getFramesWritten() - getFramesRead());
mAudioTrack->flush();
mFramesWritten.reset32();
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamTrack::requestStop() {
+aaudio_result_t AudioStreamTrack::requestStop() {
if (mAudioTrack.get() == nullptr) {
- return OBOE_ERROR_INVALID_STATE;
+ return AAUDIO_ERROR_INVALID_STATE;
}
- setState(OBOE_STREAM_STATE_STOPPING);
+ setState(AAUDIO_STREAM_STATE_STOPPING);
incrementFramesRead(getFramesWritten() - getFramesRead()); // TODO review
mAudioTrack->stop();
mFramesWritten.reset32();
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamTrack::updateState()
+aaudio_result_t AudioStreamTrack::updateState()
{
status_t err;
- oboe_wrapping_frames_t position;
+ aaudio_wrapping_frames_t position;
switch (getState()) {
// TODO add better state visibility to AudioTrack
- case OBOE_STREAM_STATE_STARTING:
+ case AAUDIO_STREAM_STATE_STARTING:
if (mAudioTrack->hasStarted()) {
- setState(OBOE_STREAM_STATE_STARTED);
+ setState(AAUDIO_STREAM_STATE_STARTED);
}
break;
- case OBOE_STREAM_STATE_PAUSING:
+ case AAUDIO_STREAM_STATE_PAUSING:
if (mAudioTrack->stopped()) {
err = mAudioTrack->getPosition(&position);
if (err != OK) {
- return OboeConvert_androidToOboeResult(err);
+ return AAudioConvert_androidToAAudioResult(err);
} else if (position == mPositionWhenPausing) {
// Has stream really stopped advancing?
- setState(OBOE_STREAM_STATE_PAUSED);
+ setState(AAUDIO_STREAM_STATE_PAUSED);
}
mPositionWhenPausing = position;
}
break;
- case OBOE_STREAM_STATE_FLUSHING:
+ case AAUDIO_STREAM_STATE_FLUSHING:
{
err = mAudioTrack->getPosition(&position);
if (err != OK) {
- return OboeConvert_androidToOboeResult(err);
+ return AAudioConvert_androidToAAudioResult(err);
} else if (position == 0) {
// Advance frames read to match written.
- setState(OBOE_STREAM_STATE_FLUSHED);
+ setState(AAUDIO_STREAM_STATE_FLUSHED);
}
}
break;
- case OBOE_STREAM_STATE_STOPPING:
+ case AAUDIO_STREAM_STATE_STOPPING:
if (mAudioTrack->stopped()) {
- setState(OBOE_STREAM_STATE_STOPPED);
+ setState(AAUDIO_STREAM_STATE_STOPPED);
}
break;
default:
break;
}
- return OBOE_OK;
+ return AAUDIO_OK;
}
-oboe_result_t AudioStreamTrack::write(const void *buffer,
- oboe_size_frames_t numFrames,
- oboe_nanoseconds_t timeoutNanoseconds)
+aaudio_result_t AudioStreamTrack::write(const void *buffer,
+ aaudio_size_frames_t numFrames,
+ aaudio_nanoseconds_t timeoutNanoseconds)
{
- oboe_size_frames_t bytesPerFrame = getBytesPerFrame();
- oboe_size_bytes_t numBytes;
- oboe_result_t result = OboeConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
- if (result != OBOE_OK) {
+ aaudio_size_frames_t bytesPerFrame = getBytesPerFrame();
+ aaudio_size_bytes_t numBytes;
+ aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
+ if (result != AAUDIO_OK) {
return result;
}
@@ -237,33 +237,33 @@
return 0;
} else if (bytesWritten < 0) {
ALOGE("invalid write, returned %d", (int)bytesWritten);
- return OboeConvert_androidToOboeResult(bytesWritten);
+ return AAudioConvert_androidToAAudioResult(bytesWritten);
}
- oboe_size_frames_t framesWritten = (oboe_size_frames_t)(bytesWritten / bytesPerFrame);
+ aaudio_size_frames_t framesWritten = (aaudio_size_frames_t)(bytesWritten / bytesPerFrame);
incrementFramesWritten(framesWritten);
return framesWritten;
}
-oboe_result_t AudioStreamTrack::setBufferSize(oboe_size_frames_t requestedFrames,
- oboe_size_frames_t *actualFrames)
+aaudio_result_t AudioStreamTrack::setBufferSize(aaudio_size_frames_t requestedFrames,
+ aaudio_size_frames_t *actualFrames)
{
ssize_t result = mAudioTrack->setBufferSizeInFrames(requestedFrames);
if (result != OK) {
- return OboeConvert_androidToOboeResult(result);
+ return AAudioConvert_androidToAAudioResult(result);
} else {
*actualFrames = result;
- return OBOE_OK;
+ return AAUDIO_OK;
}
}
-oboe_size_frames_t AudioStreamTrack::getBufferSize() const
+aaudio_size_frames_t AudioStreamTrack::getBufferSize() const
{
- return static_cast<oboe_size_frames_t>(mAudioTrack->getBufferSizeInFrames());
+ return static_cast<aaudio_size_frames_t>(mAudioTrack->getBufferSizeInFrames());
}
-oboe_size_frames_t AudioStreamTrack::getBufferCapacity() const
+aaudio_size_frames_t AudioStreamTrack::getBufferCapacity() const
{
- return static_cast<oboe_size_frames_t>(mAudioTrack->frameCount());
+ return static_cast<aaudio_size_frames_t>(mAudioTrack->frameCount());
}
int32_t AudioStreamTrack::getXRunCount() const
@@ -276,13 +276,13 @@
return 192; // TODO add query to AudioTrack.cpp
}
-oboe_position_frames_t AudioStreamTrack::getFramesRead() {
- oboe_wrapping_frames_t position;
+aaudio_position_frames_t AudioStreamTrack::getFramesRead() {
+ aaudio_wrapping_frames_t position;
status_t result;
switch (getState()) {
- case OBOE_STREAM_STATE_STARTING:
- case OBOE_STREAM_STATE_STARTED:
- case OBOE_STREAM_STATE_STOPPING:
+ case AAUDIO_STREAM_STATE_STARTING:
+ case AAUDIO_STREAM_STATE_STARTED:
+ case AAUDIO_STREAM_STATE_STOPPING:
result = mAudioTrack->getPosition(&position);
if (result == OK) {
mFramesRead.update32(position);
diff --git a/media/liboboe/src/legacy/AudioStreamTrack.h b/media/liboboe/src/legacy/AudioStreamTrack.h
index 0c41331..73d0cac 100644
--- a/media/liboboe/src/legacy/AudioStreamTrack.h
+++ b/media/liboboe/src/legacy/AudioStreamTrack.h
@@ -18,13 +18,13 @@
#define LEGACY_AUDIO_STREAM_TRACK_H
#include <media/AudioTrack.h>
-#include <oboe/OboeAudio.h>
+#include <aaudio/AAudio.h>
#include "AudioStreamBuilder.h"
#include "AudioStream.h"
-#include "OboeLegacy.h"
+#include "AAudioLegacy.h"
-namespace oboe {
+namespace aaudio {
/**
@@ -37,42 +37,42 @@
virtual ~AudioStreamTrack();
- virtual oboe_result_t open(const AudioStreamBuilder & builder) override;
- virtual oboe_result_t close() override;
+ virtual aaudio_result_t open(const AudioStreamBuilder & builder) override;
+ virtual aaudio_result_t close() override;
- virtual oboe_result_t requestStart() override;
- virtual oboe_result_t requestPause() override;
- virtual oboe_result_t requestFlush() override;
- virtual oboe_result_t requestStop() override;
+ virtual aaudio_result_t requestStart() override;
+ virtual aaudio_result_t requestPause() override;
+ virtual aaudio_result_t requestFlush() override;
+ virtual aaudio_result_t requestStop() override;
- virtual oboe_result_t getTimestamp(clockid_t clockId,
- oboe_position_frames_t *framePosition,
- oboe_nanoseconds_t *timeNanoseconds) override {
- return OBOE_ERROR_UNIMPLEMENTED; // TODO call getTimestamp(ExtendedTimestamp *timestamp);
+ virtual aaudio_result_t getTimestamp(clockid_t clockId,
+ aaudio_position_frames_t *framePosition,
+ aaudio_nanoseconds_t *timeNanoseconds) override {
+ return AAUDIO_ERROR_UNIMPLEMENTED; // TODO call getTimestamp(ExtendedTimestamp *timestamp);
}
- virtual oboe_result_t write(const void *buffer,
- oboe_size_frames_t numFrames,
- oboe_nanoseconds_t timeoutNanoseconds) override;
+ virtual aaudio_result_t write(const void *buffer,
+ aaudio_size_frames_t numFrames,
+ aaudio_nanoseconds_t timeoutNanoseconds) override;
- virtual oboe_result_t setBufferSize(oboe_size_frames_t requestedFrames,
- oboe_size_frames_t *actualFrames) override;
- virtual oboe_size_frames_t getBufferSize() const override;
- virtual oboe_size_frames_t getBufferCapacity() const override;
- virtual oboe_size_frames_t getFramesPerBurst()const 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 int32_t getXRunCount() const override;
- virtual oboe_position_frames_t getFramesRead() override;
+ virtual aaudio_position_frames_t getFramesRead() override;
- virtual oboe_result_t updateState() override;
+ virtual aaudio_result_t updateState() override;
private:
android::sp<android::AudioTrack> mAudioTrack;
// TODO add 64-bit position reporting to AudioRecord and use it.
- oboe_wrapping_frames_t mPositionWhenStarting = 0;
- oboe_wrapping_frames_t mPositionWhenPausing = 0;
+ aaudio_wrapping_frames_t mPositionWhenStarting = 0;
+ aaudio_wrapping_frames_t mPositionWhenPausing = 0;
};
-} /* namespace oboe */
+} /* namespace aaudio */
#endif /* LEGACY_AUDIO_STREAM_TRACK_H */
diff --git a/media/liboboe/src/legacy/README.md b/media/liboboe/src/legacy/README.md
index b51c44b..8805915 100644
--- a/media/liboboe/src/legacy/README.md
+++ b/media/liboboe/src/legacy/README.md
@@ -1,2 +1,2 @@
-The legacy folder contains the classes that implement Oboe AudioStream on top of
+The legacy folder contains the classes that implement AAudio AudioStream on top of
Android AudioTrack and AudioRecord.