diff --git a/media/liboboe/include/aaudio/AAudio.h b/media/liboboe/include/aaudio/AAudio.h
new file mode 100644
index 0000000..7324137
--- /dev/null
+++ b/media/liboboe/include/aaudio/AAudio.h
@@ -0,0 +1,574 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This is the 'C' ABI for AAudio.
+ */
+#ifndef AAUDIO_AAUDIO_H
+#define AAUDIO_AAUDIO_H
+
+#include "AAudioDefinitions.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef aaudio_handle_t AAudioStream;
+typedef aaudio_handle_t AAudioStreamBuilder;
+
+#define AAUDIO_STREAM_NONE         ((AAudioStream)AAUDIO_HANDLE_INVALID)
+#define AAUDIO_STREAM_BUILDER_NONE ((AAudioStreamBuilder)AAUDIO_HANDLE_INVALID)
+
+/* AAUDIO_API will probably get defined in a Makefile for a specific platform. */
+#ifndef AAUDIO_API
+#define AAUDIO_API /* for exporting symbols */
+#endif
+
+// ============================================================
+// Audio System
+// ============================================================
+
+/**
+ * @return time in the same clock domain as the timestamps
+ */
+AAUDIO_API aaudio_nanoseconds_t AAudio_getNanoseconds(aaudio_clockid_t clockid);
+
+/**
+ * The text is the ASCII symbol corresponding to the returnCode,
+ * or an English message saying the returnCode is unrecognized.
+ * This is intended for developers to use when debugging.
+ * It is not for display to users.
+ *
+ * @return pointer to a text representation of an AAudio result code.
+ */
+AAUDIO_API const char * AAudio_convertResultToText(aaudio_result_t returnCode);
+
+/**
+ * The text is the ASCII symbol corresponding to the stream state,
+ * or an English message saying the state is unrecognized.
+ * This is intended for developers to use when debugging.
+ * It is not for display to users.
+ *
+ * @return pointer to a text representation of an AAudio state.
+ */
+AAUDIO_API const char * AAudio_convertStreamStateToText(aaudio_stream_state_t state);
+
+// ============================================================
+// StreamBuilder
+// ============================================================
+
+/**
+ * Create a StreamBuilder that can be used to open a Stream.
+ *
+ * The deviceId is initially unspecified, meaning that the current default device will be used.
+ *
+ * The default direction is AAUDIO_DIRECTION_OUTPUT.
+ * The default sharing mode is AAUDIO_SHARING_MODE_LEGACY.
+ * The data format, samplesPerFrames and sampleRate are unspecified and will be
+ * chosen by the device when it is opened.
+ *
+ * AAudioStreamBuilder_delete() must be called when you are done using the builder.
+ */
+AAUDIO_API aaudio_result_t AAudio_createStreamBuilder(AAudioStreamBuilder *builder);
+
+/**
+ * Request an audio device identified device using an ID.
+ * The ID is platform specific.
+ * On Android, for example, the ID could be obtained from the Java AudioManager.
+ *
+ * By default, the primary device will be used.
+ *
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @param deviceId platform specific identifier or AAUDIO_DEVICE_UNSPECIFIED
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_setDeviceId(AAudioStreamBuilder builder,
+                                                     aaudio_device_id_t deviceId);
+/**
+ * Passes back requested device ID.
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_getDeviceId(AAudioStreamBuilder builder,
+                                                     aaudio_device_id_t *deviceId);
+
+/**
+ * Request a sample rate in Hz.
+ * The stream may be opened with a different sample rate.
+ * So the application should query for the actual rate after the stream is opened.
+ *
+ * Technically, this should be called the "frame rate" or "frames per second",
+ * because it refers to the number of complete frames transferred per second.
+ * But it is traditionally called "sample rate". Se we use that term.
+ *
+ * Default is AAUDIO_UNSPECIFIED.
+ *
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_setSampleRate(AAudioStreamBuilder builder,
+                                                       aaudio_sample_rate_t sampleRate);
+
+/**
+ * Returns sample rate in Hertz (samples per second).
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_getSampleRate(AAudioStreamBuilder builder,
+                                                       aaudio_sample_rate_t *sampleRate);
+
+
+/**
+ * Request a number of samples per frame.
+ * The stream may be opened with a different value.
+ * So the application should query for the actual value after the stream is opened.
+ *
+ * Default is AAUDIO_UNSPECIFIED.
+ *
+ * Note, this quantity is sometimes referred to as "channel count".
+ *
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_setSamplesPerFrame(AAudioStreamBuilder builder,
+                                                   int32_t samplesPerFrame);
+
+/**
+ * Note, this quantity is sometimes referred to as "channel count".
+ *
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @param samplesPerFrame pointer to a variable to be set to samplesPerFrame.
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_getSamplesPerFrame(AAudioStreamBuilder builder,
+                                                   int32_t *samplesPerFrame);
+
+
+/**
+ * Request a sample data format, for example AAUDIO_FORMAT_PCM_I16.
+ * The application should query for the actual format after the stream is opened.
+ *
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_setFormat(AAudioStreamBuilder builder,
+                                                   aaudio_audio_format_t format);
+
+/**
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_getFormat(AAudioStreamBuilder builder,
+                                                   aaudio_audio_format_t *format);
+
+/**
+ * Request a mode for sharing the device.
+ * The requested sharing mode may not be available.
+ * So the application should query for the actual mode after the stream is opened.
+ *
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @param sharingMode AAUDIO_SHARING_MODE_LEGACY or AAUDIO_SHARING_MODE_EXCLUSIVE
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_setSharingMode(AAudioStreamBuilder builder,
+                                                        aaudio_sharing_mode_t sharingMode);
+
+/**
+ * Return requested sharing mode.
+ * @return AAUDIO_OK or a negative error
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_getSharingMode(AAudioStreamBuilder builder,
+                                                        aaudio_sharing_mode_t *sharingMode);
+
+/**
+ * Request the direction for a stream. The default is AAUDIO_DIRECTION_OUTPUT.
+ *
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @param direction AAUDIO_DIRECTION_OUTPUT or AAUDIO_DIRECTION_INPUT
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_setDirection(AAudioStreamBuilder builder,
+                                                      aaudio_direction_t direction);
+
+/**
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @param direction pointer to a variable to be set to the currently requested direction.
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_getDirection(AAudioStreamBuilder builder,
+                                                      aaudio_direction_t *direction);
+
+/**
+ * Open a stream based on the options in the StreamBuilder.
+ *
+ * AAudioStream_close must be called when finished with the stream to recover
+ * the memory and to free the associated resources.
+ *
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @param stream pointer to a variable to receive the new stream handle
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t  AAudioStreamBuilder_openStream(AAudioStreamBuilder builder,
+                                                     AAudioStream *stream);
+
+/**
+ * Delete the resources associated with the StreamBuilder.
+ *
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t  AAudioStreamBuilder_delete(AAudioStreamBuilder builder);
+
+// ============================================================
+// Stream Control
+// ============================================================
+
+/**
+ * Free the resources associated with a stream created by AAudioStreamBuilder_openStream()
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t  AAudioStream_close(AAudioStream stream);
+
+/**
+ * Asynchronously request to start playing the stream. For output streams, one should
+ * write to the stream to fill the buffer before starting.
+ * Otherwise it will underflow.
+ * After this call the state will be in AAUDIO_STREAM_STATE_STARTING or AAUDIO_STREAM_STATE_STARTED.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t  AAudioStream_requestStart(AAudioStream stream);
+
+/**
+ * Asynchronous request for the stream to pause.
+ * Pausing a stream will freeze the data flow but not flush any buffers.
+ * Use AAudioStream_Start() to resume playback after a pause.
+ * After this call the state will be in AAUDIO_STREAM_STATE_PAUSING or AAUDIO_STREAM_STATE_PAUSED.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t  AAudioStream_requestPause(AAudioStream stream);
+
+/**
+ * Asynchronous request for the stream to flush.
+ * Flushing will discard any pending data.
+ * This call only works if the stream is pausing or paused. TODO review
+ * Frame counters are not reset by a flush. They may be advanced.
+ * After this call the state will be in AAUDIO_STREAM_STATE_FLUSHING or AAUDIO_STREAM_STATE_FLUSHED.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t  AAudioStream_requestFlush(AAudioStream stream);
+
+/**
+ * Asynchronous request for the stream to stop.
+ * The stream will stop after all of the data currently buffered has been played.
+ * After this call the state will be in AAUDIO_STREAM_STATE_STOPPING or AAUDIO_STREAM_STATE_STOPPED.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t  AAudioStream_requestStop(AAudioStream stream);
+
+/**
+ * Query the current state, eg. AAUDIO_STREAM_STATE_PAUSING
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param state pointer to a variable that will be set to the current state
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getState(AAudioStream stream, aaudio_stream_state_t *state);
+
+/**
+ * Wait until the current state no longer matches the input state.
+ *
+ * <pre><code>
+ * aaudio_stream_state_t currentState;
+ * aaudio_result_t result = AAudioStream_getState(stream, &currentState);
+ * while (result == AAUDIO_OK && currentState != AAUDIO_STREAM_STATE_PAUSING) {
+ *     result = AAudioStream_waitForStateChange(
+ *                                   stream, currentState, &currentState, MY_TIMEOUT_NANOS);
+ * }
+ * </code></pre>
+ *
+ * @param stream A handle provided by AAudioStreamBuilder_openStream()
+ * @param inputState The state we want to avoid.
+ * @param nextState Pointer to a variable that will be set to the new state.
+ * @param timeoutNanoseconds Maximum number of nanoseconds to wait for completion.
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_waitForStateChange(AAudioStream stream,
+                                            aaudio_stream_state_t inputState,
+                                            aaudio_stream_state_t *nextState,
+                                            aaudio_nanoseconds_t timeoutNanoseconds);
+
+// ============================================================
+// Stream I/O
+// ============================================================
+
+/**
+ * Read data from the stream.
+ *
+ * The call will wait until the read is complete or until it runs out of time.
+ * If timeoutNanos is zero then this call will not wait.
+ *
+ * Note that timeoutNanoseconds is a relative duration in wall clock time.
+ * Time will not stop if the thread is asleep.
+ * So it will be implemented using CLOCK_BOOTTIME.
+ *
+ * This call is "strong non-blocking" unless it has to wait for data.
+ *
+ * @param stream A stream created using AAudioStreamBuilder_openStream().
+ * @param buffer The address of the first sample.
+ * @param numFrames Number of frames to read. Only complete frames will be written.
+ * @param timeoutNanoseconds Maximum number of nanoseconds to wait for completion.
+ * @return The number of frames actually written or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_read(AAudioStream stream,
+                               void *buffer,
+                               aaudio_size_frames_t numFrames,
+                               aaudio_nanoseconds_t timeoutNanoseconds);
+
+/**
+ * Write data to the stream.
+ *
+ * The call will wait until the write is complete or until it runs out of time.
+ * If timeoutNanos is zero then this call will not wait.
+ *
+ * Note that timeoutNanoseconds is a relative duration in wall clock time.
+ * Time will not stop if the thread is asleep.
+ * So it will be implemented using CLOCK_BOOTTIME.
+ *
+ * This call is "strong non-blocking" unless it has to wait for room in the buffer.
+ *
+ * @param stream A stream created using AAudioStreamBuilder_openStream().
+ * @param buffer The address of the first sample.
+ * @param numFrames Number of frames to write. Only complete frames will be written.
+ * @param timeoutNanoseconds Maximum number of nanoseconds to wait for completion.
+ * @return The number of frames actually written or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_write(AAudioStream stream,
+                               const void *buffer,
+                               aaudio_size_frames_t numFrames,
+                               aaudio_nanoseconds_t timeoutNanoseconds);
+
+
+// ============================================================
+// High priority audio threads
+// ============================================================
+
+typedef void *(aaudio_audio_thread_proc_t)(void *);
+
+/**
+ * Create a thread associated with a stream. The thread has special properties for
+ * low latency audio performance. This thread can be used to implement a callback API.
+ *
+ * Only one thread may be associated with a stream.
+ *
+ * Note that this API is in flux.
+ *
+ * @param stream A stream created using AAudioStreamBuilder_openStream().
+ * @param periodNanoseconds the estimated period at which the audio thread will need to wake up
+ * @param startRoutine your thread entry point
+ * @param arg an argument that will be passed to your thread entry point
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_createThread(AAudioStream stream,
+                                     aaudio_nanoseconds_t periodNanoseconds,
+                                     aaudio_audio_thread_proc_t *threadProc,
+                                     void *arg);
+
+/**
+ * Wait until the thread exits or an error occurs.
+ * The thread handle will be deleted.
+ *
+ * @param stream A stream created using AAudioStreamBuilder_openStream().
+ * @param returnArg a pointer to a variable to receive the return value
+ * @param timeoutNanoseconds Maximum number of nanoseconds to wait for completion.
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_joinThread(AAudioStream stream,
+                                   void **returnArg,
+                                   aaudio_nanoseconds_t timeoutNanoseconds);
+
+// ============================================================
+// Stream - queries
+// ============================================================
+
+
+/**
+ * This can be used to adjust the latency of the buffer by changing
+ * the threshold where blocking will occur.
+ * By combining this with AAudioStream_getUnderrunCount(), the latency can be tuned
+ * at run-time for each device.
+ *
+ * This cannot be set higher than AAudioStream_getBufferCapacity().
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param requestedFrames requested number of frames that can be filled without blocking
+ * @param actualFrames receives final number of frames
+ * @return AAUDIO_OK or a negative error
+ */
+AAUDIO_API aaudio_result_t AAudioStream_setBufferSize(AAudioStream stream,
+                                                aaudio_size_frames_t requestedFrames,
+                                                aaudio_size_frames_t *actualFrames);
+
+/**
+ * Query the maximum number of frames that can be filled without blocking.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param frames pointer to variable to receive the buffer size
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getBufferSize(AAudioStream stream, aaudio_size_frames_t *frames);
+
+/**
+ * Query the number of frames that are read or written by the endpoint at one time.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param frames pointer to variable to receive the burst size
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getFramesPerBurst(AAudioStream stream, aaudio_size_frames_t *frames);
+
+/**
+ * Query maximum buffer capacity in frames.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param frames pointer to variable to receive the buffer capacity
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getBufferCapacity(AAudioStream stream, aaudio_size_frames_t *frames);
+
+/**
+ * An XRun is an Underrun or an Overrun.
+ * During playing, an underrun will occur if the stream is not written in time
+ * and the system runs out of valid data.
+ * During recording, an overrun will occur if the stream is not read in time
+ * and there is no place to put the incoming data so it is discarded.
+ *
+ * An underrun or overrun can cause an audible "pop" or "glitch".
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param xRunCount pointer to variable to receive the underrun or overrun count
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getXRunCount(AAudioStream stream, int32_t *xRunCount);
+
+/**
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param sampleRate pointer to variable to receive the actual sample rate
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getSampleRate(AAudioStream stream, aaudio_sample_rate_t *sampleRate);
+
+/**
+ * The samplesPerFrame is also known as channelCount.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param samplesPerFrame pointer to variable to receive the actual samples per frame
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getSamplesPerFrame(AAudioStream stream, int32_t *samplesPerFrame);
+
+/**
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param deviceId pointer to variable to receive the actual device ID
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getDeviceId(AAudioStream stream, aaudio_device_id_t *deviceId);
+
+/**
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param format pointer to variable to receive the actual data format
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getFormat(AAudioStream stream, aaudio_audio_format_t *format);
+
+/**
+ * Provide actual sharing mode.
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param sharingMode pointer to variable to receive the actual sharing mode
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getSharingMode(AAudioStream stream,
+                                        aaudio_sharing_mode_t *sharingMode);
+
+/**
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param direction pointer to a variable to be set to the current direction.
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getDirection(AAudioStream stream, aaudio_direction_t *direction);
+
+/**
+ * Passes back the number of frames that have been written since the stream was created.
+ * For an output stream, this will be advanced by the application calling write().
+ * For an input stream, this will be advanced by the device or service.
+ *
+ * The frame position is monotonically increasing.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param frames pointer to variable to receive the frames written
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getFramesWritten(AAudioStream stream,
+                                                   aaudio_position_frames_t *frames);
+
+/**
+ * Passes back the number of frames that have been read since the stream was created.
+ * For an output stream, this will be advanced by the device or service.
+ * For an input stream, this will be advanced by the application calling read().
+ *
+ * The frame position is monotonically increasing.
+ *
+ * @param stream handle provided by AAudioStreamBuilder_openStream()
+ * @param frames pointer to variable to receive the frames written
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getFramesRead(AAudioStream stream, aaudio_position_frames_t *frames);
+
+/**
+ * Passes back the time at which a particular frame was presented.
+ * This can be used to synchronize audio with video or MIDI.
+ * It can also be used to align a recorded stream with a playback stream.
+ *
+ * Timestamps are only valid when the stream is in AAUDIO_STREAM_STATE_STARTED.
+ * AAUDIO_ERROR_INVALID_STATE will be returned if the stream is not started.
+ * Note that because requestStart() is asynchronous, timestamps will not be valid until
+ * a short time after calling requestStart().
+ * So AAUDIO_ERROR_INVALID_STATE should not be considered a fatal error.
+ * Just try calling again later.
+ *
+ * If an error occurs, then the position and time will not be modified.
+ *
+ * The position and time passed back are monotonically increasing.
+ *
+ * @param stream A handle provided by AAudioStreamBuilder_openStream()
+ * @param clockid AAUDIO_CLOCK_MONOTONIC or AAUDIO_CLOCK_BOOTTIME
+ * @param framePosition pointer to a variable to receive the position
+ * @param timeNanoseconds pointer to a variable to receive the time
+ * @return AAUDIO_OK or a negative error
+ */
+AAUDIO_API aaudio_result_t AAudioStream_getTimestamp(AAudioStream stream,
+                                      aaudio_clockid_t clockid,
+                                      aaudio_position_frames_t *framePosition,
+                                      aaudio_nanoseconds_t *timeNanoseconds);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //AAUDIO_AAUDIO_H
diff --git a/media/liboboe/include/aaudio/AAudioDefinitions.h b/media/liboboe/include/aaudio/AAudioDefinitions.h
new file mode 100644
index 0000000..979b8c9
--- /dev/null
+++ b/media/liboboe/include/aaudio/AAudioDefinitions.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AAUDIO_AAUDIODEFINITIONS_H
+#define AAUDIO_AAUDIODEFINITIONS_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef int32_t  aaudio_handle_t; // negative handles are error codes
+typedef int32_t  aaudio_result_t;
+/**
+ * A platform specific identifier for a device.
+ */
+typedef int32_t  aaudio_device_id_t;
+typedef int32_t  aaudio_sample_rate_t;
+/** This is used for small quantities such as the number of frames in a buffer. */
+typedef int32_t  aaudio_size_frames_t;
+/** This is used for small quantities such as the number of bytes in a frame. */
+typedef int32_t  aaudio_size_bytes_t;
+/**
+ * This is used for large quantities, such as the number of frames that have
+ * been played since a stream was started.
+ * At 48000 Hz, a 32-bit integer would wrap around in just over 12 hours.
+ */
+typedef int64_t  aaudio_position_frames_t;
+
+typedef int64_t  aaudio_nanoseconds_t;
+
+/**
+ * This is used to represent a value that has not been specified.
+ * For example, an application could use AAUDIO_UNSPECIFIED to indicate
+ * that is did not not care what the specific value of a parameter was
+ * and would accept whatever it was given.
+ */
+#define AAUDIO_UNSPECIFIED           0
+#define AAUDIO_DEVICE_UNSPECIFIED    ((aaudio_device_id_t) -1)
+#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)
+
+#define AAUDIO_HANDLE_INVALID     ((aaudio_handle_t)-1)
+
+enum aaudio_direction_t {
+    AAUDIO_DIRECTION_OUTPUT,
+    AAUDIO_DIRECTION_INPUT,
+    AAUDIO_DIRECTION_COUNT // This should always be last.
+};
+
+enum aaudio_audio_format_t {
+    AAUDIO_FORMAT_INVALID = -1,
+    AAUDIO_FORMAT_UNSPECIFIED = 0,
+    AAUDIO_FORMAT_PCM_I16,
+    AAUDIO_FORMAT_PCM_FLOAT,
+    AAUDIO_FORMAT_PCM_I8_24,
+    AAUDIO_FORMAT_PCM_I32
+};
+
+// TODO These are deprecated. Remove these aliases once all references are replaced.
+#define AAUDIO_FORMAT_PCM16    AAUDIO_FORMAT_PCM_I16
+#define AAUDIO_FORMAT_PCM824   AAUDIO_FORMAT_PCM_I8_24
+#define AAUDIO_FORMAT_PCM32    AAUDIO_FORMAT_PCM_I32
+
+enum {
+    AAUDIO_OK,
+    AAUDIO_ERROR_BASE = -900, // TODO review
+    AAUDIO_ERROR_DISCONNECTED,
+    AAUDIO_ERROR_ILLEGAL_ARGUMENT,
+    AAUDIO_ERROR_INCOMPATIBLE,
+    AAUDIO_ERROR_INTERNAL, // an underlying API returned an error code
+    AAUDIO_ERROR_INVALID_STATE,
+    AAUDIO_ERROR_UNEXPECTED_STATE,
+    AAUDIO_ERROR_UNEXPECTED_VALUE,
+    AAUDIO_ERROR_INVALID_HANDLE,
+    AAUDIO_ERROR_INVALID_QUERY,
+    AAUDIO_ERROR_UNIMPLEMENTED,
+    AAUDIO_ERROR_UNAVAILABLE,
+    AAUDIO_ERROR_NO_FREE_HANDLES,
+    AAUDIO_ERROR_NO_MEMORY,
+    AAUDIO_ERROR_NULL,
+    AAUDIO_ERROR_TIMEOUT,
+    AAUDIO_ERROR_WOULD_BLOCK,
+    AAUDIO_ERROR_INVALID_ORDER,
+    AAUDIO_ERROR_OUT_OF_RANGE,
+    AAUDIO_ERROR_NO_SERVICE
+};
+
+typedef enum {
+    AAUDIO_CLOCK_MONOTONIC, // Clock since booted, pauses when CPU is sleeping.
+    AAUDIO_CLOCK_BOOTTIME,  // Clock since booted, runs all the time.
+    AAUDIO_CLOCK_COUNT // This should always be last.
+} aaudio_clockid_t;
+
+typedef enum
+{
+    AAUDIO_STREAM_STATE_UNINITIALIZED = 0,
+    AAUDIO_STREAM_STATE_OPEN,
+    AAUDIO_STREAM_STATE_STARTING,
+    AAUDIO_STREAM_STATE_STARTED,
+    AAUDIO_STREAM_STATE_PAUSING,
+    AAUDIO_STREAM_STATE_PAUSED,
+    AAUDIO_STREAM_STATE_FLUSHING,
+    AAUDIO_STREAM_STATE_FLUSHED,
+    AAUDIO_STREAM_STATE_STOPPING,
+    AAUDIO_STREAM_STATE_STOPPED,
+    AAUDIO_STREAM_STATE_CLOSING,
+    AAUDIO_STREAM_STATE_CLOSED,
+} aaudio_stream_state_t;
+
+// TODO review API
+typedef enum {
+    /**
+     * This will use an AudioTrack object for playing audio
+     * and an AudioRecord for recording data.
+     */
+    AAUDIO_SHARING_MODE_LEGACY,
+    /**
+     * This will be the only stream using a particular source or sink.
+     * This mode will provide the lowest possible latency.
+     * You should close EXCLUSIVE streams immediately when you are not using them.
+     */
+    AAUDIO_SHARING_MODE_EXCLUSIVE,
+    /**
+     * Multiple applications will be mixed by the AAudio Server.
+     * This will have higher latency than the EXCLUSIVE mode.
+     */
+    AAUDIO_SHARING_MODE_SHARED,
+    /**
+     * Multiple applications will do their own mixing into a memory mapped buffer.
+     * It may be possible for malicious applications to read the data produced by
+     * other apps. So do not use this for private data such as telephony or messaging.
+     */
+    AAUDIO_SHARING_MODE_PUBLIC_MIX,
+    AAUDIO_SHARING_MODE_COUNT // This should always be last.
+} aaudio_sharing_mode_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AAUDIO_AAUDIODEFINITIONS_H
diff --git a/media/liboboe/include/oboe/NOTICE b/media/liboboe/include/aaudio/NOTICE
similarity index 100%
rename from media/liboboe/include/oboe/NOTICE
rename to media/liboboe/include/aaudio/NOTICE
diff --git a/media/liboboe/include/oboe/README.md b/media/liboboe/include/aaudio/README.md
similarity index 69%
rename from media/liboboe/include/oboe/README.md
rename to media/liboboe/include/aaudio/README.md
index de60d03..8c4ae51 100644
--- a/media/liboboe/include/oboe/README.md
+++ b/media/liboboe/include/aaudio/README.md
@@ -1,4 +1,4 @@
-Oboe Audio headers
+AAudio Audio headers
 
 This folder contains the public header files.
 
