diff --git a/media/liboboe/examples/write_sine/src/write_sine_threaded.cpp b/media/liboboe/examples/write_sine/src/write_sine_threaded.cpp
index 7cde67b..4ea2807 100644
--- a/media/liboboe/examples/write_sine/src/write_sine_threaded.cpp
+++ b/media/liboboe/examples/write_sine/src/write_sine_threaded.cpp
@@ -86,10 +86,18 @@
         result = AAudioStream_getSampleRate(mStream, &mFramesPerSecond);
         printf("open() mFramesPerSecond = %d\n", mFramesPerSecond);
         if (result != AAUDIO_OK) goto finish2;
+
         result = AAudioStream_getSamplesPerFrame(mStream, &mSamplesPerFrame);
         printf("open() mSamplesPerFrame = %d\n", mSamplesPerFrame);
         if (result != AAUDIO_OK) goto finish2;
 
+        {
+            aaudio_size_frames_t bufferCapacity;
+            result = AAudioStream_getBufferCapacity(mStream, &bufferCapacity);
+            if (result != AAUDIO_OK) goto finish2;
+            printf("open() got bufferCapacity = %d\n", bufferCapacity);
+        }
+
         // This is the number of frames that are read in one chunk by a DMA controller
         // or a DSP or a mixer.
         result = AAudioStream_getFramesPerBurst(mStream, &mFramesPerBurst);
