diff --git a/_docs/help.html b/_docs/help.html
index 534d9d3370173764e9ba748b8d260a0049932cb5..6677eb0dfe9e163f3fe38c1bc2be633c8506a37f 100644
--- a/_docs/help.html
+++ b/_docs/help.html
@@ -80,6 +80,8 @@
 <li><a href="#contact">Contacting me (bugs etc)</a></li>
 </ul>
 
+<!-- Remember that ad must not be more than 30% of total page content height (i.e., total page, not just what's
+on screen in the viewport. -->
 <!-- start adsense code -->
 <script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
 <!-- help_top_1 -->
@@ -368,8 +370,6 @@ regions will have their brightness boosted to bring out the detail. This mode is
 of brightness (e.g., on a bright sunny day) as well as being useful to automatically optimise photos in low light scenes. Also
 see <a href="#dro_vs_hdr">DRO vs HDR</a>.</p>
 
-<p>Note that if Camera2 API is used, DRO will give improved quality in bright scenes.</p>
-
 <p><a name="hdr"><b>HDR</b></a></p>
 
 <p>High Dynamic Range Imaging (HDR) is a technique where the camera takes multiple shots at different exposures, and combines them
@@ -515,7 +515,7 @@ recording.</p>
 delay (see below).</p>
 
 <p><b>Volume keys</b> - You can set what happens when your device's volume keys are pressed:</p><ul>
-<li>Take photo or start/stop video (depending on photo/video mode).</li>
+<li>Take photo or start/stop video (depending on photo/video mode). On Android 7+, volume down will instead pause/resume video when recording video.</li>
 <li>Trigger an autofocus - or if in manual mode, change the focus distance in/out. In this mode, holding down both volume keys
 will take a photo (or start/stop video). This makes your volume keys behave more like a physical camera button - hold down one
 key to focus, then both to take a photo.</li>
@@ -888,6 +888,10 @@ create the final HDR image (although if you don't want Open Camera's HDR mode at
 Exposure Bracketing Photo Mode). Note this will make saving slower, especially if options like "Stamp photos" or
 <a href="#auto_stabilise">Auto-level</a> are also used.</p>
 
+<p><b>HDR tonemapping</b> - When using <a href="#hdr">HDR</a> mode, the high dynamic range image needs to be converted
+back to a regular image, using a process called tonemapping. This option allows you to choose some different
+tonemapping algorithms.</p>
+
 <p><b>HDR contrast enhancement</b> - When using <a href="#hdr">HDR</a> mode, in some (bright) scenes a local contrast
 enhancement algorithm is applied to improve the look of the image. It also gives such images a look that is stereotypically
 associated with "HDR". If you prefer not to apply this at all, you can change this option from "Smart" to "Off". Or you can
@@ -915,6 +919,11 @@ a third party File Explorer application to see and delete XML files.</p>
 photos will still be as the camera (or other people) view the scene. This option can be used to mirror the
 resultant photo, so the resultant photo matches the mirrored image you see on the screen.</p>
 
+<p><b>Remove device EXIF data</b> - Whether to remove device EXIF metadata from JPEG photos. Note that
+    this will not remove exif tags applied by other Open Camera settings that apply EXIF metadata (e.g.
+    location/geotagging, artist, copyright etc). Those other options are independent and will override this
+    setting. Also note that RAW/DNG and videos are not affected.</p>
+
 <p><b>Artist</b> - If text is entered in this setting, then the text will be stored in the image's Exif metadata as the
     "Artist" tag. Only supported for JPEG format. Not supported for RAW photos (DNG format).</p>
 
diff --git a/_docs/history.html b/_docs/history.html
index 1e08a256c5c225de62ce3fd41262f4ee6bff6022..0a9bde2b3cee5a1d42fe905c2aee91a238599e8e 100644
--- a/_docs/history.html
+++ b/_docs/history.html
@@ -47,6 +47,52 @@
 <p>&lt; <small><a href="index.html">Main Page.</a></small></p>
 
 <pre>
+Version 1.51.1 (2023/01/02)
+
+FIXED   Fix crashes for Camera2 API.
+
+Version 1.51 (2022/12/21)
+
+FIXED   Gallery thumbnail had incorrect orientation on some Android 10+ devices.
+FIXED   Focus bracketing images came out underexposed on some devices since
+        version 1.50 (e.g. Pixel 6 Pro).
+FIXED   Problems with NR, fast burst and long manual exposures on some devices (e.g., Pixel 6 Pro).
+FIXED   Face detection on-screen icon shouldn't show in camera vendor extension modes (as not
+        supported).
+FIXED   For Camera2 API, red eye flash was incorrectly being shown even on devices that didn't
+        support it.
+FIXED   Not saving location exif information for Camera2 API on some devices (e.g., Pixel 6 Pro).
+FIXED   Crashed recording video on some devices and resolutions (e.g. Pixel 6 Pro at 1920x1440) if
+        those resolutions didn't support the same frame rate as other resolutions.
+FIXED   Don't display error message if using volume keys to turn auto-level on or off in RAW or
+        Panorama mode (unless device doesn't support auto-level at all).
+ADDED   New option Settings/Photo settings/"Remove device EXIF data" to remove device metadata from
+        JPEG photos.
+ADDED   Shading for auto-level and crop guides, to darken the preview outside of the region of
+        interest.
+ADDED   Display message to hold device steady when using X-Night photo mode.
+ADDED   New option Settings/Photo settings/"HDR tonemapping" to choose tonemapping algorithm used
+        for HDR photo mode.
+UPDATED Applied a timeout of 1 second for focusing with Camera2 API.
+UPDATED Made it easier to zoom to 1x zoom using seekbar on devices that can zoom out to ultra-wide
+        camera.
+UPDATED Make zoom seekbar snap to powers of two (for Camera2 API).
+UPDATED No longer switch to manual mode in DRO and NR photo modes, as on some devices this meant
+        losing the benefit of manufacturer algorithms.
+UPDATED Volume key down now supports pause/resume video on Android 7+ when recording video, if
+        option for volume keys is set to "Take photo (or start/stop video recording)".
+UPDATED Apply a dimmed effect when reopening camera or switching modes (for Camera2 API).
+UPDATED Improved look of on-screen level line.
+UPDATED On-screen pitch and compass lines now show smaller intervals as camera zooms in.
+UPDATED Improvement to HDR algorithm for dark scenes.
+UPDATED Camera2 extension night mode now adds "_Night" to filename.
+UPDATED Default to Camera2 API for some devices (will only take affect for new installs or if
+        resetting settings).
+UPDATED Default to flash off instead of flash auto.
+UPDATED DRO, HDR, NR modes no longer activate showing full on-screen info toast when opening camera.
+UPDATED Use system toasts without custom views when appropriate.
+UPDATED Display current value for photo stamp font size and colour in preference summary.
+
 Version 1.50.1 (2022/06/08)
 
 FIXED   Crash on OPPO devices for old camera API introduced in 1.50.
diff --git a/_docs/index.html b/_docs/index.html
index d3bd47db00de4b1371990a0485ceddf6fb4ad970..4eadf078568901d575ad92fac201417e130574f5 100644
--- a/_docs/index.html
+++ b/_docs/index.html
@@ -80,6 +80,8 @@
 responsive ads won't show (at least on my Nexus 6)!
 If any code is changed here, make sure layout is still good and ads show on laptop, Nexus 6 and Galaxy Nexus.
 -->
+<!-- Remember that ad must not be more than 30% of total page content height (i.e., total page, not just what's
+on screen in the viewport. -->
 <!--<a href="Screenshot_2014-09-22-14-34-48.jpg">
 <img src="Screenshot_2014-09-22-14-34-48_thumbversion.jpg" alt="Screenshot" title="Screenshot" style="max-width:100%">
 </a>-->
@@ -118,6 +120,7 @@ browsers -->
 <li>Overlay a choice of grids and crop guides.</li>
 <li>Optional GPS location tagging (geotagging) of photos and videos; for photos this includes compass direction (GPSImgDirection, GPSImgDirectionRef).</li>
 <li>Apply date and timestamp, location coordinates, and custom text to photos; store date/time and location as video subtitles (.SRT).</li>
+<li>Option to remove device exif metadata from photos.</li>
 <li>Panorama, including for front camera.</li>
 <li>Support for <a href="help.html#hdr">HDR</a> (with auto-alignment and ghost removal) and Exposure Bracketing.</li>
 <li>Support for Camera2 API: manual controls (with optional focus assist); burst mode; RAW (DNG) files; camera vendor extensions; slow motion video; log profile video.</li>
@@ -151,6 +154,8 @@ browsers -->
 
 <!-- don't have ads too close to download links! -->
 <hr>
+<!-- Remember that ad must not be more than 30% of total page content height (i.e., total page, not just what's
+on screen in the viewport. -->
 <!-- start adsense code -->
 <script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
 <!-- contents_ad -->
diff --git a/app/build.gradle b/app/build.gradle
index 64413aafa05be4577654548cd7638c1494aca2b4..c9eee76d4aca09a513fac14b4bf4672938cd5646 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -21,7 +21,8 @@ android {
         // also need build tools at least 21 to avoid Google Play 64-bit warning (required from 1 August 2019)
 
         testApplicationId "net.sourceforge.opencamera.test"
-        testInstrumentationRunner "android.test.InstrumentationTestRunner"
+        //testInstrumentationRunner "android.test.InstrumentationTestRunner"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
 
     buildTypes {
@@ -63,4 +64,9 @@ dependencies {
     implementation 'foundation.e:elib:0.0.1-alpha11'
 
     testImplementation 'junit:junit:4.13.1'
+
+    // newer AndroidJUnit4 InstrumentedTest
+    androidTestImplementation "androidx.test:runner:1.4.0"
+    androidTestImplementation "androidx.test:rules:1.4.0"
+    androidTestImplementation "androidx.test.espresso:espresso-core:3.4.0"
 }
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/AvgTestSuite.java b/app/src/androidTest/java/net/sourceforge/opencamera/AvgTestSuite.java
new file mode 100644
index 0000000000000000000000000000000000000000..82f3d6670586c90c40f0ac46308e2fd573a6a88c
--- /dev/null
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/AvgTestSuite.java
@@ -0,0 +1,17 @@
+package net.sourceforge.opencamera;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/** Tests for Avg algorithm - only need to run on a single device
+ *  Should manually look over the images dumped onto DCIM/
+ *  To use these tests, the testdata/ subfolder should be manually copied to the test device in the DCIM/testOpenCamera/
+ *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
+ *  time to transfer to the device every time we run the tests.
+ *  On Android 10+, scoped storage permission needs to be given to Open Camera for the DCIM/testOpenCamera/ folder.
+ */
+@RunWith(Categories.class)
+@Categories.IncludeCategory(AvgTests.class)
+@Suite.SuiteClasses({InstrumentedTest.class})
+public class AvgTestSuite {}
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/HDRNTestSuite.java b/app/src/androidTest/java/net/sourceforge/opencamera/HDRNTestSuite.java
new file mode 100644
index 0000000000000000000000000000000000000000..94314c209612f950a5ba4f98dc64b5488bd0fcb1
--- /dev/null
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/HDRNTestSuite.java
@@ -0,0 +1,17 @@
+package net.sourceforge.opencamera;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/** Tests for HDR algorithm with more than 3 images - only need to run on a single device
+ *  Should manually look over the images dumped onto DCIM/
+ *  To use these tests, the testdata/ subfolder should be manually copied to the test device in the DCIM/testOpenCamera/
+ *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
+ *  time to transfer to the device every time we run the tests.
+ *  On Android 10+, scoped storage permission needs to be given to Open Camera for the DCIM/testOpenCamera/ folder.
+ */
+@RunWith(Categories.class)
+@Categories.IncludeCategory(HDRNTests.class)
+@Suite.SuiteClasses({InstrumentedTest.class})
+public class HDRNTestSuite {}
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/HDRTestSuite.java b/app/src/androidTest/java/net/sourceforge/opencamera/HDRTestSuite.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ecd61239ffc93f031cb06e558ece9f34013e6df
--- /dev/null
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/HDRTestSuite.java
@@ -0,0 +1,17 @@
+package net.sourceforge.opencamera;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/** Tests for HDR algorithm - only need to run on a single device
+ *  Should manually look over the images dumped onto DCIM/
+ *  To use these tests, the testdata/ subfolder should be manually copied to the test device in the DCIM/testOpenCamera/
+ *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
+ *  time to transfer to the device every time we run the tests.
+ *  On Android 10+, scoped storage permission needs to be given to Open Camera for the DCIM/testOpenCamera/ folder.
+ */
+@RunWith(Categories.class)
+@Categories.IncludeCategory(HDRTests.class)
+@Suite.SuiteClasses({InstrumentedTest.class})
+public class HDRTestSuite {}
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/InstrumentedTest.java b/app/src/androidTest/java/net/sourceforge/opencamera/InstrumentedTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7fd9bdd8c73fda1c856e0528a592aa6990da0c1
--- /dev/null
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/InstrumentedTest.java
@@ -0,0 +1,6333 @@
+package net.sourceforge.opencamera;
+
+import static androidx.test.espresso.Espresso.onView;
+import static androidx.test.espresso.action.ViewActions.click;
+import static androidx.test.espresso.assertion.ViewAssertions.matches;
+import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
+import static androidx.test.espresso.matcher.ViewMatchers.withId;
+import static org.hamcrest.Matchers.anyOf;
+import static org.hamcrest.Matchers.endsWith;
+import static org.junit.Assert.*;
+
+import android.annotation.TargetApi;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.graphics.Bitmap;
+import android.os.Build;
+import android.os.Looper;
+import android.preference.PreferenceManager;
+import android.util.Log;
+import android.view.View;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.espresso.matcher.ViewMatchers;
+import androidx.test.ext.junit.rules.ActivityScenarioRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import net.sourceforge.opencamera.ui.DrawPreview;
+import net.sourceforge.opencamera.ui.PopupView;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+interface PhotoTests {}
+
+interface HDRTests {}
+
+interface HDRNTests {}
+
+interface AvgTests {}
+
+interface PanoramaTests {}
+
+@RunWith(AndroidJUnit4.class)
+public class InstrumentedTest {
+
+    private static final String TAG = "InstrumentedTest";
+    public static final boolean test_camera2 = false;
+    //public static final boolean test_camera2 = true;
+
+    static final Intent intent;
+    static {
+        // used for code to run before the activity is started
+        intent = new Intent(ApplicationProvider.getApplicationContext(), MainActivity.class);
+        TestUtils.setDefaultIntent(intent);
+        intent.putExtra("test_project_junit4", true);
+
+        // need to run this here, not in before(), so it's run before activity is created (otherwise Camera2 won't be enabled)
+        TestUtils.initTest(ApplicationProvider.getApplicationContext(), test_camera2);
+    }
+
+    @Rule
+    //public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule<>(MainActivity.class);
+    //public ActivityScenarioRule<MainActivity> mActivityRule = new ActivityScenarioRule<>(MainActivity.class);
+    public ActivityScenarioRule<MainActivity> mActivityRule = new ActivityScenarioRule<>(intent);
+
+    /** This is run before each test, but after the activity is started (unlike MainActivityTest.setUp() which
+     *  is run before the activity is started).
+     */
+    @Before
+    public void before() throws InterruptedException {
+        Log.d(TAG, "before");
+
+        // don't run TestUtils.initTest() here - instead we do it in the static code block, and then
+        // after each test
+
+        // the following was true for MainActivityTest (using ActivityInstrumentationTestCase2), unclear if it's true for
+        // InstrumentedTest:
+        // don't waitUntilCameraOpened() here, as if an assertion fails in setUp(), it can cause later tests to hang in the suite
+        // instead we now wait for camera to open in setToDefault()
+        //waitUntilCameraOpened();
+    }
+
+    @After
+    public void after() throws InterruptedException {
+        Log.d(TAG, "after");
+
+        // As noted above, we need to call TestUtils.initTest() before the activity starts (so in
+        // the static code block, and not before()). But we should still call initTest() before every
+        // subsequent test (so that settings are reset, and test static variables are reset), so
+        // easiest to do this after each test. This also means the application is left in a default
+        // state after running tests.
+        mActivityRule.getScenario().onActivity(activity -> {
+            Log.d(TAG, "after: init");
+            TestUtils.initTest(activity, test_camera2);
+        });
+
+        Log.d(TAG, "after done");
+    }
+
+    private interface GetActivityValueCallback<T> {
+        T get(MainActivity activity);
+    }
+
+    /** This helper method simplifies getting data from the MainActivity.
+     *  We can't call MainActivity classes directly, but instead have to go via
+     *  mActivityRule.getScenario().onActivity().
+     */
+    private <T> T getActivityValue(GetActivityValueCallback<T> cb) {
+        AtomicReference<T> resultRef = new AtomicReference<>();
+        mActivityRule.getScenario().onActivity(activity -> resultRef.set( cb.get(activity) ));
+        return resultRef.get();
+    }
+
+    private void waitUntilCameraOpened() {
+        Log.d(TAG, "wait until camera opened");
+        long time_s = System.currentTimeMillis();
+
+        boolean done = false;
+        while( !done ) {
+            assertTrue( System.currentTimeMillis() - time_s < 20000 );
+            done = getActivityValue(activity -> activity.getPreview().openCameraAttempted());
+        }
+
+        Log.d(TAG, "camera is open!");
+
+        try {
+            Thread.sleep(100); // sleep a bit just to be safe
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void updateForSettings(MainActivity activity) {
+        Log.d(TAG, "updateForSettings");
+        assertEquals(Looper.getMainLooper().getThread(), Thread.currentThread()); // check on UI thread
+        // updateForSettings has code that must run on UI thread
+        activity.initLocation(); // initLocation now called via MainActivity.setWindowFlagsForCamera() rather than updateForSettings()
+        activity.getApplicationInterface().getDrawPreview().updateSettings();
+        activity.updateForSettings(true);
+
+        waitUntilCameraOpened(); // may need to wait if camera is reopened, e.g., when changing scene mode - see testSceneMode()
+        // but we also need to wait for the delay if instead we've stopped and restarted the preview, the latter now only happens after dim_effect_time_c
+        try {
+            Thread.sleep(DrawPreview.dim_effect_time_c+50); // wait for updateForSettings
+        }
+        catch(InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /** Used to click when we have View instead of an Id. It should only be called from onActivity()
+     *  (so that we can be sure we're already on the UI thread).
+     */
+    private void clickView(final View view) {
+        Log.d(TAG, "clickView: "+ view);
+        assertEquals(Looper.getMainLooper().getThread(), Thread.currentThread()); // check on UI thread
+        assertEquals(view.getVisibility(), View.VISIBLE);
+        assertTrue(view.performClick());
+    }
+
+    private void openPopupMenu() {
+        Log.d(TAG, "openPopupMenu");
+        assertFalse( getActivityValue(MainActivity::popupIsOpen) );
+        onView(withId(R.id.popup)).check(matches(isDisplayed()));
+        onView(withId(R.id.popup)).perform(click());
+
+        Log.d(TAG, "wait for popup to open");
+
+        boolean done = false;
+        while( !done ) {
+            done = getActivityValue(MainActivity::popupIsOpen);
+        }
+        Log.d(TAG, "popup is now open");
+    }
+
+    private void switchToFlashValue(String required_flash_value) {
+        Log.d(TAG, "switchToFlashValue: "+ required_flash_value);
+        boolean supports_flash = getActivityValue(activity -> activity.getPreview().supportsFlash());
+        if( supports_flash ) {
+            String flash_value = getActivityValue(activity -> activity.getPreview().getCurrentFlashValue());
+            Log.d(TAG, "start flash_value: "+ flash_value);
+            if( !flash_value.equals(required_flash_value) ) {
+
+                openPopupMenu();
+
+                String flash_value_f = flash_value;
+                mActivityRule.getScenario().onActivity(activity -> {
+                    View currentFlashButton = activity.getUIButton("TEST_FLASH_" + flash_value_f);
+                    assertNotNull(currentFlashButton);
+                    assertEquals(currentFlashButton.getAlpha(), PopupView.ALPHA_BUTTON_SELECTED, 1.0e-5);
+                    View flashButton = activity.getUIButton("TEST_FLASH_" + required_flash_value);
+                    assertNotNull(flashButton);
+                    assertEquals(flashButton.getAlpha(), PopupView.ALPHA_BUTTON, 1.0e-5);
+                    clickView(flashButton);
+                });
+
+                flash_value = getActivityValue(activity -> activity.getPreview().getCurrentFlashValue());
+                Log.d(TAG, "changed flash_value to: "+ flash_value);
+            }
+            assertEquals(flash_value, required_flash_value);
+            String controller_flash_value = getActivityValue(activity -> activity.getPreview().getCameraController().getFlashValue());
+            Log.d(TAG, "controller_flash_value: "+ controller_flash_value);
+            if( flash_value.equals("flash_frontscreen_auto") || flash_value.equals("flash_frontscreen_on") ) {
+                // for frontscreen flash, the controller flash value will be "" (due to real flash not supported) - although on Galaxy Nexus this is "flash_off" due to parameters.getFlashMode() returning Camera.Parameters.FLASH_MODE_OFF
+                assertTrue(controller_flash_value.equals("") || controller_flash_value.equals("flash_off"));
+            }
+            else {
+                Log.d(TAG, "expected_flash_value: "+ flash_value);
+                assertEquals(flash_value, controller_flash_value);
+            }
+        }
+    }
+
+    private void switchToFocusValue(String required_focus_value) {
+        Log.d(TAG, "switchToFocusValue: "+ required_focus_value);
+        boolean supports_focus = getActivityValue(activity -> activity.getPreview().supportsFocus());
+        if( supports_focus ) {
+            String focus_value = getActivityValue(activity -> activity.getPreview().getCurrentFocusValue());
+            Log.d(TAG, "start focus_value: "+ focus_value);
+            if( !focus_value.equals(required_focus_value) ) {
+
+                openPopupMenu();
+
+                mActivityRule.getScenario().onActivity(activity -> {
+                    View focusButton = activity.getUIButton("TEST_FOCUS_" + required_focus_value);
+                    assertNotNull(focusButton);
+                    clickView(focusButton);
+                });
+
+                focus_value = getActivityValue(activity -> activity.getPreview().getCurrentFocusValue());
+                Log.d(TAG, "changed focus_value to: "+ focus_value);
+            }
+            assertEquals(focus_value, required_focus_value);
+            String controller_focus_value = getActivityValue(activity -> activity.getPreview().getCameraController().getFocusValue());
+            Log.d(TAG, "controller_focus_value: "+ controller_focus_value);
+            boolean using_camera2 = getActivityValue(activity -> activity.getPreview().usingCamera2API());
+            String compare_focus_value = focus_value;
+            if( compare_focus_value.equals("focus_mode_locked") )
+                compare_focus_value = "focus_mode_auto";
+            else if( compare_focus_value.equals("focus_mode_infinity") && using_camera2 )
+                compare_focus_value = "focus_mode_manual2";
+            assertEquals(compare_focus_value, controller_focus_value);
+        }
+    }
+
+    /* Sets the camera up to a predictable state:
+     * - Flash off (if flash supported)
+     * - Focus mode picture continuous (if focus modes supported)
+     * As a side-effect, the camera and/or camera parameters values may become invalid.
+     */
+    private void setToDefault() {
+        waitUntilCameraOpened();
+
+        assertFalse( getActivityValue(activity -> activity.getPreview().isVideo()) );
+
+        switchToFlashValue("flash_off");
+        switchToFocusValue("focus_mode_continuous_picture");
+
+        // pause for safety - needed for Nokia 8 at least otherwise some tests like testContinuousPictureFocusRepeat,
+        // testLocationOff result in hang whilst waiting for photo to be taken, and hit the timeout in waitForTakePhoto()
+        try {
+            Thread.sleep(200);
+        }
+        catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /*@Test
+    public void testDummy() {
+        Log.d(TAG, "testDummy");
+    }*/
+
+    private static void checkHistogramDetails(TestUtils.HistogramDetails hdrHistogramDetails, int exp_min_value, int exp_median_value, int exp_max_value) {
+        TestUtils.checkHistogramDetails(hdrHistogramDetails, exp_min_value, exp_median_value, exp_max_value);
+    }
+
+    /** Tests calling the DRO routine with 0.0 factor, and DROALGORITHM_NONE - and that the resultant image is identical.
+     */
+    @Category(HDRTests.class)
+    @Test
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public void testDROZero() throws IOException, InterruptedException {
+        Log.d(TAG, "testDROZero");
+
+        if( Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP ) {
+            Log.d(TAG, "renderscript requires Android Lollipop or better");
+            return;
+        }
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            Bitmap bitmap = TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR3/input1.jpg");
+            Bitmap bitmap_saved = bitmap.copy(bitmap.getConfig(), false);
+
+            try {
+                Thread.sleep(1000); // wait for camera to open
+            }
+            catch(InterruptedException e) {
+                e.printStackTrace();
+            }
+
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add(bitmap);
+            try {
+                activity.getApplicationInterface().getHDRProcessor().processHDR(inputs, true, null, true, null, 0.0f, 4, true, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_REINHARD, HDRProcessor.DROTonemappingAlgorithm.DROALGORITHM_NONE);
+            }
+            catch(HDRProcessorException e) {
+                e.printStackTrace();
+                throw new RuntimeException();
+            }
+
+            TestUtils.saveBitmap(activity, inputs.get(0), "droZerotestHDR3_output.jpg");
+            TestUtils.checkHistogram(activity, bitmap);
+
+            // check bitmaps are the same
+            Log.d(TAG, "compare bitmap " + bitmap);
+            Log.d(TAG, "with bitmap_saved " + bitmap_saved);
+            // sameAs doesn't seem to work
+            //assertTrue( bitmap.sameAs(bitmap_saved) );
+            assertEquals(bitmap.getWidth(), bitmap_saved.getWidth());
+            assertEquals(bitmap.getHeight(), bitmap_saved.getHeight());
+            int [] old_row = new int[bitmap.getWidth()];
+            int [] new_row = new int[bitmap.getWidth()];
+            for(int y=0;y<bitmap.getHeight();y++) {
+                //Log.d(TAG, "check row " + y + " / " + bitmap.getHeight());
+                bitmap_saved.getPixels(old_row, 0, bitmap.getWidth(), 0, y, bitmap.getWidth(), 1);
+                bitmap.getPixels(new_row, 0, bitmap.getWidth(), 0, y, bitmap.getWidth(), 1);
+                for(int x=0;x<bitmap.getWidth();x++) {
+                    //int old_pixel = bitmap_saved.getPixel(x, y);
+                    //int new_pixel = bitmap.getPixel(x, y);
+                    int old_pixel = old_row[x];
+                    int new_pixel = new_row[x];
+                    assertEquals(old_pixel, new_pixel);
+                }
+            }
+
+            bitmap.recycle();
+            bitmap_saved.recycle();
+            try {
+                Thread.sleep(500);
+            }
+            catch(InterruptedException e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    /** Tests DRO only on a dark image.
+     */
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    @Category(HDRTests.class)
+    @Test
+    public void testDRODark0() throws IOException, InterruptedException {
+        Log.d(TAG, "testDRODark0");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.avg_images_path + "testAvg3/input0.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testDRODark0_output.jpg", true, -1, -1);
+        });
+    }
+
+    /** Tests DRO only on a dark image.
+     */
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    @Category(HDRTests.class)
+    @Test
+    public void testDRODark1() throws IOException, InterruptedException {
+        Log.d(TAG, "testDRODark1");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.avg_images_path + "testAvg8/input0.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testDRODark1_output.jpg", true, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "saintpaul".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR1() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR1");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "saintpaul/input2.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "saintpaul/input3.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "saintpaul/input4.jpg") );
+
+            // actual ISO unknown, so guessing
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR1_output.jpg", false, 1600, 1000000000L);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+            //checkHistogramDetails(hdrHistogramDetails, 1, 44, 253);
+            //checkHistogramDetails(hdrHistogramDetails, 1, 42, 253);
+            //checkHistogramDetails(hdrHistogramDetails, 1, 24, 254);
+            checkHistogramDetails(hdrHistogramDetails, 2, 30, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "saintpaul", but with 5 images.
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR1_exp5() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR1_exp5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "saintpaul/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "saintpaul/input2.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "saintpaul/input3.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "saintpaul/input4.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "saintpaul/input5.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR1_exp5_output.jpg", false, -1, -1);
+
+            int [] exp_offsets_x = {0, 0, 0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 3, 43, 251);
+            checkHistogramDetails(hdrHistogramDetails, 6, 42, 251);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "stlouis".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR2() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR2");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "stlouis/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "stlouis/input2.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "stlouis/input3.jpg") );
+
+            // actual ISO unknown, so guessing
+            TestUtils.subTestHDR(activity, inputs, "testHDR2_output.jpg", false, 1600, (long)(1000000000L*2.5));
+
+            int [] exp_offsets_x = {0, 0, 2};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR3".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR3() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR3");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR3/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR3/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR3/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR3_output.jpg", false, 40, 1000000000L/680);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {1, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //TestUtils.checkHistogramDetails(hdrHistogramDetails, 3, 104, 255);
+            //TestUtils.checkHistogramDetails(hdrHistogramDetails, 4, 113, 255);
+            TestUtils.checkHistogramDetails(hdrHistogramDetails, 8, 113, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR4".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR4() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR4");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR4/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR4/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR4/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR4_output.jpg", true, 102, 1000000000L/60);
+
+            int [] exp_offsets_x = {-2, 0, 2};
+            int [] exp_offsets_y = {-1, 0, 1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR5".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR5() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR5/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR5/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR5/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR5_output.jpg", false, 40, 1000000000L/398);
+
+            // Nexus 6:
+            //int [] exp_offsets_x = {0, 0, 0};
+            //int [] exp_offsets_y = {-1, 0, 0};
+            // OnePlus 3T:
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR6".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR6() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR6");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR6/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR6/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR6/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR6_output.jpg", false, 40, 1000000000L/2458);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {1, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR7".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR7() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR7");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR7/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR7/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR7/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR7_output.jpg", false, 40, 1000000000L/538);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR8".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR8() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR8");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR8/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR8/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR8/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR8_output.jpg", false, 40, 1000000000L/148);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR9".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR9() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR9");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR9/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR9/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR9/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR9_output.jpg", false, 40, 1000000000L/1313);
+
+            int [] exp_offsets_x = {-1, 0, 1};
+            int [] exp_offsets_y = {0, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR10".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR10() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR10");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR10/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR10/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR10/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR10_output.jpg", false, 107, 1000000000L/120);
+
+            int [] exp_offsets_x = {2, 0, 0};
+            int [] exp_offsets_y = {5, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR11".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR11() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR11");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR11/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR11/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR11/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR11_output.jpg", true, 40, 1000000000L/2662);
+
+            int [] exp_offsets_x = {-2, 0, 1};
+            int [] exp_offsets_y = {1, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 48, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 65, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 62, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR12".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR12() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR12");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR12/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR12/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR12/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR12_output.jpg", true, 1196, 1000000000L/12);
+
+            int [] exp_offsets_x = {0, 0, 7};
+            int [] exp_offsets_y = {0, 0, 8};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR13".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR13() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR13");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR13/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR13/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR13/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR13_output.jpg", false, 323, 1000000000L/24);
+
+            int [] exp_offsets_x = {0, 0, 2};
+            int [] exp_offsets_y = {0, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR14".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR14() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR14");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR14/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR14/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR14/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR14_output.jpg", false, 40, 1000000000L/1229);
+
+            int [] exp_offsets_x = {0, 0, 1};
+            int [] exp_offsets_y = {0, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR15".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR15() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR15");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR15/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR15/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR15/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR15_output.jpg", false, 40, 1000000000L/767);
+
+            int [] exp_offsets_x = {1, 0, -1};
+            int [] exp_offsets_y = {2, 0, -3};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR16".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR16() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR16");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR16/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR16/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR16/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR16_output.jpg", false, 52, 1000000000L/120);
+
+            int [] exp_offsets_x = {-1, 0, 2};
+            int [] exp_offsets_y = {1, 0, -6};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR17".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR17() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR17");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR17/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR17/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR17/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR17_output.jpg", true, 557, 1000000000L/12);
+
+            // Nexus 6:
+            //int [] exp_offsets_x = {0, 0, -3};
+            //int [] exp_offsets_y = {0, 0, -4};
+            // OnePlus 3T:
+            int [] exp_offsets_x = {0, 0, -2};
+            int [] exp_offsets_y = {0, 0, -3};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR18".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR18() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR18");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR18/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR18/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR18/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR18_output.jpg", true, 100, 1000000000L/800);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 113, 254);
+            //checkHistogramDetails(hdrHistogramDetails, 1, 119, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 5, 120, 255);
+            checkHistogramDetails(hdrHistogramDetails, 2, 120, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR19".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR19() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR19");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR19/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR19/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR19/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR19_output.jpg", true, 100, 1000000000L/160);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR20".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR20() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR20");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR20/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR20/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR20/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR20_output.jpg", true, 100, 1000000000L*2);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {-1, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR21".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR21() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR21");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR21/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR21/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR21/input2.jpg") );
+
+            // ISO and exposure unknown, so guessing
+            TestUtils.subTestHDR(activity, inputs, "testHDR21_output.jpg", true, 800, 1000000000L/12);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR22".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR22() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR22");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR22/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR22/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR22/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR22_output.jpg", true, 391, 1000000000L/12);
+
+            // Nexus 6:
+            //int [] exp_offsets_x = {1, 0, -5};
+            //int [] exp_offsets_y = {1, 0, -6};
+            // OnePlus 3T:
+            int [] exp_offsets_x = {0, 0, -5};
+            int [] exp_offsets_y = {1, 0, -6};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR23", but with 2 images.
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR23_exp2() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR23_exp2");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR23_exp2_output.jpg", false, -1, -1);
+
+            int [] exp_offsets_x = {0, 0};
+            int [] exp_offsets_y = {0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 13, 72, 250);
+            checkHistogramDetails(hdrHistogramDetails, 24, 72, 250);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR23", but with 2 images, and greater exposure gap.
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR23_exp2b() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR23_exp2b");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR23_exp2b_output.jpg", false, -1, -1);
+
+            int [] exp_offsets_x = {0, 0};
+            int [] exp_offsets_y = {0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR23".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR23() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR23");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0066.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+
+            // ISO unknown, so guessing
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR23_output.jpg", false, 1600, 1000000000L);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 17, 81, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 32, 74, 255);
+            checkHistogramDetails(hdrHistogramDetails, 29, 68, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR23", but with 4 images.
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR23_exp4() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR23_exp4");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR23_exp4_output.jpg", false, -1, -1);
+
+            int [] exp_offsets_x = {0, 0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 15, 69, 254);
+            checkHistogramDetails(hdrHistogramDetails, 24, 70, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR23", but with 5 images.
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR23_exp5() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR23_exp5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0066.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR23_exp5_output.jpg", false, -1, -1);
+
+            int [] exp_offsets_x = {0, 0, 0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 17, 81, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 28, 82, 255);
+            checkHistogramDetails(hdrHistogramDetails, 21, 74, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR23", but with 6 images.
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR23_exp6() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR23_exp6");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0072.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0061.png") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR23_exp6_output.jpg", false, -1, -1);
+
+            int [] exp_offsets_x = {0, 0, 0, 0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0, 0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 15, 70, 254);
+            checkHistogramDetails(hdrHistogramDetails, 25, 71, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR23", but with 7 images.
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR23_exp7() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR23_exp7");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0072.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0066.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR23/memorial0061.png") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR23_exp7_output.jpg", false, -1, -1);
+
+            int [] exp_offsets_x = {0, 0, 0, 0, 0, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0, 0, 0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 17, 81, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 28, 82, 255);
+            checkHistogramDetails(hdrHistogramDetails, 20, 72, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR24".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR24() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR24");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR24/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR24/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR24/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR24_output.jpg", true, 40, 1000000000L/422);
+
+            int [] exp_offsets_x = {0, 0, 1};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR25".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR25() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR25");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR25/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR25/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR25/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR25_output.jpg", true, 40, 1000000000L/1917);
+
+            int [] exp_offsets_x = {0, 0, 0};
+            int [] exp_offsets_y = {1, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR26".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR26() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR26");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR26/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR26/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR26/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR26_output.jpg", true, 40, 1000000000L/5325);
+
+            int [] exp_offsets_x = {-1, 0, 1};
+            int [] exp_offsets_y = {1, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 104, 254);
+            checkHistogramDetails(hdrHistogramDetails, 0, 119, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR27".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR27() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR27");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR27/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR27/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR27/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR27_output.jpg", true, 40, 1000000000L/949);
+
+            int [] exp_offsets_x = {0, 0, 2};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR28".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR28() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR28");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR28/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR28/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR28/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR28_output.jpg", true, 294, 1000000000L/20);
+
+            int [] exp_offsets_x = {0, 0, 2};
+            int [] exp_offsets_y = {0, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR29".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR29() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR29");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR29/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR29/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR29/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR29_output.jpg", false, 40, 1000000000L/978);
+
+            int [] exp_offsets_x = {-1, 0, 3};
+            int [] exp_offsets_y = {0, 0, -1};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR30".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR30() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR30");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR30/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR30/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR30/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR30_output.jpg", false, 40, 1000000000L/978);
+
+            // offsets for full image
+            //int [] exp_offsets_x = {-6, 0, -1};
+            //int [] exp_offsets_y = {23, 0, -13};
+            // offsets using centre quarter image
+            int [] exp_offsets_x = {-5, 0, 0};
+            int [] exp_offsets_y = {22, 0, -13};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR31".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR31() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR31");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR31/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR31/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR31/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR31_output.jpg", false, 40, 1000000000L/422);
+
+            // offsets for full image
+            //int [] exp_offsets_x = {0, 0, 4};
+            //int [] exp_offsets_y = {21, 0, -11};
+            // offsets using centre quarter image
+            int [] exp_offsets_x = {0, 0, 3};
+            int [] exp_offsets_y = {21, 0, -11};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR32".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR32() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR32");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR32/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR32/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR32/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR32_output.jpg", true, 40, 1000000000L/1331);
+
+            int [] exp_offsets_x = {1, 0, 0};
+            int [] exp_offsets_y = {13, 0, -10};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 3, 101, 251);
+            //checkHistogramDetails(hdrHistogramDetails, 3, 109, 251);
+            //checkHistogramDetails(hdrHistogramDetails, 6, 111, 252);
+            checkHistogramDetails(hdrHistogramDetails, 2, 111, 252);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR33".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR33() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR33");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR33/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR33/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR33/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR33_output.jpg", true, 40, 1000000000L/354);
+
+            int [] exp_offsets_x = {13, 0, -10};
+            int [] exp_offsets_y = {24, 0, -12};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR34".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR34() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR34");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR34/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR34/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR34/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR34_output.jpg", true, 40, 1000000000L/4792);
+
+            int [] exp_offsets_x = {5, 0, -8};
+            int [] exp_offsets_y = {0, 0, -2};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR35".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR35() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR35");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR35/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR35/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR35/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR35_output.jpg", true, 40, 1000000000L/792);
+
+            int [] exp_offsets_x = {-10, 0, 3};
+            int [] exp_offsets_y = {7, 0, -3};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR36".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR36() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR36");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR36/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR36/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR36/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR36_output.jpg", false, 100, 1000000000L/1148);
+
+            int [] exp_offsets_x = {2, 0, -2};
+            int [] exp_offsets_y = {-4, 0, 2};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR37".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR37() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR37");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR37/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR37/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR37/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR37_output.jpg", false, 46, 1000000000L/120);
+
+            int [] exp_offsets_x = {0, 0, 3};
+            int [] exp_offsets_y = {2, 0, -19};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR38".
+     *  Tests with Filmic tonemapping.
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR38Filmic() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR38Filmic");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR38/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR38/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR38/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR38_filmic_output.jpg", false, 125, 1000000000L/2965, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_FU2);
+
+            int [] exp_offsets_x = {-1, 0, 0};
+            int [] exp_offsets_y = {0, 0, 0};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 92, 254);
+            checkHistogramDetails(hdrHistogramDetails, 0, 93, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR39".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR39() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR39");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR39/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR39/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR39/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR39_output.jpg", false, 125, 1000000000L/2135);
+
+            int [] exp_offsets_x = {-6, 0, -2};
+            int [] exp_offsets_y = {6, 0, -8};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 128, 222);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR40".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR40() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR40");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR40_output.jpg", false, 50, 1000000000L/262);
+
+            int [] exp_offsets_x = {5, 0, -2};
+            int [] exp_offsets_y = {13, 0, 24};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            checkHistogramDetails(hdrHistogramDetails, 1, 138, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR40" with Exponential tonemapping.
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR40Exponential() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR40Exponential");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR40_exponential_output.jpg", false, 50, 1000000000L/262, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_EXPONENTIAL);
+
+            int [] exp_offsets_x = {5, 0, -2};
+            int [] exp_offsets_y = {13, 0, 24};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            checkHistogramDetails(hdrHistogramDetails, 1, 138, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR40" with Filmic tonemapping.
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR40Filmic() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR40Filmic");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR40/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR40_filmic_output.jpg", false, 50, 1000000000L/262, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_FU2);
+
+            int [] exp_offsets_x = {5, 0, -2};
+            int [] exp_offsets_y = {13, 0, 24};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+
+            checkHistogramDetails(hdrHistogramDetails, 1, 130, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR41".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR41() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR41");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR41/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR41/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR41/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR41_output.jpg", false, 925, 1000000000L/25);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR42".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR42() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR42");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR42/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR42/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR42/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR42_output.jpg", false, 112, 1000000000L/679);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR43".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR43() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR43");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR43/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR43/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR43/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR43_output.jpg", false, 1196, 1000000000L/12);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR44".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR44() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR44");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR44/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR44/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR44/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR44_output.jpg", false, 100, 1000000000L/1016);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR45".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR45() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR45");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6314.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6312.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6310.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6309.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6311.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6313.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6315.jpg") );
+
+            // ISO 100, exposure time 2s, but pass in -1 since these are HDRNTests
+            TestUtils.subTestHDR(activity, inputs, "testHDR45_output.jpg", false, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR45".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR45_exp5() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR45_exp5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6314.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6312.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6310.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6309.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6311.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6313.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6315.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR45_exp5_output.jpg", false, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR45".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR45_exp7() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR45_exp7");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6314.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6312.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6310.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6309.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6311.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6313.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR45/IMG_6315.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR45_exp7_output.jpg", false, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR46".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR46() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR46");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 06.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 05.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 04.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 03.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 02.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 01.jpg") );
+
+            // ISO 100, exposure time 1/60s, but pass in -1 since these are HDRNTests
+            TestUtils.subTestHDR(activity, inputs, "testHDR46_output.jpg", false, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR46".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR46_exp5() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR46_exp5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 06.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 05.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 04.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 03.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 02.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 01.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR46_exp5_output.jpg", false, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR47".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR47_exp2() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR47_exp2");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDR47_exp2_output.jpg", false, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR47".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR47() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR47");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
+
+            // ISO 400, exposure time 1/60s, but pass in -1 since these are HDRNTests
+            TestUtils.subTestHDR(activity, inputs, "testHDR47_output.jpg", false, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR47".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR47_exp5() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR47_exp5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR47_exp5_output.jpg", false, -1, -1);
+
+            checkHistogramDetails(hdrHistogramDetails, 1, 73, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR47".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR47_exp7() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR47_exp7");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR47_exp7_output.jpg", false, -1, -1);
+
+            checkHistogramDetails(hdrHistogramDetails, 1, 73, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR48".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR48() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR48");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input2.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input3.jpg") );
+            //inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input4.jpg") );
+
+            // ISO 100, exposure time 1/716s, but pass in -1 since these are HDRNTests
+            TestUtils.subTestHDR(activity, inputs, "testHDR48_output.jpg", false, -1, -1);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR48".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR48_exp5() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR48_exp5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input2.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input3.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR48/input4.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR48_exp5_output.jpg", false, -1, -1);
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 59, 241);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR49".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR49_exp2() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR49_exp2");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input3.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR49_exp2_output.jpg", false, -1, -1);
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 92, 250);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR49".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR49() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR49");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input2.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input3.jpg") );
+
+            // ISO 100, exposure time 1/417s, but pass in -1 since these are HDRNTests
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR49_output.jpg", false, -1, -1);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 81, 254);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR49".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR49_exp4() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR49_exp4");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input3.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input4.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR49_exp4_output.jpg", false, -1, -1);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 100, 245);
+            checkHistogramDetails(hdrHistogramDetails, 0, 94, 244);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR49".
+     */
+    @Category(HDRNTests.class)
+    @Test
+    public void testHDR49_exp5() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR49_exp5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input2.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input3.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR49/input4.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR49_exp5_output.jpg", false, -1, -1);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 72, 244);
+            checkHistogramDetails(hdrHistogramDetails, 0, 78, 243);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR50".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR50() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR50");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR50/IMG_20180626_221357_0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR50/IMG_20180626_221357_1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR50/IMG_20180626_221357_2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR50_output.jpg", false, 867, 1000000000L/14);
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 69, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR51".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR51() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR51");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR51/IMG_20180323_104702_0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR51/IMG_20180323_104702_1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR51/IMG_20180323_104702_2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR51_output.jpg", true, 1600, 1000000000L/11);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR52".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR52() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR52");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR52/IMG_20181023_143633_EXP0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR52/IMG_20181023_143633_EXP1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR52/IMG_20181023_143633_EXP2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR52_output.jpg", false, 100, 1000000000L/2105);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR53".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR53() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR53");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR53/IMG_20181106_135411_EXP0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR53/IMG_20181106_135411_EXP1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR53/IMG_20181106_135411_EXP2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR53_output.jpg", false, 103, 1000000000L/5381);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 55, 254);
+            checkHistogramDetails(hdrHistogramDetails, 0, 64, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR54".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR54() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR54");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR54/IMG_20181107_115508_EXP0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR54/IMG_20181107_115508_EXP1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR54/IMG_20181107_115508_EXP2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR54_output.jpg", false, 752, 1000000000L/14);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR55".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR55() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR55");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR55/IMG_20181107_115608_EXP0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR55/IMG_20181107_115608_EXP1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR55/IMG_20181107_115608_EXP2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR55_output.jpg", false, 1505, 1000000000L/10);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR56".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR56() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR56");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR56/180502_141722_OC_0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR56/180502_141722_OC_1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR56/180502_141722_OC_2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR56_output.jpg", false, 50, 1000000000L/40);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR57".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR57() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR57");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR57/IMG_20181119_145313_EXP0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR57/IMG_20181119_145313_EXP1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR57/IMG_20181119_145313_EXP2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR57_output.jpg", true, 100, 1000000000L/204);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR58".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR58() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR58");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR58/IMG_20190911_210146_0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR58/IMG_20190911_210146_1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR58/IMG_20190911_210146_2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR58_output.jpg", false, 1250, 1000000000L/10);
+            //HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR58_output.jpg", false, 1250, 1000000000L/10, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_CLAMP);
+
+            checkHistogramDetails(hdrHistogramDetails, 11, 119, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR59".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR59() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR59");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR59/IMG_20190911_210154_0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR59/IMG_20190911_210154_1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR59/IMG_20190911_210154_2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR59_output.jpg", false, 1250, 1000000000L/10);
+            //HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR59_output.jpg", false, 1250, 1000000000L/10, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_CLAMP);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR60".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR60() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR60");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR60/IMG_20200507_020319_0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR60/IMG_20200507_020319_1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR60/IMG_20200507_020319_2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR60_output.jpg", false, 491, 1000000000L/10);
+            //HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR60_output.jpg", false, 491, 1000000000L/10, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_CLAMP);
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR61".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR61() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR61");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR61/IMG_20191111_145230_0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR61/IMG_20191111_145230_1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR61/IMG_20191111_145230_2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR61_output.jpg", false, 50, 1000000000L/5025);
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 86, 254);
+
+            int [] exp_offsets_x = {0, 0, 1};
+            int [] exp_offsets_y = {0, 0, -2};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDR62".
+     */
+    @Category(HDRTests.class)
+    @Test
+    public void testHDR62() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDR62");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR62/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR62/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDR62/input2.jpg") );
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestHDR(activity, inputs, "testHDR62_output.jpg", false, 100, 1000000000L/485);
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 113, 247);
+
+            int [] exp_offsets_x = {0, 0, -3};
+            int [] exp_offsets_y = {3, 0, -6};
+            TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y);
+        });
+    }
+
+    /** Tests HDR algorithm on test samples "testHDRtemp".
+     *  Used for one-off testing, or to recreate HDR images from the base exposures to test an updated algorithm.
+     *  The test images should be copied to the test device into DCIM/testOpenCamera/testdata/hdrsamples/testHDRtemp/ .
+     */
+    @Test
+    public void testHDRtemp() throws IOException, InterruptedException {
+        Log.d(TAG, "testHDRtemp");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<Bitmap> inputs = new ArrayList<>();
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDRtemp/input0.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDRtemp/input1.jpg") );
+            inputs.add( TestUtils.getBitmapFromFile(activity, TestUtils.hdr_images_path + "testHDRtemp/input2.jpg") );
+
+            TestUtils.subTestHDR(activity, inputs, "testHDRtemp_output.jpg", true, 100, 1000000000L/100);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg1".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg1() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg1");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg1/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg1/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg1/input2.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity, inputs, "testAvg1_output.jpg", 1600, 1000000000L/17, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //int [] exp_offsets_x = {0, 3, 0};
+                        //int [] exp_offsets_y = {0, 1, 0};
+                        //int [] exp_offsets_x = {0, 4, 0};
+                        //int [] exp_offsets_y = {0, 1, 0};
+                        //int [] exp_offsets_x = {0, 2, 0};
+                        //int [] exp_offsets_y = {0, 0, 0};
+                        int [] exp_offsets_x = {0, 4, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 2 ) {
+                        //int [] exp_offsets_x = {0, 6, 0};
+                        //int [] exp_offsets_y = {0, 0, 0};
+                        //int [] exp_offsets_x = {0, 8, 0};
+                        //int [] exp_offsets_y = {0, 1, 0};
+                        //int [] exp_offsets_x = {0, 7, 0};
+                        //int [] exp_offsets_y = {0, -1, 0};
+                        //int [] exp_offsets_x = {0, 8, 0};
+                        //int [] exp_offsets_y = {0, -4, 0};
+                        int [] exp_offsets_x = {0, 8, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else {
+                        fail();
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg2".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg2() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg2");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg2/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg2/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg2/input2.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg2_output.jpg", 1600, 1000000000L/17, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //int [] exp_offsets_x = {0, -15, 0};
+                        //int [] exp_offsets_y = {0, -10, 0};
+                        //int [] exp_offsets_x = {0, -15, 0};
+                        //int [] exp_offsets_y = {0, -11, 0};
+                        //int [] exp_offsets_x = {0, -12, 0};
+                        //int [] exp_offsets_y = {0, -12, 0};
+                        int [] exp_offsets_x = {0, -16, 0};
+                        int [] exp_offsets_y = {0, -12, 0};
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 2 ) {
+                        //int [] exp_offsets_x = {0, -15, 0};
+                        //int [] exp_offsets_y = {0, -10, 0};
+                        //int [] exp_offsets_x = {0, -13, 0};
+                        //int [] exp_offsets_y = {0, -12, 0};
+                        //int [] exp_offsets_x = {0, -12, 0};
+                        //int [] exp_offsets_y = {0, -14, 0};
+                        int [] exp_offsets_x = {0, -12, 0};
+                        int [] exp_offsets_y = {0, -12, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else {
+                        fail();
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg3".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg3() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg3");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg3/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg3/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg3/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg3/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg3/input4.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg3_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                /*if( index == 1 ) {
+                    //int [] exp_offsets_x = {0, 2, 0};
+                    //int [] exp_offsets_y = {0, -18, 0};
+                    //int [] exp_offsets_x = {0, -1, 0};
+                    //int [] exp_offsets_y = {0, 0, 0};
+                    //int [] exp_offsets_x = {0, -9, 0};
+                    //int [] exp_offsets_y = {0, -11, 0};
+                    //int [] exp_offsets_x = {0, -8, 0};
+                    //int [] exp_offsets_y = {0, -10, 0};
+                    int [] exp_offsets_x = {0, -8, 0};
+                    int [] exp_offsets_y = {0, -8, 0};
+                    assertTrue(activity.getApplicationInterface().getHDRProcessor().sharp_index == 0);
+                    TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                }
+                else if( index == 2 ) {
+                    //int [] exp_offsets_x = {0, -18, 0};
+                    //int [] exp_offsets_y = {0, 17, 0};
+                    //int [] exp_offsets_x = {0, -2, 0};
+                    //int [] exp_offsets_y = {0, 0, 0};
+                    //int [] exp_offsets_x = {0, -7, 0};
+                    //int [] exp_offsets_y = {0, -2, 0};
+                    //int [] exp_offsets_x = {0, -8, 0};
+                    //int [] exp_offsets_y = {0, -8, 0};
+                    int [] exp_offsets_x = {0, -12, 0};
+                    int [] exp_offsets_y = {0, 8, 0};
+                    TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                }
+                else if( index == 3 ) {
+                    //int [] exp_offsets_x = {0, -12, 0};
+                    //int [] exp_offsets_y = {0, -25, 0};
+                    //int [] exp_offsets_x = {0, -2, 0};
+                    //int [] exp_offsets_y = {0, 0, 0};
+                    //int [] exp_offsets_x = {0, -9, 0};
+                    //int [] exp_offsets_y = {0, 14, 0};
+                    //int [] exp_offsets_x = {0, -8, 0};
+                    //int [] exp_offsets_y = {0, 2, 0};
+                    //int [] exp_offsets_x = {0, -12, 0};
+                    //int [] exp_offsets_y = {0, 12, 0};
+                    int [] exp_offsets_x = {0, -12, 0};
+                    int [] exp_offsets_y = {0, 4, 0};
+                    TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                }
+                else if( index == 4 ) {
+                    //int [] exp_offsets_x = {0, -29, 0};
+                    //int [] exp_offsets_y = {0, -22, 0};
+                    //int [] exp_offsets_x = {0, -2, 0};
+                    //int [] exp_offsets_y = {0, 0, 0};
+                    //int [] exp_offsets_x = {0, -7, 0};
+                    //int [] exp_offsets_y = {0, 11, 0};
+                    //int [] exp_offsets_x = {0, -6, 0};
+                    //int [] exp_offsets_y = {0, 14, 0};
+                    //int [] exp_offsets_x = {0, -8, 0};
+                    //int [] exp_offsets_y = {0, 2, 0};
+                    //int [] exp_offsets_x = {0, -8, 0};
+                    //int [] exp_offsets_y = {0, 12, 0};
+                    int [] exp_offsets_x = {0, -8, 0};
+                    int [] exp_offsets_y = {0, 4, 0};
+                    TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                }
+                else {
+                    assertTrue(false);
+                }*/
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 21, 177);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 21, 152);
+            checkHistogramDetails(hdrHistogramDetails, 0, 21, 166);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg4".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg4() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg4");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg4/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg4/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg4/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg4/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg4/input4.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg4_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //int [] exp_offsets_x = {0, 5, 0};
+                        //int [] exp_offsets_y = {0, 2, 0};
+                        int [] exp_offsets_x = {0, 5, 0};
+                        int [] exp_offsets_y = {0, 1, 0};
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 2 ) {
+                        //int [] exp_offsets_x = {0, 3, 0};
+                        //int [] exp_offsets_y = {0, 5, 0};
+                        int [] exp_offsets_x = {0, 4, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 3 ) {
+                        //int [] exp_offsets_x = {0, 0, 0};
+                        //int [] exp_offsets_y = {0, 7, 0};
+                        //int [] exp_offsets_x = {0, 1, 0};
+                        //int [] exp_offsets_y = {0, 6, 0};
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 8, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 4 ) {
+                        //int [] exp_offsets_x = {0, 4, 0};
+                        //int [] exp_offsets_y = {0, 8, 0};
+                        //int [] exp_offsets_x = {0, 3, 0};
+                        //int [] exp_offsets_y = {0, 7, 0};
+                        //int [] exp_offsets_x = {0, 3, 0};
+                        //int [] exp_offsets_y = {0, 8, 0};
+                        int [] exp_offsets_x = {0, 3, 0};
+                        int [] exp_offsets_y = {0, 9, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else {
+                        fail();
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg5".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg5() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg5/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg5/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg5/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg5/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg5/input4.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg5_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                /*if( index == 1 ) {
+                    //int [] exp_offsets_x = {0, 4, 0};
+                    //int [] exp_offsets_y = {0, -1, 0};
+                    //int [] exp_offsets_x = {0, 5, 0};
+                    //int [] exp_offsets_y = {0, 0, 0};
+                    //int [] exp_offsets_x = {0, 6, 0};
+                    //int [] exp_offsets_y = {0, -2, 0};
+                    int [] exp_offsets_x = {0, 4, 0};
+                    int [] exp_offsets_y = {0, 0, 0};
+                    assertTrue(activity.getApplicationInterface().getHDRProcessor().sharp_index == 0);
+                    TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                }
+                else if( index == 2 ) {
+                    //int [] exp_offsets_x = {0, 7, 0};
+                    //int [] exp_offsets_y = {0, -2, 0};
+                    //int [] exp_offsets_x = {0, 8, 0};
+                    //int [] exp_offsets_y = {0, -1, 0};
+                    int [] exp_offsets_x = {0, 8, 0};
+                    int [] exp_offsets_y = {0, -4, 0};
+                    TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                }
+                else if( index == 3 ) {
+                    //int [] exp_offsets_x = {0, 9, 0};
+                    //int [] exp_offsets_y = {0, -2, 0};
+                    //int [] exp_offsets_x = {0, 8, 0};
+                    //int [] exp_offsets_y = {0, -1, 0};
+                    int [] exp_offsets_x = {0, 8, 0};
+                    int [] exp_offsets_y = {0, 0, 0};
+                    TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                }
+                else if( index == 4 ) {
+                    //int [] exp_offsets_x = {0, 10, 0};
+                    //int [] exp_offsets_y = {0, -4, 0};
+                    int [] exp_offsets_x = {0, 11, 0};
+                    int [] exp_offsets_y = {0, -3, 0};
+                    TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                }
+                else {
+                    assertTrue(false);
+                }*/
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg6".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg6() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg6");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg6/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg6/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg6/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg6/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg6/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg6/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg6/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg6/input7.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg6_output.jpg", 1600, 1000000000L/17, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                /*if( true )
+                    return;*/
+                    if( index == 1 ) {
+                        //int [] exp_offsets_x = {0, 0, 0};
+                        //int [] exp_offsets_y = {0, 0, 0};
+                        //int [] exp_offsets_x = {0, -2, 0};
+                        //int [] exp_offsets_y = {0, 0, 0};
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                    else if( index == 2 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 3 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 4 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 5 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 6 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 7 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else {
+                        fail();
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 18, 51, 201);
+            //checkHistogramDetails(hdrHistogramDetails, 14, 38, 200);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 9, 193);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 9, 199);
+            //checkHistogramDetails(hdrHistogramDetails, 12, 46, 202);
+            //checkHistogramDetails(hdrHistogramDetails, 12, 46, 205);
+            //checkHistogramDetails(hdrHistogramDetails, 12, 44, 209);
+            //checkHistogramDetails(hdrHistogramDetails, 12, 44, 202);
+            //checkHistogramDetails(hdrHistogramDetails, 5, 16, 190);
+            checkHistogramDetails(hdrHistogramDetails, 5, 19, 199);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg7".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg7() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg7");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg7/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg7/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg7/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg7/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg7/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg7/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg7/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg7/input7.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg7_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //int [] exp_offsets_x = {0, 0, 0};
+                        //int [] exp_offsets_y = {0, 0, 0};
+                        //int [] exp_offsets_x = {0, -10, 0};
+                        //int [] exp_offsets_y = {0, 6, 0};
+                        //int [] exp_offsets_x = {0, -6, 0};
+                        //int [] exp_offsets_y = {0, 2, 0};
+                        //int [] exp_offsets_x = {0, -4, 0};
+                        //int [] exp_offsets_y = {0, 0, 0};
+                        //int [] exp_offsets_x = {0, 0, 0};
+                        //int [] exp_offsets_y = {0, 0, 0};
+                        //int [] exp_offsets_x = {0, -4, 0};
+                        //int [] exp_offsets_y = {0, 0, 0};
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg8".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg8() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg8");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg8/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg8/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg8/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg8/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg8/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg8/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg8/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg8/input7.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg8_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 4, 26, 92);
+            //checkHistogramDetails(hdrHistogramDetails, 3, 19, 68);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 10, 60);
+            //checkHistogramDetails(hdrHistogramDetails, 1, 8, 72);
+            //checkHistogramDetails(hdrHistogramDetails, 1, 6, 64);
+            //checkHistogramDetails(hdrHistogramDetails, 1, 15, 75);
+            checkHistogramDetails(hdrHistogramDetails, 1, 16, 78);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg9".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg9() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg9");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            final boolean use_auto_photos = true;
+
+            if( use_auto_photos ) {
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto0.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto1.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto2.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto3.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto4.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto5.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto6.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto7.jpg");
+            }
+            else {
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input0.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input1.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input2.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input3.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input4.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input5.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input6.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg9/input7.jpg");
+            }
+
+            String out_filename = use_auto_photos ? "testAvg9_auto_output.jpg" : "testAvg9_output.jpg";
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, out_filename, 1600, use_auto_photos ? 1000000000L/16 : 1000000000L/11, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg10".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg10() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg10");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            final boolean use_auto_photos = false;
+
+            if( use_auto_photos ) {
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto0.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto1.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto2.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto3.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto4.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto5.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto6.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto7.jpg");
+            }
+            else {
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input0.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input1.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input2.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input3.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input4.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input5.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input6.jpg");
+                inputs.add(TestUtils.avg_images_path + "testAvg10/input7.jpg");
+            }
+
+            String out_filename = use_auto_photos ? "testAvg10_auto_output.jpg" : "testAvg10_output.jpg";
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, out_filename, 1196, use_auto_photos ? 1000000000L/12 : 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg11".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg11() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg11");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // note, we don't actually use 8 images for a bright scene like this, but it serves as a good test for
+            // misalignment/ghosting anyway
+            inputs.add(TestUtils.avg_images_path + "testAvg11/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg11/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg11/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg11/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg11/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg11/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg11/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg11/input7.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg11_output.jpg", 100, 1000000000L/338, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //int [] exp_offsets_x = {0, 4, 0};
+                        //int [] exp_offsets_y = {0, -8, 0};
+                        //int [] exp_offsets_x = {0, 6, 0};
+                        //int [] exp_offsets_y = {0, -8, 0};
+                        //int [] exp_offsets_x = {0, -6, 0};
+                        //int [] exp_offsets_y = {0, 8, 0};
+                        int [] exp_offsets_x = {0, -4, 0};
+                        int [] exp_offsets_y = {0, 8, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                        //assertTrue(activity.getApplicationInterface().getHDRProcessor().sharp_index == 1);
+                    }
+                    else if( index == 2 ) {
+                        //int [] exp_offsets_x = {0, -5, 0};
+                        //int [] exp_offsets_y = {0, -1, 0};
+                        //int [] exp_offsets_x = {0, -10, 0};
+                        //int [] exp_offsets_y = {0, 6, 0};
+                        int [] exp_offsets_x = {0, -8, 0};
+                        int [] exp_offsets_y = {0, 8, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 3 ) {
+                        //int [] exp_offsets_x = {0, -1, 0};
+                        //int [] exp_offsets_y = {0, -18, 0};
+                        //int [] exp_offsets_x = {0, 0, 0};
+                        //int [] exp_offsets_y = {0, -16, 0};
+                        //int [] exp_offsets_x = {0, -4, 0};
+                        //int [] exp_offsets_y = {0, -10, 0};
+                        //int [] exp_offsets_x = {0, -4, 0};
+                        //int [] exp_offsets_y = {0, -8, 0};
+                        int [] exp_offsets_x = {0, -4, 0};
+                        int [] exp_offsets_y = {0, -12, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 4 ) {
+                        //int [] exp_offsets_x = {0, -3, 0};
+                        //int [] exp_offsets_y = {0, -20, 0};
+                        //int [] exp_offsets_x = {0, -2, 0};
+                        //int [] exp_offsets_y = {0, -18, 0};
+                        //int [] exp_offsets_x = {0, -6, 0};
+                        //int [] exp_offsets_y = {0, -12, 0};
+                        int [] exp_offsets_x = {0, -8, 0};
+                        int [] exp_offsets_y = {0, -12, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 5 ) {
+                        //int [] exp_offsets_x = {0, -8, 0};
+                        //int [] exp_offsets_y = {0, 2, 0};
+                        //int [] exp_offsets_x = {0, -10, 0};
+                        //int [] exp_offsets_y = {0, 4, 0};
+                        //int [] exp_offsets_x = {0, -12, 0};
+                        //int [] exp_offsets_y = {0, 10, 0};
+                        int [] exp_offsets_x = {0, -12, 0};
+                        int [] exp_offsets_y = {0, 8, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 6 ) {
+                        //int [] exp_offsets_x = {0, 0, 0};
+                        //int [] exp_offsets_y = {0, -6, 0};
+                        //int [] exp_offsets_x = {0, 2, 0};
+                        //int [] exp_offsets_y = {0, -6, 0};
+                        //int [] exp_offsets_x = {0, -4, 0};
+                        //int [] exp_offsets_y = {0, 2, 0};
+                        int [] exp_offsets_x = {0, -4, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 7 ) {
+                        //int [] exp_offsets_x = {0, 7, 0};
+                        //int [] exp_offsets_y = {0, -2, 0};
+                        //int [] exp_offsets_x = {0, 6, 0};
+                        //int [] exp_offsets_y = {0, 6, 0};
+                        //int [] exp_offsets_x = {0, 4, 0};
+                        //int [] exp_offsets_y = {0, 4, 0};
+                        //int [] exp_offsets_x = {0, 8, 0};
+                        //int [] exp_offsets_y = {0, 8, 0};
+                        int [] exp_offsets_x = {0, 4, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else {
+                        fail();
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg12".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg12() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg12");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg12/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg12/input1.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg12_output.jpg", 100, 1000000000L/1617, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //assertTrue(activity.getApplicationInterface().getHDRProcessor().sharp_index == 1);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 30, 254);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 27, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 20, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 17, 254);
+            checkHistogramDetails(hdrHistogramDetails, 0, 31, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg13".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg13() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg13");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg13/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg13/input1.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg13_output.jpg", 100, 1000000000L/2482, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //assertTrue(activity.getApplicationInterface().getHDRProcessor().sharp_index == 1);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg14".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg14() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg14");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg14/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg14/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg14/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg14/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg14/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg14/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg14/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg14/input7.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg14_output.jpg", 1600, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        int [] exp_offsets_x = {0, -8, 0};
+                        int [] exp_offsets_y = {0, -8, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                    else if( index == 7 ) {
+                        //int [] exp_offsets_x = {0, 4, 0};
+                        //int [] exp_offsets_y = {0, 28, 0};
+                        int [] exp_offsets_x = {0, 4, 0};
+                        int [] exp_offsets_y = {0, 40, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                }
+            });
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 25, 245);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg15".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg15() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg15");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg15/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg15/input1.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg15_output.jpg", 100, 1000000000L/1525, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 38, 254);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg16".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg16() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg16");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg16/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg16/input1.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg16_output.jpg", 100, 1000000000L/293, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //assertTrue(activity.getApplicationInterface().getHDRProcessor().sharp_index == 1);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg17".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg17() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg17");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg17/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg17/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg17/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg17/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg17/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg17/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg17/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg17/input7.jpg");
+
+            // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
+            // of 800; in reality for a scene this dark, it was probably more like ISO 1600
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg17_output.jpg", 1600, 1000000000L/17, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        int [] exp_offsets_x = {0, -8, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                    else if( index == 7 ) {
+                        int [] exp_offsets_x = {0, 12, 0};
+                        int [] exp_offsets_y = {0, 28, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 100, 233);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 100, 236);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 92, 234);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 102, 241);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 102, 238);
+            checkHistogramDetails(hdrHistogramDetails, 0, 103, 244);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg18".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg18() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg18");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg18/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg18/input1.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg18_output.jpg", 100, 1000000000L/591, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        //assertTrue(activity.getApplicationInterface().getHDRProcessor().sharp_index == 1);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg19".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg19() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg19");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // repeat same image twice
+            inputs.add(TestUtils.avg_images_path + "testAvg19/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg19/input0.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg19_output.jpg", 100, 1000000000L/2483, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 88, 252);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 77, 252);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 87, 252);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 74, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 58, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg20".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg20() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg20");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // repeat same image twice
+            inputs.add(TestUtils.avg_images_path + "testAvg20/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg20/input0.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg20_output.jpg", 100, 1000000000L/3124, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg21".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg21() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg21");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // repeat same image twice
+            inputs.add(TestUtils.avg_images_path + "testAvg21/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg21/input0.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg21_output.jpg", 102, 1000000000L/6918, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg22".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg22() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg22");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // repeat same image twice
+            inputs.add(TestUtils.avg_images_path + "testAvg22/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg22/input0.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg22_output.jpg", 100, 1000000000L/3459, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg23".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg23() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg23");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_3.jpg");
+            // only test 4 images, to reflect latest behaviour that we take 4 images for this ISO
+        /*inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_7.jpg");*/
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg23_output.jpg", 1044, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        int [] exp_offsets_x = {0, -4, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 2 ) {
+                        int [] exp_offsets_x = {0, -4, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 3 ) {
+                        int [] exp_offsets_x = {0, -8, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 4 ) {
+                        int [] exp_offsets_x = {0, -8, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 5 ) {
+                        int [] exp_offsets_x = {0, -12, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 6 ) {
+                        int [] exp_offsets_x = {0, -12, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 7 ) {
+                        int [] exp_offsets_x = {0, -12, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else {
+                        fail();
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 81, 251);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 80, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 83, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg24".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg24() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg24");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg24/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg24/input1.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg24_output.jpg", 100, 1000000000L/2421, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 77, 250);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 74, 250);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 86, 250);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 86, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 80, 254);
+            checkHistogramDetails(hdrHistogramDetails, 0, 56, 254);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg25".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg25() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg25");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg25/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg25/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg25/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg25/input3.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg25_output.jpg", 512, 1000000000L/20, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg26".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg26() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg26");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // note we now take only 3 images for bright scenes, but still test with 4 images as this serves as a good test
+            // against ghosting
+            inputs.add(TestUtils.avg_images_path + "testAvg26/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg26/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg26/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg26/input3.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg26_output.jpg", 100, 1000000000L/365, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                /*if( true )
+                    return;*/
+                    if( index == 1 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 2 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 3 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, -4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else {
+                        fail();
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg27".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg27() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg27");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg27/IMG_20180610_205929_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg27/IMG_20180610_205929_1.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg27_output.jpg", 100, 1000000000L/482, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg28".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg28() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg28");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg28/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg28/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg28/input003.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg28/input004.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg28/input005.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg28/input006.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg28/input007.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg28/input008.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg28_output.jpg", 811, 1000000000L/21, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 21, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 18, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 8, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 13, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg29".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg29() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg29");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input003.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input004.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input005.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input006.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input007.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input008.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg29/input009.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg29_output.jpg", 40, 1000000000L/2660, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 88, 127, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 92, 134, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg30".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg30() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg30");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg30/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg30/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg30/input003.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg30_output.jpg", 60, 1000000000L/411, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 2 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, -4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 3 ) {
+                        int [] exp_offsets_x = {0, 0, 0};
+                        int [] exp_offsets_y = {0, -4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else {
+                        fail();
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 134, 254);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 144, 254);
+            checkHistogramDetails(hdrHistogramDetails, 0, 107, 254);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg31".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg31() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg31");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input003.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input004.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input005.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input006.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input007.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input008.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input009.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg31/input010.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg31_output.jpg", 609, 1000000000L/25, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 24, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 9, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 13, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg32".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg32() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg32");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg32/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg32/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg32/input003.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg32/input004.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg32/input005.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg32/input006.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg32/input007.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg32_output.jpg", 335, 1000000000L/120, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 34, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 13, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 36, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 61, 254);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg33".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg33() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg33");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input003.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input004.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input005.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input006.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input007.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input008.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input009.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg33/input010.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg33_output.jpg", 948, 1000000000L/18, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 81, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 63, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg34".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg34() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg34");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg34/IMG_20180627_121959_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg34/IMG_20180627_121959_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg34/IMG_20180627_121959_2.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg34_output.jpg", 100, 1000000000L/289, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 86, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 108, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 114, 254);
+            checkHistogramDetails(hdrHistogramDetails, 0, 103, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg35".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg35() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg35");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg35/IMG_20180711_144453_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg35/IMG_20180711_144453_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg35/IMG_20180711_144453_2.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg35_output.jpg", 100, 1000000000L/2549, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 165, 247);
+            checkHistogramDetails(hdrHistogramDetails, 0, 169, 248);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg36".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg36() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg36");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_3.jpg");
+            // only test 4 images, to reflect latest behaviour that we take 4 images for this ISO/exposure time
+        /*inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_7.jpg");*/
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg36_output.jpg", 752, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        int [] exp_offsets_x = {0, -12, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                    else if( index == 3 ) {
+                        int [] exp_offsets_x = {0, -28, 0};
+                        int [] exp_offsets_y = {0, 0, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 86, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg37".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg37() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg37");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg37/IMG_20180715_173155_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg37/IMG_20180715_173155_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg37/IMG_20180715_173155_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg37/IMG_20180715_173155_3.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg37_output.jpg", 131, 1000000000L/50, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 12, 109, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 3, 99, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 99, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 125, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 94, 255);
+            checkHistogramDetails(hdrHistogramDetails, 6, 94, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg38".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg38() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg38");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_7.jpg");
+
+            // n.b., this was a zoomed in photo, but can't quite remember the exact zoom level!
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg38_output.jpg", 1505, 1000000000L/10, 3.95f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg39".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg39() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg39");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input003.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input004.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input005.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input006.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input007.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input008.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input009.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg39/input010.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg39_output.jpg", 521, 1000000000L/27, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 64, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 25, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg40".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg40() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg40");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input003.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input004.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input005.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input006.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input007.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input008.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg40/input009.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg40_output.jpg", 199, 1000000000L/120, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 50, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 19, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 50, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 67, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg41".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg41() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg41");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            // example from Google HDR+ dataset
+            // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
+            // to the Google HDR+ result
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input001.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input002.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input003.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input004.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input005.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input006.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input007.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input008.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input009.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg41/input010.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg41_output.jpg", 100, 1000000000L/869, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 49, 255);
+            //checkHistogramDetails(hdrHistogramDetails, 0, 37, 255);
+            checkHistogramDetails(hdrHistogramDetails, 0, 59, 254);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg42".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg42() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg42");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg42/IMG_20180822_145152_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg42/IMG_20180822_145152_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg42/IMG_20180822_145152_2.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg42_output.jpg", 100, 1000000000L/2061, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 67, 254);
+            checkHistogramDetails(hdrHistogramDetails, 0, 61, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg43".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg43() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg43");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg43/IMG_20180831_143226_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg43/IMG_20180831_143226_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg43/IMG_20180831_143226_2.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg43_output.jpg", 100, 1000000000L/2152, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 69, 253);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg44".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg44() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg44");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg44/IMG_20180830_133917_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg44/IMG_20180830_133917_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg44/IMG_20180830_133917_2.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg44_output.jpg", 40, 1000000000L/2130, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg45".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg45() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg45");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg45/IMG_20180719_133947_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg45/IMG_20180719_133947_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg45/IMG_20180719_133947_2.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg45_output.jpg", 100, 1000000000L/865, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg46".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg46() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg46");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_7.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg46_output.jpg", 1505, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 30, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg47".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg47() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg47");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg47/IMG_20180911_114752_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg47/IMG_20180911_114752_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg47/IMG_20180911_114752_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg47/IMG_20180911_114752_3.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg47_output.jpg", 749, 1000000000L/12, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 30, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg48".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg48() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg48");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_7.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg48_output.jpg", 1196, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 30, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg49".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg49() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg49");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_7.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg49_output.jpg", 1505, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 30, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg50".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg50() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg50");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg50/IMG_20181015_144335_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg50/IMG_20181015_144335_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg50/IMG_20181015_144335_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg50/IMG_20181015_144335_3.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg50_output.jpg", 114, 1000000000L/33, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            checkHistogramDetails(hdrHistogramDetails, 0, 91, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg51".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg51() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg51");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_7.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg51_output.jpg", 1600, 1000000000L/3, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                    if( index == 1 ) {
+                        int [] exp_offsets_x = {0, 8, 0};
+                        int [] exp_offsets_y = {0, 4, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                        assertEquals(0, activity.getApplicationInterface().getHDRProcessor().sharp_index);
+                    }
+                    else if( index == 7 ) {
+                        int [] exp_offsets_x = {0, 60, 0};
+                        int [] exp_offsets_y = {0, 28, 0};
+                        TestUtils.checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize());
+                    }
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 91, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvg52".
+     */
+    @Category(AvgTests.class)
+    @Test
+    public void testAvg52() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvg52");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvg52/IMG_20181119_144836_0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg52/IMG_20181119_144836_1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg52/IMG_20181119_144836_2.jpg");
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvg52_output.jpg", 100, 1000000000L/297, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 0, 91, 255);
+        });
+    }
+
+    /** Tests Avg algorithm on test samples "testAvgtemp".
+     *  Used for one-off testing, or to recreate NR images from the base exposures to test an updated alorithm.
+     *  The test images should be copied to the test device into DCIM/testOpenCamera/testdata/hdrsamples/testAvgtemp/ .
+     */
+    @Test
+    public void testAvgtemp() throws IOException, InterruptedException {
+        Log.d(TAG, "testAvgtemp");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+            inputs.add(TestUtils.avg_images_path + "testAvgtemp/input0.png");
+            /*inputs.add(TestUtils.avg_images_path + "testAvgtemp/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvgtemp/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvgtemp/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvgtemp/input3.jpg");*/
+            /*inputs.add(TestUtils.avg_images_path + "testAvgtemp/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvgtemp/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvgtemp/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvgtemp/input7.jpg");*/
+
+            TestUtils.HistogramDetails hdrHistogramDetails = TestUtils.subTestAvg(activity,inputs, "testAvgtemp_output.jpg", 250, 1000000000L/33, 1.0f, new TestUtils.TestAvgCallback() {
+                @Override
+                public void doneProcessAvg(int index) {
+                    Log.d(TAG, "doneProcessAvg: " + index);
+                }
+            });
+
+            //checkHistogramDetails(hdrHistogramDetails, 1, 39, 253);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanoramaWhite".
+     *  This tests that auto-alignment fails gracefully if we can't find any matches.
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanoramaWhite() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanoramaWhite");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            inputs.add(TestUtils.panorama_images_path + "testPanoramaWhite/input0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanoramaWhite/input0.jpg");
+            float camera_angle_x = 66.3177f;
+            float camera_angle_y = 50.04736f;
+            float panorama_pics_per_screen = 2.0f;
+            String output_name = "testPanoramaWhite_output.jpg";
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, null, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 2.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama1".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama1() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama1");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            inputs.add(TestUtils.panorama_images_path + "testPanorama1/input0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama1/input1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama1/input2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama1/input3.jpg");
+            float camera_angle_x = 62.93796f;
+            float camera_angle_y = 47.44656f;
+            float panorama_pics_per_screen = 2.0f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (47.44656/49.56283);
+            String output_name = "testPanorama1_output.jpg";
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, null, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 2.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama2".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama2() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama2");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            /*final float panorama_pics_per_screen = 1.0f;
+            //inputs.add(TestUtils.panorama_images_path + "testPanorama2xxx/input0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama2xxx/input1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama2xxx/input2.jpg");*/
+            /*final float panorama_pics_per_screen = 2.0f;
+            //inputs.add(TestUtils.panorama_images_path + "testPanorama1/input0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama1/input1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama1/input2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama1/input3.jpg");
+            String output_name = "testPanorama1_output.jpg";*/
+            float panorama_pics_per_screen = 4.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama2/input0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama2/input1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama2/input2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama2/input3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama2/input4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama2/input5.jpg");
+            String output_name = "testPanorama2_output.jpg";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/52.26029);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, null, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 2.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama3".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama3() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama3");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 4.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131249.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131252.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131255.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131258.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131301.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131303.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131305.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131307.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131315.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131317.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131320.jpg");
+            String output_name = "testPanorama3_output.jpg";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/52.26029);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, null, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama3", with panorama_pics_per_screen set
+     *  to 4.0.
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama3_picsperscreen2() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama3_picsperscreen2");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 2.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131249.jpg");
+            //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131252.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131255.jpg");
+            //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131258.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131301.jpg");
+            //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131303.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131305.jpg");
+            //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131307.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131315.jpg");
+            //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131317.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131320.jpg");
+            String output_name = "testPanorama3_picsperscreen2_output.jpg";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/52.26029);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, null, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama4".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama4() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama4");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 4.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_7.jpg");
+            String output_name = "testPanorama4_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/52.26029);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama5".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama5() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama5");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 4.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_7.jpg");
+            String output_name = "testPanorama5_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/52.26029);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama6".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama6() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama6");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 4.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_7.jpg");
+            String output_name = "testPanorama6_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/52.26029);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama7".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama7() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama7");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 4.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_8.jpg");
+            String output_name = "testPanorama7_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/52.26029);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama8".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama8() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama8");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 2.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431_3.jpg");
+            String output_name = "testPanorama8_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/52.26029);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama9".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama9() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama9");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_6.jpg");
+            String output_name = "testPanorama9_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/50.44399);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+
+            try {
+                Thread.sleep(1000); // need to wait for debug images to be saved/broadcast?
+            }
+            catch(InterruptedException e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama10".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama10() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama10");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_9.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_10.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_11.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_12.jpg");
+            String output_name = "testPanorama10_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/50.44399);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama11".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama11() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama11");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_6.jpg");
+            String output_name = "testPanorama11_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/50.44399);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama12".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama12() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama12");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_9.jpg");
+            String output_name = "testPanorama12_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+            // these images were taken with incorrect camera view angles, so we compensate in the test:
+            panorama_pics_per_screen *= (50.282097/50.44399);
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama13".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama13() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama13");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_9.jpg");
+            String output_name = "testPanorama13_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152.xml";
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama14".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama14() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama14");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_9.jpg");
+            String output_name = "testPanorama14_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama15".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama15() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama15");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_9.jpg");
+            String output_name = "testPanorama15_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama16".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama16() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama16");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_9.jpg");
+            String output_name = "testPanorama16_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama17".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama17() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama17");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_9.jpg");
+            String output_name = "testPanorama17_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama18".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama18() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama18");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_9.jpg");
+            String output_name = "testPanorama18_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama19".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama19() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama19");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_9.jpg");
+            String output_name = "testPanorama19_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama20".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama20() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama20");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_9.jpg");
+            String output_name = "testPanorama20_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama21".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama21() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama21");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_9.jpg");
+            String output_name = "testPanorama21_output.jpg";
+            String gyro_name = TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552.xml";
+            //gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 0.5f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama22".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama22() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama22");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_7.jpg");
+            String output_name = "testPanorama22_output.jpg";
+            String gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama23".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama23() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama23");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_4.jpg");
+            String output_name = "testPanorama23_output.jpg";
+            String gyro_name = null;
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama24".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama24() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama24");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_9.jpg");
+            String output_name = "testPanorama24_output.jpg";
+            String gyro_name = null;
+            // taken with OnePlus 3T, Camera2 API:
+            float camera_angle_x = 62.93796f;
+            float camera_angle_y = 47.44656f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama25".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama25() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama25");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            //float panorama_pics_per_screen = 3.33333f / 2.0f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_6.jpg");
+            String output_name = "testPanorama25_output.jpg";
+            String gyro_name = null;
+            // taken with Nokia 8, Camera2 API:
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama26".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama26() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama26");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_6.jpg");
+            String output_name = "testPanorama26_output.jpg";
+            String gyro_name = null;
+            // taken with Nokia 8, Camera2 API:
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama27".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama27() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama27");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_6.jpg");
+            String output_name = "testPanorama27_output.jpg";
+            String gyro_name = null;
+            // taken with Nokia 8, Camera2 API:
+            float camera_angle_x = 66.708595f;
+            float camera_angle_y = 50.282097f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama28".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama28() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama28");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            // right-to-left:
+        /*inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_0.jpg");*/
+            // converted from original JPEGs to PNG using Nokia 8:
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_0.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_1.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_2.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_3.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_4.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_5.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_6.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_7.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_8.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_9.png");
+            String output_name = "testPanorama28_output.jpg";
+            String gyro_name = null;
+            // taken with Samsung Galaxy S10e, Camera2 API, standard rear camera:
+            float camera_angle_x = 66.3177f;
+            float camera_angle_y = 50.04736f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama28", but with a nbnq similar set of
+     *  input images. Instead of converting the original JPEGs to PNG on Nokia 8, this was done on
+     *  the Samsung Galaxy S10e, which gives small differences, but enough to show up potential
+     *  stability issues.
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama28_galaxys10e() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama28_galaxys10e");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            // right-to-left:
+        /*inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_0.jpg");*/
+            // converted from original JPEGs to PNG using Samsung Galaxy S10e:
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_0.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_1.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_2.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_3.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_4.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_5.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_6.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_7.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_8.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_9.png");
+            String output_name = "testPanorama28_galaxys10e_output.jpg";
+            String gyro_name = null;
+            // taken with Samsung Galaxy S10e, Camera2 API, standard rear camera:
+            float camera_angle_x = 66.3177f;
+            float camera_angle_y = 50.04736f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama29".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama29() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama29");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            // right-to-left:
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_9.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_0.jpg");
+            String output_name = "testPanorama29_output.jpg";
+            String gyro_name = null;
+            // taken with Nokia 8, old API:
+            float camera_angle_x = 66.1062f;
+            float camera_angle_y = 49.88347f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama30".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama30() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama30");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+        /*inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_9.jpg");*/
+            // converted from original JPEGs to PNG using Nokia 8:
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_0.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_1.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_2.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_3.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_4.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_5.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_6.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_7.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_8.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_9.png");
+            String output_name = "testPanorama30_output.jpg";
+            String gyro_name = null;
+            // taken with Samsung Galaxy S10e, old API, standard rear camera:
+            // n.b., camera angles are indeed the exact same as with Camera2
+            float camera_angle_x = 66.3177f;
+            float camera_angle_y = 50.04736f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama30", but with a nbnq similar set of
+     *  input images. Instead of converting the original JPEGs to PNG on Nokia 8, this was done on
+     *  the Samsung Galaxy S10e, which gives small differences, but enough to show up potential
+     *  stability issues.
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama30_galaxys10e() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama30_galaxys10e");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+        /*inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_9.jpg");*/
+            // converted from original JPEGs to PNG using Samsung Galaxy S10e:
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_0.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_1.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_2.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_3.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_4.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_5.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_6.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_7.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_8.png");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_9.png");
+            String output_name = "testPanorama30_galaxys10e_output.jpg";
+            String gyro_name = null;
+            // taken with Samsung Galaxy S10e, old API, standard rear camera:
+            // n.b., camera angles are indeed the exact same as with Camera2
+            float camera_angle_x = 66.3177f;
+            float camera_angle_y = 50.04736f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama31".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama31() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama31");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_6.jpg");
+            String output_name = "testPanorama31_output.jpg";
+            String gyro_name = null;
+            // taken with OnePlus 3T, Camera2 API:
+            float camera_angle_x = 62.93796f;
+            float camera_angle_y = 47.44656f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama3".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama32() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama32");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_8.jpg");
+            String output_name = "testPanorama32_output.jpg";
+            String gyro_name = null;
+            // taken with OnePlus 3T, old API:
+            float camera_angle_x = 60.0f;
+            float camera_angle_y = 45.0f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama33".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama33() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama33");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_5.jpg");
+            String output_name = "testPanorama33_output.jpg";
+            String gyro_name = null;
+            // taken with Nokia 8, old API:
+            float camera_angle_x = 66.1062f;
+            float camera_angle_y = 49.88347f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama34".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama34() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama34");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            // right-to-left:
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_9.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_0.jpg");
+            String output_name = "testPanorama34_output.jpg";
+            String gyro_name = null;
+            // taken with Nexus 6, old API:
+            float camera_angle_x = 62.7533f;
+            float camera_angle_y = 47.298824f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama35".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama35() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama35");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_9.jpg");
+            String output_name = "testPanorama35_output.jpg";
+            String gyro_name = null;
+            // taken with Nexus 7, old API:
+            float camera_angle_x = 55.0f;
+            float camera_angle_y = 41.401073f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama36".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama36() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama36");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_7.jpg");
+            String output_name = "testPanorama36_output.jpg";
+            String gyro_name = null;
+            // taken with Samsung Galaxy S10e, Camera2 API, ultra wide rear camera:
+            float camera_angle_x = 104.00253f;
+            float camera_angle_y = 81.008804f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama37".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama37() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama37");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_8.jpg");
+            String output_name = "testPanorama37_output.jpg";
+            String gyro_name = null;
+            // taken with Samsung Galaxy S10e, old API, standard rear camera:
+            // n.b., camera angles are indeed the exact same as with Camera2
+            float camera_angle_x = 66.3177f;
+            float camera_angle_y = 50.04736f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    /** Tests panorama algorithm on test samples "testPanorama38".
+     */
+    @Category(PanoramaTests.class)
+    @Test
+    public void testPanorama38() throws IOException, InterruptedException {
+        Log.d(TAG, "testPanorama38");
+
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> { // for simplicity, run the entire test on the UI thread
+            // list assets
+            List<String> inputs = new ArrayList<>();
+
+            float panorama_pics_per_screen = 3.33333f;
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_0.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_1.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_2.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_3.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_4.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_5.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_6.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_7.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_8.jpg");
+            inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_9.jpg");
+            String output_name = "testPanorama38_output.jpg";
+            String gyro_name = null;
+            // taken with Samsung Galaxy S10e, Camera2 API, standard rear camera:
+            float camera_angle_x = 66.3177f;
+            float camera_angle_y = 50.04736f;
+
+            TestUtils.subTestPanorama(activity, inputs, output_name, gyro_name, panorama_pics_per_screen, camera_angle_x, camera_angle_y, 1.0f);
+        });
+    }
+
+    private void waitForTakePhoto() {
+        Log.d(TAG, "wait until finished taking photo");
+        long time_s = System.currentTimeMillis();
+        while(true) {
+            boolean waiting = getActivityValue(activity -> (activity.getPreview().isTakingPhoto() || !activity.getApplicationInterface().canTakeNewPhoto()));
+            if( !waiting ) {
+                break;
+            }
+            mActivityRule.getScenario().onActivity(activity -> {
+                TestUtils.waitForTakePhotoChecks(activity, time_s);
+            });
+        }
+
+        Log.d(TAG, "done taking photo");
+    }
+
+    private void subTestTouchToFocus(final boolean wait_after_focus, final boolean single_tap_photo, final boolean double_tap_photo, final boolean manual_can_auto_focus, final boolean can_focus_area, final String focus_value, final String focus_value_ui) throws InterruptedException {
+        // touch to auto-focus with focus area (will also exit immersive mode)
+        // autofocus shouldn't be immediately, but after a delay
+        // and Galaxy S10e needs a longer delay for some reason, for the subsequent touch of the preview view to register
+        Thread.sleep(2000);
+        int saved_count = getActivityValue(activity -> activity.getPreview().count_cameraAutoFocus);
+        Log.d(TAG, "saved count_cameraAutoFocus: " + saved_count);
+        Log.d(TAG, "### about to click preview for autofocus");
+
+        onView(anyOf(ViewMatchers.withClassName(endsWith("MySurfaceView")), ViewMatchers.withClassName(endsWith("MyTextureView")))).perform(click());
+
+        Log.d(TAG, "### done click preview for autofocus");
+
+        mActivityRule.getScenario().onActivity(activity -> {
+            TestUtils.touchToFocusChecks(activity, single_tap_photo, double_tap_photo, manual_can_auto_focus, can_focus_area, focus_value, focus_value_ui, saved_count);
+        });
+
+        if( double_tap_photo ) {
+            Thread.sleep(100);
+            Log.d(TAG, "about to click preview again for double tap");
+            //onView(withId(preview_view_id)).perform(ViewActions.doubleClick());
+            mActivityRule.getScenario().onActivity(activity -> {
+                //onView(anyOf(ViewMatchers.withClassName(endsWith("MySurfaceView")), ViewMatchers.withClassName(endsWith("MyTextureView")))).perform(click());
+                activity.getPreview().onDoubleTap(); // calling tapView twice doesn't seem to work consistently, so we call this directly!
+            });
+        }
+        if( wait_after_focus && !single_tap_photo && !double_tap_photo) {
+            // don't wait after single or double tap photo taking, as the photo taking operation is already started
+            Log.d(TAG, "wait after focus...");
+            Thread.sleep(3000);
+        }
+    }
+
+    private void subTestTakePhoto(boolean locked_focus, boolean immersive_mode, boolean touch_to_focus, boolean wait_after_focus, boolean single_tap_photo, boolean double_tap_photo, boolean is_raw, boolean test_wait_capture_result) throws InterruptedException {
+        Thread.sleep(500);
+
+        TestUtils.SubTestTakePhotoInfo info = getActivityValue(activity -> TestUtils.getSubTestTakePhotoInfo(activity, immersive_mode, single_tap_photo, double_tap_photo));
+
+        int saved_count_cameraTakePicture = getActivityValue(activity -> activity.getPreview().count_cameraTakePicture);
+
+        // count initial files in folder
+        String [] files = getActivityValue(activity -> TestUtils.filesInSaveFolder(activity));
+        int n_files = files == null ? 0 : files.length;
+        Log.d(TAG, "n_files at start: " + n_files);
+
+        int saved_count = getActivityValue(activity -> activity.getPreview().count_cameraAutoFocus);
+
+        int saved_thumbnail_count = getActivityValue(activity -> activity.getApplicationInterface().getDrawPreview().test_thumbnail_anim_count);
+        Log.d(TAG, "saved_thumbnail_count: " + saved_thumbnail_count);
+
+        if( touch_to_focus ) {
+            subTestTouchToFocus(wait_after_focus, single_tap_photo, double_tap_photo, info.manual_can_auto_focus, info.can_focus_area, info.focus_value, info.focus_value_ui);
+        }
+        Log.d(TAG, "saved count_cameraAutoFocus: " + saved_count);
+
+        if( !single_tap_photo && !double_tap_photo ) {
+            mActivityRule.getScenario().onActivity(activity -> {
+                View takePhotoButton = activity.findViewById(net.sourceforge.opencamera.R.id.take_photo);
+                assertFalse( activity.hasThumbnailAnimation() );
+                Log.d(TAG, "about to click take photo");
+                clickView(takePhotoButton);
+                Log.d(TAG, "done clicking take photo");
+            });
+        }
+
+        waitForTakePhoto();
+
+        int new_count_cameraTakePicture = getActivityValue(activity -> activity.getPreview().count_cameraTakePicture);
+        Log.d(TAG, "take picture count: " + new_count_cameraTakePicture);
+        assertEquals(new_count_cameraTakePicture, saved_count_cameraTakePicture + 1);
+
+        /*if( test_wait_capture_result ) {
+            // if test_wait_capture_result, then we'll have waited too long for thumbnail animation
+        }
+        else if( info.is_focus_bracketing ) {
+            // thumbnail animation may have already occurred (e.g., see testTakePhotoFocusBracketingHeavy()
+        }
+        else*/ if( info.has_thumbnail_anim ) {
+            long time_s = System.currentTimeMillis();
+            for(;;) {
+                //boolean waiting = getActivityValue(activity -> !activity.hasThumbnailAnimation());
+                boolean waiting = getActivityValue(activity -> (activity.getApplicationInterface().getDrawPreview().test_thumbnail_anim_count <= saved_thumbnail_count));
+                if( !waiting ) {
+                    break;
+                }
+                Log.d(TAG, "waiting for thumbnail animation");
+                Thread.sleep(10);
+                int allowed_time_ms = 10000;
+                if( info.is_hdr || info.is_nr || info.is_expo ) {
+                    // some devices need longer time (especially Nexus 6)
+                    allowed_time_ms = 16000;
+                }
+                assertTrue( System.currentTimeMillis() - time_s < allowed_time_ms );
+            }
+        }
+        else {
+            boolean has_thumbnail_animation = getActivityValue(activity -> activity.hasThumbnailAnimation());
+            assertFalse( has_thumbnail_animation );
+            int new_thumbnail_count = getActivityValue(activity -> activity.getApplicationInterface().getDrawPreview().test_thumbnail_anim_count);
+            assertEquals(saved_thumbnail_count, new_thumbnail_count);
+        }
+
+        mActivityRule.getScenario().onActivity(activity -> {
+            activity.waitUntilImageQueueEmpty();
+
+            TestUtils.checkFocusAfterTakePhoto(activity, info.focus_value, info.focus_value_ui);
+
+            try {
+                TestUtils.checkFilesAfterTakePhoto(activity, is_raw, test_wait_capture_result, files);
+            }
+            catch(InterruptedException e) {
+                e.printStackTrace();
+            }
+
+            TestUtils.checkFocusAfterTakePhoto2(activity, touch_to_focus, single_tap_photo, double_tap_photo, test_wait_capture_result, locked_focus, info.can_auto_focus, info.can_focus_area, saved_count);
+
+            TestUtils.postTakePhotoChecks(activity, immersive_mode, info.exposureVisibility, info.exposureLockVisibility);
+
+            assertFalse(activity.getApplicationInterface().getImageSaver().test_queue_blocked);
+            assertTrue( activity.getPreview().getCameraController() == null || activity.getPreview().getCameraController().count_camera_parameters_exception == 0 );
+        });
+
+    }
+
+    /*@Category(PhotoTests.class)
+    @Test
+    public void testTakePhoto() throws InterruptedException {
+        Log.d(TAG, "testTakePhoto");
+        setToDefault();
+        subTestTakePhoto(false, false, true, true, false, false, false, false);
+    }*/
+
+    /** Tests option to remove device exif info.
+     */
+    @Category(PhotoTests.class)
+    @Test
+    public void testTakePhotoRemoveExifOn() throws InterruptedException {
+        Log.d(TAG, "testTakePhotoRemoveExifOn");
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> {
+            SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(activity);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putString(PreferenceKeys.RemoveDeviceExifPreferenceKey, "preference_remove_device_exif_on");
+            editor.apply();
+            updateForSettings(activity);
+        });
+
+        subTestTakePhoto(false, false, true, true, false, false, false, false);
+
+        mActivityRule.getScenario().onActivity(activity -> {
+            try {
+                TestUtils.testExif(activity, activity.test_last_saved_image, activity.test_last_saved_imageuri, false, false, false);
+            }
+            catch(IOException e) {
+                e.printStackTrace();
+                fail();
+            }
+        });
+    }
+
+    /** Tests option to remove device exif info, but with auto-level to test codepath where we
+     *  resave the bitmap.
+     */
+    @Category(PhotoTests.class)
+    @Test
+    public void testTakePhotoRemoveExifOn2() throws InterruptedException {
+        Log.d(TAG, "testTakePhotoRemoveExifOn2");
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> {
+            SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(activity);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putString(PreferenceKeys.RemoveDeviceExifPreferenceKey, "preference_remove_device_exif_on");
+            editor.putBoolean(PreferenceKeys.AutoStabilisePreferenceKey, true);
+            editor.apply();
+            updateForSettings(activity);
+        });
+
+        subTestTakePhoto(false, false, true, true, false, false, false, false);
+
+        mActivityRule.getScenario().onActivity(activity -> {
+            try {
+                TestUtils.testExif(activity, activity.test_last_saved_image, activity.test_last_saved_imageuri, false, false, false);
+            }
+            catch(IOException e) {
+                e.printStackTrace();
+                fail();
+            }
+        });
+    }
+    /** Tests option to remove device exif info, but keeping datetime tags.
+     */
+    @Category(PhotoTests.class)
+    @Test
+    public void testTakePhotoRemoveExifKeepDatetime() throws InterruptedException {
+        Log.d(TAG, "testTakePhotoRemoveExifKeepDatetime");
+        setToDefault();
+
+        mActivityRule.getScenario().onActivity(activity -> {
+            SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(activity);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putString(PreferenceKeys.RemoveDeviceExifPreferenceKey, "preference_remove_device_exif_keep_datetime");
+            editor.apply();
+            updateForSettings(activity);
+        });
+
+        subTestTakePhoto(false, false, true, true, false, false, false, false);
+
+        mActivityRule.getScenario().onActivity(activity -> {
+            try {
+                TestUtils.testExif(activity, activity.test_last_saved_image, activity.test_last_saved_imageuri, false, true, false);
+            }
+            catch(IOException e) {
+                e.printStackTrace();
+                fail();
+            }
+        });
+    }
+}
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/PanoramaTestSuite.java b/app/src/androidTest/java/net/sourceforge/opencamera/PanoramaTestSuite.java
new file mode 100644
index 0000000000000000000000000000000000000000..84186f7837bb175eef55a970b64162211fffb9a0
--- /dev/null
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/PanoramaTestSuite.java
@@ -0,0 +1,17 @@
+package net.sourceforge.opencamera;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/** Tests for Panorama algorithm - only need to run on a single device
+ *  Should manually look over the images dumped onto DCIM/
+ *  To use these tests, the testdata/ subfolder should be manually copied to the test device in the DCIM/testOpenCamera/
+ *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
+ *  time to transfer to the device every time we run the tests.
+ *  On Android 10+, scoped storage permission needs to be given to Open Camera for the DCIM/testOpenCamera/ folder.
+ */
+@RunWith(Categories.class)
+@Categories.IncludeCategory(PanoramaTests.class)
+@Suite.SuiteClasses({InstrumentedTest.class})
+public class PanoramaTestSuite {}
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/PhotoTestSuite.java b/app/src/androidTest/java/net/sourceforge/opencamera/PhotoTestSuite.java
new file mode 100644
index 0000000000000000000000000000000000000000..05a311294a9ed43fb490d86c570deec47f5ac153
--- /dev/null
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/PhotoTestSuite.java
@@ -0,0 +1,13 @@
+package net.sourceforge.opencamera;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/** Tests related to taking photos; note that tests to do with photo mode that don't take photos are still part of MainTests.
+ */
+
+@RunWith(Categories.class)
+@Categories.IncludeCategory(PhotoTests.class)
+@Suite.SuiteClasses({InstrumentedTest.class})
+public class PhotoTestSuite {}
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/TestUtils.java b/app/src/androidTest/java/net/sourceforge/opencamera/TestUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..92c980f52345bd0bfb1a9bdfb50d92c71e5bb9b1
--- /dev/null
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/TestUtils.java
@@ -0,0 +1,1478 @@
+package net.sourceforge.opencamera;
+
+import static org.junit.Assert.*;
+
+import android.annotation.TargetApi;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.os.ParcelFileDescriptor;
+import android.preference.PreferenceManager;
+import android.provider.DocumentsContract;
+import android.provider.MediaStore;
+import android.renderscript.Allocation;
+import android.util.Log;
+import android.view.View;
+
+import androidx.annotation.RequiresApi;
+import androidx.exifinterface.media.ExifInterface;
+
+import net.sourceforge.opencamera.preview.Preview;
+
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+/** Helper class for testing. This method should not include any code specific to any test framework
+ *  (e.g., shouldn't be specific to ActivityInstrumentationTestCase2).
+ */
+public class TestUtils {
+    private static final String TAG = "TestUtils";
+
+    final private static String images_base_path = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getAbsolutePath();
+    final public static String hdr_images_path = images_base_path + "/testOpenCamera/testdata/hdrsamples/";
+    final public static String avg_images_path = images_base_path + "/testOpenCamera/testdata/avgsamples/";
+    final public static String logprofile_images_path = images_base_path + "/testOpenCamera/testdata/logprofilesamples/";
+    final public static String panorama_images_path = images_base_path + "/testOpenCamera/testdata/panoramasamples/";
+
+    public static void setDefaultIntent(Intent intent) {
+        intent.putExtra("test_project", true);
+    }
+
+    /** Code to call before running each test.
+     */
+    public static void initTest(Context context, boolean test_camera2) {
+        Log.d(TAG, "initTest: " + test_camera2);
+        // initialise test statics (to avoid the persisting between tests in a test suite run!)
+        MainActivity.test_preview_want_no_limits = false;
+        MainActivity.test_preview_want_no_limits_value = false;
+        ImageSaver.test_small_queue_size = false;
+
+        SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(context);
+        SharedPreferences.Editor editor = settings.edit();
+        editor.clear();
+        if( test_camera2 ) {
+            MainActivity.test_force_supports_camera2 = true;
+            //editor.putBoolean(PreferenceKeys.UseCamera2PreferenceKey, true);
+            editor.putString(PreferenceKeys.CameraAPIPreferenceKey, "preference_camera_api_camera2");
+        }
+        editor.apply();
+
+        Log.d(TAG, "initTest: done");
+    }
+
+    public static boolean isEmulator() {
+        return Build.MODEL.contains("Android SDK built for x86");
+    }
+
+    /** Converts a path to a Uri for com.android.providers.media.documents.
+     */
+    private static Uri getDocumentUri(String filename) throws FileNotFoundException {
+        Log.d(TAG, "getDocumentUri: " + filename);
+
+        // convert from File path format to Storage Access Framework form
+        Uri treeUri = Uri.parse("content://com.android.externalstorage.documents/tree/primary%3ADCIM%2FtestOpenCamera");
+        Log.d(TAG, "treeUri: " + treeUri);
+        if( !filename.startsWith(images_base_path) ) {
+            Log.e(TAG, "unknown base for: " + filename);
+            throw new FileNotFoundException();
+        }
+        String stem = filename.substring(images_base_path.length());
+        Uri stemUri = Uri.parse("content://com.android.externalstorage.documents/tree/primary%3ADCIM" + stem.replace("/", "%2F"));
+        Log.d(TAG, "stem: " + stem);
+        Log.d(TAG, "stemUri: " + stemUri);
+        //String docID = "primary:DCIM" + stem;
+        String docID = DocumentsContract.getTreeDocumentId(stemUri);
+        Log.d(TAG, "docID: " + docID);
+        Uri uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, docID);
+
+        if( uri == null ) {
+            throw new FileNotFoundException();
+        }
+        return uri;
+    }
+
+    public static Bitmap getBitmapFromFile(MainActivity activity, String filename) {
+        return getBitmapFromFile(activity, filename, 1);
+    }
+
+    public static Bitmap getBitmapFromFile(MainActivity activity, String filename, int inSampleSize) {
+        try {
+            return getBitmapFromFileCore(activity, filename, inSampleSize);
+        }
+        catch(FileNotFoundException e) {
+            e.printStackTrace();
+            fail("FileNotFoundException loading: " + filename);
+            return null;
+        }
+    }
+
+    /** Loads bitmap from supplied filename.
+     *  Note that on Android 10+ (with scoped storage), this uses Storage Access Framework, which
+     *  means Open Camera must have SAF permission to the folder DCIM/testOpenCamera.
+     */
+    private static Bitmap getBitmapFromFileCore(MainActivity activity, String filename, int inSampleSize) throws FileNotFoundException {
+        Log.d(TAG, "getBitmapFromFileCore: " + filename);
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inMutable = true;
+        //options.inSampleSize = inSampleSize;
+        if( inSampleSize > 1 ) {
+            // use inDensity for better quality, as inSampleSize uses nearest neighbour
+            // see same code in ImageSaver.setBitmapOptionsSampleSize()
+            options.inDensity = inSampleSize;
+            options.inTargetDensity = 1;
+        }
+
+        Uri uri = null;
+        Bitmap bitmap;
+
+        if( MainActivity.useScopedStorage() ) {
+            uri = getDocumentUri(filename);
+            Log.d(TAG, "uri: " + uri);
+            InputStream is = activity.getContentResolver().openInputStream(uri);
+            bitmap = BitmapFactory.decodeStream(is, null, options);
+            try {
+                is.close();
+            }
+            catch(IOException e) {
+                e.printStackTrace();
+            }
+        }
+        else {
+            bitmap = BitmapFactory.decodeFile(filename, options);
+        }
+        if( bitmap == null )
+            throw new FileNotFoundException();
+        Log.d(TAG, "    done: " + bitmap);
+
+        // now need to take exif orientation into account, as some devices or camera apps store the orientation in the exif tag,
+        // which getBitmap() doesn't account for
+        ParcelFileDescriptor parcelFileDescriptor = null;
+        FileDescriptor fileDescriptor;
+        try {
+            ExifInterface exif = null;
+            if( uri != null ) {
+                parcelFileDescriptor = activity.getContentResolver().openFileDescriptor(uri, "r");
+                if( parcelFileDescriptor != null ) {
+                    fileDescriptor = parcelFileDescriptor.getFileDescriptor();
+                    exif = new ExifInterface(fileDescriptor);
+                }
+            }
+            else {
+                exif = new ExifInterface(filename);
+            }
+            if( exif != null ) {
+                int exif_orientation_s = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED);
+                boolean needs_tf = false;
+                int exif_orientation = 0;
+                // from http://jpegclub.org/exif_orientation.html
+                // and http://stackoverflow.com/questions/20478765/how-to-get-the-correct-orientation-of-the-image-selected-from-the-default-image
+                if( exif_orientation_s == ExifInterface.ORIENTATION_UNDEFINED || exif_orientation_s == ExifInterface.ORIENTATION_NORMAL ) {
+                    // leave unchanged
+                }
+                else if( exif_orientation_s == ExifInterface.ORIENTATION_ROTATE_180 ) {
+                    needs_tf = true;
+                    exif_orientation = 180;
+                }
+                else if( exif_orientation_s == ExifInterface.ORIENTATION_ROTATE_90 ) {
+                    needs_tf = true;
+                    exif_orientation = 90;
+                }
+                else if( exif_orientation_s == ExifInterface.ORIENTATION_ROTATE_270 ) {
+                    needs_tf = true;
+                    exif_orientation = 270;
+                }
+                else {
+                    // just leave unchanged for now
+                    Log.e(TAG, "    unsupported exif orientation: " + exif_orientation_s);
+                }
+                Log.d(TAG, "    exif orientation: " + exif_orientation);
+
+                if( needs_tf ) {
+                    Log.d(TAG, "    need to rotate bitmap due to exif orientation tag");
+                    Matrix m = new Matrix();
+                    m.setRotate(exif_orientation, bitmap.getWidth() * 0.5f, bitmap.getHeight() * 0.5f);
+                    Bitmap rotated_bitmap = Bitmap.createBitmap(bitmap, 0, 0,bitmap.getWidth(), bitmap.getHeight(), m, true);
+                    if( rotated_bitmap != bitmap ) {
+                        bitmap.recycle();
+                        bitmap = rotated_bitmap;
+                    }
+                }
+            }
+        }
+        catch(IOException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if( parcelFileDescriptor != null ) {
+                try {
+                    parcelFileDescriptor.close();
+                }
+                catch(IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        /*{
+            for(int y=0;y<bitmap.getHeight();y++) {
+                for(int x=0;x<bitmap.getWidth();x++) {
+                    int color = bitmap.getPixel(x, y);
+                    Log.d(TAG, x + "," + y + ": " + Color.red(color) + "," + Color.green(color) + "," + Color.blue(color));
+                }
+            }
+        }*/
+        return bitmap;
+    }
+
+    /** Returns the mediastore Uri for the supplied filename inside the supplied baseUri, or null
+     *  if an entry can't be found.
+     */
+    private static Uri getUriFromName(MainActivity activity, Uri baseUri, String name) {
+        Uri uri = null;
+        String [] projection = new String[]{MediaStore.Images.ImageColumns._ID};
+        Cursor cursor = null;
+        try {
+            cursor = activity.getContentResolver().query(baseUri, projection, MediaStore.Images.ImageColumns.DISPLAY_NAME + " LIKE ?", new String[]{name}, null);
+            if( cursor != null && cursor.moveToFirst() ) {
+                Log.d(TAG, "found: " + cursor.getCount());
+                long id = cursor.getLong(0);
+                uri = ContentUris.withAppendedId(baseUri, id);
+                Log.d(TAG, "id: " + id);
+                Log.d(TAG, "uri: " + uri);
+            }
+        }
+        catch(Exception e) {
+            Log.e(TAG, "Exception trying to find uri from filename");
+            e.printStackTrace();
+        }
+        finally {
+            if( cursor != null ) {
+                cursor.close();
+            }
+        }
+        return uri;
+    }
+
+    public static void saveBitmap(MainActivity activity, Bitmap bitmap, String name) {
+        try {
+            saveBitmapCore(activity, bitmap, name);
+        }
+        catch(IOException e) {
+            e.printStackTrace();
+            fail("IOException saving: " + name);
+        }
+    }
+
+    private static void saveBitmapCore(MainActivity activity, Bitmap bitmap, String name) throws IOException {
+        Log.d(TAG, "saveBitmapCore: " + name);
+
+        File file = null;
+        ContentValues contentValues = null;
+        Uri uri = null;
+        OutputStream outputStream;
+        if( MainActivity.useScopedStorage() ) {
+            Uri folder = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ?
+                    MediaStore.Images.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY) :
+                    MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+
+            // first try to delete pre-existing image
+            Uri old_uri = getUriFromName(activity, folder, name);
+            if( old_uri != null ) {
+                Log.d(TAG, "delete: " + old_uri);
+                activity.getContentResolver().delete(old_uri, null, null);
+            }
+
+            contentValues = new ContentValues();
+            contentValues.put(MediaStore.Images.Media.DISPLAY_NAME, name);
+            String extension = name.substring(name.lastIndexOf("."));
+            String mime_type = activity.getStorageUtils().getImageMimeType(extension);
+            Log.d(TAG, "mime_type: " + mime_type);
+            contentValues.put(MediaStore.Images.Media.MIME_TYPE, mime_type);
+            if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ) {
+                String relative_path = Environment.DIRECTORY_DCIM + File.separator;
+                Log.d(TAG, "relative_path: " + relative_path);
+                contentValues.put(MediaStore.Images.Media.RELATIVE_PATH, relative_path);
+                contentValues.put(MediaStore.Images.Media.IS_PENDING, 1);
+            }
+
+            uri = activity.getContentResolver().insert(folder, contentValues);
+            Log.d(TAG, "saveUri: " + uri);
+            if( uri == null ) {
+                throw new IOException();
+            }
+            outputStream = activity.getContentResolver().openOutputStream(uri);
+        }
+        else {
+            file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM) + File.separator + name);
+            outputStream = new FileOutputStream(file);
+        }
+
+        bitmap.compress(Bitmap.CompressFormat.JPEG, 90, outputStream);
+        outputStream.close();
+
+        if( MainActivity.useScopedStorage() ) {
+            if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ) {
+                contentValues.clear();
+                contentValues.put(MediaStore.Images.Media.IS_PENDING, 0);
+                activity.getContentResolver().update(uri, contentValues, null, null);
+            }
+        }
+        else {
+            activity.getStorageUtils().broadcastFile(file, true, false, true, false, null);
+        }
+    }
+
+    public static class HistogramDetails {
+        public final int min_value;
+        public final int median_value;
+        public final int max_value;
+
+        HistogramDetails(int min_value, int median_value, int max_value) {
+            this.min_value = min_value;
+            this.median_value = median_value;
+            this.max_value = max_value;
+        }
+    }
+
+    /** Checks for the resultant histogram.
+     *  We check that we have a single range of non-zero values.
+     * @param bitmap The bitmap to compute and check a histogram for.
+     */
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public static HistogramDetails checkHistogram(MainActivity activity, Bitmap bitmap) {
+        int [] histogram = activity.getApplicationInterface().getHDRProcessor().computeHistogram(bitmap, true);
+        assertEquals(256, histogram.length);
+        int total = 0;
+        for(int i=0;i<histogram.length;i++) {
+            Log.d(TAG, "histogram[" + i + "]: " + histogram[i]);
+            total += histogram[i];
+        }
+        Log.d(TAG, "total: " + total);
+        boolean started = false;
+        int min_value = -1, median_value = -1, max_value = -1;
+        int count = 0;
+        int middle = total/2;
+        for(int i=0;i<histogram.length;i++) {
+            int value = histogram[i];
+            if( !started ) {
+                started = value != 0;
+            }
+            if( value != 0 ) {
+                if( min_value == -1 )
+                    min_value = i;
+                max_value = i;
+                count += value;
+                if( count >= middle && median_value == -1 )
+                    median_value = i;
+            }
+        }
+        Log.d(TAG, "min_value: " + min_value);
+        Log.d(TAG, "median_value: " + median_value);
+        Log.d(TAG, "max_value: " + max_value);
+        return new HistogramDetails(min_value, median_value, max_value);
+    }
+
+    public static HistogramDetails subTestHDR(MainActivity activity, List<Bitmap> inputs, String output_name, boolean test_dro, int iso, long exposure_time) {
+        return subTestHDR(activity, inputs, output_name, test_dro, iso, exposure_time, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_REINHARD);
+    }
+
+    /** The testHDRX tests test the HDR algorithm on a given set of input images.
+     *  By testing on a fixed sample, this makes it easier to finetune the HDR algorithm for quality and performance.
+     *  To use these tests, the testdata/ subfolder should be manually copied to the test device in the DCIM/testOpenCamera/
+     *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
+     *  time to transfer to the device everytime we run the tests.
+     * @param iso The ISO of the middle image (for testing Open Camera's "smart" contrast enhancement). If set to -1, then use "always" contrast enhancement.
+     * @param exposure_time The exposure time of the middle image (for testing Open Camera's "smart" contrast enhancement)
+     */
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public static HistogramDetails subTestHDR(MainActivity activity, List<Bitmap> inputs, String output_name, boolean test_dro, int iso, long exposure_time, HDRProcessor.TonemappingAlgorithm tonemapping_algorithm/*, HDRTestCallback test_callback*/) {
+        Log.d(TAG, "subTestHDR");
+
+        if( Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP ) {
+            Log.d(TAG, "renderscript requires Android Lollipop or better");
+            return null;
+        }
+
+        try {
+            Thread.sleep(1000); // wait for camera to open
+        }
+        catch(InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        Bitmap dro_bitmap_in = null;
+        if( test_dro ) {
+            // save copy of input bitmap to also test DRO (since the HDR routine will free the inputs)
+            int mid = (inputs.size()-1)/2;
+            dro_bitmap_in = inputs.get(mid);
+            dro_bitmap_in = dro_bitmap_in.copy(dro_bitmap_in.getConfig(), true);
+        }
+
+        HistogramDetails hdrHistogramDetails = null;
+        if( inputs.size() > 1 ) {
+            String preference_hdr_contrast_enhancement = (iso==-1) ? "preference_hdr_contrast_enhancement_always" : "preference_hdr_contrast_enhancement_smart";
+            float hdr_alpha = ImageSaver.getHDRAlpha(preference_hdr_contrast_enhancement, exposure_time, inputs.size());
+            long time_s = System.currentTimeMillis();
+            try {
+                activity.getApplicationInterface().getHDRProcessor().processHDR(inputs, true, null, true, null, hdr_alpha, 4, true, tonemapping_algorithm, HDRProcessor.DROTonemappingAlgorithm.DROALGORITHM_GAINGAMMA);
+                //test_callback.doHDR(inputs, tonemapping_algorithm, hdr_alpha);
+            }
+            catch(HDRProcessorException e) {
+                e.printStackTrace();
+                throw new RuntimeException();
+            }
+            Log.d(TAG, "HDR time: " + (System.currentTimeMillis() - time_s));
+
+            saveBitmap(activity, inputs.get(0), output_name);
+            hdrHistogramDetails = checkHistogram(activity, inputs.get(0));
+        }
+        inputs.get(0).recycle();
+        inputs.clear();
+
+        if( test_dro ) {
+            inputs.add(dro_bitmap_in);
+            long time_s = System.currentTimeMillis();
+            try {
+                activity.getApplicationInterface().getHDRProcessor().processHDR(inputs, true, null, true, null, 0.5f, 4, true, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_REINHARD, HDRProcessor.DROTonemappingAlgorithm.DROALGORITHM_GAINGAMMA);
+                //test_callback.doHDR(inputs, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_REINHARD, 0.5f);
+            }
+            catch(HDRProcessorException e) {
+                e.printStackTrace();
+                throw new RuntimeException();
+            }
+            Log.d(TAG, "DRO time: " + (System.currentTimeMillis() - time_s));
+
+            saveBitmap(activity, inputs.get(0), "dro" + output_name);
+            checkHistogram(activity, inputs.get(0));
+            inputs.get(0).recycle();
+            inputs.clear();
+        }
+        try {
+            Thread.sleep(500);
+        }
+        catch(InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return hdrHistogramDetails;
+    }
+
+    public static void checkHDROffsets(MainActivity activity, int [] exp_offsets_x, int [] exp_offsets_y) {
+        checkHDROffsets(activity, exp_offsets_x, exp_offsets_y, 1);
+    }
+
+    /** Checks that the HDR offsets used for auto-alignment are as expected.
+     */
+    public static void checkHDROffsets(MainActivity activity, int [] exp_offsets_x, int [] exp_offsets_y, int scale) {
+        int [] offsets_x = activity.getApplicationInterface().getHDRProcessor().offsets_x;
+        int [] offsets_y = activity.getApplicationInterface().getHDRProcessor().offsets_y;
+        for(int i=0;i<offsets_x.length;i++) {
+            Log.d(TAG, "offsets " + i + " ( " + offsets_x[i]*scale + " , " + offsets_y[i]*scale + " ), expected ( " + exp_offsets_x[i] + " , " + exp_offsets_y[i] + " )");
+            // we allow some tolerance as different devices can produce different results (e.g., Nexus 6 vs OnePlus 3T; see testHDR5 on Nexus 6)
+            assertTrue(Math.abs(offsets_x[i]*scale - exp_offsets_x[i]) <= 1);
+            assertTrue(Math.abs(offsets_y[i]*scale - exp_offsets_y[i]) <= 1);
+        }
+    }
+
+    public static void checkHistogramDetails(HistogramDetails hdrHistogramDetails, int exp_min_value, int exp_median_value, int exp_max_value) {
+        Log.d(TAG, "checkHistogramDetails");
+        Log.d(TAG, "compare min value " + hdrHistogramDetails.min_value + " to expected " + exp_min_value);
+        Log.d(TAG, "compare median value " + hdrHistogramDetails.median_value + " to expected " + exp_median_value);
+        Log.d(TAG, "compare max value " + hdrHistogramDetails.max_value + " to expected " + exp_max_value);
+        // we allow some tolerance as different devices can produce different results (e.g., Nexus 6 vs OnePlus 3T; see testHDR18 on Nexus 6 which needs a tolerance of 2)
+        // interestingly it's testHDR18 that also needs a higher tolerance for Nokia 8 vs Galaxy S10e
+        assertTrue(Math.abs(exp_min_value - hdrHistogramDetails.min_value) <= 3);
+        assertTrue(Math.abs(exp_median_value - hdrHistogramDetails.median_value) <= 3);
+        assertTrue(Math.abs(exp_max_value - hdrHistogramDetails.max_value) <= 3);
+    }
+
+    public interface TestAvgCallback {
+        void doneProcessAvg(int index); // called after every call to HDRProcessor.processAvg()
+    }
+
+    /** The following testAvgX tests test the Avg noise reduction algorithm on a given set of input images.
+     *  By testing on a fixed sample, this makes it easier to finetune the algorithm for quality and performance.
+     *  To use these tests, the testdata/ subfolder should be manually copied to the test device in the DCIM/testOpenCamera/
+     *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
+     *  time to transfer to the device everytime we run the tests.
+     */
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public static HistogramDetails subTestAvg(MainActivity activity, List<String> inputs, String output_name, int iso, long exposure_time, float zoom_factor, TestAvgCallback cb) {
+        Log.d(TAG, "subTestAvg");
+
+        if( Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP ) {
+            Log.d(TAG, "renderscript requires Android Lollipop or better");
+            return null;
+        }
+
+        try {
+            Thread.sleep(1000); // wait for camera to open
+        }
+        catch(InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        /*Bitmap nr_bitmap = getBitmapFromFile(activity, inputs.get(0));
+        long time_s = System.currentTimeMillis();
+        try {
+            for(int i=1;i<inputs.size();i++) {
+                Log.d(TAG, "processAvg for image: " + i);
+                Bitmap new_bitmap = getBitmapFromFile(activity, inputs.get(i));
+                float avg_factor = (float)i;
+                activity.getApplicationInterface().getHDRProcessor().processAvg(nr_bitmap, new_bitmap, avg_factor, true);
+                // processAvg recycles new_bitmap
+                if( cb != null ) {
+                    cb.doneProcessAvg(i);
+                }
+                //break; // test
+            }
+            //activity.getApplicationInterface().getHDRProcessor().processAvgMulti(inputs, hdr_strength, 4);
+        }
+        catch(HDRProcessorException e) {
+            e.printStackTrace();
+            throw new RuntimeException();
+        }
+        Log.d(TAG, "Avg time: " + (System.currentTimeMillis() - time_s));
+
+        {
+            activity.getApplicationInterface().getHDRProcessor().avgBrighten(nr_bitmap);
+            Log.d(TAG, "time after brighten: " + (System.currentTimeMillis() - time_s));
+        }*/
+
+        Bitmap nr_bitmap;
+        try {
+            // initialise allocation from first two bitmaps
+            //int inSampleSize = activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize(inputs.size());
+            int inSampleSize = activity.getApplicationInterface().getHDRProcessor().getAvgSampleSize(iso, exposure_time);
+            Bitmap bitmap0 = getBitmapFromFile(activity, inputs.get(0), inSampleSize);
+            Bitmap bitmap1 = getBitmapFromFile(activity, inputs.get(1), inSampleSize);
+            int width = bitmap0.getWidth();
+            int height = bitmap0.getHeight();
+
+            float avg_factor = 1.0f;
+            List<Long> times = new ArrayList<>();
+            long time_s = System.currentTimeMillis();
+            HDRProcessor.AvgData avg_data = activity.getApplicationInterface().getHDRProcessor().processAvg(bitmap0, bitmap1, avg_factor, iso, exposure_time, zoom_factor);
+            Allocation allocation = avg_data.allocation_out;
+            times.add(System.currentTimeMillis() - time_s);
+            // processAvg recycles both bitmaps
+            if( cb != null ) {
+                cb.doneProcessAvg(1);
+            }
+
+            for(int i=2;i<inputs.size();i++) {
+                Log.d(TAG, "processAvg for image: " + i);
+
+                Bitmap new_bitmap = getBitmapFromFile(activity, inputs.get(i), inSampleSize);
+                avg_factor = (float)i;
+                time_s = System.currentTimeMillis();
+                activity.getApplicationInterface().getHDRProcessor().updateAvg(avg_data, width, height, new_bitmap, avg_factor, iso, exposure_time, zoom_factor);
+                times.add(System.currentTimeMillis() - time_s);
+                // updateAvg recycles new_bitmap
+                if( cb != null ) {
+                    cb.doneProcessAvg(i);
+                }
+            }
+
+            time_s = System.currentTimeMillis();
+            nr_bitmap = activity.getApplicationInterface().getHDRProcessor().avgBrighten(allocation, width, height, iso, exposure_time);
+            avg_data.destroy();
+            //noinspection UnusedAssignment
+            avg_data = null;
+            times.add(System.currentTimeMillis() - time_s);
+
+            long total_time = 0;
+            Log.d(TAG, "*** times are:");
+            for(long time : times) {
+                total_time += time;
+                Log.d(TAG, "    " + time);
+            }
+            Log.d(TAG, "    total: " + total_time);
+        }
+        catch(HDRProcessorException e) {
+            e.printStackTrace();
+            throw new RuntimeException();
+        }
+
+        saveBitmap(activity, nr_bitmap, output_name);
+        HistogramDetails hdrHistogramDetails = checkHistogram(activity, nr_bitmap);
+        nr_bitmap.recycle();
+        System.gc();
+        inputs.clear();
+
+        try {
+            Thread.sleep(500);
+        }
+        catch(InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return hdrHistogramDetails;
+    }
+
+    /**
+     * @param panorama_pics_per_screen The value of panorama_pics_per_screen used when taking the input photos.
+     * @param camera_angle_x The value of preview.getViewAngleX(for_preview=false) (in degrees) when taking the input photos (on the device used).
+     * @param camera_angle_y The value of preview.getViewAngleY(for_preview=false) (in degrees) when taking the input photos (on the device used).
+     */
+    public static void subTestPanorama(MainActivity activity, List<String> inputs, String output_name, String gyro_debug_info_filename, float panorama_pics_per_screen, float camera_angle_x, float camera_angle_y, float gyro_tol_degrees) {
+        Log.d(TAG, "subTestPanorama");
+
+        // we set panorama_pics_per_screen in the test rather than using MyApplicationInterface.panorama_pics_per_screen,
+        // in case the latter value is changed
+
+        boolean first = true;
+        Matrix scale_matrix = null;
+        int bitmap_width = 0;
+        int bitmap_height = 0;
+        List<Bitmap> bitmaps = new ArrayList<>();
+        for(String input : inputs) {
+            Bitmap bitmap = getBitmapFromFile(activity, input);
+
+            if( first ) {
+                bitmap_width = bitmap.getWidth();
+                bitmap_height = bitmap.getHeight();
+                Log.d(TAG, "bitmap_width: " + bitmap_width);
+                Log.d(TAG, "bitmap_height: " + bitmap_height);
+
+                final int max_height = 2080;
+                //final int max_height = 2079; // test non power of 2
+                if( bitmap_height > max_height ) {
+                    float scale = ((float)max_height) / ((float)bitmap_height);
+                    Log.d(TAG, "scale: " + scale);
+                    scale_matrix = new Matrix();
+                    scale_matrix.postScale(scale, scale);
+                }
+
+                first = false;
+            }
+
+            // downscale
+            if( scale_matrix != null ) {
+                Bitmap new_bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap_width, bitmap_height, scale_matrix, true);
+                bitmap.recycle();
+                bitmap = new_bitmap;
+            }
+
+            bitmaps.add(bitmap);
+        }
+
+        bitmap_width = bitmaps.get(0).getWidth();
+        bitmap_height = bitmaps.get(0).getHeight();
+        Log.d(TAG, "bitmap_width is now: " + bitmap_width);
+        Log.d(TAG, "bitmap_height is now: " + bitmap_height);
+
+
+        /*ImageSaver.GyroDebugInfo gyro_debug_info = null;
+        if( gyro_debug_info_filename != null ) {
+            InputStream inputStream;
+            try {
+                inputStream = new FileInputStream(gyro_debug_info_filename);
+            }
+            catch(FileNotFoundException e) {
+                Log.e(TAG, "failed to load gyro debug info file: " + gyro_debug_info_filename);
+                e.printStackTrace();
+                throw new RuntimeException();
+            }
+
+            gyro_debug_info = new ImageSaver.GyroDebugInfo();
+            if( !ImageSaver.readGyroDebugXml(inputStream, gyro_debug_info) ) {
+                Log.e(TAG, "failed to read gyro debug xml");
+                throw new RuntimeException();
+            }
+            else if( gyro_debug_info.image_info.size() != bitmaps.size() ) {
+                Log.e(TAG, "gyro debug xml has unexpected number of images: " + gyro_debug_info.image_info.size());
+                throw new RuntimeException();
+            }
+        }*/
+        //bitmaps.subList(2,bitmaps.size()).clear(); // test
+
+        Bitmap panorama = null;
+        try {
+            final boolean crop = true;
+            //final boolean crop = false; // test
+            panorama = activity.getApplicationInterface().getPanoramaProcessor().panorama(bitmaps, panorama_pics_per_screen, camera_angle_y, crop);
+        }
+        catch(PanoramaProcessorException e) {
+            e.printStackTrace();
+            fail();
+        }
+
+        saveBitmap(activity, panorama, output_name);
+        try {
+            Thread.sleep(500);
+        }
+        catch(InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        // check we've cropped correctly:
+        final float black_factor = 0.9f;
+        // top:
+        int n_black = 0;
+        for(int i=0;i<panorama.getWidth();i++) {
+            int color = panorama.getPixel(i, 0);
+            if( ((color >> 16) & 0xff) == 0 && ((color >> 8) & 0xff) == 0 && ((color) & 0xff) == 0 ) {
+                n_black++;
+            }
+        }
+        if( n_black >= panorama.getWidth()*black_factor ) {
+            Log.e(TAG, "too many black pixels on top border: " + n_black);
+            fail();
+        }
+        // bottom:
+        n_black = 0;
+        for(int i=0;i<panorama.getWidth();i++) {
+            int color = panorama.getPixel(i, panorama.getHeight()-1);
+            if( ((color >> 16) & 0xff) == 0 && ((color >> 8) & 0xff) == 0 && ((color) & 0xff) == 0 ) {
+                n_black++;
+            }
+        }
+        if( n_black >= panorama.getWidth()*black_factor ) {
+            Log.e(TAG, "too many black pixels on bottom border: " + n_black);
+            fail();
+        }
+        // left:
+        n_black = 0;
+        for(int i=0;i<panorama.getHeight();i++) {
+            int color = panorama.getPixel(0, i);
+            if( ((color >> 16) & 0xff) == 0 && ((color >> 8) & 0xff) == 0 && ((color) & 0xff) == 0 ) {
+                n_black++;
+            }
+        }
+        if( n_black >= panorama.getHeight()*black_factor ) {
+            Log.e(TAG, "too many black pixels on left border: " + n_black);
+            fail();
+        }
+        // right:
+        n_black = 0;
+        for(int i=0;i<panorama.getHeight();i++) {
+            int color = panorama.getPixel(panorama.getWidth()-1, i);
+            if( ((color >> 16) & 0xff) == 0 && ((color >> 8) & 0xff) == 0 && ((color) & 0xff) == 0 ) {
+                n_black++;
+            }
+        }
+        if( n_black >= panorama.getHeight()*black_factor ) {
+            Log.e(TAG, "too many black pixels on right border: " + n_black);
+            fail();
+        }
+    }
+
+    public static void waitForTakePhotoChecks(MainActivity activity, long time_s) {
+        Preview preview = activity.getPreview();
+        View switchCameraButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_camera);
+        View switchMultiCameraButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_multi_camera);
+        View switchVideoButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_video);
+        //View flashButton = activity.findViewById(net.sourceforge.opencamera.R.id.flash);
+        //View focusButton = activity.findViewById(net.sourceforge.opencamera.R.id.focus_mode);
+        View exposureButton = activity.findViewById(net.sourceforge.opencamera.R.id.exposure);
+        View exposureLockButton = activity.findViewById(net.sourceforge.opencamera.R.id.exposure_lock);
+        View audioControlButton = activity.findViewById(net.sourceforge.opencamera.R.id.audio_control);
+        View popupButton = activity.findViewById(net.sourceforge.opencamera.R.id.popup);
+        View trashButton = activity.findViewById(net.sourceforge.opencamera.R.id.trash);
+        View shareButton = activity.findViewById(net.sourceforge.opencamera.R.id.share);
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity);
+        boolean is_focus_bracketing = activity.supportsFocusBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_focus_bracketing");
+        boolean is_panorama = activity.supportsPanorama() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_panorama");
+
+        // make sure the test fails rather than hanging, if for some reason we get stuck (note that testTakePhotoManualISOExposure takes over 10s on Nexus 6)
+        // also see note at end of setToDefault for Nokia 8, need to sleep briefly to avoid hanging here
+        if( !is_focus_bracketing ) {
+            assertTrue(System.currentTimeMillis() - time_s < (is_panorama ? 50000 : 20000)); // need longer for panorama on Nexus 7 for testTakePhotoPanoramaMax
+        }
+        assertTrue(!preview.isTakingPhoto() || switchCameraButton.getVisibility() == View.GONE);
+        assertTrue(!preview.isTakingPhoto() || switchMultiCameraButton.getVisibility() == View.GONE);
+        assertTrue(!preview.isTakingPhoto() || switchVideoButton.getVisibility() == View.GONE);
+        //assertTrue(!preview.isTakingPhoto() || flashButton.getVisibility() == View.GONE);
+        //assertTrue(!preview.isTakingPhoto() || focusButton.getVisibility() == View.GONE);
+        assertTrue(!preview.isTakingPhoto() || exposureButton.getVisibility() == View.GONE);
+        assertTrue(!preview.isTakingPhoto() || exposureLockButton.getVisibility() == View.GONE);
+        assertTrue(!preview.isTakingPhoto() || audioControlButton.getVisibility() == View.GONE);
+        assertTrue(!preview.isTakingPhoto() || popupButton.getVisibility() == View.GONE);
+        assertTrue(!preview.isTakingPhoto() || trashButton.getVisibility() == View.GONE);
+        assertTrue(!preview.isTakingPhoto() || shareButton.getVisibility() == View.GONE);
+    }
+
+    private static void checkFocusInitial(MainActivity activity, final String focus_value, final String focus_value_ui) {
+        String new_focus_value_ui = activity.getPreview().getCurrentFocusValue();
+        //noinspection StringEquality
+        assertTrue(new_focus_value_ui == focus_value_ui || new_focus_value_ui.equals(focus_value_ui)); // also need to do == check, as strings may be null if focus not supported
+        assertEquals(activity.getPreview().getCameraController().getFocusValue(), focus_value);
+    }
+
+    public static void checkFocusAfterTakePhoto(MainActivity activity, final String focus_value, final String focus_value_ui) {
+        // focus should be back to normal now:
+        String new_focus_value_ui = activity.getPreview().getCurrentFocusValue();
+        Log.d(TAG, "focus_value_ui: " + focus_value_ui);
+        Log.d(TAG, "new new_focus_value_ui: " + new_focus_value_ui);
+        //noinspection StringEquality
+        assertTrue(new_focus_value_ui == focus_value_ui || new_focus_value_ui.equals(focus_value_ui)); // also need to do == check, as strings may be null if focus not supported
+        String new_focus_value = activity.getPreview().getCameraController().getFocusValue();
+        Log.d(TAG, "focus_value: " + focus_value);
+        Log.d(TAG, "new focus_value: " + new_focus_value);
+        if( new_focus_value_ui != null && new_focus_value_ui.equals("focus_mode_continuous_picture") && focus_value.equals("focus_mode_auto") && new_focus_value.equals("focus_mode_continuous_picture") ) {
+            // this is fine, it just means we were temporarily in touch-to-focus mode
+        }
+        else {
+            assertEquals(new_focus_value, focus_value);
+        }
+    }
+
+    public static void checkFocusAfterTakePhoto2(MainActivity activity, final boolean touch_to_focus, final boolean single_tap_photo, final boolean double_tap_photo, final boolean test_wait_capture_result, final boolean locked_focus, final boolean can_auto_focus, final boolean can_focus_area, final int saved_count) {
+        Preview preview = activity.getPreview();
+        // in locked focus mode, taking photo should never redo an auto-focus
+        // if photo mode, we may do a refocus if the previous auto-focus failed, but not if it succeeded
+        Log.d(TAG, "2 count_cameraAutoFocus: " + preview.count_cameraAutoFocus);
+        if( locked_focus ) {
+            assertEquals(preview.count_cameraAutoFocus, (can_auto_focus ? saved_count + 1 : saved_count));
+        }
+        if( test_wait_capture_result ) {
+            // if test_wait_capture_result, then we'll have waited too long, so focus settings may have changed
+        }
+        else if( touch_to_focus ) {
+            Log.d(TAG, "can_focus_area?: " + can_focus_area);
+            Log.d(TAG, "hasFocusArea?: " + preview.hasFocusArea());
+            if( single_tap_photo || double_tap_photo ) {
+                assertFalse(preview.hasFocusArea());
+                assertNull(preview.getCameraController().getFocusAreas());
+                assertNull(preview.getCameraController().getMeteringAreas());
+            }
+            else if( can_focus_area ) {
+                assertTrue(preview.hasFocusArea());
+                assertNotNull(preview.getCameraController().getFocusAreas());
+                assertEquals(1, preview.getCameraController().getFocusAreas().size());
+                assertNotNull(preview.getCameraController().getMeteringAreas());
+                assertEquals(1, preview.getCameraController().getMeteringAreas().size());
+            }
+            else {
+                assertFalse(preview.hasFocusArea());
+                assertNull(preview.getCameraController().getFocusAreas());
+
+                if( preview.getCameraController().supportsMetering() ) {
+                    // we still set metering areas
+                    assertNotNull(preview.getCameraController().getMeteringAreas());
+                    assertEquals(1, preview.getCameraController().getMeteringAreas().size());
+                }
+                else {
+                    assertNull(preview.getCameraController().getMeteringAreas());
+                }
+            }
+        }
+        else {
+            assertFalse(preview.hasFocusArea());
+            assertNull(preview.getCameraController().getFocusAreas());
+            assertNull(preview.getCameraController().getMeteringAreas());
+        }
+    }
+
+    private static int getExpNNewFiles(MainActivity activity, final boolean is_raw) {
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity);
+        boolean hdr_save_expo =  sharedPreferences.getBoolean(PreferenceKeys.HDRSaveExpoPreferenceKey, false);
+        boolean is_hdr = activity.supportsHDR() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_hdr");
+        boolean is_expo = activity.supportsExpoBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_expo_bracketing");
+        boolean is_focus_bracketing = activity.supportsFocusBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_focus_bracketing");
+        boolean is_fast_burst = activity.supportsFastBurst() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_fast_burst");
+        String n_expo_images_s = sharedPreferences.getString(PreferenceKeys.ExpoBracketingNImagesPreferenceKey, "3");
+        int n_expo_images = Integer.parseInt(n_expo_images_s);
+        String n_focus_bracketing_images_s = sharedPreferences.getString(PreferenceKeys.FocusBracketingNImagesPreferenceKey, "3");
+        int n_focus_bracketing_images = Integer.parseInt(n_focus_bracketing_images_s);
+        String n_fast_burst_images_s = sharedPreferences.getString(PreferenceKeys.FastBurstNImagesPreferenceKey, "5");
+        int n_fast_burst_images = Integer.parseInt(n_fast_burst_images_s);
+
+        int exp_n_new_files;
+        if( is_hdr && hdr_save_expo ) {
+            exp_n_new_files = 4;
+            if( is_raw && !activity.getApplicationInterface().isRawOnly() ) {
+                exp_n_new_files += 3;
+            }
+        }
+        else if( is_expo ) {
+            exp_n_new_files = n_expo_images;
+            if( is_raw && !activity.getApplicationInterface().isRawOnly() ) {
+                exp_n_new_files *= 2;
+            }
+        }
+        else if( is_focus_bracketing ) {
+            exp_n_new_files = n_focus_bracketing_images;
+            if( is_raw && !activity.getApplicationInterface().isRawOnly() ) {
+                exp_n_new_files *= 2;
+            }
+        }
+        else if( is_fast_burst )
+            exp_n_new_files = n_fast_burst_images;
+        else {
+            exp_n_new_files = 1;
+            if( is_raw && !activity.getApplicationInterface().isRawOnly() ) {
+                exp_n_new_files *= 2;
+            }
+        }
+        Log.d(TAG, "exp_n_new_files: " + exp_n_new_files);
+        return exp_n_new_files;
+    }
+
+    private static void checkFilenames(MainActivity activity, final boolean is_raw, final String [] files, final String [] files2) {
+        Log.d(TAG, "checkFilenames");
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity);
+        boolean hdr_save_expo =  sharedPreferences.getBoolean(PreferenceKeys.HDRSaveExpoPreferenceKey, false);
+        boolean is_hdr = activity.supportsHDR() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_hdr");
+        boolean is_fast_burst = activity.supportsFastBurst() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_fast_burst");
+        boolean is_expo = activity.supportsExpoBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_expo_bracketing");
+        boolean is_focus_bracketing = activity.supportsFocusBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_focus_bracketing");
+
+        // check files have names as expected
+        String filename_jpeg = null;
+        String filename_dng = null;
+        int n_files = files == null ? 0 : files.length;
+        for(String file : files2) {
+            Log.d(TAG, "check file: " + file);
+            boolean is_new = true;
+            for(int j=0;j<n_files && is_new;j++) {
+                if( file.equals( files[j] ) ) {
+                    is_new = false;
+                    break;
+                }
+            }
+            if( is_new ) {
+                Log.d(TAG, "file is new");
+                //String filename = file.getName();
+                //noinspection UnnecessaryLocalVariable
+                String filename = file;
+                assertTrue(filename.startsWith("IMG_"));
+                if( filename.endsWith(".jpg") ) {
+                    assertTrue(hdr_save_expo || is_expo || is_focus_bracketing || is_fast_burst || filename_jpeg == null);
+                    if( is_hdr && hdr_save_expo ) {
+                        // only look for the "_HDR" image
+                        if( filename.contains("_HDR") )
+                            filename_jpeg = filename;
+                    }
+                    else if( is_expo || is_focus_bracketing ) {
+                        if( filename_jpeg != null ) {
+                            // check same root
+                            int last_underscore_jpeg = filename_jpeg.lastIndexOf('_');
+                            assertTrue(last_underscore_jpeg != -1);
+                            String filename_base_jpeg = filename_jpeg.substring(0, last_underscore_jpeg+1);
+
+                            int last_underscore = filename.lastIndexOf('_');
+                            assertTrue(last_underscore != -1);
+                            String filename_base = filename.substring(0, last_underscore+1);
+                            Log.d(TAG, "filename_base: " + filename_base);
+
+                            assertEquals(filename_base_jpeg, filename_base);
+                        }
+                        filename_jpeg = filename; // store the last name, to match activity.test_last_saved_image
+                    }
+                    else {
+                        filename_jpeg = filename;
+                    }
+                }
+                else if( filename.endsWith(".dng") ) {
+                    assertTrue(is_raw);
+                    assertTrue(hdr_save_expo || is_expo || is_focus_bracketing || filename_dng == null);
+                    filename_dng = filename;
+                }
+                else {
+                    fail();
+                }
+            }
+        }
+        assertEquals((filename_jpeg == null), (is_raw && activity.getApplicationInterface().isRawOnly() && !is_hdr));
+        assertEquals((filename_dng != null), is_raw);
+        if( is_raw && !activity.getApplicationInterface().isRawOnly() ) {
+            // check we have same filenames (ignoring extensions)
+            // if HDR, then we should exclude the "_HDR" vs "_x" of the base filenames
+            // if expo, then exclude the "_x" as values may be different due to different order of JPEG vs DNG files in the files2 array (at least on Galaxy S10e)
+            String filename_base_jpeg;
+            String filename_base_dng;
+            if( is_hdr ) {
+                filename_base_jpeg = filename_jpeg.substring(0, filename_jpeg.length()-7);
+                filename_base_dng = filename_dng.substring(0, filename_dng.length()-5);
+            }
+            else if( is_expo ) {
+                filename_base_jpeg = filename_jpeg.substring(0, filename_jpeg.length()-5);
+                filename_base_dng = filename_dng.substring(0, filename_dng.length()-5);
+            }
+            else {
+                filename_base_jpeg = filename_jpeg.substring(0, filename_jpeg.length()-4);
+                filename_base_dng = filename_dng.substring(0, filename_dng.length()-4);
+            }
+            Log.d(TAG, "filename_base_jpeg: " + filename_base_jpeg);
+            Log.d(TAG, "filename_base_dng: " + filename_base_dng);
+            assertEquals(filename_base_jpeg, filename_base_dng);
+        }
+    }
+
+    private enum UriType {
+        MEDIASTORE_IMAGES,
+        MEDIASTORE_VIDEOS,
+        STORAGE_ACCESS_FRAMEWORK
+    }
+
+    /** Returns an array of filenames (not including full path) of images or videos in the current
+     *  save folder, by querying the media store; or by using storage access framework on the
+     *  supplied uri.
+     */
+    private static List<String> mediaFilesinSaveFolder(MainActivity activity, Uri baseUri, String bucket_id, UriType uri_type) {
+        List<String> files = new ArrayList<>();
+        final int column_name_c = 0; // filename (without path), including extension
+
+        String [] projection;
+        switch( uri_type ) {
+            case MEDIASTORE_IMAGES:
+                projection = new String[] {MediaStore.Images.ImageColumns.DISPLAY_NAME};
+                break;
+            case MEDIASTORE_VIDEOS:
+                projection = new String[] {MediaStore.Video.VideoColumns.DISPLAY_NAME};
+                break;
+            case STORAGE_ACCESS_FRAMEWORK:
+                projection = new String[] {DocumentsContract.Document.COLUMN_DISPLAY_NAME};
+                break;
+            default:
+                throw new RuntimeException("unknown uri_type: " + uri_type);
+        }
+
+        String selection = "";
+        switch( uri_type ) {
+            case MEDIASTORE_IMAGES:
+                selection = MediaStore.Images.ImageColumns.BUCKET_ID + " = " + bucket_id;
+                break;
+            case MEDIASTORE_VIDEOS:
+                selection = MediaStore.Video.VideoColumns.BUCKET_ID + " = " + bucket_id;
+                break;
+            case STORAGE_ACCESS_FRAMEWORK:
+                break;
+            default:
+                throw new RuntimeException("unknown uri_type: " + uri_type);
+        }
+        Log.d(TAG, "selection: " + selection);
+
+        Cursor cursor = activity.getContentResolver().query(baseUri, projection, selection, null, null);
+        if( cursor != null && cursor.moveToFirst() ) {
+            Log.d(TAG, "found: " + cursor.getCount());
+
+            do {
+                String name = cursor.getString(column_name_c);
+                files.add(name);
+            }
+            while( cursor.moveToNext() );
+        }
+
+        if( cursor != null ) {
+            cursor.close();
+        }
+
+        return files;
+    }
+
+    /** Returns an array of filenames (not including full path) in the current save folder.
+     */
+    public static String [] filesInSaveFolder(MainActivity activity) {
+        Log.d(TAG, "filesInSaveFolder");
+        if( MainActivity.useScopedStorage() ) {
+            List<String> files = new ArrayList<>();
+            if( activity.getStorageUtils().isUsingSAF() ) {
+                // See documentation for StorageUtils.getLatestMediaSAF() - for some reason with scoped storage when not having READ_EXTERNAL_STORAGE,
+                // we can't query the mediastore for files saved via SAF!
+                Uri treeUri = activity.getStorageUtils().getTreeUriSAF();
+                Uri baseUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, DocumentsContract.getTreeDocumentId(treeUri));
+                files.addAll( mediaFilesinSaveFolder(activity, baseUri, null, UriType.STORAGE_ACCESS_FRAMEWORK) );
+            }
+            else {
+                String save_folder = activity.getStorageUtils().getImageFolderPath();
+                String bucket_id = String.valueOf(save_folder.toLowerCase().hashCode());
+                files.addAll( mediaFilesinSaveFolder(activity, MediaStore.Images.Media.EXTERNAL_CONTENT_URI, bucket_id, UriType.MEDIASTORE_IMAGES) );
+                files.addAll( mediaFilesinSaveFolder(activity, MediaStore.Video.Media.EXTERNAL_CONTENT_URI, bucket_id, UriType.MEDIASTORE_VIDEOS) );
+            }
+
+            if( files.size() == 0 ) {
+                return null;
+            }
+            else {
+                return files.toArray(new String[0]);
+            }
+        }
+        else {
+            File folder = activity.getImageFolder();
+            File [] files = folder.listFiles();
+            if( files == null )
+                return null;
+            String [] filenames = new String[files.length];
+            for(int i=0;i<files.length;i++) {
+                filenames[i] = files[i].getName();
+            }
+            return filenames;
+        }
+    }
+
+    public static void checkFilesAfterTakePhoto(MainActivity activity, final boolean is_raw, final boolean test_wait_capture_result, final String [] files) throws InterruptedException {
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity);
+        boolean is_dro = activity.supportsDRO() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_dro");
+        boolean is_hdr = activity.supportsHDR() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_hdr");
+        boolean is_nr = activity.supportsNoiseReduction() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_noise_reduction");
+        boolean is_expo = activity.supportsExpoBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_expo_bracketing");
+        boolean is_focus_bracketing = activity.supportsFocusBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_focus_bracketing");
+        boolean is_fast_burst = activity.supportsFastBurst() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_fast_burst");
+        String n_expo_images_s = sharedPreferences.getString(PreferenceKeys.ExpoBracketingNImagesPreferenceKey, "3");
+        int n_expo_images = Integer.parseInt(n_expo_images_s);
+        String n_focus_bracketing_images_s = sharedPreferences.getString(PreferenceKeys.FocusBracketingNImagesPreferenceKey, "3");
+        int n_focus_bracketing_images = Integer.parseInt(n_focus_bracketing_images_s);
+        String n_fast_burst_images_s = sharedPreferences.getString(PreferenceKeys.FastBurstNImagesPreferenceKey, "5");
+        int n_fast_burst_images = Integer.parseInt(n_fast_burst_images_s);
+
+        Date date = new Date();
+        String suffix = "";
+        int max_time_s = 3;
+        if( is_dro ) {
+            suffix = "_DRO";
+        }
+        else if( is_hdr ) {
+            suffix = "_HDR";
+        }
+        else if( is_nr ) {
+            suffix = "_NR";
+            if( activity.getApplicationInterface().getNRModePref() == MyApplicationInterface.NRModePref.NRMODE_LOW_LIGHT )
+                max_time_s += 6; // takes longer to save low light photo
+            else
+                max_time_s += 5;
+        }
+        else if( is_expo ) {
+            suffix = "_" + (n_expo_images-1);
+        }
+        else if( is_focus_bracketing ) {
+            suffix = "_" + (n_focus_bracketing_images-1); // when focus bracketing starts from _0
+            //suffix = "_" + (n_focus_bracketing_images); // when focus bracketing starts from _1
+            max_time_s = 60; // can take much longer to save in focus bracketing mode!
+        }
+        else if( is_fast_burst ) {
+            suffix = "_" + (n_fast_burst_images-1); // when burst numbering starts from _0
+            //suffix = "_" + (n_fast_burst_images); // when burst numbering starts from _1
+            max_time_s = 4; // takes longer to save 20 images!
+        }
+
+        if( is_raw ) {
+            max_time_s += 6; // extra time needed for Nexus 6 at least
+        }
+
+        boolean pause_preview = sharedPreferences.getBoolean(PreferenceKeys.PausePreviewPreferenceKey, false);
+        if( pause_preview ) {
+            max_time_s += 3; // need to allow longer for testTakePhotoRawWaitCaptureResult with Nexus 6 at least
+        }
+
+        int n_files = files == null ? 0 : files.length;
+        String [] files2 = filesInSaveFolder(activity);
+        int n_new_files = (files2 == null ? 0 : files2.length) - n_files;
+        Log.d(TAG, "n_new_files: " + n_new_files);
+        int exp_n_new_files = getExpNNewFiles(activity, is_raw);
+        assertEquals(n_new_files, exp_n_new_files);
+        checkFilenames(activity, is_raw, files, files2);
+        Thread.sleep(1500); // wait until we've scanned
+        if( test_wait_capture_result ) {
+            // if test_wait_capture_result, then it may take longer before we've scanned
+        }
+        else {
+            Log.d(TAG, "failed to scan: " + activity.getStorageUtils().failed_to_scan);
+            assertFalse(activity.getStorageUtils().failed_to_scan);
+        }
+
+        if( !activity.getApplicationInterface().isRawOnly() ) {
+            String saved_image_filename;
+            if( MainActivity.useScopedStorage() || activity.getStorageUtils().isUsingSAF() ) {
+                /*assertNotNull(activity.test_last_saved_imagename);
+                saved_image_filename = activity.test_last_saved_imagename;*/
+                assertNotNull(activity.test_last_saved_imageuri);
+                saved_image_filename = activity.getStorageUtils().getFileName(activity.test_last_saved_imageuri);
+            }
+            else {
+                assertNotNull(activity.test_last_saved_image);
+                File saved_image_file = new File(activity.test_last_saved_image);
+                saved_image_filename = saved_image_file.getName();
+            }
+            Log.d(TAG, "saved name: " + saved_image_filename);
+            /*Log.d(TAG, "expected name: " + expected_filename);
+            Log.d(TAG, "expected name1: " + expected_filename1);
+            assertTrue(expected_filename.equals(saved_image_file.getName()) || expected_filename1.equals(saved_image_file.getName()));*/
+            // allow for possibility that the time has passed since taking the photo
+            boolean matched = false;
+            for(int i=0;i<=max_time_s && !matched;i++) {
+                Date test_date = new Date(date.getTime() - 1000L *i);
+                String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(test_date);
+                String expected_filename = "IMG_" + timeStamp + suffix + ".jpg";
+                Log.d(TAG, "expected name: " + expected_filename);
+                if( expected_filename.equals(saved_image_filename) )
+                    matched = true;
+            }
+            assertTrue(matched);
+        }
+    }
+
+    public static void postTakePhotoChecks(MainActivity activity, final boolean immersive_mode, final int exposureVisibility, final int exposureLockVisibility) {
+        Preview preview = activity.getPreview();
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity);
+        boolean has_audio_control_button = !sharedPreferences.getString(PreferenceKeys.AudioControlPreferenceKey, "none").equals("none");
+
+        View switchCameraButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_camera);
+        View switchMultiCameraButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_multi_camera);
+        View switchVideoButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_video);
+        View exposureButton = activity.findViewById(net.sourceforge.opencamera.R.id.exposure);
+        View exposureLockButton = activity.findViewById(net.sourceforge.opencamera.R.id.exposure_lock);
+        View audioControlButton = activity.findViewById(net.sourceforge.opencamera.R.id.audio_control);
+        View popupButton = activity.findViewById(net.sourceforge.opencamera.R.id.popup);
+        View trashButton = activity.findViewById(net.sourceforge.opencamera.R.id.trash);
+        View shareButton = activity.findViewById(net.sourceforge.opencamera.R.id.share);
+
+        // trash/share only shown when preview is paused after taking a photo
+        boolean pause_preview =  sharedPreferences.getBoolean(PreferenceKeys.PausePreviewPreferenceKey, false);
+        if( pause_preview ) {
+            assertFalse(preview.isPreviewStarted());
+            assertEquals(switchCameraButton.getVisibility(), View.GONE);
+            assertEquals(switchMultiCameraButton.getVisibility(), View.GONE);
+            assertEquals(switchVideoButton.getVisibility(), View.GONE);
+            assertEquals(exposureButton.getVisibility(), View.GONE);
+            assertEquals(exposureLockButton.getVisibility(), View.GONE);
+            assertEquals(audioControlButton.getVisibility(), View.GONE);
+            assertEquals(popupButton.getVisibility(), View.GONE);
+            assertEquals(trashButton.getVisibility(), View.VISIBLE);
+            assertEquals(shareButton.getVisibility(), View.VISIBLE);
+        }
+        else {
+            assertTrue(preview.isPreviewStarted()); // check preview restarted
+            assertEquals(switchCameraButton.getVisibility(), (preview.getCameraControllerManager().getNumberOfCameras() > 1 ? View.VISIBLE : View.GONE));
+            assertEquals(switchMultiCameraButton.getVisibility(), (activity.showSwitchMultiCamIcon() ? View.VISIBLE : View.GONE));
+            assertEquals(switchVideoButton.getVisibility(), View.VISIBLE);
+            if( !immersive_mode ) {
+                assertEquals(exposureButton.getVisibility(), exposureVisibility);
+                assertEquals(exposureLockButton.getVisibility(), exposureLockVisibility);
+            }
+            assertEquals(audioControlButton.getVisibility(), (has_audio_control_button ? View.VISIBLE : View.GONE));
+            assertEquals(popupButton.getVisibility(), View.VISIBLE);
+            assertEquals(trashButton.getVisibility(), View.GONE);
+            assertEquals(shareButton.getVisibility(), View.GONE);
+        }
+    }
+
+    public static class SubTestTakePhotoInfo {
+        public boolean has_thumbnail_anim;
+        public boolean is_hdr;
+        public boolean is_nr;
+        public boolean is_expo;
+        public int exposureVisibility;
+        public int exposureLockVisibility;
+        public String focus_value;
+        public String focus_value_ui;
+        public boolean can_auto_focus;
+        public boolean manual_can_auto_focus;
+        public boolean can_focus_area;
+    }
+
+    public static SubTestTakePhotoInfo getSubTestTakePhotoInfo(MainActivity activity, boolean immersive_mode, boolean single_tap_photo, boolean double_tap_photo) {
+        assertTrue(activity.getPreview().isPreviewStarted());
+        assertFalse(activity.getApplicationInterface().getImageSaver().test_queue_blocked);
+
+        SubTestTakePhotoInfo info = new SubTestTakePhotoInfo();
+
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity);
+
+        info.has_thumbnail_anim = sharedPreferences.getBoolean(PreferenceKeys.ThumbnailAnimationPreferenceKey, true);
+        info.is_hdr = activity.supportsHDR() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_hdr");
+        info.is_nr = activity.supportsNoiseReduction() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_noise_reduction");
+        info.is_expo = activity.supportsExpoBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_expo_bracketing");
+
+        boolean has_audio_control_button = !sharedPreferences.getString(PreferenceKeys.AudioControlPreferenceKey, "none").equals("none");
+
+        View switchCameraButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_camera);
+        View switchMultiCameraButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_multi_camera);
+        View switchVideoButton = activity.findViewById(net.sourceforge.opencamera.R.id.switch_video);
+        //View flashButton = activity.findViewById(net.sourceforge.opencamera.R.id.flash);
+        //View focusButton = activity.findViewById(net.sourceforge.opencamera.R.id.focus_mode);
+        View exposureButton = activity.findViewById(net.sourceforge.opencamera.R.id.exposure);
+        View exposureLockButton = activity.findViewById(net.sourceforge.opencamera.R.id.exposure_lock);
+        View audioControlButton = activity.findViewById(net.sourceforge.opencamera.R.id.audio_control);
+        View popupButton = activity.findViewById(net.sourceforge.opencamera.R.id.popup);
+        View trashButton = activity.findViewById(net.sourceforge.opencamera.R.id.trash);
+        View shareButton = activity.findViewById(net.sourceforge.opencamera.R.id.share);
+        assertEquals(switchCameraButton.getVisibility(), (immersive_mode ? View.GONE : (activity.getPreview().getCameraControllerManager().getNumberOfCameras() > 1 ? View.VISIBLE : View.GONE)));
+        assertEquals(switchMultiCameraButton.getVisibility(), (immersive_mode ? View.GONE : (activity.showSwitchMultiCamIcon() ? View.VISIBLE : View.GONE)));
+        assertEquals(switchVideoButton.getVisibility(), (immersive_mode ? View.GONE : View.VISIBLE));
+        info.exposureVisibility = exposureButton.getVisibility();
+        info.exposureLockVisibility = exposureLockButton.getVisibility();
+        assertEquals(audioControlButton.getVisibility(), ((has_audio_control_button && !immersive_mode) ? View.VISIBLE : View.GONE));
+        assertEquals(popupButton.getVisibility(), (immersive_mode ? View.GONE : View.VISIBLE));
+        assertEquals(trashButton.getVisibility(), View.GONE);
+        assertEquals(shareButton.getVisibility(), View.GONE);
+
+        info.focus_value = activity.getPreview().getCameraController().getFocusValue();
+        info.focus_value_ui = activity.getPreview().getCurrentFocusValue();
+        info.can_auto_focus = false;
+        info.manual_can_auto_focus = false;
+        info.can_focus_area = false;
+        if( info.focus_value.equals("focus_mode_auto") || info.focus_value.equals("focus_mode_macro") ) {
+            info.can_auto_focus = true;
+        }
+
+        if( info.focus_value.equals("focus_mode_auto") || info.focus_value.equals("focus_mode_macro") ) {
+            info.manual_can_auto_focus = true;
+        }
+        else if( info.focus_value.equals("focus_mode_continuous_picture") && !single_tap_photo && !double_tap_photo ) {
+            // if single_tap_photo or double_tap_photo, and continuous mode, we go straight to taking a photo rather than doing a touch to focus
+            info.manual_can_auto_focus = true;
+        }
+
+        if( activity.getPreview().getMaxNumFocusAreas() != 0 && ( info.focus_value.equals("focus_mode_auto") || info.focus_value.equals("focus_mode_macro") || info.focus_value.equals("focus_mode_continuous_picture") || info.focus_value.equals("focus_mode_continuous_video") || info.focus_value.equals("focus_mode_manual2") ) ) {
+            info.can_focus_area = true;
+        }
+        Log.d(TAG, "focus_value? " + info.focus_value);
+        Log.d(TAG, "can_auto_focus? " + info.can_auto_focus);
+        Log.d(TAG, "manual_can_auto_focus? " + info.manual_can_auto_focus);
+        Log.d(TAG, "can_focus_area? " + info.can_focus_area);
+
+        checkFocusInitial(activity, info.focus_value, info.focus_value_ui);
+
+        return info;
+    }
+
+    public static void touchToFocusChecks(MainActivity activity, final boolean single_tap_photo, final boolean double_tap_photo, final boolean manual_can_auto_focus, final boolean can_focus_area, final String focus_value, final String focus_value_ui, int saved_count) {
+        Preview preview = activity.getPreview();
+        Log.d(TAG, "1 count_cameraAutoFocus: " + preview.count_cameraAutoFocus);
+        assertEquals((manual_can_auto_focus ? saved_count + 1 : saved_count), preview.count_cameraAutoFocus);
+        Log.d(TAG, "has focus area?: " + preview.hasFocusArea());
+        if( single_tap_photo || double_tap_photo ) {
+            assertFalse(preview.hasFocusArea());
+            assertNull(preview.getCameraController().getFocusAreas());
+            assertNull(preview.getCameraController().getMeteringAreas());
+        }
+        else if( can_focus_area ) {
+            assertTrue(preview.hasFocusArea());
+            assertNotNull(preview.getCameraController().getFocusAreas());
+            assertEquals(1, preview.getCameraController().getFocusAreas().size());
+            assertNotNull(preview.getCameraController().getMeteringAreas());
+            assertEquals(1, preview.getCameraController().getMeteringAreas().size());
+        }
+        else {
+            assertFalse(preview.hasFocusArea());
+            assertNull(preview.getCameraController().getFocusAreas());
+            if( preview.getCameraController().supportsMetering() ) {
+                // we still set metering areas
+                assertNotNull(preview.getCameraController().getMeteringAreas());
+                assertEquals(1, preview.getCameraController().getMeteringAreas().size());
+            }
+            else {
+                assertNull(preview.getCameraController().getMeteringAreas());
+            }
+        }
+        String new_focus_value_ui = preview.getCurrentFocusValue();
+        //noinspection StringEquality
+        assertTrue(new_focus_value_ui == focus_value_ui || new_focus_value_ui.equals(focus_value_ui)); // also need to do == check, as strings may be null if focus not supported
+        if( focus_value.equals("focus_mode_continuous_picture") && !single_tap_photo && !double_tap_photo && preview.supportsFocus() && preview.getSupportedFocusValues().contains("focus_mode_auto") )
+            assertEquals("focus_mode_auto", preview.getCameraController().getFocusValue()); // continuous focus mode switches to auto focus on touch (unless single_tap_photo, or auto focus not supported)
+        else
+            assertEquals(preview.getCameraController().getFocusValue(), focus_value);
+    }
+
+    /** Tests the Exif tags in the resultant file. If the file is null, the uri will be
+     *  used instead to read the Exif tags.
+     */
+    public static void testExif(MainActivity activity, String file, Uri uri, boolean expect_device_tags, boolean expect_datetime, boolean expect_gps) throws IOException {
+        //final String TAG_GPS_IMG_DIRECTION = "GPSImgDirection";
+        //final String TAG_GPS_IMG_DIRECTION_REF = "GPSImgDirectionRef";
+        InputStream inputStream = null;
+        ExifInterface exif;
+        if( file != null ) {
+            assertNull(uri); // should only supply one of file or uri
+            exif = new ExifInterface(file);
+        }
+        else {
+            assertNotNull(uri);
+            inputStream = activity.getContentResolver().openInputStream(uri);
+            exif = new ExifInterface(inputStream);
+        }
+
+        assertNotNull(exif.getAttribute(ExifInterface.TAG_ORIENTATION));
+        if( !( isEmulator() && Build.VERSION.SDK_INT <= Build.VERSION_CODES.N_MR1 ) ) {
+            // older Android emulator versions don't store exif info in photos
+            if( expect_device_tags ) {
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_MAKE));
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_MODEL));
+            }
+            else {
+                assertNull(exif.getAttribute(ExifInterface.TAG_MAKE));
+                assertNull(exif.getAttribute(ExifInterface.TAG_MODEL));
+
+                assertNull(exif.getAttribute(ExifInterface.TAG_F_NUMBER));
+                assertNull(exif.getAttribute(ExifInterface.TAG_EXPOSURE_TIME));
+                assertNull(exif.getAttribute(ExifInterface.TAG_FLASH));
+                assertNull(exif.getAttribute(ExifInterface.TAG_FOCAL_LENGTH));
+                assertNull(exif.getAttribute(ExifInterface.TAG_IMAGE_DESCRIPTION));
+                assertNull(exif.getAttribute(ExifInterface.TAG_IMAGE_UNIQUE_ID));
+                assertNull(exif.getAttribute(ExifInterface.TAG_USER_COMMENT));
+                assertNull(exif.getAttribute(ExifInterface.TAG_ARTIST));
+                assertNull(exif.getAttribute(ExifInterface.TAG_COPYRIGHT));
+            }
+
+            if( expect_datetime ) {
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_DATETIME));
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_DATETIME_ORIGINAL));
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_DATETIME_DIGITIZED));
+                if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP ) {
+                    // not available on Galaxy Nexus Android 4.3 at least
+                    assertNotNull(exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME));
+                    assertNotNull(exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME_ORIGINAL));
+                    assertNotNull(exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME_DIGITIZED));
+                    assertNotNull(exif.getAttribute(ExifInterface.TAG_OFFSET_TIME));
+                    assertNotNull(exif.getAttribute(ExifInterface.TAG_OFFSET_TIME_ORIGINAL));
+                    assertNotNull(exif.getAttribute(ExifInterface.TAG_OFFSET_TIME_DIGITIZED));
+                }
+            }
+            else {
+                assertNull(exif.getAttribute(ExifInterface.TAG_DATETIME));
+                assertNull(exif.getAttribute(ExifInterface.TAG_DATETIME_ORIGINAL));
+                assertNull(exif.getAttribute(ExifInterface.TAG_DATETIME_DIGITIZED));
+                assertNull(exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME));
+                assertNull(exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME_ORIGINAL));
+                assertNull(exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME_DIGITIZED));
+                assertNull(exif.getAttribute(ExifInterface.TAG_OFFSET_TIME));
+                assertNull(exif.getAttribute(ExifInterface.TAG_OFFSET_TIME_ORIGINAL));
+                assertNull(exif.getAttribute(ExifInterface.TAG_OFFSET_TIME_DIGITIZED));
+            }
+
+            if( expect_gps ) {
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF));
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
+                assertNotNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF));
+                // can't read custom tags, even though we can write them?!
+                //assertTrue(exif.getAttribute(TAG_GPS_IMG_DIRECTION) != null);
+                //assertTrue(exif.getAttribute(TAG_GPS_IMG_DIRECTION_REF) != null);
+            }
+            else {
+                assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
+                assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF));
+                assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
+                assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF));
+                // can't read custom tags, even though we can write them?!
+                //assertTrue(exif.getAttribute(TAG_GPS_IMG_DIRECTION) == null);
+                //assertTrue(exif.getAttribute(TAG_GPS_IMG_DIRECTION_REF) == null);
+            }
+        }
+
+        if( inputStream != null ) {
+            inputStream.close();
+        }
+    }
+}
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/test/AvgTests.java b/app/src/androidTest/java/net/sourceforge/opencamera/test/AvgTests.java
index 6e5334ce5364f4b3c7716084adf5af1155cd97c8..fbc1119b654c69fb2b37d24842a64ed1b20992d7 100644
--- a/app/src/androidTest/java/net/sourceforge/opencamera/test/AvgTests.java
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/test/AvgTests.java
@@ -10,6 +10,7 @@ public class AvgTests {
      *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
      *  time to transfer to the device every time we run the tests.
      *  On Android 10+, scoped storage permission needs to be given to Open Camera for the DCIM/testOpenCamera/ folder.
+     *  UPDATE: now deprecated, replaced with AvgTestSuite.
      */
     public static Test suite() {
         TestSuite suite = new TestSuite(MainTests.class.getName());
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/test/HDRNTests.java b/app/src/androidTest/java/net/sourceforge/opencamera/test/HDRNTests.java
index 4c82cfd8a2d3dfcd2e48639e456c5b5a66161130..fe14fab5c946c1ca13173861b895a82e34dc35eb 100644
--- a/app/src/androidTest/java/net/sourceforge/opencamera/test/HDRNTests.java
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/test/HDRNTests.java
@@ -10,6 +10,7 @@ public class HDRNTests {
      *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
      *  time to transfer to the device every time we run the tests.
      *  On Android 10+, scoped storage permission needs to be given to Open Camera for the DCIM/testOpenCamera/ folder.
+     *  UPDATE: now deprecated, replaced with HDRNTestSuite.
      */
     public static Test suite() {
         TestSuite suite = new TestSuite(MainTests.class.getName());
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/test/HDRTests.java b/app/src/androidTest/java/net/sourceforge/opencamera/test/HDRTests.java
index 5c6b5622412ada30e95696045ee975052da70aa8..029065386b83e58e8acf90fcf277301dbfead88b 100644
--- a/app/src/androidTest/java/net/sourceforge/opencamera/test/HDRTests.java
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/test/HDRTests.java
@@ -10,6 +10,7 @@ public class HDRTests {
      *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
      *  time to transfer to the device every time we run the tests.
      *  On Android 10+, scoped storage permission needs to be given to Open Camera for the DCIM/testOpenCamera/ folder.
+     *  UPDATE: now deprecated, replaced with HDRTestSuite.
      */
     public static Test suite() {
         TestSuite suite = new TestSuite(MainTests.class.getName());
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/test/MainActivityTest.java b/app/src/androidTest/java/net/sourceforge/opencamera/test/MainActivityTest.java
index d59715747073e88d9abd282f733e48f42a1ad344..b1db2c87b7d97d40191bb5b4b700d3a3ae6b5d68 100644
--- a/app/src/androidTest/java/net/sourceforge/opencamera/test/MainActivityTest.java
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/test/MainActivityTest.java
@@ -7,10 +7,8 @@ import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.OutputStream;
 import java.io.IOException;
-import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Date;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
@@ -18,7 +16,7 @@ import java.util.Set;
 
 import net.sourceforge.opencamera.LocationSupplier;
 import net.sourceforge.opencamera.MyPreferenceFragment;
-import net.sourceforge.opencamera.PanoramaProcessorException;
+import net.sourceforge.opencamera.TestUtils;
 import net.sourceforge.opencamera.cameracontroller.CameraController2;
 import net.sourceforge.opencamera.HDRProcessor;
 import net.sourceforge.opencamera.HDRProcessorException;
@@ -31,22 +29,18 @@ import net.sourceforge.opencamera.preview.VideoProfile;
 import net.sourceforge.opencamera.SaveLocationHistory;
 import net.sourceforge.opencamera.cameracontroller.CameraController;
 import net.sourceforge.opencamera.preview.Preview;
+import net.sourceforge.opencamera.ui.DrawPreview;
 import net.sourceforge.opencamera.ui.FolderChooserDialog;
 import net.sourceforge.opencamera.ui.MainUI;
 import net.sourceforge.opencamera.ui.PopupView;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
-import android.content.ContentUris;
-import android.content.ContentValues;
 import android.content.Intent;
 import android.content.SharedPreferences;
 //import android.content.res.AssetManager;
-import android.database.Cursor;
 import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
 import android.graphics.Color;
-import android.graphics.Matrix;
 import android.graphics.Point;
 import android.graphics.PointF;
 import android.hardware.camera2.CameraMetadata;
@@ -54,17 +48,11 @@ import android.hardware.camera2.CaptureRequest;
 import android.hardware.camera2.params.TonemapCurve;
 import android.location.Location;
 import android.media.CamcorderProfile;
-import androidx.exifinterface.media.ExifInterface;
 import android.media.MediaScannerConnection;
 import android.net.Uri;
 import android.os.Build;
-import android.os.Environment;
-import android.os.ParcelFileDescriptor;
 import android.preference.PreferenceManager;
-import android.provider.DocumentsContract;
 import android.provider.MediaStore;
-import android.renderscript.Allocation;
-import androidx.annotation.RequiresApi;
 import android.test.ActivityInstrumentationTestCase2;
 import android.test.TouchUtils;
 import android.util.Log;
@@ -90,13 +78,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         super("net.sourceforge.opencamera", MainActivity.class);
     }
 
-    static boolean isEmulator() {
-        return Build.MODEL.contains("Android SDK built for x86");
-    }
-
-    private Intent createDefaultIntent() {
+    private static Intent createDefaultIntent() {
         Intent intent = new Intent();
-        intent.putExtra("test_project", true);
+        TestUtils.setDefaultIntent(intent);
         return intent;
     }
 
@@ -106,24 +90,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         super.setUp();
 
         setActivityInitialTouchMode(false);
-        Log.d(TAG, "setUp: 1");
-
-        // initialise test statics (to avoid the persisting between tests in a test suite run!)
-        MainActivity.test_preview_want_no_limits = false;
-        MainActivity.test_preview_want_no_limits_value = false;
-        ImageSaver.test_small_queue_size = false;
 
         // use getTargetContext() as we haven't started the activity yet (and don't want to, as we want to set prefs before starting)
-        SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(this.getInstrumentation().getTargetContext());
-        SharedPreferences.Editor editor = settings.edit();
-        editor.clear();
-        if( test_camera2 ) {
-            MainActivity.test_force_supports_camera2 = true;
-            //editor.putBoolean(PreferenceKeys.UseCamera2PreferenceKey, true);
-            editor.putString(PreferenceKeys.CameraAPIPreferenceKey, "preference_camera_api_camera2");
-        }
-        editor.apply();
-        Log.d(TAG, "setUp: 2");
+        TestUtils.initTest(this.getInstrumentation().getTargetContext(), test_camera2);
 
         Intent intent = createDefaultIntent();
         setActivityIntent(intent);
@@ -155,7 +124,8 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         //assertTrue( mPreview.getCameraController() == null || mPreview.getCameraController().count_camera_parameters_exception == 0 );
         //assertTrue( mPreview.getCameraController() == null || mPreview.getCameraController().count_precapture_timeout == 0 );
 
-        // reset back to defaults
+        // reset back to defaults (whilst each test will reset the settings anyway via before()->TestUtils.initTest(), it's useful
+        // to leave the application in a default state after running tests)
         SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(mActivity);
         SharedPreferences.Editor editor = settings.edit();
         editor.clear();
@@ -251,6 +221,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // need to wait for UI code to finish before leaving
         this.getInstrumentation().waitForIdleSync();
         waitUntilCameraOpened(); // may need to wait if camera is reopened, e.g., when changing scene mode - see testSceneMode()
+        // but we also need to wait for the delay if instead we've stopped and restarted the preview, the latter now only happens after dim_effect_time_c
+        try {
+            Thread.sleep(DrawPreview.dim_effect_time_c+50); // wait for updateForSettings
+        }
+        catch(InterruptedException e) {
+            e.printStackTrace();
+        }
+        this.getInstrumentation().waitForIdleSync();
+
     }
 
     private void clickView(final View view) {
@@ -283,19 +262,35 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
     }
 
+    private void openPopupMenu() {
+        Log.d(TAG, "openPopupMenu");
+        assertFalse( mActivity.popupIsOpen() );
+        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
+        clickView(popupButton);
+        Log.d(TAG, "wait for popup to open");
+        while( !mActivity.popupIsOpen() ) {
+        }
+        Log.d(TAG, "popup is now open");
+    }
+
+    private void closePopupMenu() {
+        Log.d(TAG, "closePopupMenu");
+        assertTrue( mActivity.popupIsOpen() );
+        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
+        clickView(popupButton);
+        Log.d(TAG, "wait for popup to close");
+        while( mActivity.popupIsOpen() ) {
+        }
+        Log.d(TAG, "popup is now closed");
+    }
+
     private void switchToFlashValue(String required_flash_value) {
+        Log.d(TAG, "switchToFlashValue: "+ required_flash_value);
         if( mPreview.supportsFlash() ) {
             String flash_value = mPreview.getCurrentFlashValue();
             Log.d(TAG, "start flash_value: "+ flash_value);
-            Log.d(TAG, "required_flash_value: "+ required_flash_value);
             if( !flash_value.equals(required_flash_value) ) {
-                assertFalse( mActivity.popupIsOpen() );
-                View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-                clickView(popupButton);
-                Log.d(TAG, "wait for popup to open");
-                while( !mActivity.popupIsOpen() ) {
-                }
-                Log.d(TAG, "popup is now open");
+                openPopupMenu();
                 View currentFlashButton = mActivity.getUIButton("TEST_FLASH_" + flash_value);
                 assertNotNull(currentFlashButton);
                 assertEquals(currentFlashButton.getAlpha(), PopupView.ALPHA_BUTTON_SELECTED);
@@ -326,11 +321,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             String focus_value = mPreview.getCurrentFocusValue();
             Log.d(TAG, "start focus_value: "+ focus_value);
             if( !focus_value.equals(required_focus_value) ) {
-                assertFalse( mActivity.popupIsOpen() );
-                View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-                clickView(popupButton);
-                while( !mActivity.popupIsOpen() ) {
-                }
+                openPopupMenu();
                 View focusButton = mActivity.getUIButton("TEST_FOCUS_" + required_focus_value);
                 assertNotNull(focusButton);
                 clickView(focusButton);
@@ -338,14 +329,14 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
                 Log.d(TAG, "changed focus_value to: "+ focus_value);
             }
             assertEquals(focus_value, required_focus_value);
-            String actual_focus_value = mPreview.getCameraController().getFocusValue();
-            Log.d(TAG, "actual_focus_value: "+ actual_focus_value);
+            String controller_focus_value = mPreview.getCameraController().getFocusValue();
+            Log.d(TAG, "controller_focus_value: "+ controller_focus_value);
             String compare_focus_value = focus_value;
             if( compare_focus_value.equals("focus_mode_locked") )
                 compare_focus_value = "focus_mode_auto";
             else if( compare_focus_value.equals("focus_mode_infinity") && mPreview.usingCamera2API() )
                 compare_focus_value = "focus_mode_manual2";
-            assertEquals(compare_focus_value, actual_focus_value);
+            assertEquals(compare_focus_value, controller_focus_value);
         }
     }
 
@@ -354,11 +345,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         int iso = mPreview.getCameraController().getISO();
         Log.d(TAG, "start iso: "+ iso);
         if( iso != required_iso ) {
-            /*assertFalse( mActivity.popupIsOpen() );
-            View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-            clickView(popupButton);
-            while( !mActivity.popupIsOpen() ) {
-            }
+            /*openPopupMenu();
             View isoButton = mActivity.getUIButton("TEST_ISO_" + required_iso);
             assertTrue(isoButton != null);
             clickView(isoButton);
@@ -372,6 +359,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             View isoButton = mActivity.getUIButton("TEST_ISO_" + required_iso);
             assertNotNull(isoButton);
             clickView(isoButton);
+            try {
+                Thread.sleep(DrawPreview.dim_effect_time_c+50); // wait for updateForSettings
+                this.getInstrumentation().waitForIdleSync();
+            }
+            catch(InterruptedException e) {
+                e.printStackTrace();
+            }
             iso = mPreview.getCameraController().getISO();
             Log.d(TAG, "changed iso to: "+ iso);
             clickView(exposureButton);
@@ -404,6 +398,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         switchToFlashValue("flash_off");
         switchToFocusValue("focus_mode_continuous_picture");
+
         // pause for safety - needed for Nokia 8 at least otherwise some tests like testContinuousPictureFocusRepeat,
         // testLocationOff result in hang whilst waiting for photo to be taken, and hit the timeout in waitForTakePhoto()
         try {
@@ -904,7 +899,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
     /* Ensures that preview resolution is set as expected in non-WYSIWYG mode
      */
-    public void testPreviewSize() {
+    public void testPreviewSize() throws InterruptedException {
         Log.d(TAG, "testPreviewSize");
 
         setToDefault();
@@ -972,8 +967,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         double targetRatio = mPreview.getTargetRatio();
         double expTargetRatio = ((double)picture_size.width) / (double)picture_size.height;
         double previewRatio = ((double)preview_size.width) / (double)preview_size.height;
+        Log.d(TAG, "picture_size: " + picture_size.width + " x " + picture_size.height);
+        Log.d(TAG, "preview_size: " + preview_size.width + " x " + preview_size.height);
+        Log.d(TAG, "expTargetRatio: " + expTargetRatio);
+        Log.d(TAG, "targetRatio: " + targetRatio);
+        Log.d(TAG, "previewRatio: " + previewRatio);
+        // need larger tolerance for Pixel 6 Pro, as default resolution 4080x3072 has aspect ratio 1.328125,
+        // but closet preview aspect ratio is 4:3
         assertTrue( Math.abs(targetRatio - expTargetRatio) <= 1.0e-5 );
-        assertTrue( Math.abs(previewRatio - expTargetRatio) <= 1.0e-5 );
+        assertTrue( Math.abs(previewRatio - expTargetRatio) <= 0.01 );
         checkOptimalPreviewSize();
         checkSquareAspectRatio();
 
@@ -989,7 +991,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         expTargetRatio = ((double)profile.videoFrameWidth) / (double)profile.videoFrameHeight;
         previewRatio = ((double)video_preview_size.width) / (double)video_preview_size.height;
         assertTrue( Math.abs(targetRatio - expTargetRatio) <= 1.0e-5 );
-        assertTrue( Math.abs(previewRatio - expTargetRatio) <= 1.0e-5 );
+        assertTrue( Math.abs(previewRatio - expTargetRatio) <= 0.01 );
         checkOptimalPreviewSize();
         checkSquareAspectRatio();
         checkOptimalVideoPictureSize(expTargetRatio);
@@ -1019,7 +1021,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             expTargetRatio = ((double)picture_size.width) / (double)picture_size.height;
             previewRatio = ((double)preview_size.width) / (double)preview_size.height;
             assertTrue( Math.abs(targetRatio - expTargetRatio) <= 1.0e-5 );
-            assertTrue( Math.abs(previewRatio - expTargetRatio) <= 1.0e-5 );
+            assertTrue( Math.abs(previewRatio - expTargetRatio) <= 0.01 );
             checkOptimalPreviewSize();
             checkSquareAspectRatio();
 
@@ -1034,7 +1036,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             expTargetRatio = ((double)profile.videoFrameWidth) / (double)profile.videoFrameHeight;
             previewRatio = ((double)video_preview_size.width) / (double)video_preview_size.height;
             assertTrue( Math.abs(targetRatio - expTargetRatio) <= 1.0e-5 );
-            assertTrue( Math.abs(previewRatio - expTargetRatio) <= 1.0e-5 );
+            assertTrue( Math.abs(previewRatio - expTargetRatio) <= 0.01 );
             checkOptimalPreviewSize();
             checkSquareAspectRatio();
             checkOptimalVideoPictureSize(expTargetRatio);
@@ -1782,9 +1784,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         assertEquals(has_exposure_lock, exposure_lock_visible);
         assertTrue(popup_visible);
 
-        clickView(popupButton);
-        while( !mActivity.popupIsOpen() ) {
-        }
+        openPopupMenu();
         subTestPopupButtonAvailability();
     }
 
@@ -1852,12 +1852,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         String photo_focus_value = mPreview.getCameraController().getFocusValue();
         Log.d(TAG, "picture photo_focus_value: "+ photo_focus_value);
 
-        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-        clickView(popupButton);
-        Log.d(TAG, "wait for popup to open");
-        while( !mActivity.popupIsOpen() ) {
-        }
-        Log.d(TAG, "popup is now open");
+        openPopupMenu();
 
         // test popup buttons for photo mode:
         subTestPopupButtonContentDescription(net.sourceforge.opencamera.R.string.preference_resolution, "PHOTO_RESOLUTIONS", false, true);
@@ -1880,11 +1875,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
 
         // test popup buttons for video mode:
-        clickView(popupButton);
-        Log.d(TAG, "wait for popup to open");
-        while( !mActivity.popupIsOpen() ) {
-        }
-        Log.d(TAG, "popup is now open");
+        openPopupMenu();
         subTestPopupButtonContentDescription(net.sourceforge.opencamera.R.string.video_quality, "VIDEO_RESOLUTIONS", false, true);
         subTestPopupButtonContentDescription(net.sourceforge.opencamera.R.string.video_quality, "VIDEO_RESOLUTIONS", true, false);
         if( mActivity.getApplicationInterface().getSupportedVideoCaptureRates().size() > 1 ) {
@@ -1925,11 +1916,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             Log.d(TAG, "front picture photo_focus_value: "+ photo_focus_value);
 
             // test popup buttons for photo mode:
-            clickView(popupButton);
-            Log.d(TAG, "wait for popup to open");
-            while( !mActivity.popupIsOpen() ) {
-            }
-            Log.d(TAG, "popup is now open");
+            openPopupMenu();
             subTestPopupButtonContentDescription(net.sourceforge.opencamera.R.string.preference_resolution, "PHOTO_RESOLUTIONS", false, true);
             subTestPopupButtonContentDescription(net.sourceforge.opencamera.R.string.preference_resolution, "PHOTO_RESOLUTIONS", true, false);
             subTestPopupButtonContentDescription(net.sourceforge.opencamera.R.string.preference_timer, "TIMER", false, false);
@@ -1949,11 +1936,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             }
 
             // test popup buttons for video mode:
-            clickView(popupButton);
-            Log.d(TAG, "wait for popup to open");
-            while( !mActivity.popupIsOpen() ) {
-            }
-            Log.d(TAG, "popup is now open");
+            openPopupMenu();
             subTestPopupButtonContentDescription(net.sourceforge.opencamera.R.string.video_quality, "VIDEO_RESOLUTIONS", false, true);
             subTestPopupButtonContentDescription(net.sourceforge.opencamera.R.string.video_quality, "VIDEO_RESOLUTIONS", true, false);
             if( mActivity.getApplicationInterface().getSupportedVideoCaptureRates().size() > 1 ) {
@@ -2084,10 +2067,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         Thread.sleep(1000);
 
-        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-        clickView(popupButton);
-        while( !mActivity.popupIsOpen() ) {
-        }
+        openPopupMenu();
 
         Thread.sleep(1000);
 
@@ -2707,7 +2687,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
         else if( mPreview.supportsISORange() ) {
             subTestPopupButtonAvailability("TEST_ISO", "auto", true);
-            int [] test_isos = {0, 50, 100, 200, 400, 800, 1600, 3200, 6400, 10000};
+            int [] test_isos = {0, 50, 100, 200, 400, 800, 1600, 3200, 6400};
             int min_iso = mPreview.getMinimumISO();
             int max_iso = mPreview.getMaximumISO();
             for(int test_iso : test_isos) {
@@ -2744,7 +2724,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         long [] delays = {20, 50, 100, 1000};
         int [] n_iters = {50, 30, 30, 3};
-        if( isEmulator() ) {
+        if( TestUtils.isEmulator() ) {
             // this takes much longer to run on emulator, due to taking ~15s for the first waitForIdleSync() in the loop
             n_iters = new int[]{1, 1, 1, 1};
         }
@@ -3110,12 +3090,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         updateForSettings();*/
 
         // simulate having changed this through popup view:
-        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-        clickView(popupButton);
-        Log.d(TAG, "wait for popup to open");
-        while( !mActivity.popupIsOpen() ) {
-        }
-        Log.d(TAG, "popup is now open");
+        openPopupMenu();
         SharedPreferences.Editor editor = settings.edit();
         editor.putString(PreferenceKeys.WhiteBalancePreferenceKey, "manual");
         editor.apply();
@@ -3126,12 +3101,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         });
         this.getInstrumentation().waitForIdleSync();
 
-        /*View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-        clickView(popupButton);
-        Log.d(TAG, "wait for popup to open");
-        while( !mActivity.popupIsOpen() ) {
-        }
-        Log.d(TAG, "popup is now open");
+        /*openPopupMenu();
         // first need to open the white balance sub-menu
         View wbButton = mActivity.getUIButton("TEST_WHITE_BALANCE");
         assertTrue(wbButton != null);
@@ -3289,40 +3259,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
     }
 
     private void waitForTakePhoto() {
-        View switchCameraButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_camera);
-        View switchMultiCameraButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_multi_camera);
-        View switchVideoButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_video);
-        //View flashButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.flash);
-        //View focusButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.focus_mode);
-        View exposureButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.exposure);
-        View exposureLockButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.exposure_lock);
-        View audioControlButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.audio_control);
-        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-        View trashButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.trash);
-        View shareButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.share);
-        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(mActivity);
-        boolean is_focus_bracketing = mActivity.supportsFocusBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_focus_bracketing");
-        boolean is_panorama = mActivity.supportsPanorama() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_panorama");
-
         Log.d(TAG, "wait until finished taking photo");
         long time_s = System.currentTimeMillis();
         while( mPreview.isTakingPhoto() || !mActivity.getApplicationInterface().canTakeNewPhoto() ) {
-            // make sure the test fails rather than hanging, if for some reason we get stuck (note that testTakePhotoManualISOExposure takes over 10s on Nexus 6)
-            // also see note at end of setToDefault for Nokia 8, need to sleep briefly to avoid hanging here
-            if( !is_focus_bracketing ) {
-                assertTrue(System.currentTimeMillis() - time_s < (is_panorama ? 50000 : 20000)); // need longer for panorama on Nexus 7 for testTakePhotoPanoramaMax
-            }
-            assertTrue(!mPreview.isTakingPhoto() || switchCameraButton.getVisibility() == View.GONE);
-            assertTrue(!mPreview.isTakingPhoto() || switchMultiCameraButton.getVisibility() == View.GONE);
-            assertTrue(!mPreview.isTakingPhoto() || switchVideoButton.getVisibility() == View.GONE);
-            //assertTrue(!mPreview.isTakingPhoto() || flashButton.getVisibility() == View.GONE);
-            //assertTrue(!mPreview.isTakingPhoto() || focusButton.getVisibility() == View.GONE);
-            assertTrue(!mPreview.isTakingPhoto() || exposureButton.getVisibility() == View.GONE);
-            assertTrue(!mPreview.isTakingPhoto() || exposureLockButton.getVisibility() == View.GONE);
-            assertTrue(!mPreview.isTakingPhoto() || audioControlButton.getVisibility() == View.GONE);
-            assertTrue(!mPreview.isTakingPhoto() || popupButton.getVisibility() == View.GONE);
-            assertTrue(!mPreview.isTakingPhoto() || trashButton.getVisibility() == View.GONE);
-            assertTrue(!mPreview.isTakingPhoto() || shareButton.getVisibility() == View.GONE);
+            TestUtils.waitForTakePhotoChecks(mActivity, time_s);
         }
         Log.d(TAG, "done taking photo");
     }
@@ -3335,48 +3275,19 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         int saved_count = mPreview.count_cameraAutoFocus;
         Log.d(TAG, "saved count_cameraAutoFocus: " + saved_count);
         Log.d(TAG, "has focus area?: " + mPreview.hasFocusArea());
-        Log.d(TAG, "about to click preview for autofocus");
+        Log.d(TAG, "### about to click preview for autofocus");
         if( double_tap_photo ) {
             TouchUtils.tapView(MainActivityTest.this, mPreview.getView());
         }
         else {
             TouchUtils.clickView(MainActivityTest.this, mPreview.getView());
         }
+        Log.d(TAG, "### done click preview for autofocus");
         this.getInstrumentation().waitForIdleSync();
-        Log.d(TAG, "1 count_cameraAutoFocus: " + mPreview.count_cameraAutoFocus);
-        assertEquals((manual_can_auto_focus ? saved_count + 1 : saved_count), mPreview.count_cameraAutoFocus);
-        Log.d(TAG, "has focus area?: " + mPreview.hasFocusArea());
-        if( single_tap_photo || double_tap_photo ) {
-            assertFalse(mPreview.hasFocusArea());
-            assertNull(mPreview.getCameraController().getFocusAreas());
-            assertNull(mPreview.getCameraController().getMeteringAreas());
-        }
-        else if( can_focus_area ) {
-            assertTrue(mPreview.hasFocusArea());
-            assertNotNull(mPreview.getCameraController().getFocusAreas());
-            assertEquals(1, mPreview.getCameraController().getFocusAreas().size());
-            assertNotNull(mPreview.getCameraController().getMeteringAreas());
-            assertEquals(1, mPreview.getCameraController().getMeteringAreas().size());
-        }
-        else {
-            assertFalse(mPreview.hasFocusArea());
-            assertNull(mPreview.getCameraController().getFocusAreas());
-            if( mPreview.getCameraController().supportsMetering() ) {
-                // we still set metering areas
-                assertNotNull(mPreview.getCameraController().getMeteringAreas());
-                assertEquals(1, mPreview.getCameraController().getMeteringAreas().size());
-            }
-            else {
-                assertNull(mPreview.getCameraController().getMeteringAreas());
-            }
-        }
-        String new_focus_value_ui = mPreview.getCurrentFocusValue();
-        //noinspection StringEquality
-        assertTrue(new_focus_value_ui == focus_value_ui || new_focus_value_ui.equals(focus_value_ui)); // also need to do == check, as strings may be null if focus not supported
-        if( focus_value.equals("focus_mode_continuous_picture") && !single_tap_photo && !double_tap_photo && mPreview.supportsFocus() && mPreview.getSupportedFocusValues().contains("focus_mode_auto") )
-            assertEquals("focus_mode_auto", mPreview.getCameraController().getFocusValue()); // continuous focus mode switches to auto focus on touch (unless single_tap_photo, or auto focus not supported)
-        else
-            assertEquals(mPreview.getCameraController().getFocusValue(), focus_value);
+        Log.d(TAG, "done wait for idle sync");
+
+        TestUtils.touchToFocusChecks(mActivity, single_tap_photo, double_tap_photo, manual_can_auto_focus, can_focus_area, focus_value, focus_value_ui, saved_count);
+
         if( double_tap_photo ) {
             Thread.sleep(100);
             Log.d(TAG, "about to click preview again for double tap");
@@ -3391,429 +3302,30 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
     }
 
-    private void checkFocusInitial(final String focus_value, final String focus_value_ui) {
-        String new_focus_value_ui = mPreview.getCurrentFocusValue();
-        //noinspection StringEquality
-        assertTrue(new_focus_value_ui == focus_value_ui || new_focus_value_ui.equals(focus_value_ui)); // also need to do == check, as strings may be null if focus not supported
-        assertEquals(mPreview.getCameraController().getFocusValue(), focus_value);
-    }
-
-    private void checkFocusAfterTakePhoto(final String focus_value, final String focus_value_ui) {
-        // focus should be back to normal now:
-        String new_focus_value_ui = mPreview.getCurrentFocusValue();
-        Log.d(TAG, "focus_value_ui: " + focus_value_ui);
-        Log.d(TAG, "new new_focus_value_ui: " + new_focus_value_ui);
-        //noinspection StringEquality
-        assertTrue(new_focus_value_ui == focus_value_ui || new_focus_value_ui.equals(focus_value_ui)); // also need to do == check, as strings may be null if focus not supported
-        String new_focus_value = mPreview.getCameraController().getFocusValue();
-        Log.d(TAG, "focus_value: " + focus_value);
-        Log.d(TAG, "new focus_value: " + new_focus_value);
-        if( new_focus_value_ui != null && new_focus_value_ui.equals("focus_mode_continuous_picture") && focus_value.equals("focus_mode_auto") && new_focus_value.equals("focus_mode_continuous_picture") ) {
-            // this is fine, it just means we were temporarily in touch-to-focus mode
-        }
-        else {
-            assertEquals(new_focus_value, focus_value);
-        }
-    }
-
-    private void checkFocusAfterTakePhoto2(final boolean touch_to_focus, final boolean single_tap_photo, final boolean double_tap_photo, final boolean test_wait_capture_result, final boolean locked_focus, final boolean can_auto_focus, final boolean can_focus_area, final int saved_count) {
-        // in locked focus mode, taking photo should never redo an auto-focus
-        // if photo mode, we may do a refocus if the previous auto-focus failed, but not if it succeeded
-        Log.d(TAG, "2 count_cameraAutoFocus: " + mPreview.count_cameraAutoFocus);
-        if( locked_focus ) {
-            assertEquals(mPreview.count_cameraAutoFocus, (can_auto_focus ? saved_count + 1 : saved_count));
-        }
-        if( test_wait_capture_result ) {
-            // if test_wait_capture_result, then we'll have waited too long, so focus settings may have changed
-        }
-        else if( touch_to_focus ) {
-            Log.d(TAG, "can_focus_area?: " + can_focus_area);
-            Log.d(TAG, "hasFocusArea?: " + mPreview.hasFocusArea());
-            if( single_tap_photo || double_tap_photo ) {
-                assertFalse(mPreview.hasFocusArea());
-                assertNull(mPreview.getCameraController().getFocusAreas());
-                assertNull(mPreview.getCameraController().getMeteringAreas());
-            }
-            else if( can_focus_area ) {
-                assertTrue(mPreview.hasFocusArea());
-                assertNotNull(mPreview.getCameraController().getFocusAreas());
-                assertEquals(1, mPreview.getCameraController().getFocusAreas().size());
-                assertNotNull(mPreview.getCameraController().getMeteringAreas());
-                assertEquals(1, mPreview.getCameraController().getMeteringAreas().size());
-            }
-            else {
-                assertFalse(mPreview.hasFocusArea());
-                assertNull(mPreview.getCameraController().getFocusAreas());
-
-                if( mPreview.getCameraController().supportsMetering() ) {
-                    // we still set metering areas
-                    assertNotNull(mPreview.getCameraController().getMeteringAreas());
-                    assertEquals(1, mPreview.getCameraController().getMeteringAreas().size());
-                }
-                else {
-                    assertNull(mPreview.getCameraController().getMeteringAreas());
-                }
-            }
-        }
-        else {
-            assertFalse(mPreview.hasFocusArea());
-            assertNull(mPreview.getCameraController().getFocusAreas());
-            assertNull(mPreview.getCameraController().getMeteringAreas());
-        }
-    }
-
-    private int getExpNNewFiles(final boolean is_raw) {
-        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(mActivity);
-        boolean hdr_save_expo =  sharedPreferences.getBoolean(PreferenceKeys.HDRSaveExpoPreferenceKey, false);
-        boolean is_hdr = mActivity.supportsHDR() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_hdr");
-        boolean is_expo = mActivity.supportsExpoBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_expo_bracketing");
-        boolean is_focus_bracketing = mActivity.supportsFocusBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_focus_bracketing");
-        boolean is_fast_burst = mActivity.supportsFastBurst() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_fast_burst");
-        String n_expo_images_s = sharedPreferences.getString(PreferenceKeys.ExpoBracketingNImagesPreferenceKey, "3");
-        int n_expo_images = Integer.parseInt(n_expo_images_s);
-        String n_focus_bracketing_images_s = sharedPreferences.getString(PreferenceKeys.FocusBracketingNImagesPreferenceKey, "3");
-        int n_focus_bracketing_images = Integer.parseInt(n_focus_bracketing_images_s);
-        String n_fast_burst_images_s = sharedPreferences.getString(PreferenceKeys.FastBurstNImagesPreferenceKey, "5");
-        int n_fast_burst_images = Integer.parseInt(n_fast_burst_images_s);
-
-        int exp_n_new_files;
-        if( is_hdr && hdr_save_expo ) {
-            exp_n_new_files = 4;
-            if( is_raw && !mActivity.getApplicationInterface().isRawOnly() ) {
-                exp_n_new_files += 3;
-            }
-        }
-        else if( is_expo ) {
-            exp_n_new_files = n_expo_images;
-            if( is_raw && !mActivity.getApplicationInterface().isRawOnly() ) {
-                exp_n_new_files *= 2;
-            }
-        }
-        else if( is_focus_bracketing ) {
-            exp_n_new_files = n_focus_bracketing_images;
-            if( is_raw && !mActivity.getApplicationInterface().isRawOnly() ) {
-                exp_n_new_files *= 2;
-            }
-        }
-        else if( is_fast_burst )
-            exp_n_new_files = n_fast_burst_images;
-        else {
-            exp_n_new_files = 1;
-            if( is_raw && !mActivity.getApplicationInterface().isRawOnly() ) {
-                exp_n_new_files *= 2;
-            }
-        }
-        Log.d(TAG, "exp_n_new_files: " + exp_n_new_files);
-        return exp_n_new_files;
-    }
-
-    private void checkFilenames(final boolean is_raw, final String [] files, final String [] files2) {
-        Log.d(TAG, "checkFilenames");
-        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(mActivity);
-        boolean hdr_save_expo =  sharedPreferences.getBoolean(PreferenceKeys.HDRSaveExpoPreferenceKey, false);
-        boolean is_hdr = mActivity.supportsHDR() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_hdr");
-        boolean is_fast_burst = mActivity.supportsFastBurst() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_fast_burst");
-        boolean is_expo = mActivity.supportsExpoBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_expo_bracketing");
-        boolean is_focus_bracketing = mActivity.supportsFocusBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_focus_bracketing");
-
-        // check files have names as expected
-        String filename_jpeg = null;
-        String filename_dng = null;
-        int n_files = files == null ? 0 : files.length;
-        for(String file : files2) {
-            Log.d(TAG, "check file: " + file);
-            boolean is_new = true;
-            for(int j=0;j<n_files && is_new;j++) {
-                if( file.equals( files[j] ) ) {
-                    is_new = false;
-                    break;
-                }
-            }
-            if( is_new ) {
-                Log.d(TAG, "file is new");
-                //String filename = file.getName();
-                //noinspection UnnecessaryLocalVariable
-                String filename = file;
-                assertTrue(filename.startsWith("IMG_"));
-                if( filename.endsWith(".jpg") ) {
-                    assertTrue(hdr_save_expo || is_expo || is_focus_bracketing || is_fast_burst || filename_jpeg == null);
-                    if( is_hdr && hdr_save_expo ) {
-                        // only look for the "_HDR" image
-                        if( filename.contains("_HDR") )
-                            filename_jpeg = filename;
-                    }
-                    else if( is_expo || is_focus_bracketing ) {
-                        if( filename_jpeg != null ) {
-                            // check same root
-                            int last_underscore_jpeg = filename_jpeg.lastIndexOf('_');
-                            assertTrue(last_underscore_jpeg != -1);
-                            String filename_base_jpeg = filename_jpeg.substring(0, last_underscore_jpeg+1);
-
-                            int last_underscore = filename.lastIndexOf('_');
-                            assertTrue(last_underscore != -1);
-                            String filename_base = filename.substring(0, last_underscore+1);
-                            Log.d(TAG, "filename_base: " + filename_base);
-
-                            assertEquals(filename_base_jpeg, filename_base);
-                        }
-                        filename_jpeg = filename; // store the last name, to match mActivity.test_last_saved_image
-                    }
-                    else {
-                        filename_jpeg = filename;
-                    }
-                }
-                else if( filename.endsWith(".dng") ) {
-                    assertTrue(is_raw);
-                    assertTrue(hdr_save_expo || is_expo || is_focus_bracketing || filename_dng == null);
-                    filename_dng = filename;
-                }
-                else {
-                    fail();
-                }
-            }
-        }
-        assertEquals((filename_jpeg == null), (is_raw && mActivity.getApplicationInterface().isRawOnly() && !is_hdr));
-        assertEquals((filename_dng != null), is_raw);
-        if( is_raw && !mActivity.getApplicationInterface().isRawOnly() ) {
-            // check we have same filenames (ignoring extensions)
-            // if HDR, then we should exclude the "_HDR" vs "_x" of the base filenames
-            // if expo, then exclude the "_x" as values may be different due to different order of JPEG vs DNG files in the files2 array (at least on Galaxy S10e)
-            String filename_base_jpeg;
-            String filename_base_dng;
-            if( is_hdr ) {
-                filename_base_jpeg = filename_jpeg.substring(0, filename_jpeg.length()-7);
-                filename_base_dng = filename_dng.substring(0, filename_dng.length()-5);
-            }
-            else if( is_expo ) {
-                filename_base_jpeg = filename_jpeg.substring(0, filename_jpeg.length()-5);
-                filename_base_dng = filename_dng.substring(0, filename_dng.length()-5);
-            }
-            else {
-                filename_base_jpeg = filename_jpeg.substring(0, filename_jpeg.length()-4);
-                filename_base_dng = filename_dng.substring(0, filename_dng.length()-4);
-            }
-            Log.d(TAG, "filename_base_jpeg: " + filename_base_jpeg);
-            Log.d(TAG, "filename_base_dng: " + filename_base_dng);
-            assertEquals(filename_base_jpeg, filename_base_dng);
-        }
-    }
-
-    private enum UriType {
-        MEDIASTORE_IMAGES,
-        MEDIASTORE_VIDEOS,
-        STORAGE_ACCESS_FRAMEWORK
-    }
-
-    /** Returns an array of filenames (not including full path)  of images or videos in the current
-     *  save folder, by querying the media store; or by using storage access framework on the
-     *  supplied uri.
-     */
-    private List<String> mediaFilesinSaveFolder(Uri baseUri, String bucket_id, UriType uri_type) {
-        List<String> files = new ArrayList<>();
-        final int column_name_c = 0; // filename (without path), including extension
-
-        String [] projection;
-        switch( uri_type ) {
-            case MEDIASTORE_IMAGES:
-                projection = new String[] {MediaStore.Images.ImageColumns.DISPLAY_NAME};
-                break;
-            case MEDIASTORE_VIDEOS:
-                projection = new String[] {MediaStore.Video.VideoColumns.DISPLAY_NAME};
-                break;
-            case STORAGE_ACCESS_FRAMEWORK:
-                projection = new String[] {DocumentsContract.Document.COLUMN_DISPLAY_NAME};
-                break;
-            default:
-                throw new RuntimeException("unknown uri_type: " + uri_type);
-        }
-
-        String selection = "";
-        switch( uri_type ) {
-            case MEDIASTORE_IMAGES:
-                selection = MediaStore.Images.ImageColumns.BUCKET_ID + " = " + bucket_id;
-                break;
-            case MEDIASTORE_VIDEOS:
-                selection = MediaStore.Video.VideoColumns.BUCKET_ID + " = " + bucket_id;
-                break;
-            case STORAGE_ACCESS_FRAMEWORK:
-                break;
-            default:
-                throw new RuntimeException("unknown uri_type: " + uri_type);
-        }
-        Log.d(TAG, "selection: " + selection);
-
-        Cursor cursor = mActivity.getContentResolver().query(baseUri, projection, selection, null, null);
-        if( cursor != null && cursor.moveToFirst() ) {
-            Log.d(TAG, "found: " + cursor.getCount());
-
-            do {
-                String name = cursor.getString(column_name_c);
-                files.add(name);
-            }
-            while( cursor.moveToNext() );
-        }
-
-        if( cursor != null ) {
-            cursor.close();
-        }
-
-        return files;
-    }
-
     /** Returns an array of filenames (not including full path) in the current save folder.
      */
     private String [] filesInSaveFolder() {
-        Log.d(TAG, "filesInSaveFolder");
-        if( MainActivity.useScopedStorage() ) {
-            List<String> files = new ArrayList<>();
-            if( mActivity.getStorageUtils().isUsingSAF() ) {
-                // See documentation for StorageUtils.getLatestMediaSAF() - for some reason with scoped storage when not having READ_EXTERNAL_STORAGE,
-                // we can't query the mediastore for files saved via SAF!
-                Uri treeUri = mActivity.getStorageUtils().getTreeUriSAF();
-                Uri baseUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, DocumentsContract.getTreeDocumentId(treeUri));
-                files.addAll( mediaFilesinSaveFolder(baseUri, null, UriType.STORAGE_ACCESS_FRAMEWORK) );
-            }
-            else {
-                String save_folder = mActivity.getStorageUtils().getImageFolderPath();
-                String bucket_id = String.valueOf(save_folder.toLowerCase().hashCode());
-                files.addAll( mediaFilesinSaveFolder(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, bucket_id, UriType.MEDIASTORE_IMAGES) );
-                files.addAll( mediaFilesinSaveFolder(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, bucket_id, UriType.MEDIASTORE_VIDEOS) );
-            }
-
-            if( files.size() == 0 ) {
-                return null;
-            }
-            else {
-                return files.toArray(new String[0]);
-            }
-        }
-        else {
-            File folder = mActivity.getImageFolder();
-            File [] files = folder.listFiles();
-            if( files == null )
-                return null;
-            String [] filenames = new String[files.length];
-            for(int i=0;i<files.length;i++) {
-                filenames[i] = files[i].getName();
-            }
-            return filenames;
-        }
-    }
-
-    private void checkFilesAfterTakePhoto(final boolean is_raw, final boolean test_wait_capture_result, final String [] files, final String suffix, final int max_time_s, final Date date) throws InterruptedException {
-        int n_files = files == null ? 0 : files.length;
-        String [] files2 = filesInSaveFolder();
-        int n_new_files = (files2 == null ? 0 : files2.length) - n_files;
-        Log.d(TAG, "n_new_files: " + n_new_files);
-        int exp_n_new_files = getExpNNewFiles(is_raw);
-        assertEquals(n_new_files, exp_n_new_files);
-        checkFilenames(is_raw, files, files2);
-        Thread.sleep(1500); // wait until we've scanned
-        if( test_wait_capture_result ) {
-            // if test_wait_capture_result, then it may take longer before we've scanned
-        }
-        else {
-            Log.d(TAG, "failed to scan: " + mActivity.getStorageUtils().failed_to_scan);
-            assertFalse(mActivity.getStorageUtils().failed_to_scan);
-        }
-
-        if( !mActivity.getApplicationInterface().isRawOnly() ) {
-            String saved_image_filename;
-            if( MainActivity.useScopedStorage() || mActivity.getStorageUtils().isUsingSAF() ) {
-                /*assertNotNull(mActivity.test_last_saved_imagename);
-                saved_image_filename = mActivity.test_last_saved_imagename;*/
-                assertNotNull(mActivity.test_last_saved_imageuri);
-                saved_image_filename = mActivity.getStorageUtils().getFileName(mActivity.test_last_saved_imageuri);
-            }
-            else {
-                assertNotNull(mActivity.test_last_saved_image);
-                File saved_image_file = new File(mActivity.test_last_saved_image);
-                saved_image_filename = saved_image_file.getName();
-            }
-            Log.d(TAG, "saved name: " + saved_image_filename);
-            /*Log.d(TAG, "expected name: " + expected_filename);
-            Log.d(TAG, "expected name1: " + expected_filename1);
-            assertTrue(expected_filename.equals(saved_image_file.getName()) || expected_filename1.equals(saved_image_file.getName()));*/
-            // allow for possibility that the time has passed since taking the photo
-            boolean matched = false;
-            for(int i=0;i<=max_time_s && !matched;i++) {
-                Date test_date = new Date(date.getTime() - 1000L *i);
-                String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(test_date);
-                String expected_filename = "IMG_" + timeStamp + suffix + ".jpg";
-                Log.d(TAG, "expected name: " + expected_filename);
-                if( expected_filename.equals(saved_image_filename) )
-                    matched = true;
-            }
-            assertTrue(matched);
-        }
-    }
-
-    private void postTakePhotoChecks(final boolean immersive_mode, final int exposureVisibility, final int exposureLockVisibility) {
-        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(mActivity);
-        boolean has_audio_control_button = !sharedPreferences.getString(PreferenceKeys.AudioControlPreferenceKey, "none").equals("none");
-
-        View switchCameraButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_camera);
-        View switchMultiCameraButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_multi_camera);
-        View switchVideoButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_video);
-        View exposureButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.exposure);
-        View exposureLockButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.exposure_lock);
-        View audioControlButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.audio_control);
-        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-        View trashButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.trash);
-        View shareButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.share);
-
-        // trash/share only shown when preview is paused after taking a photo
-        boolean pause_preview =  sharedPreferences.getBoolean(PreferenceKeys.PausePreviewPreferenceKey, false);
-        if( pause_preview ) {
-            assertFalse(mPreview.isPreviewStarted());
-            assertEquals(switchCameraButton.getVisibility(), View.GONE);
-            assertEquals(switchMultiCameraButton.getVisibility(), View.GONE);
-            assertEquals(switchVideoButton.getVisibility(), View.GONE);
-            assertEquals(exposureButton.getVisibility(), View.GONE);
-            assertEquals(exposureLockButton.getVisibility(), View.GONE);
-            assertEquals(audioControlButton.getVisibility(), View.GONE);
-            assertEquals(popupButton.getVisibility(), View.GONE);
-            assertEquals(trashButton.getVisibility(), View.VISIBLE);
-            assertEquals(shareButton.getVisibility(), View.VISIBLE);
-        }
-        else {
-            assertTrue(mPreview.isPreviewStarted()); // check preview restarted
-            assertEquals(switchCameraButton.getVisibility(), (mPreview.getCameraControllerManager().getNumberOfCameras() > 1 ? View.VISIBLE : View.GONE));
-            assertEquals(switchMultiCameraButton.getVisibility(), (mActivity.showSwitchMultiCamIcon() ? View.VISIBLE : View.GONE));
-            assertEquals(switchVideoButton.getVisibility(), View.VISIBLE);
-            if( !immersive_mode ) {
-                assertEquals(exposureButton.getVisibility(), exposureVisibility);
-                assertEquals(exposureLockButton.getVisibility(), exposureLockVisibility);
-            }
-            assertEquals(audioControlButton.getVisibility(), (has_audio_control_button ? View.VISIBLE : View.GONE));
-            assertEquals(popupButton.getVisibility(), View.VISIBLE);
-            assertEquals(trashButton.getVisibility(), View.GONE);
-            assertEquals(shareButton.getVisibility(), View.GONE);
-        }
+        return TestUtils.filesInSaveFolder(mActivity);
     }
 
     /*
      * Note that we pass test_wait_capture_result as a parameter rather than reading from the activity, as for some reason this sometimes resets to false?! Declaring it volatile doesn't fix the problem.
      */
     private void subTestTakePhoto(boolean locked_focus, boolean immersive_mode, boolean touch_to_focus, boolean wait_after_focus, boolean single_tap_photo, boolean double_tap_photo, boolean is_raw, boolean test_wait_capture_result) throws InterruptedException {
-        assertTrue(mPreview.isPreviewStarted());
-        assertFalse(mActivity.getApplicationInterface().getImageSaver().test_queue_blocked);
-
-        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(mActivity);
-        boolean has_thumbnail_anim = sharedPreferences.getBoolean(PreferenceKeys.ThumbnailAnimationPreferenceKey, true);
-        boolean has_audio_control_button = !sharedPreferences.getString(PreferenceKeys.AudioControlPreferenceKey, "none").equals("none");
-        boolean is_dro = mActivity.supportsDRO() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_dro");
-        boolean is_hdr = mActivity.supportsHDR() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_hdr");
-        boolean is_nr = mActivity.supportsNoiseReduction() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_noise_reduction");
-        boolean is_expo = mActivity.supportsExpoBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_expo_bracketing");
-        boolean is_focus_bracketing = mActivity.supportsFocusBracketing() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_focus_bracketing");
-        boolean is_fast_burst = mActivity.supportsFastBurst() && sharedPreferences.getString(PreferenceKeys.PhotoModePreferenceKey, "preference_photo_mode_std").equals("preference_photo_mode_fast_burst");
-        String n_expo_images_s = sharedPreferences.getString(PreferenceKeys.ExpoBracketingNImagesPreferenceKey, "3");
-        int n_expo_images = Integer.parseInt(n_expo_images_s);
-        String n_focus_bracketing_images_s = sharedPreferences.getString(PreferenceKeys.FocusBracketingNImagesPreferenceKey, "3");
-        int n_focus_bracketing_images = Integer.parseInt(n_focus_bracketing_images_s);
-        String n_fast_burst_images_s = sharedPreferences.getString(PreferenceKeys.FastBurstNImagesPreferenceKey, "5");
-        int n_fast_burst_images = Integer.parseInt(n_fast_burst_images_s);
+        Thread.sleep(500); // needed for Pixel 6 Pro with Camera 2 API
+
+        TestUtils.SubTestTakePhotoInfo info = TestUtils.getSubTestTakePhotoInfo(mActivity, immersive_mode, single_tap_photo, double_tap_photo);
+        boolean has_thumbnail_anim = info.has_thumbnail_anim;
+        boolean is_hdr = info.is_hdr;
+        boolean is_nr = info.is_nr;
+        boolean is_expo = info.is_expo;
+        int exposureVisibility = info.exposureVisibility;
+        int exposureLockVisibility = info.exposureLockVisibility;
+        String focus_value = info.focus_value;
+        String focus_value_ui = info.focus_value_ui;
+        boolean can_auto_focus = info.can_auto_focus;
+        boolean manual_can_auto_focus = info.manual_can_auto_focus;
+        boolean can_focus_area = info.can_focus_area;
 
         int saved_count_cameraTakePicture = mPreview.count_cameraTakePicture;
 
@@ -3822,54 +3334,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         int n_files = files == null ? 0 : files.length;
         Log.d(TAG, "n_files at start: " + n_files);
 
-        View switchCameraButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_camera);
-        View switchMultiCameraButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_multi_camera);
-        View switchVideoButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_video);
-        //View flashButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.flash);
-        //View focusButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.focus_mode);
-        View exposureButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.exposure);
-        View exposureLockButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.exposure_lock);
-        View audioControlButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.audio_control);
-        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-        View trashButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.trash);
-        View shareButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.share);
-        assertEquals(switchCameraButton.getVisibility(), (immersive_mode ? View.GONE : (mPreview.getCameraControllerManager().getNumberOfCameras() > 1 ? View.VISIBLE : View.GONE)));
-        assertEquals(switchMultiCameraButton.getVisibility(), (immersive_mode ? View.GONE : (mActivity.showSwitchMultiCamIcon() ? View.VISIBLE : View.GONE)));
-        assertEquals(switchVideoButton.getVisibility(), (immersive_mode ? View.GONE : View.VISIBLE));
-        int exposureVisibility = exposureButton.getVisibility();
-        int exposureLockVisibility = exposureLockButton.getVisibility();
-        assertEquals(audioControlButton.getVisibility(), ((has_audio_control_button && !immersive_mode) ? View.VISIBLE : View.GONE));
-        assertEquals(popupButton.getVisibility(), (immersive_mode ? View.GONE : View.VISIBLE));
-        assertEquals(trashButton.getVisibility(), View.GONE);
-        assertEquals(shareButton.getVisibility(), View.GONE);
-
-        String focus_value = mPreview.getCameraController().getFocusValue();
-        String focus_value_ui = mPreview.getCurrentFocusValue();
-        boolean can_auto_focus = false;
-        boolean manual_can_auto_focus = false;
-        boolean can_focus_area = false;
-        if( focus_value.equals("focus_mode_auto") || focus_value.equals("focus_mode_macro") ) {
-            can_auto_focus = true;
-        }
-
-        if( focus_value.equals("focus_mode_auto") || focus_value.equals("focus_mode_macro") ) {
-            manual_can_auto_focus = true;
-        }
-        else if( focus_value.equals("focus_mode_continuous_picture") && !single_tap_photo && !double_tap_photo ) {
-            // if single_tap_photo or double_tap_photo, and continuous mode, we go straight to taking a photo rather than doing a touch to focus
-            manual_can_auto_focus = true;
-        }
-
-        if( mPreview.getMaxNumFocusAreas() != 0 && ( focus_value.equals("focus_mode_auto") || focus_value.equals("focus_mode_macro") || focus_value.equals("focus_mode_continuous_picture") || focus_value.equals("focus_mode_continuous_video") || focus_value.equals("focus_mode_manual2") ) ) {
-            can_focus_area = true;
-        }
-        Log.d(TAG, "focus_value? " + focus_value);
-        Log.d(TAG, "can_auto_focus? " + can_auto_focus);
-        Log.d(TAG, "manual_can_auto_focus? " + manual_can_auto_focus);
-        Log.d(TAG, "can_focus_area? " + can_focus_area);
         int saved_count = mPreview.count_cameraAutoFocus;
 
-        checkFocusInitial(focus_value, focus_value_ui);
+        //checkFocusInitial(focus_value, focus_value_ui);
 
         int saved_thumbnail_count = mActivity.getApplicationInterface().getDrawPreview().test_thumbnail_anim_count;
         Log.d(TAG, "saved_thumbnail_count: " + saved_thumbnail_count);
@@ -3889,43 +3356,6 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         waitForTakePhoto();
 
-        Date date = new Date();
-        String suffix = "";
-        int max_time_s = 2;
-        if( is_dro ) {
-            suffix = "_DRO";
-        }
-        else if( is_hdr ) {
-            suffix = "_HDR";
-        }
-        else if( is_nr ) {
-            suffix = "_NR";
-            if( mActivity.getApplicationInterface().getNRModePref() == MyApplicationInterface.NRModePref.NRMODE_LOW_LIGHT )
-                max_time_s += 6; // takes longer to save low light photo
-        }
-        else if( is_expo ) {
-            suffix = "_" + (n_expo_images-1);
-        }
-        else if( is_focus_bracketing ) {
-            suffix = "_" + (n_focus_bracketing_images-1); // when focus bracketing starts from _0
-            //suffix = "_" + (n_focus_bracketing_images); // when focus bracketing starts from _1
-            max_time_s = 60; // can take much longer to save in focus bracketing mode!
-        }
-        else if( is_fast_burst ) {
-            suffix = "_" + (n_fast_burst_images-1); // when burst numbering starts from _0
-            //suffix = "_" + (n_fast_burst_images); // when burst numbering starts from _1
-            max_time_s = 4; // takes longer to save 20 images!
-        }
-
-        if( is_raw ) {
-            max_time_s += 6; // extra time needed for Nexus 6 at least
-        }
-
-        boolean pause_preview =  sharedPreferences.getBoolean(PreferenceKeys.PausePreviewPreferenceKey, false);
-        if( pause_preview ) {
-            max_time_s += 3; // need to allow longer for testTakePhotoRawWaitCaptureResult with Nexus 6 at least
-        }
-
         this.getInstrumentation().waitForIdleSync();
         Log.d(TAG, "after idle sync");
         Log.d(TAG, "take picture count: " + mPreview.count_cameraTakePicture);
@@ -3957,13 +3387,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         mActivity.waitUntilImageQueueEmpty();
         Log.d(TAG, "mActivity.hasThumbnailAnimation()?: " + mActivity.hasThumbnailAnimation());
 
-        checkFocusAfterTakePhoto(focus_value, focus_value_ui);
+        TestUtils.checkFocusAfterTakePhoto(mActivity, focus_value, focus_value_ui);
 
-        checkFilesAfterTakePhoto(is_raw, test_wait_capture_result, files, suffix, max_time_s, date);
+        TestUtils.checkFilesAfterTakePhoto(mActivity, is_raw, test_wait_capture_result, files);
 
-        checkFocusAfterTakePhoto2(touch_to_focus, single_tap_photo, double_tap_photo, test_wait_capture_result, locked_focus, can_auto_focus, can_focus_area, saved_count);
+        TestUtils.checkFocusAfterTakePhoto2(mActivity, touch_to_focus, single_tap_photo, double_tap_photo, test_wait_capture_result, locked_focus, can_auto_focus, can_focus_area, saved_count);
 
-        postTakePhotoChecks(immersive_mode, exposureVisibility, exposureLockVisibility);
+        TestUtils.postTakePhotoChecks(mActivity, immersive_mode, exposureVisibility, exposureLockVisibility);
 
         assertFalse(mActivity.getApplicationInterface().getImageSaver().test_queue_blocked);
         assertTrue( mPreview.getCameraController() == null || mPreview.getCameraController().count_camera_parameters_exception == 0 );
@@ -5049,6 +4479,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         boolean has_audio_control_button = !sharedPreferences.getString(PreferenceKeys.AudioControlPreferenceKey, "none").equals("none");
 
         Log.d(TAG, "check if preview is started");
+        Thread.sleep(500); // needed for Pixel 6 Pro with Camera 2 API
         assertTrue(mPreview.isPreviewStarted());
 
         View switchCameraButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_camera);
@@ -5202,6 +4633,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(mActivity);
         boolean has_audio_control_button = !sharedPreferences.getString(PreferenceKeys.AudioControlPreferenceKey, "none").equals("none");
 
+        Thread.sleep(500); // needed for Pixel 6 Pro with Camera 2 API
         assertTrue(mPreview.isPreviewStarted());
 
         View switchCameraButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.switch_camera);
@@ -5745,7 +5177,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         mActivity.test_have_angle = false;
     }
 
-    private void subTestTakePhotoAutoLevelAngles() {
+    private void subTestTakePhotoAutoLevelAngles() throws InterruptedException {
         Log.d(TAG, "subTestTakePhotoAutoLevelAngles");
         setToDefault();
 
@@ -5755,6 +5187,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.apply();
         updateForSettings();
 
+        Thread.sleep(500); // needed for Pixel 6 Pro with Camera 2 API
         assertTrue(mPreview.isPreviewStarted());
         assertTrue(mActivity.getApplicationInterface().getDrawPreview().getStoredAutoStabilisePref());
         final int [] angles = new int[]{0, -129, 30, -44, 61, -89, 179};
@@ -5783,7 +5216,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
     /* Tests taking photos repeatedly with auto-stabilise enabled, at various angles.
      * Tests with front and back.
      */
-    public void testTakePhotoAutoLevelAngles() {
+    public void testTakePhotoAutoLevelAngles() throws InterruptedException {
         Log.d(TAG, "testTakePhotoAutoLevel");
 
         subTestTakePhotoAutoLevelAngles();
@@ -5791,7 +5224,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
     /* As testTakePhotoAutoLevelAngles(), but with test_low_memory set.
      */
-    public void testTakePhotoAutoLevelAnglesLowMemory() {
+    public void testTakePhotoAutoLevelAnglesLowMemory() throws InterruptedException {
         Log.d(TAG, "testTakePhotoAutoLevelAnglesLowMemory");
 
         mActivity.test_low_memory = true;
@@ -5807,6 +5240,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
      * @return The number of resultant video files
      */
     private int subTestTakeVideo(boolean test_exposure_lock, boolean test_focus_area, boolean allow_failure, boolean immersive_mode, VideoTestCallback test_cb, long time_ms, boolean max_filesize, int n_non_video_files) throws InterruptedException {
+        Thread.sleep(500); // needed for Pixel 6 Pro with Camera 2 API
         assertTrue(mPreview.isPreviewStarted());
         if( mPreview.usingCamera2API() ) {
             assertEquals(mPreview.getCurrentPreviewSize().width, mPreview.getCameraController().test_texture_view_buffer_w);
@@ -6013,6 +5447,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
 
         if( mPreview.usingCamera2API() ) {
+            assertNotNull(mPreview.getCameraController());
             assertEquals(mPreview.getCurrentPreviewSize().width, mPreview.getCameraController().test_texture_view_buffer_w);
             assertEquals(mPreview.getCurrentPreviewSize().height, mPreview.getCameraController().test_texture_view_buffer_h);
         }
@@ -6868,7 +6303,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             // as this tests Android 8+'s seamless restart
             return;
         }
-        if( isEmulator() ) {
+        if( TestUtils.isEmulator() ) {
             // as test takes about 6.5 minutes on emulator (possibly due to unusual video file sizes), even though it does eventually pass
             return;
         }
@@ -6937,8 +6372,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
     }
 
     /** As testTakeVideoMaxFileSize4(), but using Storage Access Framework.
-     *  N.B., failing on Galaxy S10e Android 12 due to receiving MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED
-     *  shortly after MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING.
+     *  N.B., failing on Galaxy S10e Android 12 and Pixel 6 Pro due to receiving MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED
+     *  shortly after MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING. Seems to be issue specific to using SAF with too small
+     *  maximum file sizes.
      */
     public void testTakeVideoMaxFileSize4SAF() throws InterruptedException {
         Log.d(TAG, "testTakeVideoMaxFileSize4SAF");
@@ -7135,6 +6571,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
     }
 
     /** Will likely be unreliable on OnePlus 3T and Galaxy S10e with Camera2.
+     *  Also hangs with old camera API on Pixel 6 Pro.
      */
     public void testTakeVideoFPS() throws InterruptedException {
         Log.d(TAG, "testTakeVideoFPS");
@@ -7179,7 +6616,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
     }
 
-    /** Will likely be unreliable on OnePlus 3T and Galaxy S10e.
+    /** Will likely be unreliable on OnePlus 3T, Galaxy S10e, Pixel 6 Pro.
      *  Manual mode should be ignored by high speed video, but check this doesn't crash at least!
      */
     public void testTakeVideoFPSHighSpeedManual() throws InterruptedException {
@@ -7359,7 +6796,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         assertTrue(video_width == high_speed_video_width && video_height == high_speed_video_height);
     }
 
-    /** Will likely be unreliable on OnePlus 3T and Galaxy S10e.
+    /** Will likely be unreliable on OnePlus 3T, Galaxy S10e and Pixel 6 Pro.
      */
     public void testTakeVideoSlowMotion() throws InterruptedException {
         Log.d(TAG, "testTakeVideoSlowMotion");
@@ -7412,6 +6849,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
     /** Take video with timelapse mode.
      *  Fails on Android emulator (at least for Android 7.1 on VirtualScene camera).
+     *  Fails on Pixel 6 Pro with old camera API.
      */
     public void testTakeVideoTimeLapse() throws InterruptedException {
         Log.d(TAG, "testTakeVideoTimeLapse");
@@ -8051,10 +7489,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
                 Thread.sleep(1000); // need at least 1000ms for Nexus 7
             }
             else {
-                View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-                clickView(popupButton);
-                while( !mActivity.popupIsOpen() ) {
-                }
+                openPopupMenu();
             }
             takePhotoButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.take_photo);
             // check timer cancelled, and not yet taken a photo
@@ -8246,19 +7681,138 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             }
         }
 
-        // now open popup, pause and resume, then reopen popup
-        // this tests against a crash, if we don't remove the popup from the popup container in MainUI.destroyPopup()
-        View popupButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup);
-        assertFalse(mActivity.popupIsOpen());
-        clickView(popupButton);
-        while( !mActivity.popupIsOpen() ) {
-        }
+        // now open popup, pause and resume, then reopen popup
+        // this tests against a crash, if we don't remove the popup from the popup container in MainUI.destroyPopup()
+        openPopupMenu();
+
+        pauseAndResume();
+        openPopupMenu();
+    }
+
+    /* Tests against a bug where popup wouldn't show with left UI placement, due to 0 popup view height.
+     */
+    public void testPopupLeftLayout() {
+        Log.d(TAG, "testPopupLeftLayout");
+
+        setToDefault();
+        SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(mActivity);
+        SharedPreferences.Editor editor = settings.edit();
+        editor.putString(PreferenceKeys.UIPlacementPreferenceKey, "ui_left");
+        editor.apply();
+        updateForSettings();
+
+        View popup_view = mActivity.findViewById(net.sourceforge.opencamera.R.id.popup_container);
+
+        openPopupMenu();
+
+        int popup_width = popup_view.getWidth();
+        int popup_height = popup_view.getHeight();
+        int test_popup_width = mActivity.getMainUI().test_saved_popup_width;
+        int test_popup_height = mActivity.getMainUI().test_saved_popup_height;
+        Log.d(TAG, "popup_width: " + popup_width);
+        Log.d(TAG, "popup_height: " + popup_height);
+        Log.d(TAG, "test_popup_width: " + test_popup_width);
+        Log.d(TAG, "test_popup_height: " + test_popup_height);
+        assertTrue(popup_width > 0);
+        assertTrue(popup_height > 0);
+        assertEquals(popup_width, test_popup_width);
+        assertEquals(popup_height, test_popup_height);
+
+        // now reopen popup view, and check the same dimensions
+        closePopupMenu();
+
+        openPopupMenu();
+
+        int new_popup_width = popup_view.getWidth();
+        int new_popup_height = popup_view.getHeight();
+        test_popup_width = mActivity.getMainUI().test_saved_popup_width;
+        test_popup_height = mActivity.getMainUI().test_saved_popup_height;
+        Log.d(TAG, "new_popup_width: " + new_popup_width);
+        Log.d(TAG, "new_popup_height: " + new_popup_height);
+        Log.d(TAG, "test_popup_width: " + test_popup_width);
+        Log.d(TAG, "test_popup_height: " + test_popup_height);
+        assertEquals(popup_width, new_popup_width);
+        assertEquals(popup_height, new_popup_height);
+        assertEquals(popup_width, test_popup_width);
+        assertEquals(popup_height, test_popup_height);
+    }
+
+    /* Tests with ui_right vs ui_top layout.
+     */
+    public void testRightLayout() {
+        Log.d(TAG, "testRightLayout");
+
+        setToDefault();
+        {
+            SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(mActivity);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putString(PreferenceKeys.UIPlacementPreferenceKey, "ui_right");
+            editor.apply();
+            updateForSettings();
+        }
+
+        openPopupMenu();
+
+        Point display_size = new Point();
+        {
+            Display display = mActivity.getWindowManager().getDefaultDisplay();
+            display.getSize(display_size);
+            Log.d(TAG, "display_size: " + display_size.x + " x " + display_size.y);
+        }
+        View settingsButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.settings);
+        View galleryButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.gallery);
+
+        Log.d(TAG, "settings right: " + settingsButton.getRight());
+        Log.d(TAG, "settings top: " + settingsButton.getTop());
+        Log.d(TAG, "gallery right: " + galleryButton.getRight());
+        Log.d(TAG, "gallery top: " + galleryButton.getTop());
+
+        final float scale = mActivity.getResources().getDisplayMetrics().density;
+        int expected_gap = (int) (MainUI.privacy_indicator_gap_dp * scale + 0.5f); // convert dps to pixels;
+        if( mActivity.getSystemOrientation() == MainActivity.SystemOrientation.PORTRAIT ) {
+            assertTrue(settingsButton.getBottom() > (int)(0.8*display_size.y));
+            assertEquals(display_size.x, settingsButton.getRight());
+            // position may be 1 coordinate different on some devices, e.g., Galaxy Nexus
+            // have 14 pixel gap on Pixel 6 Pro
+            assertEquals((double)(display_size.y-1-expected_gap), (double)(galleryButton.getBottom()), 14.0+1.0e-5);
+            assertEquals(display_size.x-expected_gap, galleryButton.getRight());
+        }
+        else {
+            assertTrue(settingsButton.getRight() > (int)(0.8*display_size.x));
+            assertEquals(0, settingsButton.getTop());
+            assertEquals(display_size.x-expected_gap, galleryButton.getRight());
+            assertEquals(expected_gap, galleryButton.getTop());
+        }
+
+        {
+            SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(mActivity);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putString(PreferenceKeys.UIPlacementPreferenceKey, "ui_top");
+            editor.apply();
+            updateForSettings();
+        }
+
+        Log.d(TAG, "settings right: " + settingsButton.getRight());
+        Log.d(TAG, "settings top: " + settingsButton.getTop());
+        Log.d(TAG, "gallery right: " + galleryButton.getRight());
+        Log.d(TAG, "gallery top: " + galleryButton.getTop());
 
-        pauseAndResume();
-        assertFalse(mActivity.popupIsOpen());
-        clickView(popupButton);
-        while( !mActivity.popupIsOpen() ) {
+        if( mActivity.getSystemOrientation() == MainActivity.SystemOrientation.PORTRAIT ) {
+            assertTrue(settingsButton.getBottom() < (int)(0.2*display_size.y));
+            assertEquals(display_size.x, settingsButton.getRight());
+            // position may be 1 coordinate different on some devices, e.g., Galaxy Nexus
+            // have 14 pixel gap on Pixel 6 Pro
+            assertEquals((double)(display_size.y-1-expected_gap), (double)(galleryButton.getBottom()), 14.0+1.0e-5);
+            assertEquals(display_size.x-expected_gap, galleryButton.getRight());
+        }
+        else {
+            assertTrue(settingsButton.getRight() < (int)(0.2*display_size.x));
+            assertEquals(0, settingsButton.getTop());
+            assertEquals(display_size.x-expected_gap, galleryButton.getRight());
+            assertEquals(expected_gap, galleryButton.getTop());
         }
+
+        openPopupMenu();
     }
 
     /* Tests layout bug with popup menu.
@@ -8280,10 +7834,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
             Thread.sleep(400);
 
             // open popup
-            assertFalse(mActivity.popupIsOpen());
-            clickView(popupButton);
-            while( !mActivity.popupIsOpen() ) {
-            }
+            openPopupMenu();
 
             // check popup width is not larger than expected
             int popup_container_width = popup_container.getWidth();
@@ -8325,9 +7876,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         if( !on_timer ) {
             // open popup now
-            clickView(popupButton);
-            while( !mActivity.popupIsOpen() ) {
-            }
+            openPopupMenu();
         }
 
         View takePhotoButton = mActivity.findViewById(net.sourceforge.opencamera.R.id.take_photo);
@@ -8343,9 +7892,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
                 Thread.sleep(2000);
 
                 // now open popup
-                clickView(popupButton);
-                while( !mActivity.popupIsOpen() ) {
-                }
+                openPopupMenu();
 
                 // check timer is cancelled
                 assertFalse(mPreview.isOnTimer());
@@ -8377,9 +7924,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
                 }
                 else {
                     // now open popup again
-                    clickView(popupButton);
-                    while( !mActivity.popupIsOpen() ) {
-                    }
+                    openPopupMenu();
                     subTestPopupButtonAvailability("TEST_FLASH", "flash_off", supported_flash_values);
                     subTestPopupButtonAvailability("TEST_FLASH", "flash_auto", supported_flash_values);
                     subTestPopupButtonAvailability("TEST_FLASH", "flash_on", supported_flash_values);
@@ -8423,9 +7968,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
 
         // now open popup again
-        clickView(popupButton);
-        while( !mActivity.popupIsOpen() ) {
-        }
+        openPopupMenu();
         subTestPopupButtonAvailability();
     }
 
@@ -8922,53 +8465,8 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         assertEquals(size, new_size);
     }
 
-    /** Tests the Exif tags in the resultant file. If the file is null, the uri will be
-     *  used instead to read the Exif tags.
-     */
-    private void testExif(String file, Uri uri, boolean expect_gps) throws IOException {
-        //final String TAG_GPS_IMG_DIRECTION = "GPSImgDirection";
-        //final String TAG_GPS_IMG_DIRECTION_REF = "GPSImgDirectionRef";
-        InputStream inputStream = null;
-        ExifInterface exif;
-        if( file != null ) {
-            assertNull(uri); // should only supply one of file or uri
-            exif = new ExifInterface(file);
-        }
-        else {
-            assertNotNull(uri);
-            inputStream = getActivity().getContentResolver().openInputStream(uri);
-            exif = new ExifInterface(inputStream);
-        }
-
-        assertNotNull(exif.getAttribute(ExifInterface.TAG_ORIENTATION));
-        if( !( isEmulator() && Build.VERSION.SDK_INT <= Build.VERSION_CODES.N_MR1 ) ) {
-            // older Android emulator versions don't store exif info in photos
-            assertNotNull(exif.getAttribute(ExifInterface.TAG_MAKE));
-            assertNotNull(exif.getAttribute(ExifInterface.TAG_MODEL));
-
-            if( expect_gps ) {
-                assertNotNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
-                assertNotNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF));
-                assertNotNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
-                assertNotNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF));
-                // can't read custom tags, even though we can write them?!
-                //assertTrue(exif.getAttribute(TAG_GPS_IMG_DIRECTION) != null);
-                //assertTrue(exif.getAttribute(TAG_GPS_IMG_DIRECTION_REF) != null);
-            }
-            else {
-                assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
-                assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF));
-                assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
-                assertNull(exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF));
-                // can't read custom tags, even though we can write them?!
-                //assertTrue(exif.getAttribute(TAG_GPS_IMG_DIRECTION) == null);
-                //assertTrue(exif.getAttribute(TAG_GPS_IMG_DIRECTION_REF) == null);
-            }
-        }
-
-        if( inputStream != null ) {
-            inputStream.close();
-        }
+    private void testExif(String file, Uri uri, boolean expect_device_tags, boolean expect_datetime, boolean expect_gps) throws IOException {
+        TestUtils.testExif(getActivity(), file, uri, expect_device_tags, expect_datetime, expect_gps);
     }
 
     private void subTestLocationOn(boolean gps_direction) throws IOException {
@@ -9017,7 +8515,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         this.getInstrumentation().waitForIdleSync();
         assertEquals(1, mPreview.count_cameraTakePicture);
         mActivity.waitUntilImageQueueEmpty();
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, true);
 
         // now test with auto-stabilise
         {
@@ -9036,7 +8534,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         this.getInstrumentation().waitForIdleSync();
         assertEquals(2, mPreview.count_cameraTakePicture);
         mActivity.waitUntilImageQueueEmpty();
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, true);
 
         // switch to front camera
         if( mPreview.getCameraControllerManager().getNumberOfCameras() > 1 ) {
@@ -9130,7 +8628,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         assertNull(mActivity.getLocationSupplier().getLocation());
 
         mActivity.waitUntilImageQueueEmpty();
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, false);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, false);
 
         assertTrue(mActivity.getLocationSupplier().noLocationListeners());
         assertFalse(mActivity.getLocationSupplier().testHasReceivedLocation());
@@ -9162,7 +8660,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         assertNull(mActivity.getLocationSupplier().getLocation());
 
         mActivity.waitUntilImageQueueEmpty();
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, false);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, false);
 
         assertTrue(mActivity.getLocationSupplier().noLocationListeners());
         assertFalse(mActivity.getLocationSupplier().testHasReceivedLocation());
@@ -9450,7 +8948,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         int n_files = getNFiles() - n_old_files;
         Log.d(TAG, "n_files: " + n_files);
         assertEquals(1, n_files);
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, false);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, false);
 
         // now again with location
         {
@@ -9484,7 +8982,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         n_files = getNFiles() - n_old_files;
         Log.d(TAG, "n_files: " + n_files);
         assertEquals(2, n_files);
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, true);
 
         // now again with location and custom text
         {
@@ -9513,7 +9011,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         n_files = getNFiles() - n_old_files;
         Log.d(TAG, "n_files: " + n_files);
         assertEquals(3, n_files);
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, true);
 
         // now test with auto-stabilise
         {
@@ -9538,7 +9036,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         n_files = getNFiles() - n_old_files;
         Log.d(TAG, "n_files: " + n_files);
         assertEquals(4, n_files);
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, true);
 
         // now again with auto-stabilise angle 0
 
@@ -9556,7 +9054,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         n_files = getNFiles() - n_old_files;
         Log.d(TAG, "n_files: " + n_files);
         assertEquals(5, n_files);
-        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true);
+        testExif(mActivity.test_last_saved_image, mActivity.test_last_saved_imageuri, true, true, true);
 
         mActivity.test_have_angle = false;
     }
@@ -9779,6 +9277,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.putBoolean(PreferenceKeys.ShowZoomControlsPreferenceKey, true);
         editor.apply();
         updateForSettings();
+
         assertEquals(zoomControls.getVisibility(), View.VISIBLE);
 
         Log.d(TAG, "zoom in");
@@ -9828,6 +9327,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.putBoolean(PreferenceKeys.ShowZoomSliderControlsPreferenceKey, false);
         editor.apply();
         updateForSettings();
+
         assertEquals(zoomSeekBar.getVisibility(), View.INVISIBLE);
 
         Log.d(TAG, "zoom in");
@@ -10775,10 +10275,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         CameraController.Size old_picture_size = mPreview.getCameraController().getPictureSize();
 
         // open popup
-        assertFalse( mActivity.popupIsOpen() );
-        clickView(popupButton);
-        while( !mActivity.popupIsOpen() ) {
-        }
+        openPopupMenu();
 
         TextView photoResolutionButton = (TextView)mActivity.getUIButton("PHOTO_RESOLUTIONS");
         assertNotNull(photoResolutionButton);
@@ -10815,10 +10312,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         assertTrue(mPreview.isVideo());
 
         // open popup
-        assertFalse( mActivity.popupIsOpen() );
-        clickView(popupButton);
-        while( !mActivity.popupIsOpen() ) {
-        }
+        openPopupMenu();
 
         TextView videoResolutionButton = (TextView)mActivity.getUIButton("VIDEO_RESOLUTIONS");
         assertNotNull(videoResolutionButton);
@@ -11952,152 +11446,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         return bitmap;
     }*/
 
-    /** Converts a path to a Uri for com.android.providers.media.documents.
-     */
-    private Uri getDocumentUri(String filename) throws FileNotFoundException {
-        Log.d(TAG, "getDocumentUri: " + filename);
-
-        // convert from File path format to Storage Access Framework form
-        Uri treeUri = Uri.parse("content://com.android.externalstorage.documents/tree/primary%3ADCIM%2FtestOpenCamera");
-        Log.d(TAG, "treeUri: " + treeUri);
-        if( !filename.startsWith(images_base_path) ) {
-            Log.e(TAG, "unknown base for: " + filename);
-            throw new FileNotFoundException();
-        }
-        String stem = filename.substring(images_base_path.length());
-        Uri stemUri = Uri.parse("content://com.android.externalstorage.documents/tree/primary%3ADCIM" + stem.replace("/", "%2F"));
-        Log.d(TAG, "stem: " + stem);
-        Log.d(TAG, "stemUri: " + stemUri);
-        //String docID = "primary:DCIM" + stem;
-        String docID = DocumentsContract.getTreeDocumentId(stemUri);
-        Log.d(TAG, "docID: " + docID);
-        Uri uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, docID);
-
-        if( uri == null ) {
-            throw new FileNotFoundException();
-        }
-        return uri;
-    }
-
-    private Bitmap getBitmapFromFile(String filename) throws FileNotFoundException {
-        return getBitmapFromFile(filename, 1);
+    private Bitmap getBitmapFromFile(String filename) {
+        return TestUtils.getBitmapFromFile(mActivity, filename);
     }
 
-    /** Loads bitmap from supplied filename.
-     *  Note that on Android 10+ (with scoped storage), this uses Storage Access Framework, which
-     *  means Open Camera must have SAF permission to the folder DCIM/testOpenCamera.
-     */
-    private Bitmap getBitmapFromFile(String filename, int inSampleSize) throws FileNotFoundException {
-        Log.d(TAG, "getBitmapFromFile: " + filename);
-        BitmapFactory.Options options = new BitmapFactory.Options();
-        options.inMutable = true;
-        //options.inSampleSize = inSampleSize;
-        if( inSampleSize > 1 ) {
-            // use inDensity for better quality, as inSampleSize uses nearest neighbour
-            // see same code in ImageSaver.setBitmapOptionsSampleSize()
-            options.inDensity = inSampleSize;
-            options.inTargetDensity = 1;
-        }
-
-        Uri uri = null;
-        Bitmap bitmap;
-
-        if( MainActivity.useScopedStorage() ) {
-            uri = getDocumentUri(filename);
-            Log.d(TAG, "uri: " + uri);
-            InputStream is = mActivity.getContentResolver().openInputStream(uri);
-            bitmap = BitmapFactory.decodeStream(is, null, options);
-            try {
-                is.close();
-            }
-            catch(IOException e) {
-                e.printStackTrace();
-            }
-        }
-        else {
-            bitmap = BitmapFactory.decodeFile(filename, options);
-        }
-        if( bitmap == null )
-            throw new FileNotFoundException();
-        Log.d(TAG, "    done: " + bitmap);
-
-        // now need to take exif orientation into account, as some devices or camera apps store the orientation in the exif tag,
-        // which getBitmap() doesn't account for
-        ParcelFileDescriptor parcelFileDescriptor = null;
-        FileDescriptor fileDescriptor;
-        try {
-            ExifInterface exif = null;
-            if( uri != null ) {
-                parcelFileDescriptor = mActivity.getContentResolver().openFileDescriptor(uri, "r");
-                if( parcelFileDescriptor != null ) {
-                    fileDescriptor = parcelFileDescriptor.getFileDescriptor();
-                    exif = new ExifInterface(fileDescriptor);
-                }
-            }
-            else {
-                exif = new ExifInterface(filename);
-            }
-            if( exif != null ) {
-                int exif_orientation_s = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED);
-                boolean needs_tf = false;
-                int exif_orientation = 0;
-                // from http://jpegclub.org/exif_orientation.html
-                // and http://stackoverflow.com/questions/20478765/how-to-get-the-correct-orientation-of-the-image-selected-from-the-default-image
-                if( exif_orientation_s == ExifInterface.ORIENTATION_UNDEFINED || exif_orientation_s == ExifInterface.ORIENTATION_NORMAL ) {
-                    // leave unchanged
-                }
-                else if( exif_orientation_s == ExifInterface.ORIENTATION_ROTATE_180 ) {
-                    needs_tf = true;
-                    exif_orientation = 180;
-                }
-                else if( exif_orientation_s == ExifInterface.ORIENTATION_ROTATE_90 ) {
-                    needs_tf = true;
-                    exif_orientation = 90;
-                }
-                else if( exif_orientation_s == ExifInterface.ORIENTATION_ROTATE_270 ) {
-                    needs_tf = true;
-                    exif_orientation = 270;
-                }
-                else {
-                    // just leave unchanged for now
-                    Log.e(TAG, "    unsupported exif orientation: " + exif_orientation_s);
-                }
-                Log.d(TAG, "    exif orientation: " + exif_orientation);
-
-                if( needs_tf ) {
-                    Log.d(TAG, "    need to rotate bitmap due to exif orientation tag");
-                    Matrix m = new Matrix();
-                    m.setRotate(exif_orientation, bitmap.getWidth() * 0.5f, bitmap.getHeight() * 0.5f);
-                    Bitmap rotated_bitmap = Bitmap.createBitmap(bitmap, 0, 0,bitmap.getWidth(), bitmap.getHeight(), m, true);
-                    if( rotated_bitmap != bitmap ) {
-                        bitmap.recycle();
-                        bitmap = rotated_bitmap;
-                    }
-                }
-            }
-        }
-        catch(IOException e) {
-            e.printStackTrace();
-        }
-        finally {
-            if( parcelFileDescriptor != null ) {
-                try {
-                    parcelFileDescriptor.close();
-                }
-                catch(IOException e) {
-                    e.printStackTrace();
-                }
-            }
-        }
-        /*{
-            for(int y=0;y<bitmap.getHeight();y++) {
-                for(int x=0;x<bitmap.getWidth();x++) {
-                    int color = bitmap.getPixel(x, y);
-                    Log.d(TAG, x + "," + y + ": " + Color.red(color) + "," + Color.green(color) + "," + Color.blue(color));
-                }
-            }
-        }*/
-        return bitmap;
+    private Bitmap getBitmapFromFile(String filename, int inSampleSize) {
+        return TestUtils.getBitmapFromFile(mActivity, filename, inSampleSize);
     }
 
     /* Tests restarting a large number of times - can be useful for testing for memory/resource leaks.
@@ -12300,163 +11654,29 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
     }
 
-    private static class HistogramDetails {
-        final int min_value;
-        final int median_value;
-        final int max_value;
-
-        HistogramDetails(int min_value, int median_value, int max_value) {
-            this.min_value = min_value;
-            this.median_value = median_value;
-            this.max_value = max_value;
-        }
-    }
-
-    /** Checks for the resultant histogram.
-     *  We check that we have a single range of non-zero values.
-     * @param bitmap The bitmap to compute and check a histogram for.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
-    private HistogramDetails checkHistogram(Bitmap bitmap) {
-        int [] histogram = mActivity.getApplicationInterface().getHDRProcessor().computeHistogram(bitmap, true);
-        assertEquals(256, histogram.length);
-        int total = 0;
-        for(int i=0;i<histogram.length;i++) {
-            Log.d(TAG, "histogram[" + i + "]: " + histogram[i]);
-            total += histogram[i];
-        }
-        Log.d(TAG, "total: " + total);
-        boolean started = false;
-        int min_value = -1, median_value = -1, max_value = -1;
-        int count = 0;
-        int middle = total/2;
-        for(int i=0;i<histogram.length;i++) {
-            int value = histogram[i];
-            if( !started ) {
-                started = value != 0;
-            }
-            if( value != 0 ) {
-                if( min_value == -1 )
-                    min_value = i;
-                max_value = i;
-                count += value;
-                if( count >= middle && median_value == -1 )
-                    median_value = i;
-            }
-        }
-        Log.d(TAG, "min_value: " + min_value);
-        Log.d(TAG, "median_value: " + median_value);
-        Log.d(TAG, "max_value: " + max_value);
-        return new HistogramDetails(min_value, median_value, max_value);
+    private TestUtils.HistogramDetails checkHistogram(Bitmap bitmap) {
+        return TestUtils.checkHistogram(mActivity, bitmap);
     }
 
-    private HistogramDetails subTestHDR(List<Bitmap> inputs, String output_name, boolean test_dro, int iso, long exposure_time) throws IOException, InterruptedException {
-        return subTestHDR(inputs, output_name, test_dro, iso, exposure_time, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_REINHARD);
+    private TestUtils.HistogramDetails subTestHDR(List<Bitmap> inputs, String output_name, boolean test_dro, int iso, long exposure_time) {
+        return TestUtils.subTestHDR(mActivity, inputs, output_name, test_dro, iso, exposure_time);
     }
 
-    /** The following testHDRX tests test the HDR algorithm on a given set of input images.
-     *  By testing on a fixed sample, this makes it easier to finetune the HDR algorithm for quality and performance.
-     *  To use these tests, the testdata/ subfolder should be manually copied to the test device in the DCIM/testOpenCamera/
-     *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
-     *  time to transfer to the device everytime we run the tests.
-     * @param iso The ISO of the middle image (for testing Open Camera's "smart" contrast enhancement). If set to -1, then use "always" contrast enhancement.
-     * @param exposure_time The exposure time of the middle image (for testing Open Camera's "smart" contrast enhancement)
-     */
-    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
-    private HistogramDetails subTestHDR(List<Bitmap> inputs, String output_name, boolean test_dro, int iso, long exposure_time, HDRProcessor.TonemappingAlgorithm tonemapping_algorithm) throws IOException, InterruptedException {
-        Log.d(TAG, "subTestHDR");
-
-        if( Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP ) {
-            Log.d(TAG, "renderscript requires Android Lollipop or better");
-            return null;
-        }
-
-        Thread.sleep(1000); // wait for camera to open
-
-        Bitmap dro_bitmap_in = null;
-        if( test_dro ) {
-            // save copy of input bitmap to also test DRO (since the HDR routine will free the inputs)
-            int mid = (inputs.size()-1)/2;
-            dro_bitmap_in = inputs.get(mid);
-            dro_bitmap_in = dro_bitmap_in.copy(dro_bitmap_in.getConfig(), true);
-        }
-
-        HistogramDetails hdrHistogramDetails = null;
-        if( inputs.size() > 1 ) {
-            String preference_hdr_contrast_enhancement = (iso==-1) ? "preference_hdr_contrast_enhancement_always" : "preference_hdr_contrast_enhancement_smart";
-    		float hdr_alpha = ImageSaver.getHDRAlpha(preference_hdr_contrast_enhancement, exposure_time, inputs.size());
-            long time_s = System.currentTimeMillis();
-            try {
-                mActivity.getApplicationInterface().getHDRProcessor().processHDR(inputs, true, null, true, null, hdr_alpha, 4, true, tonemapping_algorithm, HDRProcessor.DROTonemappingAlgorithm.DROALGORITHM_GAINGAMMA);
-            }
-            catch(HDRProcessorException e) {
-                e.printStackTrace();
-                throw new RuntimeException();
-            }
-            Log.d(TAG, "HDR time: " + (System.currentTimeMillis() - time_s));
-
-            saveBitmap(inputs.get(0), output_name);
-            hdrHistogramDetails = checkHistogram(inputs.get(0));
-        }
-        inputs.get(0).recycle();
-        inputs.clear();
-
-        if( test_dro ) {
-            inputs.add(dro_bitmap_in);
-            long time_s = System.currentTimeMillis();
-            try {
-                mActivity.getApplicationInterface().getHDRProcessor().processHDR(inputs, true, null, true, null, 0.5f, 4, true, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_REINHARD, HDRProcessor.DROTonemappingAlgorithm.DROALGORITHM_GAINGAMMA);
-            }
-            catch(HDRProcessorException e) {
-                e.printStackTrace();
-                throw new RuntimeException();
-            }
-            Log.d(TAG, "DRO time: " + (System.currentTimeMillis() - time_s));
-
-            saveBitmap(inputs.get(0), "dro" + output_name);
-            checkHistogram(inputs.get(0));
-            inputs.get(0).recycle();
-            inputs.clear();
-        }
-        Thread.sleep(500);
-
-        return hdrHistogramDetails;
+    private TestUtils.HistogramDetails subTestHDR(List<Bitmap> inputs, String output_name, boolean test_dro, int iso, long exposure_time, HDRProcessor.TonemappingAlgorithm tonemapping_algorithm/*, HDRTestCallback test_callback*/) {
+        return TestUtils.subTestHDR(mActivity, inputs, output_name, test_dro, iso, exposure_time, tonemapping_algorithm);
     }
 
     private void checkHDROffsets(int [] exp_offsets_x, int [] exp_offsets_y) {
-        checkHDROffsets(exp_offsets_x, exp_offsets_y, 1);
+        TestUtils.checkHDROffsets(mActivity, exp_offsets_x, exp_offsets_y);
     }
 
-    /** Checks that the HDR offsets used for auto-alignment are as expected.
-     */
     private void checkHDROffsets(int [] exp_offsets_x, int [] exp_offsets_y, int scale) {
-        int [] offsets_x = mActivity.getApplicationInterface().getHDRProcessor().offsets_x;
-        int [] offsets_y = mActivity.getApplicationInterface().getHDRProcessor().offsets_y;
-        for(int i=0;i<offsets_x.length;i++) {
-            Log.d(TAG, "offsets " + i + " ( " + offsets_x[i]*scale + " , " + offsets_y[i]*scale + " ), expected ( " + exp_offsets_x[i] + " , " + exp_offsets_y[i] + " )");
-            // we allow some tolerance as different devices can produce different results (e.g., Nexus 6 vs OnePlus 3T; see testHDR5 on Nexus 6)
-            assertTrue(Math.abs(offsets_x[i]*scale - exp_offsets_x[i]) <= 1);
-            assertTrue(Math.abs(offsets_y[i]*scale - exp_offsets_y[i]) <= 1);
-        }
-    }
-
-    private void checkHistogramDetails(HistogramDetails hdrHistogramDetails, int exp_min_value, int exp_median_value, int exp_max_value) {
-        Log.d(TAG, "checkHistogramDetails");
-        Log.d(TAG, "compare min value " + hdrHistogramDetails.min_value + " to expected " + exp_min_value);
-        Log.d(TAG, "compare median value " + hdrHistogramDetails.median_value + " to expected " + exp_median_value);
-        Log.d(TAG, "compare max value " + hdrHistogramDetails.max_value + " to expected " + exp_max_value);
-        // we allow some tolerance as different devices can produce different results (e.g., Nexus 6 vs OnePlus 3T; see testHDR18 on Nexus 6 which needs a tolerance of 2)
-        // interestingly it's testHDR18 that also needs a higher tolerance for Nokia 8 vs Galaxy S10e
-        assertTrue(Math.abs(exp_min_value - hdrHistogramDetails.min_value) <= 3);
-        assertTrue(Math.abs(exp_median_value - hdrHistogramDetails.median_value) <= 3);
-        assertTrue(Math.abs(exp_max_value - hdrHistogramDetails.max_value) <= 3);
-    }
-
-    final private String images_base_path = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getAbsolutePath();
-    final private String hdr_images_path = images_base_path + "/testOpenCamera/testdata/hdrsamples/";
-    final private String avg_images_path = images_base_path + "/testOpenCamera/testdata/avgsamples/";
-    final private String logprofile_images_path = images_base_path + "/testOpenCamera/testdata/logprofilesamples/";
-    final private String panorama_images_path = images_base_path + "/testOpenCamera/testdata/panoramasamples/";
+        TestUtils.checkHDROffsets(mActivity, exp_offsets_x, exp_offsets_y, scale);
+    }
+
+    private static void checkHistogramDetails(TestUtils.HistogramDetails hdrHistogramDetails, int exp_min_value, int exp_median_value, int exp_max_value) {
+        TestUtils.checkHistogramDetails(hdrHistogramDetails, exp_min_value, exp_median_value, exp_max_value);
+    }
 
     /** Tests HDR algorithm on test samples "saintpaul".
      */
@@ -12467,12 +11687,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "saintpaul/input2.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "saintpaul/input3.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "saintpaul/input4.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "saintpaul/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "saintpaul/input3.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "saintpaul/input4.jpg") );
 
         // actual ISO unknown, so guessing
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR1_output.jpg", false, 1600, 1000000000L);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR1_output.jpg", false, 1600, 1000000000L);
 
         int [] exp_offsets_x = {0, 0, 0};
         int [] exp_offsets_y = {0, 0, 0};
@@ -12494,13 +11714,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "saintpaul/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "saintpaul/input2.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "saintpaul/input3.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "saintpaul/input4.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "saintpaul/input5.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "saintpaul/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "saintpaul/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "saintpaul/input3.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "saintpaul/input4.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "saintpaul/input5.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR1_exp5_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR1_exp5_output.jpg", false, -1, -1);
 
         int [] exp_offsets_x = {0, 0, 0, 0, 0};
         int [] exp_offsets_y = {0, 0, 0, 0, 0};
@@ -12519,9 +11739,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "stlouis/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "stlouis/input2.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "stlouis/input3.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "stlouis/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "stlouis/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "stlouis/input3.jpg") );
 
         // actual ISO unknown, so guessing
         subTestHDR(inputs, "testHDR2_output.jpg", false, 1600, (long)(1000000000L*2.5));
@@ -12540,11 +11760,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR3/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR3/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR3/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR3/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR3/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR3/input2.jpg") );
         
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR3_output.jpg", false, 40, 1000000000L/680);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR3_output.jpg", false, 40, 1000000000L/680);
 
         int [] exp_offsets_x = {0, 0, 0};
         int [] exp_offsets_y = {1, 0, -1};
@@ -12564,9 +11784,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR4/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR4/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR4/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR4/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR4/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR4/input2.jpg") );
         
         subTestHDR(inputs, "testHDR4_output.jpg", true, 102, 1000000000L/60);
 
@@ -12584,9 +11804,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR5/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR5/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR5/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR5/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR5/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR5/input2.jpg") );
         
         subTestHDR(inputs, "testHDR5_output.jpg", false, 40, 1000000000L/398);
 
@@ -12608,9 +11828,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR6/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR6/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR6/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR6/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR6/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR6/input2.jpg") );
         
         subTestHDR(inputs, "testHDR6_output.jpg", false, 40, 1000000000L/2458);
 
@@ -12628,9 +11848,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR7/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR7/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR7/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR7/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR7/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR7/input2.jpg") );
         
         subTestHDR(inputs, "testHDR7_output.jpg", false, 40, 1000000000L/538);
 
@@ -12648,9 +11868,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR8/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR8/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR8/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR8/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR8/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR8/input2.jpg") );
         
         subTestHDR(inputs, "testHDR8_output.jpg", false, 40, 1000000000L/148);
 
@@ -12668,9 +11888,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR9/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR9/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR9/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR9/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR9/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR9/input2.jpg") );
         
         subTestHDR(inputs, "testHDR9_output.jpg", false, 40, 1000000000L/1313);
 
@@ -12688,9 +11908,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR10/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR10/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR10/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR10/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR10/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR10/input2.jpg") );
         
         subTestHDR(inputs, "testHDR10_output.jpg", false, 107, 1000000000L/120);
 
@@ -12708,11 +11928,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR11/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR11/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR11/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR11/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR11/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR11/input2.jpg") );
         
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR11_output.jpg", true, 40, 1000000000L/2662);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR11_output.jpg", true, 40, 1000000000L/2662);
 
         int [] exp_offsets_x = {-2, 0, 1};
         int [] exp_offsets_y = {1, 0, -1};
@@ -12732,9 +11952,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR12/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR12/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR12/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR12/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR12/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR12/input2.jpg") );
         
         subTestHDR(inputs, "testHDR12_output.jpg", true, 1196, 1000000000L/12);
 
@@ -12752,9 +11972,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR13/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR13/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR13/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR13/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR13/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR13/input2.jpg") );
         
         subTestHDR(inputs, "testHDR13_output.jpg", false, 323, 1000000000L/24);
 
@@ -12772,9 +11992,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR14/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR14/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR14/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR14/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR14/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR14/input2.jpg") );
         
         subTestHDR(inputs, "testHDR14_output.jpg", false, 40, 1000000000L/1229);
 
@@ -12792,9 +12012,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR15/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR15/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR15/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR15/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR15/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR15/input2.jpg") );
         
         subTestHDR(inputs, "testHDR15_output.jpg", false, 40, 1000000000L/767);
 
@@ -12812,9 +12032,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR16/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR16/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR16/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR16/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR16/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR16/input2.jpg") );
         
         subTestHDR(inputs, "testHDR16_output.jpg", false, 52, 1000000000L/120);
 
@@ -12832,9 +12052,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR17/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR17/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR17/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR17/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR17/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR17/input2.jpg") );
         
         subTestHDR(inputs, "testHDR17_output.jpg", true, 557, 1000000000L/12);
 
@@ -12856,11 +12076,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR18/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR18/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR18/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR18/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR18/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR18/input2.jpg") );
         
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR18_output.jpg", true, 100, 1000000000L/800);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR18_output.jpg", true, 100, 1000000000L/800);
 
         int [] exp_offsets_x = {0, 0, 0};
         int [] exp_offsets_y = {0, 0, 0};
@@ -12881,9 +12101,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR19/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR19/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR19/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR19/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR19/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR19/input2.jpg") );
         
         subTestHDR(inputs, "testHDR19_output.jpg", true, 100, 1000000000L/160);
 
@@ -12901,9 +12121,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR20/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR20/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR20/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR20/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR20/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR20/input2.jpg") );
         
         subTestHDR(inputs, "testHDR20_output.jpg", true, 100, 1000000000L*2);
 
@@ -12921,9 +12141,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR21/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR21/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR21/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR21/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR21/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR21/input2.jpg") );
 
         // ISO and exposure unknown, so guessing
         subTestHDR(inputs, "testHDR21_output.jpg", true, 800, 1000000000L/12);
@@ -12942,9 +12162,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR22/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR22/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR22/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR22/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR22/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR22/input2.jpg") );
         
         subTestHDR(inputs, "testHDR22_output.jpg", true, 391, 1000000000L/12);
 
@@ -12966,10 +12186,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0068.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0064.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp2_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp2_output.jpg", false, -1, -1);
 
         int [] exp_offsets_x = {0, 0};
         int [] exp_offsets_y = {0, 0};
@@ -12988,10 +12208,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0070.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0062.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp2b_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp2b_output.jpg", false, -1, -1);
 
         int [] exp_offsets_x = {0, 0};
         int [] exp_offsets_y = {0, 0};
@@ -13007,12 +12227,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0068.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0066.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0064.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0066.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
 
         // ISO unknown, so guessing
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_output.jpg", false, 1600, 1000000000L);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_output.jpg", false, 1600, 1000000000L);
 
         int [] exp_offsets_x = {0, 0, 0};
         int [] exp_offsets_y = {0, 0, 0};
@@ -13032,12 +12252,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0070.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0068.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0064.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0062.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp4_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp4_output.jpg", false, -1, -1);
 
         int [] exp_offsets_x = {0, 0, 0, 0};
         int [] exp_offsets_y = {0, 0, 0, 0};
@@ -13056,13 +12276,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0070.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0068.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0066.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0064.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0062.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0066.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp5_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp5_output.jpg", false, -1, -1);
 
         int [] exp_offsets_x = {0, 0, 0, 0, 0};
         int [] exp_offsets_y = {0, 0, 0, 0, 0};
@@ -13082,14 +12302,14 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0072.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0070.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0068.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0064.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0062.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0061.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0072.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0061.png") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp6_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp6_output.jpg", false, -1, -1);
 
         int [] exp_offsets_x = {0, 0, 0, 0, 0, 0};
         int [] exp_offsets_y = {0, 0, 0, 0, 0, 0};
@@ -13108,15 +12328,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0072.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0070.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0068.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0066.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0064.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0062.png") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR23/memorial0061.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0072.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0070.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0068.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0066.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0064.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0062.png") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR23/memorial0061.png") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp7_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR23_exp7_output.jpg", false, -1, -1);
 
         int [] exp_offsets_x = {0, 0, 0, 0, 0, 0, 0};
         int [] exp_offsets_y = {0, 0, 0, 0, 0, 0, 0};
@@ -13136,9 +12356,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR24/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR24/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR24/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR24/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR24/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR24/input2.jpg") );
         
         subTestHDR(inputs, "testHDR24_output.jpg", true, 40, 1000000000L/422);
 
@@ -13156,9 +12376,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR25/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR25/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR25/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR25/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR25/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR25/input2.jpg") );
         
         subTestHDR(inputs, "testHDR25_output.jpg", true, 40, 1000000000L/1917);
 
@@ -13176,11 +12396,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR26/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR26/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR26/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR26/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR26/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR26/input2.jpg") );
         
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR26_output.jpg", true, 40, 1000000000L/5325);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR26_output.jpg", true, 40, 1000000000L/5325);
 
         int [] exp_offsets_x = {-1, 0, 1};
         int [] exp_offsets_y = {1, 0, -1};
@@ -13199,9 +12419,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR27/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR27/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR27/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR27/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR27/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR27/input2.jpg") );
         
         subTestHDR(inputs, "testHDR27_output.jpg", true, 40, 1000000000L/949);
 
@@ -13219,9 +12439,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR28/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR28/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR28/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR28/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR28/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR28/input2.jpg") );
         
         subTestHDR(inputs, "testHDR28_output.jpg", true, 294, 1000000000L/20);
 
@@ -13239,9 +12459,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR29/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR29/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR29/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR29/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR29/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR29/input2.jpg") );
         
         subTestHDR(inputs, "testHDR29_output.jpg", false, 40, 1000000000L/978);
 
@@ -13259,9 +12479,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR30/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR30/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR30/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR30/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR30/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR30/input2.jpg") );
 
         subTestHDR(inputs, "testHDR30_output.jpg", false, 40, 1000000000L/978);
 
@@ -13283,9 +12503,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR31/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR31/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR31/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR31/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR31/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR31/input2.jpg") );
 
         subTestHDR(inputs, "testHDR31_output.jpg", false, 40, 1000000000L/422);
 
@@ -13307,11 +12527,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR32/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR32/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR32/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR32/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR32/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR32/input2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR32_output.jpg", true, 40, 1000000000L/1331);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR32_output.jpg", true, 40, 1000000000L/1331);
 
         int [] exp_offsets_x = {1, 0, 0};
         int [] exp_offsets_y = {13, 0, -10};
@@ -13332,9 +12552,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR33/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR33/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR33/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR33/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR33/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR33/input2.jpg") );
 
         subTestHDR(inputs, "testHDR33_output.jpg", true, 40, 1000000000L/354);
 
@@ -13352,9 +12572,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR34/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR34/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR34/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR34/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR34/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR34/input2.jpg") );
 
         subTestHDR(inputs, "testHDR34_output.jpg", true, 40, 1000000000L/4792);
 
@@ -13372,9 +12592,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR35/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR35/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR35/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR35/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR35/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR35/input2.jpg") );
 
         subTestHDR(inputs, "testHDR35_output.jpg", true, 40, 1000000000L/792);
 
@@ -13392,9 +12612,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR36/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR36/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR36/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR36/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR36/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR36/input2.jpg") );
 
         subTestHDR(inputs, "testHDR36_output.jpg", false, 100, 1000000000L/1148);
 
@@ -13412,9 +12632,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR37/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR37/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR37/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR37/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR37/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR37/input2.jpg") );
 
         subTestHDR(inputs, "testHDR37_output.jpg", false, 46, 1000000000L/120);
 
@@ -13433,11 +12653,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR38/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR38/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR38/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR38/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR38/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR38/input2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR38_filmic_output.jpg", false, 125, 1000000000L/2965, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_FILMIC);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR38_filmic_output.jpg", false, 125, 1000000000L/2965, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_FU2);
 
         int [] exp_offsets_x = {-1, 0, 0};
         int [] exp_offsets_y = {0, 0, 0};
@@ -13456,11 +12676,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR39/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR39/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR39/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR39/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR39/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR39/input2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR39_output.jpg", false, 125, 1000000000L/2135);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR39_output.jpg", false, 125, 1000000000L/2135);
 
         int [] exp_offsets_x = {-6, 0, -2};
         int [] exp_offsets_y = {6, 0, -8};
@@ -13478,11 +12698,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR40_output.jpg", false, 50, 1000000000L/262);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR40_output.jpg", false, 50, 1000000000L/262);
 
         int [] exp_offsets_x = {5, 0, -2};
         int [] exp_offsets_y = {13, 0, 24};
@@ -13500,11 +12720,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR40_exponential_output.jpg", false, 50, 1000000000L/262, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_EXPONENTIAL);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR40_exponential_output.jpg", false, 50, 1000000000L/262, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_EXPONENTIAL);
 
         int [] exp_offsets_x = {5, 0, -2};
         int [] exp_offsets_y = {13, 0, 24};
@@ -13522,11 +12742,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR40/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR40/input2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR40_filmic_output.jpg", false, 50, 1000000000L/262, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_FILMIC);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR40_filmic_output.jpg", false, 50, 1000000000L/262, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_FU2);
 
         int [] exp_offsets_x = {5, 0, -2};
         int [] exp_offsets_y = {13, 0, 24};
@@ -13544,9 +12764,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR41/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR41/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR41/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR41/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR41/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR41/input2.jpg") );
 
         subTestHDR(inputs, "testHDR41_output.jpg", false, 925, 1000000000L/25);
     }
@@ -13560,9 +12780,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR42/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR42/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR42/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR42/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR42/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR42/input2.jpg") );
 
         subTestHDR(inputs, "testHDR42_output.jpg", false, 112, 1000000000L/679);
     }
@@ -13576,9 +12796,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR43/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR43/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR43/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR43/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR43/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR43/input2.jpg") );
 
         subTestHDR(inputs, "testHDR43_output.jpg", false, 1196, 1000000000L/12);
     }
@@ -13592,9 +12812,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR44/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR44/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR44/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR44/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR44/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR44/input2.jpg") );
 
         subTestHDR(inputs, "testHDR44_output.jpg", false, 100, 1000000000L/1016);
     }
@@ -13608,13 +12828,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6314.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6312.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6310.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6309.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6311.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6313.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6315.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6314.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6312.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6310.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6309.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6311.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6313.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6315.jpg") );
 
         // ISO 100, exposure time 2s, but pass in -1 since these are HDRNTests
         subTestHDR(inputs, "testHDR45_output.jpg", false, -1, -1);
@@ -13629,15 +12849,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6314.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6312.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6310.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6309.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6311.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6313.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6315.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6314.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6312.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6310.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6309.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6311.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6313.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6315.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR45_exp5_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR45_exp5_output.jpg", false, -1, -1);
     }
 
     /** Tests HDR algorithm on test samples "testHDR45".
@@ -13649,15 +12869,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6314.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6312.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6310.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6309.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6311.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6313.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR45/IMG_6315.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6314.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6312.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6310.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6309.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6311.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6313.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR45/IMG_6315.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR45_exp7_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR45_exp7_output.jpg", false, -1, -1);
     }
 
     /** Tests HDR algorithm on test samples "testHDR46".
@@ -13669,12 +12889,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 06.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 05.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 04.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 03.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 02.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 01.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 06.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 05.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 04.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 03.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 02.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 01.jpg") );
 
         // ISO 100, exposure time 1/60s, but pass in -1 since these are HDRNTests
         subTestHDR(inputs, "testHDR46_output.jpg", false, -1, -1);
@@ -13689,14 +12909,14 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 06.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 05.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 04.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 03.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 02.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR46/Izmir Harbor - ppw - 01.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 06.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 05.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 04.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 03.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 02.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR46/Izmir Harbor - ppw - 01.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR46_exp5_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR46_exp5_output.jpg", false, -1, -1);
     }
 
     /** Tests HDR algorithm on test samples "testHDR47".
@@ -13709,8 +12929,8 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
 
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
 
         subTestHDR(inputs, "testHDR47_exp2_output.jpg", false, -1, -1);
     }
@@ -13725,14 +12945,14 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
 
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
 
         // ISO 400, exposure time 1/60s, but pass in -1 since these are HDRNTests
         subTestHDR(inputs, "testHDR47_output.jpg", false, -1, -1);
@@ -13747,16 +12967,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR47_exp5_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR47_exp5_output.jpg", false, -1, -1);
 
         checkHistogramDetails(hdrHistogramDetails, 1, 73, 255);
     }
@@ -13770,16 +12990,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 08.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 07.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 06.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 05.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 04.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 03.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 02.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR47/High Five - ppw - 01.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR47_exp7_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR47_exp7_output.jpg", false, -1, -1);
 
         checkHistogramDetails(hdrHistogramDetails, 1, 73, 255);
     }
@@ -13794,11 +13014,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
 
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input2.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input3.jpg") );
-        //inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input4.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input3.jpg") );
+        //inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input4.jpg") );
 
         // ISO 100, exposure time 1/716s, but pass in -1 since these are HDRNTests
         subTestHDR(inputs, "testHDR48_output.jpg", false, -1, -1);
@@ -13814,13 +13034,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
 
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input2.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input3.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR48/input4.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input3.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR48/input4.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR48_exp5_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR48_exp5_output.jpg", false, -1, -1);
 
         checkHistogramDetails(hdrHistogramDetails, 0, 59, 241);
     }
@@ -13834,10 +13054,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input3.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input3.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR49_exp2_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR49_exp2_output.jpg", false, -1, -1);
 
         checkHistogramDetails(hdrHistogramDetails, 0, 92, 250);
     }
@@ -13851,12 +13071,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input2.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input3.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input3.jpg") );
 
         // ISO 100, exposure time 1/417s, but pass in -1 since these are HDRNTests
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR49_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR49_output.jpg", false, -1, -1);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
         checkHistogramDetails(hdrHistogramDetails, 0, 81, 254);
@@ -13871,12 +13091,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input3.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input4.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input3.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input4.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR49_exp4_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR49_exp4_output.jpg", false, -1, -1);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 100, 245);
         checkHistogramDetails(hdrHistogramDetails, 0, 94, 244);
@@ -13891,13 +13111,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input2.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input3.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR49/input4.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input3.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR49/input4.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR49_exp5_output.jpg", false, -1, -1);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR49_exp5_output.jpg", false, -1, -1);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 72, 244);
         checkHistogramDetails(hdrHistogramDetails, 0, 78, 243);
@@ -13912,11 +13132,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR50/IMG_20180626_221357_0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR50/IMG_20180626_221357_1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR50/IMG_20180626_221357_2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR50/IMG_20180626_221357_0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR50/IMG_20180626_221357_1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR50/IMG_20180626_221357_2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR50_output.jpg", false, 867, 1000000000L/14);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR50_output.jpg", false, 867, 1000000000L/14);
 
         checkHistogramDetails(hdrHistogramDetails, 0, 69, 255);
     }
@@ -13930,11 +13150,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR51/IMG_20180323_104702_0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR51/IMG_20180323_104702_1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR51/IMG_20180323_104702_2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR51/IMG_20180323_104702_0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR51/IMG_20180323_104702_1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR51/IMG_20180323_104702_2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR51_output.jpg", true, 1600, 1000000000L/11);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR51_output.jpg", true, 1600, 1000000000L/11);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
     }
@@ -13948,11 +13168,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR52/IMG_20181023_143633_EXP0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR52/IMG_20181023_143633_EXP1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR52/IMG_20181023_143633_EXP2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR52/IMG_20181023_143633_EXP0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR52/IMG_20181023_143633_EXP1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR52/IMG_20181023_143633_EXP2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR52_output.jpg", false, 100, 1000000000L/2105);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR52_output.jpg", false, 100, 1000000000L/2105);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
     }
@@ -13966,11 +13186,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR53/IMG_20181106_135411_EXP0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR53/IMG_20181106_135411_EXP1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR53/IMG_20181106_135411_EXP2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR53/IMG_20181106_135411_EXP0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR53/IMG_20181106_135411_EXP1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR53/IMG_20181106_135411_EXP2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR53_output.jpg", false, 103, 1000000000L/5381);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR53_output.jpg", false, 103, 1000000000L/5381);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 55, 254);
         checkHistogramDetails(hdrHistogramDetails, 0, 64, 255);
@@ -13985,11 +13205,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR54/IMG_20181107_115508_EXP0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR54/IMG_20181107_115508_EXP1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR54/IMG_20181107_115508_EXP2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR54/IMG_20181107_115508_EXP0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR54/IMG_20181107_115508_EXP1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR54/IMG_20181107_115508_EXP2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR54_output.jpg", false, 752, 1000000000L/14);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR54_output.jpg", false, 752, 1000000000L/14);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
     }
@@ -14003,11 +13223,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR55/IMG_20181107_115608_EXP0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR55/IMG_20181107_115608_EXP1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR55/IMG_20181107_115608_EXP2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR55/IMG_20181107_115608_EXP0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR55/IMG_20181107_115608_EXP1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR55/IMG_20181107_115608_EXP2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR55_output.jpg", false, 1505, 1000000000L/10);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR55_output.jpg", false, 1505, 1000000000L/10);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
     }
@@ -14021,11 +13241,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR56/180502_141722_OC_0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR56/180502_141722_OC_1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR56/180502_141722_OC_2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR56/180502_141722_OC_0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR56/180502_141722_OC_1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR56/180502_141722_OC_2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR56_output.jpg", false, 50, 1000000000L/40);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR56_output.jpg", false, 50, 1000000000L/40);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
     }
@@ -14039,11 +13259,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR57/IMG_20181119_145313_EXP0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR57/IMG_20181119_145313_EXP1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR57/IMG_20181119_145313_EXP2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR57/IMG_20181119_145313_EXP0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR57/IMG_20181119_145313_EXP1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR57/IMG_20181119_145313_EXP2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR57_output.jpg", true, 100, 1000000000L/204);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR57_output.jpg", true, 100, 1000000000L/204);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
     }
@@ -14057,11 +13277,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR58/IMG_20190911_210146_0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR58/IMG_20190911_210146_1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR58/IMG_20190911_210146_2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR58/IMG_20190911_210146_0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR58/IMG_20190911_210146_1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR58/IMG_20190911_210146_2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR58_output.jpg", false, 1250, 1000000000L/10);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR58_output.jpg", false, 1250, 1000000000L/10);
         //HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR58_output.jpg", false, 1250, 1000000000L/10, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_CLAMP);
 
         checkHistogramDetails(hdrHistogramDetails, 11, 119, 255);
@@ -14076,11 +13296,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR59/IMG_20190911_210154_0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR59/IMG_20190911_210154_1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR59/IMG_20190911_210154_2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR59/IMG_20190911_210154_0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR59/IMG_20190911_210154_1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR59/IMG_20190911_210154_2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR59_output.jpg", false, 1250, 1000000000L/10);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR59_output.jpg", false, 1250, 1000000000L/10);
         //HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR59_output.jpg", false, 1250, 1000000000L/10, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_CLAMP);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
@@ -14095,11 +13315,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR60/IMG_20200507_020319_0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR60/IMG_20200507_020319_1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR60/IMG_20200507_020319_2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR60/IMG_20200507_020319_0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR60/IMG_20200507_020319_1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR60/IMG_20200507_020319_2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR60_output.jpg", false, 491, 1000000000L/10);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR60_output.jpg", false, 491, 1000000000L/10);
         //HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR60_output.jpg", false, 491, 1000000000L/10, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_CLAMP);
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 75, 255);
@@ -14114,11 +13334,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR61/IMG_20191111_145230_0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR61/IMG_20191111_145230_1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDR61/IMG_20191111_145230_2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR61/IMG_20191111_145230_0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR61/IMG_20191111_145230_1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDR61/IMG_20191111_145230_2.jpg") );
 
-        HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR61_output.jpg", false, 50, 1000000000L/5025);
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestHDR(inputs, "testHDR61_output.jpg", false, 50, 1000000000L/5025);
 
         checkHistogramDetails(hdrHistogramDetails, 0, 86, 254);
 
@@ -14138,9 +13358,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDRtemp/input0.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDRtemp/input1.jpg") );
-        inputs.add( getBitmapFromFile(hdr_images_path + "testHDRtemp/input2.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDRtemp/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDRtemp/input1.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.hdr_images_path + "testHDRtemp/input2.jpg") );
         
         subTestHDR(inputs, "testHDRtemp_output.jpg", true, 100, 1000000000L/100);
     }
@@ -14155,7 +13375,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(avg_images_path + "testAvg3/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.avg_images_path + "testAvg3/input0.jpg") );
 
         subTestHDR(inputs, "testDRODark0_output.jpg", true, -1, -1);
     }
@@ -14170,7 +13390,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<Bitmap> inputs = new ArrayList<>();
-        inputs.add( getBitmapFromFile(avg_images_path + "testAvg8/input0.jpg") );
+        inputs.add( getBitmapFromFile(TestUtils.avg_images_path + "testAvg8/input0.jpg") );
 
         subTestHDR(inputs, "testDRODark1_output.jpg", true, -1, -1);
     }
@@ -14188,7 +13408,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         setToDefault();
 
-        Bitmap bitmap = getBitmapFromFile(hdr_images_path + "testHDR3/input1.jpg");
+        Bitmap bitmap = getBitmapFromFile(TestUtils.hdr_images_path + "testHDR3/input1.jpg");
         Bitmap bitmap_saved = bitmap.copy(bitmap.getConfig(), false);
 
         Thread.sleep(1000); // wait for camera to open
@@ -14234,118 +13454,8 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
     }
 
-    private interface TestAvgCallback {
-        void doneProcessAvg(int index); // called after every call to HDRProcessor.processAvg()
-    }
-
-    /** The following testAvgX tests test the Avg noise reduction algorithm on a given set of input images.
-     *  By testing on a fixed sample, this makes it easier to finetune the algorithm for quality and performance.
-     *  To use these tests, the testdata/ subfolder should be manually copied to the test device in the DCIM/testOpenCamera/
-     *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
-     *  time to transfer to the device everytime we run the tests.
-     */
-    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
-    private HistogramDetails subTestAvg(List<String> inputs, String output_name, int iso, long exposure_time, float zoom_factor, TestAvgCallback cb) throws IOException, InterruptedException {
-        Log.d(TAG, "subTestAvg");
-
-        if( Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP ) {
-            Log.d(TAG, "renderscript requires Android Lollipop or better");
-            return null;
-        }
-
-        Thread.sleep(1000); // wait for camera to open
-
-        /*Bitmap nr_bitmap = getBitmapFromFile(inputs.get(0));
-        long time_s = System.currentTimeMillis();
-        try {
-            for(int i=1;i<inputs.size();i++) {
-                Log.d(TAG, "processAvg for image: " + i);
-                Bitmap new_bitmap = getBitmapFromFile(inputs.get(i));
-                float avg_factor = (float)i;
-                mActivity.getApplicationInterface().getHDRProcessor().processAvg(nr_bitmap, new_bitmap, avg_factor, true);
-                // processAvg recycles new_bitmap
-                if( cb != null ) {
-                    cb.doneProcessAvg(i);
-                }
-                //break; // test
-            }
-            //mActivity.getApplicationInterface().getHDRProcessor().processAvgMulti(inputs, hdr_strength, 4);
-        }
-        catch(HDRProcessorException e) {
-            e.printStackTrace();
-            throw new RuntimeException();
-        }
-        Log.d(TAG, "Avg time: " + (System.currentTimeMillis() - time_s));
-
-        {
-            mActivity.getApplicationInterface().getHDRProcessor().avgBrighten(nr_bitmap);
-            Log.d(TAG, "time after brighten: " + (System.currentTimeMillis() - time_s));
-        }*/
-
-        Bitmap nr_bitmap;
-        try {
-            // initialise allocation from first two bitmaps
-            //int inSampleSize = mActivity.getApplicationInterface().getHDRProcessor().getAvgSampleSize(inputs.size());
-            int inSampleSize = mActivity.getApplicationInterface().getHDRProcessor().getAvgSampleSize(iso, exposure_time);
-            Bitmap bitmap0 = getBitmapFromFile(inputs.get(0), inSampleSize);
-            Bitmap bitmap1 = getBitmapFromFile(inputs.get(1), inSampleSize);
-            int width = bitmap0.getWidth();
-            int height = bitmap0.getHeight();
-
-            float avg_factor = 1.0f;
-            List<Long> times = new ArrayList<>();
-            long time_s = System.currentTimeMillis();
-            HDRProcessor.AvgData avg_data = mActivity.getApplicationInterface().getHDRProcessor().processAvg(bitmap0, bitmap1, avg_factor, iso, exposure_time, zoom_factor);
-            Allocation allocation = avg_data.allocation_out;
-            times.add(System.currentTimeMillis() - time_s);
-            // processAvg recycles both bitmaps
-            if( cb != null ) {
-                cb.doneProcessAvg(1);
-            }
-
-            for(int i=2;i<inputs.size();i++) {
-                Log.d(TAG, "processAvg for image: " + i);
-
-                Bitmap new_bitmap = getBitmapFromFile(inputs.get(i), inSampleSize);
-                avg_factor = (float)i;
-                time_s = System.currentTimeMillis();
-                mActivity.getApplicationInterface().getHDRProcessor().updateAvg(avg_data, width, height, new_bitmap, avg_factor, iso, exposure_time, zoom_factor);
-                times.add(System.currentTimeMillis() - time_s);
-                // updateAvg recycles new_bitmap
-                if( cb != null ) {
-                    cb.doneProcessAvg(i);
-                }
-            }
-
-            time_s = System.currentTimeMillis();
-            nr_bitmap = mActivity.getApplicationInterface().getHDRProcessor().avgBrighten(allocation, width, height, iso, exposure_time);
-            avg_data.destroy();
-            //noinspection UnusedAssignment
-            avg_data = null;
-            times.add(System.currentTimeMillis() - time_s);
-
-            long total_time = 0;
-            Log.d(TAG, "*** times are:");
-            for(long time : times) {
-                total_time += time;
-                Log.d(TAG, "    " + time);
-            }
-            Log.d(TAG, "    total: " + total_time);
-        }
-        catch(HDRProcessorException e) {
-            e.printStackTrace();
-            throw new RuntimeException();
-        }
-
-        saveBitmap(nr_bitmap, output_name);
-        HistogramDetails hdrHistogramDetails = checkHistogram(nr_bitmap);
-        nr_bitmap.recycle();
-        System.gc();
-        inputs.clear();
-
-        Thread.sleep(500);
-
-        return hdrHistogramDetails;
+    private TestUtils.HistogramDetails subTestAvg(List<String> inputs, String output_name, int iso, long exposure_time, float zoom_factor, TestUtils.TestAvgCallback cb) {
+        return TestUtils.subTestAvg(mActivity, inputs, output_name, iso, exposure_time, zoom_factor, cb);
     }
 
     /** Tests Avg algorithm on test samples "testAvg1".
@@ -14357,13 +13467,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg1/input0.jpg");
-        inputs.add(avg_images_path + "testAvg1/input1.jpg");
-        inputs.add(avg_images_path + "testAvg1/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg1/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg1/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg1/input2.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg1_output.jpg", 1600, 1000000000L/17, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg1_output.jpg", 1600, 1000000000L/17, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14410,13 +13520,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg2/input0.jpg");
-        inputs.add(avg_images_path + "testAvg2/input1.jpg");
-        inputs.add(avg_images_path + "testAvg2/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg2/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg2/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg2/input2.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg2_output.jpg", 1600, 1000000000L/17, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg2_output.jpg", 1600, 1000000000L/17, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14461,15 +13571,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg3/input0.jpg");
-        inputs.add(avg_images_path + "testAvg3/input1.jpg");
-        inputs.add(avg_images_path + "testAvg3/input2.jpg");
-        inputs.add(avg_images_path + "testAvg3/input3.jpg");
-        inputs.add(avg_images_path + "testAvg3/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg3/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg3/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg3/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg3/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg3/input4.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg3_output.jpg", 1600, 1000000000L/16, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg3_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14552,15 +13662,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg4/input0.jpg");
-        inputs.add(avg_images_path + "testAvg4/input1.jpg");
-        inputs.add(avg_images_path + "testAvg4/input2.jpg");
-        inputs.add(avg_images_path + "testAvg4/input3.jpg");
-        inputs.add(avg_images_path + "testAvg4/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg4/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg4/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg4/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg4/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg4/input4.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg4_output.jpg", 1600, 1000000000L/16, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg4_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14617,15 +13727,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg5/input0.jpg");
-        inputs.add(avg_images_path + "testAvg5/input1.jpg");
-        inputs.add(avg_images_path + "testAvg5/input2.jpg");
-        inputs.add(avg_images_path + "testAvg5/input3.jpg");
-        inputs.add(avg_images_path + "testAvg5/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg5/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg5/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg5/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg5/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg5/input4.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg5_output.jpg", 1600, 1000000000L/16, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg5_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14684,18 +13794,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg6/input0.jpg");
-        inputs.add(avg_images_path + "testAvg6/input1.jpg");
-        inputs.add(avg_images_path + "testAvg6/input2.jpg");
-        inputs.add(avg_images_path + "testAvg6/input3.jpg");
-        inputs.add(avg_images_path + "testAvg6/input4.jpg");
-        inputs.add(avg_images_path + "testAvg6/input5.jpg");
-        inputs.add(avg_images_path + "testAvg6/input6.jpg");
-        inputs.add(avg_images_path + "testAvg6/input7.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg6/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg6/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg6/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg6/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg6/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg6/input5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg6/input6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg6/input7.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg6_output.jpg", 1600, 1000000000L/17, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg6_output.jpg", 1600, 1000000000L/17, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14768,18 +13878,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg7/input0.jpg");
-        inputs.add(avg_images_path + "testAvg7/input1.jpg");
-        inputs.add(avg_images_path + "testAvg7/input2.jpg");
-        inputs.add(avg_images_path + "testAvg7/input3.jpg");
-        inputs.add(avg_images_path + "testAvg7/input4.jpg");
-        inputs.add(avg_images_path + "testAvg7/input5.jpg");
-        inputs.add(avg_images_path + "testAvg7/input6.jpg");
-        inputs.add(avg_images_path + "testAvg7/input7.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg7/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg7/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg7/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg7/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg7/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg7/input5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg7/input6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg7/input7.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg7_output.jpg", 1600, 1000000000L/16, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg7_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14816,18 +13926,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg8/input0.jpg");
-        inputs.add(avg_images_path + "testAvg8/input1.jpg");
-        inputs.add(avg_images_path + "testAvg8/input2.jpg");
-        inputs.add(avg_images_path + "testAvg8/input3.jpg");
-        inputs.add(avg_images_path + "testAvg8/input4.jpg");
-        inputs.add(avg_images_path + "testAvg8/input5.jpg");
-        inputs.add(avg_images_path + "testAvg8/input6.jpg");
-        inputs.add(avg_images_path + "testAvg8/input7.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg8/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg8/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg8/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg8/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg8/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg8/input5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg8/input6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg8/input7.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg8_output.jpg", 1600, 1000000000L/16, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg8_output.jpg", 1600, 1000000000L/16, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14858,31 +13968,31 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         final boolean use_auto_photos = true;
 
         if( use_auto_photos ) {
-            inputs.add(avg_images_path + "testAvg9/input_auto0.jpg");
-            inputs.add(avg_images_path + "testAvg9/input_auto1.jpg");
-            inputs.add(avg_images_path + "testAvg9/input_auto2.jpg");
-            inputs.add(avg_images_path + "testAvg9/input_auto3.jpg");
-            inputs.add(avg_images_path + "testAvg9/input_auto4.jpg");
-            inputs.add(avg_images_path + "testAvg9/input_auto5.jpg");
-            inputs.add(avg_images_path + "testAvg9/input_auto6.jpg");
-            inputs.add(avg_images_path + "testAvg9/input_auto7.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input_auto7.jpg");
         }
         else {
-            inputs.add(avg_images_path + "testAvg9/input0.jpg");
-            inputs.add(avg_images_path + "testAvg9/input1.jpg");
-            inputs.add(avg_images_path + "testAvg9/input2.jpg");
-            inputs.add(avg_images_path + "testAvg9/input3.jpg");
-            inputs.add(avg_images_path + "testAvg9/input4.jpg");
-            inputs.add(avg_images_path + "testAvg9/input5.jpg");
-            inputs.add(avg_images_path + "testAvg9/input6.jpg");
-            inputs.add(avg_images_path + "testAvg9/input7.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg9/input7.jpg");
         }
 
         String out_filename = use_auto_photos ? "testAvg9_auto_output.jpg" : "testAvg9_output.jpg";
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, out_filename, 1600, use_auto_photos ? 1000000000L/16 : 1000000000L/11, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, out_filename, 1600, use_auto_photos ? 1000000000L/16 : 1000000000L/11, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14907,29 +14017,29 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         final boolean use_auto_photos = false;
 
         if( use_auto_photos ) {
-            inputs.add(avg_images_path + "testAvg10/input_auto0.jpg");
-            inputs.add(avg_images_path + "testAvg10/input_auto1.jpg");
-            inputs.add(avg_images_path + "testAvg10/input_auto2.jpg");
-            inputs.add(avg_images_path + "testAvg10/input_auto3.jpg");
-            inputs.add(avg_images_path + "testAvg10/input_auto4.jpg");
-            inputs.add(avg_images_path + "testAvg10/input_auto5.jpg");
-            inputs.add(avg_images_path + "testAvg10/input_auto6.jpg");
-            inputs.add(avg_images_path + "testAvg10/input_auto7.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input_auto7.jpg");
         }
         else {
-            inputs.add(avg_images_path + "testAvg10/input0.jpg");
-            inputs.add(avg_images_path + "testAvg10/input1.jpg");
-            inputs.add(avg_images_path + "testAvg10/input2.jpg");
-            inputs.add(avg_images_path + "testAvg10/input3.jpg");
-            inputs.add(avg_images_path + "testAvg10/input4.jpg");
-            inputs.add(avg_images_path + "testAvg10/input5.jpg");
-            inputs.add(avg_images_path + "testAvg10/input6.jpg");
-            inputs.add(avg_images_path + "testAvg10/input7.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input0.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input1.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input2.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input3.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input4.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input5.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input6.jpg");
+            inputs.add(TestUtils.avg_images_path + "testAvg10/input7.jpg");
         }
 
         String out_filename = use_auto_photos ? "testAvg10_auto_output.jpg" : "testAvg10_output.jpg";
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, out_filename, 1196, use_auto_photos ? 1000000000L/12 : 1000000000L/10, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, out_filename, 1196, use_auto_photos ? 1000000000L/12 : 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -14953,16 +14063,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
         // note, we don't actually use 8 images for a bright scene like this, but it serves as a good test for
         // misalignment/ghosting anyway
-        inputs.add(avg_images_path + "testAvg11/input0.jpg");
-        inputs.add(avg_images_path + "testAvg11/input1.jpg");
-        inputs.add(avg_images_path + "testAvg11/input2.jpg");
-        inputs.add(avg_images_path + "testAvg11/input3.jpg");
-        inputs.add(avg_images_path + "testAvg11/input4.jpg");
-        inputs.add(avg_images_path + "testAvg11/input5.jpg");
-        inputs.add(avg_images_path + "testAvg11/input6.jpg");
-        inputs.add(avg_images_path + "testAvg11/input7.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg11_output.jpg", 100, 1000000000L/338, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg11/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg11/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg11/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg11/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg11/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg11/input5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg11/input6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg11/input7.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg11_output.jpg", 100, 1000000000L/338, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15064,10 +14174,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg12/input0.jpg");
-        inputs.add(avg_images_path + "testAvg12/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg12/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg12/input1.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg12_output.jpg", 100, 1000000000L/1617, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg12_output.jpg", 100, 1000000000L/1617, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15093,10 +14203,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg13/input0.jpg");
-        inputs.add(avg_images_path + "testAvg13/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg13/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg13/input1.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg13_output.jpg", 100, 1000000000L/2482, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg13_output.jpg", 100, 1000000000L/2482, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15118,18 +14228,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg14/input0.jpg");
-        inputs.add(avg_images_path + "testAvg14/input1.jpg");
-        inputs.add(avg_images_path + "testAvg14/input2.jpg");
-        inputs.add(avg_images_path + "testAvg14/input3.jpg");
-        inputs.add(avg_images_path + "testAvg14/input4.jpg");
-        inputs.add(avg_images_path + "testAvg14/input5.jpg");
-        inputs.add(avg_images_path + "testAvg14/input6.jpg");
-        inputs.add(avg_images_path + "testAvg14/input7.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg14/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg14/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg14/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg14/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg14/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg14/input5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg14/input6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg14/input7.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg14_output.jpg", 1600, 1000000000L/10, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg14_output.jpg", 1600, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15161,10 +14271,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg15/input0.jpg");
-        inputs.add(avg_images_path + "testAvg15/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg15/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg15/input1.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg15_output.jpg", 100, 1000000000L/1525, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg15_output.jpg", 100, 1000000000L/1525, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15186,10 +14296,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg16/input0.jpg");
-        inputs.add(avg_images_path + "testAvg16/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg16/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg16/input1.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg16_output.jpg", 100, 1000000000L/293, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg16_output.jpg", 100, 1000000000L/293, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15211,18 +14321,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg17/input0.jpg");
-        inputs.add(avg_images_path + "testAvg17/input1.jpg");
-        inputs.add(avg_images_path + "testAvg17/input2.jpg");
-        inputs.add(avg_images_path + "testAvg17/input3.jpg");
-        inputs.add(avg_images_path + "testAvg17/input4.jpg");
-        inputs.add(avg_images_path + "testAvg17/input5.jpg");
-        inputs.add(avg_images_path + "testAvg17/input6.jpg");
-        inputs.add(avg_images_path + "testAvg17/input7.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg17/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg17/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg17/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg17/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg17/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg17/input5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg17/input6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg17/input7.jpg");
 
         // the input images record ISO=800, but they were taken with OnePlus 3T which has bug where ISO is reported as max
         // of 800; in reality for a scene this dark, it was probably more like ISO 1600
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg17_output.jpg", 1600, 1000000000L/17, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg17_output.jpg", 1600, 1000000000L/17, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15257,10 +14367,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg18/input0.jpg");
-        inputs.add(avg_images_path + "testAvg18/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg18/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg18/input1.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg18_output.jpg", 100, 1000000000L/591, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg18_output.jpg", 100, 1000000000L/591, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15283,10 +14393,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<String> inputs = new ArrayList<>();
         // repeat same image twice
-        inputs.add(avg_images_path + "testAvg19/input0.jpg");
-        inputs.add(avg_images_path + "testAvg19/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg19/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg19/input0.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg19_output.jpg", 100, 1000000000L/2483, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg19_output.jpg", 100, 1000000000L/2483, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15313,10 +14423,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<String> inputs = new ArrayList<>();
         // repeat same image twice
-        inputs.add(avg_images_path + "testAvg20/input0.jpg");
-        inputs.add(avg_images_path + "testAvg20/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg20/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg20/input0.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg20_output.jpg", 100, 1000000000L/3124, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg20_output.jpg", 100, 1000000000L/3124, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15339,10 +14449,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<String> inputs = new ArrayList<>();
         // repeat same image twice
-        inputs.add(avg_images_path + "testAvg21/input0.jpg");
-        inputs.add(avg_images_path + "testAvg21/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg21/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg21/input0.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg21_output.jpg", 102, 1000000000L/6918, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg21_output.jpg", 102, 1000000000L/6918, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15365,10 +14475,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<String> inputs = new ArrayList<>();
         // repeat same image twice
-        inputs.add(avg_images_path + "testAvg22/input0.jpg");
-        inputs.add(avg_images_path + "testAvg22/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg22/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg22/input0.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg22_output.jpg", 100, 1000000000L/3459, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg22_output.jpg", 100, 1000000000L/3459, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15390,17 +14500,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg23/IMG_20180520_111250_0.jpg");
-        inputs.add(avg_images_path + "testAvg23/IMG_20180520_111250_1.jpg");
-        inputs.add(avg_images_path + "testAvg23/IMG_20180520_111250_2.jpg");
-        inputs.add(avg_images_path + "testAvg23/IMG_20180520_111250_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_3.jpg");
         // only test 4 images, to reflect latest behaviour that we take 4 images for this ISO
-        /*inputs.add(avg_images_path + "testAvg23/IMG_20180520_111250_4.jpg");
-        inputs.add(avg_images_path + "testAvg23/IMG_20180520_111250_5.jpg");
-        inputs.add(avg_images_path + "testAvg23/IMG_20180520_111250_6.jpg");
-        inputs.add(avg_images_path + "testAvg23/IMG_20180520_111250_7.jpg");*/
+        /*inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg23/IMG_20180520_111250_7.jpg");*/
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg23_output.jpg", 1044, 1000000000L/10, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg23_output.jpg", 1044, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15459,10 +14569,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg24/input0.jpg");
-        inputs.add(avg_images_path + "testAvg24/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg24/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg24/input1.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg24_output.jpg", 100, 1000000000L/2421, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg24_output.jpg", 100, 1000000000L/2421, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15486,12 +14596,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg25/input0.jpg");
-        inputs.add(avg_images_path + "testAvg25/input1.jpg");
-        inputs.add(avg_images_path + "testAvg25/input2.jpg");
-        inputs.add(avg_images_path + "testAvg25/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg25/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg25/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg25/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg25/input3.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg25_output.jpg", 512, 1000000000L/20, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg25_output.jpg", 512, 1000000000L/20, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15512,12 +14622,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
         // note we now take only 3 images for bright scenes, but still test with 4 images as this serves as a good test
         // against ghosting
-        inputs.add(avg_images_path + "testAvg26/input0.jpg");
-        inputs.add(avg_images_path + "testAvg26/input1.jpg");
-        inputs.add(avg_images_path + "testAvg26/input2.jpg");
-        inputs.add(avg_images_path + "testAvg26/input3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg26/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg26/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg26/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg26/input3.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg26_output.jpg", 100, 1000000000L/365, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg26_output.jpg", 100, 1000000000L/365, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15556,10 +14666,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg27/IMG_20180610_205929_0.jpg");
-        inputs.add(avg_images_path + "testAvg27/IMG_20180610_205929_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg27/IMG_20180610_205929_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg27/IMG_20180610_205929_1.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg27_output.jpg", 100, 1000000000L/482, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg27_output.jpg", 100, 1000000000L/482, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15581,16 +14691,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg28/input001.jpg");
-        inputs.add(avg_images_path + "testAvg28/input002.jpg");
-        inputs.add(avg_images_path + "testAvg28/input003.jpg");
-        inputs.add(avg_images_path + "testAvg28/input004.jpg");
-        inputs.add(avg_images_path + "testAvg28/input005.jpg");
-        inputs.add(avg_images_path + "testAvg28/input006.jpg");
-        inputs.add(avg_images_path + "testAvg28/input007.jpg");
-        inputs.add(avg_images_path + "testAvg28/input008.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg28_output.jpg", 811, 1000000000L/21, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg28/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg28/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg28/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg28/input004.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg28/input005.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg28/input006.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg28/input007.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg28/input008.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg28_output.jpg", 811, 1000000000L/21, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15615,17 +14725,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg29/input001.jpg");
-        inputs.add(avg_images_path + "testAvg29/input002.jpg");
-        inputs.add(avg_images_path + "testAvg29/input003.jpg");
-        inputs.add(avg_images_path + "testAvg29/input004.jpg");
-        inputs.add(avg_images_path + "testAvg29/input005.jpg");
-        inputs.add(avg_images_path + "testAvg29/input006.jpg");
-        inputs.add(avg_images_path + "testAvg29/input007.jpg");
-        inputs.add(avg_images_path + "testAvg29/input008.jpg");
-        inputs.add(avg_images_path + "testAvg29/input009.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg29_output.jpg", 40, 1000000000L/2660, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input004.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input005.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input006.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input007.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input008.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg29/input009.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg29_output.jpg", 40, 1000000000L/2660, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15648,11 +14758,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg30/input001.jpg");
-        inputs.add(avg_images_path + "testAvg30/input002.jpg");
-        inputs.add(avg_images_path + "testAvg30/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg30/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg30/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg30/input003.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg30_output.jpg", 60, 1000000000L/411, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg30_output.jpg", 60, 1000000000L/411, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15694,18 +14804,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg31/input001.jpg");
-        inputs.add(avg_images_path + "testAvg31/input002.jpg");
-        inputs.add(avg_images_path + "testAvg31/input003.jpg");
-        inputs.add(avg_images_path + "testAvg31/input004.jpg");
-        inputs.add(avg_images_path + "testAvg31/input005.jpg");
-        inputs.add(avg_images_path + "testAvg31/input006.jpg");
-        inputs.add(avg_images_path + "testAvg31/input007.jpg");
-        inputs.add(avg_images_path + "testAvg31/input008.jpg");
-        inputs.add(avg_images_path + "testAvg31/input009.jpg");
-        inputs.add(avg_images_path + "testAvg31/input010.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg31_output.jpg", 609, 1000000000L/25, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input004.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input005.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input006.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input007.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input008.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input009.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg31/input010.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg31_output.jpg", 609, 1000000000L/25, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15729,15 +14839,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg32/input001.jpg");
-        inputs.add(avg_images_path + "testAvg32/input002.jpg");
-        inputs.add(avg_images_path + "testAvg32/input003.jpg");
-        inputs.add(avg_images_path + "testAvg32/input004.jpg");
-        inputs.add(avg_images_path + "testAvg32/input005.jpg");
-        inputs.add(avg_images_path + "testAvg32/input006.jpg");
-        inputs.add(avg_images_path + "testAvg32/input007.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg32_output.jpg", 335, 1000000000L/120, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg32/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg32/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg32/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg32/input004.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg32/input005.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg32/input006.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg32/input007.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg32_output.jpg", 335, 1000000000L/120, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15762,18 +14872,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg33/input001.jpg");
-        inputs.add(avg_images_path + "testAvg33/input002.jpg");
-        inputs.add(avg_images_path + "testAvg33/input003.jpg");
-        inputs.add(avg_images_path + "testAvg33/input004.jpg");
-        inputs.add(avg_images_path + "testAvg33/input005.jpg");
-        inputs.add(avg_images_path + "testAvg33/input006.jpg");
-        inputs.add(avg_images_path + "testAvg33/input007.jpg");
-        inputs.add(avg_images_path + "testAvg33/input008.jpg");
-        inputs.add(avg_images_path + "testAvg33/input009.jpg");
-        inputs.add(avg_images_path + "testAvg33/input010.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg33_output.jpg", 948, 1000000000L/18, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input004.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input005.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input006.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input007.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input008.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input009.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg33/input010.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg33_output.jpg", 948, 1000000000L/18, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15793,11 +14903,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg34/IMG_20180627_121959_0.jpg");
-        inputs.add(avg_images_path + "testAvg34/IMG_20180627_121959_1.jpg");
-        inputs.add(avg_images_path + "testAvg34/IMG_20180627_121959_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg34/IMG_20180627_121959_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg34/IMG_20180627_121959_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg34/IMG_20180627_121959_2.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg34_output.jpg", 100, 1000000000L/289, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg34_output.jpg", 100, 1000000000L/289, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15819,11 +14929,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg35/IMG_20180711_144453_0.jpg");
-        inputs.add(avg_images_path + "testAvg35/IMG_20180711_144453_1.jpg");
-        inputs.add(avg_images_path + "testAvg35/IMG_20180711_144453_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg35/IMG_20180711_144453_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg35/IMG_20180711_144453_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg35/IMG_20180711_144453_2.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg35_output.jpg", 100, 1000000000L/2549, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg35_output.jpg", 100, 1000000000L/2549, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15843,17 +14953,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg36/IMG_20180709_114831_0.jpg");
-        inputs.add(avg_images_path + "testAvg36/IMG_20180709_114831_1.jpg");
-        inputs.add(avg_images_path + "testAvg36/IMG_20180709_114831_2.jpg");
-        inputs.add(avg_images_path + "testAvg36/IMG_20180709_114831_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_3.jpg");
         // only test 4 images, to reflect latest behaviour that we take 4 images for this ISO/exposure time
-        /*inputs.add(avg_images_path + "testAvg36/IMG_20180709_114831_4.jpg");
-        inputs.add(avg_images_path + "testAvg36/IMG_20180709_114831_5.jpg");
-        inputs.add(avg_images_path + "testAvg36/IMG_20180709_114831_6.jpg");
-        inputs.add(avg_images_path + "testAvg36/IMG_20180709_114831_7.jpg");*/
+        /*inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg36/IMG_20180709_114831_7.jpg");*/
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg36_output.jpg", 752, 1000000000L/10, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg36_output.jpg", 752, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15882,12 +14992,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg37/IMG_20180715_173155_0.jpg");
-        inputs.add(avg_images_path + "testAvg37/IMG_20180715_173155_1.jpg");
-        inputs.add(avg_images_path + "testAvg37/IMG_20180715_173155_2.jpg");
-        inputs.add(avg_images_path + "testAvg37/IMG_20180715_173155_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg37/IMG_20180715_173155_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg37/IMG_20180715_173155_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg37/IMG_20180715_173155_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg37/IMG_20180715_173155_3.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg37_output.jpg", 131, 1000000000L/50, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg37_output.jpg", 131, 1000000000L/50, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15911,17 +15021,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg38/IMG_20180716_232102_0.jpg");
-        inputs.add(avg_images_path + "testAvg38/IMG_20180716_232102_1.jpg");
-        inputs.add(avg_images_path + "testAvg38/IMG_20180716_232102_2.jpg");
-        inputs.add(avg_images_path + "testAvg38/IMG_20180716_232102_3.jpg");
-        inputs.add(avg_images_path + "testAvg38/IMG_20180716_232102_4.jpg");
-        inputs.add(avg_images_path + "testAvg38/IMG_20180716_232102_5.jpg");
-        inputs.add(avg_images_path + "testAvg38/IMG_20180716_232102_6.jpg");
-        inputs.add(avg_images_path + "testAvg38/IMG_20180716_232102_7.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg38/IMG_20180716_232102_7.jpg");
 
         // n.b., this was a zoomed in photo, but can't quite remember the exact zoom level!
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg38_output.jpg", 1505, 1000000000L/10, 3.95f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg38_output.jpg", 1505, 1000000000L/10, 3.95f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15941,18 +15051,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg39/input001.jpg");
-        inputs.add(avg_images_path + "testAvg39/input002.jpg");
-        inputs.add(avg_images_path + "testAvg39/input003.jpg");
-        inputs.add(avg_images_path + "testAvg39/input004.jpg");
-        inputs.add(avg_images_path + "testAvg39/input005.jpg");
-        inputs.add(avg_images_path + "testAvg39/input006.jpg");
-        inputs.add(avg_images_path + "testAvg39/input007.jpg");
-        inputs.add(avg_images_path + "testAvg39/input008.jpg");
-        inputs.add(avg_images_path + "testAvg39/input009.jpg");
-        inputs.add(avg_images_path + "testAvg39/input010.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg39_output.jpg", 521, 1000000000L/27, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input004.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input005.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input006.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input007.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input008.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input009.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg39/input010.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg39_output.jpg", 521, 1000000000L/27, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -15975,17 +15085,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg40/input001.jpg");
-        inputs.add(avg_images_path + "testAvg40/input002.jpg");
-        inputs.add(avg_images_path + "testAvg40/input003.jpg");
-        inputs.add(avg_images_path + "testAvg40/input004.jpg");
-        inputs.add(avg_images_path + "testAvg40/input005.jpg");
-        inputs.add(avg_images_path + "testAvg40/input006.jpg");
-        inputs.add(avg_images_path + "testAvg40/input007.jpg");
-        inputs.add(avg_images_path + "testAvg40/input008.jpg");
-        inputs.add(avg_images_path + "testAvg40/input009.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg40_output.jpg", 199, 1000000000L/120, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input004.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input005.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input006.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input007.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input008.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg40/input009.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg40_output.jpg", 199, 1000000000L/120, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16010,18 +15120,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // example from Google HDR+ dataset
         // note, the number of input images doesn't necessarily match what we'd take for this scene, but we want to compare
         // to the Google HDR+ result
-        inputs.add(avg_images_path + "testAvg41/input001.jpg");
-        inputs.add(avg_images_path + "testAvg41/input002.jpg");
-        inputs.add(avg_images_path + "testAvg41/input003.jpg");
-        inputs.add(avg_images_path + "testAvg41/input004.jpg");
-        inputs.add(avg_images_path + "testAvg41/input005.jpg");
-        inputs.add(avg_images_path + "testAvg41/input006.jpg");
-        inputs.add(avg_images_path + "testAvg41/input007.jpg");
-        inputs.add(avg_images_path + "testAvg41/input008.jpg");
-        inputs.add(avg_images_path + "testAvg41/input009.jpg");
-        inputs.add(avg_images_path + "testAvg41/input010.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg41_output.jpg", 100, 1000000000L/869, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input001.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input002.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input003.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input004.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input005.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input006.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input007.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input008.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input009.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg41/input010.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg41_output.jpg", 100, 1000000000L/869, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16042,11 +15152,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg42/IMG_20180822_145152_0.jpg");
-        inputs.add(avg_images_path + "testAvg42/IMG_20180822_145152_1.jpg");
-        inputs.add(avg_images_path + "testAvg42/IMG_20180822_145152_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg42/IMG_20180822_145152_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg42/IMG_20180822_145152_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg42/IMG_20180822_145152_2.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg42_output.jpg", 100, 1000000000L/2061, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg42_output.jpg", 100, 1000000000L/2061, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16066,11 +15176,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg43/IMG_20180831_143226_0.jpg");
-        inputs.add(avg_images_path + "testAvg43/IMG_20180831_143226_1.jpg");
-        inputs.add(avg_images_path + "testAvg43/IMG_20180831_143226_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg43/IMG_20180831_143226_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg43/IMG_20180831_143226_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg43/IMG_20180831_143226_2.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg43_output.jpg", 100, 1000000000L/2152, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg43_output.jpg", 100, 1000000000L/2152, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16089,11 +15199,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg44/IMG_20180830_133917_0.jpg");
-        inputs.add(avg_images_path + "testAvg44/IMG_20180830_133917_1.jpg");
-        inputs.add(avg_images_path + "testAvg44/IMG_20180830_133917_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg44/IMG_20180830_133917_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg44/IMG_20180830_133917_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg44/IMG_20180830_133917_2.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg44_output.jpg", 40, 1000000000L/2130, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg44_output.jpg", 40, 1000000000L/2130, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16112,11 +15222,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg45/IMG_20180719_133947_0.jpg");
-        inputs.add(avg_images_path + "testAvg45/IMG_20180719_133947_1.jpg");
-        inputs.add(avg_images_path + "testAvg45/IMG_20180719_133947_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg45/IMG_20180719_133947_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg45/IMG_20180719_133947_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg45/IMG_20180719_133947_2.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg45_output.jpg", 100, 1000000000L/865, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg45_output.jpg", 100, 1000000000L/865, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16135,16 +15245,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg46/IMG_20180903_203141_0.jpg");
-        inputs.add(avg_images_path + "testAvg46/IMG_20180903_203141_1.jpg");
-        inputs.add(avg_images_path + "testAvg46/IMG_20180903_203141_2.jpg");
-        inputs.add(avg_images_path + "testAvg46/IMG_20180903_203141_3.jpg");
-        inputs.add(avg_images_path + "testAvg46/IMG_20180903_203141_4.jpg");
-        inputs.add(avg_images_path + "testAvg46/IMG_20180903_203141_5.jpg");
-        inputs.add(avg_images_path + "testAvg46/IMG_20180903_203141_6.jpg");
-        inputs.add(avg_images_path + "testAvg46/IMG_20180903_203141_7.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg46_output.jpg", 1505, 1000000000L/10, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg46/IMG_20180903_203141_7.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg46_output.jpg", 1505, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16163,12 +15273,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg47/IMG_20180911_114752_0.jpg");
-        inputs.add(avg_images_path + "testAvg47/IMG_20180911_114752_1.jpg");
-        inputs.add(avg_images_path + "testAvg47/IMG_20180911_114752_2.jpg");
-        inputs.add(avg_images_path + "testAvg47/IMG_20180911_114752_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg47/IMG_20180911_114752_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg47/IMG_20180911_114752_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg47/IMG_20180911_114752_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg47/IMG_20180911_114752_3.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg47_output.jpg", 749, 1000000000L/12, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg47_output.jpg", 749, 1000000000L/12, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16187,16 +15297,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg48/IMG_20180911_110520_0.jpg");
-        inputs.add(avg_images_path + "testAvg48/IMG_20180911_110520_1.jpg");
-        inputs.add(avg_images_path + "testAvg48/IMG_20180911_110520_2.jpg");
-        inputs.add(avg_images_path + "testAvg48/IMG_20180911_110520_3.jpg");
-        inputs.add(avg_images_path + "testAvg48/IMG_20180911_110520_4.jpg");
-        inputs.add(avg_images_path + "testAvg48/IMG_20180911_110520_5.jpg");
-        inputs.add(avg_images_path + "testAvg48/IMG_20180911_110520_6.jpg");
-        inputs.add(avg_images_path + "testAvg48/IMG_20180911_110520_7.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg48_output.jpg", 1196, 1000000000L/10, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg48/IMG_20180911_110520_7.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg48_output.jpg", 1196, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16215,16 +15325,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg49/IMG_20180911_120200_0.jpg");
-        inputs.add(avg_images_path + "testAvg49/IMG_20180911_120200_1.jpg");
-        inputs.add(avg_images_path + "testAvg49/IMG_20180911_120200_2.jpg");
-        inputs.add(avg_images_path + "testAvg49/IMG_20180911_120200_3.jpg");
-        inputs.add(avg_images_path + "testAvg49/IMG_20180911_120200_4.jpg");
-        inputs.add(avg_images_path + "testAvg49/IMG_20180911_120200_5.jpg");
-        inputs.add(avg_images_path + "testAvg49/IMG_20180911_120200_6.jpg");
-        inputs.add(avg_images_path + "testAvg49/IMG_20180911_120200_7.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg49_output.jpg", 1505, 1000000000L/10, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg49/IMG_20180911_120200_7.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg49_output.jpg", 1505, 1000000000L/10, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16243,12 +15353,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg50/IMG_20181015_144335_0.jpg");
-        inputs.add(avg_images_path + "testAvg50/IMG_20181015_144335_1.jpg");
-        inputs.add(avg_images_path + "testAvg50/IMG_20181015_144335_2.jpg");
-        inputs.add(avg_images_path + "testAvg50/IMG_20181015_144335_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg50/IMG_20181015_144335_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg50/IMG_20181015_144335_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg50/IMG_20181015_144335_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg50/IMG_20181015_144335_3.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg50_output.jpg", 114, 1000000000L/33, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg50_output.jpg", 114, 1000000000L/33, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16267,16 +15377,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg51/IMG_20181025_182917_0.jpg");
-        inputs.add(avg_images_path + "testAvg51/IMG_20181025_182917_1.jpg");
-        inputs.add(avg_images_path + "testAvg51/IMG_20181025_182917_2.jpg");
-        inputs.add(avg_images_path + "testAvg51/IMG_20181025_182917_3.jpg");
-        inputs.add(avg_images_path + "testAvg51/IMG_20181025_182917_4.jpg");
-        inputs.add(avg_images_path + "testAvg51/IMG_20181025_182917_5.jpg");
-        inputs.add(avg_images_path + "testAvg51/IMG_20181025_182917_6.jpg");
-        inputs.add(avg_images_path + "testAvg51/IMG_20181025_182917_7.jpg");
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg51_output.jpg", 1600, 1000000000L/3, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_3.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg51/IMG_20181025_182917_7.jpg");
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg51_output.jpg", 1600, 1000000000L/3, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16306,11 +15416,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvg52/IMG_20181119_144836_0.jpg");
-        inputs.add(avg_images_path + "testAvg52/IMG_20181119_144836_1.jpg");
-        inputs.add(avg_images_path + "testAvg52/IMG_20181119_144836_2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg52/IMG_20181119_144836_0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg52/IMG_20181119_144836_1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvg52/IMG_20181119_144836_2.jpg");
 
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg52_output.jpg", 100, 1000000000L/297, 1.0f, new TestAvgCallback() {
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvg52_output.jpg", 100, 1000000000L/297, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16331,17 +15441,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         // list assets
         List<String> inputs = new ArrayList<>();
-        inputs.add(avg_images_path + "testAvgtemp/input0.png");
-        /*inputs.add(avg_images_path + "testAvgtemp/input0.jpg");
-        inputs.add(avg_images_path + "testAvgtemp/input1.jpg");
-        inputs.add(avg_images_path + "testAvgtemp/input2.jpg");
-        inputs.add(avg_images_path + "testAvgtemp/input3.jpg");*/
-        /*inputs.add(avg_images_path + "testAvgtemp/input4.jpg");
-        inputs.add(avg_images_path + "testAvgtemp/input5.jpg");
-        inputs.add(avg_images_path + "testAvgtemp/input6.jpg");
-        inputs.add(avg_images_path + "testAvgtemp/input7.jpg");*/
-
-        HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvgtemp_output.jpg", 250, 1000000000L/33, 1.0f, new TestAvgCallback() {
+        inputs.add(TestUtils.avg_images_path + "testAvgtemp/input0.png");
+        /*inputs.add(TestUtils.avg_images_path + "testAvgtemp/input0.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvgtemp/input1.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvgtemp/input2.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvgtemp/input3.jpg");*/
+        /*inputs.add(TestUtils.avg_images_path + "testAvgtemp/input4.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvgtemp/input5.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvgtemp/input6.jpg");
+        inputs.add(TestUtils.avg_images_path + "testAvgtemp/input7.jpg");*/
+
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestAvg(inputs, "testAvgtemp_output.jpg", 250, 1000000000L/33, 1.0f, new TestUtils.TestAvgCallback() {
             @Override
             public void doneProcessAvg(int index) {
                 Log.d(TAG, "doneProcessAvg: " + index);
@@ -16373,7 +15483,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         return (int)(255.0f * out_f + 0.5f);
     }
 
-    private HistogramDetails subTestLogProfile(String image_path, String output_name) throws IOException, InterruptedException {
+    private TestUtils.HistogramDetails subTestLogProfile(String image_path, String output_name) throws IOException, InterruptedException {
         Log.d(TAG, "subTestLogProfile");
 
         if( !mPreview.usingCamera2API() ) {
@@ -16427,7 +15537,7 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         }
 
         saveBitmap(bitmap, output_name);
-        HistogramDetails hdrHistogramDetails = checkHistogram(bitmap);
+        TestUtils.HistogramDetails hdrHistogramDetails = checkHistogram(bitmap);
         bitmap.recycle();
         System.gc();
 
@@ -16448,9 +15558,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.apply();
         updateForSettings();
 
-        String image_path = avg_images_path + "testAvg1/input0.jpg";
+        String image_path = TestUtils.avg_images_path + "testAvg1/input0.jpg";
 
-        HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile1_output.jpg");
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile1_output.jpg");
 
         //checkHistogramDetails(hdrHistogramDetails, 1, 23, 253);
         checkHistogramDetails(hdrHistogramDetails, 0, 7, 253);
@@ -16468,9 +15578,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.apply();
         updateForSettings();
 
-        String image_path = avg_images_path + "testAvg20/input0.jpg";
+        String image_path = TestUtils.avg_images_path + "testAvg20/input0.jpg";
 
-        HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile2_output.jpg");
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile2_output.jpg");
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 58, 243);
 
@@ -16499,9 +15609,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.apply();
         updateForSettings();
 
-        String image_path = logprofile_images_path + "testLogProfile3.jpg";
+        String image_path = TestUtils.logprofile_images_path + "testLogProfile3.jpg";
 
-        HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile3_output.jpg");
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile3_output.jpg");
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 157, 255);
         checkHistogramDetails(hdrHistogramDetails, 0, 143, 255);
@@ -16519,9 +15629,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.apply();
         updateForSettings();
 
-        String image_path = avg_images_path + "testAvg1/input0.jpg";
+        String image_path = TestUtils.avg_images_path + "testAvg1/input0.jpg";
 
-        HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile1_extra_strong_output.jpg");
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile1_extra_strong_output.jpg");
 
         //checkHistogramDetails(hdrHistogramDetails, 2, 67, 254);
 
@@ -16550,9 +15660,9 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.apply();
         updateForSettings();
 
-        String image_path = avg_images_path + "testAvg20/input0.jpg";
+        String image_path = TestUtils.avg_images_path + "testAvg20/input0.jpg";
 
-        HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile2_extra_strong_output.jpg");
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile2_extra_strong_output.jpg");
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 126, 250);
 
@@ -16581,243 +15691,20 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         editor.apply();
         updateForSettings();
 
-        String image_path = logprofile_images_path + "testLogProfile3.jpg";
+        String image_path = TestUtils.logprofile_images_path + "testLogProfile3.jpg";
 
-        HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile3_extra_strong_output.jpg");
+        TestUtils.HistogramDetails hdrHistogramDetails = subTestLogProfile(image_path, "testLogProfile3_extra_strong_output.jpg");
 
         //checkHistogramDetails(hdrHistogramDetails, 0, 212, 255);
         checkHistogramDetails(hdrHistogramDetails, 0, 170, 255);
     }
 
-    /** Returns the mediastore Uri for the supplied filename inside the supplied baseUri, or null
-     *  if an entry can't be found.
-     */
-    private Uri getUriFromName(Uri baseUri, String name) {
-        Uri uri = null;
-        String [] projection = new String[]{MediaStore.Images.ImageColumns._ID};
-        Cursor cursor = null;
-        try {
-            cursor = mActivity.getContentResolver().query(baseUri, projection, MediaStore.Images.ImageColumns.DISPLAY_NAME + " LIKE ?", new String[]{name}, null);
-            if( cursor != null && cursor.moveToFirst() ) {
-                Log.d(TAG, "found: " + cursor.getCount());
-                long id = cursor.getLong(0);
-                uri = ContentUris.withAppendedId(baseUri, id);
-                Log.d(TAG, "id: " + id);
-                Log.d(TAG, "uri: " + uri);
-            }
-        }
-        catch(Exception e) {
-            Log.e(TAG, "Exception trying to find uri from filename");
-            e.printStackTrace();
-        }
-        finally {
-            if( cursor != null ) {
-                cursor.close();
-            }
-        }
-        return uri;
-    }
-
-    private void saveBitmap(Bitmap bitmap, String name) throws IOException {
-        Log.d(TAG, "saveBitmap: " + name);
-
-        File file = null;
-        ContentValues contentValues = null;
-        Uri uri = null;
-        OutputStream outputStream;
-        if( MainActivity.useScopedStorage() ) {
-            Uri folder = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ?
-                    MediaStore.Images.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY) :
-                    MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
-
-            // first try to delete pre-existing image
-            Uri old_uri = getUriFromName(folder, name);
-            if( old_uri != null ) {
-                Log.d(TAG, "delete: " + old_uri);
-                mActivity.getContentResolver().delete(old_uri, null, null);
-            }
-
-            contentValues = new ContentValues();
-            contentValues.put(MediaStore.Images.Media.DISPLAY_NAME, name);
-            String extension = name.substring(name.lastIndexOf("."));
-            String mime_type = mActivity.getStorageUtils().getImageMimeType(extension);
-            Log.d(TAG, "mime_type: " + mime_type);
-            contentValues.put(MediaStore.Images.Media.MIME_TYPE, mime_type);
-            if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ) {
-                String relative_path = Environment.DIRECTORY_DCIM + File.separator;
-                Log.d(TAG, "relative_path: " + relative_path);
-                contentValues.put(MediaStore.Images.Media.RELATIVE_PATH, relative_path);
-                contentValues.put(MediaStore.Images.Media.IS_PENDING, 1);
-            }
-
-            uri = mActivity.getContentResolver().insert(folder, contentValues);
-            Log.d(TAG, "saveUri: " + uri);
-            if( uri == null ) {
-                throw new IOException();
-            }
-            outputStream = mActivity.getContentResolver().openOutputStream(uri);
-        }
-        else {
-            file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM) + File.separator + name);
-            outputStream = new FileOutputStream(file);
-        }
-
-        bitmap.compress(Bitmap.CompressFormat.JPEG, 90, outputStream);
-        outputStream.close();
-
-        if( MainActivity.useScopedStorage() ) {
-            if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ) {
-                contentValues.clear();
-                contentValues.put(MediaStore.Images.Media.IS_PENDING, 0);
-                mActivity.getContentResolver().update(uri, contentValues, null, null);
-            }
-        }
-        else {
-            mActivity.getStorageUtils().broadcastFile(file, true, false, true);
-        }
+    private void saveBitmap(Bitmap bitmap, String name) {
+        TestUtils.saveBitmap(mActivity, bitmap, name);
     }
 
-    /**
-     * @param panorama_pics_per_screen The value of panorama_pics_per_screen used when taking the input photos.
-     * @param camera_angle_x The value of preview.getViewAngleX(for_preview=false) (in degrees) when taking the input photos (on the device used).
-     * @param camera_angle_y The value of preview.getViewAngleY(for_preview=false) (in degrees) when taking the input photos (on the device used).
-     */
-    private void subTestPanorama(List<String> inputs, String output_name, String gyro_debug_info_filename, float panorama_pics_per_screen, float camera_angle_x, float camera_angle_y, float gyro_tol_degrees) throws IOException, InterruptedException {
-        Log.d(TAG, "subTestPanorama");
-
-        // we set panorama_pics_per_screen in the test rather than using MyApplicationInterface.panorama_pics_per_screen,
-        // in case the latter value is changed
-
-        boolean first = true;
-        Matrix scale_matrix = null;
-        int bitmap_width = 0;
-        int bitmap_height = 0;
-        List<Bitmap> bitmaps = new ArrayList<>();
-        for(String input : inputs) {
-            Bitmap bitmap = getBitmapFromFile(input);
-
-            if( first ) {
-                bitmap_width = bitmap.getWidth();
-                bitmap_height = bitmap.getHeight();
-                Log.d(TAG, "bitmap_width: " + bitmap_width);
-                Log.d(TAG, "bitmap_height: " + bitmap_height);
-
-                final int max_height = 2080;
-                //final int max_height = 2079; // test non power of 2
-                if( bitmap_height > max_height ) {
-                    float scale = ((float)max_height) / ((float)bitmap_height);
-                    Log.d(TAG, "scale: " + scale);
-                    scale_matrix = new Matrix();
-                    scale_matrix.postScale(scale, scale);
-                }
-
-                first = false;
-            }
-
-            // downscale
-            if( scale_matrix != null ) {
-                Bitmap new_bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap_width, bitmap_height, scale_matrix, true);
-                bitmap.recycle();
-                bitmap = new_bitmap;
-            }
-
-            bitmaps.add(bitmap);
-        }
-
-        bitmap_width = bitmaps.get(0).getWidth();
-        bitmap_height = bitmaps.get(0).getHeight();
-        Log.d(TAG, "bitmap_width is now: " + bitmap_width);
-        Log.d(TAG, "bitmap_height is now: " + bitmap_height);
-
-
-        /*ImageSaver.GyroDebugInfo gyro_debug_info = null;
-        if( gyro_debug_info_filename != null ) {
-            InputStream inputStream;
-            try {
-                inputStream = new FileInputStream(gyro_debug_info_filename);
-            }
-            catch(FileNotFoundException e) {
-                Log.e(TAG, "failed to load gyro debug info file: " + gyro_debug_info_filename);
-                e.printStackTrace();
-                throw new RuntimeException();
-            }
-
-            gyro_debug_info = new ImageSaver.GyroDebugInfo();
-            if( !ImageSaver.readGyroDebugXml(inputStream, gyro_debug_info) ) {
-                Log.e(TAG, "failed to read gyro debug xml");
-                throw new RuntimeException();
-            }
-            else if( gyro_debug_info.image_info.size() != bitmaps.size() ) {
-                Log.e(TAG, "gyro debug xml has unexpected number of images: " + gyro_debug_info.image_info.size());
-                throw new RuntimeException();
-            }
-        }*/
-        //bitmaps.subList(2,bitmaps.size()).clear(); // test
-
-        Bitmap panorama = null;
-        try {
-            final boolean crop = true;
-            //final boolean crop = false; // test
-            panorama = mActivity.getApplicationInterface().getPanoramaProcessor().panorama(bitmaps, panorama_pics_per_screen, camera_angle_y, crop);
-        }
-        catch(PanoramaProcessorException e) {
-            e.printStackTrace();
-            fail();
-        }
-
-        saveBitmap(panorama, output_name);
-        Thread.sleep(500);
-
-        // check we've cropped correctly:
-        final float black_factor = 0.9f;
-        // top:
-        int n_black = 0;
-        for(int i=0;i<panorama.getWidth();i++) {
-            int color = panorama.getPixel(i, 0);
-            if( ((color >> 16) & 0xff) == 0 && ((color >> 8) & 0xff) == 0 && ((color) & 0xff) == 0 ) {
-                n_black++;
-            }
-        }
-        if( n_black >= panorama.getWidth()*black_factor ) {
-            Log.e(TAG, "too many black pixels on top border: " + n_black);
-            fail();
-        }
-        // bottom:
-        n_black = 0;
-        for(int i=0;i<panorama.getWidth();i++) {
-            int color = panorama.getPixel(i, panorama.getHeight()-1);
-            if( ((color >> 16) & 0xff) == 0 && ((color >> 8) & 0xff) == 0 && ((color) & 0xff) == 0 ) {
-                n_black++;
-            }
-        }
-        if( n_black >= panorama.getWidth()*black_factor ) {
-            Log.e(TAG, "too many black pixels on bottom border: " + n_black);
-            fail();
-        }
-        // left:
-        n_black = 0;
-        for(int i=0;i<panorama.getHeight();i++) {
-            int color = panorama.getPixel(0, i);
-            if( ((color >> 16) & 0xff) == 0 && ((color >> 8) & 0xff) == 0 && ((color) & 0xff) == 0 ) {
-                n_black++;
-            }
-        }
-        if( n_black >= panorama.getHeight()*black_factor ) {
-            Log.e(TAG, "too many black pixels on left border: " + n_black);
-            fail();
-        }
-        // right:
-        n_black = 0;
-        for(int i=0;i<panorama.getHeight();i++) {
-            int color = panorama.getPixel(panorama.getWidth()-1, i);
-            if( ((color >> 16) & 0xff) == 0 && ((color >> 8) & 0xff) == 0 && ((color) & 0xff) == 0 ) {
-                n_black++;
-            }
-        }
-        if( n_black >= panorama.getHeight()*black_factor ) {
-            Log.e(TAG, "too many black pixels on right border: " + n_black);
-            fail();
-        }
+    private void subTestPanorama(List<String> inputs, String output_name, String gyro_debug_info_filename, float panorama_pics_per_screen, float camera_angle_x, float camera_angle_y, float gyro_tol_degrees) {
+        TestUtils.subTestPanorama(mActivity, inputs, output_name, gyro_debug_info_filename, panorama_pics_per_screen, camera_angle_x, camera_angle_y, gyro_tol_degrees);
     }
 
     /** Tests panorama algorithm on test samples "testPanoramaWhite".
@@ -16831,8 +15718,8 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<String> inputs = new ArrayList<>();
 
-        inputs.add(panorama_images_path + "testPanoramaWhite/input0.jpg");
-        inputs.add(panorama_images_path + "testPanoramaWhite/input0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanoramaWhite/input0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanoramaWhite/input0.jpg");
         float camera_angle_x = 66.3177f;
         float camera_angle_y = 50.04736f;
         float panorama_pics_per_screen = 2.0f;
@@ -16851,10 +15738,10 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         // list assets
         List<String> inputs = new ArrayList<>();
 
-        inputs.add(panorama_images_path + "testPanorama1/input0.jpg");
-        inputs.add(panorama_images_path + "testPanorama1/input1.jpg");
-        inputs.add(panorama_images_path + "testPanorama1/input2.jpg");
-        inputs.add(panorama_images_path + "testPanorama1/input3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama1/input0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama1/input1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama1/input2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama1/input3.jpg");
         float camera_angle_x = 62.93796f;
         float camera_angle_y = 47.44656f;
         float panorama_pics_per_screen = 2.0f;
@@ -16876,22 +15763,22 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         /*final float panorama_pics_per_screen = 1.0f;
-        //inputs.add(panorama_images_path + "testPanorama2xxx/input0.jpg");
-        inputs.add(panorama_images_path + "testPanorama2xxx/input1.jpg");
-        inputs.add(panorama_images_path + "testPanorama2xxx/input2.jpg");*/
+        //inputs.add(TestUtils.panorama_images_path + "testPanorama2xxx/input0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama2xxx/input1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama2xxx/input2.jpg");*/
         /*final float panorama_pics_per_screen = 2.0f;
-        //inputs.add(panorama_images_path + "testPanorama1/input0.jpg");
-        inputs.add(panorama_images_path + "testPanorama1/input1.jpg");
-        inputs.add(panorama_images_path + "testPanorama1/input2.jpg");
-        inputs.add(panorama_images_path + "testPanorama1/input3.jpg");
+        //inputs.add(TestUtils.panorama_images_path + "testPanorama1/input0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama1/input1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama1/input2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama1/input3.jpg");
         String output_name = "testPanorama1_output.jpg";*/
         float panorama_pics_per_screen = 4.0f;
-        inputs.add(panorama_images_path + "testPanorama2/input0.jpg");
-        inputs.add(panorama_images_path + "testPanorama2/input1.jpg");
-        inputs.add(panorama_images_path + "testPanorama2/input2.jpg");
-        inputs.add(panorama_images_path + "testPanorama2/input3.jpg");
-        inputs.add(panorama_images_path + "testPanorama2/input4.jpg");
-        inputs.add(panorama_images_path + "testPanorama2/input5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama2/input0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama2/input1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama2/input2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama2/input3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama2/input4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama2/input5.jpg");
         String output_name = "testPanorama2_output.jpg";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -16912,17 +15799,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 4.0f;
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131249.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131252.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131255.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131258.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131301.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131303.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131305.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131307.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131315.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131317.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131320.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131249.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131252.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131255.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131258.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131301.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131303.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131305.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131307.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131315.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131317.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131320.jpg");
         String output_name = "testPanorama3_output.jpg";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -16944,17 +15831,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 2.0f;
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131249.jpg");
-        //inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131252.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131255.jpg");
-        //inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131258.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131301.jpg");
-        //inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131303.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131305.jpg");
-        //inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131307.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131315.jpg");
-        //inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131317.jpg");
-        inputs.add(panorama_images_path + "testPanorama3/IMG_20190214_131320.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131249.jpg");
+        //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131252.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131255.jpg");
+        //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131258.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131301.jpg");
+        //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131303.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131305.jpg");
+        //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131307.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131315.jpg");
+        //inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131317.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama3/IMG_20190214_131320.jpg");
         String output_name = "testPanorama3_picsperscreen2_output.jpg";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -16975,16 +15862,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 4.0f;
-        inputs.add(panorama_images_path + "testPanorama4/IMG_20190222_225317_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama4/IMG_20190222_225317_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama4/IMG_20190222_225317_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama4/IMG_20190222_225317_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama4/IMG_20190222_225317_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama4/IMG_20190222_225317_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama4/IMG_20190222_225317_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama4/IMG_20190222_225317_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317_7.jpg");
         String output_name = "testPanorama4_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama4/IMG_20190222_225317.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama4/IMG_20190222_225317.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
         // these images were taken with incorrect camera view angles, so we compensate in the test:
@@ -17004,16 +15891,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 4.0f;
-        inputs.add(panorama_images_path + "testPanorama5/IMG_20190223_220524_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama5/IMG_20190223_220524_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama5/IMG_20190223_220524_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama5/IMG_20190223_220524_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama5/IMG_20190223_220524_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama5/IMG_20190223_220524_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama5/IMG_20190223_220524_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama5/IMG_20190223_220524_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524_7.jpg");
         String output_name = "testPanorama5_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama5/IMG_20190223_220524.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama5/IMG_20190223_220524.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
         // these images were taken with incorrect camera view angles, so we compensate in the test:
@@ -17033,16 +15920,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 4.0f;
-        inputs.add(panorama_images_path + "testPanorama6/IMG_20190225_154232_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama6/IMG_20190225_154232_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama6/IMG_20190225_154232_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama6/IMG_20190225_154232_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama6/IMG_20190225_154232_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama6/IMG_20190225_154232_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama6/IMG_20190225_154232_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama6/IMG_20190225_154232_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232_7.jpg");
         String output_name = "testPanorama6_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama6/IMG_20190225_154232.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama6/IMG_20190225_154232.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
         // these images were taken with incorrect camera view angles, so we compensate in the test:
@@ -17062,17 +15949,17 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 4.0f;
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama7/IMG_20190225_155510_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510_8.jpg");
         String output_name = "testPanorama7_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama7/IMG_20190225_155510.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama7/IMG_20190225_155510.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
         // these images were taken with incorrect camera view angles, so we compensate in the test:
@@ -17092,12 +15979,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 2.0f;
-        inputs.add(panorama_images_path + "testPanorama8/IMG_20190227_001431_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama8/IMG_20190227_001431_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama8/IMG_20190227_001431_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama8/IMG_20190227_001431_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431_3.jpg");
         String output_name = "testPanorama8_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama8/IMG_20190227_001431.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama8/IMG_20190227_001431.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
         // these images were taken with incorrect camera view angles, so we compensate in the test:
@@ -17117,15 +16004,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.0f;
-        inputs.add(panorama_images_path + "testPanorama9/IMG_20190301_145213_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama9/IMG_20190301_145213_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama9/IMG_20190301_145213_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama9/IMG_20190301_145213_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama9/IMG_20190301_145213_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama9/IMG_20190301_145213_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama9/IMG_20190301_145213_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213_6.jpg");
         String output_name = "testPanorama9_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama9/IMG_20190301_145213.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama9/IMG_20190301_145213.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
         // these images were taken with incorrect camera view angles, so we compensate in the test:
@@ -17147,21 +16034,21 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.0f;
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_9.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_10.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_11.jpg");
-        inputs.add(panorama_images_path + "testPanorama10/IMG_20190301_144948_12.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_10.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_11.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948_12.jpg");
         String output_name = "testPanorama10_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama10/IMG_20190301_144948.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama10/IMG_20190301_144948.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17182,15 +16069,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.0f;
-        inputs.add(panorama_images_path + "testPanorama11/IMG_20190306_143652_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama11/IMG_20190306_143652_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama11/IMG_20190306_143652_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama11/IMG_20190306_143652_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama11/IMG_20190306_143652_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama11/IMG_20190306_143652_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama11/IMG_20190306_143652_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652_6.jpg");
         String output_name = "testPanorama11_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama11/IMG_20190306_143652.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama11/IMG_20190306_143652.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
         // these images were taken with incorrect camera view angles, so we compensate in the test:
@@ -17210,18 +16097,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.0f;
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama12/IMG_20190308_152008_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008_9.jpg");
         String output_name = "testPanorama12_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama12/IMG_20190308_152008.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama12/IMG_20190308_152008.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
         // these images were taken with incorrect camera view angles, so we compensate in the test:
@@ -17241,18 +16128,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.0f;
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama13/IMG_20190512_014152_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152_9.jpg");
         String output_name = "testPanorama13_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama13/IMG_20190512_014152.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama13/IMG_20190512_014152.xml";
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
 
@@ -17270,18 +16157,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama14/IMG_20190513_151249_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249_9.jpg");
         String output_name = "testPanorama14_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama14/IMG_20190513_151249.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama14/IMG_20190513_151249.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17300,18 +16187,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama15/IMG_20190513_151624_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624_9.jpg");
         String output_name = "testPanorama15_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama15/IMG_20190513_151624.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama15/IMG_20190513_151624.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17330,18 +16217,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama16/IMG_20190624_151731_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731_9.jpg");
         String output_name = "testPanorama16_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama16/IMG_20190624_151731.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama16/IMG_20190624_151731.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17360,18 +16247,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama17/IMG_20190625_135423_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423_9.jpg");
         String output_name = "testPanorama17_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama17/IMG_20190625_135423.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama17/IMG_20190625_135423.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17390,18 +16277,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama18/IMG_20190626_152559_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559_9.jpg");
         String output_name = "testPanorama18_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama18/IMG_20190626_152559.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama18/IMG_20190626_152559.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17420,18 +16307,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama19/IMG_20190627_134059_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059_9.jpg");
         String output_name = "testPanorama19_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama19/IMG_20190627_134059.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama19/IMG_20190627_134059.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17450,18 +16337,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama20/IMG_20190628_145027_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027_9.jpg");
         String output_name = "testPanorama20_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama20/IMG_20190628_145027.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama20/IMG_20190628_145027.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17480,18 +16367,18 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama21/IMG_20190628_145552_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552_9.jpg");
         String output_name = "testPanorama21_output.jpg";
-        String gyro_name = panorama_images_path + "testPanorama21/IMG_20190628_145552.xml";
+        String gyro_name = TestUtils.panorama_images_path + "testPanorama21/IMG_20190628_145552.xml";
         //gyro_name = null;
         float camera_angle_x = 66.708595f;
         float camera_angle_y = 50.282097f;
@@ -17510,14 +16397,14 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama22/IMG_20190629_165627_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama22/IMG_20190629_165627_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama22/IMG_20190629_165627_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama22/IMG_20190629_165627_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama22/IMG_20190629_165627_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama22/IMG_20190629_165627_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama22/IMG_20190629_165627_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama22/IMG_20190629_165627_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama22/IMG_20190629_165627_7.jpg");
         String output_name = "testPanorama22_output.jpg";
         String gyro_name = null;
         float camera_angle_x = 66.708595f;
@@ -17537,11 +16424,11 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama23/IMG_20190702_145916_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama23/IMG_20190702_145916_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama23/IMG_20190702_145916_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama23/IMG_20190702_145916_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama23/IMG_20190702_145916_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama23/IMG_20190702_145916_4.jpg");
         String output_name = "testPanorama23_output.jpg";
         String gyro_name = null;
         float camera_angle_x = 66.708595f;
@@ -17561,16 +16448,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama24/IMG_20190703_154333_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama24/IMG_20190703_154333_9.jpg");
         String output_name = "testPanorama24_output.jpg";
         String gyro_name = null;
         // taken with OnePlus 3T, Camera2 API:
@@ -17592,13 +16479,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         float panorama_pics_per_screen = 3.33333f;
         //float panorama_pics_per_screen = 3.33333f / 2.0f;
-        inputs.add(panorama_images_path + "testPanorama25/IMG_20190706_215940_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama25/IMG_20190706_215940_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama25/IMG_20190706_215940_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama25/IMG_20190706_215940_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama25/IMG_20190706_215940_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama25/IMG_20190706_215940_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama25/IMG_20190706_215940_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama25/IMG_20190706_215940_6.jpg");
         String output_name = "testPanorama25_output.jpg";
         String gyro_name = null;
         // taken with Nokia 8, Camera2 API:
@@ -17619,13 +16506,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama26/IMG_20190706_214842_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama26/IMG_20190706_214842_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama26/IMG_20190706_214842_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama26/IMG_20190706_214842_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama26/IMG_20190706_214842_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama26/IMG_20190706_214842_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama26/IMG_20190706_214842_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama26/IMG_20190706_214842_6.jpg");
         String output_name = "testPanorama26_output.jpg";
         String gyro_name = null;
         // taken with Nokia 8, Camera2 API:
@@ -17646,13 +16533,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama27/IMG_20190706_192120_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama27/IMG_20190706_192120_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama27/IMG_20190706_192120_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama27/IMG_20190706_192120_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama27/IMG_20190706_192120_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama27/IMG_20190706_192120_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama27/IMG_20190706_192120_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama27/IMG_20190706_192120_6.jpg");
         String output_name = "testPanorama27_output.jpg";
         String gyro_name = null;
         // taken with Nokia 8, Camera2 API:
@@ -17674,27 +16561,27 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         float panorama_pics_per_screen = 3.33333f;
         // right-to-left:
-        /*inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_9.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_0.jpg");*/
+        /*inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_0.jpg");*/
         // converted from original JPEGs to PNG using Nokia 8:
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_0.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_1.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_2.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_3.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_4.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_5.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_6.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_7.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_8.png");
-        inputs.add(panorama_images_path + "testPanorama28/input_bitmap_9.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_0.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_1.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_2.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_3.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_4.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_5.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_6.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_7.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_8.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/input_bitmap_9.png");
         String output_name = "testPanorama28_output.jpg";
         String gyro_name = null;
         // taken with Samsung Galaxy S10e, Camera2 API, standard rear camera:
@@ -17719,27 +16606,27 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         float panorama_pics_per_screen = 3.33333f;
         // right-to-left:
-        /*inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_9.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama28/IMG_20190725_134756_0.jpg");*/
+        /*inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/IMG_20190725_134756_0.jpg");*/
         // converted from original JPEGs to PNG using Samsung Galaxy S10e:
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_0.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_1.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_2.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_3.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_4.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_5.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_6.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_7.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_8.png");
-        inputs.add(panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_9.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_0.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_1.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_2.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_3.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_4.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_5.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_6.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_7.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_8.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama28/galaxys10e_input_bitmap_9.png");
         String output_name = "testPanorama28_galaxys10e_output.jpg";
         String gyro_name = null;
         // taken with Samsung Galaxy S10e, Camera2 API, standard rear camera:
@@ -17761,16 +16648,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         float panorama_pics_per_screen = 3.33333f;
         // right-to-left:
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_9.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama29/IMG_20190719_145852_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama29/IMG_20190719_145852_0.jpg");
         String output_name = "testPanorama29_output.jpg";
         String gyro_name = null;
         // taken with Nokia 8, old API:
@@ -17791,27 +16678,27 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        /*inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_9.jpg");*/
+        /*inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_9.jpg");*/
         // converted from original JPEGs to PNG using Nokia 8:
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_0.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_1.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_2.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_3.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_4.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_5.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_6.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_7.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_8.png");
-        inputs.add(panorama_images_path + "testPanorama30/nokia8_input_bitmap_9.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_0.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_1.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_2.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_3.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_4.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_5.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_6.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_7.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_8.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/nokia8_input_bitmap_9.png");
         String output_name = "testPanorama30_output.jpg";
         String gyro_name = null;
         // taken with Samsung Galaxy S10e, old API, standard rear camera:
@@ -17836,27 +16723,27 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        /*inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama30/IMG_20190723_142934_9.jpg");*/
+        /*inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/IMG_20190723_142934_9.jpg");*/
         // converted from original JPEGs to PNG using Samsung Galaxy S10e:
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_0.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_1.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_2.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_3.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_4.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_5.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_6.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_7.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_8.png");
-        inputs.add(panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_9.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_0.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_1.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_2.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_3.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_4.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_5.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_6.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_7.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_8.png");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama30/galaxys10e_input_bitmap_9.png");
         String output_name = "testPanorama30_galaxys10e_output.jpg";
         String gyro_name = null;
         // taken with Samsung Galaxy S10e, old API, standard rear camera:
@@ -17878,13 +16765,13 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama31/IMG_20190704_135633_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama31/IMG_20190704_135633_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama31/IMG_20190704_135633_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama31/IMG_20190704_135633_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama31/IMG_20190704_135633_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama31/IMG_20190704_135633_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama31/IMG_20190704_135633_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama31/IMG_20190704_135633_6.jpg");
         String output_name = "testPanorama31_output.jpg";
         String gyro_name = null;
         // taken with OnePlus 3T, Camera2 API:
@@ -17905,15 +16792,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama32/IMG_20190705_145938_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama32/IMG_20190705_145938_8.jpg");
         String output_name = "testPanorama32_output.jpg";
         String gyro_name = null;
         // taken with OnePlus 3T, old API:
@@ -17934,12 +16821,12 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama33/IMG_20190713_013437_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama33/IMG_20190713_013437_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama33/IMG_20190713_013437_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama33/IMG_20190713_013437_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama33/IMG_20190713_013437_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama33/IMG_20190713_013437_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama33/IMG_20190713_013437_5.jpg");
         String output_name = "testPanorama33_output.jpg";
         String gyro_name = null;
         // taken with Nokia 8, old API:
@@ -17961,16 +16848,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
 
         float panorama_pics_per_screen = 3.33333f;
         // right-to-left:
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_9.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama34/IMG_20190717_144042_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama34/IMG_20190717_144042_0.jpg");
         String output_name = "testPanorama34_output.jpg";
         String gyro_name = null;
         // taken with Nexus 6, old API:
@@ -17991,16 +16878,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama35/IMG_20190717_145114_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama35/IMG_20190717_145114_9.jpg");
         String output_name = "testPanorama35_output.jpg";
         String gyro_name = null;
         // taken with Nexus 7, old API:
@@ -18021,14 +16908,14 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama36/IMG_20190722_201331_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama36/IMG_20190722_201331_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama36/IMG_20190722_201331_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama36/IMG_20190722_201331_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama36/IMG_20190722_201331_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama36/IMG_20190722_201331_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama36/IMG_20190722_201331_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama36/IMG_20190722_201331_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama36/IMG_20190722_201331_7.jpg");
         String output_name = "testPanorama36_output.jpg";
         String gyro_name = null;
         // taken with Samsung Galaxy S10e, Camera2 API, ultra wide rear camera:
@@ -18049,15 +16936,15 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama37/IMG_20190723_203441_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama37/IMG_20190723_203441_8.jpg");
         String output_name = "testPanorama37_output.jpg";
         String gyro_name = null;
         // taken with Samsung Galaxy S10e, old API, standard rear camera:
@@ -18079,16 +16966,16 @@ public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActiv
         List<String> inputs = new ArrayList<>();
 
         float panorama_pics_per_screen = 3.33333f;
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_0.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_1.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_2.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_3.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_4.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_5.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_6.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_7.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_8.jpg");
-        inputs.add(panorama_images_path + "testPanorama38/IMG_20190722_141148_9.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_0.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_1.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_2.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_3.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_4.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_5.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_6.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_7.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_8.jpg");
+        inputs.add(TestUtils.panorama_images_path + "testPanorama38/IMG_20190722_141148_9.jpg");
         String output_name = "testPanorama38_output.jpg";
         String gyro_name = null;
         // taken with Samsung Galaxy S10e, Camera2 API, standard rear camera:
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/test/MultiCameraTests.java b/app/src/androidTest/java/net/sourceforge/opencamera/test/MultiCameraTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..830e58348b15204e3f316e44499cf0b007335c10
--- /dev/null
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/test/MultiCameraTests.java
@@ -0,0 +1,18 @@
+package net.sourceforge.opencamera.test;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+public class MultiCameraTests {
+    // Tests to run specifically on devices where MainActivity.isMultiCamEnabled() returns true.
+    public static Test suite() {
+        TestSuite suite = new TestSuite(MainTests.class.getName());
+
+        suite.addTest(TestSuite.createTest(MainActivityTest.class, "testIconsAgainstCameras"));
+        suite.addTest(TestSuite.createTest(MainActivityTest.class, "testTakePhotoFrontCameraAll"));
+        suite.addTest(TestSuite.createTest(MainActivityTest.class, "testTakePhotoFrontCamera"));
+        suite.addTest(TestSuite.createTest(MainActivityTest.class, "testTakePhotoFrontCameraMulti"));
+
+        return suite;
+    }
+}
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/test/Nexus7Tests.java b/app/src/androidTest/java/net/sourceforge/opencamera/test/Nexus7Tests.java
index 079a2ced56a476390f5773201230a701d69ab5a5..74f39348b68cd9c5d8cfbb217b7da745f6fa2929 100644
--- a/app/src/androidTest/java/net/sourceforge/opencamera/test/Nexus7Tests.java
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/test/Nexus7Tests.java
@@ -5,6 +5,8 @@ import android.os.Build;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
+import net.sourceforge.opencamera.TestUtils;
+
 public class Nexus7Tests {
     // Tests to run specifically on Nexus 7
     public static Test suite() {
@@ -22,7 +24,7 @@ public class Nexus7Tests {
 
         // tests for testing Camera2 API with LEGACY Camera2 functionality
         suite.addTest(TestSuite.createTest(MainActivityTest.class, "testTakePhoto"));
-        if( MainActivityTest.isEmulator() && Build.VERSION.SDK_INT == Build.VERSION_CODES.M ) {
+        if( TestUtils.isEmulator() && Build.VERSION.SDK_INT == Build.VERSION_CODES.M ) {
             // video doesn't work on Android 6 emulator!
         }
         else {
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/test/PanoramaTests.java b/app/src/androidTest/java/net/sourceforge/opencamera/test/PanoramaTests.java
index 554ac0b79e667ea01cffce5c68b51caa06682913..d97cff41ac30f626f5fc959f472d593b957b3db2 100644
--- a/app/src/androidTest/java/net/sourceforge/opencamera/test/PanoramaTests.java
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/test/PanoramaTests.java
@@ -10,6 +10,7 @@ public class PanoramaTests {
      *  folder (so you have DCIM/testOpenCamera/testdata/). We don't use assets/ as we'd end up with huge APK sizes which takes
      *  time to transfer to the device every time we run the tests.
      *  On Android 10+, scoped storage permission needs to be given to Open Camera for the DCIM/testOpenCamera/ folder.
+     *  UPDATE: now deprecated, replaced with PanoramaTestSuite.
      */
     public static Test suite() {
         TestSuite suite = new TestSuite(MainTests.class.getName());
diff --git a/app/src/androidTest/java/net/sourceforge/opencamera/test/VideoTests.java b/app/src/androidTest/java/net/sourceforge/opencamera/test/VideoTests.java
index 4787ac2baef6b382d8b46ae9d0785d0f68dd9362..38b1f38cdc52886dcffc351b1a2e10538f03025f 100644
--- a/app/src/androidTest/java/net/sourceforge/opencamera/test/VideoTests.java
+++ b/app/src/androidTest/java/net/sourceforge/opencamera/test/VideoTests.java
@@ -79,7 +79,7 @@ public class VideoTests {
             suite.addTest(TestSuite.createTest(MainActivityTest.class, "testVideoEdgeModeNoiseReductionMode"));
         }
         // put tests which change bitrate, fps or test 4K at end
-        suite.addTest(TestSuite.createTest(MainActivityTest.class, "testTakeVideoFPS"));
+        //suite.addTest(TestSuite.createTest(MainActivityTest.class, "testTakeVideoFPS")); // disabled as unreliable
         if( MainActivityTest.test_camera2 ) {
             suite.addTest(TestSuite.createTest(MainActivityTest.class, "testTakeVideoFPSHighSpeedManual"));
             suite.addTest(TestSuite.createTest(MainActivityTest.class, "testTakeVideoSlowMotion"));
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 1a9fb772372ca5dcfcf0d0bcfac761f28f6e64c9..0f69e855ce28a58bd16d0b14b64b2beb40ecc737 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -2,8 +2,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
     package="foundation.e.camera"
-    android:versionCode="85"
-    android:versionName="1.50.1"
+    android:versionCode="87"
+    android:versionName="1.51.1"
     android:installLocation="auto"
     tools:ignore="GoogleAppIndexingWarning">
     <!-- ignore GoogleAppIndexingWarning as we don't want to implement that -->
@@ -18,7 +18,7 @@
         />
     <uses-permission android:name="android.permission.BLUETOOTH_SCAN"
         android:usesPermissionFlags="neverForLocation"
-        />
+        tools:targetApi="s" />
     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
         android:maxSdkVersion="28"
diff --git a/app/src/main/java/net/sourceforge/opencamera/HDRProcessor.java b/app/src/main/java/net/sourceforge/opencamera/HDRProcessor.java
index 6fa6ede472b8e14ea6ac013101fe7a28742b694d..5a187a7b7f9f0adc7d00166f60d3b6cb0f43d136 100644
--- a/app/src/main/java/net/sourceforge/opencamera/HDRProcessor.java
+++ b/app/src/main/java/net/sourceforge/opencamera/HDRProcessor.java
@@ -55,9 +55,10 @@ public class HDRProcessor {
         TONEMAPALGORITHM_CLAMP,
         TONEMAPALGORITHM_EXPONENTIAL,
         TONEMAPALGORITHM_REINHARD,
-        TONEMAPALGORITHM_FILMIC,
+        TONEMAPALGORITHM_FU2,
         TONEMAPALGORITHM_ACES
     }
+    public static final TonemappingAlgorithm default_tonemapping_algorithm_c = TonemappingAlgorithm.TONEMAPALGORITHM_REINHARD;
     public enum DROTonemappingAlgorithm {
         DROALGORITHM_NONE,
         DROALGORITHM_GAINGAMMA
@@ -481,18 +482,14 @@ public class HDRProcessor {
             for(int i=0;i<x_samples.size();i++) {
                 double value = x_samples.get(i);
                 double value_y = y_samples.get(i);
+                double weight = (value <= med_value) ? value - min_value : max_value - value;
                 if( is_dark_exposure ) {
                     // for dark exposure, also need to worry about the y values (which will be brighter than x) being overexposed
-                    double weight = (value <= med_value) ? value - min_value : max_value - value;
                     double weight_y = (value_y <= med_value_y) ? value_y - min_value_y : max_value_y - value_y;
                     if( weight_y < weight )
                         weight = weight_y;
-                    weights.add(weight);
-                }
-                else {
-                    double weight = (value <= med_value) ? value - min_value : max_value - value;
-                    weights.add(weight);
                 }
+                weights.add(weight);
             }
         }
 
@@ -730,10 +727,10 @@ public class HDRProcessor {
                     Log.d(TAG, "tonemapping algorithm: reinhard");
                 processHDRScript.set_tonemap_algorithm( processHDRScript.get_tonemap_algorithm_reinhard_c() );
                 break;
-            case TONEMAPALGORITHM_FILMIC:
+            case TONEMAPALGORITHM_FU2:
                 if( MyDebug.LOG )
-                    Log.d(TAG, "tonemapping algorithm: filmic");
-                processHDRScript.set_tonemap_algorithm( processHDRScript.get_tonemap_algorithm_filmic_c() );
+                    Log.d(TAG, "tonemapping algorithm: fu2");
+                processHDRScript.set_tonemap_algorithm( processHDRScript.get_tonemap_algorithm_fu2_c() );
                 break;
             case TONEMAPALGORITHM_ACES:
                 if( MyDebug.LOG )
@@ -855,14 +852,14 @@ public class HDRProcessor {
                 processHDRScript.set_linear_scale(linear_scale);
                 break;
             }
-            case TONEMAPALGORITHM_FILMIC:
+            case TONEMAPALGORITHM_FU2:
             {
-                // For filmic, we have f(V) = U(EV) / U(W), where V is the HDR value, U is a function.
+                // For FU2, we have f(V) = U(EV) / U(W), where V is the HDR value, U is a function.
                 // We want f(Vmax) = 1, so EVmax = W
-                float E = processHDRScript.get_filmic_exposure_bias();
+                float E = processHDRScript.get_fu2_exposure_bias();
                 float W = E * max_possible_value;
                 if( MyDebug.LOG )
-                    Log.d(TAG, "filmic W: " + W);
+                    Log.d(TAG, "fu2 W: " + W);
                 processHDRScript.set_W(W);
                 break;
             }
@@ -1019,14 +1016,12 @@ public class HDRProcessor {
 
         if( release_bitmaps ) {
             allocation.copyTo(bitmaps.get(0));
-            if( MyDebug.LOG )
-                Log.d(TAG, "time after copying to bitmap: " + (System.currentTimeMillis() - time_s));
         }
         else {
             output_allocation.copyTo(output_bitmap);
-            if( MyDebug.LOG )
-                Log.d(TAG, "time after copying to bitmap: " + (System.currentTimeMillis() - time_s));
         }
+        if( MyDebug.LOG )
+            Log.d(TAG, "time after copying to bitmap: " + (System.currentTimeMillis() - time_s));
 
         if( free_output_allocation )
             allocation.destroy();
@@ -2597,11 +2592,11 @@ public class HDRProcessor {
                         // * Lastly, we only modify a given histogram value if pixels of that brightness
                         //   would be made darker by the CLAHE algorithm. We can do this by looking at
                         //   the cumulative histogram (as computed before modifying any values).
-                        if( MyDebug.LOG ) {
+                        /*if( MyDebug.LOG ) {
                             for(int x=0;x<256;x++) {
                                 Log.d(TAG, "pre-brighten histogram[" + x + "] = " + histogram[x]);
                             }
-                        }
+                        }*/
 
                         temp_c_histogram[0] = histogram[0];
                         for(int x=1;x<256;x++) {
diff --git a/app/src/main/java/net/sourceforge/opencamera/ImageSaver.java b/app/src/main/java/net/sourceforge/opencamera/ImageSaver.java
index 886801fbfffd7ba6e9cab8e0ba11a7693a9a2b10..e808c4697183c186ed378dc473afcc0d8f3e00db 100644
--- a/app/src/main/java/net/sourceforge/opencamera/ImageSaver.java
+++ b/app/src/main/java/net/sourceforge/opencamera/ImageSaver.java
@@ -109,9 +109,10 @@ public class ImageSaver extends Thread {
         final Type type;
         enum ProcessType {
             NORMAL,
-            HDR,
+            HDR, // also covers DRO, if only 1 image in the request
             AVERAGE,
-            PANORAMA
+            PANORAMA,
+            X_NIGHT
         }
         final ProcessType process_type; // for type==JPEG
         final boolean force_suffix; // affects filename suffixes for saving jpeg_images: if true, filenames will always be appended with a suffix like _0, even if there's only 1 image in jpeg_images
@@ -152,6 +153,7 @@ public class ImageSaver extends Thread {
         final boolean is_front_facing;
         boolean mirror;
         final Date current_date;
+        final HDRProcessor.TonemappingAlgorithm preference_hdr_tonemapping_algorithm; // for HDR
         final String preference_hdr_contrast_enhancement; // for HDR
         final int iso; // not applicable for RAW image
         final long exposure_time; // not applicable for RAW image
@@ -167,6 +169,12 @@ public class ImageSaver extends Thread {
         //final String preference_stamp_geo_address;
         final String preference_units_distance;
         final boolean panorama_crop; // used for panorama
+        enum RemoveDeviceExif {
+            OFF, // don't remove any device exif tags
+            ON, // remove all device exif tags
+            KEEP_DATETIME // remove all device exif tags except datetime tags
+        }
+        final RemoveDeviceExif remove_device_exif;
         final boolean store_location;
         final Location location;
         final boolean store_geo_direction;
@@ -191,6 +199,7 @@ public class ImageSaver extends Thread {
                 boolean is_front_facing,
                 boolean mirror,
                 Date current_date,
+                HDRProcessor.TonemappingAlgorithm preference_hdr_tonemapping_algorithm,
                 String preference_hdr_contrast_enhancement,
                 int iso,
                 long exposure_time,
@@ -199,6 +208,7 @@ public class ImageSaver extends Thread {
                 //String preference_stamp_geo_address,
                 String preference_units_distance,
                 boolean panorama_crop,
+                RemoveDeviceExif remove_device_exif,
                 boolean store_location, Location location, boolean store_geo_direction, double geo_direction,
                 double pitch_angle, boolean store_ypr,
                 String custom_tag_artist,
@@ -223,6 +233,7 @@ public class ImageSaver extends Thread {
             this.is_front_facing = is_front_facing;
             this.mirror = mirror;
             this.current_date = current_date;
+            this.preference_hdr_tonemapping_algorithm = preference_hdr_tonemapping_algorithm;
             this.preference_hdr_contrast_enhancement = preference_hdr_contrast_enhancement;
             this.iso = iso;
             this.exposure_time = exposure_time;
@@ -238,6 +249,7 @@ public class ImageSaver extends Thread {
             //this.preference_stamp_geo_address = preference_stamp_geo_address;
             this.preference_units_distance = preference_units_distance;
             this.panorama_crop = panorama_crop;
+            this.remove_device_exif = remove_device_exif;
             this.store_location = store_location;
             this.location = location;
             this.store_geo_direction = store_geo_direction;
@@ -267,6 +279,7 @@ public class ImageSaver extends Thread {
                     this.is_front_facing,
                     this.mirror,
                     this.current_date,
+                    this.preference_hdr_tonemapping_algorithm,
                     this.preference_hdr_contrast_enhancement,
                     this.iso,
                     this.exposure_time,
@@ -274,7 +287,7 @@ public class ImageSaver extends Thread {
                     this.preference_stamp, this.preference_textstamp, this.font_size, this.color, this.pref_style, this.preference_stamp_dateformat, this.preference_stamp_timeformat, this.preference_stamp_gpsformat,
                     //this.preference_stamp_geo_address,
                     this.preference_units_distance,
-                    this.panorama_crop, this.store_location, this.location, this.store_geo_direction, this.geo_direction,
+                    this.panorama_crop, this.remove_device_exif, this.store_location, this.location, this.store_geo_direction, this.geo_direction,
                     this.pitch_angle, this.store_ypr,
                     this.custom_tag_artist,
                     this.custom_tag_copyright,
@@ -566,7 +579,7 @@ public class ImageSaver extends Thread {
      *  successfully.
      */
     boolean saveImageJpeg(boolean do_in_background,
-                          boolean is_hdr,
+                          Request.ProcessType processType,
                           boolean force_suffix,
                           int suffix_offset,
                           boolean save_expo,
@@ -578,6 +591,7 @@ public class ImageSaver extends Thread {
                           boolean is_front_facing,
                           boolean mirror,
                           Date current_date,
+                          HDRProcessor.TonemappingAlgorithm preference_hdr_tonemapping_algorithm,
                           String preference_hdr_contrast_enhancement,
                           int iso,
                           long exposure_time,
@@ -586,6 +600,7 @@ public class ImageSaver extends Thread {
                           //String preference_stamp_geo_address,
                           String preference_units_distance,
                           boolean panorama_crop,
+                          Request.RemoveDeviceExif remove_device_exif,
                           boolean store_location, Location location, boolean store_geo_direction, double geo_direction,
                           double pitch_angle, boolean store_ypr,
                           String custom_tag_artist,
@@ -598,7 +613,7 @@ public class ImageSaver extends Thread {
         }
         return saveImage(do_in_background,
                 false,
-                is_hdr,
+                processType,
                 force_suffix,
                 suffix_offset,
                 save_expo,
@@ -611,6 +626,7 @@ public class ImageSaver extends Thread {
                 is_front_facing,
                 mirror,
                 current_date,
+                preference_hdr_tonemapping_algorithm,
                 preference_hdr_contrast_enhancement,
                 iso,
                 exposure_time,
@@ -618,7 +634,7 @@ public class ImageSaver extends Thread {
                 preference_stamp, preference_textstamp, font_size, color, pref_style, preference_stamp_dateformat, preference_stamp_timeformat, preference_stamp_gpsformat,
                 //preference_stamp_geo_address,
                 preference_units_distance,
-                panorama_crop, store_location, location, store_geo_direction, geo_direction,
+                panorama_crop, remove_device_exif, store_location, location, store_geo_direction, geo_direction,
                 pitch_angle, store_ypr,
                 custom_tag_artist,
                 custom_tag_copyright,
@@ -642,7 +658,7 @@ public class ImageSaver extends Thread {
         }
         return saveImage(do_in_background,
                 true,
-                false,
+                Request.ProcessType.NORMAL,
                 force_suffix,
                 suffix_offset,
                 false,
@@ -655,6 +671,7 @@ public class ImageSaver extends Thread {
                 false,
                 false,
                 current_date,
+                HDRProcessor.default_tonemapping_algorithm_c,
                 null,
                 0,
                 0,
@@ -662,7 +679,7 @@ public class ImageSaver extends Thread {
                 null, null, 0, 0, null, null, null, null,
                 //null,
                 null,
-                false, false, null, false, 0.0,
+                false, Request.RemoveDeviceExif.OFF, false, null, false, 0.0,
                 0.0, false,
                 null, null,
                 1);
@@ -690,6 +707,7 @@ public class ImageSaver extends Thread {
                            //String preference_stamp_geo_address,
                            String preference_units_distance,
                            boolean panorama_crop,
+                           Request.RemoveDeviceExif remove_device_exif,
                            boolean store_location, Location location, boolean store_geo_direction, double geo_direction,
                            double pitch_angle, boolean store_ypr,
                            String custom_tag_artist,
@@ -713,6 +731,7 @@ public class ImageSaver extends Thread {
                 is_front_facing,
                 mirror,
                 current_date,
+                HDRProcessor.default_tonemapping_algorithm_c,
                 null,
                 iso,
                 exposure_time,
@@ -720,7 +739,7 @@ public class ImageSaver extends Thread {
                 preference_stamp, preference_textstamp, font_size, color, pref_style, preference_stamp_dateformat, preference_stamp_timeformat, preference_stamp_gpsformat,
                 //preference_stamp_geo_address,
                 preference_units_distance,
-                panorama_crop, store_location, location, store_geo_direction, geo_direction,
+                panorama_crop, remove_device_exif, store_location, location, store_geo_direction, geo_direction,
                 pitch_angle, store_ypr,
                 custom_tag_artist,
                 custom_tag_copyright,
@@ -781,7 +800,7 @@ public class ImageSaver extends Thread {
      */
     private boolean saveImage(boolean do_in_background,
                               boolean is_raw,
-                              boolean is_hdr,
+                              Request.ProcessType processType,
                               boolean force_suffix,
                               int suffix_offset,
                               boolean save_expo,
@@ -794,6 +813,7 @@ public class ImageSaver extends Thread {
                               boolean is_front_facing,
                               boolean mirror,
                               Date current_date,
+                              HDRProcessor.TonemappingAlgorithm preference_hdr_tonemapping_algorithm,
                               String preference_hdr_contrast_enhancement,
                               int iso,
                               long exposure_time,
@@ -802,6 +822,7 @@ public class ImageSaver extends Thread {
                               //String preference_stamp_geo_address,
                               String preference_units_distance,
                               boolean panorama_crop,
+                              Request.RemoveDeviceExif remove_device_exif,
                               boolean store_location, Location location, boolean store_geo_direction, double geo_direction,
                               double pitch_angle, boolean store_ypr,
                               String custom_tag_artist,
@@ -816,7 +837,7 @@ public class ImageSaver extends Thread {
         //do_in_background = false;
 
         Request request = new Request(is_raw ? Request.Type.RAW : Request.Type.JPEG,
-                is_hdr ? Request.ProcessType.HDR : Request.ProcessType.NORMAL,
+                processType,
                 force_suffix,
                 suffix_offset,
                 save_expo ? Request.SaveBase.SAVEBASE_ALL : Request.SaveBase.SAVEBASE_NONE,
@@ -829,6 +850,7 @@ public class ImageSaver extends Thread {
                 is_front_facing,
                 mirror,
                 current_date,
+                preference_hdr_tonemapping_algorithm,
                 preference_hdr_contrast_enhancement,
                 iso,
                 exposure_time,
@@ -836,7 +858,7 @@ public class ImageSaver extends Thread {
                 preference_stamp, preference_textstamp, font_size, color, pref_style, preference_stamp_dateformat, preference_stamp_timeformat, preference_stamp_gpsformat,
                 //preference_stamp_geo_address,
                 preference_units_distance,
-                panorama_crop, store_location, location, store_geo_direction, geo_direction,
+                panorama_crop, remove_device_exif, store_location, location, store_geo_direction, geo_direction,
                 pitch_angle, store_ypr,
                 custom_tag_artist,
                 custom_tag_copyright,
@@ -942,6 +964,7 @@ public class ImageSaver extends Thread {
                 false,
                 false,
                 null,
+                HDRProcessor.default_tonemapping_algorithm_c,
                 null,
                 0,
                 0,
@@ -949,7 +972,7 @@ public class ImageSaver extends Thread {
                 null, null, 0, 0, null, null, null, null,
                 //null,
                 null,
-                false, false, null, false, 0.0,
+                false, Request.RemoveDeviceExif.OFF, false, null, false, 0.0,
                 0.0, false,
                 null, null,
                 1);
@@ -1573,7 +1596,7 @@ public class ImageSaver extends Thread {
                 Log.d(TAG, "before HDR first bitmap: " + bitmaps.get(0) + " is mutable? " + bitmaps.get(0).isMutable());
             try {
                 if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP ) {
-                    hdrProcessor.processHDR(bitmaps, true, null, true, null, hdr_alpha, 4, true, HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_REINHARD, HDRProcessor.DROTonemappingAlgorithm.DROALGORITHM_GAINGAMMA); // this will recycle all the bitmaps except bitmaps.get(0), which will contain the hdr image
+                    hdrProcessor.processHDR(bitmaps, true, null, true, null, hdr_alpha, 4, true, request.preference_hdr_tonemapping_algorithm, HDRProcessor.DROTonemappingAlgorithm.DROALGORITHM_GAINGAMMA); // this will recycle all the bitmaps except bitmaps.get(0), which will contain the hdr image
                 }
                 else {
                     Log.e(TAG, "shouldn't have offered HDR as an option if not on Android 5");
@@ -1694,10 +1717,10 @@ public class ImageSaver extends Thread {
                     }
 
                     if( saveFile != null ) {
-                        storageUtils.broadcastFile(saveFile, false, false, false);
+                        storageUtils.broadcastFile(saveFile, false, false, false, false, null);
                     }
                     else {
-                        broadcastSAFFile(saveUri, false, false);
+                        broadcastSAFFile(saveUri, false, false, false);
                     }
                 }
                 catch(IOException e) {
@@ -1818,6 +1841,9 @@ public class ImageSaver extends Thread {
             byte [] image = request.jpeg_images.get(i);
             boolean multiple_jpegs = request.jpeg_images.size() > 1 && !first_only;
             String filename_suffix = (multiple_jpegs || request.force_suffix) ? suffix + (i + request.suffix_offset) : "";
+            if( request.process_type == Request.ProcessType.X_NIGHT ) {
+                filename_suffix = "_Night" + filename_suffix;
+            }
             boolean share_image = share && (i == mid_image);
             if( !saveSingleImageNow(request, image, null, filename_suffix, update_thumbnail, share_image, false, false) ) {
                 if( MyDebug.LOG )
@@ -2344,19 +2370,15 @@ public class ImageSaver extends Thread {
             Log.d(TAG, "postProcessBitmap");
         long time_s = System.currentTimeMillis();
 
-        boolean dategeo_stamp = request.preference_stamp.equals("preference_stamp_yes");
-        boolean text_stamp = request.preference_textstamp.length() > 0;
-        if( bitmap != null || request.image_format != Request.ImageFormat.STD || request.do_auto_stabilise || request.mirror || dategeo_stamp || text_stamp ) {
-            // either we have a bitmap, or will need to decode the bitmap to do post-processing
-            if( !ignore_exif_orientation ) {
-                if( bitmap != null ) {
-                    // rotate the bitmap if necessary for exif tags
-                    if( MyDebug.LOG )
-                        Log.d(TAG, "rotate pre-existing bitmap for exif tags?");
-                    bitmap = rotateForExif(bitmap, data);
-                }
+        if( !ignore_exif_orientation ) {
+            if( bitmap != null ) {
+                // rotate the bitmap if necessary for exif tags
+                if( MyDebug.LOG )
+                    Log.d(TAG, "rotate pre-existing bitmap for exif tags?");
+                bitmap = rotateForExif(bitmap, data);
             }
         }
+
         if( request.do_auto_stabilise ) {
             bitmap = autoStabilise(data, bitmap, request.level_angle, request.is_front_facing);
         }
@@ -2376,6 +2398,18 @@ public class ImageSaver extends Thread {
                 throw new IOException();
             }
         }
+        if( request.remove_device_exif != Request.RemoveDeviceExif.OFF && bitmap == null ) {
+            if( MyDebug.LOG )
+                Log.d(TAG, "need to decode bitmap to strip exif tags");
+            // if removing device exif data, it's easier to do this by going through the codepath that
+            // resaves the bitmap, and then we avoid transferring/adding exif tags that we don't want
+            bitmap = loadBitmapWithRotation(data, true);
+            if( bitmap == null ) {
+                // if we can't load bitmap for removing device tags, don't want to continue
+                System.gc();
+                throw new IOException();
+            }
+        }
         bitmap = stampImage(request, data, bitmap);
         if( MyDebug.LOG ) {
             Log.d(TAG, "Save single image performance: time after photostamp: " + (System.currentTimeMillis() - time_s));
@@ -2663,9 +2697,11 @@ public class ImageSaver extends Thread {
                     storageUtils.clearLastMediaScanned();
                 }
 
+                boolean hasnoexifdatetime = request.remove_device_exif != Request.RemoveDeviceExif.OFF && request.remove_device_exif != Request.RemoveDeviceExif.KEEP_DATETIME;
+
                 if( picFile != null && saveUri == null ) {
                     // broadcast for SAF is done later, when we've actually written out the file
-                    storageUtils.broadcastFile(picFile, true, false, update_thumbnail);
+                    storageUtils.broadcastFile(picFile, true, false, update_thumbnail, hasnoexifdatetime, null);
                     main_activity.test_last_saved_image = picFile.getAbsolutePath();
                 }
 
@@ -2696,12 +2732,12 @@ public class ImageSaver extends Thread {
                             storageUtils.announceUri(saveUri, true, false);
                             if( update_thumbnail ) {
                                 // we also want to save the uri - we can use the media uri directly, rather than having to scan it
-                                storageUtils.setLastMediaScanned(saveUri, false);
+                                storageUtils.setLastMediaScanned(saveUri, false, hasnoexifdatetime, saveUri);
                             }
                         }
                     }
                     else {
-                        broadcastSAFFile(saveUri, update_thumbnail, request.image_capture_intent);
+                        broadcastSAFFile(saveUri, update_thumbnail, hasnoexifdatetime, request.image_capture_intent);
                     }
 
                     main_activity.test_last_saved_imageuri = saveUri;
@@ -2855,11 +2891,11 @@ public class ImageSaver extends Thread {
         }
     }
 
-    private void broadcastSAFFile(Uri saveUri, boolean set_last_scanned, boolean image_capture_intent) {
+    private void broadcastSAFFile(Uri saveUri, boolean set_last_scanned, boolean hasnoexifdatetime, boolean image_capture_intent) {
         if( MyDebug.LOG )
             Log.d(TAG, "broadcastSAFFile");
         StorageUtils storageUtils = main_activity.getStorageUtils();
-        storageUtils.broadcastUri(saveUri, true, false, set_last_scanned, image_capture_intent);
+        storageUtils.broadcastUri(saveUri, true, false, set_last_scanned, hasnoexifdatetime, image_capture_intent);
     }
 
     /** As setExifFromFile, but can read the Exif tags directly from the jpeg data, and to a file descriptor, rather than a file.
@@ -2883,32 +2919,20 @@ public class ImageSaver extends Thread {
         }
     }
 
-    /** Transfers exif tags from exif to exif_new, and then applies any extra Exif tags according to the preferences in the request.
-     *  Note that we use several ExifInterface tags that are now deprecated in API level 23 and 24. These are replaced with new tags that have
-     *  the same string value (e.g., TAG_APERTURE replaced with TAG_F_NUMBER, but both have value "FNumber"). We use the deprecated versions
-     *  to avoid complicating the code (we'd still have to read the deprecated values for older devices).
+    /** Transfers device exif info. Should only be called if request.remove_device_exif == Request.RemoveDeviceExif.OFF.
      */
-    private void setExif(final Request request, ExifInterface exif, ExifInterface exif_new) throws IOException {
+    private void transferDeviceExif(ExifInterface exif, ExifInterface exif_new) {
         if( MyDebug.LOG )
-            Log.d(TAG, "setExif");
+            Log.d(TAG, "transferDeviceExif");
 
         if( MyDebug.LOG )
             Log.d(TAG, "read back EXIF data");
+
         String exif_aperture = exif.getAttribute(ExifInterface.TAG_F_NUMBER); // previously TAG_APERTURE
-        String exif_datetime = exif.getAttribute(ExifInterface.TAG_DATETIME);
         String exif_exposure_time = exif.getAttribute(ExifInterface.TAG_EXPOSURE_TIME);
         String exif_flash = exif.getAttribute(ExifInterface.TAG_FLASH);
         String exif_focal_length = exif.getAttribute(ExifInterface.TAG_FOCAL_LENGTH);
-        String exif_gps_altitude = exif.getAttribute(ExifInterface.TAG_GPS_ALTITUDE);
-        String exif_gps_altitude_ref = exif.getAttribute(ExifInterface.TAG_GPS_ALTITUDE_REF);
-        String exif_gps_datestamp = exif.getAttribute(ExifInterface.TAG_GPS_DATESTAMP);
-        String exif_gps_latitude = exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE);
-        String exif_gps_latitude_ref = exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF);
-        String exif_gps_longitude = exif.getAttribute(ExifInterface.TAG_GPS_LONGITUDE);
-        String exif_gps_longitude_ref = exif.getAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF);
-        String exif_gps_processing_method = exif.getAttribute(ExifInterface.TAG_GPS_PROCESSING_METHOD);
-        String exif_gps_timestamp = exif.getAttribute(ExifInterface.TAG_GPS_TIMESTAMP);
-        // leave width/height, as this may have changed! similarly TAG_IMAGE_LENGTH?
+        // leave TAG_IMAGE_WIDTH/TAG_IMAGE_LENGTH, as this may have changed!
         //noinspection deprecation
         String exif_iso = exif.getAttribute(ExifInterface.TAG_ISO_SPEED_RATINGS); // previously TAG_ISO
         String exif_make = exif.getAttribute(ExifInterface.TAG_MAKE);
@@ -2916,19 +2940,6 @@ public class ImageSaver extends Thread {
         // leave orientation - since we rotate bitmaps to account for orientation, we don't want to write it to the saved image!
         String exif_white_balance = exif.getAttribute(ExifInterface.TAG_WHITE_BALANCE);
 
-        String exif_datetime_digitized;
-        String exif_subsec_time;
-        String exif_subsec_time_dig;
-        String exif_subsec_time_orig;
-        {
-            // tags that are new in Android M - note we skip tags unlikely to be relevant for camera photos
-            // update, now available in all Android versions thanks to using AndroidX ExifInterface
-            exif_datetime_digitized = exif.getAttribute(ExifInterface.TAG_DATETIME_DIGITIZED);
-            exif_subsec_time = exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME);
-            exif_subsec_time_dig = exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME_DIGITIZED); // previously TAG_SUBSEC_TIME_DIG
-            exif_subsec_time_orig = exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME_ORIGINAL); // previously TAG_SUBSEC_TIME_ORIG
-        }
-
         String exif_aperture_value;
         String exif_brightness_value;
         String exif_cfa_pattern;
@@ -2937,7 +2948,6 @@ public class ImageSaver extends Thread {
         String exif_compressed_bits_per_pixel;
         String exif_compression;
         String exif_contrast;
-        String exif_datetime_original;
         String exif_device_setting_description;
         String exif_digital_zoom_ratio;
         String exif_exposure_bias_value;
@@ -2980,7 +2990,6 @@ public class ImageSaver extends Thread {
             exif_compressed_bits_per_pixel = exif.getAttribute(ExifInterface.TAG_COMPRESSED_BITS_PER_PIXEL);
             exif_compression = exif.getAttribute(ExifInterface.TAG_COMPRESSION);
             exif_contrast = exif.getAttribute(ExifInterface.TAG_CONTRAST);
-            exif_datetime_original = exif.getAttribute(ExifInterface.TAG_DATETIME_ORIGINAL);
             exif_device_setting_description = exif.getAttribute(ExifInterface.TAG_DEVICE_SETTING_DESCRIPTION);
             exif_digital_zoom_ratio = exif.getAttribute(ExifInterface.TAG_DIGITAL_ZOOM_RATIO);
             // unclear if we should transfer TAG_EXIF_VERSION - don't want to risk conficting with whatever ExifInterface writes itself
@@ -3003,7 +3012,7 @@ public class ImageSaver extends Thread {
             // don't care about TAG_GPS_MAP_DATUM?
             exif_gps_measure_mode = exif.getAttribute(ExifInterface.TAG_GPS_MEASURE_MODE);
             // don't care about TAG_GPS_SATELLITES?
-            // don't care about TAG_GPS_SPEED, TAG_GPS_SPEED_REF, TAG_GPS_STATUS, TAG_GPS_TRACK, TAG_GPS_TRACK_REF, TAG_GPS_VERSION_ID
+            // don't care about TAG_GPS_STATUS, TAG_GPS_TRACK, TAG_GPS_TRACK_REF, TAG_GPS_VERSION_ID
             exif_image_description = exif.getAttribute(ExifInterface.TAG_IMAGE_DESCRIPTION);
             // unclear what TAG_IMAGE_UNIQUE_ID, TAG_INTEROPERABILITY_INDEX are
             // TAG_ISO_SPEED_RATINGS same as TAG_ISO
@@ -3040,36 +3049,26 @@ public class ImageSaver extends Thread {
             // don't care about TAG_Y_*?
         }
 
+        String exif_photographic_sensitivity = exif.getAttribute(ExifInterface.TAG_PHOTOGRAPHIC_SENSITIVITY);
+        String exif_sensitivity_type = exif.getAttribute(ExifInterface.TAG_SENSITIVITY_TYPE);
+        String exif_standard_output_sensitivity = exif.getAttribute(ExifInterface.TAG_STANDARD_OUTPUT_SENSITIVITY);
+        String exif_recommended_exposure_index = exif.getAttribute(ExifInterface.TAG_RECOMMENDED_EXPOSURE_INDEX);
+        String exif_iso_speed = exif.getAttribute(ExifInterface.TAG_ISO_SPEED);
+        String exif_custom_rendered = exif.getAttribute(ExifInterface.TAG_CUSTOM_RENDERED);
+        String exif_lens_specification = exif.getAttribute(ExifInterface.TAG_LENS_SPECIFICATION);
+        String exif_lens_name = exif.getAttribute(ExifInterface.TAG_LENS_MAKE);
+        String exif_lens_model = exif.getAttribute(ExifInterface.TAG_LENS_MODEL);
+
         if( MyDebug.LOG )
             Log.d(TAG, "now write new EXIF data");
         if( exif_aperture != null )
             exif_new.setAttribute(ExifInterface.TAG_F_NUMBER, exif_aperture);
-        if( exif_datetime != null )
-            exif_new.setAttribute(ExifInterface.TAG_DATETIME, exif_datetime);
         if( exif_exposure_time != null )
             exif_new.setAttribute(ExifInterface.TAG_EXPOSURE_TIME, exif_exposure_time);
         if( exif_flash != null )
             exif_new.setAttribute(ExifInterface.TAG_FLASH, exif_flash);
         if( exif_focal_length != null )
             exif_new.setAttribute(ExifInterface.TAG_FOCAL_LENGTH, exif_focal_length);
-        if( exif_gps_altitude != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_ALTITUDE, exif_gps_altitude);
-        if( exif_gps_altitude_ref != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_ALTITUDE_REF, exif_gps_altitude_ref);
-        if( exif_gps_datestamp != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_DATESTAMP, exif_gps_datestamp);
-        if( exif_gps_latitude != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_LATITUDE, exif_gps_latitude);
-        if( exif_gps_latitude_ref != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_LATITUDE_REF, exif_gps_latitude_ref);
-        if( exif_gps_longitude != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_LONGITUDE, exif_gps_longitude);
-        if( exif_gps_longitude_ref != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF, exif_gps_longitude_ref);
-        if( exif_gps_processing_method != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_PROCESSING_METHOD, exif_gps_processing_method);
-        if( exif_gps_timestamp != null )
-            exif_new.setAttribute(ExifInterface.TAG_GPS_TIMESTAMP, exif_gps_timestamp);
         if( exif_iso != null )
             //noinspection deprecation
             exif_new.setAttribute(ExifInterface.TAG_ISO_SPEED_RATINGS, exif_iso);
@@ -3080,17 +3079,6 @@ public class ImageSaver extends Thread {
         if( exif_white_balance != null )
             exif_new.setAttribute(ExifInterface.TAG_WHITE_BALANCE, exif_white_balance);
 
-        {
-            if( exif_datetime_digitized != null )
-                exif_new.setAttribute(ExifInterface.TAG_DATETIME_DIGITIZED, exif_datetime_digitized);
-            if( exif_subsec_time != null )
-                exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME, exif_subsec_time);
-            if( exif_subsec_time_dig != null )
-                exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME_DIGITIZED, exif_subsec_time_dig);
-            if( exif_subsec_time_orig != null )
-                exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME_ORIGINAL, exif_subsec_time_orig);
-        }
-
         {
             if( exif_aperture_value != null )
                 exif_new.setAttribute(ExifInterface.TAG_APERTURE_VALUE, exif_aperture_value);
@@ -3108,8 +3096,6 @@ public class ImageSaver extends Thread {
                 exif_new.setAttribute(ExifInterface.TAG_COMPRESSION, exif_compression);
             if( exif_contrast != null )
                 exif_new.setAttribute(ExifInterface.TAG_CONTRAST, exif_contrast);
-            if( exif_datetime_original != null )
-                exif_new.setAttribute(ExifInterface.TAG_DATETIME_ORIGINAL, exif_datetime_original);
             if( exif_device_setting_description != null )
                 exif_new.setAttribute(ExifInterface.TAG_DEVICE_SETTING_DESCRIPTION, exif_device_setting_description);
             if( exif_digital_zoom_ratio != null )
@@ -3174,8 +3160,329 @@ public class ImageSaver extends Thread {
                 exif_new.setAttribute(ExifInterface.TAG_USER_COMMENT, exif_user_comment);
         }
 
-        modifyExif(exif_new, request.type == Request.Type.JPEG, request.using_camera2, request.using_camera_extensions, request.current_date, request.store_location, request.location, request.store_geo_direction, request.geo_direction, request.custom_tag_artist, request.custom_tag_copyright, request.level_angle, request.pitch_angle, request.store_ypr);
-        setDateTimeExif(exif_new);
+        if( exif_photographic_sensitivity != null )
+            exif_new.setAttribute(ExifInterface.TAG_PHOTOGRAPHIC_SENSITIVITY, exif_photographic_sensitivity);
+        if( exif_sensitivity_type != null )
+            exif_new.setAttribute(ExifInterface.TAG_SENSITIVITY_TYPE, exif_sensitivity_type);
+        if( exif_standard_output_sensitivity != null )
+            exif_new.setAttribute(ExifInterface.TAG_STANDARD_OUTPUT_SENSITIVITY, exif_standard_output_sensitivity);
+        if( exif_recommended_exposure_index != null )
+            exif_new.setAttribute(ExifInterface.TAG_RECOMMENDED_EXPOSURE_INDEX, exif_recommended_exposure_index);
+        if( exif_iso_speed != null )
+            exif_new.setAttribute(ExifInterface.TAG_ISO_SPEED, exif_iso_speed);
+        if( exif_custom_rendered != null )
+            exif_new.setAttribute(ExifInterface.TAG_CUSTOM_RENDERED, exif_custom_rendered);
+        if( exif_lens_specification != null )
+            exif_new.setAttribute(ExifInterface.TAG_LENS_SPECIFICATION, exif_lens_specification);
+        if( exif_lens_name != null )
+            exif_new.setAttribute(ExifInterface.TAG_LENS_MAKE, exif_lens_name);
+        if( exif_lens_model != null )
+            exif_new.setAttribute(ExifInterface.TAG_LENS_MODEL, exif_lens_model);
+
+    }
+
+    /** Transfers device exif info related to date and time.
+     */
+    private void transferDeviceExifDateTime(ExifInterface exif, ExifInterface exif_new) {
+        if( MyDebug.LOG )
+            Log.d(TAG, "transferDeviceExifDateTime");
+
+        // tags related to date and time
+
+        String exif_datetime = exif.getAttribute(ExifInterface.TAG_DATETIME);
+        String exif_datetime_original = exif.getAttribute(ExifInterface.TAG_DATETIME_ORIGINAL);
+        String exif_datetime_digitized = exif.getAttribute(ExifInterface.TAG_DATETIME_DIGITIZED);
+        String exif_subsec_time = exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME);
+        String exif_subsec_time_orig = exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME_ORIGINAL); // previously TAG_SUBSEC_TIME_ORIG
+        String exif_subsec_time_dig = exif.getAttribute(ExifInterface.TAG_SUBSEC_TIME_DIGITIZED); // previously TAG_SUBSEC_TIME_DIG
+        String exif_offset_time = exif.getAttribute(ExifInterface.TAG_OFFSET_TIME);
+        String exif_offset_time_orig = exif.getAttribute(ExifInterface.TAG_OFFSET_TIME_ORIGINAL);
+        String exif_offset_time_dig = exif.getAttribute(ExifInterface.TAG_OFFSET_TIME_DIGITIZED);
+
+        if( exif_datetime != null )
+            exif_new.setAttribute(ExifInterface.TAG_DATETIME, exif_datetime);
+        if( exif_datetime_original != null )
+            exif_new.setAttribute(ExifInterface.TAG_DATETIME_ORIGINAL, exif_datetime_original);
+        if( exif_datetime_digitized != null )
+            exif_new.setAttribute(ExifInterface.TAG_DATETIME_DIGITIZED, exif_datetime_digitized);
+        if( exif_subsec_time != null )
+            exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME, exif_subsec_time);
+        if( exif_subsec_time_orig != null )
+            exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME_ORIGINAL, exif_subsec_time_orig);
+        if( exif_subsec_time_dig != null )
+            exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME_DIGITIZED, exif_subsec_time_dig);
+        if( exif_offset_time != null )
+            exif_new.setAttribute(ExifInterface.TAG_OFFSET_TIME, exif_offset_time);
+        if( exif_offset_time_orig != null )
+            exif_new.setAttribute(ExifInterface.TAG_OFFSET_TIME_ORIGINAL, exif_offset_time_orig);
+        if( exif_offset_time_dig != null )
+            exif_new.setAttribute(ExifInterface.TAG_OFFSET_TIME_DIGITIZED, exif_offset_time_dig);
+
+    }
+
+    /** Transfers device exif info related to gps location.
+     */
+    private void transferDeviceExifGPS(ExifInterface exif, ExifInterface exif_new) {
+        if( MyDebug.LOG )
+            Log.d(TAG, "transferDeviceExifGPS");
+
+        // tags for gps info
+
+        String exif_gps_processing_method = exif.getAttribute(ExifInterface.TAG_GPS_PROCESSING_METHOD);
+        String exif_gps_latitude = exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE);
+        String exif_gps_latitude_ref = exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF);
+        String exif_gps_longitude = exif.getAttribute(ExifInterface.TAG_GPS_LONGITUDE);
+        String exif_gps_longitude_ref = exif.getAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF);
+        String exif_gps_altitude = exif.getAttribute(ExifInterface.TAG_GPS_ALTITUDE);
+        String exif_gps_altitude_ref = exif.getAttribute(ExifInterface.TAG_GPS_ALTITUDE_REF);
+        String exif_gps_datestamp = exif.getAttribute(ExifInterface.TAG_GPS_DATESTAMP);
+        String exif_gps_timestamp = exif.getAttribute(ExifInterface.TAG_GPS_TIMESTAMP);
+        String exif_gps_speed = exif.getAttribute(ExifInterface.TAG_GPS_SPEED);
+        String exif_gps_speed_ref = exif.getAttribute(ExifInterface.TAG_GPS_SPEED_REF);
+
+        if( exif_gps_processing_method != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_PROCESSING_METHOD, exif_gps_processing_method);
+        if( exif_gps_latitude != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_LATITUDE, exif_gps_latitude);
+        if( exif_gps_latitude_ref != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_LATITUDE_REF, exif_gps_latitude_ref);
+        if( exif_gps_longitude != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_LONGITUDE, exif_gps_longitude);
+        if( exif_gps_longitude_ref != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF, exif_gps_longitude_ref);
+        if( exif_gps_altitude != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_ALTITUDE, exif_gps_altitude);
+        if( exif_gps_altitude_ref != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_ALTITUDE_REF, exif_gps_altitude_ref);
+        if( exif_gps_datestamp != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DATESTAMP, exif_gps_datestamp);
+        if( exif_gps_timestamp != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_TIMESTAMP, exif_gps_timestamp);
+        if( exif_gps_speed != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_SPEED, exif_gps_speed);
+        if( exif_gps_speed_ref != null )
+            exif_new.setAttribute(ExifInterface.TAG_GPS_SPEED_REF, exif_gps_speed_ref);
+    }
+
+    /** Explicitly removes tags based on the RemoveDeviceExif option.
+     *  Note that in theory this method is unnecessary: we implement the RemoveDeviceExif options
+     *  (if not OFF) by resaving the JPEG via a bitmap, and then limiting what Exif tags are
+     *  transferred across. This method is for extra paranoia: first to reduce the risk of future
+     *  bugs, secondly just in case saving via a bitmap does ever add exif tags.
+     */
+    private void removeExifTags(ExifInterface exif_new, final Request request) {
+        if( MyDebug.LOG )
+            Log.d(TAG, "removeExifTags");
+
+        if( request.remove_device_exif != Request.RemoveDeviceExif.OFF ) {
+            if( MyDebug.LOG )
+                Log.d(TAG, "remove exif tags");
+            exif_new.setAttribute(ExifInterface.TAG_F_NUMBER, null);
+            exif_new.setAttribute(ExifInterface.TAG_EXPOSURE_TIME, null);
+            exif_new.setAttribute(ExifInterface.TAG_FLASH, null);
+            exif_new.setAttribute(ExifInterface.TAG_FOCAL_LENGTH, null);
+            exif_new.setAttribute(ExifInterface.TAG_IMAGE_WIDTH, null);
+            exif_new.setAttribute(ExifInterface.TAG_IMAGE_LENGTH, null);
+            //noinspection deprecation
+            exif_new.setAttribute(ExifInterface.TAG_ISO_SPEED_RATINGS, null);
+            exif_new.setAttribute(ExifInterface.TAG_PHOTOGRAPHIC_SENSITIVITY, null);
+            exif_new.setAttribute(ExifInterface.TAG_MAKE, null);
+            exif_new.setAttribute(ExifInterface.TAG_MODEL, null);
+            exif_new.setAttribute(ExifInterface.TAG_WHITE_BALANCE, null);
+            exif_new.setAttribute(ExifInterface.TAG_APERTURE_VALUE, null);
+            exif_new.setAttribute(ExifInterface.TAG_BRIGHTNESS_VALUE, null);
+            exif_new.setAttribute(ExifInterface.TAG_CFA_PATTERN, null);
+            exif_new.setAttribute(ExifInterface.TAG_COLOR_SPACE, null);
+            exif_new.setAttribute(ExifInterface.TAG_COMPONENTS_CONFIGURATION, null);
+            exif_new.setAttribute(ExifInterface.TAG_COMPRESSED_BITS_PER_PIXEL, null);
+            exif_new.setAttribute(ExifInterface.TAG_COMPRESSION, null);
+            exif_new.setAttribute(ExifInterface.TAG_CONTRAST, null);
+            exif_new.setAttribute(ExifInterface.TAG_DEVICE_SETTING_DESCRIPTION, null);
+            exif_new.setAttribute(ExifInterface.TAG_DIGITAL_ZOOM_RATIO, null);
+            exif_new.setAttribute(ExifInterface.TAG_EXPOSURE_BIAS_VALUE, null);
+            exif_new.setAttribute(ExifInterface.TAG_EXPOSURE_INDEX, null);
+            exif_new.setAttribute(ExifInterface.TAG_EXPOSURE_MODE, null);
+            exif_new.setAttribute(ExifInterface.TAG_EXPOSURE_PROGRAM, null);
+            exif_new.setAttribute(ExifInterface.TAG_FLASH_ENERGY, null);
+            exif_new.setAttribute(ExifInterface.TAG_FOCAL_LENGTH_IN_35MM_FILM, null);
+            exif_new.setAttribute(ExifInterface.TAG_FOCAL_PLANE_RESOLUTION_UNIT, null);
+            exif_new.setAttribute(ExifInterface.TAG_FOCAL_PLANE_X_RESOLUTION, null);
+            exif_new.setAttribute(ExifInterface.TAG_FOCAL_PLANE_Y_RESOLUTION, null);
+            exif_new.setAttribute(ExifInterface.TAG_GAIN_CONTROL, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_AREA_INFORMATION, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DEST_BEARING, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DEST_BEARING_REF, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DEST_DISTANCE, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DEST_DISTANCE_REF, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DEST_LATITUDE, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DEST_LATITUDE_REF, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DEST_LONGITUDE, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DEST_LONGITUDE_REF, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DIFFERENTIAL, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_DOP, null);
+            if( !request.store_geo_direction ) {
+                exif_new.setAttribute(ExifInterface.TAG_GPS_IMG_DIRECTION, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_IMG_DIRECTION_REF, null);
+            }
+            exif_new.setAttribute(ExifInterface.TAG_GPS_MAP_DATUM, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_MEASURE_MODE, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_SATELLITES, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_STATUS, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_TRACK, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_TRACK_REF, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_VERSION_ID, null);
+            exif_new.setAttribute(ExifInterface.TAG_IMAGE_DESCRIPTION, null);
+            exif_new.setAttribute(ExifInterface.TAG_IMAGE_UNIQUE_ID, null);
+            exif_new.setAttribute(ExifInterface.TAG_INTEROPERABILITY_INDEX, null);
+            exif_new.setAttribute(ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT, null);
+            exif_new.setAttribute(ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH, null);
+            exif_new.setAttribute(ExifInterface.TAG_LIGHT_SOURCE, null);
+            exif_new.setAttribute(ExifInterface.TAG_MAKER_NOTE, null);
+            exif_new.setAttribute(ExifInterface.TAG_MAX_APERTURE_VALUE, null);
+            exif_new.setAttribute(ExifInterface.TAG_METERING_MODE, null);
+            exif_new.setAttribute(ExifInterface.TAG_OECF, null);
+            exif_new.setAttribute(ExifInterface.TAG_PHOTOMETRIC_INTERPRETATION, null);
+            exif_new.setAttribute(ExifInterface.TAG_PIXEL_X_DIMENSION, null);
+            exif_new.setAttribute(ExifInterface.TAG_PIXEL_Y_DIMENSION, null);
+            exif_new.setAttribute(ExifInterface.TAG_PLANAR_CONFIGURATION, null);
+            exif_new.setAttribute(ExifInterface.TAG_PRIMARY_CHROMATICITIES, null);
+            exif_new.setAttribute(ExifInterface.TAG_REFERENCE_BLACK_WHITE, null);
+            exif_new.setAttribute(ExifInterface.TAG_RESOLUTION_UNIT, null);
+            exif_new.setAttribute(ExifInterface.TAG_ROWS_PER_STRIP, null);
+            exif_new.setAttribute(ExifInterface.TAG_SAMPLES_PER_PIXEL, null);
+            exif_new.setAttribute(ExifInterface.TAG_SATURATION, null);
+            exif_new.setAttribute(ExifInterface.TAG_SCENE_CAPTURE_TYPE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SCENE_TYPE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SENSING_METHOD, null);
+            exif_new.setAttribute(ExifInterface.TAG_SHARPNESS, null);
+            exif_new.setAttribute(ExifInterface.TAG_SHUTTER_SPEED_VALUE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SOFTWARE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SPATIAL_FREQUENCY_RESPONSE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SPECTRAL_SENSITIVITY, null);
+            exif_new.setAttribute(ExifInterface.TAG_STRIP_BYTE_COUNTS, null);
+            exif_new.setAttribute(ExifInterface.TAG_STRIP_OFFSETS, null);
+            exif_new.setAttribute(ExifInterface.TAG_SUBJECT_AREA, null);
+            exif_new.setAttribute(ExifInterface.TAG_SUBJECT_DISTANCE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SUBJECT_DISTANCE_RANGE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SUBJECT_LOCATION, null);
+            exif_new.setAttribute(ExifInterface.TAG_THUMBNAIL_IMAGE_WIDTH, null);
+            exif_new.setAttribute(ExifInterface.TAG_THUMBNAIL_IMAGE_LENGTH, null);
+            exif_new.setAttribute(ExifInterface.TAG_TRANSFER_FUNCTION, null);
+            if( !request.store_ypr ) {
+                exif_new.setAttribute(ExifInterface.TAG_USER_COMMENT, null);
+            }
+            exif_new.setAttribute(ExifInterface.TAG_WHITE_POINT, null);
+            exif_new.setAttribute(ExifInterface.TAG_X_RESOLUTION, null);
+            exif_new.setAttribute(ExifInterface.TAG_Y_CB_CR_COEFFICIENTS, null);
+            exif_new.setAttribute(ExifInterface.TAG_Y_CB_CR_POSITIONING, null);
+            exif_new.setAttribute(ExifInterface.TAG_Y_CB_CR_SUB_SAMPLING, null);
+            exif_new.setAttribute(ExifInterface.TAG_Y_RESOLUTION, null);
+            if( !(request.custom_tag_artist != null && request.custom_tag_artist.length() > 0) ) {
+                exif_new.setAttribute(ExifInterface.TAG_ARTIST, null);
+            }
+            if( !(request.custom_tag_copyright != null && request.custom_tag_copyright.length() > 0) ) {
+                exif_new.setAttribute(ExifInterface.TAG_COPYRIGHT, null);
+            }
+
+            exif_new.setAttribute(ExifInterface.TAG_BITS_PER_SAMPLE, null);
+            exif_new.setAttribute(ExifInterface.TAG_EXIF_VERSION, null);
+            exif_new.setAttribute(ExifInterface.TAG_FLASHPIX_VERSION, null);
+            exif_new.setAttribute(ExifInterface.TAG_GAMMA, null);
+            exif_new.setAttribute(ExifInterface.TAG_RELATED_SOUND_FILE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SENSITIVITY_TYPE, null);
+            exif_new.setAttribute(ExifInterface.TAG_STANDARD_OUTPUT_SENSITIVITY, null);
+            exif_new.setAttribute(ExifInterface.TAG_RECOMMENDED_EXPOSURE_INDEX, null);
+            exif_new.setAttribute(ExifInterface.TAG_ISO_SPEED, null);
+            exif_new.setAttribute(ExifInterface.TAG_ISO_SPEED_LATITUDE_YYY, null);
+            exif_new.setAttribute(ExifInterface.TAG_ISO_SPEED_LATITUDE_ZZZ, null);
+            exif_new.setAttribute(ExifInterface.TAG_FILE_SOURCE, null);
+            exif_new.setAttribute(ExifInterface.TAG_CUSTOM_RENDERED, null);
+            exif_new.setAttribute(ExifInterface.TAG_CAMERA_OWNER_NAME, null);
+            exif_new.setAttribute(ExifInterface.TAG_BODY_SERIAL_NUMBER, null);
+            exif_new.setAttribute(ExifInterface.TAG_LENS_SPECIFICATION, null);
+            exif_new.setAttribute(ExifInterface.TAG_LENS_MAKE, null);
+            exif_new.setAttribute(ExifInterface.TAG_LENS_MODEL, null);
+            exif_new.setAttribute(ExifInterface.TAG_LENS_SERIAL_NUMBER, null);
+            exif_new.setAttribute(ExifInterface.TAG_GPS_H_POSITIONING_ERROR, null);
+            exif_new.setAttribute(ExifInterface.TAG_DNG_VERSION, null);
+            exif_new.setAttribute(ExifInterface.TAG_DEFAULT_CROP_SIZE, null);
+            exif_new.setAttribute(ExifInterface.TAG_ORF_THUMBNAIL_IMAGE, null);
+            exif_new.setAttribute(ExifInterface.TAG_ORF_PREVIEW_IMAGE_START, null);
+            exif_new.setAttribute(ExifInterface.TAG_ORF_PREVIEW_IMAGE_LENGTH, null);
+            exif_new.setAttribute(ExifInterface.TAG_ORF_ASPECT_FRAME, null);
+            exif_new.setAttribute(ExifInterface.TAG_RW2_SENSOR_BOTTOM_BORDER, null);
+            exif_new.setAttribute(ExifInterface.TAG_RW2_SENSOR_LEFT_BORDER, null);
+            exif_new.setAttribute(ExifInterface.TAG_RW2_SENSOR_RIGHT_BORDER, null);
+            exif_new.setAttribute(ExifInterface.TAG_RW2_SENSOR_TOP_BORDER, null);
+            exif_new.setAttribute(ExifInterface.TAG_RW2_ISO, null);
+            exif_new.setAttribute(ExifInterface.TAG_RW2_JPG_FROM_RAW, null);
+            exif_new.setAttribute(ExifInterface.TAG_XMP, null);
+            exif_new.setAttribute(ExifInterface.TAG_NEW_SUBFILE_TYPE, null);
+            exif_new.setAttribute(ExifInterface.TAG_SUBFILE_TYPE, null);
+
+            if( request.remove_device_exif != Request.RemoveDeviceExif.KEEP_DATETIME ) {
+                if( MyDebug.LOG )
+                    Log.d(TAG, "remove datetime tags");
+                exif_new.setAttribute(ExifInterface.TAG_DATETIME, null);
+                exif_new.setAttribute(ExifInterface.TAG_DATETIME_ORIGINAL, null);
+                exif_new.setAttribute(ExifInterface.TAG_DATETIME_DIGITIZED, null);
+                exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME, null);
+                exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME_ORIGINAL, null);
+                exif_new.setAttribute(ExifInterface.TAG_SUBSEC_TIME_DIGITIZED, null);
+                exif_new.setAttribute(ExifInterface.TAG_OFFSET_TIME, null);
+                exif_new.setAttribute(ExifInterface.TAG_OFFSET_TIME_ORIGINAL, null);
+                exif_new.setAttribute(ExifInterface.TAG_OFFSET_TIME_DIGITIZED, null);
+            }
+
+            if( !request.store_location ) {
+                if( MyDebug.LOG )
+                    Log.d(TAG, "remove gps tags");
+                exif_new.setAttribute(ExifInterface.TAG_GPS_PROCESSING_METHOD, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_LATITUDE, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_LATITUDE_REF, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_LONGITUDE, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_ALTITUDE, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_ALTITUDE_REF, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_DATESTAMP, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_TIMESTAMP, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_SPEED, null);
+                exif_new.setAttribute(ExifInterface.TAG_GPS_SPEED_REF, null);
+            }
+        }
+    }
+
+    /** Transfers exif tags from exif to exif_new, and then applies any extra Exif tags according to the preferences in the request.
+     *  Note that we use several ExifInterface tags that are now deprecated in API level 23 and 24. These are replaced with new tags that have
+     *  the same string value (e.g., TAG_APERTURE replaced with TAG_F_NUMBER, but both have value "FNumber"). We use the deprecated versions
+     *  to avoid complicating the code (we'd still have to read the deprecated values for older devices).
+     */
+    private void setExif(final Request request, ExifInterface exif, ExifInterface exif_new) throws IOException {
+        if( MyDebug.LOG )
+            Log.d(TAG, "setExif");
+
+        if( request.remove_device_exif == Request.RemoveDeviceExif.OFF ) {
+            transferDeviceExif(exif, exif_new);
+        }
+
+        if( request.remove_device_exif == Request.RemoveDeviceExif.OFF || request.remove_device_exif == Request.RemoveDeviceExif.KEEP_DATETIME ) {
+            transferDeviceExifDateTime(exif, exif_new);
+        }
+
+        if( request.remove_device_exif == Request.RemoveDeviceExif.OFF || request.store_location ) {
+            // If geotagging is enabled, we explicitly override the remove_device_exif setting.
+            // Arguably we don't need an if statement here at all - but if there was some device strangely
+            // setting GPS tags even when we haven't set them, it's better to remove them if the user has
+            // requested RemoveDeviceExif.OFF.
+            transferDeviceExifGPS(exif, exif_new);
+        }
+
+        modifyExif(exif_new, request.remove_device_exif, request.type == Request.Type.JPEG, request.using_camera2, request.using_camera_extensions, request.current_date, request.store_location, request.location, request.store_geo_direction, request.geo_direction, request.custom_tag_artist, request.custom_tag_copyright, request.level_angle, request.pitch_angle, request.store_ypr);
+        if( request.remove_device_exif == Request.RemoveDeviceExif.OFF || request.remove_device_exif == Request.RemoveDeviceExif.KEEP_DATETIME ) {
+            setDateTimeExif(exif_new);
+        }
+
+        removeExifTags(exif_new, request); // must be last, before saving attributes
         exif_new.saveAttributes();
     }
 
@@ -3294,8 +3601,11 @@ public class ImageSaver extends Thread {
                 storageUtils.clearLastMediaScanned();
             }
 
+            // n.b., at time of writing, remove_device_exif will always be OFF for RAW, but have added the code for future proofing
+            boolean hasnoexifdatetime = request.remove_device_exif != Request.RemoveDeviceExif.OFF && request.remove_device_exif != Request.RemoveDeviceExif.KEEP_DATETIME;
+
             if( saveUri == null ) {
-                storageUtils.broadcastFile(picFile, true, false, raw_only);
+                storageUtils.broadcastFile(picFile, true, false, raw_only, hasnoexifdatetime, null);
             }
             else if( use_media_store ) {
                 if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ) {
@@ -3313,11 +3623,11 @@ public class ImageSaver extends Thread {
 
                 if( raw_only ) {
                     // we also want to save the uri - we can use the media uri directly, rather than having to scan it
-                    storageUtils.setLastMediaScanned(saveUri, true);
+                    storageUtils.setLastMediaScanned(saveUri, true, hasnoexifdatetime, saveUri);
                 }
             }
             else {
-                storageUtils.broadcastUri(saveUri, true, false, raw_only, false);
+                storageUtils.broadcastUri(saveUri, true, false, raw_only, hasnoexifdatetime, false);
             }
         }
         catch(FileNotFoundException e) {
@@ -3533,17 +3843,26 @@ public class ImageSaver extends Thread {
     private void updateExif(Request request, File picFile, Uri saveUri) throws IOException {
         if( MyDebug.LOG )
             Log.d(TAG, "updateExif: " + picFile);
-        if( request.store_geo_direction || request.store_ypr || hasCustomExif(request.custom_tag_artist, request.custom_tag_copyright) || request.using_camera_extensions ) {
+        if( request.store_geo_direction || request.store_ypr || hasCustomExif(request.custom_tag_artist, request.custom_tag_copyright) ||
+                request.using_camera_extensions || // when using camera extensions, we need to call modifyExif() to fix up various missing tags
+                needGPSExifFix(request.type == Request.Type.JPEG, request.using_camera2, request.store_location) ) {
             long time_s = System.currentTimeMillis();
             if( MyDebug.LOG )
                 Log.d(TAG, "add additional exif info");
             try {
                 ExifInterfaceHolder exif_holder = createExifInterface(picFile, saveUri);
+                if( MyDebug.LOG )
+                    Log.d(TAG, "*** time after create exif: " + (System.currentTimeMillis() - time_s));
                 try {
                     ExifInterface exif = exif_holder.getExif();
                     if( exif != null ) {
-                        modifyExif(exif, request.type == Request.Type.JPEG, request.using_camera2, request.using_camera_extensions, request.current_date, request.store_location, request.location, request.store_geo_direction, request.geo_direction, request.custom_tag_artist, request.custom_tag_copyright, request.level_angle, request.pitch_angle, request.store_ypr);
+                        modifyExif(exif, request.remove_device_exif, request.type == Request.Type.JPEG, request.using_camera2, request.using_camera_extensions, request.current_date, request.store_location, request.location, request.store_geo_direction, request.geo_direction, request.custom_tag_artist, request.custom_tag_copyright, request.level_angle, request.pitch_angle, request.store_ypr);
+
+                        if( MyDebug.LOG )
+                            Log.d(TAG, "*** time after modifyExif: " + (System.currentTimeMillis() - time_s));
                         exif.saveAttributes();
+                        if( MyDebug.LOG )
+                            Log.d(TAG, "*** time after saveAttributes: " + (System.currentTimeMillis() - time_s));
                     }
                 }
                 finally {
@@ -3559,29 +3878,6 @@ public class ImageSaver extends Thread {
             if( MyDebug.LOG )
                 Log.d(TAG, "*** time to add additional exif info: " + (System.currentTimeMillis() - time_s));
         }
-        else if( needGPSTimestampHack(request.type == Request.Type.JPEG, request.using_camera2, request.store_location) ) {
-            if( MyDebug.LOG )
-                Log.d(TAG, "remove GPS timestamp hack");
-            try {
-                ExifInterfaceHolder exif_holder = createExifInterface(picFile, saveUri);
-                try {
-                    ExifInterface exif = exif_holder.getExif();
-                    if( exif != null ) {
-                        fixGPSTimestamp(exif, request.current_date);
-                        exif.saveAttributes();
-                    }
-                }
-                finally {
-                    exif_holder.close();
-                }
-            }
-            catch(NoClassDefFoundError exception) {
-                // have had Google Play crashes from new ExifInterface() elsewhere for Galaxy Ace4 (vivalto3g), Galaxy S Duos3 (vivalto3gvn), so also catch here just in case
-                if( MyDebug.LOG )
-                    Log.e(TAG, "exif orientation NoClassDefFoundError");
-                exception.printStackTrace();
-            }
-        }
         else {
             if( MyDebug.LOG )
                 Log.d(TAG, "no exif data to update for: " + picFile);
@@ -3589,8 +3885,9 @@ public class ImageSaver extends Thread {
     }
 
     /** Makes various modifications to the exif data, if necessary.
+     *  Any fix-ups should respect the setting of RemoveDeviceExif!
      */
-    private void modifyExif(ExifInterface exif, boolean is_jpeg, boolean using_camera2, boolean using_camera_extensions, Date current_date, boolean store_location, Location location, boolean store_geo_direction, double geo_direction, String custom_tag_artist, String custom_tag_copyright, double level_angle, double pitch_angle, boolean store_ypr) {
+    private void modifyExif(ExifInterface exif, Request.RemoveDeviceExif remove_device_exif, boolean is_jpeg, boolean using_camera2, boolean using_camera_extensions, Date current_date, boolean store_location, Location location, boolean store_geo_direction, double geo_direction, String custom_tag_artist, String custom_tag_copyright, double level_angle, double pitch_angle, boolean store_ypr) {
         if( MyDebug.LOG )
             Log.d(TAG, "modifyExif");
         setGPSDirectionExif(exif, store_geo_direction, geo_direction);
@@ -3600,20 +3897,30 @@ public class ImageSaver extends Thread {
                 geo_angle += 360.0f;
             }
             String encoding = "ASCII\0\0\0";
+            // fine to ignore request.remove_device_exif, as this is a separate user option
             //exif.setAttribute(ExifInterface.TAG_USER_COMMENT,"Yaw:" + geo_angle + ",Pitch:" + pitch_angle + ",Roll:" + level_angle);
             exif.setAttribute(ExifInterface.TAG_USER_COMMENT,encoding + "Yaw:" + geo_angle + ",Pitch:" + pitch_angle + ",Roll:" + level_angle);
             if( MyDebug.LOG )
                 Log.d(TAG, "UserComment: " + exif.getAttribute(ExifInterface.TAG_USER_COMMENT));
         }
         setCustomExif(exif, custom_tag_artist, custom_tag_copyright);
+
+        if( store_location && ( !exif.hasAttribute(ExifInterface.TAG_GPS_LATITUDE) || !exif.hasAttribute(ExifInterface.TAG_GPS_LATITUDE) ) ) {
+            // We need this when using camera extensions (since Camera API doesn't support location for camera extensions).
+            // But some devices (e.g., Pixel 6 Pro with Camera2 API) seem to not store location data, so we always check if we need to add it.
+            // fine to ignore request.remove_device_exif, as this is a separate user option
+            if( MyDebug.LOG )
+                Log.d(TAG, "store location"); // don't log location for privacy reasons!
+            exif.setGpsInfo(location);
+        }
+
         if( using_camera_extensions ) {
-            addDateTimeExif(exif, current_date);
-            if( store_location ) {
-                // also need to store geotagging, since Camera API doesn't support doing this for camera extensions
-                exif.setGpsInfo(location);
+            if( remove_device_exif == Request.RemoveDeviceExif.OFF || remove_device_exif == Request.RemoveDeviceExif.KEEP_DATETIME ) {
+                addDateTimeExif(exif, current_date);
             }
         }
-        else if( needGPSTimestampHack(is_jpeg, using_camera2, store_location) ) {
+        else if( needGPSExifFix(is_jpeg, using_camera2, store_location) ) {
+            // fine to ignore request.remove_device_exif, as this is a separate user option
             fixGPSTimestamp(exif, current_date);
         }
     }
@@ -3632,6 +3939,7 @@ public class ImageSaver extends Thread {
             String GPSImgDirection_string = Math.round(geo_angle*100) + "/100";
             if( MyDebug.LOG )
                 Log.d(TAG, "GPSImgDirection_string: " + GPSImgDirection_string);
+            // fine to ignore request.remove_device_exif, as this is a separate user option
             exif.setAttribute(ExifInterface.TAG_GPS_IMG_DIRECTION, GPSImgDirection_string);
             exif.setAttribute(ExifInterface.TAG_GPS_IMG_DIRECTION_REF, "M");
         }
@@ -3655,12 +3963,14 @@ public class ImageSaver extends Thread {
         if( custom_tag_artist != null && custom_tag_artist.length() > 0 ) {
             if( MyDebug.LOG )
                 Log.d(TAG, "apply TAG_ARTIST: " + custom_tag_artist);
+            // fine to ignore request.remove_device_exif, as this is a separate user option
             exif.setAttribute(ExifInterface.TAG_ARTIST, custom_tag_artist);
         }
         if( custom_tag_copyright != null && custom_tag_copyright.length() > 0 ) {
-            exif.setAttribute(ExifInterface.TAG_COPYRIGHT, custom_tag_copyright);
             if( MyDebug.LOG )
                 Log.d(TAG, "apply TAG_COPYRIGHT: " + custom_tag_copyright);
+            // fine to ignore request.remove_device_exif, as this is a separate user option
+            exif.setAttribute(ExifInterface.TAG_COPYRIGHT, custom_tag_copyright);
         }
     }
 
@@ -3676,10 +3986,17 @@ public class ImageSaver extends Thread {
             Log.d(TAG, "setDateTimeExif");
         String exif_datetime = exif.getAttribute(ExifInterface.TAG_DATETIME);
         if( exif_datetime != null ) {
-            if( MyDebug.LOG )
+            if( MyDebug.LOG ) {
                 Log.d(TAG, "write datetime tags: " + exif_datetime);
+                Log.d(TAG, "TAG_DATETIME_ORIGINAL was: " + exif.getAttribute(ExifInterface.TAG_DATETIME_ORIGINAL));
+                Log.d(TAG, "TAG_DATETIME_DIGITIZED was: " + exif.getAttribute(ExifInterface.TAG_DATETIME_DIGITIZED));
+            }
             exif.setAttribute(ExifInterface.TAG_DATETIME_ORIGINAL, exif_datetime);
             exif.setAttribute(ExifInterface.TAG_DATETIME_DIGITIZED, exif_datetime);
+            if( MyDebug.LOG ) {
+                Log.d(TAG, "TAG_DATETIME_ORIGINAL is now: " + exif.getAttribute(ExifInterface.TAG_DATETIME_ORIGINAL));
+                Log.d(TAG, "TAG_DATETIME_DIGITIZED is now: " + exif.getAttribute(ExifInterface.TAG_DATETIME_DIGITIZED));
+            }
         }
     }
 
@@ -3754,7 +4071,12 @@ public class ImageSaver extends Thread {
             Log.d(TAG, "fixGPSTimestamp exit");
     }
 
-    private boolean needGPSTimestampHack(boolean is_jpeg, boolean using_camera2, boolean store_location) {
+    /** Whether we need to fix up issues with location.
+     *  See comments in fixGPSTimestamp(), where some devices with Camera2 need fixes for TAG_GPS_DATESTAMP and TAG_GPS_TIMESTAMP.
+     *  Also some devices (e.g. Pixel 6 Pro) have problem that location is not stored in images with Camera2 API, so we need to
+     *  enter modifyExif() to add it if not present.
+     */
+    private boolean needGPSExifFix(boolean is_jpeg, boolean using_camera2, boolean store_location) {
         if( is_jpeg && using_camera2 ) {
             return store_location;
         }
diff --git a/app/src/main/java/net/sourceforge/opencamera/MainActivity.java b/app/src/main/java/net/sourceforge/opencamera/MainActivity.java
index 56b14fadef18762283aa3fd98fd55a01c8df356a..7ae06d028592520b9e4413851c052086f18a7288 100644
--- a/app/src/main/java/net/sourceforge/opencamera/MainActivity.java
+++ b/app/src/main/java/net/sourceforge/opencamera/MainActivity.java
@@ -88,6 +88,7 @@ import net.sourceforge.opencamera.preview.Preview;
 import net.sourceforge.opencamera.preview.VideoProfile;
 import net.sourceforge.opencamera.remotecontrol.BluetoothRemoteControl;
 import net.sourceforge.opencamera.ui.CircleImageView;
+import net.sourceforge.opencamera.ui.DrawPreview;
 import net.sourceforge.opencamera.ui.FolderChooserDialog;
 import net.sourceforge.opencamera.ui.MainUI;
 import net.sourceforge.opencamera.ui.ManualSeekbars;
@@ -104,6 +105,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -337,8 +339,19 @@ public class MainActivity extends AppCompatActivity {
         //speechControl = new SpeechControl(this);
 
         // determine whether we support Camera2 API
+        // must be done before setDeviceDefaults()
         initCamera2Support();
 
+        // set some per-device defaults
+        // must be done before creating the Preview (as setDeviceDefaults() may set Camera2 API)
+        boolean has_done_first_time = sharedPreferences.contains(PreferenceKeys.FirstTimePreferenceKey);
+        if( MyDebug.LOG )
+            Log.d(TAG, "has_done_first_time: " + has_done_first_time);
+        if( !has_done_first_time ) {
+            // must be done after initCamera2Support()
+            setDeviceDefaults();
+        }
+
         // set up window flags for normal operation
         setWindowFlagsForCamera();
         if( MyDebug.LOG )
@@ -659,7 +672,6 @@ public class MainActivity extends AppCompatActivity {
             Log.d(TAG, "onCreate: time after setting system ui visibility listener: " + (System.currentTimeMillis() - debug_time));
 
         // show "about" dialog for first time use; also set some per-device defaults
-        boolean has_done_first_time = sharedPreferences.contains(PreferenceKeys.FirstTimePreferenceKey);
         if( MyDebug.LOG )
             Log.d(TAG, "has_done_first_time: " + has_done_first_time);
         if (!has_done_first_time) {
@@ -693,7 +705,7 @@ public class MainActivity extends AppCompatActivity {
                     // E.g., we have a "What's New" for 1.44 (64), but then push out a quick fix for 1.44.1 (65). We don't want to
                     // show the dialog again to people who already received 1.44 (64), but we still want to show the dialog to people
                     // upgrading from earlier versions.
-                    int whats_new_version = 84; // 1.50
+                    int whats_new_version = 86; // 1.51
                     whats_new_version = Math.min(whats_new_version, version_code); // whats_new_version should always be <= version_code, but just in case!
                     if( MyDebug.LOG ) {
                         Log.d(TAG, "whats_new_version: " + whats_new_version);
@@ -939,6 +951,40 @@ public class MainActivity extends AppCompatActivity {
 			editor.putBoolean(PreferenceKeys.getCamera2FastBurstPreferenceKey(), false);
 			editor.apply();
 		}*/
+        if( supports_camera2 && !is_test ) {
+            // n.b., when testing, we explicitly decide whether to run with Camera2 API or not
+            CameraControllerManager2 manager2 = new CameraControllerManager2(this);
+            int n_cameras = manager2.getNumberOfCameras();
+            boolean all_supports_camera2 = true; // whether all cameras have at least LIMITED support for Camera2 (risky to default to Camera2 if any cameras are LEGACY, as not easy to test such devices)
+            for(int i=0;i<n_cameras && all_supports_camera2;i++) {
+                if( !manager2.allowCamera2Support(i) ) {
+                    if( MyDebug.LOG )
+                        Log.d(TAG, "camera " + i + " doesn't have at least LIMITED support for Camera2 API");
+                    all_supports_camera2 = false;
+                }
+            }
+
+            if( all_supports_camera2 ) {
+                boolean default_to_camera2 = false;
+                boolean is_google = Build.MANUFACTURER.toLowerCase(Locale.US).contains("google");
+                boolean is_nokia = Build.MANUFACTURER.toLowerCase(Locale.US).contains("hmd global");
+                boolean is_samsung = Build.MANUFACTURER.toLowerCase(Locale.US).contains("samsung");
+                if( is_google && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S )
+                    default_to_camera2 = true;
+                else if( is_nokia && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P )
+                    default_to_camera2 = true;
+                else if( is_samsung && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S )
+                    default_to_camera2 = true;
+
+                if( default_to_camera2 ) {
+                    if( MyDebug.LOG )
+                        Log.d(TAG, "default to camera2 API");
+                    SharedPreferences.Editor editor = sharedPreferences.edit();
+                    editor.putString(PreferenceKeys.CameraAPIPreferenceKey, "preference_camera_api_camera2");
+                    editor.apply();
+                }
+            }
+        }
     }
 
     /** Switches modes if required, if called from a relevant intent/tile.
@@ -1360,6 +1406,8 @@ public class MainActivity extends AppCompatActivity {
         if (MyDebug.LOG)
             Log.d(TAG, "getOnlineHelpUrl: " + append);
         // if we change this, remember that any page linked to must abide by Google Play developer policies!
+        // also if we change this method name or where it's located, remember to update the mention in
+        // opencamera_source.txt
         //return "https://opencamera.sourceforge.io/" + append;
         return "https://opencamera.org.uk/" + append;
     }
@@ -1535,6 +1583,8 @@ public class MainActivity extends AppCompatActivity {
         // (this should already have been set from the call in onPause(), but we set it here again just in case)
         applicationInterface.getDrawPreview().setCoverPreview(true);
 
+        applicationInterface.getDrawPreview().clearDimPreview(); // shouldn't be needed, but just in case the dim preview flag got set somewhere
+
         cancelImageSavingNotification();
 
         // Set black window background; also needed if we hide the virtual buttons in immersive mode
@@ -1561,7 +1611,53 @@ public class MainActivity extends AppCompatActivity {
         resetCachedSystemOrientation(); // just in case?
         mainUI.layoutUI();
 
-        updateGalleryIcon(); // update in case images deleted whilst idle
+        // If the cached last media has exif datetime info, it's fine to just call updateGalleryIcon(),
+        // which will find the most recent media (and takes care of if the cached last image may have
+        // been deleted).
+        // If it doesn't have exif datetime tags, updateGalleryIcon() may not be able to find the most
+        // recent media, so we stick with the cached uri if we can test that it's still accessible.
+        if( !getStorageUtils().getLastMediaScannedHasNoExifDateTime() ) {
+            updateGalleryIcon();
+        }
+        else {
+            if( MyDebug.LOG )
+                Log.d(TAG, "last media has no exif datetime, so check it still exists");
+            boolean uri_exists = false;
+            InputStream inputStream = null;
+            Uri check_uri = getStorageUtils().getLastMediaScannedCheckUri();
+            if( MyDebug.LOG )
+                Log.d(TAG, "check_uri: " + check_uri);
+            try {
+                inputStream = this.getContentResolver().openInputStream(check_uri);
+                if( inputStream != null )
+                    uri_exists = true;
+            }
+            catch(Exception ignored) {
+            }
+            finally {
+                if( inputStream != null ) {
+                    try {
+                        inputStream.close();
+                    }
+                    catch(IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+
+            if( uri_exists ) {
+                if( MyDebug.LOG )
+                    Log.d(TAG, "    most recent uri exists");
+                // also re-allow ghost image again in case that option is set (since we won't be
+                // doing this via updateGalleryIcon())
+                applicationInterface.getDrawPreview().allowGhostImage();
+            }
+            else {
+                if( MyDebug.LOG )
+                    Log.d(TAG, "    most recent uri no longer valid");
+                updateGalleryIcon();
+            }
+        }
 
         applicationInterface.reset(false); // should be called before opening the camera in preview.onResume()
 
@@ -1956,6 +2052,12 @@ public class MainActivity extends AppCompatActivity {
     public void clickedPauseVideo(View view) {
         if( MyDebug.LOG )
             Log.d(TAG, "clickedPauseVideo");
+        pauseVideo();
+    }
+
+    public void pauseVideo() {
+        if( MyDebug.LOG )
+            Log.d(TAG, "pauseVideo");
         if( preview.isVideoRecording() ) { // just in case
             preview.pauseVideo();
             mainUI.setPauseVideoContentDescription();
@@ -2023,7 +2125,7 @@ public class MainActivity extends AppCompatActivity {
         this.closePopup();
 
         String message = getResources().getString(R.string.preference_location) + ": " + getResources().getString(value ? R.string.on : R.string.off);
-        preview.showToast(store_location_toast, message);
+        preview.showToast(store_location_toast, message, true);
     }
 
     public void clickedTextStamp(View view) {
@@ -2103,7 +2205,7 @@ public class MainActivity extends AppCompatActivity {
 
         mainUI.updateStampIcon();
         applicationInterface.getDrawPreview().updateSettings();
-        preview.showToast(stamp_toast, value ? R.string.stamp_enabled : R.string.stamp_disabled);
+        preview.showToast(stamp_toast, value ? R.string.stamp_enabled : R.string.stamp_disabled, true);
     }
 
     public void clickedAutoLevel(View view) {
@@ -2132,7 +2234,7 @@ public class MainActivity extends AppCompatActivity {
 
         if( !done_dialog ) {
             String message = getResources().getString(R.string.preference_auto_stabilise) + ": " + getResources().getString(value ? R.string.on : R.string.off);
-            preview.showToast(this.getChangedAutoStabiliseToastBoxer(), message);
+            preview.showToast(this.getChangedAutoStabiliseToastBoxer(), message, true);
         }
 
         mainUI.updateAutoLevelIcon();
@@ -2162,7 +2264,7 @@ public class MainActivity extends AppCompatActivity {
         editor.apply();
 
         mainUI.updateFaceDetectionIcon();
-        preview.showToast(stamp_toast, value ? R.string.face_detection_enabled : R.string.face_detection_disabled);
+        preview.showToast(stamp_toast, value ? R.string.face_detection_enabled : R.string.face_detection_disabled, true);
         block_startup_toast = true; // so the toast from reopening camera is suppressed, otherwise it conflicts with the face detection toast
         preview.reopenCamera();
     }
@@ -2328,6 +2430,7 @@ public class MainActivity extends AppCompatActivity {
         switchCameraButton.setEnabled(false);
         switchMultiCameraButton.setEnabled(false);
         applicationInterface.reset(true);
+        this.getApplicationInterface().getDrawPreview().setDimPreview(true);
         if (is_multi_cam && getResources().getBoolean(R.bool.zoom_level_switch_supported)) {
             changeZoomFactor();
         } else {
@@ -2497,6 +2600,7 @@ public class MainActivity extends AppCompatActivity {
 
         switchVideoButton.setEnabled(false); // prevent slowdown if user repeatedly clicks
         applicationInterface.reset(false);
+        this.getApplicationInterface().getDrawPreview().setDimPreview(true);
         this.preview.switchVideo(false, true);
         switchVideoButton.setEnabled(true);
 
@@ -2517,7 +2621,7 @@ public class MainActivity extends AppCompatActivity {
             Log.d(TAG, "clickedWhiteBalanceLock");
         this.preview.toggleWhiteBalanceLock();
         mainUI.updateWhiteBalanceLockIcon();
-        preview.showToast(white_balance_lock_toast, preview.isWhiteBalanceLocked() ? R.string.white_balance_locked : R.string.white_balance_unlocked);
+        preview.showToast(white_balance_lock_toast, preview.isWhiteBalanceLocked() ? R.string.white_balance_locked : R.string.white_balance_unlocked, true);
     }
 
     public void clickedExposureLock(View view) {
@@ -2525,7 +2629,7 @@ public class MainActivity extends AppCompatActivity {
             Log.d(TAG, "clickedExposureLock");
         this.preview.toggleExposureLock();
         mainUI.updateExposureLockIcon();
-        preview.showToast(exposure_lock_toast, preview.isExposureLocked() ? R.string.exposure_locked : R.string.exposure_unlocked);
+        preview.showToast(exposure_lock_toast, preview.isExposureLocked() ? R.string.exposure_locked : R.string.exposure_unlocked, true);
     }
 
     public void clickedExposure(View view) {
@@ -2686,6 +2790,7 @@ public class MainActivity extends AppCompatActivity {
                     //case "preference_raw_focus_bracketing": // as above
                     //case "preference_nr_save": // we could probably whitelist this, but have not done so in case in future we allow RAW to be saved for the base image
                     //case "preference_hdr_save_expo": // we need to update if this is changed, as it affects whether we request RAW or not in HDR mode when RAW is enabled
+                case "preference_hdr_tonemapping":
                 case "preference_hdr_contrast_enhancement":
                     //case "preference_expo_bracketing_n_images": // need to set up camera controller
                     //case "preference_expo_bracketing_stops": // need to set up camera controller
@@ -3022,11 +3127,11 @@ public class MainActivity extends AppCompatActivity {
     }
 
     public void updateForSettings(boolean update_camera) {
-        updateForSettings(update_camera, null, false);
+        updateForSettings(update_camera, null);
     }
 
     public void updateForSettings(boolean update_camera, String toast_message) {
-        updateForSettings(update_camera, toast_message, false);
+        updateForSettings(update_camera, toast_message, false, false);
     }
 
     /** Must be called when an settings (as stored in SharedPreferences) are made, so we can update the
@@ -3036,10 +3141,12 @@ public class MainActivity extends AppCompatActivity {
      * @param toast_message If non-null, display this toast instead of the usual camera "startup" toast
      *                      that's shown in showPhotoVideoToast(). If non-null but an empty string, then
      *                      this means no toast is shown at all.
-     * @param keep_popup If false, the popup will be closed and destroyed. Set to true if you're sure
-     *                   that the changed setting isn't one that requires the PopupView to be recreated
+     * @param keep_popup    If false, the popup will be closed and destroyed. Set to true if you're sure
+     *                      that the changed setting isn't one that requires the PopupView to be recreated
+     * @param allow_dim     If true, for Camera2 API a dimming effect will be applied if updating the
+     *                      camera.
      */
-    public void updateForSettings(boolean update_camera, String toast_message, boolean keep_popup) {
+    public void updateForSettings(boolean update_camera, String toast_message, boolean keep_popup, boolean allow_dim) {
         if( MyDebug.LOG ) {
             Log.d(TAG, "updateForSettings()");
             if( toast_message != null ) {
@@ -3185,6 +3292,8 @@ public class MainActivity extends AppCompatActivity {
             // don't try to update camera
         }
         else if( need_reopen || preview.getCameraController() == null ) { // if camera couldn't be opened before, might as well try again
+            if( allow_dim )
+                applicationInterface.getDrawPreview().setDimPreview(true);
             preview.reopenCamera();
             if( MyDebug.LOG ) {
                 Log.d(TAG, "updateForSettings: time after reopen: " + (System.currentTimeMillis() - debug_time));
@@ -3195,18 +3304,25 @@ public class MainActivity extends AppCompatActivity {
             if( MyDebug.LOG ) {
                 Log.d(TAG, "updateForSettings: time after set display orientation: " + (System.currentTimeMillis() - debug_time));
             }
+            if( allow_dim )
+                applicationInterface.getDrawPreview().setDimPreview(true);
             preview.pausePreview(true);
             if( MyDebug.LOG ) {
                 Log.d(TAG, "updateForSettings: time after pause: " + (System.currentTimeMillis() - debug_time));
             }
-            preview.setupCamera(false);
-            if( MyDebug.LOG ) {
-                Log.d(TAG, "updateForSettings: time after setup: " + (System.currentTimeMillis() - debug_time));
-            }
+
+            Handler handler = new Handler();
+            // We run setupCamera on the UI thread, but we do it on a post-delayed so that the dimming effect (for Camera2 API) has a chance to run.
+            // Even if allow_dim==false, still run as a postDelayed (a) for consistency, (b) to allow UI to run for a bit (to avoid risk of slow frames).
+            handler.postDelayed(new Runnable() {
+                public void run() {
+                    preview.setupCamera(false);
+                }
+            }, DrawPreview.dim_effect_time_c+16); // +16 to allow time for a frame update to run
         }
         // don't set block_startup_toast to false yet, as camera might be closing/opening on background thread
         if( toast_message != null && toast_message.length() > 0 )
-            preview.showToast(null, toast_message);
+            preview.showToast(null, toast_message, true);
 
         // don't need to reset to saved_focus_value, as we'll have done this when setting up the camera (or will do so when the camera is reopened, if need_reopen)
     	/*if( saved_focus_value != null ) {
@@ -3321,6 +3437,11 @@ public class MainActivity extends AppCompatActivity {
         // to avoid reading the preferences in every single frame).
         applicationInterface.getDrawPreview().updateSettings();
 
+        // Set the flag to cover the preview until the camera is open and receiving frames again
+        // (for Camera2 API) - avoids showing a flash of the preview from before the user went to
+        // the settings.
+        applicationInterface.getDrawPreview().setCoverPreview(true);
+
         if( preferencesListener.anyChange() ) {
             mainUI.updateOnScreenIcons();
         }
@@ -3895,9 +4016,9 @@ public class MainActivity extends AppCompatActivity {
      *  MediaStore uris, as well as allowing control over the resolution of the thumbnail.
      *  If sample_factor is 1, this returns a bitmap scaled to match the display resolution. If
      *  sample_factor is greater than 1, it will be scaled down to a lower resolution.
-     * @param mediastore Whether the uri is for a mediastore uri or not.
+     * @param exif_rotate Whether the rotate the bitmap due to exif orientation.
      */
-    private Bitmap loadThumbnailFromUri(Uri uri, int sample_factor, boolean mediastore) {
+    private Bitmap loadThumbnailFromUri(Uri uri, int sample_factor, boolean exif_rotate) {
         Bitmap thumbnail = null;
         try {
             //thumbnail = MediaStore.Images.Media.getBitmap(getContentResolver(), media.uri);
@@ -3954,10 +4075,7 @@ public class MainActivity extends AppCompatActivity {
             }
             is.close();
 
-            if( !mediastore ) {
-                // When loading from a mediastore, the bitmap already seems to have the correct orientation.
-                // But when loading from a saf uri, we need to apply the rotation.
-                // E.g., test on Galaxy S10e with ghost image last image option, when using SAF, in portrait orientation, after pause/resume.
+            if( exif_rotate ) {
                 thumbnail = rotateForExif(thumbnail, uri);
             }
         }
@@ -4042,6 +4160,7 @@ public class MainActivity extends AppCompatActivity {
                     Log.d(TAG, "doInBackground");
                 StorageUtils.Media media = applicationInterface.getStorageUtils().getLatestMedia();
                 Bitmap thumbnail = null;
+                boolean rotate_for_orientation = true; // whether we should apply the media.orientation rotation
                 KeyguardManager keyguard_manager = (KeyguardManager)MainActivity.this.getSystemService(Context.KEYGUARD_SERVICE);
                 boolean is_locked = keyguard_manager != null && keyguard_manager.inKeyguardRestrictedInputMode();
                 if( MyDebug.LOG )
@@ -4056,7 +4175,8 @@ public class MainActivity extends AppCompatActivity {
                     if( ghost_image_last && !media.video ) {
                         if( MyDebug.LOG )
                             Log.d(TAG, "load full size bitmap for ghost image last photo");
-                        thumbnail = loadThumbnailFromUri(media.uri, 1, media.mediastore);
+                        // if media.mediastore, we'll rotate below using the media.orientation
+                        thumbnail = loadThumbnailFromUri(media.uri, 1, !media.mediastore);
                     }
                     if( thumbnail == null ) {
                         try {
@@ -4095,7 +4215,7 @@ public class MainActivity extends AppCompatActivity {
                                 else {
                                     if( MyDebug.LOG )
                                         Log.d(TAG, "load thumbnail for photo from SAF uri");
-                                    thumbnail = loadThumbnailFromUri(media.uri, 4, media.mediastore);
+                                    thumbnail = loadThumbnailFromUri(media.uri, 4, true);
                                 }
                             }
                             else if( media.video ) {
@@ -4107,6 +4227,10 @@ public class MainActivity extends AppCompatActivity {
                                 if( MyDebug.LOG )
                                     Log.d(TAG, "load thumbnail for photo");
                                 thumbnail = MediaStore.Images.Thumbnails.getThumbnail(getContentResolver(), media.id, MediaStore.Images.Thumbnails.MINI_KIND, null);
+                                if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ) {
+                                    // MediaStore.Images.Thumbnails.getThumbnail() is documented that as of Android Q, we no longer need to apply the orientation
+                                    rotate_for_orientation = false;
+                                }
                             }
                         }
                         catch(Throwable exception) {
@@ -4117,7 +4241,7 @@ public class MainActivity extends AppCompatActivity {
                             exception.printStackTrace();
                         }
                     }
-                    if( thumbnail != null ) {
+                    if( thumbnail != null && rotate_for_orientation ) {
                         if( MyDebug.LOG )
                             Log.d(TAG, "thumbnail orientation is " + media.orientation);
                         if( media.orientation != 0 ) {
@@ -4169,7 +4293,7 @@ public class MainActivity extends AppCompatActivity {
                         Log.d(TAG, "found media uri: " + uri);
                         Log.d(TAG, "    is_raw?: " + is_raw);
                     }
-                    applicationInterface.getStorageUtils().setLastMediaScanned(uri, is_raw);
+                    applicationInterface.getStorageUtils().setLastMediaScanned(uri, is_raw, false, null);
                 }
                 if( thumbnail != null ) {
                     if( MyDebug.LOG )
@@ -5143,6 +5267,11 @@ public class MainActivity extends AppCompatActivity {
             Log.d(TAG, "cameraSetup");
             debug_time = System.currentTimeMillis();
         }
+        if( preview.getCameraController() == null ) {
+            if( MyDebug.LOG )
+                Log.d(TAG, "camera controller is null");
+            return;
+        }
 
         boolean old_want_no_limits = want_no_limits;
         this.want_no_limits = false;
@@ -5449,6 +5578,8 @@ public class MainActivity extends AppCompatActivity {
         block_startup_toast = false;
         if( MyDebug.LOG )
             Log.d(TAG, "cameraSetup: total time for cameraSetup: " + (System.currentTimeMillis() - debug_time));
+
+        this.getApplicationInterface().getDrawPreview().setDimPreview(false);
     }
 
     private void setManualFocusSeekbar(final boolean is_target_distance) {
@@ -5565,6 +5696,13 @@ public class MainActivity extends AppCompatActivity {
         return this.supports_auto_stabilise;
     }
 
+    /** Returns whether the device supports auto-level at all. Most callers probably want to use
+     *  supportsAutoStabilise() which also checks whether auto-level is allowed with current options.
+     */
+    public boolean deviceSupportsAutoStabilise() {
+        return this.supports_auto_stabilise;
+    }
+
     public boolean supportsDRO() {
         if( applicationInterface.isRawOnly(MyApplicationInterface.PhotoMode.DRO) )
             return false; // if not saving JPEGs, no point having DRO mode, as it won't affect the RAW images
@@ -5913,7 +6051,8 @@ public class MainActivity extends AppCompatActivity {
             String photo_mode_string = getPhotoModeString(photo_mode, false);
             if( photo_mode_string != null ) {
                 toast_string += (toast_string.length()==0 ? "" : "\n") + getResources().getString(R.string.photo_mode) + ": " + photo_mode_string;
-                simple = false;
+                if( photo_mode != MyApplicationInterface.PhotoMode.DRO && photo_mode != MyApplicationInterface.PhotoMode.HDR && photo_mode != MyApplicationInterface.PhotoMode.NoiseReduction )
+                    simple = false;
             }
 
             if( preview.supportsFocus() && preview.getSupportedFocusValues().size() > 1 && photo_mode != MyApplicationInterface.PhotoMode.FocusBracketing ) {
@@ -6062,7 +6201,7 @@ public class MainActivity extends AppCompatActivity {
         MyAudioTriggerListenerCallback callback = new MyAudioTriggerListenerCallback(this);
         audio_listener = new AudioListener(callback);
         if( audio_listener.status() ) {
-            preview.showToast(audio_control_toast, R.string.audio_listener_started);
+            preview.showToast(audio_control_toast, R.string.audio_listener_started, true);
 
             audio_listener.start();
             SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
diff --git a/app/src/main/java/net/sourceforge/opencamera/MyApplicationInterface.java b/app/src/main/java/net/sourceforge/opencamera/MyApplicationInterface.java
index a6345f470ccdf887879568f47363b4ea17e9f5e4..96e8f16934c0ae24e9b035571dd125c2bb007289 100644
--- a/app/src/main/java/net/sourceforge/opencamera/MyApplicationInterface.java
+++ b/app/src/main/java/net/sourceforge/opencamera/MyApplicationInterface.java
@@ -1208,6 +1208,17 @@ public class MyApplicationInterface extends BasicApplicationInterface {
         return timer_delay;
     }
 
+    private ImageSaver.Request.RemoveDeviceExif getRemoveDeviceExifPref() {
+        switch( sharedPreferences.getString(PreferenceKeys.RemoveDeviceExifPreferenceKey, "preference_remove_device_exif_off") ) {
+            case "preference_remove_device_exif_on":
+                return ImageSaver.Request.RemoveDeviceExif.ON;
+            case "preference_remove_device_exif_keep_datetime":
+                return ImageSaver.Request.RemoveDeviceExif.KEEP_DATETIME;
+            default:
+                return ImageSaver.Request.RemoveDeviceExif.OFF;
+        }
+    }
+
     @Override
     public boolean getGeotaggingPref() {
         return sharedPreferences.getBoolean(PreferenceKeys.LocationPreferenceKey, false);
@@ -1710,12 +1721,6 @@ public class MyApplicationInterface extends BasicApplicationInterface {
         return PhotoMode.Standard;
     }
 
-    @Override
-    public boolean getOptimiseAEForDROPref() {
-        PhotoMode photo_mode = getPhotoMode();
-        return( photo_mode == PhotoMode.DRO );
-    }
-
     private ImageSaver.Request.ImageFormat getImageFormatPref() {
         switch( sharedPreferences.getString(PreferenceKeys.ImageFormatPreferenceKey, "preference_image_format_jpeg") ) {
             case "preference_image_format_webp":
@@ -1985,7 +1990,7 @@ public class MyApplicationInterface extends BasicApplicationInterface {
                     Log.d(TAG, "TargetCallback.onTooFar");
 
                 if( !main_activity.is_test ) {
-                    main_activity.getPreview().showToast(null, R.string.panorama_cancelled);
+                    main_activity.getPreview().showToast(null, R.string.panorama_cancelled, true);
                     MyApplicationInterface.this.stopPanorama(true);
                 }
             }
@@ -2530,7 +2535,7 @@ public class MyApplicationInterface extends BasicApplicationInterface {
                 storageUtils.announceUri(uri, false, true);
 
                 // we also want to save the uri - we can use the media uri directly, rather than having to scan it
-                storageUtils.setLastMediaScanned(uri, false);
+                storageUtils.setLastMediaScanned(uri, false, false, null);
 
                 done = true;
             }
@@ -2538,14 +2543,14 @@ public class MyApplicationInterface extends BasicApplicationInterface {
         else if( video_method == VideoMethod.FILE ) {
             if( filename != null ) {
                 File file = new File(filename);
-                storageUtils.broadcastFile(file, false, true, true);
+                storageUtils.broadcastFile(file, false, true, true, false, null);
                 done = true;
             }
         }
         else {
             if( uri != null ) {
                 // see note in onPictureTaken() for where we call broadcastFile for SAF photos
-                storageUtils.broadcastUri(uri, false, true, true, false);
+                storageUtils.broadcastUri(uri, false, true, true, false, false);
                 done = true;
             }
         }
@@ -2600,13 +2605,13 @@ public class MyApplicationInterface extends BasicApplicationInterface {
             if( MyDebug.LOG )
                 Log.d(TAG, "next output file started");
             int message_id = R.string.video_max_filesize;
-            main_activity.getPreview().showToast(null, message_id);
+            main_activity.getPreview().showToast(null, message_id, true);
         }
         else if( what == MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED ) {
             if( MyDebug.LOG )
                 Log.d(TAG, "max filesize reached");
             int message_id = R.string.video_max_filesize;
-            main_activity.getPreview().showToast(null, message_id);
+            main_activity.getPreview().showToast(null, message_id, true);
         }
         // in versions 1.24 and 1.24, there was a bug where we had "info_" for onVideoError and "error_" for onVideoInfo!
         // fixed in 1.25; also was correct for 1.23 and earlier
@@ -2736,6 +2741,10 @@ public class MyApplicationInterface extends BasicApplicationInterface {
         n_capture_images = 0;
         n_capture_images_raw = 0;
         drawPreview.onCaptureStarted();
+
+        if( getPhotoMode() == PhotoMode.X_Night ) {
+            main_activity.getPreview().showToast(null, R.string.preference_nr_mode_low_light_message, true);
+        }
     }
 
     @Override
@@ -3288,13 +3297,13 @@ public class MyApplicationInterface extends BasicApplicationInterface {
         //String preference_stamp_geo_address = this.getStampGeoAddressPref();
         String preference_units_distance = this.getUnitsDistancePref();
         boolean panorama_crop = sharedPreferences.getString(PreferenceKeys.PanoramaCropPreferenceKey, "preference_panorama_crop_on").equals("preference_panorama_crop_on");
+        ImageSaver.Request.RemoveDeviceExif remove_device_exif = getRemoveDeviceExifPref();
         boolean store_location = getGeotaggingPref() && getLocation() != null;
         Location location = store_location ? getLocation() : null;
         boolean store_geo_direction = main_activity.getPreview().hasGeoDirection() && getGeodirectionPref();
         double geo_direction = main_activity.getPreview().hasGeoDirection() ? main_activity.getPreview().getGeoDirection() : 0.0;
         String custom_tag_artist = sharedPreferences.getString(PreferenceKeys.ExifArtistPreferenceKey, "");
         String custom_tag_copyright = sharedPreferences.getString(PreferenceKeys.ExifCopyrightPreferenceKey, "");
-        String preference_hdr_contrast_enhancement = sharedPreferences.getString(PreferenceKeys.HDRContrastEnhancementPreferenceKey, "preference_hdr_contrast_enhancement_smart");
 
         int iso = 800; // default value if we can't get ISO
         long exposure_time = 1000000000L/30; // default value if we can't get shutter speed
@@ -3400,6 +3409,7 @@ public class MyApplicationInterface extends BasicApplicationInterface {
                         //preference_stamp_geo_address,
                         preference_units_distance,
                         panorama_crop,
+                        remove_device_exif,
                         store_location, location, store_geo_direction, geo_direction,
                         pitch_angle, store_ypr,
                         custom_tag_artist, custom_tag_copyright,
@@ -3421,9 +3431,39 @@ public class MyApplicationInterface extends BasicApplicationInterface {
             success = true;
         }
         else {
-            boolean is_hdr = photo_mode == PhotoMode.DRO || photo_mode == PhotoMode.HDR;
+            ImageSaver.Request.ProcessType processType;
+            if( photo_mode == PhotoMode.DRO || photo_mode == PhotoMode.HDR )
+                processType = ImageSaver.Request.ProcessType.HDR;
+            else if( photo_mode == PhotoMode.X_Night )
+                processType = ImageSaver.Request.ProcessType.X_NIGHT;
+            else
+                processType = ImageSaver.Request.ProcessType.NORMAL;
             boolean force_suffix = forceSuffix(photo_mode);
-            success = imageSaver.saveImageJpeg(do_in_background, is_hdr,
+
+            HDRProcessor.TonemappingAlgorithm preference_hdr_tonemapping_algorithm = HDRProcessor.default_tonemapping_algorithm_c;
+            {
+                String tonemapping_algorithm_pref = sharedPreferences.getString(PreferenceKeys.HDRTonemappingPreferenceKey, "preference_hdr_tonemapping_default");
+                switch( tonemapping_algorithm_pref ) {
+                    case "preference_hdr_tonemapping_clamp":
+                        preference_hdr_tonemapping_algorithm = HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_CLAMP;
+                        break;
+                    case "preference_hdr_tonemapping_exponential":
+                        preference_hdr_tonemapping_algorithm = HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_EXPONENTIAL;
+                        break;
+                    case "preference_hdr_tonemapping_default": // reinhard
+                        preference_hdr_tonemapping_algorithm = HDRProcessor.default_tonemapping_algorithm_c;
+                        break;
+                    case "preference_hdr_tonemapping_aces":
+                        preference_hdr_tonemapping_algorithm = HDRProcessor.TonemappingAlgorithm.TONEMAPALGORITHM_ACES;
+                        break;
+                    default:
+                        Log.e(TAG, "unhandled case for tonemapping: " + tonemapping_algorithm_pref);
+                        break;
+                }
+            }
+            String preference_hdr_contrast_enhancement = sharedPreferences.getString(PreferenceKeys.HDRContrastEnhancementPreferenceKey, "preference_hdr_contrast_enhancement_smart");
+
+            success = imageSaver.saveImageJpeg(do_in_background, processType,
                     force_suffix,
                     // N.B., n_capture_images will be 1 for first image, not 0, so subtract 1 so we start off from _0.
                     // (It wouldn't be a huge problem if we did start from _1, but it would be inconsistent with the naming
@@ -3437,6 +3477,7 @@ public class MyApplicationInterface extends BasicApplicationInterface {
                     is_front_facing,
                     mirror,
                     current_date,
+                    preference_hdr_tonemapping_algorithm,
                     preference_hdr_contrast_enhancement,
                     iso,
                     exposure_time,
@@ -3445,6 +3486,7 @@ public class MyApplicationInterface extends BasicApplicationInterface {
                     //preference_stamp_geo_address,
                     preference_units_distance,
                     false, // panorama doesn't use this codepath
+                    remove_device_exif,
                     store_location, location, store_geo_direction, geo_direction,
                     pitch_angle, store_ypr,
                     custom_tag_artist, custom_tag_copyright,
@@ -3655,10 +3697,10 @@ public class MyApplicationInterface extends BasicApplicationInterface {
                     if( MyDebug.LOG )
                         Log.d(TAG, "successfully deleted " + image_uri);
                     if( from_user )
-                        preview.showToast(null, R.string.photo_deleted);
+                        preview.showToast(null, R.string.photo_deleted, true);
                     if( file != null ) {
                         // SAF doesn't broadcast when deleting them
-                        storageUtils.broadcastFile(file, false, false, true);
+                        storageUtils.broadcastFile(file, false, false, false, false, null);
                     }
                 }
             }
@@ -3673,7 +3715,10 @@ public class MyApplicationInterface extends BasicApplicationInterface {
         else if( image_type == LastImagesType.MEDIASTORE && image_uri != null ) {
             if( MyDebug.LOG )
                 Log.d(TAG, "Delete MediaStore: " + image_uri);
-            main_activity.getContentResolver().delete(image_uri, null, null);
+            if( main_activity.getContentResolver().delete(image_uri, null, null) > 0 ) {
+                if( from_user )
+                    preview.showToast(photo_delete_toast, R.string.photo_deleted, true);
+            }
         }
         else if( image_name != null ) {
             if( MyDebug.LOG )
@@ -3687,8 +3732,8 @@ public class MyApplicationInterface extends BasicApplicationInterface {
                 if( MyDebug.LOG )
                     Log.d(TAG, "successfully deleted " + image_name);
                 if( from_user )
-                    preview.showToast(photo_delete_toast, R.string.photo_deleted);
-                storageUtils.broadcastFile(file, false, false, true);
+                    preview.showToast(photo_delete_toast, R.string.photo_deleted, true);
+                storageUtils.broadcastFile(file, false, false, false, false, null);
             }
         }
     }
@@ -3708,6 +3753,8 @@ public class MyApplicationInterface extends BasicApplicationInterface {
         }
         // Calling updateGalleryIcon() immediately has problem that it still returns the latest image that we've just deleted!
         // But works okay if we call after a delay. 100ms works fine on Nexus 7 and Galaxy Nexus, but set to 500 just to be safe.
+        // Also note that if using option to strip all exif tags, we won't be able to find the previous most recent image - but not
+        // much we can do here when the user is using that option.
         final Handler handler = new Handler();
         handler.postDelayed(new Runnable() {
             @Override
diff --git a/app/src/main/java/net/sourceforge/opencamera/MyPreferenceFragment.java b/app/src/main/java/net/sourceforge/opencamera/MyPreferenceFragment.java
index 8c91d200503c1744c4d41e27b7383ef8d8589107..4fd422c427c850b078cbdc7cab43e441d3373fd4 100644
--- a/app/src/main/java/net/sourceforge/opencamera/MyPreferenceFragment.java
+++ b/app/src/main/java/net/sourceforge/opencamera/MyPreferenceFragment.java
@@ -411,6 +411,10 @@ public class MyPreferenceFragment extends PreferenceFragment implements OnShared
             PreferenceGroup pg = (PreferenceGroup)this.findPreference("preference_screen_photo_settings");
             pg.removePreference(pref);
 
+            pref = findPreference("preference_hdr_tonemapping");
+            pg = (PreferenceGroup)this.findPreference("preference_screen_photo_settings");
+            pg.removePreference(pref);
+
             pref = findPreference("preference_hdr_contrast_enhancement");
             pg = (PreferenceGroup)this.findPreference("preference_screen_photo_settings");
             pg.removePreference(pref);
diff --git a/app/src/main/java/net/sourceforge/opencamera/PanoramaProcessor.java b/app/src/main/java/net/sourceforge/opencamera/PanoramaProcessor.java
index 2734b607b1f4954714db7f3a7b18e818f39f0b9c..1a3f2c1903a452c5b807715bb9e76ecb5f26dd4f 100644
--- a/app/src/main/java/net/sourceforge/opencamera/PanoramaProcessor.java
+++ b/app/src/main/java/net/sourceforge/opencamera/PanoramaProcessor.java
@@ -489,7 +489,7 @@ public class PanoramaProcessor {
                 bitmap.compress(Bitmap.CompressFormat.JPEG, 90, outputStream);
             outputStream.close();
             MainActivity mActivity = (MainActivity) context;
-            mActivity.getStorageUtils().broadcastFile(file, true, false, true);
+            mActivity.getStorageUtils().broadcastFile(file, true, false, true, false, null);
         }
         catch(IOException e) {
             e.printStackTrace();
@@ -1957,7 +1957,7 @@ public class PanoramaProcessor {
                 bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
                 outputStream.close();
                 MainActivity mActivity = (MainActivity) context;
-                mActivity.getStorageUtils().broadcastFile(file, true, false, true);
+                mActivity.getStorageUtils().broadcastFile(file, true, false, true, false, null);
             }
             catch(IOException e) {
                 e.printStackTrace();
@@ -2484,7 +2484,7 @@ public class PanoramaProcessor {
         return ratio_brightnesses;
     }
 
-    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    /*@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
     private void adjustExposures(List<Bitmap> bitmaps, long time_s) {
         List<HDRProcessor.HistogramInfo> histogramInfos = new ArrayList<>();
 
@@ -2514,23 +2514,21 @@ public class PanoramaProcessor {
             if( MyDebug.LOG )
                 Log.d(TAG, "    adjust exposure for image: " + i);
 
-            /*
             // use local average
-            float local_mean_brightness = median_brightnesses.get(i);
-            int count = 1;
-            if( i > 0 ) {
-                local_mean_brightness += median_brightnesses.get(i-1);
-                count++;
-            }
-            if( i < bitmaps.size()-1 ) {
-                local_mean_brightness += median_brightnesses.get(i+1);
-                count++;
-            }
-            local_mean_brightness /= count;
-            if( MyDebug.LOG )
-                Log.d(TAG, "    local_mean_brightness: " + local_mean_brightness);
-            final int brightness_target = (int)(local_mean_brightness + 0.1f);
-            */
+            //float local_mean_brightness = median_brightnesses.get(i);
+            //int count = 1;
+            //if( i > 0 ) {
+            //    local_mean_brightness += median_brightnesses.get(i-1);
+            //    count++;
+            //}
+            //if( i < bitmaps.size()-1 ) {
+            //    local_mean_brightness += median_brightnesses.get(i+1);
+            //    count++;
+            //}
+            //local_mean_brightness /= count;
+            //if( MyDebug.LOG )
+            //    Log.d(TAG, "    local_mean_brightness: " + local_mean_brightness);
+            //final int brightness_target = (int)(local_mean_brightness + 0.1f);
 
             min_preferred_scale = Math.min(min_preferred_scale, brightness_target/(float)histogramInfo.median_brightness);
             max_preferred_scale = Math.max(max_preferred_scale, brightness_target/(float)histogramInfo.median_brightness);
@@ -2554,7 +2552,7 @@ public class PanoramaProcessor {
             Log.d(TAG, "max_preferred_scale: " + max_preferred_scale);
             Log.d(TAG, "### time after adjusting brightnesses: " + (System.currentTimeMillis() - time_s));
         }
-    }
+    }*/
 
     @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
     private void computePanoramaTransforms(List<Matrix> cumulative_transforms, List<Integer> align_x_values, List<Integer> dst_offset_x_values,
@@ -2564,7 +2562,7 @@ public class PanoramaProcessor {
         Matrix cumulative_transform = new Matrix();
         int align_x = 0, align_y = 0;
         int dst_offset_x = 0;
-        List<Integer> align_y_values = new ArrayList<>();
+        //List<Integer> align_y_values = new ArrayList<>();
 
         final boolean use_auto_align = true;
         //final boolean use_auto_align = false;
@@ -2712,7 +2710,7 @@ public class PanoramaProcessor {
             }
 
             align_x_values.add(align_x);
-            align_y_values.add(align_y);
+            //align_y_values.add(align_y);
             dst_offset_x_values.add(dst_offset_x);
             cumulative_transforms.add(new Matrix(cumulative_transform));
 
diff --git a/app/src/main/java/net/sourceforge/opencamera/PreferenceKeys.java b/app/src/main/java/net/sourceforge/opencamera/PreferenceKeys.java
index ef56fce2a3f4d402f506def284cc03f6ee551b89..d95909d978eac8c7a755d287c8ba2c88c3cb065c 100644
--- a/app/src/main/java/net/sourceforge/opencamera/PreferenceKeys.java
+++ b/app/src/main/java/net/sourceforge/opencamera/PreferenceKeys.java
@@ -118,6 +118,8 @@ public class PreferenceKeys {
 
     public static final String HDRSaveExpoPreferenceKey = "preference_hdr_save_expo";
 
+    public static final String HDRTonemappingPreferenceKey = "preference_hdr_tonemapping";
+
     public static final String HDRContrastEnhancementPreferenceKey = "preference_hdr_contrast_enhancement";
 
     public static final String NRSaveExpoPreferenceKey = "preference_nr_save";
@@ -126,6 +128,8 @@ public class PreferenceKeys {
 
     public static final String LocationPreferenceKey = "preference_location";
 
+    public static final String RemoveDeviceExifPreferenceKey = "preference_remove_device_exif";
+
     public static final String GPSDirectionPreferenceKey = "preference_gps_direction";
 
     public static final String RequireLocationPreferenceKey = "preference_require_location";
diff --git a/app/src/main/java/net/sourceforge/opencamera/SaveLocationHistory.java b/app/src/main/java/net/sourceforge/opencamera/SaveLocationHistory.java
index 6afa4f9502a62ba4cd51e7739c6050754228a309..8467275a4863f57224a2e3a27c1a768022562775 100644
--- a/app/src/main/java/net/sourceforge/opencamera/SaveLocationHistory.java
+++ b/app/src/main/java/net/sourceforge/opencamera/SaveLocationHistory.java
@@ -52,7 +52,13 @@ public class SaveLocationHistory {
     void updateFolderHistory(String folder_name, boolean update_icon) {
         updateFolderHistory(folder_name);
         if( update_icon ) {
-            main_activity.updateGalleryIcon(); // if the folder has changed, need to update the gallery icon
+            // If the folder has changed, need to update the gallery icon.
+            // Note that if using option to strip all exif tags, we won't be able to find the most recent image - so seems
+            // better to stick with the current gallery thumbnail. (Also beware that we call this method when changing
+            // non-trivial settings, even if the save folder wasn't actually changed.)
+            if( !main_activity.getStorageUtils().getLastMediaScannedHasNoExifDateTime() ) {
+                main_activity.updateGalleryIcon();
+            }
         }
     }
 
diff --git a/app/src/main/java/net/sourceforge/opencamera/SettingsManager.java b/app/src/main/java/net/sourceforge/opencamera/SettingsManager.java
index dd6ff0ad5a4b6f27500b25c1325ae308f171c862..0d4446cef97c656a4640c2df9f0868839fd74423 100644
--- a/app/src/main/java/net/sourceforge/opencamera/SettingsManager.java
+++ b/app/src/main/java/net/sourceforge/opencamera/SettingsManager.java
@@ -263,7 +263,7 @@ public class SettingsManager {
                 storageUtils.broadcastUri(uri, false, false, false);
             }
             else*/ {
-                storageUtils.broadcastFile(file, false, false, false);
+                storageUtils.broadcastFile(file, false, false, false, false, null);
             }
         }
         catch(IOException e) {
diff --git a/app/src/main/java/net/sourceforge/opencamera/StorageUtils.java b/app/src/main/java/net/sourceforge/opencamera/StorageUtils.java
index d8fdc55db307c666a374207e84d5b2200a489e66..f9b51c915a09262c2fbb7a4d88b1a6410cc9b71d 100644
--- a/app/src/main/java/net/sourceforge/opencamera/StorageUtils.java
+++ b/app/src/main/java/net/sourceforge/opencamera/StorageUtils.java
@@ -52,8 +52,16 @@ public class StorageUtils {
 
     private final Context context;
     private final MyApplicationInterface applicationInterface;
-    private Uri last_media_scanned;
+    private Uri last_media_scanned; // mediastore uri
     private boolean last_media_scanned_is_raw;
+    private boolean last_media_scanned_hasnoexifdatetime;
+    private Uri last_media_scanned_check_uri;
+    // If last_media_scanned_hasnoexifdatetime==true, it means that the last media saved had the
+    // option to strip exif tags. Therefore we should do more to remember the last media scanned,
+    // as we otherwise won't be able to find it again.
+    // last_media_scanned_check_uri is only non-null if last_media_scanned_hasnoexifdatetime==true.
+    // It stores a uri that can be used to test if the media still exists. In practice this will be
+    // the last_media_scanned uri, except for SAF images, when it'll be a SAF uri.
 
     private final static String RELATIVE_FOLDER_BASE = Environment.DIRECTORY_DCIM;
 
@@ -73,19 +81,36 @@ public class StorageUtils {
         return last_media_scanned_is_raw;
     }
 
+    boolean getLastMediaScannedHasNoExifDateTime() {
+        return last_media_scanned_hasnoexifdatetime;
+    }
+
+    Uri getLastMediaScannedCheckUri() {
+        return last_media_scanned_check_uri;
+    }
+
     void clearLastMediaScanned() {
         if( MyDebug.LOG )
             Log.d(TAG, "clearLastMediaScanned");
         last_media_scanned = null;
         last_media_scanned_is_raw = false;
+        last_media_scanned_hasnoexifdatetime = false;
+        last_media_scanned_check_uri = null;
     }
 
-    void setLastMediaScanned(Uri uri, boolean is_raw) {
+    void setLastMediaScanned(Uri uri, boolean is_raw, boolean hasnoexifdatetime, Uri check_uri) {
         last_media_scanned = uri;
         last_media_scanned_is_raw = is_raw;
+        last_media_scanned_hasnoexifdatetime = hasnoexifdatetime;
+        if( hasnoexifdatetime )
+            last_media_scanned_check_uri = check_uri;
+        else
+            last_media_scanned_check_uri = null;
         if( MyDebug.LOG ) {
             Log.d(TAG, "set last_media_scanned to " + last_media_scanned);
             Log.d(TAG, "    last_media_scanned_is_raw: " + last_media_scanned_is_raw);
+            Log.d(TAG, "    last_media_scanned_hasnoexifdatetime: " + last_media_scanned_hasnoexifdatetime);
+            Log.d(TAG, "    last_media_scanned_check_uri: " + check_uri);
         }
     }
 
@@ -232,7 +257,7 @@ public class StorageUtils {
      *    This may well be intentional, since most gallery applications won't read DNG files anyway. But it's still important to
      *    call this function for DNGs, so that they show up on MTP.
      */
-    public void broadcastFile(final File file, final boolean is_new_picture, final boolean is_new_video, final boolean set_last_scanned) {
+    public void broadcastFile(final File file, final boolean is_new_picture, final boolean is_new_video, final boolean set_last_scanned, final boolean hasnoexifdatetime, final Uri saf_uri) {
         if( MyDebug.LOG )
             Log.d(TAG, "broadcastFile: " + file.getAbsolutePath());
         // note that the new method means that the new folder shows up as a file when connected to a PC via MTP (at least tested on Windows 8)
@@ -258,16 +283,7 @@ public class StorageUtils {
                             }
                             if( set_last_scanned ) {
                                 boolean is_raw = filenameIsRaw(file.getName());
-                                setLastMediaScanned(uri, is_raw);
-                                last_media_scanned = uri;
-                                if (is_new_video) {
-                                    Media media = getLatestMedia(UriType.MEDIASTORE_VIDEOS);
-                                    if (media != null) {
-                                        setLastMediaScanned(media.uri, is_raw);
-                                    }
-                                }
-                                if( MyDebug.LOG )
-                                    Log.d(TAG, "set last_media_scanned to " + last_media_scanned);
+                                setLastMediaScanned(uri, is_raw, hasnoexifdatetime, saf_uri != null ? saf_uri : uri);
                             }
                             announceUri(uri, is_new_picture, is_new_video);
                             applicationInterface.scannedFile(file, uri);
@@ -290,7 +306,7 @@ public class StorageUtils {
 
     /** Wrapper for broadcastFile, when we only have a Uri (e.g., for SAF)
      */
-    public void broadcastUri(final Uri uri, final boolean is_new_picture, final boolean is_new_video, final boolean set_last_scanned, final boolean image_capture_intent) {
+    public void broadcastUri(final Uri uri, final boolean is_new_picture, final boolean is_new_video, final boolean set_last_scanned, final boolean hasnoexifdatetime, final boolean image_capture_intent) {
         if( MyDebug.LOG )
             Log.d(TAG, "broadcastUri: " + uri);
         /* We still need to broadcastFile for SAF for various reasons:
@@ -314,7 +330,7 @@ public class StorageUtils {
                 Log.d(TAG, "broadcast file");
             //Uri media_uri = broadcastFileRaw(real_file, current_date, location);
             //announceUri(media_uri, is_new_picture, is_new_video);
-            broadcastFile(real_file, is_new_picture, is_new_video, set_last_scanned);
+            broadcastFile(real_file, is_new_picture, is_new_video, set_last_scanned, hasnoexifdatetime, uri);
         }
         else if( !image_capture_intent ) {
             if( MyDebug.LOG )
@@ -710,7 +726,7 @@ public class StorageUtils {
                 Log.e(TAG, "failed to create directory");
                 throw new IOException();
             }
-            broadcastFile(folder, false, false, false);
+            broadcastFile(folder, false, false, false, false, null);
         }
     }
 
diff --git a/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController.java b/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController.java
index 1b475ca8906d026e97f75f4c686a52d9ff619538..a8404225e04eaf0b043b051accbe4873f63f3cfe 100644
--- a/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController.java
+++ b/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController.java
@@ -119,6 +119,10 @@ public abstract class CameraController {
             return false;
         }
 
+        /**
+         * @param return_closest If true, return a match for the width/height, even if the fps doesn't
+         *                       match.
+         */
         public static Size findSize(List<Size> sizes, Size size, double fps, boolean return_closest) {
             Size last_s = null;
             for(Size s : sizes) {
@@ -190,7 +194,7 @@ public abstract class CameraController {
             return supported_extensions != null && supported_extensions.contains(extension);
         }
 
-        boolean supportsFrameRate(double fps) {
+        public boolean supportsFrameRate(double fps) {
             for (int[] f : this.fps_ranges) {
                 if (f[0] <= fps && fps <= f[1])
                     return true;
@@ -198,6 +202,26 @@ public abstract class CameraController {
             return false;
         }
 
+        public int closestFrameRate(double fps) {
+            int closest_fps = -1;
+            int closest_dist = -1;
+            for (int[] f : this.fps_ranges) {
+                if (f[0] <= fps && fps <= f[1])
+                    return (int)fps;
+                int this_fps;
+                if( fps < f[0] )
+                    this_fps = f[0];
+                else
+                    this_fps = f[1];
+                int dist = Math.abs(this_fps - (int)fps);
+                if( closest_dist == -1 || dist < closest_dist ) {
+                    closest_fps = this_fps;
+                    closest_dist = dist;
+                }
+            }
+            return closest_fps;
+        }
+
         @Override
         public boolean equals(Object o) {
             if( !(o instanceof Size) )
@@ -325,14 +349,20 @@ public abstract class CameraController {
         return cameraId;
     }
 
-    /** For CameraController2 only. Applications should cover the preview textureview if either camera_controller==null, or if this
-     *  method returns true. Otherwise there is a risk when opening the camera that the textureview still shows an image from when
+    /** For CameraController2 only. Applications should cover the preview textureview if since last resuming, camera_controller
+     *  has never been non-null or this method has never returned false.
+     *  Otherwise there is a risk when opening the camera that the textureview still shows an image from when
      *  the camera was previously opened (e.g., from pausing and resuming the application). This returns false (for CameraController2)
      *  when the camera has received its first frame.
      */
     public boolean shouldCoverPreview() {
         return false;
     }
+    /** For CameraController2 only. After calling this, shouldCoverPreview() will return true, until a new
+     *  frame from the camera has been received.
+     */
+    public void resetCoverPreview() {
+    }
     public abstract SupportedValues setSceneMode(String value);
     /**
      * @return The current scene mode. Will be null if scene mode not supported.
@@ -437,10 +467,6 @@ public abstract class CameraController {
      *  burst if known. If not known (e.g., for continuous burst mode), returns 0.
      */
     public abstract int getBurstTotal();
-    /** If optimise_ae_for_dro is true, then this is a hint that if in auto-exposure mode and flash/torch
-     *  is not on, the CameraController should try to optimise for a DRO (dynamic range optimisation) mode.
-     */
-    public abstract void setOptimiseAEForDRO(boolean optimise_ae_for_dro);
 
     /**
      * @param want_raw       Whether to enable taking photos in RAW (DNG) format.
diff --git a/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController1.java b/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController1.java
index f8acf03925ab42d257c4c14b2e581c02df44e7d8..1601649ba7e98f3e201b7520103a2fd64f7af3a9 100644
--- a/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController1.java
+++ b/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController1.java
@@ -882,11 +882,6 @@ public class CameraController1 extends CameraController {
         return n_burst;
     }
 
-    @Override
-    public void setOptimiseAEForDRO(boolean optimise_ae_for_dro) {
-        // not supported for CameraController1
-    }
-
     @Override
     public void setRaw(boolean want_raw, int max_raw_images) {
         // not supported for CameraController1
diff --git a/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController2.java b/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController2.java
index dbc3ffe287fac21bcce22d896ff84bb6c3db2f88..7104a189514eb8d7136fd49d9841633e5ba999fd 100644
--- a/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController2.java
+++ b/app/src/main/java/net/sourceforge/opencamera/cameracontroller/CameraController2.java
@@ -76,7 +76,6 @@ public class CameraController2 extends CameraController {
     private CameraDevice camera;
     private final String cameraIdS;
 
-    private final boolean is_oneplus;
     private final boolean is_samsung;
     private final boolean is_samsung_s7; // Galaxy S7 or Galaxy S7 Edge
     private final boolean is_samsung_galaxy_s;
@@ -180,7 +179,10 @@ public class CameraController2 extends CameraController {
     private CaptureRequest.Builder previewBuilder;
     private boolean previewIsVideoMode;
     private AutoFocusCallback autofocus_cb;
+    private long autofocus_time_ms = -1; // time we set autofocus_cb to non-null
+    private static final long autofocus_timeout_c = 1000; // timeout for calling autofocus_cb (applies for both auto and continuous focus)
     private boolean capture_follows_autofocus_hint;
+    private boolean ready_for_capture;
     private FaceDetectionListener face_detection_listener;
     private int last_faces_detected = -1;
     private final Object open_camera_lock = new Object(); // lock to wait for camera to be opened from CameraDevice.StateCallback
@@ -214,7 +216,6 @@ public class CameraController2 extends CameraController {
     private boolean dummy_capture_hack = false;
     //private boolean dummy_capture_hack = true; // test
 
-    private boolean optimise_ae_for_dro = false;
     private boolean want_raw;
     //private boolean want_raw = true;
     private int max_raw_images;
@@ -266,7 +267,6 @@ public class CameraController2 extends CameraController {
     private long precapture_state_change_time_ms = -1; // time we changed state for precapture modes
     private static final long precapture_start_timeout_c = 2000;
     private static final long precapture_done_timeout_c = 3000;
-    private boolean ready_for_capture;
 
     private boolean use_fake_precapture; // see CameraController.setUseCamera2FakeFlash() for details - this is the user/application setting, see use_fake_precapture_mode for whether fake precapture is enabled (as we may do this for other purposes, e.g., front screen flash)
     private boolean use_fake_precapture_mode; // true if either use_fake_precapture is true, or we're temporarily using fake precapture mode (e.g., for front screen flash or exposure bracketing)
@@ -1465,7 +1465,8 @@ public class CameraController2 extends CameraController {
                 // or strange behaviour where an old image appears when the user next takes a photo
                 Log.e(TAG, "no picture callback available");
                 Image image = reader.acquireNextImage();
-                image.close();
+                if( image != null )
+                    image.close();
                 return;
             }
             if( skip_next_image ) {
@@ -1473,7 +1474,8 @@ public class CameraController2 extends CameraController {
                     Log.d(TAG, "skipping image");
                 skip_next_image = false;
                 Image image = reader.acquireNextImage();
-                image.close();
+                if( image != null )
+                    image.close();
                 return;
             }
 
@@ -1482,6 +1484,11 @@ public class CameraController2 extends CameraController {
             boolean call_takePhotoCompleted = false;
 
             Image image = reader.acquireNextImage();
+            if( image == null ) {
+                // can happen if camera closed whilst taking photo - this happens in testTakePhotoAutoFocusReleaseDuringPhoto() on Pixel 6 Pro
+                Log.e(TAG, "onImageAvailable: image is null");
+                return;
+            }
             if( MyDebug.LOG )
                 Log.d(TAG, "image timestamp: " + image.getTimestamp());
             ByteBuffer buffer = image.getPlanes()[0].getBuffer();
@@ -1900,7 +1907,8 @@ public class CameraController2 extends CameraController {
                 // or strange behaviour where an old image appears when the user next takes a photo
                 Log.e(TAG, "no picture callback available");
                 Image this_image = reader.acquireNextImage();
-                this_image.close();
+                if( this_image != null )
+                    this_image.close();
                 return;
             }
             if( skip_next_image ) {
@@ -1908,12 +1916,17 @@ public class CameraController2 extends CameraController {
                     Log.d(TAG, "skipping image");
                 skip_next_image = false;
                 Image image = reader.acquireNextImage();
-                image.close();
+                if( image != null )
+                    image.close();
                 return;
             }
             synchronized( background_camera_lock ) {
                 // see comment above in setCaptureResult() for why we synchronize
                 Image image = reader.acquireNextImage();
+                if( image == null ) {
+                    Log.e(TAG, "RAW onImageAvailable: image is null");
+                    return;
+                }
                 images.add(image);
             }
             processImage();
@@ -1982,12 +1995,11 @@ public class CameraController2 extends CameraController {
         this.preview_error_cb = preview_error_cb;
         this.camera_error_cb = camera_error_cb;
 
-        this.is_oneplus = Build.MANUFACTURER.toLowerCase(Locale.US).contains("oneplus");
+        //this.is_oneplus = Build.MANUFACTURER.toLowerCase(Locale.US).contains("oneplus");
         this.is_samsung = Build.MANUFACTURER.toLowerCase(Locale.US).contains("samsung");
         this.is_samsung_s7 = Build.MODEL.toLowerCase(Locale.US).contains("sm-g93");
         this.is_samsung_galaxy_s = is_samsung && Build.MODEL.toLowerCase(Locale.US).contains("sm-g");
         if( MyDebug.LOG ) {
-            Log.d(TAG, "is_oneplus: " + is_oneplus);
             Log.d(TAG, "is_samsung: " + is_samsung);
             Log.d(TAG, "is_samsung_s7: " + is_samsung_s7);
             Log.d(TAG, "is_samsung_galaxy_s: " + is_samsung_galaxy_s);
@@ -2489,7 +2501,101 @@ public class CameraController2 extends CameraController {
     public String getAPI() {
         return "Camera2 (Android L)";
     }
-    
+
+    /** Computes the zoom ratios to use, for devices that support zoom.
+     * @param ratios   List to be filled with zoom ratios.
+     * @param min_zoom Minimum zoom supported.
+     * @param max_zoom Maximum zoom supported.
+     * @return         Index of ratios list that is for 1x zoom.
+     */
+    public static int computeZoomRatios(List<Integer> ratios, float min_zoom, float max_zoom) {
+        int zoom_value_1x;
+
+        // prepare zoom rations > 1x
+        // set 20 steps per 2x factor
+        final double scale_factor_c = 1.0352649238413775043477881942112;
+        List<Integer> zoom_ratios_above_one = new ArrayList<>();
+        double zoom = scale_factor_c;
+        while( zoom < max_zoom - 1.0e-5f ) {
+            int zoom_ratio = (int)(zoom*100);
+            zoom_ratios_above_one.add(zoom_ratio);
+            zoom *= scale_factor_c;
+        }
+        int max_zoom_ratio = (int)(max_zoom*100);
+        if( zoom_ratios_above_one.size() == 0 || zoom_ratios_above_one.get(zoom_ratios_above_one.size()-1) != max_zoom_ratio ) {
+            zoom_ratios_above_one.add(max_zoom_ratio);
+        }
+        int n_steps_above_one = zoom_ratios_above_one.size();
+        if( MyDebug.LOG ) {
+            Log.d(TAG, "n_steps_above_one: " + n_steps_above_one);
+        }
+
+        // now populate full zoom ratios
+
+        // add minimum zoom
+        ratios.add((int)(min_zoom*100));
+        if( ratios.get(0)/100.0f < min_zoom ) {
+            // fix for rounding down to less than the min_zoom
+            // e.g. if min_zoom = 0.666, we'd have stored a zoom ratio of 66 which then would
+            // convert back to 0.66
+            ratios.set(0, ratios.get(0) + 1);
+        }
+
+        if( ratios.get(0) < 100 ) {
+            int n_steps_below_one = Math.max(1, n_steps_above_one/5);
+            // if the min zoom is < 1.0, we add multiple entries for 1x zoom, when using the zoom
+            // seekbar it's easy for the user to zoom to exactly 1x
+            int n_steps_one = Math.max(1, n_steps_above_one/10);
+            if( MyDebug.LOG ) {
+                Log.d(TAG, "n_steps_below_one: " + n_steps_below_one);
+                Log.d(TAG, "n_steps_one: " + n_steps_one);
+            }
+
+            // add rest of zoom values < 1.0f
+            zoom = min_zoom;
+            final double scale_factor = Math.pow(1.0f / min_zoom, 1.0/(double)n_steps_below_one);
+            if( MyDebug.LOG ) {
+                Log.d(TAG, "scale_factor for below 1.0x: " + scale_factor);
+            }
+            for(int i=0;i<n_steps_below_one-1;i++) {
+                zoom *= scale_factor;
+                int zoom_ratio = (int)(zoom*100);
+                if( zoom_ratio > ratios.get(0) ) {
+                    // on some devices (e.g., Pixel 6 Pro), the second entry would equal the first entry, due to the rounding fix above
+                    ratios.add(zoom_ratio);
+                }
+            }
+
+            // add values for 1.0f (we add repeated values so for cameras with min_zoom < 1x, the zoom seekbar will snap to 1x)
+            zoom_value_1x = ratios.size();
+            for(int i=0;i<n_steps_one;i++)
+                ratios.add(100);
+        }
+        else {
+            zoom_value_1x = 0;
+        }
+
+        // add zoom values > 1.0f
+        int n_steps_power_two = Math.max(1, (int)(0.5f+n_steps_above_one/15.0f));
+        if( MyDebug.LOG ) {
+            Log.d(TAG, "n_steps_power_two: " + n_steps_power_two);
+        }
+        for(int zoom_ratio : zoom_ratios_above_one) {
+            ratios.add(zoom_ratio);
+
+            if( zoom_ratio != zoom_ratios_above_one.get(zoom_ratios_above_one.size()-1) && zoom_ratio % 100 == 0 ) {
+                int zoom_ratio_int = zoom_ratio/100;
+                if( zoom_ratio_int != 0 && (zoom_ratio_int & (zoom_ratio_int-1)) == 0 ) {
+                    // is power of 2 that isn't the max zoom
+                    for(int i=0;i<n_steps_power_two-1;i++)
+                        ratios.add(zoom_ratio);
+                }
+            }
+        }
+
+        return zoom_value_1x;
+    }
+
     @Override
     public CameraFeatures getCameraFeatures() throws CameraControllerException {
         if( MyDebug.LOG )
@@ -2568,80 +2674,11 @@ public class CameraController2 extends CameraController {
             Log.d(TAG, "max_zoom: " + max_zoom);
         }
         if( camera_features.is_zoom_supported ) {
-            float zoom_max_min_ratio = max_zoom / min_zoom;
-            // set 20 steps per 2x factor
-            final int steps_per_2x_factor = 20;
-            int n_steps = (int)( (steps_per_2x_factor * Math.log(zoom_max_min_ratio + 1.0e-11)) / Math.log(2.0));
-            if( MyDebug.LOG ) {
-                Log.d(TAG, "n_steps: " + n_steps);
-            }
-
-            camera_features.zoom_ratios = new ArrayList<>();
-
-            // add minimum zoom
-            camera_features.zoom_ratios.add((int)(min_zoom*100));
-            if( camera_features.zoom_ratios.get(0)/100.0f < min_zoom ) {
-                // fix for rounding down to less than the min_zoom
-                // e.g. if min_zoom = 0.666, we'd have stored a zoom ratio of 66 which then would
-                // convert back to 0.66
-                camera_features.zoom_ratios.set(0, camera_features.zoom_ratios.get(0) + 1);
-            }
-
-            if( camera_features.zoom_ratios.get(0) < 100 ) {
-                int n_steps_below_one = Math.max(1, n_steps/5);
-                // if the min zoom is < 1.0, we add multiple entries for 1x zoom, when using the zoom
-                // seekbar it's easy for the user to zoom to exactly 1x
-                int n_steps_one = Math.max(1, n_steps/20);
-                if( MyDebug.LOG ) {
-                    Log.d(TAG, "n_steps_below_one: " + n_steps_below_one);
-                    Log.d(TAG, "n_steps_one: " + n_steps_one);
-                }
-
-                // add rest of zoom values < 1.0f
-                double zoom = min_zoom;
-                final double scale_factor = Math.pow(1.0f / min_zoom, 1.0/(double)n_steps_below_one);
-                if( MyDebug.LOG ) {
-                    Log.d(TAG, "scale_factor for below 1.0x: " + scale_factor);
-                }
-                for(int i=0;i<n_steps_below_one-1;i++) {
-                    zoom *= scale_factor;
-                    int zoom_ratio = (int)(zoom*100);
-                    if( zoom_ratio > camera_features.zoom_ratios.get(0) ) {
-                        // on some devices (e.g., Pixel 6 Pro), the second entry would equal the first entry, due to the rounding fix above
-                        camera_features.zoom_ratios.add(zoom_ratio);
-                    }
-                }
-
-                // add values for 1.0f
-                zoom_value_1x = camera_features.zoom_ratios.size();
-                for(int i=0;i<n_steps_one;i++)
-                    camera_features.zoom_ratios.add(100);
-            }
-            else {
-                zoom_value_1x = 0;
-            }
-
-            final int n_steps_above_one = Math.max(1, n_steps - camera_features.zoom_ratios.size());
-            if( MyDebug.LOG ) {
-                Log.d(TAG, "n_steps_above_one: " + n_steps_above_one);
-            }
-
-            // add zoom values > 1.0f
-            double zoom = 1.0f;
-            final double scale_factor = Math.pow(max_zoom, 1.0/(double)n_steps_above_one);
-            if( MyDebug.LOG ) {
-                Log.d(TAG, "scale_factor for above 1.0x: " + scale_factor);
-            }
-            for(int i=0;i<n_steps_above_one-1;i++) {
-                zoom *= scale_factor;
-                int zoom_ratio = (int)(zoom*100);
-                camera_features.zoom_ratios.add(zoom_ratio);
-            }
 
-            // add maximum zoom
-            int zoom_ratio = (int)(max_zoom*100);
-            camera_features.zoom_ratios.add(zoom_ratio);
+            List<Integer> ratios = new ArrayList<>();
+            this.zoom_value_1x = computeZoomRatios(ratios, min_zoom, max_zoom);
 
+            camera_features.zoom_ratios = ratios;
             camera_features.max_zoom = camera_features.zoom_ratios.size()-1;
             this.zoom_ratios = camera_features.zoom_ratios;
             if( MyDebug.LOG ) {
@@ -3021,13 +3058,27 @@ public class CameraController2 extends CameraController {
         }
 
         if( characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE) ) {
+            int [] supported_flash_modes_arr = characteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES); // Android format
+            List<Integer> supported_flash_modes = new ArrayList<>();
+            for(Integer supported_flash_mode : supported_flash_modes_arr)
+                supported_flash_modes.add(supported_flash_mode);
+
             camera_features.supported_flash_values = new ArrayList<>();
+            // also resort as well as converting
+
+            // documentation for CONTROL_AE_AVAILABLE_MODES says the following modes are always supported:
             camera_features.supported_flash_values.add("flash_off");
             camera_features.supported_flash_values.add("flash_auto");
             camera_features.supported_flash_values.add("flash_on");
             camera_features.supported_flash_values.add("flash_torch");
+
             if( !use_fake_precapture ) {
-                camera_features.supported_flash_values.add("flash_red_eye");
+                if( supported_flash_modes.contains(CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE) ) {
+                    camera_features.supported_flash_values.add("flash_red_eye");
+                    if( MyDebug.LOG ) {
+                        Log.d(TAG, " supports flash_red_eye");
+                    }
+                }
             }
         }
         else if( (getFacing() == Facing.FACING_FRONT) ) {
@@ -3205,6 +3256,10 @@ public class CameraController2 extends CameraController {
         return !has_received_frame;
     }
 
+    public void resetCoverPreview() {
+        this.has_received_frame = false;
+    }
+
     private String convertSceneMode(int value2) {
         String value;
         switch( value2 ) {
@@ -4224,6 +4279,12 @@ public class CameraController2 extends CameraController {
                 Log.e(TAG, "no camera");
             return;
         }
+        if( sessionType == (enabled ? SessionType.SESSIONTYPE_EXTENSION : SessionType.SESSIONTYPE_NORMAL) && this.camera_extension == (enabled ? extension : 0) ) {
+            // quick exit
+            if( MyDebug.LOG )
+                Log.d(TAG, "    no change");
+            return;
+        }
         if( hasCaptureSession() ) {
             // can only call this when captureSession not created - as it affects how we create the imageReader
             if( MyDebug.LOG )
@@ -4365,29 +4426,6 @@ public class CameraController2 extends CameraController {
         return n_burst_total;
     }
 
-    @Override
-    public void setOptimiseAEForDRO(boolean optimise_ae_for_dro) {
-        if( MyDebug.LOG )
-            Log.d(TAG, "setOptimiseAEForDRO: " + optimise_ae_for_dro);
-        if( is_oneplus ) {
-            // OnePlus 3T has preview corruption / camera freezing problems when using manual shutter speeds.
-            // So best not to modify auto-exposure for DRO.
-            this.optimise_ae_for_dro = false;
-            if( MyDebug.LOG )
-                Log.d(TAG, "don't modify ae for OnePlus");
-        }
-        else if( is_samsung ) {
-            // At least some Samsung devices (e.g., Galaxy S10e on Android 11) give better results in auto mode
-            // than manual mode, so we're better off staying in auto mode.
-            this.optimise_ae_for_dro = false;
-            if( MyDebug.LOG )
-                Log.d(TAG, "don't modify ae for Samsung");
-        }
-        else {
-            this.optimise_ae_for_dro = optimise_ae_for_dro;
-        }
-    }
-
     @Override
     public void setBurstNImages(int burst_requested_n_images) {
         if( MyDebug.LOG )
@@ -6196,6 +6234,7 @@ public class CameraController2 extends CameraController {
                     Log.d(TAG, "skip af trigger due to continuous mode");
                 this.capture_follows_autofocus_hint = capture_follows_autofocus_hint;
                 this.autofocus_cb = cb;
+                this.autofocus_time_ms = System.currentTimeMillis();
                 return;
             }
             else if( is_video_high_speed ) {
@@ -6209,6 +6248,7 @@ public class CameraController2 extends CameraController {
                 // need to update the callback!
                 this.capture_follows_autofocus_hint = capture_follows_autofocus_hint;
                 this.autofocus_cb = cb;
+                this.autofocus_time_ms = System.currentTimeMillis();
                 return;
             }*/
             CaptureRequest.Builder afBuilder = previewBuilder;
@@ -6232,6 +6272,7 @@ public class CameraController2 extends CameraController {
             precapture_state_change_time_ms = -1;
             this.capture_follows_autofocus_hint = capture_follows_autofocus_hint;
             this.autofocus_cb = cb;
+            this.autofocus_time_ms = System.currentTimeMillis();
             try {
                 if( use_fake_precapture_mode ) {
                     boolean want_flash = false;
@@ -6291,6 +6332,7 @@ public class CameraController2 extends CameraController {
                 precapture_state_change_time_ms = -1;
                 push_autofocus_cb = autofocus_cb;
                 autofocus_cb = null;
+                this.autofocus_time_ms = -1;
                 this.capture_follows_autofocus_hint = false;
             }
             afBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_IDLE); // ensure set back to idle
@@ -6352,6 +6394,7 @@ public class CameraController2 extends CameraController {
             }
             previewBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_IDLE);
             this.autofocus_cb = null;
+            this.autofocus_time_ms = -1;
             this.capture_follows_autofocus_hint = false;
             state = STATE_NORMAL;
             precapture_state_change_time_ms = -1;
@@ -6379,62 +6422,6 @@ public class CameraController2 extends CameraController {
         this.continuous_focus_move_callback = cb;
     }
 
-    static public double getScaleForExposureTime(long exposure_time, long fixed_exposure_time, long scaled_exposure_time, double full_exposure_time_scale) {
-        if( MyDebug.LOG )
-            Log.d(TAG, "getScaleForExposureTime");
-        double alpha = (exposure_time - fixed_exposure_time) / (double) (scaled_exposure_time - fixed_exposure_time);
-        if( alpha < 0.0 )
-            alpha = 0.0;
-        else if( alpha > 1.0 )
-            alpha = 1.0;
-        if( MyDebug.LOG ) {
-            Log.d(TAG, "exposure_time: " + exposure_time);
-            Log.d(TAG, "alpha: " + alpha);
-        }
-        // alpha==0 means exposure_time_scale==1; alpha==1 means exposure_time_scale==full_exposure_time_scale
-        return (1.0 - alpha) + alpha * full_exposure_time_scale;
-    }
-
-    /** Sets up a builder to have manual exposure time, if supported. The exposure time will be
-     *  clamped to the allowed values, and manual ISO will also be set based on the current ISO value.
-     */
-    private void setManualExposureTime(CaptureRequest.Builder stillBuilder, long exposure_time, boolean set_iso, int new_iso) {
-        if( MyDebug.LOG )
-            Log.d(TAG, "setManualExposureTime: " + exposure_time);
-        Range<Integer> iso_range = characteristics.get(CameraCharacteristics.SENSOR_INFO_SENSITIVITY_RANGE); // may be null on some devices
-        if( this.supports_exposure_time && iso_range != null ) {
-            if( exposure_time < min_exposure_time )
-                exposure_time = min_exposure_time;
-            if( exposure_time > max_exposure_time )
-                exposure_time = max_exposure_time;
-            if (MyDebug.LOG) {
-                Log.d(TAG, "exposure_time: " + exposure_time);
-            }
-            stillBuilder.set(CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_OFF);
-            {
-                // set ISO
-                int iso = 800;
-                if( set_iso )
-                    iso = new_iso;
-                else if( capture_result_has_iso )
-                    iso = capture_result_iso;
-                // see https://sourceforge.net/p/opencamera/tickets/321/ - some devices may have auto ISO that's
-                // outside of the allowed manual iso range!
-                iso = Math.max(iso, iso_range.getLower());
-                iso = Math.min(iso, iso_range.getUpper());
-                if( MyDebug.LOG ) {
-                    Log.d(TAG, "iso: " + iso);
-                }
-                stillBuilder.set(CaptureRequest.SENSOR_SENSITIVITY, iso );
-            }
-            if( capture_result_has_frame_duration  )
-                stillBuilder.set(CaptureRequest.SENSOR_FRAME_DURATION, capture_result_frame_duration);
-            else
-                stillBuilder.set(CaptureRequest.SENSOR_FRAME_DURATION, 1000000000L/30);
-            stillBuilder.set(CaptureRequest.SENSOR_EXPOSURE_TIME, exposure_time);
-        }
-    }
-
     private void takePictureAfterPrecapture() {
         if( MyDebug.LOG )
             Log.d(TAG, "takePictureAfterPrecapture");
@@ -6495,22 +6482,10 @@ public class CameraController2 extends CameraController {
                     stillBuilder.set(CaptureRequest.FLASH_MODE, CameraMetadata.FLASH_MODE_TORCH);
                     test_fake_flash_photo++;
                 }
-                if( !camera_settings.has_iso && this.optimise_ae_for_dro && capture_result_has_exposure_time && (camera_settings.flash_value.equals("flash_off") || camera_settings.flash_value.equals("flash_auto") || camera_settings.flash_value.equals("flash_frontscreen_auto") ) ) {
-                    final double full_exposure_time_scale = Math.pow(2.0, -0.5);
-                    final long fixed_exposure_time = 1000000000L/60; // we only scale the exposure time at all if it's less than this value
-                    final long scaled_exposure_time = 1000000000L/120; // we only scale the exposure time by the full_exposure_time_scale if the exposure time is less than this value
-                    long exposure_time = capture_result_exposure_time;
-                    if( exposure_time <= fixed_exposure_time ) {
-                        double exposure_time_scale = getScaleForExposureTime(exposure_time, fixed_exposure_time, scaled_exposure_time, full_exposure_time_scale);
-                        exposure_time *= exposure_time_scale;
-                        if( MyDebug.LOG ) {
-                            Log.d(TAG, "reduce exposure shutter speed further, was: " + exposure_time);
-                            Log.d(TAG, "exposure_time_scale: " + exposure_time_scale);
-                        }
-                        modified_from_camera_settings = true;
-                        setManualExposureTime(stillBuilder, exposure_time, false, 0);
-                    }
-                }
+                // Versions previous to 1.51 would switch to manual mode and underexpose in bright scenes; however on more modern devices such as Samsung and
+                // Pixels, this means that we lose the benefit of manufacturer algorithms creating a worse result. So we're better off staying in auto mode.
+                // (Even on old versions, we didn't do this on OnePlus devices due to OnePlus 3T having preview corruption / camera freezing problems when
+                // using manual shutter speeds.)
                 //stillBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                 //stillBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
                 if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && sessionType != SessionType.SESSIONTYPE_EXTENSION ) {
@@ -6737,9 +6712,13 @@ public class CameraController2 extends CameraController {
                 }
                 int n_dummy_requests = 0;
 
-                CaptureRequest.Builder stillBuilder = camera.createCaptureRequest(CameraDevice.TEMPLATE_MANUAL);
+                CaptureRequest.Builder stillBuilder = camera.createCaptureRequest((burst_type == BurstType.BURSTTYPE_EXPO || camera_settings.has_iso) ? CameraDevice.TEMPLATE_MANUAL : CameraDevice.TEMPLATE_STILL_CAPTURE);
                 // Needs to be TEMPLATE_MANUAL! Otherwise first image in burst may come out incorrectly (on Pixel 6 Pro,
-                // the first image incorrectly had HDR+ applied, which we don't want here).
+                // the first image incorrectly had HDR+ applied, which we don't want here). Also problem on Pixel 6 Pro
+                // where manual exposure is ignored when longer than the preview exposure.
+                // Update: but only when doing burst for expo bracketing, not focus bracketing (unless actually doing that
+                // in manual mode)! (Only manual exposure should use TEMPLATE_MANUAL, otherwise focus bracketing images
+                // come out underexposed on Pixel 6 Pro).
                 // n.b., don't set RequestTagType.CAPTURE here - we only do it for the last of the burst captures (see below)
                 camera_settings.setupBuilder(stillBuilder, true);
 
@@ -7024,7 +7003,7 @@ public class CameraController2 extends CameraController {
                 try {
                     modified_from_camera_settings = true;
                     //setRepeatingRequest(requests.get(0));
-                    if( use_expo_fast_burst && burst_type == BurstType.BURSTTYPE_EXPO ) { // alway use slow burst for focus bracketing
+                    if( use_expo_fast_burst && burst_type == BurstType.BURSTTYPE_EXPO ) { // always use slow burst for focus bracketing
                         if( MyDebug.LOG )
                             Log.d(TAG, "using fast burst");
                         int sequenceId = captureSession.captureBurst(requests, previewCaptureCallback, handler);
@@ -7101,8 +7080,10 @@ public class CameraController2 extends CameraController {
                     Log.d(TAG, "imageReader surface: " + imageReader.getSurface().toString());
                 }
 
-                CaptureRequest.Builder stillBuilder = camera.createCaptureRequest(previewIsVideoMode ? CameraDevice.TEMPLATE_VIDEO_SNAPSHOT : CameraDevice.TEMPLATE_STILL_CAPTURE);
-                stillBuilder.set(CaptureRequest.CONTROL_CAPTURE_INTENT, CaptureRequest.CONTROL_CAPTURE_INTENT_STILL_CAPTURE);
+                CaptureRequest.Builder stillBuilder = camera.createCaptureRequest(previewIsVideoMode ? CameraDevice.TEMPLATE_VIDEO_SNAPSHOT : camera_settings.has_iso ? CameraDevice.TEMPLATE_MANUAL : CameraDevice.TEMPLATE_STILL_CAPTURE);
+                // N.B., takePictureBurst() not currently called if previewIsVideoMode==true, but have put this code here for possible future use.
+                // Important to use TEMPLATE_MANUAL for manual exposure: this fixes bug on Pixel 6 Pro where manual exposure is ignored when longer than the
+                // preview exposure time (e.g. for fast burst).
                 // n.b., don't set RequestTagType.CAPTURE here - we only do it for the last of the burst captures (see below)
                 camera_settings.setupBuilder(stillBuilder, true);
                 if( use_fake_precapture_mode && fake_precapture_torch_performed ) {
@@ -7169,59 +7150,22 @@ public class CameraController2 extends CameraController {
                             if( MyDebug.LOG )
                                 Log.d(TAG, "optimise for dark scene");
                             n_burst = noise_reduction_low_light ? N_IMAGES_NR_DARK_LOW_LIGHT : N_IMAGES_NR_DARK;
-                            // OnePlus 3T at least has bug where manual ISO can't be set to above 800, so dark images end up too dark -
-                            // so no point enabling this code, which is meant to brighten the scene, not make it darker!
-                            if( !camera_settings.has_iso && !is_oneplus ) {
-                                long exposure_time = noise_reduction_low_light ? 1000000000L/3 : 1000000000L/10;
-                                if(  capture_result_exposure_time < exposure_time ) {
-                                    if( MyDebug.LOG )
-                                        Log.d(TAG, "also set long exposure time");
-                                    modified_from_camera_settings = true;
-
-                                    boolean set_new_iso = false;
-                                    int new_iso = 0;
-                                    {
-                                        // ISO*exposure should be a constant
-                                        set_new_iso = true;
-                                        new_iso = (int)((capture_result_iso * capture_result_exposure_time)/exposure_time);
-                                        // but don't make ISO too low
-                                        new_iso = Math.max(new_iso, capture_result_iso/2);
-                                        new_iso = Math.max(new_iso, 1100);
-                                        if( MyDebug.LOG )
-                                            Log.d(TAG, "... and set iso to " + new_iso);
-                                    }
-
-                                    setManualExposureTime(stillBuilder, exposure_time, set_new_iso, new_iso);
-                                }
-                                else {
-                                    if( MyDebug.LOG )
-                                        Log.d(TAG, "no need to extend exposure time for dark scene, already long enough: " + exposure_time);
-                                }
-                            }
+                            // Versions previous to 1.51 would switch to manual mode and overexpose in bright scenes; however on more modern devices such as Samsung and
+                            // Pixels, this means that we lose the benefit of manufacturer algorithms creating a worse result. So we're better off staying in auto mode.
+                            // (Even on old versions, we didn't do this for OnePlus devices, due to bug on OnePlus 3T where manual mode can't be set above 800, so this
+                            // would cause images to come out too dark.)
                         }
                         else if( capture_result_has_exposure_time ) {
-                            //final double full_exposure_time_scale = 0.5;
-                            final double full_exposure_time_scale = Math.pow(2.0, -0.5);
-                            final long fixed_exposure_time = 1000000000L/60; // we only scale the exposure time at all if it's less than this value
-                            final long scaled_exposure_time = 1000000000L/120; // we only scale the exposure time by the full_exposure_time_scale if the exposure time is less than this value
+                            final long fixed_exposure_time = 1000000000L/60;
                             long exposure_time = capture_result_exposure_time;
                             if( exposure_time <= fixed_exposure_time ) {
                                 if( MyDebug.LOG )
                                     Log.d(TAG, "optimise for bright scene");
                                 //n_burst = 2;
                                 n_burst = 3;
-                                // At least some Samsung devices (e.g., Galaxy S10e on Android 11) give better results in auto mode
-                                // than manual mode, so we're better off staying in auto mode.
-                                if( !camera_settings.has_iso && !is_samsung ) {
-                                    double exposure_time_scale = getScaleForExposureTime(exposure_time, fixed_exposure_time, scaled_exposure_time, full_exposure_time_scale);
-                                    exposure_time *= exposure_time_scale;
-                                    if( MyDebug.LOG ) {
-                                        Log.d(TAG, "reduce exposure shutter speed further, was: " + exposure_time);
-                                        Log.d(TAG, "exposure_time_scale: " + exposure_time_scale);
-                                    }
-                                    modified_from_camera_settings = true;
-                                    setManualExposureTime(stillBuilder, exposure_time, false, 0);
-                                }
+                                // Versions previous to 1.51 would switch to manual mode and underexpose in bright scenes; however on more modern devices such as
+                                // Samsung and Pixels, this means that we lose the benefit of manufacturer algorithms creating a worse result. So we're better off
+                                // staying in auto mode.
                             }
                         }
                     }
@@ -8231,7 +8175,10 @@ public class CameraController2 extends CameraController {
                     Log.d(TAG, "CONTROL_AWB_STATE = " + awb_state);
             }*/
 
-            if( af_state != null && af_state == CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN ) {
+            boolean autofocus_timeout = autofocus_time_ms != -1 && System.currentTimeMillis() > autofocus_time_ms + autofocus_timeout_c;
+            if( MyDebug.LOG && autofocus_timeout )
+                Log.d(TAG, "autofocus timeout!");
+            if( af_state != null && af_state == CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN && !autofocus_timeout ) {
                 /*if( MyDebug.LOG )
                     Log.d(TAG, "not ready for capture: " + af_state);*/
                 ready_for_capture = false;
@@ -8262,6 +8209,7 @@ public class CameraController2 extends CameraController {
                         }
                         autofocus_cb.onAutoFocus(focus_success);
                         autofocus_cb = null;
+                        autofocus_time_ms = -1;
                         capture_follows_autofocus_hint = false;
                     }
                 }
@@ -8297,11 +8245,12 @@ public class CameraController2 extends CameraController {
                         autofocus_cb.onAutoFocus(false);
                         autofocus_cb = null;
                     }
+                    autofocus_time_ms = -1;
                     capture_follows_autofocus_hint = false;
                 }
-                else if( af_state != last_af_state ) {
+                else if( af_state != last_af_state || autofocus_timeout ) {
                     // check for autofocus completing
-                    if( af_state == CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED || af_state == CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED /*||
+                    if( autofocus_timeout || af_state == CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED || af_state == CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED /*||
                             af_state == CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED || af_state == CaptureResult.CONTROL_AF_STATE_PASSIVE_UNFOCUSED*/
                     ) {
                         boolean focus_success = af_state == CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED || af_state == CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED;
@@ -8365,6 +8314,7 @@ public class CameraController2 extends CameraController {
                             autofocus_cb.onAutoFocus(focus_success);
                             autofocus_cb = null;
                         }
+                        autofocus_time_ms = -1;
                         capture_follows_autofocus_hint = false;
                     }
                 }
diff --git a/app/src/main/java/net/sourceforge/opencamera/preview/ApplicationInterface.java b/app/src/main/java/net/sourceforge/opencamera/preview/ApplicationInterface.java
index bfe4760ae699a328198f365f877e8fd17c3499a1..5471f1df3f9ef97bdc8615ddba6d35290e9e303a 100644
--- a/app/src/main/java/net/sourceforge/opencamera/preview/ApplicationInterface.java
+++ b/app/src/main/java/net/sourceforge/opencamera/preview/ApplicationInterface.java
@@ -165,7 +165,6 @@ public interface ApplicationInterface {
     @RequiresApi(api = Build.VERSION_CODES.S)
     int getCameraExtensionPref(); // if isCameraExtensionPref() returns true, the camera extension mode to use
     float getAperturePref(); // get desired aperture (called if Preview.getSupportedApertures() returns non-null); return -1.0f for no preference
-    boolean getOptimiseAEForDROPref(); // see CameraController doc for setOptimiseAEForDRO().
     enum RawPref {
         RAWPREF_JPEG_ONLY, // JPEG only
         RAWPREF_JPEG_DNG // JPEG and RAW (DNG)
diff --git a/app/src/main/java/net/sourceforge/opencamera/preview/BasicApplicationInterface.java b/app/src/main/java/net/sourceforge/opencamera/preview/BasicApplicationInterface.java
index b9875eafbffb8be32a4a8b3e31d6890d046ce86c..32a97db8444be3a107b48be05c7c61466ada231d 100644
--- a/app/src/main/java/net/sourceforge/opencamera/preview/BasicApplicationInterface.java
+++ b/app/src/main/java/net/sourceforge/opencamera/preview/BasicApplicationInterface.java
@@ -369,11 +369,6 @@ public abstract class BasicApplicationInterface implements ApplicationInterface
         return -1.0f;
     }
 
-    @Override
-    public boolean getOptimiseAEForDROPref() {
-        return false;
-    }
-
     @Override
     public RawPref getRawPref() {
         return RawPref.RAWPREF_JPEG_ONLY;
diff --git a/app/src/main/java/net/sourceforge/opencamera/preview/Preview.java b/app/src/main/java/net/sourceforge/opencamera/preview/Preview.java
index bb44d61dcddc869711c9efcae27c8ab0da3f8a89..9d856a2ad6929c54a309135d999d14a7afb3eb12 100644
--- a/app/src/main/java/net/sourceforge/opencamera/preview/Preview.java
+++ b/app/src/main/java/net/sourceforge/opencamera/preview/Preview.java
@@ -40,7 +40,7 @@ import android.util.Log;
 import android.util.Pair;
 import android.view.Display;
 import android.view.GestureDetector;
-import android.view.Gravity;
+//import android.view.Gravity;
 import android.view.LayoutInflater;
 import android.view.MotionEvent;
 import android.view.OrientationEventListener;
@@ -417,6 +417,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
 
     // for testing; must be volatile for test project reading the state
     private boolean is_test; // whether called from OpenCamera.test testing
+    private boolean is_test_junit4;
     public volatile int count_cameraStartPreview;
     public volatile int count_cameraAutoFocus;
     public volatile int count_cameraTakePicture;
@@ -442,8 +443,11 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
         if (activity.getIntent() != null && activity.getIntent().getExtras() != null) {
             // whether called from testing
             is_test = activity.getIntent().getExtras().getBoolean("test_project");
-            if (MyDebug.LOG)
-                Log.d(TAG, "is_test: " + is_test);
+            is_test_junit4 = activity.getIntent().getExtras().getBoolean("test_project_junit4");
+        }
+        if( MyDebug.LOG ) {
+            Log.d(TAG, "is_test: " + is_test);
+            Log.d(TAG, "is_test_junit4: " + is_test_junit4);
         }
 
         this.using_android_l = Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && applicationInterface.useCamera2();
@@ -1160,7 +1164,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
             // MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED, so it is the application responsibility to create the zero-size
             // video file that will have been created
             if( MyDebug.LOG )
-                Log.d(TAG, "delete ununused next video file");
+                Log.d(TAG, "delete unused next video file");
             nextVideoFileInfo.close();
             applicationInterface.deleteUnusedVideo(nextVideoFileInfo.video_method, nextVideoFileInfo.video_uri, nextVideoFileInfo.video_filename);
         }
@@ -1216,8 +1220,8 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                     if (!due_to_max_filesize)
                         toast = remaining_restart_video + " " + getContext().getResources().getString(R.string.repeats_to_go);
                     takePicture(due_to_max_filesize, false, false);
-                    if (!due_to_max_filesize) {
-                        showToast(null, toast); // show the toast afterwards, as we're hogging the UI thread here, and media recorder takes time to start up
+                    if( !due_to_max_filesize ) {
+                        showToast(null, toast, true); // show the toast afterwards, as we're hogging the UI thread here, and media recorder takes time to start up
                         // must decrement after calling takePicture(), so that takePicture() doesn't reset the value of remaining_restart_video
                         remaining_restart_video--;
                     }
@@ -2128,8 +2132,6 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
             }
         }
 
-        camera_controller.setOptimiseAEForDRO(applicationInterface.getOptimiseAEForDROPref());
-
         // Must set preview size before starting camera preview
         // and must do it after setting photo vs video mode
         // and after setting what camera extension we're using (if any)
@@ -3001,11 +3003,15 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                 VideoProfile profile = getVideoProfile();
                 if (MyDebug.LOG)
                     Log.d(TAG, "check if we need high speed video for " + profile.videoFrameWidth + " x " + profile.videoFrameHeight + " at fps " + profile.videoCaptureRate);
-                CameraController.Size best_video_size = video_quality_handler.findVideoSizeForFrameRate(profile.videoFrameWidth, profile.videoFrameHeight, profile.videoCaptureRate);
+                CameraController.Size best_video_size = video_quality_handler.findVideoSizeForFrameRate(profile.videoFrameWidth, profile.videoFrameHeight, profile.videoCaptureRate, false);
+                    // n.b., we should pass videoCaptureRate and not videoFrameRate (as for slow motion, it's videoCaptureRate that will be high, not videoFrameRate)
 
-                if (best_video_size == null && video_quality_handler.getSupportedVideoSizesHighSpeed() != null) {
+                if( best_video_size == null && fpsIsHighSpeed("" + profile.videoFrameRate) && video_quality_handler.getSupportedVideoSizesHighSpeed() != null ) {
                     Log.e(TAG, "can't find match for capture rate: " + profile.videoCaptureRate + " and video size: " + profile.videoFrameWidth + " x " + profile.videoFrameHeight + " at fps " + profile.videoCaptureRate);
-                    // try falling back to one of the supported high speed resolutions
+                    // If fpsIsHighSpeed() returns true for profile.videoFrameRate, then it means an fps is one that isn't
+                    // supported by any standard video sizes, but it is supported by a high speed video size. If
+                    // best_video_size==null, then we must have an incompatible size for this fps.
+                    // So try falling back to one of the supported high speed resolutions.
                     CameraController.Size requested_size = video_quality_handler.getMaxSupportedVideoSizeHighSpeed();
                     profile.videoFrameWidth = requested_size.width;
                     profile.videoFrameHeight = requested_size.height;
@@ -3084,10 +3090,13 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                     // whilst devices with flash should support flash_auto, we'll also be in this codepath for front cameras with
                     // no flash, as instead the available options will be flash_off, flash_frontscreen_auto, flash_frontscreen_on
                     // see testTakePhotoFrontCameraScreenFlash
-                    if (supported_flash_values.contains("flash_auto"))
+                    /*if( supported_flash_values.contains("flash_auto") )
                         updateFlash("flash_auto", true);
                     else
-                        updateFlash("flash_off", true);
+                        updateFlash("flash_off", true);*/
+                    // update, we now default to flash off - flash is increasingly less useful on modern cameras,
+                    // plus reduces problems from risk of buggy flash on Camera2 API...
+                    updateFlash("flash_off", true);
                 }
             } else {
                 if (MyDebug.LOG)
@@ -3411,7 +3420,32 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
         //video_profile.fileFormat = MediaRecorder.OutputFormat.MPEG_4;
         //video_profile.videoCodec = MediaRecorder.VideoEncoder.H264;
 
-        if (!fps_value.equals("default")) {
+        if( fps_value.equals("default") ) {
+            if( supports_video_high_speed && video_profile.videoFrameWidth != 0 && video_profile.videoFrameHeight != 0 ) {
+                // Check videoFrameRate is actually supported by requested video resolution.
+                // We need this as sometimes the CamcorderProfile we use may store a frame rate not actually
+                // supported for the resolution (e.g., on Pixel 6 Pro, 1920x1080 and 3840x2160 support 60fps,
+                // and the CamcorderProfiles set 60fps, but the intermediate resolutions such as 1920x1440 only
+                // support 30fps).
+                // Limited to supports_video_high_speed - at the least, we don't want this code for old camera API where
+                // supported frame rates aren't available.
+                // N.B., we should pass videoCaptureRate and not videoFrameRate (as for slow motion, it's videoCaptureRate
+                // that will be high, not videoFrameRate).
+                CameraController.Size best_video_size = video_quality_handler.findVideoSizeForFrameRate(video_profile.videoFrameWidth, video_profile.videoFrameHeight, video_profile.videoCaptureRate, true);
+                if( best_video_size != null && !best_video_size.supportsFrameRate(video_profile.videoCaptureRate) ) {
+                    if( MyDebug.LOG )
+                        Log.d(TAG, "video resolution " + video_profile.videoFrameWidth + " x " + video_profile.videoFrameHeight + " doesn't support requested fps " + video_profile.videoFrameRate);
+                    int closest_fps = best_video_size.closestFrameRate(video_profile.videoFrameRate);
+                    if( MyDebug.LOG )
+                        Log.d(TAG, "    instead choose valid fps: " + closest_fps);
+                    if( closest_fps != -1 ) { // just in case?
+                        video_profile.videoFrameRate = closest_fps;
+                        video_profile.videoCaptureRate = closest_fps;
+                    }
+                }
+            }
+        }
+        else {
             try {
                 int fps = Integer.parseInt(fps_value);
                 if (MyDebug.LOG)
@@ -4234,7 +4268,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
             if (camera_controller.setExposureCompensation(new_exposure)) {
                 // now save
                 applicationInterface.setExposureCompensationPref(new_exposure);
-                showToast(getExposureCompensationString(new_exposure), 0, true);
+                showToast(null, getExposureCompensationString(new_exposure), 0, true);
             }
         }
     }
@@ -4250,7 +4284,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
             if (camera_controller.setWhiteBalanceTemperature(new_temperature)) {
                 // now save
                 applicationInterface.setWhiteBalanceTemperaturePref(new_temperature);
-                showToast(getResources().getString(R.string.white_balance) + " " + new_temperature, 0, true);
+                showToast(null, getResources().getString(R.string.white_balance) + " " + new_temperature, 0, true);
             }
         }
     }
@@ -4287,7 +4321,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
             if (camera_controller.setISO(new_iso)) {
                 // now save
                 applicationInterface.setISOPref("" + new_iso);
-                showToast(getISOString(new_iso), 0, true);
+                showToast(null, getISOString(new_iso), 0, true);
             }
         }
     }
@@ -4303,7 +4337,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
             if (camera_controller.setExposureTime(new_exposure_time)) {
                 // now save
                 applicationInterface.setExposureTimePref(new_exposure_time);
-                showToast(getExposureTimeString(new_exposure_time), 0, true);
+                showToast(null, getExposureTimeString(new_exposure_time), 0, true);
             }
         }
     }
@@ -4886,8 +4920,8 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                 if (flash_value.equals(flash_values[i])) {
                     if (MyDebug.LOG)
                         Log.d(TAG, "    found entry: " + i);
-                    if (!initial) {
-                        showToast(focus_flash_toast, flash_entries[i]);
+                    if( !initial ) {
+                        showToast(focus_flash_toast, flash_entries[i], true);
                     }
                     break;
                 }
@@ -5001,8 +5035,8 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                 Log.d(TAG, "    focus_value: " + focus_value);
             if (!quiet) {
                 String focus_entry = findFocusEntryForValue(focus_value);
-                if (focus_entry != null) {
-                    showToast(focus_flash_toast, focus_entry);
+                if( focus_entry != null ) {
+                    showToast(focus_flash_toast, focus_entry, true);
                 }
             }
             this.setFocusValue(focus_value, auto_focus);
@@ -5151,7 +5185,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
         }
         if (this.isOnTimer()) {
             cancelTimer();
-            showToast(take_photo_toast, R.string.cancelled_timer);
+            showToast(take_photo_toast, R.string.cancelled_timer, true);
             return;
         }
         //if( !photo_snapshot && this.phase == PHASE_TAKING_PHOTO ) {
@@ -5174,10 +5208,11 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                 Log.d(TAG, "already taking a photo");
             if (remaining_repeat_photos != 0) {
                 cancelRepeat();
-                showToast(take_photo_toast, R.string.cancelled_repeat_mode);
-            } else if (!is_video && camera_controller.getBurstType() == CameraController.BurstType.BURSTTYPE_FOCUS && camera_controller.isCapturingBurst()) {
+                showToast(take_photo_toast, R.string.cancelled_repeat_mode, true);
+            }
+            else if( !is_video && camera_controller.getBurstType() == CameraController.BurstType.BURSTTYPE_FOCUS && camera_controller.isCapturingBurst() ) {
                 camera_controller.stopFocusBracketingBurst();
-                showToast(take_photo_toast, R.string.cancelled_focus_bracketing);
+                showToast(take_photo_toast, R.string.cancelled_focus_bracketing, true);
             }
             return;
         }
@@ -5314,8 +5349,10 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
     private void onVideoInfo(int what, int extra) {
         if (MyDebug.LOG)
             Log.d(TAG, "onVideoInfo: " + what + " extra: " + extra);
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && what == MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING && video_restart_on_max_filesize) {
-            if (MyDebug.LOG)
+        // n.b., we shouldn't refactor "Build.VERSION.SDK_INT >= Build.VERSION_CODES.O" to a single variable, as it means we'll then get the Android
+        // warnings of "Call requires API level 26"
+        if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && what == MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING && video_restart_on_max_filesize ) {
+            if( MyDebug.LOG )
                 Log.d(TAG, "seamless restart due to max filesize approaching - try setNextOutputFile");
             if (video_recorder == null) {
                 // just in case?
@@ -5491,8 +5528,8 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                 } else {
                     if (MyDebug.LOG)
                         Log.d(TAG, "location data required, but not available");
-                    showToast(null, R.string.location_not_available);
-                    if (!is_video || photo_snapshot)
+                    showToast(null, R.string.location_not_available, true);
+                    if( !is_video || photo_snapshot )
                         this.phase = PHASE_NORMAL;
                     applicationInterface.cameraInOperation(false, false);
                     if (is_video)
@@ -5639,8 +5676,8 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
             });
 
             camera_controller.initVideoRecorderPrePrepare(local_video_recorder);
-            if (profile.no_audio_permission) {
-                showToast(null, R.string.permission_record_audio_not_available);
+            if( profile.no_audio_permission ) {
+                showToast(null, R.string.permission_record_audio_not_available, true);
             }
 
             boolean store_location = applicationInterface.getGeotaggingPref();
@@ -5965,9 +6002,10 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                 video_recorder.resume();
                 video_recorder_is_paused = false;
                 video_start_time = System.currentTimeMillis();
-                this.showToast(pause_video_toast, R.string.video_resume);
-            } else {
-                if (MyDebug.LOG)
+                this.showToast(pause_video_toast, R.string.video_resume, true);
+            }
+            else {
+                if( MyDebug.LOG )
                     Log.d(TAG, "pausing...");
                 video_recorder.pause();
                 video_recorder_is_paused = true;
@@ -5977,7 +6015,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                     Log.d(TAG, "last_time: " + last_time);
                     Log.d(TAG, "video_accumulated_time is now: " + video_accumulated_time);
                 }
-                this.showToast(pause_video_toast, R.string.video_pause);
+                this.showToast(pause_video_toast, R.string.video_pause, true);
             }
         } else {
             Log.e(TAG, "pauseVideo called but not video recording");
@@ -6171,9 +6209,9 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                 if (MyDebug.LOG)
                     Log.d(TAG, "onStarted");
                 applicationInterface.onCaptureStarted();
-                if (applicationInterface.getBurstForNoiseReduction() && applicationInterface.getNRModePref() == ApplicationInterface.NRModePref.NRMODE_LOW_LIGHT) {
-                    if (camera_controller.getBurstTotal() >= CameraController.N_IMAGES_NR_DARK_LOW_LIGHT) {
-                        showToast(null, R.string.preference_nr_mode_low_light_message);
+                if( applicationInterface.getBurstForNoiseReduction() && applicationInterface.getNRModePref() == ApplicationInterface.NRModePref.NRMODE_LOW_LIGHT ) {
+                    if( camera_controller.getBurstTotal() >= CameraController.N_IMAGES_NR_DARK_LOW_LIGHT ) {
+                        showToast(null, R.string.preference_nr_mode_low_light_message, true);
                     }
                 }
             }
@@ -7335,9 +7373,9 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                         Log.d(TAG, "    width: " + profile.videoFrameWidth);
                         Log.d(TAG, "    height: " + profile.videoFrameHeight);
                     }
-                    CameraController.Size best_video_size = video_quality_handler.findVideoSizeForFrameRate(profile.videoFrameWidth, profile.videoFrameHeight, fps);
-                    if (best_video_size != null) {
-                        if (MyDebug.LOG)
+                    CameraController.Size best_video_size = video_quality_handler.findVideoSizeForFrameRate(profile.videoFrameWidth, profile.videoFrameHeight, fps, false);
+                    if( best_video_size != null ) {
+                        if( MyDebug.LOG )
                             Log.d(TAG, "    requested frame rate is supported");
                         filtered_video_quality.add(quality);
                     } else {
@@ -7579,6 +7617,10 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
         showToast(clear_toast, getResources().getString(message_id), false);
     }
 
+    public void showToast(final ToastBoxer clear_toast, final int message_id, final boolean use_fake_toast) {
+        showToast(clear_toast, getResources().getString(message_id), use_fake_toast);
+    }
+
     public void showToast(final ToastBoxer clear_toast, final String message) {
         showToast(clear_toast, message, false);
     }
@@ -7592,9 +7634,9 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
         showToast(clear_toast, message, 32, use_fake_toast);
     }
 
-    public void showToast(final String message, final int offset_y_dp, final boolean use_fake_toast) {
+    /*public void showToast(final String message, final int offset_y_dp, final boolean use_fake_toast) {
         showToast(null, message, offset_y_dp, use_fake_toast);
-    }
+    }*/
 
     /**
      * Displays a "toast", but has several advantages over calling Android's Toast API directly.
@@ -7605,15 +7647,27 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
      *                       with the same clear_toast value will overwrite the previous ones rather than
      *                       being queued. Note that toasts no longer seem to be queued anyway on
      *                       Android 9+.
+     *                       (N.B., some callers with use_fake_toast==true still supply a use_fake_toast
+     *                       for historical reasons, from when previously those calls weren't using a fake
+     *                       toast.)
      * @param message        The message to display.
-     * @param offset_y_dp    The y-offset from the centre of the screen.
-     * @param use_fake_toast If true, don't use Android's Toast system at all. This is due to problems on
-     *                       Android 9+ where rapidly displaying toasts (e.g., to display values from a
-     *                       seekbar being modified) cause problems where toast sometimes disappear (this
-     *                       happens whether using clear_toast or not). Note that using use_fake_toast
-     *                       means that the toasts don't have the fade out effect.
+     * @param offset_y_dp    The y-offset from the centre of the screen. Only relevant if use_fake_toast is
+     *                       true.
+     * @param use_fake_toast If true, don't use Android's Toast system at all, and instead display a message
+     *                       on the Preview.
+     *                       This is due to problems on Android 9+ where rapidly displaying toasts (e.g., to
+     *                       display values from a seekbar being modified) cause problems where toast sometimes
+     *                       disappear (this happens whether using clear_toast or not). Note that using
+     *                       use_fake_toast means that the toasts don't have the fade out effect.
+     *                       Update: Toasts with custom views (Toast.setView()) are now deprecated. So
+     *                       use_fake_toast==false no longer uses a custom view. So we should now only set
+     *                       use_fake_toast==false for when we really want to use the system toast (e.g.,
+     *                       anything that isn't when the Preview is showing such as from Settings, or when
+     *                       we want the Android toast look such as for an error message).
+     *                       Usages where we want to display info on the Preview should always set
+     *                       use_fake_toast==true for a consistent look.
      */
-    private void showToast(final ToastBoxer clear_toast, final String message, final int offset_y_dp, final boolean use_fake_toast) {
+    public void showToast(final ToastBoxer clear_toast, final String message, final int offset_y_dp, final boolean use_fake_toast) {
         //final boolean use_fake_toast = true;
         //final boolean use_fake_toast = old_use_fake_toast;
         if (!applicationInterface.getShowToastsPref()) {
@@ -7707,6 +7761,7 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                 // However should only do this if the previous toast was the most recent toast (to avoid messing up ordering)
                 Toast toast;
                 long time_now = System.currentTimeMillis();
+                /*
                 // We recreate a toast every 2s, to workaround Android toast bug that calling show() no longer seems to extend the toast duration!
                 // (E.g., see bug where toasts for sliders disappear after a while if continually moving the slider.)
                 if (clear_toast != null && clear_toast.toast != null && clear_toast.toast == last_toast && time_now < last_toast_time_ms + 2000) {
@@ -7719,29 +7774,31 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
                     view.setPadding(0, offset_y, 0, 0);
                     view.invalidate(); // make sure the toast is redrawn
                     toast.setView(view);
-                } else {
-                    if (clear_toast != null && clear_toast.toast != null) {
-                        if (MyDebug.LOG)
+                }
+                else*/ {
+                    if( clear_toast != null && clear_toast.toast != null ) {
+                        if( MyDebug.LOG )
                             Log.d(TAG, "cancel last toast: " + clear_toast.toast);
                         clear_toast.toast.cancel();
                     }
-                    toast = new Toast(activity);
-                    if (MyDebug.LOG)
+                    //toast = new Toast(activity);
+                    toast = Toast.makeText(activity, message, Toast.LENGTH_SHORT);
+                    if( MyDebug.LOG )
                         Log.d(TAG, "created new toast: " + toast);
                     if (clear_toast != null)
                         clear_toast.toast = toast;
-                    @SuppressLint("InflateParams") // we add the view to the toast
+                    /*@SuppressLint("InflateParams") // we add the view to the toast
                     final View view = LayoutInflater.from(activity).inflate(R.layout.toast_textview, null);
                     TextView text = view.findViewById(R.id.text_view);
                     text.setShadowLayer(shadow_radius, 0.0f, 0.0f, Color.BLACK);
                     text.setText(message);
                     view.setPadding(0, offset_y, 0, 0);
                     toast.setView(text);
-                    toast.setGravity(Gravity.CENTER, 0, 0);
+                    toast.setGravity(Gravity.CENTER, 0, 0);*/
                     last_toast_time_ms = time_now;
                 }
-                toast.setDuration(Toast.LENGTH_SHORT);
-                if (!((Activity) getContext()).isFinishing()) {
+                //toast.setDuration(Toast.LENGTH_SHORT);
+                if( !((Activity)getContext()).isFinishing() ) {
                     // Workaround for crash due to bug in Android 7.1 when activity is closing whilst toast shows.
                     // This was fixed in Android 8, but still good to fix the crash on Android 7.1! See
                     // https://stackoverflow.com/questions/47548317/what-belong-is-badtokenexception-at-classes-of-project and
@@ -8466,10 +8523,19 @@ public class Preview implements SurfaceHolder.Callback, TextureView.SurfaceTextu
     	   Camera2 API. Testing suggests this does not seem to adversely affect battery life.
     	   This is limited to Android 7+, to avoid causing problems on older devices (which don't
     	   contribute to Google Analytics anyway).
+    	   If we ever are able to use lower frame rates in future, remember we'll still need a high
+    	   frame rate when applying the dimming effect when reopening or updating the camera (see
+    	   DrawPreview.setDimPreview()) (especially for MainActivity.updateForSettings() when we
+    	   pause/unpause the preview instead of reopening the camera).
     	 */
         //
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
+        if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.N ) {
+            if( is_test_junit4 ) {
+                // see https://stackoverflow.com/questions/29550508/espresso-freezing-on-view-with-looping-animation
+                return 32;
+            }
             return 16;
+        }
         // old behaviour: avoid overloading ui thread when taking photo
         return this.isTakingPhoto() ? 500 : 100;
     }
diff --git a/app/src/main/java/net/sourceforge/opencamera/preview/VideoProfile.java b/app/src/main/java/net/sourceforge/opencamera/preview/VideoProfile.java
index 8de628050e4e6fb40eb016ef1763e7c17a33046c..6fae2d60af83fc0b32796279bdcfb7e5e9b29b88 100644
--- a/app/src/main/java/net/sourceforge/opencamera/preview/VideoProfile.java
+++ b/app/src/main/java/net/sourceforge/opencamera/preview/VideoProfile.java
@@ -90,11 +90,13 @@ public class VideoProfile {
         // n.b., order may be important - output format should be first, at least
         // also match order of MediaRecorder.setProfile() just to be safe, see https://stackoverflow.com/questions/5524672/is-it-possible-to-use-camcorderprofile-without-audio-source
         media_recorder.setOutputFormat(this.fileFormat);
+        if( MyDebug.LOG )
+            Log.d(TAG, "set frame rate: " + this.videoFrameRate);
         media_recorder.setVideoFrameRate(this.videoFrameRate);
         // it's probably safe to always call setCaptureRate, but to be safe (and keep compatibility with old Open Camera versions), we only do so when needed
         if( this.videoCaptureRate != (double)this.videoFrameRate ) {
             if( MyDebug.LOG )
-                Log.d(TAG, "set capture rate");
+                Log.d(TAG, "set capture rate: " + this.videoCaptureRate);
             media_recorder.setCaptureRate(this.videoCaptureRate);
         }
         media_recorder.setVideoSize(this.videoFrameWidth, this.videoFrameHeight);
diff --git a/app/src/main/java/net/sourceforge/opencamera/preview/VideoQualityHandler.java b/app/src/main/java/net/sourceforge/opencamera/preview/VideoQualityHandler.java
index e49e8499fc8a3987154820940238527e432d7585..5ade76c7ea8ca904bef03a8753bce3ea8270a2e9 100644
--- a/app/src/main/java/net/sourceforge/opencamera/preview/VideoQualityHandler.java
+++ b/app/src/main/java/net/sourceforge/opencamera/preview/VideoQualityHandler.java
@@ -171,7 +171,7 @@ public class VideoQualityHandler {
         return CameraController.CameraFeatures.supportsFrameRate(this.video_sizes_high_speed, fps);
     }
 
-    CameraController.Size findVideoSizeForFrameRate(int width, int height, double fps) {
+    CameraController.Size findVideoSizeForFrameRate(int width, int height, double fps, boolean return_closest) {
         if( MyDebug.LOG ) {
             Log.d(TAG, "findVideoSizeForFrameRate");
             Log.d(TAG, "width: " + width);
@@ -179,12 +179,12 @@ public class VideoQualityHandler {
             Log.d(TAG, "fps: " + fps);
         }
         CameraController.Size requested_size = new CameraController.Size(width, height);
-        CameraController.Size best_video_size = CameraController.CameraFeatures.findSize(this.getSupportedVideoSizes(), requested_size, fps, false);
+        CameraController.Size best_video_size = CameraController.CameraFeatures.findSize(this.getSupportedVideoSizes(), requested_size, fps, return_closest);
         if( best_video_size == null && this.getSupportedVideoSizesHighSpeed() != null ) {
             if( MyDebug.LOG )
                 Log.d(TAG, "need to check high speed sizes");
             // check high speed
-            best_video_size = CameraController.CameraFeatures.findSize(this.getSupportedVideoSizesHighSpeed(), requested_size, fps, false);
+            best_video_size = CameraController.CameraFeatures.findSize(this.getSupportedVideoSizesHighSpeed(), requested_size, fps, return_closest);
         }
         return best_video_size;
     }
diff --git a/app/src/main/java/net/sourceforge/opencamera/ui/DrawPreview.java b/app/src/main/java/net/sourceforge/opencamera/ui/DrawPreview.java
index be5fdfe17e7d01b6c85ef16b77c94a3b1c1f77d3..7285ac7fa4cf10db8b2f2a3262da8de65c758116 100644
--- a/app/src/main/java/net/sourceforge/opencamera/ui/DrawPreview.java
+++ b/app/src/main/java/net/sourceforge/opencamera/ui/DrawPreview.java
@@ -59,7 +59,25 @@ public class DrawPreview {
     private final MainActivity main_activity;
     private final MyApplicationInterface applicationInterface;
 
+    // In some cases when reopening the camera or pausing preview, we apply a dimming effect (only
+    // supported when using Camera2 API, since we need to know when frames have been received).
+    enum DimPreview {
+        DIM_PREVIEW_OFF, // don't dim the preview
+        DIM_PREVIEW_ON, // do dim the preview
+        DIM_PREVIEW_UNTIL // dim the preview until the camera_controller is non-null and has received frames, then switch to DIM_PREVIEW_OFF
+    }
+    private DimPreview dim_preview = DimPreview.DIM_PREVIEW_OFF;
+
+    // Time for the dimming effect. This should be quick, because we call Preview.setupCamera() on
+    // the UI thread, which will block redraws:
+    // - When reopening the camera, we want the dimming to have occurred whilst reopening the
+    //   camera, before we call setupCamera() on the UI thread.
+    // - When pausing the preview in MainActivity.updateForSettings(), we call setupCamera() after
+    //   this delay - so we don't want to keep the user waiting too long.
+    public final static long dim_effect_time_c = 50;
+
     private boolean cover_preview; // whether to cover the preview for Camera2 API
+    private long camera_inactive_time_ms = -1; // if != -1, the time when the camera became inactive
 
     // store to avoid calling PreferenceManager.getDefaultSharedPreferences() repeatedly
     private final SharedPreferences sharedPreferences;
@@ -240,6 +258,8 @@ public class DrawPreview {
     private final static int histogram_width_dp = 100;
     private final static int histogram_height_dp = 60;
 
+    private final static int crop_shading_alpha_c = 160; // alpha to use for shading areas not of interest
+
     public DrawPreview(MainActivity main_activity, MyApplicationInterface applicationInterface) {
         if( MyDebug.LOG )
             Log.d(TAG, "DrawPreview");
@@ -472,6 +492,13 @@ public class DrawPreview {
         this.show_last_image = false;
     }
 
+    public void allowGhostImage() {
+        if( MyDebug.LOG )
+            Log.d(TAG, "allowGhostImage");
+        if( last_thumbnail != null )
+            this.allow_ghost_last_image = true;
+    }
+
     public void clearGhostImage() {
         if( MyDebug.LOG )
             Log.d(TAG, "clearGhostImage");
@@ -982,9 +1009,6 @@ public class DrawPreview {
         if( preview.isVideo() || preview_size_wysiwyg_pref ) {
             String preference_crop_guide = sharedPreferences.getString(PreferenceKeys.ShowCropGuidePreferenceKey, "crop_guide_none");
             if( camera_controller != null && preview.getTargetRatio() > 0.0 && !preference_crop_guide.equals("crop_guide_none") ) {
-                p.setStyle(Paint.Style.STROKE);
-                p.setStrokeWidth(stroke_width);
-                p.setColor(Color.rgb(255, 235, 59)); // Yellow 500
                 double crop_ratio = -1.0;
                 switch(preference_crop_guide) {
                     case "crop_guide_1":
@@ -1040,23 +1064,36 @@ public class DrawPreview {
                             Log.d(TAG, "canvas width: " + canvas.getWidth());
                             Log.d(TAG, "canvas height: " + canvas.getHeight());
                         }*/
+                        p.setStyle(Paint.Style.FILL);
+                        p.setColor(Color.rgb(0, 0, 0));
+                        p.setAlpha(crop_shading_alpha_c);
                         int left = 1, top = 1, right = canvas.getWidth()-1, bottom = canvas.getHeight()-1;
                         if( crop_ratio > preview_aspect_ratio ) {
                             // crop ratio is wider, so we have to crop top/bottom
                             double new_hheight = ((double)canvas.getWidth()) / (2.0f*crop_ratio);
                             top = (canvas.getHeight()/2 - (int)new_hheight);
                             bottom = (canvas.getHeight()/2 + (int)new_hheight);
+                            // draw shaded area
+                            canvas.drawRect(0, 0, canvas.getWidth(), top, p);
+                            canvas.drawRect(0, bottom, canvas.getWidth(), canvas.getHeight(), p);
                         }
                         else {
                             // crop ratio is taller, so we have to crop left/right
                             double new_hwidth = (((double)canvas.getHeight()) * crop_ratio) / 2.0f;
                             left = (canvas.getWidth()/2 - (int)new_hwidth);
                             right = (canvas.getWidth()/2 + (int)new_hwidth);
+                            // draw shaded area
+                            canvas.drawRect(0, 0, left, canvas.getHeight(), p);
+                            canvas.drawRect(right, 0, canvas.getWidth(), canvas.getHeight(), p);
                         }
+                        p.setStyle(Paint.Style.STROKE);
+                        p.setStrokeWidth(stroke_width);
+                        p.setColor(Color.rgb(255, 235, 59)); // Yellow 500
                         canvas.drawRect(left, top, right, bottom, p);
+                        p.setStyle(Paint.Style.FILL); // reset
+                        p.setAlpha(255); // reset
                     }
                 }
-                p.setStyle(Paint.Style.FILL); // reset
             }
         }
     }
@@ -2133,6 +2170,19 @@ public class DrawPreview {
         return "·    " + zoom_ratio + "X" + "    ·";
     }
 
+    private int getAngleStep() {
+        Preview preview = main_activity.getPreview();
+        int angle_step = 10;
+        float zoom_ratio = preview.getZoomRatio();
+        if( zoom_ratio >= 10.0f )
+            angle_step = 1;
+        else if( zoom_ratio >= 5.0f )
+            angle_step = 2;
+        else if( zoom_ratio >= 2.0f )
+            angle_step = 5;
+        return angle_step;
+    }
+
     private void drawAngleLines(Canvas canvas, int device_ui_rotation, long time_ms) {
         Preview preview = main_activity.getPreview();
         CameraController camera_controller = preview.getCameraController();
@@ -2159,6 +2209,7 @@ public class DrawPreview {
             // lines should be shorter in portrait
             int radius_dps = (device_ui_rotation == 90 || device_ui_rotation == 270) ? 60 : 80;
             int radius = (int) (radius_dps * scale + 0.5f); // convert dps to pixels
+            int o_radius = (int) (10 * scale + 0.5f); // convert dps to pixels
             double angle = - preview.getOrigLevelAngle();
             // see http://android-developers.blogspot.co.uk/2010/09/one-screen-turn-deserves-another.html
             int rotation = main_activity.getDisplayRotation();
@@ -2192,28 +2243,41 @@ public class DrawPreview {
                 is_level = true;
             }
 
-            if( is_level ) {
-                radius = (int)(radius * 1.2);
+            final int line_alpha = 160;
+            float hthickness = (0.5f * scale + 0.5f); // convert dps to pixels
+            float shadow_radius = hthickness;
+            shadow_radius = Math.max(shadow_radius, 1.0f);
+            p.setStyle(Paint.Style.FILL);
+
+            if( actual_show_angle_line_pref && preview.hasLevelAngleStable() ) {
+                // draw the non-rotated part of the level
+                // only show the angle line if level angle "stable" (i.e., not pointing near vertically up or down)
+
+                p.setShadowLayer(shadow_radius, 0.0f, 0.0f, Color.BLACK);
+
+                if( is_level ) {
+                    p.setColor(angle_highlight_color_pref);
+                }
+                else {
+                    p.setColor(Color.WHITE);
+                }
+                p.setAlpha(line_alpha);
+                draw_rect.set(cx - radius - o_radius, cy - hthickness, cx - radius, cy + hthickness);
+                canvas.drawRoundRect(draw_rect, hthickness, hthickness, p);
+                draw_rect.set(cx + radius, cy - hthickness, cx + radius + o_radius, cy + hthickness);
+                canvas.drawRoundRect(draw_rect, hthickness, hthickness, p);
+
+                p.clearShadowLayer();
             }
 
             canvas.save();
             canvas.rotate((float)angle, cx, cy);
 
-            final int line_alpha = 160;
-            float hthickness = (0.5f * scale + 0.5f); // convert dps to pixels
-            p.setStyle(Paint.Style.FILL);
             if( actual_show_angle_line_pref && preview.hasLevelAngleStable() ) {
                 // only show the angle line if level angle "stable" (i.e., not pointing near vertically up or down)
-                // draw outline
-                p.setColor(Color.BLACK);
-                p.setAlpha(64);
-                // can't use drawRoundRect(left, top, right, bottom, ...) as that requires API 21
-                draw_rect.set(cx - radius - hthickness, cy - 2 * hthickness, cx + radius + hthickness, cy + 2 * hthickness);
-                canvas.drawRoundRect(draw_rect, 2 * hthickness, 2 * hthickness, p);
-                // draw the vertical crossbar
-                draw_rect.set(cx - 2 * hthickness, cy - radius / 2.0f - hthickness, cx + 2 * hthickness, cy + radius / 2.0f + hthickness);
-                canvas.drawRoundRect(draw_rect, hthickness, hthickness, p);
-                // draw inner portion
+
+                p.setShadowLayer(shadow_radius, 0.0f, 0.0f, Color.BLACK);
+
                 if( is_level ) {
                     p.setColor(angle_highlight_color_pref);
                 }
@@ -2231,16 +2295,13 @@ public class DrawPreview {
                 if( is_level ) {
                     // draw a second line
 
-                    p.setColor(Color.BLACK);
-                    p.setAlpha(64);
-                    draw_rect.set(cx - radius - hthickness, cy - 7 * hthickness, cx + radius + hthickness, cy - 3 * hthickness);
-                    canvas.drawRoundRect(draw_rect, 2 * hthickness, 2 * hthickness, p);
-
                     p.setColor(angle_highlight_color_pref);
                     p.setAlpha(line_alpha);
                     draw_rect.set(cx - radius, cy - 6 * hthickness, cx + radius, cy - 4 * hthickness);
                     canvas.drawRoundRect(draw_rect, hthickness, hthickness, p);
                 }
+
+                p.clearShadowLayer();
             }
             updateCachedViewAngles(time_ms); // ensure view_angle_x_preview, view_angle_y_preview are computed and up to date
             float camera_angle_x, camera_angle_y;
@@ -2272,9 +2333,7 @@ public class DrawPreview {
                 // lines should be shorter in portrait
                 int pitch_radius_dps = (device_ui_rotation == 90 || device_ui_rotation == 270) ? 80 : 100;
                 int pitch_radius = (int) (pitch_radius_dps * scale + 0.5f); // convert dps to pixels
-                int angle_step = 10;
-                if( preview.getZoomRatio() >= 2.0f )
-                    angle_step = 5;
+                int angle_step = getAngleStep();
                 for(int latitude_angle=-90;latitude_angle<=90;latitude_angle+=angle_step) {
                     double this_angle = pitch_angle - latitude_angle;
                     if( Math.abs(this_angle) < 90.0 ) {
@@ -2283,13 +2342,6 @@ public class DrawPreview {
 							Log.d(TAG, "pitch_angle: " + pitch_angle);
 							Log.d(TAG, "pitch_distance_dp: " + pitch_distance_dp);
 						}*/
-                        // draw outline
-                        p.setColor(Color.BLACK);
-                        p.setAlpha(64);
-                        // can't use drawRoundRect(left, top, right, bottom, ...) as that requires API 21
-                        draw_rect.set(cx - pitch_radius - hthickness, cy + pitch_distance - 2*hthickness, cx + pitch_radius + hthickness, cy + pitch_distance + 2*hthickness);
-                        canvas.drawRoundRect(draw_rect, 2*hthickness, 2*hthickness, p);
-                        // draw inner portion
                         p.setColor(Color.WHITE);
                         p.setTextAlign(Paint.Align.LEFT);
                         if( latitude_angle == 0 && Math.abs(pitch_angle) < 1.0 ) {
@@ -2304,8 +2356,11 @@ public class DrawPreview {
                         else {
                             p.setAlpha(line_alpha);
                         }
+                        p.setShadowLayer(shadow_radius, 0.0f, 0.0f, Color.BLACK);
+                        // can't use drawRoundRect(left, top, right, bottom, ...) as that requires API 21
                         draw_rect.set(cx - pitch_radius, cy + pitch_distance - hthickness, cx + pitch_radius, cy + pitch_distance + hthickness);
                         canvas.drawRoundRect(draw_rect, hthickness, hthickness, p);
+                        p.clearShadowLayer();
                         // draw pitch angle indicator
                         applicationInterface.drawTextWithBackground(canvas, p, "" + latitude_angle + "\u00B0", p.getColor(), Color.BLACK, (int)(cx + pitch_radius + 4*hthickness), (int)(cy + pitch_distance - 2*hthickness), MyApplicationInterface.Alignment.ALIGNMENT_CENTRE);
                     }
@@ -2317,9 +2372,7 @@ public class DrawPreview {
                 int geo_radius_dps = (device_ui_rotation == 90 || device_ui_rotation == 270) ? 100 : 80;
                 int geo_radius = (int) (geo_radius_dps * scale + 0.5f); // convert dps to pixels
                 float geo_angle = (float)Math.toDegrees(geo_direction);
-                int angle_step = 10;
-                if( preview.getZoomRatio() >= 2.0f )
-                    angle_step = 5;
+                int angle_step = getAngleStep();
                 for(int longitude_angle=0;longitude_angle<360;longitude_angle+=angle_step) {
                     double this_angle = longitude_angle - geo_angle;
 					/*if( MyDebug.LOG ) {
@@ -2340,18 +2393,14 @@ public class DrawPreview {
 							Log.d(TAG, "this_angle is now: " + this_angle);
 						}*/
                         float geo_distance = angle_scale * (float)Math.tan( Math.toRadians(this_angle) ); // angle_scale is already in pixels rather than dps
-                        // draw outline
-                        p.setColor(Color.BLACK);
-                        p.setAlpha(64);
-                        // can't use drawRoundRect(left, top, right, bottom, ...) as that requires API 21
-                        draw_rect.set(cx + geo_distance - 2*hthickness, cy - geo_radius - hthickness, cx + geo_distance + 2*hthickness, cy + geo_radius + hthickness);
-                        canvas.drawRoundRect(draw_rect, 2*hthickness, 2*hthickness, p);
-                        // draw inner portion
                         p.setColor(Color.WHITE);
                         p.setTextAlign(Paint.Align.CENTER);
                         p.setAlpha(line_alpha);
+                        p.setShadowLayer(shadow_radius, 0.0f, 0.0f, Color.BLACK);
+                        // can't use drawRoundRect(left, top, right, bottom, ...) as that requires API 21
                         draw_rect.set(cx + geo_distance - hthickness, cy - geo_radius, cx + geo_distance + hthickness, cy + geo_radius);
                         canvas.drawRoundRect(draw_rect, hthickness, hthickness, p);
+                        p.clearShadowLayer();
                         // draw geo direction angle indicator
                         applicationInterface.drawTextWithBackground(canvas, p, "" + longitude_angle + "\u00B0", p.getColor(), Color.BLACK, (int)(cx + geo_distance), (int)(cy - geo_radius - 4*hthickness), MyApplicationInterface.Alignment.ALIGNMENT_BOTTOM);
                     }
@@ -2387,9 +2436,28 @@ public class DrawPreview {
                 int cx = canvas.getWidth()/2;
                 int cy = canvas.getHeight()/2;
 
+                float left = (canvas.getWidth() - w2)/2.0f;
+                float top = (canvas.getHeight() - h2)/2.0f;
+                float right = (canvas.getWidth() + w2)/2.0f;
+                float bottom = (canvas.getHeight() + h2)/2.0f;
+
                 canvas.save();
                 canvas.rotate((float)-level_angle, cx, cy);
 
+                // draw shaded area
+                float o_dist = (float)Math.sqrt(canvas.getWidth()*canvas.getWidth() + canvas.getHeight()*canvas.getHeight());
+                float o_left = (canvas.getWidth() - o_dist)/2.0f;
+                float o_top = (canvas.getHeight() - o_dist)/2.0f;
+                float o_right = (canvas.getWidth() + o_dist)/2.0f;
+                float o_bottom = (canvas.getHeight() + o_dist)/2.0f;
+                p.setStyle(Paint.Style.FILL);
+                p.setColor(Color.rgb(0, 0, 0));
+                p.setAlpha(crop_shading_alpha_c);
+                canvas.drawRect(o_left, o_top, left, o_bottom, p);
+                canvas.drawRect(right, o_top, o_right, o_bottom, p);
+                canvas.drawRect(left, o_top, right, top, p); // top
+                canvas.drawRect(left, bottom, right, o_bottom, p); // bottom
+
                 if( has_level_angle && Math.abs(level_angle) <= close_level_angle ) { // n.b., use level_angle, not angle or orig_level_angle
                     p.setColor(angle_highlight_color_pref);
                 }
@@ -2399,11 +2467,12 @@ public class DrawPreview {
                 p.setStyle(Paint.Style.STROKE);
                 p.setStrokeWidth(stroke_width);
 
-                canvas.drawRect((canvas.getWidth() - w2)/2.0f, (canvas.getHeight() - h2)/2.0f, (canvas.getWidth() + w2)/2.0f, (canvas.getHeight() + h2)/2.0f, p);
+                canvas.drawRect(left, top, right, bottom, p);
 
                 canvas.restore();
 
                 p.setStyle(Paint.Style.FILL); // reset
+                p.setAlpha(255); // reset
             }
         }
     }
@@ -2564,6 +2633,21 @@ public class DrawPreview {
         this.cover_preview = cover_preview;
     }
 
+    public void setDimPreview(boolean on) {
+        if( MyDebug.LOG )
+            Log.d(TAG, "setDimPreview: " + on);
+        if( on ) {
+            this.dim_preview = DimPreview.DIM_PREVIEW_ON;
+        }
+        else if( this.dim_preview == DimPreview.DIM_PREVIEW_ON ) {
+            this.dim_preview = DimPreview.DIM_PREVIEW_UNTIL;
+        }
+    }
+
+    public void clearDimPreview() {
+        this.dim_preview = DimPreview.DIM_PREVIEW_OFF;
+    }
+
     public void onDrawPreview(Canvas canvas) {
 		/*if( MyDebug.LOG )
 			Log.d(TAG, "onDrawPreview");*/
@@ -2611,19 +2695,45 @@ public class DrawPreview {
         // cover up the camera when the application is pausing, and to keep it covered up until
         // after we've resumed, and the camera has been reopened and we've received frames.
         if( preview.usingCamera2API() ) {
+            boolean camera_is_active = camera_controller != null && !camera_controller.shouldCoverPreview();
             if( cover_preview ) {
                 // see if we have received a frame yet
-                if( camera_controller != null && !camera_controller.shouldCoverPreview() ) {
+                if( camera_is_active ) {
                     if( MyDebug.LOG )
                         Log.d(TAG, "no longer need to cover preview");
                     cover_preview = false;
                 }
             }
             if( cover_preview ) {
+                // camera has never been active since last resuming
                 p.setColor(Color.BLACK);
                 //p.setColor(Color.RED); // test
                 canvas.drawRect(0.0f, 0.0f, canvas.getWidth(), canvas.getHeight(), p);
             }
+            else if( dim_preview == DimPreview.DIM_PREVIEW_ON || ( !camera_is_active && dim_preview == DimPreview.DIM_PREVIEW_UNTIL ) ) {
+                long time_now = System.currentTimeMillis();
+                if( camera_inactive_time_ms == -1 ) {
+                    camera_inactive_time_ms = time_now;
+                }
+                float frac = ((time_now - camera_inactive_time_ms) / (float)dim_effect_time_c);
+                frac = Math.min(frac, 1.0f);
+                int alpha = (int)(frac * 127);
+                if( MyDebug.LOG ) {
+                    Log.d(TAG, "time diff: " + (time_now - camera_inactive_time_ms));
+                    Log.d(TAG, "    frac: " + frac);
+                    Log.d(TAG, "    alpha: " + alpha);
+                }
+                p.setColor(Color.BLACK);
+                p.setAlpha(alpha);
+                canvas.drawRect(0.0f, 0.0f, canvas.getWidth(), canvas.getHeight(), p);
+                p.setAlpha(255);
+            }
+            else {
+                camera_inactive_time_ms = -1;
+                if( dim_preview == DimPreview.DIM_PREVIEW_UNTIL && camera_is_active ) {
+                    dim_preview = DimPreview.DIM_PREVIEW_OFF;
+                }
+            }
         }
 
         if( camera_controller!= null && front_screen_flash ) {
diff --git a/app/src/main/java/net/sourceforge/opencamera/ui/MainUI.java b/app/src/main/java/net/sourceforge/opencamera/ui/MainUI.java
index 8146ea88325062fc8704b7025a976dfa8f7f3ec6..72522aa5281dc3c1cdfe67f2b64aeaa0d4e95bc6 100644
--- a/app/src/main/java/net/sourceforge/opencamera/ui/MainUI.java
+++ b/app/src/main/java/net/sourceforge/opencamera/ui/MainUI.java
@@ -1113,7 +1113,7 @@ public class MainUI {
             int diff = (layoutParams.width-layoutParams.height)/2;
             if( MyDebug.LOG )
                 Log.d(TAG, "diff: " + diff);
-            setMarginsForSystemUI(layoutParams, +diff+left, -diff+top, +diff+right, -diff+bottom);
+            setMarginsForSystemUI(layoutParams, diff+left, -diff+top, diff+right, -diff+bottom);
         }
         else {
             setMarginsForSystemUI(layoutParams, left, top, right, bottom);
@@ -1450,6 +1450,10 @@ public class MainUI {
     public boolean showFaceDetectionIcon() {
         if (!main_activity.getPreview().supportsFaceDetection())
             return false;
+        if( main_activity.getApplicationInterface().isCameraExtensionPref() ) {
+            // not supported for camera extensions
+            return false;
+        }
         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(main_activity);
         return sharedPreferences.getBoolean(PreferenceKeys.ShowFaceDetectionPreferenceKey, false);
     }
@@ -2262,7 +2266,7 @@ public class MainUI {
                         // also reset exposure time when changing from manual to auto from the popup menu:
                         editor.putLong(PreferenceKeys.ExposureTimePreferenceKey, CameraController.EXPOSURE_TIME_DEFAULT);
                         editor.apply();
-                        preview.showToast("ISO: " + toast_option, 0, true); // supply offset_y_dp to be consistent with preview.setExposure(), preview.setISO()
+                        preview.showToast(null, "ISO: " + toast_option, 0, true); // supply offset_y_dp to be consistent with preview.setExposure(), preview.setISO()
                         main_activity.updateForSettings(true, ""); // already showed the toast, so block from showing again
                     }
                     else if( old_iso.equals(CameraController.ISO_DEFAULT) ) {
@@ -2298,7 +2302,7 @@ public class MainUI {
                         }
 
                         editor.apply();
-                        preview.showToast("ISO: " + toast_option, 0, true); // supply offset_y_dp to be consistent with preview.setExposure(), preview.setISO()
+                        preview.showToast(null, "ISO: " + toast_option, 0, true); // supply offset_y_dp to be consistent with preview.setExposure(), preview.setISO()
                         main_activity.updateForSettings(true, ""); // already showed the toast, so block from showing again
                     }
                     else {
@@ -2924,7 +2928,14 @@ public class MainUI {
 
                 switch (volume_keys) {
                     case "volume_take_photo":
-                        main_activity.takePicture(false);
+                        boolean done = false;
+                        if( keyCode == KeyEvent.KEYCODE_VOLUME_DOWN && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && main_activity.getPreview().isVideoRecording() ) {
+                            done = true;
+                            main_activity.pauseVideo();
+                        }
+                        if( !done ) {
+                            main_activity.takePicture(false);
+                        }
                         return true;
                     case "volume_focus":
                         if (keydown_volume_up && keydown_volume_down) {
@@ -2980,10 +2991,12 @@ public class MainUI {
                             editor.putBoolean(PreferenceKeys.AutoStabilisePreferenceKey, auto_stabilise);
                             editor.apply();
                             String message = main_activity.getResources().getString(R.string.preference_auto_stabilise) + ": " + main_activity.getResources().getString(auto_stabilise ? R.string.on : R.string.off);
-                            main_activity.getPreview().showToast(main_activity.getChangedAutoStabiliseToastBoxer(), message);
+                            main_activity.getPreview().showToast(main_activity.getChangedAutoStabiliseToastBoxer(), message, true);
                             main_activity.getApplicationInterface().getDrawPreview().updateSettings(); // because we cache the auto-stabilise setting
                             this.destroyPopup(); // need to recreate popup in order to update the auto-level checkbox
-                        } else {
+                        }
+                        else if( !main_activity.deviceSupportsAutoStabilise() ) {
+                            // n.b., need to check deviceSupportsAutoStabilise() - if we're in e.g. Panorama mode, we shouldn't display a toast (as then supportsAutoStabilise() returns false even if auto-level is supported on the device)
                             main_activity.getPreview().showToast(main_activity.getChangedAutoStabiliseToastBoxer(), R.string.auto_stabilise_not_supported);
                         }
                         return true;
diff --git a/app/src/main/java/net/sourceforge/opencamera/ui/PopupView.java b/app/src/main/java/net/sourceforge/opencamera/ui/PopupView.java
index 7746c04a3b3219818ca9c6bfa2d3f46dca1f145b..7f55579d1991b1a9997842af81bd2dd4de0bac3f 100644
--- a/app/src/main/java/net/sourceforge/opencamera/ui/PopupView.java
+++ b/app/src/main/java/net/sourceforge/opencamera/ui/PopupView.java
@@ -411,7 +411,7 @@ public class PopupView extends LinearLayout {
                         public void run() {
                             if (MyDebug.LOG)
                                 Log.d(TAG, "update settings due to resolution change");
-                            main_activity.updateForSettings(true, "", true); // keep the popupview open
+                            main_activity.updateForSettings(true, "", true, false); // keep the popupview open
                         }
                     };
 
@@ -495,7 +495,7 @@ public class PopupView extends LinearLayout {
                         public void run() {
                             if( MyDebug.LOG )
                                 Log.d(TAG, "update settings due to video resolution change");
-                            main_activity.updateForSettings(true, "", true); // keep the popupview open
+                            main_activity.updateForSettings(true, "", true, false); // keep the popupview open
                         }
                     };
 
@@ -579,7 +579,7 @@ public class PopupView extends LinearLayout {
                             float new_aperture = apertures.get(index);
                             if( MyDebug.LOG )
                                 Log.d(TAG, "new_aperture: " + new_aperture);
-                            preview.showToast(null, getResources().getString(R.string.aperture) + ": " + option);
+                            preview.showToast(null, getResources().getString(R.string.aperture) + ": " + option, true);
                             main_activity.getApplicationInterface().setAperture(new_aperture);
                             if( preview.getCameraController() != null ) {
                                 preview.getCameraController().setAperture(new_aperture);
@@ -807,7 +807,7 @@ public class PopupView extends LinearLayout {
                             public void run() {
                                 if (MyDebug.LOG)
                                     Log.d(TAG, "update settings due to video capture rate change");
-                                main_activity.updateForSettings(true, "", true); // keep the popupview open
+                                main_activity.updateForSettings(true, "", true, false); // keep the popupview open
                             }
                         };
 
@@ -852,7 +852,7 @@ public class PopupView extends LinearLayout {
                                 handler.postDelayed(update_runnable, 400);
                             }
                             else {
-                                main_activity.updateForSettings(true, toast_message, keep_popup);
+                                main_activity.updateForSettings(true, toast_message, keep_popup, false);
                             }
                         }
                         @Override
@@ -1226,7 +1226,7 @@ public class PopupView extends LinearLayout {
             }
 
             main_activity.getApplicationInterface().getDrawPreview().updateSettings(); // because we cache the photomode
-            main_activity.updateForSettings(true, toast_message); // need to setup the camera again, as options may change (e.g., required burst mode, or whether RAW is allowed in this mode)
+            main_activity.updateForSettings(true, toast_message, false, true); // need to setup the camera again, as options may change (e.g., required burst mode, or whether RAW is allowed in this mode)
             main_activity.getMainUI().destroyPopup(); // need to recreate popup for new selection
         }
     }
diff --git a/app/src/main/res/values-az/strings.xml b/app/src/main/res/values-az/strings.xml
index ab476705bdaf68cca967b62734a474c9632672cb..8b2e5dc364260ba4d949eaa524500b0985061c57 100644
--- a/app/src/main/res/values-az/strings.xml
+++ b/app/src/main/res/values-az/strings.xml
@@ -157,7 +157,7 @@
     <string name="preference_textstamp">Mətn möhürü</string>
     <string name="preference_textstamp_summary">Şəkil üzərində xüsusi mətn yaz</string>
     <string name="preference_stamp_fontsize">Şrift ölçüsü</string>
-    <string name="preference_stamp_fontsize_summary">Şəkil üzərində mətn yazısı üçün şriftin ölçüsü</string>
+    <string name="preference_stamp_fontsize_summary">Şəkil üzərində mətn yazısı üçün şriftin ölçüsü\n%s</string>
     <string name="video_quality">Video keyfiyyəti</string>
     <string name="preference_force_video_4k">Video keyfiyyəti 4K UHD (eksperimental)</string>
     <string name="preference_force_video_4k_summary">Arxa kamera üçün 3840х2160 ölçüsü seçiləcək və yalnız cihaz verilən formatı dəstəklədiyi zaman işləyəcək!</string>
diff --git a/app/src/main/res/values-be/strings.xml b/app/src/main/res/values-be/strings.xml
index 5667b75bcb96d4478c61c7a31770bae5225e8e7f..dfea3109385d456dcf3dc95537b8eaffd99d7f51 100644
--- a/app/src/main/res/values-be/strings.xml
+++ b/app/src/main/res/values-be/strings.xml
@@ -177,9 +177,9 @@
     <string name="preference_textstamp">Прызначыць тэкст</string>
     <string name="preference_textstamp_summary">Друкаваць на фотаздымках дадзены тэкст</string>
     <string name="preference_stamp_fontsize">Памер шрыфту</string>
-    <string name="preference_stamp_fontsize_summary">Памер шрыфту для друку на фотаздымках</string>
+    <string name="preference_stamp_fontsize_summary">Памер шрыфту для друку на фотаздымках\n%s</string>
     <string name="preference_stamp_font_color">Колер шрыфту</string>
-    <string name="preference_stamp_font_color_summary">Колер шрыфту для друку на фотаздымках</string>
+    <string name="preference_stamp_font_color_summary">Колер шрыфту для друку на фотаздымках\n%s</string>
     <string name="preference_stamp_style">Стыль тэксту</string>
     <string name="preference_stamp_style_summary">Стыль для друку на фотаздымках\n%s</string>
     <string name="video_quality">Раздзяляльная здольнасць відэа</string>
diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml
index 04e2a7b0b3689b08c6e12729046b90039c59f192..7b7cb7968d9a056e159247afdfb2b78cac768435 100644
--- a/app/src/main/res/values-cs/strings.xml
+++ b/app/src/main/res/values-cs/strings.xml
@@ -180,9 +180,9 @@
     <string name="preference_textstamp">Vlastní text</string>
     <string name="preference_textstamp_summary">Orazítkovat fotografie vlastním textem</string>
     <string name="preference_stamp_fontsize">Velikost písma</string>
-    <string name="preference_stamp_fontsize_summary">Velikost písma pro oražení fotografií textem</string>
+    <string name="preference_stamp_fontsize_summary">Velikost písma pro oražení fotografií textem\n%s</string>
     <string name="preference_stamp_font_color">Barva písma</string>
-    <string name="preference_stamp_font_color_summary">Barva písma pro oražení fotografií textem</string>
+    <string name="preference_stamp_font_color_summary">Barva písma pro oražení fotografií textem\n%s</string>
     <string name="preference_stamp_style">Styl textu</string>
     <string name="preference_stamp_style_summary">Styl textu pro oražení fotografií textem\n%s</string>
     <string name="video_quality">Rozlišení videa</string>
diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml
index be1e219b964d478f74755d27ca02b4ebe7b2be4a..60a9fc1b8ea8b960a0be8328eb5278a1f9c491f3 100644
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -187,9 +187,9 @@
     <string name="preference_textstamp">Textstempel</string>
     <string name="preference_textstamp_summary">Definition eines eigenen Textstempels</string>
     <string name="preference_stamp_fontsize">Stempel-Schriftgröße</string>
-    <string name="preference_stamp_fontsize_summary">Einstellung der Stempel-Schriftgröße</string>
+    <string name="preference_stamp_fontsize_summary">Einstellung der Stempel-Schriftgröße\n%s</string>
     <string name="preference_stamp_font_color">Stempel-Schriftfarbe</string>
-    <string name="preference_stamp_font_color_summary">Einstellung der Stempel-Schriftfarbe</string>
+    <string name="preference_stamp_font_color_summary">Einstellung der Stempel-Schriftfarbe\n%s</string>
     <string name="preference_stamp_style">Stempelstil</string>
     <string name="preference_stamp_style_summary">Einstellung der Stempelart\n%s</string>
     <string name="preference_background_photo_saving">Benutze Hintergrund-Thread</string>
diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml
index bd281cdfd54c98cf872bb3e7b636e49416e5f1f3..b8201ce3d3f390d11be3340f9605494028c65c60 100644
--- a/app/src/main/res/values-el/strings.xml
+++ b/app/src/main/res/values-el/strings.xml
@@ -187,9 +187,9 @@
     <string name="preference_textstamp">Προσαρμοσμένο κείμενο</string>
     <string name="preference_textstamp_summary">Προσθήκη σφραγίδας με προσαρμοσμένο κείμενο</string>
     <string name="preference_stamp_fontsize">Μέγεθος γραματοσειράς</string>
-    <string name="preference_stamp_fontsize_summary">Μεγέθος γραμματοσειράς για χρήση στις σφραγίδες</string>
+    <string name="preference_stamp_fontsize_summary">Μεγέθος γραμματοσειράς για χρήση στις σφραγίδες\n%s</string>
     <string name="preference_stamp_font_color">Χρώμα γραμματοσειράς</string>
-    <string name="preference_stamp_font_color_summary">Χρώμα γραμματοσειράς για χρήση στις σφραγίδες</string>
+    <string name="preference_stamp_font_color_summary">Χρώμα γραμματοσειράς για χρήση στις σφραγίδες\n%s</string>
     <string name="preference_stamp_style">Στυλ κειμένου</string>
     <string name="preference_stamp_style_summary">Στυλ κειμένου για χρήση στις σφραγίδες\n%s</string>
     <string name="preference_background_photo_saving">Χρήση νήματος φόντου</string>
diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml
index 3983d2e38adbc847428a809e948b11603aae517c..1d333fa8540db7567c83228f21eb59e79910b1dc 100644
--- a/app/src/main/res/values-es/strings.xml
+++ b/app/src/main/res/values-es/strings.xml
@@ -191,9 +191,9 @@
     <string name="preference_textstamp">Texto personalizado</string>
     <string name="preference_textstamp_summary">Estampe fotos con un texto personalizado</string>
     <string name="preference_stamp_fontsize">Tamaño de fuente</string>
-    <string name="preference_stamp_fontsize_summary">Tamaño de fuente a utilizar cuando se estampe texto en las fotos</string>
+    <string name="preference_stamp_fontsize_summary">Tamaño de fuente a utilizar cuando se estampe texto en las fotos\n%s</string>
     <string name="preference_stamp_font_color">Color de fuente</string>
-    <string name="preference_stamp_font_color_summary">Color de la fuente a utilizar cuando se estampe texto en las fotos</string>
+    <string name="preference_stamp_font_color_summary">Color de la fuente a utilizar cuando se estampe texto en las fotos\n%s</string>
     <string name="preference_stamp_style">Estilo de texto</string>
     <string name="preference_stamp_style_summary">Estilo a utilizar cuando se estampe texto en las fotos\n%s</string>
     <string name="preference_background_photo_saving">Utilizar subproceso en segundo plano</string>
diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml
index b18ab46b7d0bbcc1fee055c1e245c5bacf4c57bc..5eaaec51de254e53d440ab31bb51076d5360bf68 100644
--- a/app/src/main/res/values-hu/strings.xml
+++ b/app/src/main/res/values-hu/strings.xml
@@ -190,9 +190,9 @@
     <string name="preference_textstamp">Egyéni szöveg</string>
     <string name="preference_textstamp_summary">Képek feliratozása egyéni szöveggel</string>
     <string name="preference_stamp_fontsize">Betűméret</string>
-    <string name="preference_stamp_fontsize_summary">A feliratozás szövegének betűmérete</string>
+    <string name="preference_stamp_fontsize_summary">A feliratozás szövegének betűmérete\n%s</string>
     <string name="preference_stamp_font_color">Betűszín</string>
-    <string name="preference_stamp_font_color_summary">A feliratozás szövegének betűszíne</string>
+    <string name="preference_stamp_font_color_summary">A feliratozás szövegének betűszíne\n%s</string>
     <string name="preference_stamp_style">Szövegstílus</string>
     <string name="preference_stamp_style_summary">A feliratozás szövegének stílusa\n%s</string>
     <string name="preference_background_photo_saving">Háttérszál használata</string>
diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml
index a531368d53c18732cb738beee736b30fd542640d..2c18969a6b98322b4c50c630baf61d46c354c437 100644
--- a/app/src/main/res/values-it/strings.xml
+++ b/app/src/main/res/values-it/strings.xml
@@ -189,9 +189,9 @@
     <string name="preference_textstamp">Testo personalizzato</string>
     <string name="preference_textstamp_summary">Applica il timbro sulle foto con testo personalizzato</string>
     <string name="preference_stamp_fontsize">Dimensione carattere</string>
-    <string name="preference_stamp_fontsize_summary">Dimensione del carattere da utilizzare per il testo del timbro sulle foto</string>
+    <string name="preference_stamp_fontsize_summary">Dimensione del carattere da utilizzare per il testo del timbro sulle foto\n%s</string>
     <string name="preference_stamp_font_color">Colore carattere</string>
-    <string name="preference_stamp_font_color_summary">Colore del carattere da utilizzare per il testo del timbro sulle foto</string>
+    <string name="preference_stamp_font_color_summary">Colore del carattere da utilizzare per il testo del timbro sulle foto\n%s</string>
     <string name="preference_stamp_style">Stile testo</string>
     <string name="preference_stamp_style_summary">Stile da utilizzare per il testo del timbro sulle foto\n%s</string>
     <string name="preference_background_photo_saving">Usa processo in background</string>
diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml
index 6845ae484f5ffefc9c42b2183269911aeaf37771..995083d7a610cb210a17935e2239dc233a316d09 100644
--- a/app/src/main/res/values-ja/strings.xml
+++ b/app/src/main/res/values-ja/strings.xml
@@ -189,9 +189,9 @@
     <string name="preference_textstamp">文字の内容</string>
     <string name="preference_textstamp_summary">写真に貼り付けるスタンプ文字の内容を決めます</string>
     <string name="preference_stamp_fontsize">文字のサイズ</string>
-    <string name="preference_stamp_fontsize_summary">写真に貼り付けるスタンプ文字の大きさを決めます</string>
+    <string name="preference_stamp_fontsize_summary">写真に貼り付けるスタンプ文字の大きさを決めます\n%s</string>
     <string name="preference_stamp_font_color">文字の色</string>
-    <string name="preference_stamp_font_color_summary">写真に貼り付けるスタンプ文字の色を決めます</string>
+    <string name="preference_stamp_font_color_summary">写真に貼り付けるスタンプ文字の色を決めます\n%s</string>
     <string name="preference_stamp_style">文字の装飾</string>
     <string name="preference_stamp_style_summary">写真に貼り付けるスタンプ文字の装飾方法を決めます\n%s</string>
     <string name="video_quality">ビデオの解像度</string>
diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml
index 02826698ea904f38b913f025637e19f653c0d8a5..5cf45affb757a1cfa5e67cdcf2373935a6ac1b64 100644
--- a/app/src/main/res/values-ko/strings.xml
+++ b/app/src/main/res/values-ko/strings.xml
@@ -166,7 +166,7 @@
     <string name="preference_textstamp">임의 텍스트</string>
     <string name="preference_textstamp_summary">사진에 임의의 텍스트를 새깁니다</string>
     <string name="preference_stamp_fontsize">글자 크기</string>
-    <string name="preference_stamp_fontsize_summary">사진에 글자를 새길때 사용할 글자 크기를 선택합니다</string>
+    <string name="preference_stamp_fontsize_summary">사진에 글자를 새길때 사용할 글자 크기를 선택합니다\n%s</string>
     <string name="video_quality">동영상 해상도</string>
     <string name="preference_force_video_4k">강제 4K UHD 비디오 (실험적)</string>
     <string name="preference_force_video_4k_summary">후면 카메라로 동영상 촬영시 3840x2160 해상도를 사용합니다 - 기기가 지원하는 경우에만 작동하며 아닐 경우 충돌이 발생할 수 있습니다</string>
diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml
index 69512dea6e204c39ce166eec45737a240e8cd3b8..a3b3a538c83551e754530df26058a997da657d19 100644
--- a/app/src/main/res/values-nb/strings.xml
+++ b/app/src/main/res/values-nb/strings.xml
@@ -191,9 +191,9 @@
     <string name="preference_textstamp">Tilpasset tekst</string>
     <string name="preference_textstamp_summary">Stemple bilder med tilpasset tekst.</string>
     <string name="preference_stamp_fontsize">Skrifttypestørrelse</string>
-    <string name="preference_stamp_fontsize_summary">Skrifttypestørrelsen som skal brukes når det stemples tekst oppå bilder.</string>
+    <string name="preference_stamp_fontsize_summary">Skrifttypestørrelsen som skal brukes når det stemples tekst oppå bilder.\n%s</string>
     <string name="preference_stamp_font_color">Skrifttypefarge</string>
-    <string name="preference_stamp_font_color_summary">Skrifttypefargen som skal brukes når det stemples tekst oppå bilder.</string>
+    <string name="preference_stamp_font_color_summary">Skrifttypefargen som skal brukes når det stemples tekst oppå bilder.\n%s</string>
     <string name="preference_stamp_style">Tekststil</string>
     <string name="preference_stamp_style_summary">Stilen som skal brukes når det stemples tekst oppå bilder.\n%s</string>
     <string name="preference_background_photo_saving">Bruk bakgrunnstråd</string>
diff --git a/app/src/main/res/values-pl/arrays.xml b/app/src/main/res/values-pl/arrays.xml
index c41c7de9565023ef32288dce9c5cab3d06c845e3..c79cc139a33238a220e617a66082a90ff7443ee1 100644
--- a/app/src/main/res/values-pl/arrays.xml
+++ b/app/src/main/res/values-pl/arrays.xml
@@ -69,7 +69,7 @@
         <item>preference_preview_size_wysiwyg</item>
     </string-array>
     <string-array name="preference_touch_capture_entries">
-        <item>Wyłączone</item>
+        <item>Wyłączono</item>
         <item>Pojedyncze dotknięcie</item>
         <item>Podwójne dotknięcie</item>
     </string-array>
@@ -169,7 +169,7 @@
         <item>preference_stamp_timeformat_none</item>
     </string-array>
     <string-array name="preference_stamp_gpsformat_entries">
-        <item>Domyślny</item>
+        <item>Domyślnie</item>
         <item>Stopnie/minuty/sekundy</item>
         <item>Brak</item>
     </string-array>
@@ -261,7 +261,7 @@
     <string-array name="preference_expo_bracketing_stops_entries">
         <item>-0.5 do +0.5</item>
         <item>-1 do +1</item>
-        <item>-2    do +2</item>
+        <item>-2 do +2</item>
         <item>-3 do +3</item>
     </string-array>
     <string-array name="preference_expo_bracketing_stops_values">
diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml
index fe5b020fee17a320ebd2d18ea1f004683159b2ef..2373d67a29b355fed99ce9ee9b07194644cffb89 100644
--- a/app/src/main/res/values-pl/strings.xml
+++ b/app/src/main/res/values-pl/strings.xml
@@ -4,24 +4,22 @@
     <string name="action_settings">Ustawienia</string>
     <string name="action_popup">Ustawienia wyskakujących okienek</string>
     <string name="intro_ok">OK (Ta wiadomość nie pokaże się ponownie)</string>
-    <string name="on">Włączono</string>
-    <!-- whether a setting is turned on, e.g., "Auto-level: On" -->
-    <string name="off">Wyłączono</string>
-    <!-- whether a setting is turned off, e.g., "Auto-level: Off" -->
+
+    <string name="on">Włączono</string> <!-- whether a setting is turned on, e.g., "Auto-level: On" -->
+    <string name="off">Wyłączono</string> <!-- whether a setting is turned off, e.g., "Auto-level: Off" -->
+
     <string name="choose_save_location">Wybierz miejsce zapisywania:</string>
     <string name="clear_folder_history">Wyczyść historię folderów</string>
     <string name="clear_folder_history_question">Wyczyścić historię folderów?</string>
     <string name="choose_another_folder">Wybierz inny folder</string>
     <string name="changed_save_location">Zmieniono miejsce zapisywania na:</string>
     <string name="stopped_recording_video">Zatrzymano nagrywanie filmu</string>
-    <string name="repeats_to_go">pozostało powtórzeń</string>
-    <!--    intentionally starts lower case -->
+    <string name="repeats_to_go">pozostało powtórzeń</string> <!--    intentionally starts lower case -->
     <string name="failed_to_reconnect_camera">Nie udało się połączyć z aparatem</string>
     <string name="video_may_be_corrupted">Błąd, nagranie może być uszkodzone</string>
-    <string name="not_supported">Niewspierane na Twoim urządzeniu</string>
-    <!--    intentionally starts lower case -->
-    <string name="video_error_unknown">Nieznany błąd, wideo wstrzymane</string>
-    <string name="video_error_server_died">Błąd serwera, wideo wstrzymane</string>
+    <string name="not_supported">Niewspierane na twoim urządzeniu</string> <!--    intentionally starts lower case -->
+    <string name="video_error_unknown">Nieznany błąd, wstrzymano wideo</string>
+    <string name="video_error_server_died">Błąd serwera, wstrzymano wideo</string>
     <string name="video_max_duration">Nagranie osiągnęło maksymalną długość</string>
     <string name="video_max_filesize">Nagranie osiągnęło maksymalny rozmiar pliku</string>
     <string name="exposure_compensation">Korekta ekspozycji</string>
@@ -32,8 +30,8 @@
     <string name="back_camera">Tylny aparat</string>
     <string name="photo">Zdjęcie</string>
     <string name="video">Film</string>
-    <string name="exposure_locked">Ekspozycja zablokowana</string>
-    <string name="exposure_unlocked">Ekspozycja odblokowana</string>
+    <string name="exposure_locked">Zablokowano ekspozycję</string>
+    <string name="exposure_unlocked">Odblokowano ekspozycję</string>
     <string name="cancelled_timer">Anulowano samowyzwalacz</string>
     <string name="cancelled_repeat_mode">Anulowano serię</string>
     <string name="started_timer">Włączono timer</string>
@@ -42,7 +40,7 @@
     <string name="started_recording_video">Rozpoczęto nagrywanie wideo</string>
     <string name="sorry">Niestety</string>
     <string name="failed_to_save_photo">Nie udało się zapisać zdjęcia</string>
-    <string name="failed_to_save_photo_raw">Nie udało się zapisać zdjęcia w RAW</string>
+    <string name="failed_to_save_photo_raw">Nie udało się zapisać zdjęcia jako RAW</string>
     <string name="failed_to_auto_stabilise">Nie udało się wypoziomować</string>
     <string name="failed_to_start_camera_preview">Nie udało się uruchomić podglądu aparatu</string>
     <string name="taking_photo">Robienie zdjęcia</string>
@@ -53,7 +51,7 @@
     <string name="screen_is_locked">Ekran zablokowany\nprzesuń palcem, aby odblokować</string>
     <string name="unlocked">Odblokowano</string>
     <string name="auto_stabilise_not_supported">Autopoziomowanie niedostępne\nna tym urządzeniu</string>
-    <string name="audio_disabled">Dźwięk wyłączony</string>
+    <string name="audio_disabled">Wyłączono dźwięk</string>
     <string name="max_duration">Maksymalny czas trwania</string>
     <string name="color_effect">Efekt koloru</string>
     <string name="scene_mode">Tryb scenerii</string>
@@ -67,26 +65,26 @@
     <string name="iso">ISO</string>
     <string name="zoom">Przybliżenie</string>
     <string name="free_memory">Wolne</string>
-    <string name="screen_lock_message_1">[ZABLOKOWANE:</string>
+    <string name="screen_lock_message_1">[ZABLOKOWANO:</string>
     <string name="screen_lock_message_2">Przesuń palcem, aby odblokować]</string>
     <string name="failed_to_stamp">Nie udało się dodać stempla</string>
     <string name="metres_abbreviation">m</string> <!-- symbol short for metres -->
 
     <string name="preference_category_camera_effects">Efekty aparatu</string>
     <string name="preference_auto_stabilise">Autopoziomowanie</string>
-    <string name="preference_auto_stabilise_summary">Zdjęcia będą obracane i wyrównywane do poziomu (wolniejszy zapis zdjęcia, może się nie udać na urządzeniach z małą ilością pamięci)</string>
+    <string name="preference_auto_stabilise_summary">Zdjęcia będą obracane i wyrównywane do poziomu (wolniejszy zapis zdjęcia, może nie działać na urządzeniach z małą ilością pamięci)</string>
     <string name="preference_color_effect">Nałóż efekt kolorystyczny</string>
     <string name="preference_color_effect_summary">Nakłada efekt kolorystyczny na zdjęcie</string>
     <string name="preference_scene_mode">Zastosuj tryb scenerii</string>
-    <string name="preference_scene_mode_summary">Optymalizuj zdjęcie dla innych scenerii</string>
+    <string name="preference_scene_mode_summary">Optymalizuje zdjęcie dla innych scenerii</string>
     <string name="preference_white_balance">Ustaw balans bieli</string>
-    <string name="preference_white_balance_summary">Wybierz to ustawienie, aby dopasować balans bieli</string>
+    <string name="preference_white_balance_summary">Dopasowuje balans bieli</string>
     <string name="preference_iso">Ustaw czułość ISO</string>
     <string name="preference_iso_summary">Wyższa wartość oznacza większą czułość na światło (może nie działać na niektórych urządzeniach)</string>
     <string name="preference_exposure">Ustaw korektę ekspozycji</string>
     <string name="preference_exposure_summary">Ustaw 0 dla domyślnej korekty ekspozycji</string>
     <string name="preference_lock_orientation">Zablokuj orientację zdjęcia/filmu</string>
-    <string name="preference_lock_orientation_summary">Jeśli ustawione, orientacja urządzenia będzie ignorowana, priorytet będzie miała wybrana opcja\n%s</string>
+    <string name="preference_lock_orientation_summary">Jeśli włączono, orientacja urządzenia będzie ignorowana, priorytet będzie miała wybrana opcja\n%s</string>
     <string name="preference_face_detection">Wykrywanie twarzy</string>
     <string name="preference_face_detection_summary">Używa wykrywania twarzy zamiast obszarów ostrości</string>
 
@@ -100,15 +98,15 @@
     <string name="preference_burst_interval">Interwał Serii</string>
     <string name="preference_screen_camera_controls_more">Więcej ustawień aparatu…</string>
     <string name="preference_touch_capture">Dotknij, aby zrobić zdjęcie</string>
-    <string name="preference_touch_capture_summary">Zrób zdjęcie poprzez pojedyncze lub podwójne dotknięcie</string>
+    <string name="preference_touch_capture_summary">Robi zdjęcie poprzez pojedyncze lub podwójne dotknięcie</string>
     <string name="preference_pause_preview">Pauza po zrobieniu zdjęcia</string>
-    <string name="preference_pause_preview_summary">Wstrzymaj podgląd po zrobieniu zdjęcia, z możliwością udostępnienia lub usunięcia</string>
+    <string name="preference_pause_preview_summary">Wstrzymuje podgląd po zrobieniu zdjęcia, z możliwością udostępnienia lub usunięcia</string>
     <string name="preference_shutter_sound">Dźwięk migawki</string>
     <string name="preference_shutter_sound_summary">Odtwarza dźwięk podczas robienia zdjęcia</string>
     <string name="preference_volume_keys">Klawisze głośności</string>
     <string name="preference_audio_control">Aktywacja za pomocą dźwięków</string>
-    <string name="preference_audio_noise_control_sensitivity">Wrażliwość sterowania dźwiękiem</string>
-    <string name="preference_audio_noise_control_sensitivity_summary">Poziom wrażliwości na głośne dźwięki aktywujące aparat</string>
+    <string name="preference_audio_noise_control_sensitivity">Czułość sterowania dźwiękiem</string>
+    <string name="preference_audio_noise_control_sensitivity_summary">Poziom czułości na głośne dźwięki aktywujące aparat</string>
     <string name="preference_save_location">Lokalizacja zapisu</string>
     <string name="preference_save_location_summary">Folder, do którego będą zapisywane pliki</string>
     <string name="preference_using_saf_summary">Używa Storage Access Framework do zapisu plików zdjęć i filmów</string>
@@ -117,8 +115,8 @@
     <string name="preference_save_video_prefix">Przedrostek nazw filmów</string>
     <string name="preference_save_video_prefix_summary">Przedrostek używany w nazwach plików filmów</string>
     <string name="preference_save_zulu_time">Format czasu w nazwie pliku</string>
-    <string name="preference_show_when_locked">Pokaż aparat gdy zablokowany</string>
-    <string name="preference_show_when_locked_summary">Jeśli włączone, aplikacja Open Camera będzie widoczna ponad ekranem blokady (dostęp do opcji, galerii itp. wymaga odblokowania)</string>
+    <string name="preference_show_when_locked">Pokaż aparat, gdy zablokowany</string>
+    <string name="preference_show_when_locked_summary">Jeśli włączono, aplikacja Open Camera będzie widoczna ponad ekranem blokady (dostęp do opcji, galerii itp. wymaga odblokowania)</string>
     <string name="preference_startup_focus">Automatyczna ostrość podczas uruchamiania</string>
     <string name="preference_startup_focus_summary">Autofokus będzie uruchamiany podczas włączania aplikacji. Jeśli występuje problem z włączaniem lampy błyskowej podczas uruchamiania, wyłącz tę opcję</string>
     <string name="preference_lock_video">Blokuj ekranu podczas nagrywania filmu</string>
@@ -163,7 +161,7 @@
     <string name="preference_take_photo_border">Ramka</string>
     <string name="preference_take_photo_border_summary">Wyświetla ramkę wokół ekranu po wykonaniu zdjęcia</string>
     <string name="preference_keep_display_on">Utrzymuj ekran włączony</string>
-    <string name="preference_keep_display_on_summary">Ekran nie wyłączy się jeśli główny ekran aplikacji Open Camera będzie aktywny</string>
+    <string name="preference_keep_display_on_summary">Ekran nie wyłączy się jeśli aplikacja Open Camera będzie aktywna</string>
     <string name="preference_max_brightness">Wymuś maksymalną jasność</string>
     <string name="preference_max_brightness_summary">Wymusza maksymalną jasność ekranu pomijając ustawienie systemu operacyjnego urządzenia</string>
     <string name="preference_category_camera_quality">Ustawienia zdjęć i filmów</string>
@@ -189,18 +187,18 @@
     <string name="preference_textstamp">Własny tekst</string>
     <string name="preference_textstamp_summary">Określa własny tekst na stemplu</string>
     <string name="preference_stamp_fontsize">Rozmiar czcionki</string>
-    <string name="preference_stamp_fontsize_summary">Rozmiar czcionki używanej do stemplowania zdjęcia</string>
+    <string name="preference_stamp_fontsize_summary">Rozmiar czcionki używanej do stemplowania zdjęcia\n%s</string>
     <string name="preference_stamp_font_color">Kolor czcionki</string>
-    <string name="preference_stamp_font_color_summary">Kolor czcionki używanej do stemplowania zdjęcia</string>
+    <string name="preference_stamp_font_color_summary">Kolor czcionki używanej do stemplowania zdjęcia\n%s</string>
     <string name="preference_stamp_style">Styl tekstu</string>
     <string name="preference_stamp_style_summary">Określa styl tekstu stempla\n%s</string>
     <string name="preference_background_photo_saving">Użyj wątku w tle</string>
     <string name="preference_background_photo_saving_summary">Używa wątku aplikacji działającego w tle do zapisu zdjęć (dla szybszego działania)</string>
-    <string name="video_quality">Rozdzielczość Wideo</string>
+    <string name="video_quality">Rozdzielczość wideo</string>
     <string name="preference_force_video_4k">Wymuś nagrywanie filmów 4K UHD (działa tylko na niektórych urządzeniach)</string>
     <string name="preference_force_video_4k_summary">Włącza rozdzielczość 3840x2160 przy nagrywaniu filmów z tylnego aparatu. Ta opcja to hack, który pozwala urządzeniom z obsługą 4K na nagrywanie filmów w 4K, mimo zablokowania takiej możliwości dla niefirmowych aplikacji nagrywających. Nie ma gwarancji, że to zadziała, proszę przetestować.</string>
     <string name="preference_video_stabilization">Cyfrowa stabilizacja obrazu</string>
-    <string name="preference_video_stabilization_summary">Stabilizacja redukuje wstrząsy wywołane ruchem urządzenia. Działa podczas podglądu oraz nagrywania filmów. Ta funkcja może być zbędna, jeżeli urządzenie zostało wyposażone w optyczną stabilizację obrazu (OIS)</string>
+    <string name="preference_video_stabilization_summary">Redukuje wstrząsy wywołane ruchem urządzenia. Działa podczas podglądu oraz nagrywania filmów. Ta funkcja może być zbędna, jeżeli urządzenie zostało wyposażone w optyczną stabilizację obrazu (OIS)</string>
     <string name="preference_video_bitrate">Bitrate filmów (przybliżony)</string>
     <string name="preference_video_bitrate_summary">Ustawia przybliżony bitrate filmów (wyższa wartość oznacza lepszą jakość, ale zabiera więcej pamięci; ustawienie nieobsługiwanego bitrate może spowodować błąd zapisu)\n%s</string>
     <string name="preference_video_fps">Częstotliwość klatek (przybliżona)</string>
@@ -214,18 +212,18 @@
     <string name="preference_video_restart_max_filesize">Restart nagrywania według rozmiaru</string>
     <string name="preference_video_restart_max_filesize_summary">Nagrywanie wznowi się automatycznie, gdy rozmiar pliku osiągnie ustawioną maksymalną wartość</string>
     <string name="preference_record_audio">Nagrywanie z dźwiękiem</string>
-    <string name="preference_record_audio_summary">Nagrywanie filmu wraz z dźwiękiem</string>
+    <string name="preference_record_audio_summary">Nagrywa film wraz z dźwiękiem</string>
     <string name="preference_record_audio_src">Źródło dźwięku</string>
     <string name="preference_record_audio_src_summary">Wybór mikrofonu, z którego będzie nagrywany dźwięk\n%s</string>
     <string name="preference_record_audio_channels">Źródło dźwięku</string>
     <string name="preference_record_audio_channels_summary">Wybór między dźwiękiem mono a stereo (dostępne tylko na niektórych urządzeniach)</string>
     <string name="preference_video_flash">Błysk podczas nagrywania</string>
-    <string name="preference_video_flash_summary">Jeśli włączone, lampa błyskowa będzie się włączać i wyłączać (przydatne w przypadku gdy chcemy z większej odległości stwierdzić czy kamera wciąż nagrywa)</string>
+    <string name="preference_video_flash_summary">Jeśli włączono, lampa błyskowa będzie się włączać i wyłączać (przydatne w przypadku gdy chcemy z większej odległości stwierdzić czy kamera wciąż nagrywa)</string>
     <string name="preference_category_online">Różne</string>
     <string name="preference_online_help">Pomoc on-line</string>
     <string name="preference_online_help_summary">Otwiera stronę aplikacji Open Camera w przeglądarce internetowej</string>
     <string name="preference_donate">Przekaż darowiznę</string>
-    <string name="preference_donate_summary">Jeśli spodobała Ci się ta aplikacja rozważ przekazanie darowizny, która wesprze rozwój aplikacji. Możesz to zrobić poprzez zakup specjalnej aplikacji - dotknij tutaj aby otworzyć stronę. Dzięki!</string>
+    <string name="preference_donate_summary">Jeśli spodobała ci się ta aplikacja rozważ przekazanie darowizny, która wesprze rozwój aplikacji. Możesz to zrobić poprzez zakup specjalnej aplikacji - dotknij tutaj, aby otworzyć stronę. Dzięki!</string>
     <string name="preference_use_camera2">Camera2 API</string>
     <string name="preference_use_camera2_summary">Włącza interfejs Camera2 API, który oferuje wiele dodatkowych funkcji, ale może działać niepoprawnie na niektórych urządzeniach (powoduje restart aplikacji)</string>
     <string name="preference_about">O aplikacji</string>
@@ -285,17 +283,17 @@
     <string name="preference_category_stamp">Stempel zdjęcia</string>
     <string name="preference_hdr_save_expo">Zapisz wszystkie zdjęcia dla HDR</string>
     <string name="preference_hdr_save_expo_summary">W trybie HDR zapisuje wszystkie zdjęcia, które posłużyły do powstania obrazu HDR. Może to spowodować wolniejszy zapis, zwłaszcza przy włączonej opcji stemplowania lub autopoziomowania.</string>
-    <string name="no_permission">POZWOLENIA NIE SĄ DOSTĘPNE</string>
+    <string name="no_permission">POZWOLENIA NIEDOSTĘPNE</string>
     <string name="permission_rationale_title">Wymagane pozwolenie</string>
     <string name="permission_rationale_camera">Wymagane pozwolenie na dostęp do aparatu</string>
     <string name="preference_category_photo_debugging">Opcje debugowania</string>
     <string name="preference_category_video_debugging">Opcje debugowania</string>
     <string name="preference_camera2_fake_flash">Użyj alternatywnej lampy błyskowej</string>
-    <string name="preference_camera2_fake_flash_summary">Włącz jeśli w Twoim urządzeniu lampa błyskowa przejawia dziwne zachowanie z Camera2 API</string>
+    <string name="preference_camera2_fake_flash_summary">Włącz jeśli w twoim urządzeniu lampa błyskowa przejawia dziwne zachowanie z Camera2 API</string>
     <string name="preference_expo_bracketing_n_images">Bracketing ekspozycji</string>
     <string name="preference_expo_bracketing_n_images_summary">Ilość obrazów w trybie bracketingu\n%s</string>
     <string name="preference_expo_bracketing_stops">Stopniowanie Bracketingu</string>
-    <string name="preference_expo_bracketing_stops_summary">Jaki ustawić zakres wartości dla jaśniejszej/ciemniejszej ekspozycji\n%s</string>
+    <string name="preference_expo_bracketing_stops_summary">Ustawia zakres wartości dla jaśniejszej/ciemniejszej ekspozycji\n%s</string>
     <string name="video_no_free_space">Brak wystarczającej ilości pamięci, aby nagrać film</string>
     <string name="video_power_critical">Filmowanie zatrzymane\nKrytyczny poziom baterii</string>
     <string name="preference_video_low_power_check">Sprawdzanie niskiego poziomu baterii</string>
@@ -305,7 +303,7 @@
     <string name="exposure_shutter_speed">Czas migawki</string>
     <string name="camera_error">Poważny błąd aparatu</string>
     <string name="preference_camera2_fast_burst">Szybka seria (HDR/bracketing)</string>
-    <string name="preference_camera2_fast_burst_summary">Pozwala na szybsze wykonywanie zdjęć HDR lub bracketing. Wyłącz, jeśli na Twoim urządzeniu powoduje błędy.</string>
+    <string name="preference_camera2_fast_burst_summary">Pozwala na szybsze wykonywanie zdjęć HDR lub bracketing. Wyłącz, jeśli na twoim urządzeniu powoduje błędy.</string>
     <string name="camera">Aparat</string>
     <string name="record_video">Nagraj film</string>
     <string name="selfie">Autoportret</string>
@@ -320,11 +318,11 @@
     <string name="preference_calibrate_level_calibration_reset">Reset kalibracji poziomu</string>
     <string name="photo_mode_dro">DRO</string>
     <string name="preference_show_pitch_lines">Linie pochylenia</string>
-    <string name="preference_show_pitch_lines_summary">Wyświetla poziome linie przechylenia</string>
+    <string name="preference_show_pitch_lines_summary">Wyświetla poziome linie podziałki</string>
     <string name="preference_show_geo_direction_lines">Linie kompasu</string>
     <string name="preference_show_geo_direction_lines_summary">Wyświetla linie kierunkowe kompasu</string>
     <string name="preference_video_subtitle">Napisy</string>
-    <string name="preference_video_subtitle_summary">Tworzy napisy (w formacie SRT), w których zostaną zapisane: data, czas i dane GPS (jeśli włączone)\n%s</string>
+    <string name="preference_video_subtitle_summary">Tworzy napisy (w formacie SRT), w których zostaną zapisane: data, czas i dane GPS (jeśli włączono)\n%s</string>
     <string name="duration_unlimited">Bez limitu</string>
     <string name="duration_3s">3 sekundy</string>
     <string name="duration_5s">5 sekund</string>
@@ -351,8 +349,8 @@
     <string name="duration_1h">1 godzina</string>
     <string name="preference_show_take_photo">Zrób zdjęcie</string>
     <string name="preference_show_take_photo_summary">Pokazuje przycisk do robienia zdjęć i nagrywania filmów. Można go wyłączyć na urządzeniach, które posiadają fizyczny przycisk aparatu.</string>
-    <string name="video_pause">Film wstrzymany</string>
-    <string name="video_resume">Film wznowiony</string>
+    <string name="video_pause">Wstrzymano film</string>
+    <string name="video_resume">Wznowiono film</string>
     <string name="pause_video">Wstrzymaj filmowanie</string>
     <string name="resume_video">Wznów filmowanie</string>
     <string name="capturing">Przechwytywanie…</string>
@@ -377,11 +375,11 @@
     <string name="preference_stamp_dateformat_none">Brak</string>
 
     <string name="flash_off">Lampa wyłączona</string>
-    <string name="flash_auto">Lampa auto</string>
+    <string name="flash_auto">Lampa automatyczna</string>
     <string name="flash_on">Lampa włączona</string>
     <string name="flash_torch">Latarka</string>
-    <string name="flash_red_eye">Czerwone oczy</string>
-    <string name="flash_frontscreen_auto">Błysk ekranowy auto</string>
+    <string name="flash_red_eye">Redukcja czerwonych oczu</string>
+    <string name="flash_frontscreen_auto">Błysk ekranowy automatyczny</string>
     <string name="flash_frontscreen_on">Błysk ekranowy włączony</string>
 
     <string name="preference_video_bitrate_default">Domyślnie</string>
@@ -444,7 +442,7 @@
     <string name="preference_burst_interval_1h">1h</string>
     <string name="preference_burst_interval_2h">2h</string>
 
-    <string name="preference_video_max_filesize_default">Domyślny urządzenia</string>
+    <string name="preference_video_max_filesize_default">Domyślnie dla urządzenia</string>
     <string name="preference_video_max_filesize_100mb">100MB</string>
     <string name="preference_video_max_filesize_200mb">200MB</string>
     <string name="preference_video_max_filesize_300mb">300MB</string>
@@ -473,7 +471,7 @@
     <string name="preference_audio_noise_control_sensitivity_0">0 (domyślnie)</string>
     <string name="preference_audio_noise_control_sensitivity_m1">-1</string>
     <string name="preference_audio_noise_control_sensitivity_m2">-2</string>
-    <string name="preference_audio_noise_control_sensitivity_m3">-3 (nika czułość)</string>
+    <string name="preference_audio_noise_control_sensitivity_m3">-3 (niska czułość)</string>
 
     <string name="preference_ui_placement_left">Interfejs dla leworęcznych</string>
     <string name="preference_ui_placement_right">Interfejs dla praworęcznych</string>
@@ -524,8 +522,8 @@
 
     <string name="preference_video_capture_rate">Szybkość</string>
     <string name="preference_video_capture_rate_normal">Normalnie</string>
-    <string name="slow_motion_enabled">Zwolnione tempo włączone</string>
-    <string name="slow_motion_disabled">Zwolnione tempo wyłączone</string>
+    <string name="slow_motion_enabled">Włączono zwolnione tempo</string>
+    <string name="slow_motion_disabled">Wyłączono zwolnione tempo</string>
 
     <string name="flash_frontscreen_torch">Ekranowa latarka</string>
 
@@ -537,7 +535,7 @@
     <string name="anti_banding_off">Wyłącz</string>
 
     <string name="preference_ghost_image">Efekt "ducha"</string>
-    <string name="preference_ghost_image_summary">Nakłada obraz, aby pomóc w wyrównaiu.\n%s</string>
+    <string name="preference_ghost_image_summary">Nakłada obraz, aby pomóc w wyrównaniu.\n%s</string>
     <string name="preference_ghost_image_off">Wyłączony</string>
     <string name="preference_ghost_image_last">Ostatnie zrobione zdjęcie</string>
     <string name="preference_ghost_image_selected">Wybrane zdjęcie</string>
@@ -546,9 +544,9 @@
     <string name="saf_permission_failed_open_image">Nie można otworzyć tego obrazu</string>
 
     <string name="preference_camera2_photo_video_recording">Zezwalaj na zdjęcia podczas nagrywania filmu</string>
-    <string name="preference_camera2_photo_video_recording_summary">Umożliwia robienie zdjęć podczas nagrywania filmów. Wyłącz tę opcję, jeśli występują problemy z nagrywaniem wideo przy włączonym interfejsie Camera2 API na Twoim urządzeniu.</string>
+    <string name="preference_camera2_photo_video_recording_summary">Umożliwia robienie zdjęć podczas nagrywania filmów. Wyłącz tę opcję, jeśli występują problemy z nagrywaniem wideo przy włączonym interfejsie Camera2 API na twoim urządzeniu.</string>
 
-    <string name="preference_video_log">Profile Wideo</string>
+    <string name="preference_video_log">Profile wideo</string>
     <string name="preference_video_log_summary">Ustaw standardowy lub płaski profil obrazu dla trybu wideo\n%s</string>
     <string name="preference_video_log_off">Domyślny</string>
     <string name="preference_video_log_fine">Log (Drobny)</string>
@@ -579,7 +577,7 @@
     <string name="focus_bracketing_add_infinity">Dodaj nieskończoną odległość</string>
 
     <string name="magnetic_accuracy_title">Dokładność kompasu</string>
-    <string name="magnetic_accuracy_info">Kompas Twojego urządzenia wymaga kalibracji, aby poprawić jego dokładność. Można to zrobić, poruszając urządzenie ruchem ósemkowym.\n\nAktualna dokładność:</string>
+    <string name="magnetic_accuracy_info">Kompas twojego urządzenia wymaga kalibracji, aby poprawić jego dokładność. Można to zrobić, poruszając urządzenie ruchem ósemkowym.\n\nAktualna dokładność:</string>
 
     <string name="accuracy_unreliable">Niedokładny</string>
     <string name="accuracy_low">Niski</string>
@@ -628,10 +626,10 @@
     <string name="preference_hdr_contrast_enhancement_smart">Sprytna</string>
     <string name="preference_hdr_contrast_enhancement_always">Zawsze</string>
 
-    <string name="preference_video_output_format">Format Wideo</string>
+    <string name="preference_video_output_format">Format wideo</string>
     <string name="preference_video_output_format_summary">Format plików wideo, audio oraz kodeki\n%s</string>
 
-    <string name="preference_video_output_format_default">Domyślny</string>
+    <string name="preference_video_output_format_default">Domyślnie</string>
     <string name="preference_video_output_format_mpeg4_h264">MPEG4 H264</string>
     <string name="preference_video_output_format_mpeg4_hevc">MPEG4 HEVC</string>
     <string name="preference_video_output_format_3gpp">3GPP</string>
@@ -640,7 +638,7 @@
     <string name="preference_screen_settings_manager">Menedżer ustawień</string>
 
     <string name="preference_save_settings">Zapisz ustawienia</string>
-    <string name="preference_save_settings_summary">Zapisuje wszystkie ustawienia aplikacji Open Camera w pliku</string>
+    <string name="preference_save_settings_summary">Zapisuje wszystkie ustawienia aplikacji Open Camera do pliku</string>
     <string name="preference_save_settings_filename">Nazwa zapisanych ustawień</string>
 
     <string name="preference_restore_settings">Przywróć ustawienia</string>
@@ -666,8 +664,8 @@
     <string name="preference_show_face_detection_summary">Wyświetla ikonę na ekranie do włączania lub wyłączania wykrywania twarzy</string>
     <string name="face_detection_enable">Włącz wykrywanie twarzy</string> <!-- for "ContentDescription" (used for accessibility, e.g., Google Talkback) -->
     <string name="face_detection_disable">Wyłącz wykrywanie twarzy</string> <!-- for "ContentDescription" (used for accessibility, e.g., Google Talkback) -->
-    <string name="face_detection_enabled">Wykrywanie twarzy włączone</string>
-    <string name="face_detection_disabled">Wykrywanie twarzy wyłączone</string>
+    <string name="face_detection_enabled">Włączono wykrywanie twarzy</string>
+    <string name="face_detection_disabled">Wyłączono wykrywanie twarzy</string>
 
     <string name="preference_show_auto_level">Automatyczne poziomowanie</string>
     <string name="preference_show_auto_level_summary">Wyświetla ikonę na ekranie do włączania lub wyłączania automatycznego poziomowania. Gdy automatyczne poziomowanie jest włączone, zdjęcia będą obracane, tak aby były automatycznie wyrównane z horyzontem.</string>
@@ -678,8 +676,8 @@
     <string name="preference_show_stamp_summary">Wyświetla ikonę na ekranie do włączania lub wyłączania stempla fotograficznego</string>
     <string name="stamp_enable">Włącz stemplowanie zdjęć</string> <!-- for "ContentDescription" (used for accessibility, e.g., Google Talkback) -->
     <string name="stamp_disable">Wyłącz stemplowanie zdjęć</string> <!-- for "ContentDescription" (used for accessibility, e.g., Google Talkback) -->
-    <string name="stamp_enabled">Stemplowanie zdjęć włączone</string>
-    <string name="stamp_disabled">Stemplowanie zdjęć wyłączone</string>
+    <string name="stamp_enabled">Włączono stemplowanie zdjęć</string>
+    <string name="stamp_disabled">Wyłączono stemplowanie zdjęć</string>
 
     <string name="preference_show_textstamp">Własny stempel tekstowy</string>
     <string name="preference_show_textstamp_summary">Pokazuje ikonę na ekranie do określenia własnego tekstu, który ma zostać umieszczony na zdjęciu</string>
@@ -688,8 +686,8 @@
     <string name="preference_show_white_balance_lock_summary">Wyświetla na ekranie ikonę do blokowania lub odblokowywania automatycznego balansu bieli</string>
     <string name="white_balance_lock">Zablokuj balans bieli</string>
     <string name="white_balance_unlock">Odblokuj balans bieli</string>
-    <string name="white_balance_locked">Balans bieli zablokowany</string>
-    <string name="white_balance_unlocked">Balans bieli odblokowany</string>
+    <string name="white_balance_locked">Zablokowano balans bieli</string>
+    <string name="white_balance_unlocked">Odblokowano balans bieli</string>
 
     <string name="preference_show_exposure_lock">Blokada automatycznej ekspozycji</string>
     <string name="preference_show_exposure_lock_summary">Wyświetla ikonę na ekranie do blokowania lub odblokowywania ekspozycji</string>
@@ -791,7 +789,7 @@
     <string name="preference_panorama_crop">Automatyczne kadrowanie panoramy</string>
     <string name="preference_panorama_crop_summary">W trybie panoramy: Usuwa faliste granice\n%s</string>
 
-    <string name="panorama_info">Aby zrobić zdjęcie panoramiczne, trzymając urządzenie pionowo dotknij przycisk "Zrób zdjęcie". Następnie skieruj urządzenie w lewo lub w prawo, tak aby białe kółko (na środku ekranu) pokryło się z niebieską kropką. Po przechwyceniu każdego nowego zdjęcia kieruj urządzenie, aby zakryć po kolei każdą nową niebieską kropkę.\n\nDotknij ikonkę "fajki", aby zapisać panoramę, lub ikonę "krzyżyka", aby anulować.\n\nPamiętaj, że przetwarzanie i zapisywanie zdjęć panoramicznych może zająć trochę czasu.</string>
+    <string name="panorama_info">Aby zrobić zdjęcie panoramiczne, trzymając urządzenie pionowo dotknij przycisku "Zrób zdjęcie". Następnie skieruj urządzenie w lewo lub w prawo tak, aby białe kółko (na środku ekranu) pokryło się z niebieską kropką. Po przechwyceniu każdego nowego zdjęcia kieruj urządzenie, aby zakryć po kolei każdą nową niebieską kropkę.\n\nDotknij ikonkę "fajki", aby zapisać panoramę, lub ikonę "krzyżyka", aby anulować.\n\nPamiętaj, że przetwarzanie i zapisywanie zdjęć panoramicznych może zająć trochę czasu.</string>
 
     <string name="preference_panorama_save">Oryginalne zdjęcia w trybie panoramy</string>
     <string name="preference_panorama_save_summary">Zapisuje oryginalne obrazy w trybie panoramy. Pamiętaj, że spowolni to zapisywanie zdjęć panoramicznych. Daje także możliwość zapisania pliku XML, co może być przydatne przy zgłaszaniu problemów z panoramą.\n%s</string>
@@ -817,7 +815,7 @@
 
     <!-- beware of string being too long to display! -->
     <string name="preference_stamp_geo_address_summary">Jeśli to możliwe, uzyskaj adres z lokalizacji GPS (do stempla, lub napisów do filmów).
-        Jeśli ta opcja jest włączona, Twoje urządzenie będzie przesyłało dane o lokalizacji przez Internet do strony trzeciej
+        Jeśli ta opcja jest włączona, twoje urządzenie będzie przesyłało dane o lokalizacji przez Internet do strony trzeciej
         w celu konwersji współrzędnych GPS na adres. Zobacz stronę https://developer.android.com/reference/android/location/Geocoder .
         Ta funkcja nie gwarantuje dostępności ani dokładności. Nie ma gwarancji, że wyniki będą znaczące lub poprawne.
         \n%s</string>
@@ -866,13 +864,13 @@
     <string name="preference_zebra_stripes_color_white">Biały</string>
 
     <string name="external_camera">Aparat zewnętrzny</string>
-    <string name="ultrawide">Bardzo szeroki</string>
+    <string name="ultrawide">Ultra szeroki</string>
 
     <string name="switch_to_external_camera">Przełącz na aparat zewnętrzny</string>
     <string name="switch_to_unknown_camera">Przełącz aparat</string>
     <string name="switch_multi_camera">Przełączaj się między wieloma aparatami</string>
     <string name="preference_multi_cam_button">Ikona wielu aparatów</string>
-    <string name="preference_multi_cam_button_summary">Jeśli ta opcja jest włączona, użyj oddzielnych przycisków do przełączania między przednimi/tylnymi aparatami oraz do przełączania między wieloma przednimi/tylnymi kamerami. Jeśli jest wyłączona, ikona Przełącz aparat będzie przełączać się między wszystkimi aparatami.</string>
+    <string name="preference_multi_cam_button_summary">Jeśli ta opcja jest włączona, użyj oddzielnych przycisków do przełączania między przednimi/tylnymi aparatami oraz do przełączania między wieloma przednimi/tylnymi kamerami. Jeśli jest wyłączona, ikona "Przełącz aparat" będzie przełączać między wszystkimi aparatami.</string>
 
     <string name="preference_show_camera_id">Pokaż ID aparatu</string>
     <string name="preference_show_camera_id_summary">Wyświetla aktualny numer ID aparatu na ekranie</string>
@@ -888,11 +886,11 @@
     <string name="error_features_slow_motion">Zwolnione tempo</string>
 
     <string name="preference_comment_ypr">Przechowuj odchylenie, nachylenie i przechylenie</string>
-    <string name="preference_comment_ypr_summary">Zapisz odchylenie, nachylenie i przechylenie urządzenia w komentarzu użytkownika Exif do zdjęcia (tylko format JPEG)</string>
+    <string name="preference_comment_ypr_summary">Zapisuje odchylenie, nachylenie i przechylenie urządzenia w komentarzu użytkownika Exif do zdjęcia (tylko format JPEG)</string>
 
     <string name="array_seekbar_preference_seekbar">Pasek do zmiany bieżącej wartości preferencji</string>
 
-    <string name="white_balance_auto">Automatyczny</string>
+    <string name="white_balance_auto">Automatycznie</string>
     <string name="white_balance_cloudy">Pochmurno</string>
     <string name="white_balance_daylight">Światło dzienne</string>
     <string name="white_balance_fluorescent">Świetlówka</string>
@@ -913,8 +911,8 @@
     <string name="scene_mode_party">Impreza</string>
     <string name="scene_mode_portrait">Portret</string>
     <string name="scene_mode_snow">Śnieg</string>
-    <string name="scene_mode_sports">Sporty</string>
-    <string name="scene_mode_steady_photo">Stateczne zdjęcie</string>
+    <string name="scene_mode_sports">Sport</string>
+    <string name="scene_mode_steady_photo">Statyczne zdjęcie</string>
     <string name="scene_mode_sunset">Zachód słońca</string>
     <string name="scene_mode_theatre">Teatr</string>
 
@@ -942,7 +940,25 @@
 
     <string name="high_speed">Duża prędkość</string> <!-- in the sense of high speed video frame rates -->
 
-    <string name="preference_audio_control_none">Wyłączone</string>
+    <string name="preference_audio_control_none">Wyłączono</string>
     <string name="preference_audio_control_noise">Głośny dźwięk</string>
     <string name="preference_audio_control_voice">Komenda głosowa: \"cheese\"</string> <!-- note that cheese shouldn't be translated, as we listen for this no matter what language is being used -->
+
+    <string name="preference_camera2_dummy_capture_hack">Włącz pozorną korektę HDR/ekspozycji</string>
+    <string name="preference_camera2_dummy_capture_hack_summary">Spróbuj włączyć tę opcję, jeśli w twoim urządzeniu występują problemy z wykonywaniem zdjęć w trybach HDR lub Ekspo (jeśli zdjęcia ekspo mają taką samą wartość ekspozycji). Ma to znaczenie tylko wtedy, gdy włączona jest także poniższa opcja "Szybka seria HDR/bracketing.</string>
+
+    <string name="permission_rationale_bluetooth_scan_connect">Uprawnienia do skanowania/połączenia Bluetooth są wymagane do wykrywania i łączenia się z urządzeniami zdalnego sterowania Bluetooth LE.</string>
+    <string name="unknown_device_no_permission">Nieznane urządzenie (niedostępne zezwolenie na połączenie Bluetooth)</string>
+
+    <string name="photo_mode_x_auto">X-Auto</string> <!-- keep short, as this shows in the popup menu -->
+    <string name="photo_mode_x_auto_full">Rozszerzenie: Auto</string>
+    <string name="photo_mode_x_hdr">X-HDR</string> <!-- keep short, as this shows in the popup menu -->
+    <string name="photo_mode_x_hdr_full">Rozszerzenie: HDR</string>
+    <string name="photo_mode_x_night">X-Noc</string> <!-- keep short, as this shows in the popup menu -->
+    <string name="photo_mode_x_night_full">Rozszerzenie: Night</string>
+    <string name="photo_mode_x_bokeh">X-Bokeh</string> <!-- keep short, as this shows in the popup menu -->
+    <string name="photo_mode_x_bokeh_full">Rozszerzenie: Bokeh</string>
+    <string name="photo_mode_x_beauty">X-Bty</string> <!-- keep short, as this shows in the popup menu -->
+    <string name="photo_mode_x_beauty_full">Rozszerzenie: Piękno / Retusz twarzy</string>
+
 </resources>
diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml
index da91df347e77ec6f0e7ea71fd3afdc2438f2aff9..248d2922077985c5e4fc17de3bb94a8a7b81a4b9 100644
--- a/app/src/main/res/values-pt-rBR/strings.xml
+++ b/app/src/main/res/values-pt-rBR/strings.xml
@@ -167,7 +167,7 @@
     <string name="preference_textstamp">Texto customizado</string>
     <string name="preference_textstamp_summary">Use uma marca d\'água personalizada para fotos</string>
     <string name="preference_stamp_fontsize">Tamanho da fonte</string>
-    <string name="preference_stamp_fontsize_summary">Tamanho da fonte usada na marca d\'água sobre as fotos</string>
+    <string name="preference_stamp_fontsize_summary">Tamanho da fonte usada na marca d\'água sobre as fotos\n%s</string>
     <string name="video_quality">Resolução do vídeo</string>
     <string name="preference_force_video_4k">Forçar resolução 4K UHD (experimental)</string>
     <string name="preference_force_video_4k_summary">Habilita a resolução 3840x2160 para gravação de vídeos na câmera traseira - isso funcionará se seu dispositivo suportar e pode falhar se não suportar!</string>
diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml
index 7996b3b68bbbf774f948432744eeaf81413b3871..5ce1ac1e0ecd95249d231f6a2dc538444941d505 100644
--- a/app/src/main/res/values-pt-rPT/strings.xml
+++ b/app/src/main/res/values-pt-rPT/strings.xml
@@ -188,9 +188,9 @@
     <string name="preference_textstamp">Texto personalizado</string>
     <string name="preference_textstamp_summary">Carimbar fotografias com um texto personalizado</string>
     <string name="preference_stamp_fontsize">Tamanho do tipo de letra</string>
-    <string name="preference_stamp_fontsize_summary">Tamanho do tipo de letra usado para carimbar texto nas fotografias</string>
+    <string name="preference_stamp_fontsize_summary">Tamanho do tipo de letra usado para carimbar texto nas fotografias\n%s</string>
     <string name="preference_stamp_font_color">Cor do tipo de letra</string>
-    <string name="preference_stamp_font_color_summary">Cor do tipo de letra usado para carimbar texto nas fotografias</string>
+    <string name="preference_stamp_font_color_summary">Cor do tipo de letra usado para carimbar texto nas fotografias\n%s</string>
     <string name="preference_stamp_style">Estilo do texto</string>
     <string name="preference_stamp_style_summary">Estilo usado para carimbar texto nas fotografias\n%s</string>
     <string name="preference_background_photo_saving">Usar recurso em segundo plano</string>
diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml
index 815d4f94f31c8699bc6fe1b79cd4ead99d43326e..83e2e8ab22858de272afbdb902879944acef6f0d 100644
--- a/app/src/main/res/values-ru/strings.xml
+++ b/app/src/main/res/values-ru/strings.xml
@@ -183,9 +183,9 @@
     <string name="preference_textstamp">Подписывать фото</string>
     <string name="preference_textstamp_summary">Добавлять текст на фотографию</string>
     <string name="preference_stamp_fontsize">Размер шрифта</string>
-    <string name="preference_stamp_fontsize_summary">Размер шрифта для добавляемого на фотографию текста</string>
+    <string name="preference_stamp_fontsize_summary">Размер шрифта для добавляемого на фотографию текста\n%s</string>
     <string name="preference_stamp_font_color">Цвет</string>
-    <string name="preference_stamp_font_color_summary">Цвет текста добавляемого на фотографию</string>
+    <string name="preference_stamp_font_color_summary">Цвет текста добавляемого на фотографию\n%s</string>
     <string name="preference_stamp_style">Стиль</string>
     <string name="preference_stamp_style_summary">Стиль текста добавляемого на фотографию\n%s</string>
     <string name="preference_background_photo_saving">Использовать фоновый поток</string>
diff --git a/app/src/main/res/values-sl/strings.xml b/app/src/main/res/values-sl/strings.xml
index 0abcdc5e6459fc748a209d62f3c0ff7029fce8e5..daac301cde17f69ac9fde1f61b2b3468be46822b 100644
--- a/app/src/main/res/values-sl/strings.xml
+++ b/app/src/main/res/values-sl/strings.xml
@@ -189,9 +189,9 @@
     <string name="preference_textstamp">Besedilo po meri</string>
     <string name="preference_textstamp_summary">Na fotografije dodaj žig z besedilom po meri</string>
     <string name="preference_stamp_fontsize">Velikost pisave</string>
-    <string name="preference_stamp_fontsize_summary">Velikost pisave žiga z besedilom</string>
+    <string name="preference_stamp_fontsize_summary">Velikost pisave žiga z besedilom\n%s</string>
     <string name="preference_stamp_font_color">Barva pisave</string>
-    <string name="preference_stamp_font_color_summary">Barva pisave žiga z besedilom</string>
+    <string name="preference_stamp_font_color_summary">Barva pisave žiga z besedilom\n%s</string>
     <string name="preference_stamp_style">Slog besedila</string>
     <string name="preference_stamp_style_summary">Slog besedila žiga\n%s</string>
     <string name="preference_background_photo_saving">Uporabi nit v ozadju</string>
diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml
index a7b6bf88159fc3eb303d8b7efbc7963ffc9ece7d..447852e069c35e6088bbe7bbcf01ef25db1d3d4d 100644
--- a/app/src/main/res/values-tr/strings.xml
+++ b/app/src/main/res/values-tr/strings.xml
@@ -179,9 +179,9 @@
     <string name="preference_textstamp">Özel yazı ekleme</string>
     <string name="preference_textstamp_summary">Özel bir yazı ekleyerek fotoğrafları işaretle</string>
     <string name="preference_stamp_fontsize">Font(yazı) boyutu</string>
-    <string name="preference_stamp_fontsize_summary">Fotoğrafların üzerine eklendiğinde kullanılacak font(yazı)boyutu</string>
+    <string name="preference_stamp_fontsize_summary">Fotoğrafların üzerine eklendiğinde kullanılacak font(yazı)boyutu\n%s</string>
     <string name="preference_stamp_font_color">Yazı rengi</string>
-    <string name="preference_stamp_font_color_summary">Fotoğrafların üzerine eklendiğinde kullanılacak yazı rengi</string>
+    <string name="preference_stamp_font_color_summary">Fotoğrafların üzerine eklendiğinde kullanılacak yazı rengi\n%s</string>
     <string name="preference_stamp_style">Yazı stili</string>
     <string name="preference_stamp_style_summary">Fotoğrafların üzerine eklendiğinde kullanılacak yazı stili\n%s</string>
     <string name="video_quality">Vidyo çözünürlüğü</string>
diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml
index b6bb6a55220139683a5bc6e2012827681ef5341f..16b1a7bc53ee60931d4a79af8c255b2049ed0e66 100644
--- a/app/src/main/res/values-uk/strings.xml
+++ b/app/src/main/res/values-uk/strings.xml
@@ -189,9 +189,9 @@
     <string name="preference_textstamp">Підпис фото</string>
     <string name="preference_textstamp_summary">Додавання тексту на фотографію</string>
     <string name="preference_stamp_fontsize">Розмір шрифту</string>
-    <string name="preference_stamp_fontsize_summary">Розмір шрифту для тексту, що додаватиметься на фотографію</string>
+    <string name="preference_stamp_fontsize_summary">Розмір шрифту для тексту, що додаватиметься на фотографію\n%s</string>
     <string name="preference_stamp_font_color">Колір</string>
-    <string name="preference_stamp_font_color_summary">Колір для тексту, що додаватиметься на фотографію</string>
+    <string name="preference_stamp_font_color_summary">Колір для тексту, що додаватиметься на фотографію\n%s</string>
     <string name="preference_stamp_style">Стиль</string>
     <string name="preference_stamp_style_summary">Стиль для тексту, що додаватиметься на фотографію\n%s</string>
     <string name="preference_background_photo_saving">Використовувати фоновий потік</string>
diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml
index dca3ef9a9b82bfa3732bd99630f1fefc9ee19307..60a63406090e53402733d9fbfcfdb6134b7770ec 100644
--- a/app/src/main/res/values-vi/strings.xml
+++ b/app/src/main/res/values-vi/strings.xml
@@ -188,9 +188,9 @@
     <string name="preference_textstamp">Văn bản tùy chỉnh</string>
     <string name="preference_textstamp_summary">Gắn vào ảnh một văn bản tùy chỉnh</string>
     <string name="preference_stamp_fontsize">Kích thước phông</string>
-    <string name="preference_stamp_fontsize_summary">Kích thước phông chữ được sử dụng khi gắn văn bản vào ảnh</string>
+    <string name="preference_stamp_fontsize_summary">Kích thước phông chữ được sử dụng khi gắn văn bản vào ảnh\n%s</string>
     <string name="preference_stamp_font_color">Màu phông</string>
-    <string name="preference_stamp_font_color_summary">Màu phông chữ được sử dụng khi gắn văn bản vào ảnh</string>
+    <string name="preference_stamp_font_color_summary">Màu phông chữ được sử dụng khi gắn văn bản vào ảnh\n%s</string>
     <string name="preference_stamp_style">Kiểu văn bản</string>
     <string name="preference_stamp_style_summary">Kiểu văn bản được sử dụng khi gắn vào ảnh\n%s</string>
     <string name="preference_background_photo_saving">Chạy dưới nền</string>
diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml
index 30ab17b705b79c30fb76160b2982042070b2a67a..594ff8358007ee3415fd9f882e2293212c314978 100644
--- a/app/src/main/res/values-zh-rCN/strings.xml
+++ b/app/src/main/res/values-zh-rCN/strings.xml
@@ -183,9 +183,9 @@
     <string name="preference_textstamp">自定义水印</string>
     <string name="preference_textstamp_summary">使用自定义的文本水印</string>
     <string name="preference_stamp_fontsize">字体大小</string>
-    <string name="preference_stamp_fontsize_summary">水印文本的字体大小</string>
+    <string name="preference_stamp_fontsize_summary">水印文本的字体大小\n%s</string>
     <string name="preference_stamp_font_color">字体颜色</string>
-    <string name="preference_stamp_font_color_summary">水印文本的字体颜色</string>
+    <string name="preference_stamp_font_color_summary">水印文本的字体颜色\n%s</string>
     <string name="preference_stamp_style">文本样式</string>
     <string name="preference_stamp_style_summary">水印文本的样式\n%s</string>
     <string name="video_quality">视频分辨率</string>
diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml
index 5a759b1c07856f3ed0be89b0b327fd005d726c27..2c9661deaa4a0f2c325d48ef9fe20551c966737a 100644
--- a/app/src/main/res/values-zh-rTW/strings.xml
+++ b/app/src/main/res/values-zh-rTW/strings.xml
@@ -189,9 +189,9 @@
     <string name="preference_textstamp">自訂文字</string>
     <string name="preference_textstamp_summary">用自訂文字標記照片</string>
     <string name="preference_stamp_fontsize">字型大小</string>
-    <string name="preference_stamp_fontsize_summary">當在照片上標記文字時使用的字型大小</string>
+    <string name="preference_stamp_fontsize_summary">當在照片上標記文字時使用的字型大小\n%s</string>
     <string name="preference_stamp_font_color">字型顏色</string>
-    <string name="preference_stamp_font_color_summary">當在照片上標記文字時使用的字型顏色</string>
+    <string name="preference_stamp_font_color_summary">當在照片上標記文字時使用的字型顏色\n%s</string>
     <string name="preference_stamp_style">文字樣式</string>
     <string name="preference_stamp_style_summary">當在照片上標記文字時使用的樣式\n%s</string>
     <string name="preference_background_photo_saving">使用背景執行緒</string>
diff --git a/app/src/main/res/values/arrays.xml b/app/src/main/res/values/arrays.xml
index 655945dcc8fec2fe0bdbe711d8b231c1014bb52a..bc3eb37f6651ccf7e9da1b05265763d97cf6fa75 100644
--- a/app/src/main/res/values/arrays.xml
+++ b/app/src/main/res/values/arrays.xml
@@ -383,6 +383,18 @@
         <item>preference_nr_save_single</item>
         <item>preference_nr_save_all</item>
     </string-array>
+    <string-array name="preference_hdr_tonemapping_entries">
+        <item>@string/preference_hdr_tonemapping_clamp</item>
+        <item>@string/preference_hdr_tonemapping_exponential</item>
+        <item>@string/preference_hdr_tonemapping_default</item>
+        <item>@string/preference_hdr_tonemapping_aces</item>
+    </string-array>
+    <string-array name="preference_hdr_tonemapping_values">
+        <item>preference_hdr_tonemapping_clamp</item>
+        <item>preference_hdr_tonemapping_exponential</item>
+        <item>preference_hdr_tonemapping_default</item>
+        <item>preference_hdr_tonemapping_aces</item>
+    </string-array>
     <string-array name="preference_hdr_contrast_enhancement_entries">
         <item>@string/preference_hdr_contrast_enhancement_off</item>
         <item>@string/preference_hdr_contrast_enhancement_smart</item>
@@ -997,4 +1009,14 @@
         <item>none</item>
         <item>noise</item>
     </string-array>
+    <string-array name="preference_remove_device_exif_entries">
+        <item>@string/preference_remove_device_exif_off</item>
+        <item>@string/preference_remove_device_exif_on</item>
+        <item>@string/preference_remove_device_exif_keep_datetime</item>
+    </string-array>
+    <string-array name="preference_remove_device_exif_values">
+        <item>preference_remove_device_exif_off</item>
+        <item>preference_remove_device_exif_on</item>
+        <item>preference_remove_device_exif_keep_datetime</item>
+    </string-array>
 </resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index db6642d2c590c73c9b0b330c4f5f00f4f17c7bcb..609ba67528102a2c3c9a0ced87d04ff5a55a2eaf 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -190,9 +190,9 @@
     <string name="preference_textstamp">Custom text</string>
     <string name="preference_textstamp_summary">Stamp photos with a custom text</string>
     <string name="preference_stamp_fontsize">Font size</string>
-    <string name="preference_stamp_fontsize_summary">Font size to use when stamping text onto photos</string>
+    <string name="preference_stamp_fontsize_summary">Font size to use when stamping text onto photos\n%s</string>
     <string name="preference_stamp_font_color">Font color</string>
-    <string name="preference_stamp_font_color_summary">Font color to use when stamping text onto photos</string>
+    <string name="preference_stamp_font_color_summary">Font color to use when stamping text onto photos\n%s</string>
     <string name="preference_stamp_style">Text style</string>
     <string name="preference_stamp_style_summary">Style to use when stamping text onto photos\n%s</string>
     <string name="preference_background_photo_saving">Use background thread</string>
@@ -1005,6 +1005,19 @@
     <string name="photo_mode_x_beauty">X-Bty</string> <!-- keep short, as this shows in the popup menu -->
     <string name="photo_mode_x_beauty_full">Extension: Beauty / Face Retouch</string>
 
+    <string name="preference_hdr_tonemapping">HDR tonemapping</string>
+    <string name="preference_hdr_tonemapping_summary">Algorithm to use for tonemapping in HDR photo mode\n%s</string>
+    <string name="preference_hdr_tonemapping_clamp">Simple clamp</string>
+    <string name="preference_hdr_tonemapping_exponential">Exponential</string>
+    <string name="preference_hdr_tonemapping_default">Default</string>
+    <string name="preference_hdr_tonemapping_aces" translatable="false">ACES</string>
+
+    <string name="preference_remove_device_exif">Remove device EXIF data</string>
+    <string name="preference_remove_device_exif_summary">Whether to remove device EXIF metadata from JPEG photos. This will not remove exif tags applied by other settings that apply EXIF metadata (e.g. location/geotagging). Those other options are independent and will override this setting. RAW/DNG and videos are not affected.\n%s</string>
+    <string name="preference_remove_device_exif_off">Don\'t remove device EXIF data</string>
+    <string name="preference_remove_device_exif_on">Remove device EXIF data</string>
+    <string name="preference_remove_device_exif_keep_datetime">Remove except date/time</string>
+
     <!-- The following strings should not be translated (and shouldn't be included in language-specific strings.xml), in case they need updating -->
 
     <string name="preference_privacy_policy" translatable="false">Privacy policy</string>
@@ -1053,14 +1066,17 @@
     <string name="whats_new_text" translatable="false">
         <small>[This dialog is shown when Camera is updated. You can disable it under
             Settings/On screen GUI/Show What\'s New dialog.]</small>
-        \n\n<b>v1.50:</b>\n
+        \n\n<b>v1.51:</b>\n
         <ul>
-            <li>Support for Camera Extensions. Selected Android 12 devices now have photo modes such as Night, Bokeh, Beauty. Requires Settings/\"Camera API\" to be set to Camera2 API.\n</li>
-            <li>Allow accessing ultra-wide cameras via zoom e.g. on Pixel 5/6 (when using Camera2 API).\n</li>
-            <li>Removed \"use addresses\" and \"say cheese\" options. Sorry about that, but this is due to new data privacy requirements.\n</li>
-            <li>Fixed HDR on Samsung devices since Android 12.\n</li>
-            <li>Fixes for flash on Camera2 API.\n</li>
-            <li>Various improvements for Android 12.\n</li>
+            <li>New option Settings/Photo settings/\"Remove device EXIF data\" to remove device metadata from JPEG photos.\n</li>
+            <li>New option Settings/Photo settings/\"HDR tonemapping\" to choose tonemapping algorithm used for HDR photo mode.\n</li>
+            <li>Fixed slow focusing for Camera2 API on some devices.\n</li>
+            <li>Fixed incorrect thumbnail orientation on some devices.\n</li>
+            <li>Fixed focus bracketing on some devices.\n</li>
+            <li>Fixed geotagging not working on some devices.\n</li>
+            <li>Improvement to HDR algorithm for dark scenes.\n</li>
+            <li>Default to Camera2 API for some devices (will only take affect for new installs or if resetting settings).\n</li>
+            <li>Various other UI improvements and bug fixes.\n</li>
         </ul>
     </string>
 
diff --git a/app/src/main/res/xml/preferences.xml b/app/src/main/res/xml/preferences.xml
index 61ef20b50469c40c5cc6e6b32b5c2ae794ffc7b4..d3d45529e46228351da41a90b96a7e0efb070c55 100644
--- a/app/src/main/res/xml/preferences.xml
+++ b/app/src/main/res/xml/preferences.xml
@@ -783,6 +783,16 @@
                 android:defaultValue="false"
                 />
 
+            <!--  if we move this to another PreferenceGroup, we should update code to remove this Preference -->
+            <ListPreference
+                android:key="preference_hdr_tonemapping"
+                android:title="@string/preference_hdr_tonemapping"
+                android:summary="@string/preference_hdr_tonemapping_summary"
+                android:entries="@array/preference_hdr_tonemapping_entries"
+                android:entryValues="@array/preference_hdr_tonemapping_values"
+                android:defaultValue="preference_hdr_tonemapping_default"
+                />
+
             <!--  if we move this to another PreferenceGroup, we should update code to remove this Preference -->
             <ListPreference
                 android:key="preference_hdr_contrast_enhancement"
@@ -843,6 +853,15 @@
                 android:defaultValue="preference_front_camera_mirror_no"
                 />
 
+            <ListPreference
+                android:key="preference_remove_device_exif"
+                android:title="@string/preference_remove_device_exif"
+                android:summary="@string/preference_remove_device_exif_summary"
+                android:entries="@array/preference_remove_device_exif_entries"
+                android:entryValues="@array/preference_remove_device_exif_values"
+                android:defaultValue="preference_remove_device_exif_off"
+                />
+
             <!--  if we move this to another PreferenceGroup, we should update code to remove this Preference -->
             <PreferenceCategory
                 android:key="preference_category_exif_tags"
diff --git a/app/src/main/res/xml/widget_info.xml b/app/src/main/res/xml/widget_info.xml
index a5f10adf3b9e4c9c0de83768d9e25f9d023847fb..84ada1f5e5a5f08016b554b53f0edd874bfd3c4f 100644
--- a/app/src/main/res/xml/widget_info.xml
+++ b/app/src/main/res/xml/widget_info.xml
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     android:initialLayout="@layout/widget_layout"
     android:widgetCategory="keyguard"
-    >
+    tools:targetApi="jelly_bean_mr1">
 </appwidget-provider>
diff --git a/app/src/main/res/xml/widget_info_take_photo.xml b/app/src/main/res/xml/widget_info_take_photo.xml
index 0f2494336a1153868f1e5cde8cfd19cd4ed8401a..6a14ec4a4d9a979252968ca4073248a3e8eac7ba 100644
--- a/app/src/main/res/xml/widget_info_take_photo.xml
+++ b/app/src/main/res/xml/widget_info_take_photo.xml
@@ -1,8 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     android:minWidth="40dp"
     android:minHeight="40dp"
     android:initialLayout="@layout/widget_layout_take_photo"
     android:widgetCategory="home_screen|keyguard"
-    >
+    tools:targetApi="jelly_bean_mr1">
 </appwidget-provider>
diff --git a/app/src/main/rs/process_hdr.rs b/app/src/main/rs/process_hdr.rs
index 3821de08de39ecb0080e2e027b569786a26ca2c9..ae3696c43a650f784168dd0051b156b20e02345b 100644
--- a/app/src/main/rs/process_hdr.rs
+++ b/app/src/main/rs/process_hdr.rs
@@ -38,7 +38,7 @@ const float weight_scale_c = (float)((1.0-1.0/127.5)/127.5);
 const int tonemap_algorithm_clamp_c = 0;
 const int tonemap_algorithm_exponential_c = 1;
 const int tonemap_algorithm_reinhard_c = 2;
-const int tonemap_algorithm_filmic_c = 3;
+const int tonemap_algorithm_fu2_c = 3;
 const int tonemap_algorithm_aces_c = 4;
 
 int tonemap_algorithm = tonemap_algorithm_reinhard_c;
@@ -49,14 +49,14 @@ const float exposure = 1.2f;
 // for Reinhard:
 float tonemap_scale = 1.0f;
 
-// for Filmic Uncharted 2:
-const float filmic_exposure_bias = 2.0f / 255.0f;
+// for FU2:
+const float fu2_exposure_bias = 2.0f / 255.0f;
 float W = 11.2f;
 
 // for various:
 float linear_scale = 1.0f;
 
-static float Uncharted2Tonemap(float x) {
+static float FU2Tonemap(float x) {
     const float A = 0.15f;
     const float B = 0.50f;
     const float C = 0.10f;
@@ -120,13 +120,13 @@ static uchar4 tonemap(float3 hdr) {
             }*/
             break;
         }
-        case tonemap_algorithm_filmic_c:
+        case tonemap_algorithm_fu2_c:
         {
-            // Filmic Uncharted 2
-            float white_scale = 255.0f / Uncharted2Tonemap(W);
-            float curr_r = Uncharted2Tonemap(filmic_exposure_bias * hdr.r);
-            float curr_g = Uncharted2Tonemap(filmic_exposure_bias * hdr.g);
-            float curr_b = Uncharted2Tonemap(filmic_exposure_bias * hdr.b);
+            // FU2 (Filmic)
+            float white_scale = 255.0f / FU2Tonemap(W);
+            float curr_r = FU2Tonemap(fu2_exposure_bias * hdr.r);
+            float curr_g = FU2Tonemap(fu2_exposure_bias * hdr.g);
+            float curr_b = FU2Tonemap(fu2_exposure_bias * hdr.b);
             curr_r *= white_scale;
             curr_g *= white_scale;
             curr_b *= white_scale;
@@ -138,6 +138,7 @@ static uchar4 tonemap(float3 hdr) {
         }
         case tonemap_algorithm_aces_c:
         {
+            // https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/ (released under public domain cc0)
             const float a = 2.51f;
             const float b = 0.03f;
             const float c = 2.43f;
@@ -266,7 +267,25 @@ uchar4 __attribute__((kernel)) hdr(uchar4 in, uint32_t x, uint32_t y) {
         float avg = (rgb.r+rgb.g+rgb.b) / 3.0f;
         float diff = fabs( avg - 127.5f );
         float weight = 1.0f;
-        if( diff > safe_range_c ) {
+        if( avg <= 127.5f ) {
+            // We now intentionally have the weights be non-symmetric, and have the weight fall to 0
+            // faster for dark pixels than bright pixels. This fixes ghosting problems of testHDR62,
+            // where we have very dark regions where we get ghosting between the middle and bright
+            // images, and the image is too dark for the deghosting algorithm below to resolve this.
+            // We're better off using smaller weight, so that more of the pixel comes from the
+            // bright image.
+            // This also gives improved lighting/colour in: testHDR1, testHDR2, testHDR11,
+            // testHDR12, testHDR21, testHDR52.
+            const float range_low_c = 32.0f;
+            const float range_high_c = 48.0f;
+            if( avg <= range_low_c ) {
+                weight = 0.0f;
+            }
+            else if( avg <= range_high_c ) {
+                weight = (avg - range_low_c) / (range_high_c - range_low_c);
+            }
+        }
+        else if( diff > safe_range_c ) {
             // scaling chosen so that 0 and 255 map to a non-zero weight of 0.01
             weight = 1.0f - 0.99f * (diff - safe_range_c) / (127.5f - safe_range_c);
         }
diff --git a/app/src/test/java/net/sourceforge/opencamera/test/UnitTest.java b/app/src/test/java/net/sourceforge/opencamera/test/UnitTest.java
index 211ba2db63bec9f9d79130bdfd8ddbeec95b6a18..a24377fd16ca0ffe0827c612c80b50a99c6821b0 100644
--- a/app/src/test/java/net/sourceforge/opencamera/test/UnitTest.java
+++ b/app/src/test/java/net/sourceforge/opencamera/test/UnitTest.java
@@ -517,21 +517,6 @@ public class UnitTest {
         }
     }
 
-    @Test
-    public void testScaleForExposureTime() {
-        Log.d(TAG, "testScaleForExposureTime");
-        final double delta = 1.0e-6;
-        final double full_exposure_time_scale = 0.5f;
-        final long fixed_exposure_time = 1000000000L/60; // we only scale the exposure time at all if it's less than this value
-        final long scaled_exposure_time = 1000000000L/120; // we only scale the exposure time by the full_exposure_time_scale if the exposure time is less than this value
-        assertEquals( 1.0, CameraController2.getScaleForExposureTime(1000000000L/12, fixed_exposure_time, scaled_exposure_time, full_exposure_time_scale), delta );
-        assertEquals( 1.0, CameraController2.getScaleForExposureTime(1000000000L/60, fixed_exposure_time, scaled_exposure_time, full_exposure_time_scale), delta );
-        assertEquals( 1.0, CameraController2.getScaleForExposureTime(1000000000L/60, fixed_exposure_time, scaled_exposure_time, full_exposure_time_scale), delta );
-        assertEquals( 2.0/3.0, CameraController2.getScaleForExposureTime(1000000000L/90, fixed_exposure_time, scaled_exposure_time, full_exposure_time_scale), delta );
-        assertEquals( 0.5, CameraController2.getScaleForExposureTime(1000000000L/120, fixed_exposure_time, scaled_exposure_time, full_exposure_time_scale), delta );
-        assertEquals( 0.5, CameraController2.getScaleForExposureTime(1000000000L/240, fixed_exposure_time, scaled_exposure_time, full_exposure_time_scale), delta );
-    }
-
 	/*@Test
 	public void testExponentialScaling() {
 		Log.d(TAG, "testExponentialScaling");
@@ -1042,4 +1027,43 @@ public class UnitTest {
             }
         }
     }
+
+    private void checkCameraController2ZoomRatios(float min_zoom, float max_zoom) {
+        List<Integer> ratios = new ArrayList<>();
+
+        int zoom_value_1x = CameraController2.computeZoomRatios(ratios, min_zoom, max_zoom);
+        assertEquals(100, (int)ratios.get(zoom_value_1x));
+        if( min_zoom == 1.0f ) {
+            assertEquals(0, zoom_value_1x);
+        }
+        else {
+            assertTrue(zoom_value_1x > 0);
+        }
+
+        int zoom_ratio = 100;
+        while( zoom_ratio <= (int)(100*max_zoom + 0.5) ) {
+            assertTrue(ratios.contains(zoom_ratio));
+            zoom_ratio *= 2;
+        }
+    }
+
+    @Test
+    public void testCameraController2ZoomRatios() {
+        Log.d(TAG, "testCameraController2ZoomRatios");
+
+        checkCameraController2ZoomRatios(1.0f, 1.0f);
+
+        checkCameraController2ZoomRatios(1.0f, 2.0f);
+        checkCameraController2ZoomRatios(1.0f, 4.0f);
+        checkCameraController2ZoomRatios(1.0f, 8.0f);
+        checkCameraController2ZoomRatios(1.0f, 10.0f);
+        checkCameraController2ZoomRatios(1.0f, 16.0f);
+        checkCameraController2ZoomRatios(1.0f, 20.0f);
+
+        checkCameraController2ZoomRatios(0.7f, 4.0f);
+        checkCameraController2ZoomRatios(0.7f, 8.0f);
+        checkCameraController2ZoomRatios(0.7f, 10.0f);
+        checkCameraController2ZoomRatios(0.7f, 16.0f);
+        checkCameraController2ZoomRatios(0.7f, 20.0f);
+    }
 }
diff --git a/fastlane/metadata/android/en-US/images/icon.png b/fastlane/metadata/android/en-US/images/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..77816ce80de495972866e29c5eda6fbed6148bf3
Binary files /dev/null and b/fastlane/metadata/android/en-US/images/icon.png differ
diff --git a/makesrcarchive.bat b/makesrcarchive.bat
index 5b1e403fb68068f46d6616ed461b34b6947fb55b..fb5cad4b9d97acac7cd9341294da68b1c21ce4cb 100644
--- a/makesrcarchive.bat
+++ b/makesrcarchive.bat
@@ -25,6 +25,9 @@ copy %src%\app\build.gradle %dst%\app\
 mkdir %dst%\gradle
 xcopy %src%\gradle %dst%\gradle /E /Y
 
+mkdir %dst%\fastlane
+xcopy %src%\fastlane %dst%\fastlane /E /Y
+
 REM We copy the inspectionProfiles as this stores which Android inspection warnings/errors we've disabled
 mkdir %dst%\.idea
 mkdir %dst%\.idea\inspectionProfiles
diff --git a/opencamera_source.txt b/opencamera_source.txt
index 967a8a9920e786c9152383c690c560f0adbedf71..65e866c972feac823ced9dda64fd9a86af747df3 100644
--- a/opencamera_source.txt
+++ b/opencamera_source.txt
@@ -19,6 +19,11 @@ Preview: At a higher level, you might want to take the classes in Preview/ as we
 
 Application: You might prefer to use Open Camera in its entirety, as an Activity within your application (or possibly converting the MainActivity to a fragment). Consider whether Open Camera's Settings should be unified with the settings in your application. Accesses to SharedPreferences use the PreferencesKeys class to find the keys.
 
+If you are using the Open Camera source code, there are some obvious things to change:
+* Package name
+* Online help / homepage (see MainActivity.getOnlineHelpUrl())
+* Privacy policy information, including name and email contact (see "preference_privacy_policy_text" in strings.xml)
+
 Android inspection warnings/errors
 ==================================
 
@@ -44,7 +49,7 @@ The following are enabled, but with modifications:
 Licence
 =======
 
-This source is released under the GPL v3 or later. Please see the licence in gpl-3.0.txt (or https://www.gnu.org/copyleft/gpl.html ). If you would like to use the Open Camera in a closed source app, please contact me for a closed source commercial licence, with details on your company and app.
+This source is released under the GPL v3 or later. Please see the licence in gpl-3.0.txt (or https://www.gnu.org/copyleft/gpl.html ). In particular, if you are using the Open Camera source code in your own application, please see the requirements in the licence for making source code available.
 
 Please contact me if you have suggestions, bug fixes, or whatever: mark DOT harman DOT apps AT gmail DOT com .
 
@@ -52,4 +57,4 @@ Homepage: http://opencamera.org.uk/
 
 Google Play download: https://play.google.com/store/apps/details?id=net.sourceforge.opencamera
 
-Mark Harman 16 August 2021
+Mark Harman 6 December 2022