diff --git a/METADATA b/METADATA
index b003168..ab5c8ac 100644
--- a/METADATA
+++ b/METADATA
@@ -1,12 +1,14 @@
 name: "Oboe"
-description:
-    "Native audio API for Android that calls AAudio or OpenSL ES."
-
+description: "Native audio API for Android that calls AAudio or OpenSL ES."
 third_party {
   url {
     type: GIT
     value: "https://github.com/google/oboe"
   }
-  version: "c4d7e73c8fcf5ab2edc85ee48330a43edd5f52fc"
-  last_upgrade_date { year: 2020 month: 2 day: 6 }
+  version: "386f057966b9640a25b63e7ac552d30d66b4e49d"
+  last_upgrade_date {
+    year: 2020
+    month: 9
+    day: 9
+  }
 }
diff --git a/MODULE_LICENSE_APACHE2 b/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_APACHE2
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/apps/OboeTester/app/CMakeLists.txt b/apps/OboeTester/app/CMakeLists.txt
index f2c81c1..8de21f9 100644
--- a/apps/OboeTester/app/CMakeLists.txt
+++ b/apps/OboeTester/app/CMakeLists.txt
@@ -31,4 +31,4 @@
 # link to oboe
 target_link_libraries(oboetester log oboe atomic)
 
-# bump 2 to resync CMake
+# bump 3 to resync CMake
diff --git a/apps/OboeTester/app/build.gradle b/apps/OboeTester/app/build.gradle
index 51911fe..e3aea74 100644
--- a/apps/OboeTester/app/build.gradle
+++ b/apps/OboeTester/app/build.gradle
@@ -7,8 +7,8 @@
         minSdkVersion 23
         targetSdkVersion 28
         // Also update the versions in the AndroidManifest.xml file.