diff --git a/media/liboboe/include/aaudio/AAudio.h b/media/liboboe/include/aaudio/AAudio.h
index 7324137..6987955 100644
--- a/media/liboboe/include/aaudio/AAudio.h
+++ b/media/liboboe/include/aaudio/AAudio.h
@@ -195,7 +195,7 @@
  * @return AAUDIO_OK or a negative error.
  */
 AAUDIO_API aaudio_result_t AAudioStreamBuilder_setDirection(AAudioStreamBuilder builder,
-                                                      aaudio_direction_t direction);
+                                                            aaudio_direction_t direction);
 
 /**
  * @param builder handle provided by AAudio_createStreamBuilder()
@@ -203,7 +203,31 @@
  * @return AAUDIO_OK or a negative error.
  */
 AAUDIO_API aaudio_result_t AAudioStreamBuilder_getDirection(AAudioStreamBuilder builder,
-                                                      aaudio_direction_t *direction);
+                                                            aaudio_direction_t *direction);
+
+/**
+ * Set the requested maximum buffer capacity in frames.
+ * The final AAudioStream capacity may differ, but will probably be at least this big.
+ *
+ * Default is AAUDIO_UNSPECIFIED.
+ *
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @param frames the desired buffer capacity in frames or AAUDIO_UNSPECIFIED
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_setBufferCapacity(AAudioStreamBuilder builder,
+                                                                 aaudio_size_frames_t frames);
+
+/**
+ * Query the requested maximum buffer capacity in frames that was passed to
+ * AAudioStreamBuilder_setBufferCapacity().
+ *
+ * @param builder handle provided by AAudio_createStreamBuilder()
+ * @param frames pointer to variable to receive the requested buffer capacity
+ * @return AAUDIO_OK or a negative error.
+ */
+AAUDIO_API aaudio_result_t AAudioStreamBuilder_getBufferCapacity(AAudioStreamBuilder builder,
+                                                                 aaudio_size_frames_t *frames);
 
 /**
  * Open a stream based on the options in the StreamBuilder.
@@ -422,8 +446,8 @@
  * @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);
+                                                      aaudio_size_frames_t requestedFrames,
+                                                      aaudio_size_frames_t *actualFrames);
 
 /**
  * Query the maximum number of frames that can be filled without blocking.
@@ -432,7 +456,8 @@
  * @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);
+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.
@@ -441,7 +466,8 @@
  * @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);
+AAUDIO_API aaudio_result_t AAudioStream_getFramesPerBurst(AAudioStream stream,
+                                                          aaudio_size_frames_t *frames);
 
 /**
  * Query maximum buffer capacity in frames.
@@ -450,7 +476,8 @@
  * @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);
+AAUDIO_API aaudio_result_t AAudioStream_getBufferCapacity(AAudioStream stream,
+                                                          aaudio_size_frames_t *frames);
 
 /**
  * An XRun is an Underrun or an Overrun.
@@ -472,7 +499,8 @@
  * @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);
+AAUDIO_API aaudio_result_t AAudioStream_getSampleRate(AAudioStream stream,
+                                                      aaudio_sample_rate_t *sampleRate);
 
 /**
  * The samplesPerFrame is also known as channelCount.
@@ -481,21 +509,24 @@
  * @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);
+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);
+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);
+AAUDIO_API aaudio_result_t AAudioStream_getFormat(AAudioStream stream,
+                                                  aaudio_audio_format_t *format);
 
 /**
  * Provide actual sharing mode.
@@ -511,7 +542,8 @@
  * @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);
+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.
@@ -538,7 +570,8 @@
  * @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);
+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.
diff --git a/media/liboboe/src/binding/AAudioStreamConfiguration.cpp b/media/liboboe/src/binding/AAudioStreamConfiguration.cpp
index 1cb2bfa..fe3a59f 100644
--- a/media/liboboe/src/binding/AAudioStreamConfiguration.cpp
+++ b/media/liboboe/src/binding/AAudioStreamConfiguration.cpp
@@ -39,6 +39,7 @@
     parcel->writeInt32(mSampleRate);
     parcel->writeInt32(mSamplesPerFrame);
     parcel->writeInt32((int32_t) mAudioFormat);
+    parcel->writeInt32(mBufferCapacity);
     return NO_ERROR; // TODO check for errors above
 }
 
@@ -49,6 +50,7 @@
     parcel->readInt32(&mSamplesPerFrame);
     parcel->readInt32(&temp);
     mAudioFormat = (aaudio_audio_format_t) temp;
+    parcel->readInt32(&mBufferCapacity);
     return NO_ERROR; // TODO check for errors above
 }
 
@@ -74,11 +76,17 @@
         ALOGE("AAudioStreamConfiguration.validate() invalid audioFormat = %d", mAudioFormat);
         return AAUDIO_ERROR_INTERNAL;
     }
+
+    if (mBufferCapacity < 0) {
+        ALOGE("AAudioStreamConfiguration.validate() invalid mBufferCapacity = %d", mBufferCapacity);
+        return AAUDIO_ERROR_INTERNAL;
+    }
     return AAUDIO_OK;
 }
 
 void AAudioStreamConfiguration::dump() {
-    ALOGD("AAudioStreamConfiguration mSampleRate = %d -----", mSampleRate);
+    ALOGD("AAudioStreamConfiguration mSampleRate      = %d -----", mSampleRate);
     ALOGD("AAudioStreamConfiguration mSamplesPerFrame = %d", mSamplesPerFrame);
-    ALOGD("AAudioStreamConfiguration mAudioFormat = %d", (int)mAudioFormat);
+    ALOGD("AAudioStreamConfiguration mAudioFormat     = %d", (int)mAudioFormat);
+    ALOGD("AAudioStreamConfiguration mBufferCapacity  = %d", mBufferCapacity);
 }
diff --git a/media/liboboe/src/binding/AAudioStreamConfiguration.h b/media/liboboe/src/binding/AAudioStreamConfiguration.h
index ef21443..efcdae8 100644
--- a/media/liboboe/src/binding/AAudioStreamConfiguration.h
+++ b/media/liboboe/src/binding/AAudioStreamConfiguration.h
@@ -66,6 +66,14 @@
         mAudioFormat = audioFormat;
     }
 
+    aaudio_size_frames_t getBufferCapacity() const {
+        return mBufferCapacity;
+    }
+
+    void setBufferCapacity(aaudio_size_frames_t frames) {
+        mBufferCapacity = frames;
+    }
+
     virtual status_t writeToParcel(Parcel* parcel) const override;
 
     virtual status_t readFromParcel(const Parcel* parcel) override;
@@ -77,8 +85,9 @@
 protected:
     aaudio_device_id_t    mDeviceId        = AAUDIO_DEVICE_UNSPECIFIED;
     aaudio_sample_rate_t  mSampleRate      = AAUDIO_UNSPECIFIED;
-    int32_t             mSamplesPerFrame = AAUDIO_UNSPECIFIED;
+    int32_t               mSamplesPerFrame = AAUDIO_UNSPECIFIED;
     aaudio_audio_format_t mAudioFormat     = AAUDIO_FORMAT_UNSPECIFIED;
+    aaudio_size_frames_t  mBufferCapacity  = AAUDIO_UNSPECIFIED;
 };
 
 } /* namespace aaudio */