diff --git a/media/liboboe/include/oboe/OboeAudio.h b/media/liboboe/include/oboe/OboeAudio.h
deleted file mode 100644
index 7ad354c..0000000
--- a/media/liboboe/include/oboe/OboeAudio.h
+++ /dev/null
@@ -1,574 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * This is the 'C' ABI for Oboe.
- */
-#ifndef OBOE_OBOEAUDIO_H
-#define OBOE_OBOEAUDIO_H
-
-#include "OboeDefinitions.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef oboe_handle_t OboeStream;
-typedef oboe_handle_t OboeStreamBuilder;
-
-#define OBOE_STREAM_NONE         ((OboeStream)OBOE_HANDLE_INVALID)
-#define OBOE_STREAM_BUILDER_NONE ((OboeStreamBuilder)OBOE_HANDLE_INVALID)
-
-/* OBOE_API will probably get defined in a Makefile for a specific platform. */
-#ifndef OBOE_API
-#define OBOE_API /* for exporting symbols */
-#endif
-
-// ============================================================
-// Audio System
-// ============================================================
-
-/**
- * @return time in the same clock domain as the timestamps
- */
-OBOE_API oboe_nanoseconds_t Oboe_getNanoseconds(oboe_clockid_t clockid);
-
-/**
- * The text is the ASCII symbol corresponding to the returnCode,
- * or an English message saying the returnCode is unrecognized.
- * This is intended for developers to use when debugging.
- * It is not for display to users.
- *
- * @return pointer to a text representation of an Oboe result code.
- */
-OBOE_API const char * Oboe_convertResultToText(oboe_result_t returnCode);
-
-/**
- * The text is the ASCII symbol corresponding to the stream state,
- * or an English message saying the state is unrecognized.
- * This is intended for developers to use when debugging.
- * It is not for display to users.
- *
- * @return pointer to a text representation of an Oboe state.
- */
-OBOE_API const char * Oboe_convertStreamStateToText(oboe_stream_state_t state);
-
-// ============================================================
-// StreamBuilder
-// ============================================================
-
-/**
- * Create a StreamBuilder that can be used to open a Stream.
- *
- * The deviceId is initially unspecified, meaning that the current default device will be used.
- *
- * The default direction is OBOE_DIRECTION_OUTPUT.
- * The default sharing mode is OBOE_SHARING_MODE_LEGACY.
- * The data format, samplesPerFrames and sampleRate are unspecified and will be
- * chosen by the device when it is opened.
- *
- * OboeStreamBuilder_delete() must be called when you are done using the builder.
- */
-OBOE_API oboe_result_t Oboe_createStreamBuilder(OboeStreamBuilder *builder);
-
-/**
- * Request an audio device identified device using an ID.
- * The ID is platform specific.
- * On Android, for example, the ID could be obtained from the Java AudioManager.
- *
- * By default, the primary device will be used.
- *
- * @param builder handle provided by Oboe_createStreamBuilder()
- * @param deviceId platform specific identifier or OBOE_DEVICE_UNSPECIFIED
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_setDeviceId(OboeStreamBuilder builder,
-                                                     oboe_device_id_t deviceId);
-/**
- * Passes back requested device ID.
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_getDeviceId(OboeStreamBuilder builder,
-                                                     oboe_device_id_t *deviceId);
-
-/**
- * Request a sample rate in Hz.
- * The stream may be opened with a different sample rate.
- * So the application should query for the actual rate after the stream is opened.
- *
- * Technically, this should be called the "frame rate" or "frames per second",
- * because it refers to the number of complete frames transferred per second.
- * But it is traditionally called "sample rate". Se we use that term.
- *
- * Default is OBOE_UNSPECIFIED.
- *
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_setSampleRate(OboeStreamBuilder builder,
-                                                       oboe_sample_rate_t sampleRate);
-
-/**
- * Returns sample rate in Hertz (samples per second).
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_getSampleRate(OboeStreamBuilder builder,
-                                                       oboe_sample_rate_t *sampleRate);
-
-
-/**
- * Request a number of samples per frame.
- * The stream may be opened with a different value.
- * So the application should query for the actual value after the stream is opened.
- *
- * Default is OBOE_UNSPECIFIED.
- *
- * Note, this quantity is sometimes referred to as "channel count".
- *
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_setSamplesPerFrame(OboeStreamBuilder builder,
-                                                   int32_t samplesPerFrame);
-
-/**
- * Note, this quantity is sometimes referred to as "channel count".
- *
- * @param builder handle provided by Oboe_createStreamBuilder()
- * @param samplesPerFrame pointer to a variable to be set to samplesPerFrame.
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_getSamplesPerFrame(OboeStreamBuilder builder,
-                                                   int32_t *samplesPerFrame);
-
-
-/**
- * Request a sample data format, for example OBOE_AUDIO_FORMAT_PCM_I16.
- * The application should query for the actual format after the stream is opened.
- *
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_setFormat(OboeStreamBuilder builder,
-                                                   oboe_audio_format_t format);
-
-/**
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_getFormat(OboeStreamBuilder builder,
-                                                   oboe_audio_format_t *format);
-
-/**
- * Request a mode for sharing the device.
- * The requested sharing mode may not be available.
- * So the application should query for the actual mode after the stream is opened.
- *
- * @param builder handle provided by Oboe_createStreamBuilder()
- * @param sharingMode OBOE_SHARING_MODE_LEGACY or OBOE_SHARING_MODE_EXCLUSIVE
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_setSharingMode(OboeStreamBuilder builder,
-                                                        oboe_sharing_mode_t sharingMode);
-
-/**
- * Return requested sharing mode.
- * @return OBOE_OK or a negative error
- */
-OBOE_API oboe_result_t OboeStreamBuilder_getSharingMode(OboeStreamBuilder builder,
-                                                        oboe_sharing_mode_t *sharingMode);
-
-/**
- * Request the direction for a stream. The default is OBOE_DIRECTION_OUTPUT.
- *
- * @param builder handle provided by Oboe_createStreamBuilder()
- * @param direction OBOE_DIRECTION_OUTPUT or OBOE_DIRECTION_INPUT
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_setDirection(OboeStreamBuilder builder,
-                                                      oboe_direction_t direction);
-
-/**
- * @param builder handle provided by Oboe_createStreamBuilder()
- * @param direction pointer to a variable to be set to the currently requested direction.
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStreamBuilder_getDirection(OboeStreamBuilder builder,
-                                                      oboe_direction_t *direction);
-
-/**
- * Open a stream based on the options in the StreamBuilder.
- *
- * OboeStream_close must be called when finished with the stream to recover
- * the memory and to free the associated resources.
- *
- * @param builder handle provided by Oboe_createStreamBuilder()
- * @param stream pointer to a variable to receive the new stream handle
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t  OboeStreamBuilder_openStream(OboeStreamBuilder builder,
-                                                     OboeStream *stream);
-
-/**
- * Delete the resources associated with the StreamBuilder.
- *
- * @param builder handle provided by Oboe_createStreamBuilder()
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t  OboeStreamBuilder_delete(OboeStreamBuilder builder);
-
-// ============================================================
-// Stream Control
-// ============================================================
-
-/**
- * Free the resources associated with a stream created by OboeStreamBuilder_openStream()
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t  OboeStream_close(OboeStream stream);
-
-/**
- * Asynchronously request to start playing the stream. For output streams, one should
- * write to the stream to fill the buffer before starting.
- * Otherwise it will underflow.
- * After this call the state will be in OBOE_STREAM_STATE_STARTING or OBOE_STREAM_STATE_STARTED.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t  OboeStream_requestStart(OboeStream stream);
-
-/**
- * Asynchronous request for the stream to pause.
- * Pausing a stream will freeze the data flow but not flush any buffers.
- * Use OboeStream_Start() to resume playback after a pause.
- * After this call the state will be in OBOE_STREAM_STATE_PAUSING or OBOE_STREAM_STATE_PAUSED.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t  OboeStream_requestPause(OboeStream stream);
-
-/**
- * Asynchronous request for the stream to flush.
- * Flushing will discard any pending data.
- * This call only works if the stream is pausing or paused. TODO review
- * Frame counters are not reset by a flush. They may be advanced.
- * After this call the state will be in OBOE_STREAM_STATE_FLUSHING or OBOE_STREAM_STATE_FLUSHED.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t  OboeStream_requestFlush(OboeStream stream);
-
-/**
- * Asynchronous request for the stream to stop.
- * The stream will stop after all of the data currently buffered has been played.
- * After this call the state will be in OBOE_STREAM_STATE_STOPPING or OBOE_STREAM_STATE_STOPPED.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t  OboeStream_requestStop(OboeStream stream);
-
-/**
- * Query the current state, eg. OBOE_STREAM_STATE_PAUSING
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param state pointer to a variable that will be set to the current state
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getState(OboeStream stream, oboe_stream_state_t *state);
-
-/**
- * Wait until the current state no longer matches the input state.
- *
- * <pre><code>
- * oboe_stream_state_t currentState;
- * oboe_result_t result = OboeStream_getState(stream, &currentState);
- * while (result == OBOE_OK && currentState != OBOE_STREAM_STATE_PAUSING) {
- *     result = OboeStream_waitForStateChange(
- *                                   stream, currentState, &currentState, MY_TIMEOUT_NANOS);
- * }
- * </code></pre>
- *
- * @param stream A handle provided by OboeStreamBuilder_openStream()
- * @param inputState The state we want to avoid.
- * @param nextState Pointer to a variable that will be set to the new state.
- * @param timeoutNanoseconds Maximum number of nanoseconds to wait for completion.
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_waitForStateChange(OboeStream stream,
-                                            oboe_stream_state_t inputState,
-                                            oboe_stream_state_t *nextState,
-                                            oboe_nanoseconds_t timeoutNanoseconds);
-
-// ============================================================
-// Stream I/O
-// ============================================================
-
-/**
- * Read data from the stream.
- *
- * The call will wait until the read is complete or until it runs out of time.
- * If timeoutNanos is zero then this call will not wait.
- *
- * Note that timeoutNanoseconds is a relative duration in wall clock time.
- * Time will not stop if the thread is asleep.
- * So it will be implemented using CLOCK_BOOTTIME.
- *
- * This call is "strong non-blocking" unless it has to wait for data.
- *
- * @param stream A stream created using OboeStreamBuilder_openStream().
- * @param buffer The address of the first sample.
- * @param numFrames Number of frames to read. Only complete frames will be written.
- * @param timeoutNanoseconds Maximum number of nanoseconds to wait for completion.
- * @return The number of frames actually written or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_read(OboeStream stream,
-                               void *buffer,
-                               oboe_size_frames_t numFrames,
-                               oboe_nanoseconds_t timeoutNanoseconds);
-
-/**
- * Write data to the stream.
- *
- * The call will wait until the write is complete or until it runs out of time.
- * If timeoutNanos is zero then this call will not wait.
- *
- * Note that timeoutNanoseconds is a relative duration in wall clock time.
- * Time will not stop if the thread is asleep.
- * So it will be implemented using CLOCK_BOOTTIME.
- *
- * This call is "strong non-blocking" unless it has to wait for room in the buffer.
- *
- * @param stream A stream created using OboeStreamBuilder_openStream().
- * @param buffer The address of the first sample.
- * @param numFrames Number of frames to write. Only complete frames will be written.
- * @param timeoutNanoseconds Maximum number of nanoseconds to wait for completion.
- * @return The number of frames actually written or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_write(OboeStream stream,
-                               const void *buffer,
-                               oboe_size_frames_t numFrames,
-                               oboe_nanoseconds_t timeoutNanoseconds);
-
-
-// ============================================================
-// High priority audio threads
-// ============================================================
-
-typedef void *(oboe_audio_thread_proc_t)(void *);
-
-/**
- * Create a thread associated with a stream. The thread has special properties for
- * low latency audio performance. This thread can be used to implement a callback API.
- *
- * Only one thread may be associated with a stream.
- *
- * Note that this API is in flux.
- *
- * @param stream A stream created using OboeStreamBuilder_openStream().
- * @param periodNanoseconds the estimated period at which the audio thread will need to wake up
- * @param startRoutine your thread entry point
- * @param arg an argument that will be passed to your thread entry point
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_createThread(OboeStream stream,
-                                     oboe_nanoseconds_t periodNanoseconds,
-                                     oboe_audio_thread_proc_t *threadProc,
-                                     void *arg);
-
-/**
- * Wait until the thread exits or an error occurs.
- * The thread handle will be deleted.
- *
- * @param stream A stream created using OboeStreamBuilder_openStream().
- * @param returnArg a pointer to a variable to receive the return value
- * @param timeoutNanoseconds Maximum number of nanoseconds to wait for completion.
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_joinThread(OboeStream stream,
-                                   void **returnArg,
-                                   oboe_nanoseconds_t timeoutNanoseconds);
-
-// ============================================================
-// Stream - queries
-// ============================================================
-
-
-/**
- * This can be used to adjust the latency of the buffer by changing
- * the threshold where blocking will occur.
- * By combining this with OboeStream_getUnderrunCount(), the latency can be tuned
- * at run-time for each device.
- *
- * This cannot be set higher than OboeStream_getBufferCapacity().
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param requestedFrames requested number of frames that can be filled without blocking
- * @param actualFrames receives final number of frames
- * @return OBOE_OK or a negative error
- */
-OBOE_API oboe_result_t OboeStream_setBufferSize(OboeStream stream,
-                                                oboe_size_frames_t requestedFrames,
-                                                oboe_size_frames_t *actualFrames);
-
-/**
- * Query the maximum number of frames that can be filled without blocking.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param frames pointer to variable to receive the buffer size
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getBufferSize(OboeStream stream, oboe_size_frames_t *frames);
-
-/**
- * Query the number of frames that are read or written by the endpoint at one time.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param frames pointer to variable to receive the burst size
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getFramesPerBurst(OboeStream stream, oboe_size_frames_t *frames);
-
-/**
- * Query maximum buffer capacity in frames.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param frames pointer to variable to receive the buffer capacity
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getBufferCapacity(OboeStream stream, oboe_size_frames_t *frames);
-
-/**
- * An XRun is an Underrun or an Overrun.
- * During playing, an underrun will occur if the stream is not written in time
- * and the system runs out of valid data.
- * During recording, an overrun will occur if the stream is not read in time
- * and there is no place to put the incoming data so it is discarded.
- *
- * An underrun or overrun can cause an audible "pop" or "glitch".
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param xRunCount pointer to variable to receive the underrun or overrun count
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getXRunCount(OboeStream stream, int32_t *xRunCount);
-
-/**
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param sampleRate pointer to variable to receive the actual sample rate
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getSampleRate(OboeStream stream, oboe_sample_rate_t *sampleRate);
-
-/**
- * The samplesPerFrame is also known as channelCount.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param samplesPerFrame pointer to variable to receive the actual samples per frame
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getSamplesPerFrame(OboeStream stream, int32_t *samplesPerFrame);
-
-/**
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param deviceId pointer to variable to receive the actual device ID
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getDeviceId(OboeStream stream, oboe_device_id_t *deviceId);
-
-/**
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param format pointer to variable to receive the actual data format
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getFormat(OboeStream stream, oboe_audio_format_t *format);
-
-/**
- * Provide actual sharing mode.
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param sharingMode pointer to variable to receive the actual sharing mode
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getSharingMode(OboeStream stream,
-                                        oboe_sharing_mode_t *sharingMode);
-
-/**
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param direction pointer to a variable to be set to the current direction.
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getDirection(OboeStream stream, oboe_direction_t *direction);
-
-/**
- * Passes back the number of frames that have been written since the stream was created.
- * For an output stream, this will be advanced by the application calling write().
- * For an input stream, this will be advanced by the device or service.
- *
- * The frame position is monotonically increasing.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param frames pointer to variable to receive the frames written
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getFramesWritten(OboeStream stream,
-                                                   oboe_position_frames_t *frames);
-
-/**
- * Passes back the number of frames that have been read since the stream was created.
- * For an output stream, this will be advanced by the device or service.
- * For an input stream, this will be advanced by the application calling read().
- *
- * The frame position is monotonically increasing.
- *
- * @param stream handle provided by OboeStreamBuilder_openStream()
- * @param frames pointer to variable to receive the frames written
- * @return OBOE_OK or a negative error.
- */
-OBOE_API oboe_result_t OboeStream_getFramesRead(OboeStream stream, oboe_position_frames_t *frames);
-
-/**
- * Passes back the time at which a particular frame was presented.
- * This can be used to synchronize audio with video or MIDI.
- * It can also be used to align a recorded stream with a playback stream.
- *
- * Timestamps are only valid when the stream is in OBOE_STREAM_STATE_STARTED.
- * OBOE_ERROR_INVALID_STATE will be returned if the stream is not started.
- * Note that because requestStart() is asynchronous, timestamps will not be valid until
- * a short time after calling requestStart().
- * So OBOE_ERROR_INVALID_STATE should not be considered a fatal error.
- * Just try calling again later.
- *
- * If an error occurs, then the position and time will not be modified.
- *
- * The position and time passed back are monotonically increasing.
- *
- * @param stream A handle provided by OboeStreamBuilder_openStream()
- * @param clockid OBOE_CLOCK_MONOTONIC or OBOE_CLOCK_BOOTTIME
- * @param framePosition pointer to a variable to receive the position
- * @param timeNanoseconds pointer to a variable to receive the time
- * @return OBOE_OK or a negative error
- */
-OBOE_API oboe_result_t OboeStream_getTimestamp(OboeStream stream,
-                                      oboe_clockid_t clockid,
-                                      oboe_position_frames_t *framePosition,
-                                      oboe_nanoseconds_t *timeNanoseconds);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif //OBOE_OBOEAUDIO_H
diff --git a/media/liboboe/include/oboe/OboeDefinitions.h b/media/liboboe/include/oboe/OboeDefinitions.h
deleted file mode 100644
index 9ad7387..0000000
--- a/media/liboboe/include/oboe/OboeDefinitions.h
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef OBOE_OBOEDEFINITIONS_H
-#define OBOE_OBOEDEFINITIONS_H
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef int32_t  oboe_handle_t; // negative handles are error codes
-typedef int32_t  oboe_result_t;
-/**
- * A platform specific identifier for a device.
- */
-typedef int32_t  oboe_device_id_t;
-typedef int32_t  oboe_sample_rate_t;
-/** This is used for small quantities such as the number of frames in a buffer. */
-typedef int32_t  oboe_size_frames_t;
-/** This is used for small quantities such as the number of bytes in a frame. */
-typedef int32_t  oboe_size_bytes_t;
-/**
- * This is used for large quantities, such as the number of frames that have
- * been played since a stream was started.
- * At 48000 Hz, a 32-bit integer would wrap around in just over 12 hours.
- */
-typedef int64_t  oboe_position_frames_t;
-
-typedef int64_t  oboe_nanoseconds_t;
-
-/**
- * This is used to represent a value that has not been specified.
- * For example, an application could use OBOE_UNSPECIFIED to indicate
- * that is did not not care what the specific value of a parameter was
- * and would accept whatever it was given.
- */
-#define OBOE_UNSPECIFIED           0
-#define OBOE_DEVICE_UNSPECIFIED    ((oboe_device_id_t) -1)
-#define OBOE_NANOS_PER_MICROSECOND ((int64_t)1000)
-#define OBOE_NANOS_PER_MILLISECOND (OBOE_NANOS_PER_MICROSECOND * 1000)
-#define OBOE_MILLIS_PER_SECOND     1000
-#define OBOE_NANOS_PER_SECOND      (OBOE_NANOS_PER_MILLISECOND * OBOE_MILLIS_PER_SECOND)
-
-#define OBOE_HANDLE_INVALID     ((oboe_handle_t)-1)
-
-enum oboe_direction_t {
-    OBOE_DIRECTION_OUTPUT,
-    OBOE_DIRECTION_INPUT,
-    OBOE_DIRECTION_COUNT // This should always be last.
-};
-
-enum oboe_audio_format_t {
-    OBOE_AUDIO_FORMAT_INVALID = -1,
-    OBOE_AUDIO_FORMAT_UNSPECIFIED = 0,
-    OBOE_AUDIO_FORMAT_PCM_I16,
-    OBOE_AUDIO_FORMAT_PCM_FLOAT,
-    OBOE_AUDIO_FORMAT_PCM_I8_24,
-    OBOE_AUDIO_FORMAT_PCM_I32
-};
-
-// TODO These are deprecated. Remove these aliases once all references are replaced.
-#define OBOE_AUDIO_FORMAT_PCM16    OBOE_AUDIO_FORMAT_PCM_I16
-#define OBOE_AUDIO_FORMAT_PCM824   OBOE_AUDIO_FORMAT_PCM_I8_24
-#define OBOE_AUDIO_FORMAT_PCM32    OBOE_AUDIO_FORMAT_PCM_I32
-
-enum {
-    OBOE_OK,
-    OBOE_ERROR_BASE = -900, // TODO review
-    OBOE_ERROR_DISCONNECTED,
-    OBOE_ERROR_ILLEGAL_ARGUMENT,
-    OBOE_ERROR_INCOMPATIBLE,
-    OBOE_ERROR_INTERNAL, // an underlying API returned an error code
-    OBOE_ERROR_INVALID_STATE,
-    OBOE_ERROR_UNEXPECTED_STATE,
-    OBOE_ERROR_UNEXPECTED_VALUE,
-    OBOE_ERROR_INVALID_HANDLE,
-    OBOE_ERROR_INVALID_QUERY,
-    OBOE_ERROR_UNIMPLEMENTED,
-    OBOE_ERROR_UNAVAILABLE,
-    OBOE_ERROR_NO_FREE_HANDLES,
-    OBOE_ERROR_NO_MEMORY,
-    OBOE_ERROR_NULL,
-    OBOE_ERROR_TIMEOUT,
-    OBOE_ERROR_WOULD_BLOCK,
-    OBOE_ERROR_INVALID_ORDER,
-    OBOE_ERROR_OUT_OF_RANGE,
-    OBOE_ERROR_NO_SERVICE
-};
-
-typedef enum {
-    OBOE_CLOCK_MONOTONIC, // Clock since booted, pauses when CPU is sleeping.
-    OBOE_CLOCK_BOOTTIME,  // Clock since booted, runs all the time.
-    OBOE_CLOCK_COUNT // This should always be last.
-} oboe_clockid_t;
-
-typedef enum
-{
-    OBOE_STREAM_STATE_UNINITIALIZED = 0,
-    OBOE_STREAM_STATE_OPEN,
-    OBOE_STREAM_STATE_STARTING,
-    OBOE_STREAM_STATE_STARTED,
-    OBOE_STREAM_STATE_PAUSING,
-    OBOE_STREAM_STATE_PAUSED,
-    OBOE_STREAM_STATE_FLUSHING,
-    OBOE_STREAM_STATE_FLUSHED,
-    OBOE_STREAM_STATE_STOPPING,
-    OBOE_STREAM_STATE_STOPPED,
-    OBOE_STREAM_STATE_CLOSING,
-    OBOE_STREAM_STATE_CLOSED,
-} oboe_stream_state_t;
-
-// TODO review API
-typedef enum {
-    /**
-     * This will use an AudioTrack object for playing audio
-     * and an AudioRecord for recording data.
-     */
-    OBOE_SHARING_MODE_LEGACY,
-    /**
-     * This will be the only stream using a particular source or sink.
-     * This mode will provide the lowest possible latency.
-     * You should close EXCLUSIVE streams immediately when you are not using them.
-     */
-    OBOE_SHARING_MODE_EXCLUSIVE,
-    /**
-     * Multiple applications will be mixed by the Oboe Server.
-     * This will have higher latency than the EXCLUSIVE mode.
-     */
-    OBOE_SHARING_MODE_SHARED,
-    /**
-     * Multiple applications will do their own mixing into a memory mapped buffer.
-     * It may be possible for malicious applications to read the data produced by
-     * other apps. So do not use this for private data such as telephony or messaging.
-     */
-    OBOE_SHARING_MODE_PUBLIC_MIX,
-    OBOE_SHARING_MODE_COUNT // This should always be last.
-} oboe_sharing_mode_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // OBOE_OBOEDEFINITIONS_H