-        versionCode 33
-        versionName "1.5.25"
+        versionCode 35
+        versionName "1.5.27"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
         externalNativeBuild {
             cmake {
diff --git a/apps/OboeTester/app/src/main/AndroidManifest.xml b/apps/OboeTester/app/src/main/AndroidManifest.xml
index 9bbc5a6..37a75b9 100644
--- a/apps/OboeTester/app/src/main/AndroidManifest.xml
+++ b/apps/OboeTester/app/src/main/AndroidManifest.xml
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.google.sample.oboe.manualtest"
-    android:versionCode="33"
-    android:versionName="1.5.25">
+    android:versionCode="35"
+    android:versionName="1.5.27">
     <!-- versionCode and versionName also have to be updated in build.gradle -->
 
     <uses-feature android:name="android.hardware.microphone" android:required="true" />
diff --git a/apps/OboeTester/app/src/main/cpp/AudioStreamGateway.cpp b/apps/OboeTester/app/src/main/cpp/AudioStreamGateway.cpp
index 7dd374f..c473540 100644
--- a/apps/OboeTester/app/src/main/cpp/AudioStreamGateway.cpp
+++ b/apps/OboeTester/app/src/main/cpp/AudioStreamGateway.cpp
@@ -17,6 +17,7 @@
 #include <cstring>
 #include <sched.h>
 
+#include "common/OboeDebug.h"
 #include "oboe/Oboe.h"
 #include "AudioStreamGateway.h"
 
@@ -27,10 +28,7 @@
         void *audioData,
         int numFrames) {
 
-    if (!mSchedulerChecked) {
-        mScheduler = sched_getscheduler(gettid());
-        mSchedulerChecked = true;
-    }
+    printScheduler();
 
     if (mAudioSink != nullptr) {
         mAudioSink->read(audioData, numFrames);
@@ -39,6 +37,3 @@
     return oboe::DataCallbackResult::Continue;
 }
 
-int AudioStreamGateway::getScheduler() {
-    return mScheduler;
-}
diff --git a/apps/OboeTester/app/src/main/cpp/AudioStreamGateway.h b/apps/OboeTester/app/src/main/cpp/AudioStreamGateway.h
index 982d099..0aaf429 100644
--- a/apps/OboeTester/app/src/main/cpp/AudioStreamGateway.h
+++ b/apps/OboeTester/app/src/main/cpp/AudioStreamGateway.h
@@ -21,6 +21,7 @@
 
 #include "flowgraph/FlowGraphNode.h"
 #include "oboe/Oboe.h"
+#include "OboeTesterStreamCallback.h"
 
 using namespace oboe::flowgraph;
 
@@ -29,9 +30,8 @@
  * Pass in an AudioSink and then pass
  * this object to the AudioStreamBuilder as a callback.
  */
-class AudioStreamGateway : public oboe::AudioStreamCallback {
+class AudioStreamGateway : public OboeTesterStreamCallback {
 public:
-//    AudioStreamGateway(int samplesPerFrame);
     virtual ~AudioStreamGateway() = default;
 
     void setAudioSink(std::shared_ptr<oboe::flowgraph::FlowGraphSink>  sink) {
@@ -46,11 +46,8 @@
             void *audioData,
             int numFrames) override;
 
-    int getScheduler();
-
 private:
-    bool     mSchedulerChecked = false;
-    int      mScheduler;
+
     std::shared_ptr<oboe::flowgraph::FlowGraphSink>  mAudioSink;
 };
 
diff --git a/apps/OboeTester/app/src/main/cpp/FullDuplexAnalyzer.cpp b/apps/OboeTester/app/src/main/cpp/FullDuplexAnalyzer.cpp
index c8a99ac..2da2dfd 100644
--- a/apps/OboeTester/app/src/main/cpp/FullDuplexAnalyzer.cpp
+++ b/apps/OboeTester/app/src/main/cpp/FullDuplexAnalyzer.cpp
@@ -19,7 +19,7 @@
 
 oboe::Result  FullDuplexAnalyzer::start() {
     getLoopbackProcessor()->setSampleRate(getOutputStream()->getSampleRate());
-    getLoopbackProcessor()->onStartTest();
+    getLoopbackProcessor()->prepareToTest();
     return FullDuplexStream::start();
 }
 
diff --git a/apps/OboeTester/app/src/main/cpp/InputStreamCallbackAnalyzer.cpp b/apps/OboeTester/app/src/main/cpp/InputStreamCallbackAnalyzer.cpp
index d04f09a..f9290e1 100644
--- a/apps/OboeTester/app/src/main/cpp/InputStreamCallbackAnalyzer.cpp
+++ b/apps/OboeTester/app/src/main/cpp/InputStreamCallbackAnalyzer.cpp
@@ -23,6 +23,8 @@
         int numFrames) {
     int32_t channelCount = audioStream->getChannelCount();
 
+    printScheduler();
+
     if (audioStream->getFormat() == oboe::AudioFormat::I16) {
         int16_t *shortData = (int16_t *) audioData;
         if (mRecording != nullptr) {
diff --git a/apps/OboeTester/app/src/main/cpp/InputStreamCallbackAnalyzer.h b/apps/OboeTester/app/src/main/cpp/InputStreamCallbackAnalyzer.h
index 42ffbfb..fc26b1f 100644
--- a/apps/OboeTester/app/src/main/cpp/InputStreamCallbackAnalyzer.h
+++ b/apps/OboeTester/app/src/main/cpp/InputStreamCallbackAnalyzer.h
@@ -24,17 +24,19 @@
 // TODO #include "flowgraph/FlowGraph.h"
 #include "oboe/Oboe.h"
 #include "MultiChannelRecording.h"
+#include "OboeTesterStreamCallback.h"
 #include "analyzer/PeakDetector.h"
 
 constexpr int kMaxInputChannels = 8;
 
-class InputStreamCallbackAnalyzer : public oboe::AudioStreamCallback  {
+class InputStreamCallbackAnalyzer : public OboeTesterStreamCallback {
 public:
 
     void reset() {
         for (auto detector : mPeakDetectors) {
             detector.reset();
         }
+        OboeTesterStreamCallback::reset();
     }
 
     /**
diff --git a/apps/OboeTester/app/src/main/cpp/NativeAudioContext.cpp b/apps/OboeTester/app/src/main/cpp/NativeAudioContext.cpp
index 0026610..3b51177 100644
--- a/apps/OboeTester/app/src/main/cpp/NativeAudioContext.cpp
+++ b/apps/OboeTester/app/src/main/cpp/NativeAudioContext.cpp
@@ -111,7 +111,6 @@
     for (auto entry : mOboeStreams) {
         oboe::AudioStream *oboeStream = entry.second.get();
         result = oboeStream->requestPause();
-        printScheduler();
     }
     return result;
 }
@@ -122,7 +121,6 @@
     for (auto entry : mOboeStreams) {
         oboe::AudioStream *oboeStream = entry.second.get();
         result = oboeStream->requestStop();
-        printScheduler();
     }
     return result;
 }
@@ -237,6 +235,7 @@
 
     configureForStart();
 
+    audioStreamGateway.reset();
     result = startStreams();
 
     if (!mUseCallback && result == oboe::Result::OK) {
diff --git a/apps/OboeTester/app/src/main/cpp/NativeAudioContext.h b/apps/OboeTester/app/src/main/cpp/NativeAudioContext.h
index d5cb994..bd445d1 100644
--- a/apps/OboeTester/app/src/main/cpp/NativeAudioContext.h
+++ b/apps/OboeTester/app/src/main/cpp/NativeAudioContext.h
@@ -224,13 +224,6 @@
 
     virtual void close(int32_t streamIndex);
 
-    void printScheduler() {
-#if OBOE_ENABLE_LOGGING
-        int scheduler = audioStreamGateway.getScheduler();
-#endif
-        LOGI("scheduler = 0x%08x, SCHED_FIFO = 0x%08X\n", scheduler, SCHED_FIFO);
-    }
-
     virtual void configureForStart() {}
 
     oboe::Result start();
diff --git a/apps/OboeTester/app/src/main/cpp/OboeTesterStreamCallback.cpp b/apps/OboeTester/app/src/main/cpp/OboeTesterStreamCallback.cpp
new file mode 100644
index 0000000..aab60ab
--- /dev/null
+++ b/apps/OboeTester/app/src/main/cpp/OboeTesterStreamCallback.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2020 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.
+ */
+
+
+#include "AudioStreamGateway.h"
+#include "oboe/Oboe.h"
+#include "common/OboeDebug.h"
+#include <sched.h>
+#include <cstring>
+#include "OboeTesterStreamCallback.h"
+
+// Print if scheduler changes.
+void OboeTesterStreamCallback::printScheduler() {
+#if OBOE_ENABLE_LOGGING
+    int scheduler = sched_getscheduler(gettid());
+    if (scheduler != mPreviousScheduler) {
+        int schedulerType = scheduler & 0xFFFF; // mask off high flags
+        LOGD("callback CPU scheduler = 0x%08x = %s",
+             scheduler,
+             ((schedulerType == SCHED_FIFO) ? "SCHED_FIFO" :
+              ((schedulerType == SCHED_OTHER) ? "SCHED_OTHER" :
+               ((schedulerType == SCHED_RR) ? "SCHED_RR" : "UNKNOWN")))
+        );
+        mPreviousScheduler = scheduler;
+    }
+#endif
+}
\ No newline at end of file
diff --git a/apps/OboeTester/app/src/main/cpp/OboeTesterStreamCallback.h b/apps/OboeTester/app/src/main/cpp/OboeTesterStreamCallback.h
new file mode 100644
index 0000000..ec01fe5
--- /dev/null
+++ b/apps/OboeTester/app/src/main/cpp/OboeTesterStreamCallback.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020 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 OBOETESTER_STREAM_CALLBACK_H
+#define OBOETESTER_STREAM_CALLBACK_H
+
+#include <unistd.h>
+#include <sys/types.h>
+#include "flowgraph/FlowGraphNode.h"
+#include "oboe/Oboe.h"
+
+class OboeTesterStreamCallback : public oboe::AudioStreamCallback {
+public:
+    virtual ~OboeTesterStreamCallback() = default;
+
+    // Call this before starting.
+    void reset() {
+        mPreviousScheduler = -1;
+    }
+
+protected:
+    void    printScheduler();
+
+    int     mPreviousScheduler = -1;
+};
+
+
+#endif //OBOETESTER_STREAM_CALLBACK_H
diff --git a/apps/OboeTester/app/src/main/cpp/analyzer/GlitchAnalyzer.h b/apps/OboeTester/app/src/main/cpp/analyzer/GlitchAnalyzer.h
index 7a496f3..4d1bd6f 100644
--- a/apps/OboeTester/app/src/main/cpp/analyzer/GlitchAnalyzer.h
+++ b/apps/OboeTester/app/src/main/cpp/analyzer/GlitchAnalyzer.h
@@ -14,17 +14,20 @@
  * limitations under the License.
  */
 
-#ifndef OBOETESTER_GLITCHANALYZER_H
-#define OBOETESTER_GLITCHANALYZER_H
+#ifndef ANALYZER_GLITCH_ANALYZER_H
+#define ANALYZER_GLITCH_ANALYZER_H
 
+#include <algorithm>
 #include <cctype>
+#include <iomanip>
+#include <iostream>
 
-#include "PseudoRandom.h"
-#include "LatencyAnalyzer.h"
 #include "InfiniteRecording.h"
+#include "LatencyAnalyzer.h"
+#include "PseudoRandom.h"
 
 /**
- * Output a steady sinewave and analyze the return signal.
+ * Output a steady sine wave and analyze the return signal.
  *
  * Use a cosine transform to measure the predicted magnitude and relative phase of the
  * looped back sine wave. Then generate a predicted signal and compare with the actual signal.
@@ -36,19 +39,19 @@
             : LoopbackProcessor()
             , mInfiniteRecording(64 * 1024) {}
 
-    int32_t getState() {
+    int32_t getState() const {
         return mState;
     }
 
-    float getPeakAmplitude() {
+    double getPeakAmplitude() const {
         return mPeakFollower.getLevel();
     }
 
-    float getTolerance() {
+    double getTolerance() {
         return mTolerance;
     }
 
-    void setTolerance(float tolerance) {
+    void setTolerance(double tolerance) {
         mTolerance = tolerance;
         mScaledTolerance = mMagnitude * mTolerance;
     }
@@ -58,11 +61,11 @@
         mScaledTolerance = mMagnitude * mTolerance;
     }
 
-    int32_t getGlitchCount() {
+    int32_t getGlitchCount() const {
         return mGlitchCount;
     }
 
-    int32_t getStateFrameCount(int state) {
+    int32_t getStateFrameCount(int state) const {
         return mStateFrameCounters[state];
     }
 
@@ -73,55 +76,72 @@
         } else {
             double signalToNoise = mMeanSquareSignal / mMeanSquareNoise; // power ratio
             double signalToNoiseDB = 10.0 * log(signalToNoise);
-            if (signalToNoiseDB < MIN_SNRATIO_DB) {
-                LOGD("ERROR - signal to noise ratio is too low! < %d dB. Adjust volume.",
-                     MIN_SNRATIO_DB);
+            if (signalToNoiseDB < MIN_SNR_DB) {
+                ALOGD("ERROR - signal to noise ratio is too low! < %d dB. Adjust volume.",
+                     MIN_SNR_DB);
                 setResult(ERROR_VOLUME_TOO_LOW);
             }
             return signalToNoiseDB;
         }
     }
 
-    void analyze() override {
-        LOGD("GlitchAnalyzer ------------------");
-        LOGD(LOOPBACK_RESULT_TAG "peak.amplitude     = %8f", getPeakAmplitude());
-        LOGD(LOOPBACK_RESULT_TAG "sine.magnitude     = %8f", mMagnitude);
-        LOGD(LOOPBACK_RESULT_TAG "rms.noise          = %8f", mMeanSquareNoise);
-        LOGD(LOOPBACK_RESULT_TAG "signal.to.noise.db = %8.2f", getSignalToNoiseDB());
-        LOGD(LOOPBACK_RESULT_TAG "frames.accumulated = %8d", mFramesAccumulated);
-        LOGD(LOOPBACK_RESULT_TAG "sine.period        = %8d", mSinePeriod);
-        LOGD(LOOPBACK_RESULT_TAG "test.state         = %8d", mState);
-        LOGD(LOOPBACK_RESULT_TAG "frame.count        = %8d", mFrameCounter);
+    std::string analyze() override {
+        std::stringstream report;
+        report << "GlitchAnalyzer ------------------\n";
+        report << LOOPBACK_RESULT_TAG "peak.amplitude     = " << std::setw(8)
+               << getPeakAmplitude() << "\n";
+        report << LOOPBACK_RESULT_TAG "sine.magnitude     = " << std::setw(8)
+               << mMagnitude << "\n";
+        report << LOOPBACK_RESULT_TAG "rms.noise          = " << std::setw(8)
+               << mMeanSquareNoise << "\n";
+        report << LOOPBACK_RESULT_TAG "signal.to.noise.db = " << std::setw(8)
+               << getSignalToNoiseDB() << "\n";
+        report << LOOPBACK_RESULT_TAG "frames.accumulated = " << std::setw(8)
+               << mFramesAccumulated << "\n";
+        report << LOOPBACK_RESULT_TAG "sine.period        = " << std::setw(8)
+               << mSinePeriod << "\n";
+        report << LOOPBACK_RESULT_TAG "test.state         = " << std::setw(8)
+               << mState << "\n";
+        report << LOOPBACK_RESULT_TAG "frame.count        = " << std::setw(8)
+               << mFrameCounter << "\n";
         // Did we ever get a lock?
         bool gotLock = (mState == STATE_LOCKED) || (mGlitchCount > 0);
         if (!gotLock) {
-            LOGD("ERROR - failed to lock on reference sine tone");
+            report << "ERROR - failed to lock on reference sine tone.\n";
             setResult(ERROR_NO_LOCK);
         } else {
             // Only print if meaningful.
-            LOGD(LOOPBACK_RESULT_TAG "glitch.count       = %8d", mGlitchCount);
-            LOGD(LOOPBACK_RESULT_TAG "max.glitch         = %8f", mMaxGlitchDelta);
+            report << LOOPBACK_RESULT_TAG "glitch.count       = " << std::setw(8)
+                   << mGlitchCount << "\n";
+            report << LOOPBACK_RESULT_TAG "max.glitch         = " << std::setw(8)
+                   << mMaxGlitchDelta << "\n";
             if (mGlitchCount > 0) {
-                LOGD("ERROR - number of glitches > 0");
+                report << "ERROR - number of glitches > 0\n";
                 setResult(ERROR_GLITCHES);
             }
         }
+        return report.str();
     }
 
     void printStatus() override {
-        LOGD("st = %d, #gl = %3d,", mState, mGlitchCount);
+        ALOGD("st = %d, #gl = %3d,", mState, mGlitchCount);
     }
-
-    double calculateMagnitude(double *phasePtr = NULL) {
+    /**
+     * Calculate the magnitude of the component of the input signal
+     * that matches the analysis frequency.
+     * Also calculate the phase that we can use to create a
+     * signal that matches that component.
+     * The phase will be between -PI and +PI.
+     */
+    double calculateMagnitude(double *phasePtr = nullptr) {
         if (mFramesAccumulated == 0) {
             return 0.0;
         }
         double sinMean = mSinAccumulator / mFramesAccumulated;
         double cosMean = mCosAccumulator / mFramesAccumulated;
-        double magnitude = 2.0 * sqrt( (sinMean * sinMean) + (cosMean * cosMean ));
-        if( phasePtr != NULL )
-        {
-            double phase = M_PI_2 - atan2( sinMean, cosMean );
+        double magnitude = 2.0 * sqrt((sinMean * sinMean) + (cosMean * cosMean));
+        if (phasePtr != nullptr) {
+            double phase = M_PI_2 - atan2(sinMean, cosMean);
             *phasePtr = phase;
         }
         return magnitude;
@@ -131,19 +151,20 @@
      * @param frameData contains microphone data with sine signal feedback
      * @param channelCount
      */
-    result_code processInputFrame(float *frameData, int channelCount) override {
+    result_code processInputFrame(float *frameData, int /* channelCount */) override {
         result_code result = RESULT_OK;
 
         float sample = frameData[0];
         float peak = mPeakFollower.process(sample);
         mInfiniteRecording.write(sample);
 
-        // Force a periodic glitch!
+        // Force a periodic glitch to test the detector!
         if (mForceGlitchDuration > 0) {
             if (mForceGlitchCounter == 0) {
-                LOGE("%s: force a glitch!!", __func__);
+                ALOGE("%s: force a glitch!!", __func__);
                 mForceGlitchCounter = getSampleRate();
             } else if (mForceGlitchCounter <= mForceGlitchDuration) {
+                // Force an abrupt offset.
                 sample += (sample > 0.0) ? -0.5f : 0.5f;
             }
             --mForceGlitchCounter;
@@ -172,7 +193,7 @@
             case STATE_WAITING_FOR_SIGNAL:
                 if (peak > mThreshold) {
                     mState = STATE_WAITING_FOR_LOCK;
-                    //LOGD("%5d: switch to STATE_WAITING_FOR_LOCK", mFrameCounter);
+                    //ALOGD("%5d: switch to STATE_WAITING_FOR_LOCK", mFrameCounter);
                     resetAccumulator();
                 }
                 break;
@@ -185,12 +206,12 @@
                 if (mFramesAccumulated == mSinePeriod * PERIODS_NEEDED_FOR_LOCK) {
                     double phaseOffset = 0.0;
                     setMagnitude(calculateMagnitude(&phaseOffset));
-//                    LOGD("%s() mag = %f, offset = %f, prev = %f",
+//                    ALOGD("%s() mag = %f, offset = %f, prev = %f",
 //                            __func__, mMagnitude, mPhaseOffset, mPreviousPhaseOffset);
                     if (mMagnitude > mThreshold) {
                         if (abs(phaseOffset) < kMaxPhaseError) {
                             mState = STATE_LOCKED;
-//                            LOGD("%5d: switch to STATE_LOCKED", mFrameCounter);
+//                            ALOGD("%5d: switch to STATE_LOCKED", mFrameCounter);
                         }
                         // Adjust mInputPhase to match measured phase
                         mInputPhase += phaseOffset;
@@ -202,9 +223,9 @@
 
             case STATE_LOCKED: {
                 // Predict next sine value
-                float predicted = sinf(mInputPhase) * mMagnitude;
-                float diff = predicted - sample;
-                float absDiff = fabs(diff);
+                double predicted = sinf(mInputPhase) * mMagnitude;
+                double diff = predicted - sample;
+                double absDiff = fabs(diff);
                 mMaxGlitchDelta = std::max(mMaxGlitchDelta, absDiff);
                 if (absDiff > mScaledTolerance) {
                     result = ERROR_GLITCHES;
@@ -233,11 +254,11 @@
                         if (abs(phaseOffset) > kMaxPhaseError) {
                             result = ERROR_GLITCHES;
                             onGlitchStart();
-                            LOGD("phase glitch detected, phaseOffset = %g", phaseOffset);
+                            ALOGD("phase glitch detected, phaseOffset = %g", phaseOffset);
                         } else if (mMagnitude < mThreshold) {
                             result = ERROR_GLITCHES;
                             onGlitchStart();
-                            LOGD("magnitude glitch detected, mMagnitude = %g", mMagnitude);
+                            ALOGD("magnitude glitch detected, mMagnitude = %g", mMagnitude);
                         }
                     }
                 }
@@ -247,9 +268,9 @@
             case STATE_GLITCHING: {
                 // Predict next sine value
                 mGlitchLength++;
-                float predicted = sinf(mInputPhase) * mMagnitude;
-                float diff = predicted - sample;
-                float absDiff = fabs(diff);
+                double predicted = sinf(mInputPhase) * mMagnitude;
+                double diff = predicted - sample;
+                double absDiff = fabs(diff);
                 mMaxGlitchDelta = std::max(mMaxGlitchDelta, absDiff);
                 if (absDiff < mScaledTolerance) { // close enough?
                     // If we get a full sine period of non-glitch samples in a row then consider the glitch over.
@@ -303,7 +324,7 @@
             incrementOutputPhase();
             output = (sinOut * mOutputAmplitude)
                      + (mWhiteNoise.nextRandomDouble() * kNoiseAmplitude);
-            // LOGD("%5d: sin(%f) = %f, %f", i, mPhase, sinOut,  mPhaseIncrement);
+            // ALOGD("sin(%f) = %f, %f\n", mOutputPhase, sinOut,  mPhaseIncrement);
         }
         frameData[0] = output;
         for (int i = 1; i < channelCount; i++) {
@@ -314,7 +335,7 @@
 
     void onGlitchStart() {
         mGlitchCount++;
-//        LOGD("%5d: STARTED a glitch # %d", mFrameCounter, mGlitchCount);
+//        ALOGD("%5d: STARTED a glitch # %d", mFrameCounter, mGlitchCount);
         mState = STATE_GLITCHING;
         mGlitchLength = 1;
         mNonGlitchCount = 0;
@@ -322,7 +343,7 @@
     }
 
     void onGlitchEnd() {
-//        LOGD("%5d: ENDED a glitch # %d, length = %d", mFrameCounter, mGlitchCount, mGlitchLength);
+//        ALOGD("%5d: ENDED a glitch # %d, length = %d", mFrameCounter, mGlitchCount, mGlitchLength);
         mState = STATE_LOCKED;
         resetAccumulator();
     }
@@ -337,7 +358,7 @@
     }
 
     void relock() {
-//        LOGD("relock: %d because of a very long %d glitch", mFrameCounter, mGlitchLength);
+//        ALOGD("relock: %d because of a very long %d glitch", mFrameCounter, mGlitchLength);
         mState = STATE_WAITING_FOR_LOCK;
         resetAccumulator();
     }
@@ -349,8 +370,8 @@
         resetAccumulator();
     }
 
-    void onStartTest() override {
-        LoopbackProcessor::onStartTest();
+    void prepareToTest() override {
+        LoopbackProcessor::prepareToTest();
         mSinePeriod = getSampleRate() / kTargetGlitchFrequency;
         mOutputPhase = 0.0f;
         mInverseSinePeriod = 1.0 / mSinePeriod;
@@ -362,7 +383,6 @@
         }
     }
 
-
     int32_t getLastGlitch(float *buffer, int32_t length) {
         return mInfiniteRecording.readFrom(buffer, mLastGlitchPosition - 32, length);
     }
@@ -382,10 +402,10 @@
 
     enum constants {
         // Arbitrary durations, assuming 48000 Hz
-                IDLE_FRAME_COUNT = 48 * 100,
+        IDLE_FRAME_COUNT = 48 * 100,
         IMMUNE_FRAME_COUNT = 48 * 100,
         PERIODS_NEEDED_FOR_LOCK = 8,
-        MIN_SNRATIO_DB = 65
+        MIN_SNR_DB = 65
     };
 
     static constexpr float kNoiseAmplitude = 0.00; // Used to experiment with warbling caused by DRC.
@@ -406,14 +426,15 @@
     int32_t mFramesAccumulated = 0;
     double  mSinAccumulator = 0.0;
     double  mCosAccumulator = 0.0;
-    float   mMaxGlitchDelta = 0.0f;
+    double  mMaxGlitchDelta = 0.0;
     int32_t mGlitchCount = 0;
     int32_t mNonGlitchCount = 0;
     int32_t mGlitchLength = 0;
-    float   mScaledTolerance = 0.0;
+    // This is used for processing every frame so we cache it here.
+    double  mScaledTolerance = 0.0;
     int     mDownCounter = IDLE_FRAME_COUNT;
     int32_t mFrameCounter = 0;
-    float   mOutputAmplitude = 0.75;
+    double  mOutputAmplitude = 0.75;
 
     int32_t mForceGlitchDuration = 0; // if > 0 then force a glitch for debugging
     int32_t mForceGlitchCounter = 4 * 48000; // count down and trigger at zero
@@ -435,4 +456,4 @@
 };
 
 
-#endif //OBOETESTER_GLITCHANALYZER_H
+#endif //ANALYZER_GLITCH_ANALYZER_H
diff --git a/apps/OboeTester/app/src/main/cpp/analyzer/LatencyAnalyzer.h b/apps/OboeTester/app/src/main/cpp/analyzer/LatencyAnalyzer.h
index d0d1aa8..3178c6e 100644
--- a/apps/OboeTester/app/src/main/cpp/analyzer/LatencyAnalyzer.h
+++ b/apps/OboeTester/app/src/main/cpp/analyzer/LatencyAnalyzer.h
@@ -25,16 +25,26 @@
 #include <algorithm>
 #include <assert.h>
 #include <cctype>
+#include <iomanip>
+#include <iostream>
 #include <math.h>
 #include <memory>
+#include <sstream>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <vector>
 
-#include "RandomPulseGenerator.h"
 #include "PeakDetector.h"
 #include "PseudoRandom.h"
+#include "RandomPulseGenerator.h"
+
+// This is used when the code is in Oboe.
+#ifndef ALOGD
+#define ALOGD LOGD
+#define ALOGE LOGE
+#define ALOGW LOGW
+#endif
 
 #define LOOPBACK_RESULT_TAG  "RESULT: "
 
@@ -43,7 +53,7 @@
 static constexpr int32_t kMaxLatencyMillis  = 700;  // arbitrary and generous
 static constexpr double  kMinimumConfidence = 0.2;
 
-typedef struct LatencyReport_s {
+struct LatencyReport {
     int32_t latencyInFrames = 0.0;
     double confidence = 0.0;
 
@@ -51,13 +61,12 @@
         latencyInFrames = 0;
         confidence = 0.0;
     }
-} LatencyReport;
+};
 
 // Calculate a normalized cross correlation.
 static double calculateNormalizedCorrelation(const float *a,
                                              const float *b,
-                                             int windowSize)
-{
+                                             int windowSize) {
     double correlation = 0.0;
     double sumProducts = 0.0;
     double sumSquares = 0.0;
@@ -72,7 +81,7 @@
     }
 
     if (sumSquares >= 1.0e-9) {
-        correlation = (float) (2.0 * sumProducts / sumSquares);
+        correlation = 2.0 * sumProducts / sumSquares;
     }
     return correlation;
 }
@@ -92,15 +101,9 @@
 class AudioRecording
 {
 public:
-    AudioRecording() {
-    }
-    ~AudioRecording() {
-        delete[] mData;
-    }
 
     void allocate(int maxFrames) {
-        delete[] mData;
-        mData = new float[maxFrames];
+        mData = std::make_unique<float[]>(maxFrames);
         mMaxFrames = maxFrames;
     }
 
@@ -133,30 +136,31 @@
         // stop at end of buffer
         if (mFrameCounter < mMaxFrames) {
             mData[mFrameCounter++] = sample;
+            return 1;
         }
-        return 1;
+        return 0;
     }
 
     void clear() {
         mFrameCounter = 0;
     }
-    int32_t size() {
+    int32_t size() const {
         return mFrameCounter;
     }
 
-    bool isFull() {
+    bool isFull() const {
         return mFrameCounter >= mMaxFrames;
     }
 
-    float *getData() {
-        return mData;
+    float *getData() const {
+        return mData.get();
     }
 
     void setSampleRate(int32_t sampleRate) {
         mSampleRate = sampleRate;
     }
 
-    int32_t getSampleRate() {
+    int32_t getSampleRate() const {
         return mSampleRate;
     }
 
@@ -164,9 +168,9 @@
      * Square the samples so they are all positive and so the peaks are emphasized.
      */
     void square() {
+        float *x = mData.get();
         for (int i = 0; i < mFrameCounter; i++) {
-            const float sample = mData[i];
-            mData[i] = sample * sample;
+            x[i] *= x[i];
         }
     }
 
@@ -189,7 +193,7 @@
     }
 
 private:
-    float        *mData = nullptr;
+    std::unique_ptr<float[]> mData;
     int32_t       mFrameCounter = 0;
     int32_t       mMaxFrames = 0;
     int32_t       mSampleRate = kDefaultSampleRate; // common default
@@ -197,7 +201,6 @@
 
 static int measureLatencyFromPulse(AudioRecording &recorded,
                                    AudioRecording &pulse,
-                                   int32_t framesPerEncodedBit,
                                    LatencyReport *report) {
 
     report->latencyInFrames = 0;
@@ -205,7 +208,7 @@
 
     int numCorrelations = recorded.size() - pulse.size();
     if (numCorrelations < 10) {
-        LOGE("%s() recording too small = %d frames", __func__, recorded.size());
+        ALOGE("%s() recording too small = %d frames\n", __func__, recorded.size());
         return -1;
     }
     std::unique_ptr<float[]> correlations= std::make_unique<float[]>(numCorrelations);
@@ -229,9 +232,20 @@
         }
     }
     if (peakIndex < 0) {
-        LOGE("%s() no signal for correlation", __func__);
+        ALOGE("%s() no signal for correlation\n", __func__);
         return -2;
     }
+#if 0
+    // Dump correlation data for charting.
+    else {
+        const int margin = 50;
+        int startIndex = std::max(0, peakIndex - margin);
+        int endIndex = std::min(numCorrelations - 1, peakIndex + margin);
+        for (int index = startIndex; index < endIndex; index++) {
+            ALOGD("Correlation, %d, %f", index, correlations[index]);
+        }
+    }
+#endif
 
     report->latencyInFrames = peakIndex;
     report->confidence = peakCorrelation;
@@ -244,7 +258,6 @@
 public:
     virtual ~LoopbackProcessor() = default;
 
-    // Note that these values must match the switch in RoundTripLatencyActivity.h
     enum result_code {
         RESULT_OK = 0,
         ERROR_NOISY = -99,
@@ -256,7 +269,7 @@
         ERROR_NO_LOCK
     };
 
-    virtual void onStartTest() {
+    virtual void prepareToTest() {
         reset();
     }
 
@@ -269,7 +282,7 @@
     virtual result_code processOutputFrame(float *frameData, int channelCount) = 0;
 
     void process(float *inputData, int inputChannelCount, int numInputFrames,
-                        float *outputData, int outputChannelCount, int numOutputFrames) {
+                 float *outputData, int outputChannelCount, int numOutputFrames) {
         int numBoth = std::min(numInputFrames, numOutputFrames);
         // Process one frame at a time.
         for (int i = 0; i < numBoth; i++) {
@@ -290,7 +303,7 @@
         }
     }
 
-    virtual void analyze() = 0;
+    virtual std::string analyze() = 0;
 
     virtual void printStatus() {};
 
@@ -320,11 +333,11 @@
         mSampleRate = sampleRate;
     }
 
-    int32_t getSampleRate() {
+    int32_t getSampleRate() const {
         return mSampleRate;
     }
 
-    int32_t getResetCount() {
+    int32_t getResetCount() const {
         return mResetCount;
     }
 
@@ -348,7 +361,7 @@
     LatencyAnalyzer() : LoopbackProcessor() {}
     virtual ~LatencyAnalyzer() = default;
 
-    virtual int32_t getProgress() = 0;
+    virtual int32_t getProgress() const = 0;
 
     virtual int getState() = 0;
 
@@ -380,7 +393,6 @@
                 / (kFramesPerEncodedBit * kMillisPerSecond);
         int32_t  pulseLength = numPulseBits * kFramesPerEncodedBit;
         mFramesToRecord = pulseLength + maxLatencyFrames;
-        LOGD("PulseLatencyAnalyzer: allocate recording with %d frames", mFramesToRecord);
         mAudioRecording.allocate(mFramesToRecord);
         mAudioRecording.setSampleRate(getSampleRate());
         generateRandomPulse(pulseLength);
@@ -405,7 +417,8 @@
 
     void reset() override {
         LoopbackProcessor::reset();
-        mDownCounter = getSampleRate() / 2;
+        mState = STATE_MEASURE_BACKGROUND;
+        mDownCounter = (int32_t) (getSampleRate() * kBackgroundMeasurementLengthSeconds);
         mLoopCounter = 0;
 
         mPulseCursor = 0;
@@ -414,8 +427,6 @@
         mBackgroundRMS = 0.0f;
         mSignalRMS = 0.0f;
 
-        LOGD("state reset to STATE_MEASURE_BACKGROUND");
-        mState = STATE_MEASURE_BACKGROUND;
         mAudioRecording.clear();
         mLatencyReport.reset();
     }
@@ -428,51 +439,53 @@
         return mState == STATE_DONE;
     }
 
-    int32_t getProgress() override {
+    int32_t getProgress() const override {
         return mAudioRecording.size();
     }
 
-    void analyze() override {
-        LOGD("PulseLatencyAnalyzer ---------------");
-        LOGD(LOOPBACK_RESULT_TAG "test.state             = %8d", mState);
-        LOGD(LOOPBACK_RESULT_TAG "test.state.name        = %8s", convertStateToText(mState));
-        LOGD(LOOPBACK_RESULT_TAG "background.rms         = %8f", mBackgroundRMS);
+    std::string analyze() override {
+        std::stringstream report;
+        report << "PulseLatencyAnalyzer ---------------\n";
+        report << LOOPBACK_RESULT_TAG "test.state             = "
+                << std::setw(8) << mState << "\n";
+        report << LOOPBACK_RESULT_TAG "test.state.name        = "
+                << convertStateToText(mState) << "\n";
+        report << LOOPBACK_RESULT_TAG "background.rms         = "
+                << std::setw(8) << mBackgroundRMS << "\n";
 
         int32_t newResult = RESULT_OK;
         if (mState != STATE_GOT_DATA) {
-            LOGD("WARNING - Bad state. Check volume on device.");
+            report << "WARNING - Bad state. Check volume on device.\n";
             // setResult(ERROR_INVALID_STATE);
         } else {
-            LOGD("Please wait several seconds for cross-correlation to complete.");
             float gain = mAudioRecording.normalize(1.0f);
             measureLatencyFromPulse(mAudioRecording,
                                     mPulse,
-                                    kFramesPerEncodedBit,
                                     &mLatencyReport);
 
             if (mLatencyReport.confidence < kMinimumConfidence) {
-                LOGD("   ERROR - confidence too low!");
+                report << "   ERROR - confidence too low!";
                 newResult = ERROR_CONFIDENCE;
             } else {
                 mSignalRMS = calculateRootMeanSquare(
                         &mAudioRecording.getData()[mLatencyReport.latencyInFrames], mPulse.size())
                                 / gain;
             }
-#if OBOE_ENABLE_LOGGING
             double latencyMillis = kMillisPerSecond * (double) mLatencyReport.latencyInFrames
                                    / getSampleRate();
-#endif
-            LOGD(LOOPBACK_RESULT_TAG "latency.frames         = %8d",
-                   mLatencyReport.latencyInFrames);
-            LOGD(LOOPBACK_RESULT_TAG "latency.msec           = %8.2f",
-                   latencyMillis);
-            LOGD(LOOPBACK_RESULT_TAG "latency.confidence     = %8.6f",
-                   mLatencyReport.confidence);
+            report << LOOPBACK_RESULT_TAG "latency.frames         = " << std::setw(8)
+                   << mLatencyReport.latencyInFrames << "\n";
+            report << LOOPBACK_RESULT_TAG "latency.msec           = " << std::setw(8)
+                   << latencyMillis << "\n";
+            report << LOOPBACK_RESULT_TAG "latency.confidence     = " << std::setw(8)
+                   << mLatencyReport.confidence << "\n";
         }
         mState = STATE_DONE;
         if (getResult() == RESULT_OK) {
             setResult(newResult);
         }
+
+        return report.str();
     }
 
     int32_t getMeasuredLatency() override {
@@ -491,8 +504,12 @@
         return mSignalRMS;
     }
 
+    bool isRecordingComplete() {
+        return mState == STATE_GOT_DATA;
+    }
+
     void printStatus() override {
-        LOGD("st = %d", mState);
+        ALOGD("latency: st = %d = %s", mState, convertStateToText(mState));
     }
 
     result_code processInputFrame(float *frameData, int channelCount) override {
@@ -509,7 +526,6 @@
                     mBackgroundRMS = sqrtf(mBackgroundSumSquare / mBackgroundSumCount);
                     nextState = STATE_IN_PULSE;
                     mPulseCursor = 0;
-                    LOGD("LatencyAnalyzer state => STATE_SENDING_PULSE");
                 }
                 break;
 
@@ -517,7 +533,6 @@
                 // Record input until the mAudioRecording is full.
                 mAudioRecording.write(frameData, channelCount, 1);
                 if (hasEnoughData()) {
-                    LOGD("LatencyAnalyzer state => STATE_GOT_DATA");
                     nextState = STATE_GOT_DATA;
                 }
                 break;
@@ -570,22 +585,17 @@
     };
 
     const char *convertStateToText(echo_state state) {
-        const char *result = "Unknown";
-        switch(state) {
+        switch (state) {
             case STATE_MEASURE_BACKGROUND:
-                result = "INIT";
-                break;
+                return "INIT";
             case STATE_IN_PULSE:
-                result = "PULSE";
-                break;
+                return "PULSE";
             case STATE_GOT_DATA:
-                result = "GOT_DATA";
-                break;
+                return "GOT_DATA";
             case STATE_DONE:
-                result = "DONE";
-                break;
+                return "DONE";
         }
-        return result;
+        return "UNKNOWN";
     }
 
     int32_t         mDownCounter = 500;
@@ -594,14 +604,15 @@
 
     static constexpr int32_t kFramesPerEncodedBit = 8; // multiple of 2
     static constexpr int32_t kPulseLengthMillis = 500;
+    static constexpr double  kBackgroundMeasurementLengthSeconds = 0.5;
 
     AudioRecording     mPulse;
     int32_t            mPulseCursor = 0;
 
-    float              mBackgroundSumSquare = 0.0f;
+    double             mBackgroundSumSquare = 0.0;
     int32_t            mBackgroundSumCount = 0;
-    float              mBackgroundRMS = 0.0f;
-    float              mSignalRMS = 0.0f;
+    double             mBackgroundRMS = 0.0;
+    double             mSignalRMS = 0.0;
     int32_t            mFramesToRecord = 0;
 
     AudioRecording     mAudioRecording; // contains only the input after starting the pulse
diff --git a/apps/OboeTester/app/src/main/cpp/analyzer/ManchesterEncoder.h b/apps/OboeTester/app/src/main/cpp/analyzer/ManchesterEncoder.h
index b3d12b3..0a4bd5b 100644
--- a/apps/OboeTester/app/src/main/cpp/analyzer/ManchesterEncoder.h
+++ b/apps/OboeTester/app/src/main/cpp/analyzer/ManchesterEncoder.h
@@ -41,6 +41,8 @@
             , mCursor(samplesPerPulse) {
     }
 
+    virtual ~ManchesterEncoder() = default;
+
     /**
      * This will be called when the next byte is needed.
      * @return
@@ -64,10 +66,10 @@
     /**
      * This will be called when a new bit is ready to be encoded.
      * It can be used to prepare the encoded samples.
-     * @param current 
+     * @param current
      */
-    virtual void onNextBit(bool current) {};
-    
+    virtual void onNextBit(bool /* current */) {};
+
     void advanceSample() {
         // Are we ready for a new bit?
         if (++mCursor >= mSamplesPerPulse) {
diff --git a/apps/OboeTester/app/src/main/cpp/analyzer/PeakDetector.h b/apps/OboeTester/app/src/main/cpp/analyzer/PeakDetector.h
index 9139e42..4b3b4e7 100644
--- a/apps/OboeTester/app/src/main/cpp/analyzer/PeakDetector.h
+++ b/apps/OboeTester/app/src/main/cpp/analyzer/PeakDetector.h
@@ -19,6 +19,11 @@
 
 #include <math.h>
 
+/**
+ * Measure a peak envelope by rising with the peaks,
+ * and decaying exponentially after each peak.
+ * The absolute value of the input signal is used.
+ */
 class PeakDetector {
 public:
 
@@ -27,20 +32,35 @@
     }
 
     double process(double input) {
-        mLevel *= mDecay;
+        mLevel *= mDecay; // exponential decay
         input = fabs(input);
+        // never fall below the input signal
         if (input > mLevel) {
             mLevel = input;
         }
         return mLevel;
     }
 
-    double getLevel() {
+    double getLevel() const {
         return mLevel;
     }
 
+    double getDecay() const {
+        return mDecay;
+    }
+
+    /**
+     * Multiply the level by this amount on every iteration.
+     * This provides an exponential decay curve.
+     * A value just under 1.0 is best, for example, 0.99;
+     * @param decay scale level for each input
+     */
+    void setDecay(double decay) {
+        mDecay = decay;
+    }
+
 private:
-    static constexpr float kDefaultDecay = 0.99f;
+    static constexpr double kDefaultDecay = 0.99f;
 
     double mLevel = 0.0;
     double mDecay = kDefaultDecay;
diff --git a/apps/OboeTester/app/src/main/cpp/analyzer/PseudoRandom.h b/apps/OboeTester/app/src/main/cpp/analyzer/PseudoRandom.h
index 4aedbe0..1c4938c 100644
--- a/apps/OboeTester/app/src/main/cpp/analyzer/PseudoRandom.h
+++ b/apps/OboeTester/app/src/main/cpp/analyzer/PseudoRandom.h
@@ -22,8 +22,7 @@
 
 class PseudoRandom {
 public:
-    PseudoRandom() {}
-    PseudoRandom(int64_t seed)
+    PseudoRandom(int64_t seed = 99887766)
             :    mSeed(seed)
     {}
 
@@ -36,7 +35,8 @@
         return nextRandomInteger() * (0.5 / (((int32_t)1) << 30));
     }
 
-    /** Calculate random 32 bit number using linear-congruential method.
+    /** Calculate random 32 bit number using linear-congruential method
+     * with known real-time performance.
      */
     int32_t nextRandomInteger() {
 #if __has_builtin(__builtin_mul_overflow) && __has_builtin(__builtin_add_overflow)
@@ -51,7 +51,7 @@
     }
 
 private:
-    int64_t mSeed = 99887766;
+    int64_t mSeed;
 };
 
 #endif //ANALYZER_PSEUDORANDOM_H
diff --git a/apps/OboeTester/app/src/main/cpp/analyzer/RandomPulseGenerator.h b/apps/OboeTester/app/src/main/cpp/analyzer/RandomPulseGenerator.h
index f0623cc..030050b 100644
--- a/apps/OboeTester/app/src/main/cpp/analyzer/RandomPulseGenerator.h
+++ b/apps/OboeTester/app/src/main/cpp/analyzer/RandomPulseGenerator.h
@@ -29,12 +29,14 @@
     : RoundedManchesterEncoder(samplesPerPulse) {
     }
 
+    virtual ~RandomPulseGenerator() = default;
+
     /**
      * This will be called when the next byte is needed.
      * @return random byte
      */
     uint8_t onNextByte() override {
-        return static_cast<uint8_t>(rand() & 0x00FF);
+        return static_cast<uint8_t>(rand());
     }
 };
 
diff --git a/apps/OboeTester/app/src/main/cpp/analyzer/RoundedManchesterEncoder.h b/apps/OboeTester/app/src/main/cpp/analyzer/RoundedManchesterEncoder.h
index b1ba949..f2eba84 100644
--- a/apps/OboeTester/app/src/main/cpp/analyzer/RoundedManchesterEncoder.h
+++ b/apps/OboeTester/app/src/main/cpp/analyzer/RoundedManchesterEncoder.h
@@ -35,30 +35,30 @@
         mZeroAfterZero = std::make_unique<float[]>(samplesPerPulse);
         mZeroAfterOne = std::make_unique<float[]>(samplesPerPulse);
 
-        int i = 0;
-        for (int j = 0; j < rampSize; j++) {
-            float phase = (j + 1) * M_PI / rampSize;
+        int sampleIndex = 0;
+        for (int rampIndex = 0; rampIndex < rampSize; rampIndex++) {
+            float phase = (rampIndex + 1) * M_PI / rampSize;
             float sample = -cosf(phase);
-            mZeroAfterZero[i] = sample;
-            mZeroAfterOne[i] = 1.0f;
-            i++;
+            mZeroAfterZero[sampleIndex] = sample;
+            mZeroAfterOne[sampleIndex] = 1.0f;
+            sampleIndex++;
         }
-        for (int j = 0; j < rampSize; j++) {
-            mZeroAfterZero[i] = 1.0f;
-            mZeroAfterOne[i] = 1.0f;
-            i++;
+        for (int rampIndex = 0; rampIndex < rampSize; rampIndex++) {
+            mZeroAfterZero[sampleIndex] = 1.0f;
+            mZeroAfterOne[sampleIndex] = 1.0f;
+            sampleIndex++;
         }
-        for (int j = 0; j < rampSize; j++) {
-            float phase = (j + 1) * M_PI / rampSize;
+        for (int rampIndex = 0; rampIndex < rampSize; rampIndex++) {
+            float phase = (rampIndex + 1) * M_PI / rampSize;
             float sample = cosf(phase);
-            mZeroAfterZero[i] = sample;
-            mZeroAfterOne[i] = sample;
-            i++;
+            mZeroAfterZero[sampleIndex] = sample;
+            mZeroAfterOne[sampleIndex] = sample;
+            sampleIndex++;
         }
-        for (int j = 0; j < rampSize; j++) {
-            mZeroAfterZero[i] = -1.0f;
-            mZeroAfterOne[i] = -1.0f;
-            i++;
+        for (int rampIndex = 0; rampIndex < rampSize; rampIndex++) {
+            mZeroAfterZero[sampleIndex] = -1.0f;
+            mZeroAfterOne[sampleIndex] = -1.0f;
+            sampleIndex++;
         }
     }
 
@@ -70,7 +70,6 @@
         mPreviousBit = current;
     }
 
-
     float nextFloat() override {
         advanceSample();
         float output = mCurrentSamples[mCursor];
diff --git a/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/AutoGlitchActivity.java b/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/AutoGlitchActivity.java
index 62f6f80..f86368b 100644
--- a/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/AutoGlitchActivity.java
+++ b/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/AutoGlitchActivity.java
@@ -307,21 +307,23 @@
             e.printStackTrace();
         } finally {
             super.stopAudioTest();
-            log("\n==== SUMMARY ========");
-            if (mFailCount > 0) {
-                log(mPassCount + " passed. " + mFailCount + " failed.");
-                log("These tests FAILED:");
-                log(mFailedSummary.toString());
-            } else {
-                log("All tests PASSED.");
-            }
-            log("== FINISHED at " + new Date());
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    onTestFinished();
+            if (mThreadEnabled) {
+                log("\n==== SUMMARY ========");
+                if (mFailCount > 0) {
+                    log(mPassCount + " passed. " + mFailCount + " failed.");
+                    log("These tests FAILED:");
+                    log(mFailedSummary.toString());
+                } else {
+                    log("All tests PASSED.");
                 }
-            });
+                log("== FINISHED at " + new Date());
+                runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        onTestFinished();
+                    }
+                });
+            }
         }
     }
 
diff --git a/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/RoundTripLatencyActivity.java b/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/RoundTripLatencyActivity.java
index 782950a..7edcd38 100644
--- a/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/RoundTripLatencyActivity.java
+++ b/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/RoundTripLatencyActivity.java
@@ -51,8 +51,10 @@
     // Run the test several times and report the acverage latency.
     protected class LatencyAverager {
         private final static int AVERAGE_TEST_DELAY_MSEC = 1000; // arbitrary
-        private static final int AVERAGE_MAX_ITERATIONS = 10; // arbitrary
-        private int mCount = 0;
+        private static final int GOOD_RUNS_REQUIRED = 10; // arbitrary
+        private static final int MAX_BAD_RUNS_ALLOWED = 10; // arbitrary
+        private int mBadCount = 0; // number of bad measurements
+        private int mGoodCount = 0; // number of good measurements
 
         private double  mWeightedLatencySum;
         private double  mLatencyMin;
@@ -64,51 +66,63 @@
         // Called on UI thread.
         String onAnalyserDone() {
             String message;
+            boolean reschedule = false;
             if (!mActive) {
                 message = "";
             } else if (getMeasuredResult() != 0) {
-                cancel();
-                updateButtons(false);
-                message = "averaging cancelled due to error\n";
+                mBadCount++;
+                if (mBadCount > MAX_BAD_RUNS_ALLOWED) {
+                    cancel();
+                    updateButtons(false);
+                    message = "averaging cancelled due to error\n";
+                } else {
+                    message = "skipping this bad run, "
+                            + mBadCount + " of " + MAX_BAD_RUNS_ALLOWED + " max\n";
+                    reschedule = true;
+                }
             } else {
-                mCount++;
+                mGoodCount++;
                 double latency = getMeasuredLatencyMillis();
                 double confidence = getMeasuredConfidence();
                 mWeightedLatencySum += latency * confidence; // weighted average based on confidence
                 mConfidenceSum += confidence;
                 mLatencyMin = Math.min(mLatencyMin, latency);
                 mLatencyMax = Math.max(mLatencyMax, latency);
-                if (mCount < AVERAGE_MAX_ITERATIONS) {
-                    mHandler.postDelayed(new Runnable() {
-                        @Override
-                        public void run() {
-                            measureSingleLatency();
-                        }
-                    }, AVERAGE_TEST_DELAY_MSEC);
+                if (mGoodCount < GOOD_RUNS_REQUIRED) {
+                    reschedule = true;
                 } else {
                     mActive = false;
                     updateButtons(false);
                 }
                 message = reportAverage();
             }
+            if (reschedule) {
+                mHandler.postDelayed(new Runnable() {
+                    @Override
+                    public void run() {
+                        measureSingleLatency();
+                    }
+                }, AVERAGE_TEST_DELAY_MSEC);
+            }
             return message;
         }
 
         private String reportAverage() {
             String message;
-            if (mCount == 0 || mConfidenceSum == 0.0) {
-                message = "num.iterations = " + mCount + "\n";
+            if (mGoodCount == 0 || mConfidenceSum == 0.0) {
+                message = "num.iterations = " + mGoodCount + "\n";
             } else {
                 // When I use 5.3g I only get one digit after the decimal point!
                 final double averageLatency = mWeightedLatencySum / mConfidenceSum;
-                final double mAverageConfidence = mConfidenceSum / mCount;
+                final double mAverageConfidence = mConfidenceSum / mGoodCount;
                 message =
                         "average.latency.msec = " + String.format(LATENCY_FORMAT, averageLatency) + "\n"
                         + "average.confidence = " + String.format(CONFIDENCE_FORMAT, mAverageConfidence) + "\n"
                         + "min.latency.msec = " + String.format(LATENCY_FORMAT, mLatencyMin) + "\n"
                         + "max.latency.msec = " + String.format(LATENCY_FORMAT, mLatencyMax) + "\n"
-                        + "num.iterations = " + mCount + "\n";
+                        + "num.iterations = " + mGoodCount + "\n";
             }
+            message += "num.failed = " + mBadCount + "\n";
             mLastReport = message;
             return message;
         }
@@ -119,7 +133,8 @@
             mConfidenceSum = 0.0;
             mLatencyMax = Double.MIN_VALUE;
             mLatencyMin = Double.MAX_VALUE;
-            mCount = 0;
+            mBadCount = 0;
+            mGoodCount = 0;
             mActive = true;
             mLastReport = "";
             measureSingleLatency();
diff --git a/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/TestAudioActivity.java b/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/TestAudioActivity.java
index 8aa6434..bd7fff5 100644
--- a/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/TestAudioActivity.java
+++ b/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/TestAudioActivity.java
@@ -49,7 +49,8 @@
     public static final int AUDIO_STATE_STARTED = 1;
     public static final int AUDIO_STATE_PAUSED = 2;
     public static final int AUDIO_STATE_STOPPED = 3;
-    public static final int AUDIO_STATE_CLOSED = 4;
+    public static final int AUDIO_STATE_CLOSING = 4;
+    public static final int AUDIO_STATE_CLOSED = 5;
 
     public static final int COLOR_ACTIVE = 0xFFD0D0A0;
     public static final int COLOR_IDLE = 0xFFD0D0D0;
@@ -467,10 +468,14 @@
         }
     }
 
+    protected void toastPauseError(int result) {
+        showErrorToast("Pause failed with " + result);
+    }
+
     public void pauseAudio() {
         int result = pauseNative();
         if (result < 0) {
-            showErrorToast("Pause failed with " + result);
+            toastPauseError(result);
         } else {
             mAudioState = AUDIO_STATE_PAUSED;
             updateEnabledWidgets();
@@ -493,10 +498,26 @@
         updateEnabledWidgets();
     }
 
-    public void closeAudio() {
+    // Make synchronized so we don't close from two streams at the same time.
+    public synchronized void closeAudio() {
+        if (mAudioState >= AUDIO_STATE_CLOSING) {
+            Log.d(TAG, "closeAudio() already closing");
+            return;
+        }
+        mAudioState = AUDIO_STATE_CLOSING;
+
         mStreamSniffer.stopStreamSniffer();
+        // Close output streams first because legacy callbacks may still be active
+        // and an output stream may be calling the input stream.
         for (StreamContext streamContext : mStreamContexts) {
-            streamContext.tester.close();
+            if (!streamContext.isInput()) {
+                streamContext.tester.close();
+            }
+        }
+        for (StreamContext streamContext : mStreamContexts) {
+            if (streamContext.isInput()) {
+                streamContext.tester.close();
+            }
         }
 
         if (mScoStarted) {
diff --git a/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/TestInputActivity.java b/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/TestInputActivity.java
index 6ad0480..273ca4a 100644
--- a/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/TestInputActivity.java
+++ b/apps/OboeTester/app/src/main/java/com/google/sample/oboe/manualtest/TestInputActivity.java
@@ -143,6 +143,11 @@
         resetVolumeBars();
     }
 
+    @Override
+    protected void toastPauseError(int result) {
+        showToast("Pause not implemented. Returned " + result);
+    }
+
     private boolean isRecordPermissionGranted() {
         return (ActivityCompat.checkSelfPermission(this,
                 Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED);
diff --git a/apps/OboeTester/app/src/main/res/layout/activity_rt_latency.xml b/apps/OboeTester/app/src/main/res/layout/activity_rt_latency.xml
index 5cf9124..de3ca26 100644
--- a/apps/OboeTester/app/src/main/res/layout/activity_rt_latency.xml
+++ b/apps/OboeTester/app/src/main/res/layout/activity_rt_latency.xml
@@ -88,7 +88,7 @@
         android:id="@+id/text_status"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
-        android:lines="15"
+        android:lines="16"
         android:text="@string/use_loopback"
         android:textSize="18sp"
         android:textStyle="bold" />
diff --git a/include/oboe/AudioStreamBuilder.h b/include/oboe/AudioStreamBuilder.h
index a1ea0a8..80c5da4 100644
--- a/include/oboe/AudioStreamBuilder.h
+++ b/include/oboe/AudioStreamBuilder.h
@@ -198,10 +198,11 @@
 
 
     /**
-     * Set the intended use case for the stream.
+     * Set the intended use case for an output stream.
      *
      * The system will use this information to optimize the behavior of the stream.
      * This could, for example, affect how volume and focus is handled for the stream.
+     * The usage is ignored for input streams.
      *
      * The default, if you do not call this function, is Usage::Media.
      *
@@ -215,10 +216,11 @@
     }
 
     /**
-     * Set the type of audio data that the stream will carry.
+     * Set the type of audio data that an output stream will carry.
      *
      * The system will use this information to optimize the behavior of the stream.
      * This could, for example, affect whether a stream is paused when a notification occurs.
+     * The contentType is ignored for input streams.
      *
      * The default, if you do not call this function, is ContentType::Music.
      *
diff --git a/samples/drumthumper/src/main/cpp/DrumPlayerJNI.cpp b/samples/drumthumper/src/main/cpp/DrumPlayerJNI.cpp
index 5ae41f7..b1dcf41 100644
--- a/samples/drumthumper/src/main/cpp/DrumPlayerJNI.cpp
+++ b/samples/drumthumper/src/main/cpp/DrumPlayerJNI.cpp
@@ -45,11 +45,17 @@
  * Native (JNI) implementation of DrumPlayer.setupAudioStreamNative()
  */
 JNIEXPORT void JNICALL Java_com_plausiblesoftware_drumthumper_DrumPlayer_setupAudioStreamNative(
-        JNIEnv* env, jobject, jint sampleRate, jint numChannels) {
+        JNIEnv* env, jobject, jint numChannels) {
     __android_log_print(ANDROID_LOG_INFO, TAG, "%s", "init()");
 
     // we know in this case that the sample buffers are all 1-channel, 41K
-    sDTPlayer.setupAudioStream(sampleRate, numChannels);
+    sDTPlayer.setupAudioStream(numChannels);
+}
+
+JNIEXPORT void JNICALL
+Java_com_plausiblesoftware_drumthumper_DrumPlayer_startAudioStreamNative(
+        JNIEnv *env, jobject thiz) {
+    sDTPlayer.startStream();
 }
 
 /**
@@ -69,7 +75,7 @@
  * Native (JNI) implementation of DrumPlayer.loadWavAssetNative()
  */
 JNIEXPORT jboolean JNICALL Java_com_plausiblesoftware_drumthumper_DrumPlayer_loadWavAssetNative(
-        JNIEnv* env, jobject, jbyteArray bytearray, jint index, jfloat pan, jint rate, jint channels) {
+        JNIEnv* env, jobject, jbyteArray bytearray, jint index, jfloat pan, jint channels) {
     int len = env->GetArrayLength (bytearray);
 
     unsigned char* buf = new unsigned char[len];
@@ -80,8 +86,7 @@
     WavStreamReader reader(&stream);
     reader.parse();
 
-    jboolean isFormatValid =
-            (reader.getSampleRate() == rate) && (reader.getNumChannels() == channels);
+    jboolean isFormatValid = reader.getNumChannels() == channels;
 
     SampleBuffer* sampleBuffer = new SampleBuffer();
     sampleBuffer->loadSampleData(&reader);
@@ -127,7 +132,7 @@
  */
 JNIEXPORT void JNICALL Java_com_plausiblesoftware_drumthumper_DrumPlayer_restartStream(JNIEnv*, jobject) {
     sDTPlayer.resetAll();
-    if (sDTPlayer.openStream()){
+    if (sDTPlayer.openStream() && sDTPlayer.startStream()){
         __android_log_print(ANDROID_LOG_INFO, TAG, "openStream successful");
     } else {
         __android_log_print(ANDROID_LOG_ERROR, TAG, "openStream failed");
diff --git a/samples/drumthumper/src/main/java/com/plausibleaudio/drumthumper/DrumPlayer.kt b/samples/drumthumper/src/main/java/com/plausibleaudio/drumthumper/DrumPlayer.kt
index 8d50510..62c8dbf 100644
--- a/samples/drumthumper/src/main/java/com/plausibleaudio/drumthumper/DrumPlayer.kt
+++ b/samples/drumthumper/src/main/java/com/plausibleaudio/drumthumper/DrumPlayer.kt
@@ -27,8 +27,6 @@
                                         // This IS NOT the channel format of the source samples
                                         // (which must be mono).
         val NUM_SAMPLE_CHANNELS: Int = 1;   // All WAV resource must be mono
-        val SAMPLE_RATE: Int = 44100    // All the input samples are assumed to BE 44.1K
-                                        // All the input samples are assumed to be mono.
 
         // Sample Buffer IDs
         val BASSDRUM: Int = 0
@@ -55,7 +53,11 @@
     }
 
     fun setupAudioStream() {
-        setupAudioStreamNative(SAMPLE_RATE, NUM_PLAY_CHANNELS)
+        setupAudioStreamNative(NUM_PLAY_CHANNELS)
+    }
+
+    fun startAudioStream() {
+        startAudioStreamNative();
     }
 
     fun teardownAudioStream() {
@@ -89,7 +91,7 @@
             var dataLen = assetFD.getLength().toInt()
             var dataBytes: ByteArray = ByteArray(dataLen)
             dataStream.read(dataBytes, 0, dataLen)
-            returnVal = loadWavAssetNative(dataBytes, index, pan, SAMPLE_RATE, NUM_SAMPLE_CHANNELS)
+            returnVal = loadWavAssetNative(dataBytes, index, pan, NUM_SAMPLE_CHANNELS)
             assetFD.close()
         } catch (ex: IOException) {
             Log.i(TAG, "IOException" + ex)
@@ -98,11 +100,12 @@
         return returnVal
     }
 
-    external fun setupAudioStreamNative(sampleRate: Int, numChannels: Int)
+    external fun setupAudioStreamNative(numChannels: Int)
+    external fun startAudioStreamNative();
     external fun teardownAudioStreamNative()
 
     external fun loadWavAssetNative(
-            wavBytes: ByteArray, index: Int, pan: Float, rate: Int, channels: Int) : Boolean
+            wavBytes: ByteArray, index: Int, pan: Float, channels: Int) : Boolean
     external fun unloadWavAssetsNative()
 
     external fun trigger(drumIndex: Int)
diff --git a/samples/drumthumper/src/main/java/com/plausibleaudio/drumthumper/DrumThumperActivity.kt b/samples/drumthumper/src/main/java/com/plausibleaudio/drumthumper/DrumThumperActivity.kt
index eb90cb8..2bdd6c9 100644
--- a/samples/drumthumper/src/main/java/com/plausibleaudio/drumthumper/DrumThumperActivity.kt
+++ b/samples/drumthumper/src/main/java/com/plausibleaudio/drumthumper/DrumThumperActivity.kt
@@ -161,7 +161,13 @@
 
         mAudioMgr = getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
-        // mDrumPlayer.allocSampleData()
+    }
+
+    override fun onStart() {
+        super.onStart()
+
+        mDrumPlayer.setupAudioStream()
+
         var allAssetsValid = mDrumPlayer.loadWavAssets(getAssets())
 
         if (!allAssetsValid) {
@@ -171,12 +177,7 @@
                     Toast.LENGTH_LONG)
             toast.show()
         }
-    }
-
-    override fun onStart() {
-        super.onStart()
-
-        mDrumPlayer.setupAudioStream()
+        mDrumPlayer.startAudioStream()
 
         if (mUseDeviceChangeFallback) {
             mAudioMgr!!.registerAudioDeviceCallback(mDeviceListener, null)
@@ -232,11 +233,12 @@
 
         mDrumPlayer.teardownAudioStream()
 
+        mDrumPlayer.unloadWavAssets()
+
         super.onStop()
     }
 
     override fun onDestroy() {
-        mDrumPlayer.unloadWavAssets();
         super.onDestroy()
     }
 
diff --git a/samples/iolib/src/main/cpp/CMakeLists.txt b/samples/iolib/src/main/cpp/CMakeLists.txt
index 2c3d923..dd8c626 100644
--- a/samples/iolib/src/main/cpp/CMakeLists.txt
+++ b/samples/iolib/src/main/cpp/CMakeLists.txt
@@ -29,6 +29,7 @@
 include_directories(
         ${PARSELIB_DIR}/src/main/cpp
         ${OBOE_DIR}/include
+        ${OBOE_DIR}/src/flowgraph
         ${CMAKE_CURRENT_LIST_DIR}
         ../../../../shared)
 
diff --git a/samples/iolib/src/main/cpp/player/SampleBuffer.cpp b/samples/iolib/src/main/cpp/player/SampleBuffer.cpp
index ca3a905..a882b3a 100644
--- a/samples/iolib/src/main/cpp/player/SampleBuffer.cpp
+++ b/samples/iolib/src/main/cpp/player/SampleBuffer.cpp
@@ -16,8 +16,13 @@
 
 #include "SampleBuffer.h"
 
+// Resampler Includes
+#include <resampler/MultiChannelResampler.h>
+
 #include "wav/WavStreamReader.h"
 
+using namespace resampler;
+
 namespace iolib {
 
 void SampleBuffer::loadSampleData(parselib::WavStreamReader* reader) {
@@ -41,4 +46,75 @@
     mNumSamples = 0;
 }
 
+class ResampleBlock {
+public:
+    int32_t mSampleRate;
+    float*  mBuffer;
+    int32_t mNumFrames;
+};
+
+void resampleData(const ResampleBlock& input, ResampleBlock* output) {
+    // Calculate output buffer size
+    double temp =
+            ((double)input.mNumFrames * (double)output->mSampleRate) / (double)input.mSampleRate;
+
+    // round up
+    int32_t numOutFrames = (int32_t)(temp + 0.5);
+    // We iterate thousands of times through the loop. Roundoff error could accumulate
+    // so add a few more frames for padding
+    numOutFrames += 8;
+
+    const int channelCount = 1;    // 1 for mono, 2 for stereo
+    MultiChannelResampler *resampler = MultiChannelResampler::make(
+            channelCount, // channel count
+            input.mSampleRate, // input sampleRate
+            output->mSampleRate, // output sampleRate
+            MultiChannelResampler::Quality::Medium); // conversion quality
+
+    float *inputBuffer = input.mBuffer;;     // multi-channel buffer to be consumed
+    float *outputBuffer = new float[numOutFrames];    // multi-channel buffer to be filled
+    output->mBuffer = outputBuffer;
+
+    int numOutputFrames = 0;
+    int inputFramesLeft = input.mNumFrames;
+    while (inputFramesLeft > 0) {
+        if(resampler->isWriteNeeded()) {
+            resampler->writeNextFrame(inputBuffer);
+            inputBuffer += channelCount;
+            inputFramesLeft--;
+        } else {
+            resampler->readNextFrame(outputBuffer);
+            outputBuffer += channelCount;
+            numOutputFrames++;
+        }
+    }
+    output->mNumFrames = numOutputFrames;
+
+    delete resampler;
 }
+
+void SampleBuffer::resampleData(int sampleRate) {
+    if (mAudioProperties.sampleRate == sampleRate) {
+        // nothing to do
+        return;
+    }
+
+    ResampleBlock inputBlock;
+    inputBlock.mBuffer = mSampleData;
+    inputBlock.mNumFrames = mNumSamples;
+    inputBlock.mSampleRate = mAudioProperties.sampleRate;
+
+    ResampleBlock outputBlock;
+    outputBlock.mSampleRate = sampleRate;
+    iolib::resampleData(inputBlock, &outputBlock);
+
+    // delete previous samples
+    delete[] mSampleData;
+
+    // install the resampled data
+    mSampleData = outputBlock.mBuffer;
+    mNumSamples = outputBlock.mNumFrames;
+    mAudioProperties.sampleRate = outputBlock.mSampleRate;
+}
+
+} // namespace iolib
diff --git a/samples/iolib/src/main/cpp/player/SampleBuffer.h b/samples/iolib/src/main/cpp/player/SampleBuffer.h
index 9d61f28..c92ee78 100644
--- a/samples/iolib/src/main/cpp/player/SampleBuffer.h
+++ b/samples/iolib/src/main/cpp/player/SampleBuffer.h
@@ -38,6 +38,8 @@
     void loadSampleData(parselib::WavStreamReader* reader);
     void unloadSampleData();
 
+    void resampleData(int sampleRate);
+
     virtual AudioProperties getProperties() const { return mAudioProperties; }
 
     float* getSampleData() { return mSampleData; }
diff --git a/samples/iolib/src/main/cpp/player/SimpleMultiPlayer.cpp b/samples/iolib/src/main/cpp/player/SimpleMultiPlayer.cpp
index 6110b29..2cbfae7 100644
--- a/samples/iolib/src/main/cpp/player/SimpleMultiPlayer.cpp
+++ b/samples/iolib/src/main/cpp/player/SimpleMultiPlayer.cpp
@@ -34,7 +34,7 @@
 constexpr int32_t kBufferSizeInBursts = 2; // Use 2 bursts as the buffer size (double buffer)
 
 SimpleMultiPlayer::SimpleMultiPlayer()
-  : mChannelCount(0), mSampleRate(0), mOutputReset(false)
+  : mChannelCount(0), mOutputReset(false)
 {}
 
 DataCallbackResult SimpleMultiPlayer::onAudioReady(AudioStream *oboeStream, void *audioData,
@@ -78,7 +78,7 @@
     // Create an audio stream
     AudioStreamBuilder builder;
     builder.setChannelCount(mChannelCount);
-    builder.setSampleRate(mSampleRate);
+    // we will resample source data to device rate, so take default sample rate
     builder.setCallback(this);
     builder.setPerformanceMode(PerformanceMode::LowLatency);
     builder.setSharingMode(SharingMode::Exclusive);
@@ -105,7 +105,13 @@
                 "setBufferSizeInFrames failed. Error: %s", convertToText(result));
     }
 
-    result = mAudioStream->requestStart();
+    mSampleRate = mAudioStream->getSampleRate();
+
+    return true;
+}
+
+bool SimpleMultiPlayer::startStream() {
+    Result result = mAudioStream->requestStart();
     if (result != Result::OK){
         __android_log_print(
                 ANDROID_LOG_ERROR,
@@ -117,11 +123,9 @@
     return true;
 }
 
-void SimpleMultiPlayer::setupAudioStream(int32_t sampleRate, int32_t channelCount) {
+void SimpleMultiPlayer::setupAudioStream(int32_t channelCount) {
     __android_log_print(ANDROID_LOG_INFO, TAG, "setupAudioStream()");
     mChannelCount = channelCount;
-    mSampleRate = sampleRate;
-    mSampleRate = sampleRate;
 
     openStream();
 }
@@ -135,6 +139,8 @@
 }
 
 void SimpleMultiPlayer::addSampleSource(SampleSource* source, SampleBuffer* buffer) {
+    buffer->resampleData(mSampleRate);
+
     mSampleBuffers.push_back(buffer);
     mSampleSources.push_back(source);
     mNumSampleBuffers++;
diff --git a/samples/iolib/src/main/cpp/player/SimpleMultiPlayer.h b/samples/iolib/src/main/cpp/player/SimpleMultiPlayer.h
index 3e0a1c7..d8c9877 100644
--- a/samples/iolib/src/main/cpp/player/SimpleMultiPlayer.h
+++ b/samples/iolib/src/main/cpp/player/SimpleMultiPlayer.h
@@ -41,10 +41,13 @@
     virtual void onErrorAfterClose(oboe::AudioStream *oboeStream, oboe::Result error) override;
     virtual void onErrorBeforeClose(oboe::AudioStream * oboeStream, oboe::Result error) override;
 
-    void setupAudioStream(int32_t sampleRate, int32_t channelCount);
+    void setupAudioStream(int32_t channelCount);
     void teardownAudioStream();
 
     bool openStream();
+    bool startStream();
+
+    int getSampleRate() { return mSampleRate; }
 
     // Wave Sample Loading...
     /**
@@ -77,7 +80,7 @@
     // Oboe Audio Stream
     oboe::ManagedStream mAudioStream;
 
-    // Audio attributes
+    // Playback Audio attributes
     int32_t mChannelCount;
     int32_t mSampleRate;
 
diff --git a/src/aaudio/AudioStreamAAudio.cpp b/src/aaudio/AudioStreamAAudio.cpp
index 9f493ea..96f0c39 100644
--- a/src/aaudio/AudioStreamAAudio.cpp
+++ b/src/aaudio/AudioStreamAAudio.cpp
@@ -118,7 +118,7 @@
     if (oboeStream->wasErrorCallbackCalled()) { // block extra error callbacks
         LOGE("%s() multiple error callbacks called!", __func__);
     } else if (stream != oboeStream->getUnderlyingStream()) {
-        LOGW("%s() stream already closed", __func__); // can happen if there are bugs
+        LOGW("%s() stream already closed or closing", __func__); // can happen if there are bugs
     } else if (sharedStream) {
         // Handle error on a separate thread using shared pointer.
         std::thread t(oboe_aaudio_error_thread_proc_shared, sharedStream,
@@ -258,7 +258,6 @@
     mBufferCapacityInFrames = mLibLoader->stream_getBufferCapacity(mAAudioStream);
     mBufferSizeInFrames = mLibLoader->stream_getBufferSize(mAAudioStream);
 
-
     // These were added in P so we have to check for the function pointer.
     if (mLibLoader->stream_getUsage != nullptr) {
         mUsage = static_cast<Usage>(mLibLoader->stream_getUsage(mAAudioStream));
@@ -298,6 +297,14 @@
     // This will delete the AAudio stream object so we need to null out the pointer.
     AAudioStream *stream = mAAudioStream.exchange(nullptr);
     if (stream != nullptr) {
+        // Sometimes a callback can occur shortly after a stream has been stopped and
+        // even after a close. If the stream has been closed then the callback
+        // can access memory that has been freed. That causes a crash.
+        // Two milliseconds may be enough but 10 msec is even safer.
+        // This seems to be more likely in P or earlier. But it can also occur in later versions.
+        if (OboeGlobals::areWorkaroundsEnabled()) {
+            usleep(kDelayBeforeCloseMillis * 1000);
+        }
         return static_cast<Result>(mLibLoader->stream_close(stream));
     } else {
         return Result::ErrorClosed;
diff --git a/src/aaudio/AudioStreamAAudio.h b/src/aaudio/AudioStreamAAudio.h
index 6267328..0df224a 100644
--- a/src/aaudio/AudioStreamAAudio.h
+++ b/src/aaudio/AudioStreamAAudio.h
@@ -110,6 +110,9 @@
 
 private:
 
+    // Time to sleep in order to prevent a race condition with a callback after a close().
+    static constexpr int kDelayBeforeCloseMillis = 10;
+
     std::atomic<bool>    mCallbackThreadEnabled;
 
     // pointer to the underlying AAudio stream, valid if open, null if closed
diff --git a/src/common/DataConversionFlowGraph.cpp b/src/common/DataConversionFlowGraph.cpp
index 7ddc0e6..6f0ee5b 100644
--- a/src/common/DataConversionFlowGraph.cpp
+++ b/src/common/DataConversionFlowGraph.cpp
@@ -98,8 +98,8 @@
                                 ? sourceStream->getFramesPerBurst()
                                 : sourceStream->getFramesPerCallback();
     // Source
-    // If OUTPUT and using a callback then call back to the app using a SourceCaller.
-    // If INPUT and NOT using a callback then read from the child stream using a SourceCaller.
+    // IF OUTPUT and using a callback then call back to the app using a SourceCaller.
+    // OR IF INPUT and NOT using a callback then read from the child stream using a SourceCaller.
     if ((sourceStream->getCallback() != nullptr && isOutput)
         || (sourceStream->getCallback() == nullptr && isInput)) {
         switch (sourceFormat) {
@@ -118,8 +118,8 @@
         mSourceCaller->setStream(sourceStream);
         lastOutput = &mSourceCaller->output;
     } else {
-        // If OUTPUT and NOT using a callback then write to the child stream using a BlockWriter.
-        // If INPUT and using a callback then write to the app using a BlockWriter.
+        // IF OUTPUT and NOT using a callback then write to the child stream using a BlockWriter.
+        // OR IF INPUT and using a callback then write to the app using a BlockWriter.
         switch (sourceFormat) {
             case AudioFormat::Float:
                 mSource = std::make_unique<SourceFloat>(sourceChannelCount);
@@ -200,8 +200,6 @@
     }
     lastOutput->connect(&mSink->input);
 
-    mFramePosition = 0;
-
     return Result::OK;
 }
 
@@ -210,7 +208,6 @@
         mSourceCaller->setTimeoutNanos(timeoutNanos);
     }
     int32_t numRead = mSink->read(buffer, numFrames);
-    mFramePosition += numRead;
     return numRead;
 }
 
@@ -221,7 +218,6 @@
     while (true) {
         // Pull and read some data in app format into a small buffer.
         int32_t framesRead = mSink->read(mAppBuffer.get(), flowgraph::kDefaultBufferSize);
-        mFramePosition += framesRead;
         if (framesRead <= 0) break;
         // Write to a block adapter, which will call the destination whenever it has enough data.
         int32_t bytesRead = mBlockWriter.write(mAppBuffer.get(),
diff --git a/src/common/DataConversionFlowGraph.h b/src/common/DataConversionFlowGraph.h
index 5b8d3f6..0cde1f3 100644
--- a/src/common/DataConversionFlowGraph.h
+++ b/src/common/DataConversionFlowGraph.h
@@ -80,8 +80,6 @@
     DataCallbackResult                                 mCallbackResult = DataCallbackResult::Continue;
     AudioStream                                       *mFilterStream = nullptr;
     std::unique_ptr<uint8_t[]>                         mAppBuffer;
-
-    int64_t mFramePosition = 0;
 };
 
 }
diff --git a/src/flowgraph/FlowGraphNode.cpp b/src/flowgraph/FlowGraphNode.cpp
index c7e3ff9..9a62d7d 100644
--- a/src/flowgraph/FlowGraphNode.cpp
+++ b/src/flowgraph/FlowGraphNode.cpp
@@ -111,4 +111,4 @@
 
 int32_t FlowGraphSink::pullData(int32_t numFrames) {
     return FlowGraphNode::pullData(numFrames, getLastCallCount() + 1);
-}
\ No newline at end of file
+}
diff --git a/src/flowgraph/SampleRateConverter.cpp b/src/flowgraph/SampleRateConverter.cpp
index 0c92d7f..b1ae4bd 100644
--- a/src/flowgraph/SampleRateConverter.cpp
+++ b/src/flowgraph/SampleRateConverter.cpp
@@ -25,11 +25,17 @@
     setDataPulledAutomatically(false);
 }
 
+void SampleRateConverter::reset() {
+    FlowGraphNode::reset();
+    mInputCursor = kInitialCallCount;
+}
+
 // Return true if there is a sample available.
 bool SampleRateConverter::isInputAvailable() {
+    // If we have consumed all of the input data then go out and get some more.
     if (mInputCursor >= mNumValidInputFrames) {
-        mNumValidInputFrames = input.pullData(mInputFramePosition, input.getFramesPerBuffer());
-        mInputFramePosition += mNumValidInputFrames;
+        mInputCallCount++;
+        mNumValidInputFrames = input.pullData(mInputCallCount, input.getFramesPerBuffer());
         mInputCursor = 0;
     }
     return (mInputCursor < mNumValidInputFrames);
diff --git a/src/flowgraph/SampleRateConverter.h b/src/flowgraph/SampleRateConverter.h
index 5fb5c65..534df49 100644
--- a/src/flowgraph/SampleRateConverter.h
+++ b/src/flowgraph/SampleRateConverter.h
@@ -38,6 +38,8 @@
         return "SampleRateConverter";
     }
 
+    void reset() override;
+
 private:
 
     // Return true if there is a sample available.
@@ -48,9 +50,11 @@
 
     resampler::MultiChannelResampler &mResampler;
 
-    int32_t mInputCursor = 0;
-    int32_t mNumValidInputFrames = 0;
-    int64_t mInputFramePosition = 0; // monotonic counter of input frames used for pullData
+    int32_t mInputCursor = 0;         // offset into the input port buffer
+    int32_t mNumValidInputFrames = 0; // number of valid frames currently in the input port buffer
+    // We need our own callCount for upstream calls because calls occur at a different rate.
+    // This means we cannot have cyclic graphs or merges that contain an SRC.
+    int64_t mInputCallCount = 0;
 
 };
 
diff --git a/src/flowgraph/resampler/README.md b/src/flowgraph/resampler/README.md
index 2026773..ecf030f 100644
--- a/src/flowgraph/resampler/README.md
+++ b/src/flowgraph/resampler/README.md
@@ -20,7 +20,7 @@
             2, // channel count
             44100, // input sampleRate
             48000, // output sampleRate
-            MultiChannelResampler::Medium); // conversion quality
+            MultiChannelResampler::Quality::Medium); // conversion quality
 
 Possible values for quality include { Fastest, Low, Medium, High, Best }.
 Higher quality levels will sound better but consume more CPU because they have more taps in the filter.
diff --git a/tests/testStreamOpen.cpp b/tests/testStreamOpen.cpp
index e3bf7e8..8b2fa6d 100644
--- a/tests/testStreamOpen.cpp
+++ b/tests/testStreamOpen.cpp
@@ -24,18 +24,20 @@
 public:
     DataCallbackResult onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numFrames) override {
         framesPerCallback = numFrames;
+        callbackCount++;
         return DataCallbackResult::Continue;
     }
 
     // This is exposed publicly so that the number of frames per callback can be tested.
     std::atomic<int32_t> framesPerCallback{0};
+    std::atomic<int32_t> callbackCount{0};
 };
 
 class StreamOpen : public ::testing::Test {
 
 protected:
 
-    bool openStream(){
+    bool openStream() {
         Result r = mBuilder.openStream(&mStream);
         EXPECT_EQ(r, Result::OK) << "Failed to open stream " << convertToText(r);
         EXPECT_EQ(0, openCount) << "Should start with a fresh object every time.";
@@ -43,19 +45,45 @@
         return (r == Result::OK);
     }
 
-    void closeStream(){
-        if (mStream != nullptr){
+    void closeStream() {
+        if (mStream != nullptr) {
             Result r = mStream->close();
-            if (r != Result::OK){
+            if (r != Result::OK) {
                 FAIL() << "Failed to close stream. " << convertToText(r);
             }
         }
         usleep(500 * 1000); // give previous stream time to settle
     }
 
+    void checkSampleRateConversionAdvancing(Direction direction) {
+        CallbackSizeMonitor callback;
+
+        mBuilder.setDirection(direction);
+        mBuilder.setAudioApi(AudioApi::AAudio);
+        mBuilder.setCallback(&callback);
+        mBuilder.setPerformanceMode(PerformanceMode::LowLatency);
+        mBuilder.setSampleRate(44100);
+        mBuilder.setSampleRateConversionQuality(SampleRateConversionQuality::Medium);
+
+        openStream();
+
+        ASSERT_EQ(mStream->requestStart(), Result::OK);
+        int timeout = 20;
+        while (callback.framesPerCallback == 0 && timeout > 0) {
+            usleep(50 * 1000);
+            timeout--;
+        }
+        ASSERT_GT(callback.callbackCount, 0);
+        ASSERT_GT(callback.framesPerCallback, 0);
+        ASSERT_EQ(mStream->requestStop(), Result::OK);
+
+        closeStream();
+    }
+
     AudioStreamBuilder mBuilder;
     AudioStream *mStream = nullptr;
     int32_t openCount = 0;
+
 };
 
 TEST_F(StreamOpen, ForOpenSLESDefaultSampleRateIsUsed){
@@ -110,6 +138,29 @@
     closeStream();
 }
 
+TEST_F(StreamOpen, ForOpenSlesIllegalFormatRejectedOutput) {
+    mBuilder.setAudioApi(AudioApi::OpenSLES);
+    mBuilder.setPerformanceMode(PerformanceMode::LowLatency);
+    mBuilder.setFormat(static_cast<AudioFormat>(666));
+    Result r = mBuilder.openStream(&mStream);
+    EXPECT_NE(r, Result::OK) << "Should not open stream " << convertToText(r);
+    if (mStream != nullptr) {
+        mStream->close(); // just in case it accidentally opened
+    }
+}
+
+TEST_F(StreamOpen, ForOpenSlesIllegalFormatRejectedInput) {
+    mBuilder.setAudioApi(AudioApi::OpenSLES);
+    mBuilder.setPerformanceMode(PerformanceMode::LowLatency);
+    mBuilder.setDirection(Direction::Input);
+    mBuilder.setFormat(static_cast<AudioFormat>(666));
+    Result r = mBuilder.openStream(&mStream);
+    EXPECT_NE(r, Result::OK) << "Should not open stream " << convertToText(r);
+    if (mStream != nullptr) {
+        mStream->close(); // just in case it accidentally opened
+    }
+}
+
 // Make sure the callback is called with the requested FramesPerCallback
 TEST_F(StreamOpen, OpenSLESFramesPerCallback) {
     const int kRequestedFramesPerCallback = 417;
@@ -309,3 +360,13 @@
         ASSERT_LE(bufferSize, burst * 3);
     }
 }
+
+// See if sample rate conversion by Oboe is calling the callback.
+TEST_F(StreamOpen, AAudioOutputSampleRate44100) {
+    checkSampleRateConversionAdvancing(Direction::Output);
+}
+
+// See if sample rate conversion by Oboe is calling the callback.
+TEST_F(StreamOpen, AAudioInputSampleRate44100) {
+    checkSampleRateConversionAdvancing(Direction::Input);
+}
\ No newline at end of file
diff --git a/tests/testUtilities.cpp b/tests/testUtilities.cpp
index 9945145..6b101be 100644
--- a/tests/testUtilities.cpp
+++ b/tests/testUtilities.cpp
@@ -27,9 +27,6 @@
 using namespace oboe;
 
 class UtilityFunctions : public ::testing::Test {
-
-
-
 };
 
 TEST_F(UtilityFunctions, Converts16BitIntegerToSizeOf2Bytes){