diff --git a/media/liboboe/src/binding/IAAudioService.h b/media/liboboe/src/binding/IAAudioService.h
index 7d2fd29..f3b297e 100644
--- a/media/liboboe/src/binding/IAAudioService.h
+++ b/media/liboboe/src/binding/IAAudioService.h
@@ -38,6 +38,11 @@
 
     DECLARE_META_INTERFACE(AAudioService);
 
+    /**
+     * @param request info needed to create the stream
+     * @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,
                                      aaudio::AAudioStreamConfiguration &configuration) = 0;
 
diff --git a/media/liboboe/src/binding/SharedMemoryParcelable.cpp b/media/liboboe/src/binding/SharedMemoryParcelable.cpp
index 277a992..1102dec 100644
--- a/media/liboboe/src/binding/SharedMemoryParcelable.cpp
+++ b/media/liboboe/src/binding/SharedMemoryParcelable.cpp
@@ -87,9 +87,9 @@
 }
 
 aaudio_result_t SharedMemoryParcelable::validate() {
-    if (mSizeInBytes < 0 || mSizeInBytes >= MAX_MMAP_SIZE) {
+    if (mSizeInBytes < 0 || mSizeInBytes >= MAX_MMAP_SIZE_BYTES) {
         ALOGE("SharedMemoryParcelable invalid mSizeInBytes = %d", mSizeInBytes);
-        return AAUDIO_ERROR_INTERNAL;
+        return AAUDIO_ERROR_OUT_OF_RANGE;
     }
     if (mSizeInBytes > 0) {
         if (mFd == -1) {
diff --git a/media/liboboe/src/binding/SharedMemoryParcelable.h b/media/liboboe/src/binding/SharedMemoryParcelable.h
index 5768ea9..7e0bf1a 100644
--- a/media/liboboe/src/binding/SharedMemoryParcelable.h
+++ b/media/liboboe/src/binding/SharedMemoryParcelable.h
@@ -31,8 +31,8 @@
 
 // Arbitrary limits for sanity checks. TODO remove after debugging.
 #define MAX_SHARED_MEMORIES (32)
-#define MAX_MMAP_OFFSET (32 * 1024)
-#define MAX_MMAP_SIZE (32 * 1024)
+#define MAX_MMAP_OFFSET_BYTES (32 * 1024 * 8)
+#define MAX_MMAP_SIZE_BYTES (32 * 1024 * 8)
 
 /**
  * This is a parcelable description of a shared memory referenced by a file descriptor.
diff --git a/media/liboboe/src/binding/SharedRegionParcelable.cpp b/media/liboboe/src/binding/SharedRegionParcelable.cpp
index a3e0111..8ca0023 100644
--- a/media/liboboe/src/binding/SharedRegionParcelable.cpp
+++ b/media/liboboe/src/binding/SharedRegionParcelable.cpp
@@ -75,14 +75,14 @@
 }
 
 aaudio_result_t SharedRegionParcelable::validate() {
-    if (mSizeInBytes < 0 || mSizeInBytes >= MAX_MMAP_SIZE) {
+    if (mSizeInBytes < 0 || mSizeInBytes >= MAX_MMAP_SIZE_BYTES) {
         ALOGE("SharedRegionParcelable invalid mSizeInBytes = %d", mSizeInBytes);
-        return AAUDIO_ERROR_INTERNAL;
+        return AAUDIO_ERROR_OUT_OF_RANGE;
     }
     if (mSizeInBytes > 0) {
-        if (mOffsetInBytes < 0 || mOffsetInBytes >= MAX_MMAP_OFFSET) {
+        if (mOffsetInBytes < 0 || mOffsetInBytes >= MAX_MMAP_OFFSET_BYTES) {
             ALOGE("SharedRegionParcelable invalid mOffsetInBytes = %d", mOffsetInBytes);
-            return AAUDIO_ERROR_INTERNAL;
+            return AAUDIO_ERROR_OUT_OF_RANGE;
         }
         if (mSharedMemoryIndex < 0 || mSharedMemoryIndex >= MAX_SHARED_MEMORIES) {
             ALOGE("SharedRegionParcelable invalid mSharedMemoryIndex = %d", mSharedMemoryIndex);
diff --git a/media/liboboe/src/client/AudioStreamInternal.cpp b/media/liboboe/src/client/AudioStreamInternal.cpp
index 8d7e93f..19f2300 100644
--- a/media/liboboe/src/client/AudioStreamInternal.cpp
+++ b/media/liboboe/src/client/AudioStreamInternal.cpp
@@ -33,6 +33,7 @@
 #include "binding/IAAudioService.h"
 #include "binding/AAudioServiceMessage.h"
 
+#include "core/AudioStreamBuilder.h"
 #include "AudioStreamInternal.h"
 
 #define LOG_TIMESTAMPS   0
@@ -110,6 +111,7 @@
     request.getConfiguration().setSampleRate(getSampleRate());
     request.getConfiguration().setSamplesPerFrame(getSamplesPerFrame());
     request.getConfiguration().setAudioFormat(getFormat());
+    request.getConfiguration().setBufferCapacity(builder.getBufferCapacity());
     request.dump();
 
     mServiceStreamHandle = service->openStream(request, configuration);
@@ -142,7 +144,6 @@
         // Configure endpoint based on descriptor.
         mAudioEndpoint.configure(&mEndpointDescriptor);
 
-
         mFramesPerBurst = mEndpointDescriptor.downDataQueueDescriptor.framesPerBurst;
         assert(mFramesPerBurst >= 16);
         assert(mEndpointDescriptor.downDataQueueDescriptor.capacityInFrames < 10 * 1024);
diff --git a/media/liboboe/src/core/AAudioAudio.cpp b/media/liboboe/src/core/AAudioAudio.cpp
index c1fa7cf..04dbda1 100644
--- a/media/liboboe/src/core/AAudioAudio.cpp
+++ b/media/liboboe/src/core/AAudioAudio.cpp
@@ -256,6 +256,26 @@
     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;
+}
+
 static aaudio_result_t  AAudioInternal_openStream(AudioStreamBuilder *streamBuilder,
                                               AAudioStream *streamPtr)
 {
diff --git a/media/liboboe/src/core/AudioStreamBuilder.h b/media/liboboe/src/core/AudioStreamBuilder.h
index 9e1a1a7..e72633d 100644
--- a/media/liboboe/src/core/AudioStreamBuilder.h
+++ b/media/liboboe/src/core/AudioStreamBuilder.h
@@ -83,6 +83,15 @@
         return this;
     }
 
+    aaudio_size_frames_t getBufferCapacity() const {
+        return mBufferCapacity;
+    }
+
+    AudioStreamBuilder* setBufferCapacity(aaudio_size_frames_t frames) {
+        mBufferCapacity = frames;
+        return this;
+    }
+
     aaudio_device_id_t getDeviceId() const {
         return mDeviceId;
     }
@@ -95,12 +104,13 @@
     aaudio_result_t build(AudioStream **streamPtr);
 
 private:
-    int32_t              mSamplesPerFrame = AAUDIO_UNSPECIFIED;
+    int32_t                mSamplesPerFrame = AAUDIO_UNSPECIFIED;
     aaudio_sample_rate_t   mSampleRate = AAUDIO_UNSPECIFIED;
     aaudio_device_id_t     mDeviceId = AAUDIO_DEVICE_UNSPECIFIED;
     aaudio_sharing_mode_t  mSharingMode = AAUDIO_SHARING_MODE_LEGACY;
     aaudio_audio_format_t  mFormat = AAUDIO_FORMAT_UNSPECIFIED;
     aaudio_direction_t     mDirection = AAUDIO_DIRECTION_OUTPUT;
+    aaudio_size_frames_t   mBufferCapacity = AAUDIO_UNSPECIFIED;
 };
 
 } /* namespace aaudio */
diff --git a/media/liboboe/src/legacy/AudioStreamRecord.cpp b/media/liboboe/src/legacy/AudioStreamRecord.cpp
index 2d1785f..17d0a54 100644
--- a/media/liboboe/src/legacy/AudioStreamRecord.cpp
+++ b/media/liboboe/src/legacy/AudioStreamRecord.cpp
@@ -60,6 +60,8 @@
     AudioRecord::callback_t callback = nullptr;
     audio_input_flags_t flags = (audio_input_flags_t) AUDIO_INPUT_FLAG_NONE;
 
+    size_t frameCount = (builder.getBufferCapacity() == AAUDIO_UNSPECIFIED) ? 0
+                        : builder.getBufferCapacity();
     // TODO implement an unspecified Android format then use that.
     audio_format_t format = (getFormat() == AAUDIO_UNSPECIFIED)
             ? AUDIO_FORMAT_PCM_FLOAT
@@ -70,20 +72,18 @@
             getSampleRate(),
             format,
             channelMask,
-
             mOpPackageName, // const String16& opPackageName TODO does not compile
-
-            0,    //    size_t frameCount = 0,
+            frameCount,
             callback,
             nullptr, //    void* user = nullptr,
             0,    //    uint32_t notificationFrames = 0,
             AUDIO_SESSION_ALLOCATE,
             AudioRecord::TRANSFER_DEFAULT,
             flags
-             //   int uid = -1,
-             //   pid_t pid = -1,
-             //   const audio_attributes_t* pAttributes = nullptr
-             );
+            //   int uid = -1,
+            //   pid_t pid = -1,
+            //   const audio_attributes_t* pAttributes = nullptr
+            );
 
     // Did we get a valid track?
     status_t status = mAudioRecord->initCheck();
diff --git a/media/liboboe/src/legacy/AudioStreamTrack.cpp b/media/liboboe/src/legacy/AudioStreamTrack.cpp
index a60b5b4..b7d8664 100644
--- a/media/liboboe/src/legacy/AudioStreamTrack.cpp
+++ b/media/liboboe/src/legacy/AudioStreamTrack.cpp
@@ -64,7 +64,8 @@
     AudioTrack::callback_t callback = nullptr;
     // TODO add more performance options
     audio_output_flags_t flags = (audio_output_flags_t) AUDIO_OUTPUT_FLAG_FAST;
-    size_t frameCount = 0;
+    size_t frameCount = (builder.getBufferCapacity() == AAUDIO_UNSPECIFIED) ? 0
+                        : builder.getBufferCapacity();
     // TODO implement an unspecified AudioTrack format then use that.
     audio_format_t format = (getFormat() == AAUDIO_UNSPECIFIED)
             ? AUDIO_FORMAT_PCM_FLOAT
diff --git a/media/mtp/tests/MtpFfsHandle_test.cpp b/media/mtp/tests/MtpFfsHandle_test.cpp
index b511041..e575148 100644
--- a/media/mtp/tests/MtpFfsHandle_test.cpp
+++ b/media/mtp/tests/MtpFfsHandle_test.cpp
@@ -20,6 +20,7 @@
 #include <fcntl.h>
 #include <gtest/gtest.h>
 #include <memory>
+#include <random>
 #include <string>
 #include <unistd.h>
 #include <utils/Log.h>
@@ -28,6 +29,8 @@
 
 namespace android {
 
+constexpr int MAX_FILE_CHUNK_SIZE = 3 * 1024 * 1024;
+
 constexpr int TEST_PACKET_SIZE = 512;
 constexpr int SMALL_MULT = 30;
 constexpr int MED_MULT = 510;
@@ -42,6 +45,10 @@
     "BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express o"
     "r implied.\n * Se";
 
+/**
+ * Functional tests for the MtpFfsHandle class. Ensures header and data integrity
+ * by mocking ffs endpoints as pipes to capture input / output.
+ */
 class MtpFfsHandleTest : public ::testing::Test {
 protected:
     std::unique_ptr<IMtpHandle> handle;
@@ -72,6 +79,9 @@
         EXPECT_EQ(pipe(fd), 0);
         intr.reset(fd[0]);
         ffs_handle->mIntr.reset(fd[1]);
+
+        ffs_handle->mBuffer1.resize(MAX_FILE_CHUNK_SIZE);
+        ffs_handle->mBuffer2.resize(MAX_FILE_CHUNK_SIZE);
     }
 
     ~MtpFfsHandleTest() {}
@@ -138,6 +148,7 @@
     mtp_file_range mfr;
     mfr.command = 42;
     mfr.transaction_id = 1337;
+    mfr.offset = 0;
     int size = TEST_PACKET_SIZE * SMALL_MULT;
     char buf[size + sizeof(mtp_data_header) + 1];
     buf[size + sizeof(mtp_data_header)] = '\0';
@@ -166,6 +177,7 @@
     mtp_file_range mfr;
     mfr.command = 42;
     mfr.transaction_id = 1337;
+    mfr.offset = 0;
     int size = TEST_PACKET_SIZE * MED_MULT;
     char buf[size + sizeof(mtp_data_header) + 1];
     buf[size + sizeof(mtp_data_header)] = '\0';
@@ -189,6 +201,70 @@
     EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
 }
 
+TEST_F(MtpFfsHandleTest, testSendFileMedPartial) {
+    std::stringstream ss;
+    mtp_file_range mfr;
+    mfr.fd = dummy_file.fd;
+    mfr.command = 42;
+    mfr.transaction_id = 1337;
+    int size = TEST_PACKET_SIZE * MED_MULT;
+    char buf[size + 1];
+    buf[size] = '\0';
+
+    for (int i = 0; i < MED_MULT; i++)
+        ss << dummyDataStr;
+
+    EXPECT_EQ(write(dummy_file.fd, ss.str().c_str(), size), size);
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<> dis(1, TEST_PACKET_SIZE);
+    int offset = 0;
+    while (offset != size) {
+        mfr.offset = offset;
+        int length = std::min(size - offset, dis(gen));
+        mfr.length = length;
+        char temp_buf[length + sizeof(mtp_data_header)];
+        EXPECT_EQ(handle->sendFile(mfr), 0);
+
+        EXPECT_EQ(read(bulk_in, temp_buf, length + sizeof(mtp_data_header)),
+                static_cast<long>(length + sizeof(mtp_data_header)));
+
+        struct mtp_data_header *header = reinterpret_cast<struct mtp_data_header*>(temp_buf);
+        EXPECT_EQ(header->length, static_cast<unsigned int>(length + sizeof(mtp_data_header)));
+        EXPECT_EQ(header->type, static_cast<unsigned int>(2));
+        EXPECT_EQ(header->command, static_cast<unsigned int>(42));
+        EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
+        memcpy(buf + offset, temp_buf + sizeof(mtp_data_header), length);
+        offset += length;
+    }
+    EXPECT_STREQ(buf, ss.str().c_str());
+}
+
+TEST_F(MtpFfsHandleTest, testSendFileEmpty) {
+    mtp_file_range mfr;
+    mfr.command = 42;
+    mfr.transaction_id = 1337;
+    mfr.offset = 0;
+    int size = 0;
+    char buf[size + sizeof(mtp_data_header) + 1];
+    buf[size + sizeof(mtp_data_header)] = '\0';
+
+    mfr.length = size;
+    mfr.fd = dummy_file.fd;
+
+    EXPECT_EQ(handle->sendFile(mfr), 0);
+
+    EXPECT_EQ(read(bulk_in, buf, size + sizeof(mtp_data_header)),
+            static_cast<long>(size + sizeof(mtp_data_header)));
+
+    struct mtp_data_header *header = reinterpret_cast<struct mtp_data_header*>(buf);
+    EXPECT_EQ(header->length, static_cast<unsigned int>(size + sizeof(mtp_data_header)));
+    EXPECT_EQ(header->type, static_cast<unsigned int>(2));
+    EXPECT_EQ(header->command, static_cast<unsigned int>(42));
+    EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
+}
+
 TEST_F(MtpFfsHandleTest, testSendEvent) {
     struct mtp_event event;
     event.length = TEST_PACKET_SIZE;
diff --git a/services/oboeservice/AAudioServiceStreamFakeHal.cpp b/services/oboeservice/AAudioServiceStreamFakeHal.cpp
index 627a504..1caeb3f 100644
--- a/services/oboeservice/AAudioServiceStreamFakeHal.cpp
+++ b/services/oboeservice/AAudioServiceStreamFakeHal.cpp
@@ -53,13 +53,14 @@
 }
 
 aaudio_result_t AAudioServiceStreamFakeHal::open(aaudio::AAudioStreamRequest &request,
-                                             aaudio::AAudioStreamConfiguration &configuration) {
+                                       aaudio::AAudioStreamConfiguration &configurationOutput) {
     // Open stream on HAL and pass information about the ring buffer to the client.
     mmap_buffer_info mmapInfo;
     aaudio_result_t error;
 
     // Open HAL
-    error = fake_hal_open(CARD_ID, DEVICE_ID, &mStreamId);
+    int bufferCapacity = request.getConfiguration().getBufferCapacity();
+    error = fake_hal_open(CARD_ID, DEVICE_ID, bufferCapacity, &mStreamId);
     if(error < 0) {
         ALOGE("Could not open card %d, device %d", CARD_ID, DEVICE_ID);
         return error;
@@ -87,9 +88,9 @@
          mmapInfo.buffer_capacity_in_bytes);
 
     // Fill in AAudioStreamConfiguration
-    configuration.setSampleRate(mSampleRate);
-    configuration.setSamplesPerFrame(mmapInfo.channel_count);
-    configuration.setAudioFormat(AAUDIO_FORMAT_PCM_I16);
+    configurationOutput.setSampleRate(mSampleRate);
+    configurationOutput.setSamplesPerFrame(mmapInfo.channel_count);
+    configurationOutput.setAudioFormat(AAUDIO_FORMAT_PCM_I16);
 
     return AAUDIO_OK;
 }
diff --git a/services/oboeservice/AAudioServiceStreamFakeHal.h b/services/oboeservice/AAudioServiceStreamFakeHal.h
index 170d0ee..e9480fb 100644
--- a/services/oboeservice/AAudioServiceStreamFakeHal.h
+++ b/services/oboeservice/AAudioServiceStreamFakeHal.h
@@ -37,7 +37,7 @@
     virtual aaudio_result_t getDescription(AudioEndpointParcelable &parcelable) override;
 
     virtual aaudio_result_t open(aaudio::AAudioStreamRequest &request,
-                               aaudio::AAudioStreamConfiguration &configuration) override;
+                                 aaudio::AAudioStreamConfiguration &configurationOutput) override;
 
     /**
      * Start the flow of data.
diff --git a/services/oboeservice/FakeAudioHal.cpp b/services/oboeservice/FakeAudioHal.cpp
index cf0dc86..34a2476 100644
--- a/services/oboeservice/FakeAudioHal.cpp
+++ b/services/oboeservice/FakeAudioHal.cpp
@@ -94,14 +94,25 @@
 #define FRAMES_PER_BURST_QUALCOMM 192
 #define FRAMES_PER_BURST_NVIDIA   128
 
-int fake_hal_open(int card_id, int device_id, fake_hal_stream_ptr *streamPP) {
+int fake_hal_open(int card_id, int device_id,
+                  int frameCapacity,
+                  fake_hal_stream_ptr *streamPP) {
     int framesPerBurst = FRAMES_PER_BURST_QUALCOMM; // TODO update as needed
+    int periodCountRequested = frameCapacity / framesPerBurst;
     int periodCount = 32;
     unsigned int offset1;
     unsigned int frames1;
     void *area = nullptr;
     int mmapAvail = 0;
 
+    // Try to match requested size with a power of 2.
+    while (periodCount < periodCountRequested && periodCount < 1024) {
+        periodCount *= 2;
+    }
+    std::cout << "fake_hal_open() requested frameCapacity = " << frameCapacity << std::endl;
+    std::cout << "fake_hal_open() periodCountRequested = " << periodCountRequested << std::endl;
+    std::cout << "fake_hal_open() periodCount = " << periodCount << std::endl;
+
     // Configuration for an ALSA stream.
     pcm_config cfg;
     memset(&cfg, 0, sizeof(cfg));
diff --git a/services/oboeservice/FakeAudioHal.h b/services/oboeservice/FakeAudioHal.h
index f47ccd9..d3aa4e8 100644
--- a/services/oboeservice/FakeAudioHal.h
+++ b/services/oboeservice/FakeAudioHal.h
@@ -39,7 +39,9 @@
 //extern "C"
 //{
 
-int fake_hal_open(int card_id, int device_id, fake_hal_stream_ptr *stream_pp);
+int fake_hal_open(int card_id, int device_id,
+                  int frameCapacity,
+                  fake_hal_stream_ptr *stream_pp);
 
 int fake_hal_get_mmap_info(fake_hal_stream_ptr stream, mmap_buffer_info *info);