diff --git a/apps/CameraITS/.gitignore b/apps/CameraITS/.gitignore
deleted file mode 100644
index 259969b..0000000
--- a/apps/CameraITS/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-# Ignore files that are created asa result of running the ITS tests.
-
-*.json
-*.yuv
-*.jpg
-*.jpeg
-*.png
-*.pyc
-its.target.cfg
-.DS_Store
-
diff --git a/apps/CameraITS/Android.mk b/apps/CameraITS/Android.mk
deleted file mode 100644
index cc40202..0000000
--- a/apps/CameraITS/Android.mk
+++ /dev/null
@@ -1,21 +0,0 @@
-# Copyright (C) 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-#
-# Build the ItsService and any other device packages
-#
-include $(call all-subdir-makefiles)
-
-
diff --git a/apps/CameraITS/README b/apps/CameraITS/README
deleted file mode 100644
index c7b786c..0000000
--- a/apps/CameraITS/README
+++ /dev/null
@@ -1,286 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-Android Camera Imaging Test Suite (ITS)
-=======================================
-
-1. Introduction
----------------
-
-The ITS is a framework for running tests on the images produced by an Android
-camera. The general goal of each test is to configure the camera in a desired
-manner and capture one or more shots, and then examine the shots to see if
-they contain the expected image data. Many of the tests will require that the
-camera is pointed at a specific target chart or be illuminated at a specific
-intensity.
-
-2. Setup
---------
-
-There are two components to the ITS:
-1. The Android device running ItsService.apk.
-2. A host machine connected to the Android device that runs Python tests.
-
-2.1. Device setup
------------------
-
-Build and install ItsService.apk for your device. After setting up your
-shell for Android builds, from the pdk/apps/CameraITS directory run the
-following commands:
-
-    cd service
-    mma -j32
-    adb install -r <YOUR_OUTPUT_PATH>/ItsService.apk
-
-using whatever path is appropriate to your output ItsService.apk file.
-
-2.2. Host PC setup
-------------------
-
-The first pre-requisite is the Android SDK, as adb is used to communicate with
-the device.
-
-The test framework is based on Python on the host machine. It requires
-Python 2.7 and the scipy/numpy stack, including the Python Imaging Library.
-
-(For Ubuntu users)
-
-    sudo apt-get install python-numpy python-scipy python-matplotlib
-
-(For other users)
-
-All of these pieces can be installed on your host machine separately,
-however it is highly recommended to install a bundled distribution of
-Python that comes with these modules. Some different bundles are listed
-here:
-
-    http://www.scipy.org/install.html
-
-Of these, Anaconda has been verified to work with these scripts, and it is
-available on Mac, Linux, and Windows from here:
-
-    http://continuum.io/downloads
-
-Note that the Anaconda python executable's directory must be at the front of
-your PATH environment variable, assuming that you are using this Python
-distribution. The Anaconda installer may set this up for you automatically.
-
-Once your Python installation is ready, set up the test environment.
-
-2.2.1. Linux + Mac OS X
------------------------
-
-On Linux or Mac OS X, run the following command (in a terminal) from the
-pdk/apps/CameraITS directory, from a bash shell:
-
-    source build/envsetup.sh
-
-This will do some basic sanity checks on your Python installation, and set up
-the PYTHONPATH environment variable.
-
-2.2.2. Windows
---------------
-
-On Windows, the bash script won't run (unless you have cygwin (which has not
-been tested)), but all you need to do is set your PYTHONPATH environment
-variable in your shell to point to the pdk/apps/CameraITS/pymodules directory,
-giving an absolute path. Without this, you'll get "import" errors when running
-the test scripts.
-
-3. Python framework overview
-----------------------------
-
-The Python modules are under the pymodules directory, in the "its" package.
-
-* its.device: encapsulates communication with ItsService.apk service running
-  on the device
-* its.objects: contains a collection of functions for creating Python objects
-  corresponding to the Java objects which ItsService.apk uses
-* its.image: contains a collection of functions (built on numpy arrays) for
-  processing captured images
-* its.error: the exception/error class used in this framework
-* its.target: functions to set and measure the exposure level to use for
-  manual shots in tests, to ensure that the images are exposed well for the
-  target scene
-* its.dng: functions to work with DNG metadata
-
-All of these module have associated unit tests; to run the unit tests, execute
-the modules (rather than importing them).
-
-3.1. Device control
--------------------
-
-The its.device.ItsSession class encapsulates a session with a connected device
-under test (which is running ItsService.apk). The session is over TCP, which is
-forwarded over adb.
-
-As an overview, the ItsSession.do_capture() function takes a Python dictionary
-object as an argument, converts that object to JSON, and sends it to the
-device over tcp which then deserializes from the JSON object representation to
-Camera2 Java objects (CaptureRequests) which are used to specify one or more
-captures. Once the captures are complete, the resultant images are copied back
-to the host machine (over tcp again), along with JSON representations of the
-CaptureResult and other objects that describe the shot that was actually taken.
-
-The Python capture request object(s) can contain key/value entries corresponding
-to any of the Java CaptureRequest object fields.
-
-The output surface's width, height, and format can also be specified. Currently
-supported formats are "jpg", "raw", "raw10", "dng", and "yuv", where "yuv" is
-YUV420 fully planar. The default output surface is a full sensor YUV420 frame.
-
-The metadata that is returned along with the captured images is also in JSON
-format, serialized from the CaptureRequest and CaptureResult objects that were
-passed to the capture listener, as well as the CameraProperties object.
-
-3.2. Image processing and analysis
-----------------------------------
-
-The its.image module is a collection of Python functions, built on top of numpy
-arrays, for manipulating captured images. Some functions of note include:
-
-    load_yuv420_to_rgb_image
-    apply_lut_to_image
-    apply_matrix_to_image
-    write_image
-
-The scripts in the tests directory make use of these modules.
-
-Note that it's important to do heavy image processing using the efficient numpy
-ndarray operations, rather than writing complex loops in standard Python to
-process pixels. Refer to online docs and examples of numpy for information on
-this.
-
-3.3. Tests
-----------
-
-The tests directory contains a number of self-contained test scripts. All
-tests should pass if the tree is in a good state.
-
-Most of the tests save various files in the current directory. To have all the
-output files put into a separate directory, run the script from that directory,
-for example:
-
-    mkdir out
-    cd out
-    python ../tests/scene1/test_linearity.py
-
-Any test can be specified to reboot the camera prior to capturing any shots, by
-adding a "reboot" or "reboot=N" command line argument, where N is the number of
-seconds to wait after rebooting the device before sending any commands; the
-default is 30 seconds.
-
-    python tests/scene1/test_linearity.py reboot
-    python tests/scene1/test_linearity.py reboot=20
-
-It's possible that a test could leave the camera in a bad state, in particular
-if there are any bugs in the HAL or the camera framework. Rebooting the device
-can be used to get it into a known clean state again.
-
-Each test assumes some sort of target or scene. There are multiple scene<N>
-folders under the tests directory, and each contains a README file which
-describes the scene for the scripts in that folder.
-
-By default, camera device id=0 is opened when the script connects to the unit,
-however this can be specified by adding a "camera=1" or similar argument to
-the script command line. On a typical device, camera=0 is the main (rear)
-camera, and camera=1 is the front-facing camera.
-
-    python tests/scene1/test_linearity.py camera=1
-
-The tools/run_all_tests.py script should be executed from the top-level
-CameraITS directory, and it will run all of the tests in an automated fashion,
-saving the generated output files along with the stdout and stderr dumps to
-a temporary directory.
-
-    python tools/run_all_tests.py
-
-This can be run with the "noinit" argument, and in general any args provided
-to this command line will be passed to each script as it is executed.
-
-The tests/inprog directory contains a mix of unfinished, in-progress, and
-incomplete tests. These may or may not be useful in testing a HAL impl.,
-and as these tests are copmleted they will be moved into the scene<N> folders.
-
-When running individual tests from the command line (as in the examples here),
-each test run will ensure that the ItsService is running on the device and is
-ready to accept TCP connections. When using a separate test harness to control
-this infrastructure, the "noinit" command line argument can be provided to
-skip this step; in this case, the test will just try to open a socket to the
-service on the device, and will fail if it's not running and ready.
-
-    python tests/scene1/test_linearity.py noinit
-
-3.4. Target exposure
---------------------
-
-The tools/config.py script is a wrapper for the its.target module, which is
-used to set an exposure level based on the scene that the camera is imaging.
-The purpose of this is to be able to have tests which use hard-coded manual
-exposure controls, while at the same time ensuring that the captured images
-are properly exposed for the test (and aren't clamped to white or black).
-
-If no argument is provided, the script will use the camera to measure the
-scene to determine the exposure level. An argument can be provided to hard-
-code the exposure level.
-
-    python tools/config.py
-    python tools/config.py 16531519962
-
-This creates a file named its.target.cfg in the current directory, storing the
-target exposure level. Tests that use the its.target module will be reusing
-this value, if they are run from the same directory and if they contain the
-"target" command line argument:
-
-    python tests/scene1/test_linearity.py target
-
-If the "target" argument isn't present, then the script won't use any cached
-its.target.cfg values that may be present in the current directory.
-
-3.5. Docs
----------
-
-The pydoc tool can generate HTML docs for the ITS Python modules, using the
-following command (run after PYTHONPATH has been set up as described above):
-
-    pydoc -w its its.device its.image its.error its.objects its.dng its.target
-
-There is a tutorial script in the tests folder (named tutorial.py). It
-illustrates a number of the its.image and its.device primitives, and shows
-how to work with image data in general using this infrastructure. (Its code
-is commented with explanatory remarks.)
-
-    python tests/tutorial.py
-
-3.6. List of command line args
----------------------------------
-
-The above doc sections describe the following command line arguments that may
-be provided when running a test:
-
-    reboot
-    reboot=N
-    target
-    noinit
-    camera=N
-
-4. Known issues
----------------
-
-The Python test scripts don't work if multiple devices are connected to the
-host machine; currently, the its.device module uses a simplistic "adb -d"
-approach to communicating with the device, assuming that there is only one
-device connected. Fixing this is a TODO.
-
diff --git a/apps/CameraITS/build/envsetup.sh b/apps/CameraITS/build/envsetup.sh
deleted file mode 100644
index a95c445..0000000
--- a/apps/CameraITS/build/envsetup.sh
+++ /dev/null
@@ -1,45 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# This file should be sourced from bash. Sets environment variables for
-# running tests, and also checks that a number of dependences are present
-# and that the unit tests for the modules passed (indicating that the setup
-# is correct).
-
-[[ "${BASH_SOURCE[0]}" != "${0}" ]] || \
-    { echo ">> Script must be sourced with 'source $0'" >&2; exit 1; }
-
-command -v adb >/dev/null 2>&1 || \
-    echo ">> Require adb executable to be in path" >&2
-
-command -v python >/dev/null 2>&1 || \
-    echo ">> Require python executable to be in path" >&2
-
-python -V 2>&1 | grep -q "Python 2.7" || \
-    echo ">> Require python 2.7" >&2
-
-for M in numpy PIL Image matplotlib pylab
-do
-    python -c "import $M" >/dev/null 2>&1 || \
-        echo ">> Require Python $M module" >&2
-done
-
-export PYTHONPATH="$PWD/pymodules:$PYTHONPATH"
-
-for M in device objects image caps dng target error
-do
-    python "pymodules/its/$M.py" 2>&1 | grep -q "OK" || \
-        echo ">> Unit test for $M failed" >&2
-done
-
diff --git a/apps/CameraITS/pymodules/its/__init__.py b/apps/CameraITS/pymodules/its/__init__.py
deleted file mode 100644
index 59058be..0000000
--- a/apps/CameraITS/pymodules/its/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
diff --git a/apps/CameraITS/pymodules/its/caps.py b/apps/CameraITS/pymodules/its/caps.py
deleted file mode 100644
index 6caebc0..0000000
--- a/apps/CameraITS/pymodules/its/caps.py
+++ /dev/null
@@ -1,162 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-import its.objects
-
-def full(props):
-    """Returns whether a device is a FULL capability camera2 device.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return props.has_key("android.info.supportedHardwareLevel") and \
-           props["android.info.supportedHardwareLevel"] == 1
-
-def limited(props):
-    """Returns whether a device is a LIMITED capability camera2 device.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return props.has_key("android.info.supportedHardwareLevel") and \
-           props["android.info.supportedHardwareLevel"] == 0
-
-def legacy(props):
-    """Returns whether a device is a LEGACY capability camera2 device.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return props.has_key("android.info.supportedHardwareLevel") and \
-           props["android.info.supportedHardwareLevel"] == 2
-
-def manual_sensor(props):
-    """Returns whether a device supports MANUAL_SENSOR capabilities.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return    props.has_key("android.request.availableCapabilities") and \
-              1 in props["android.request.availableCapabilities"] \
-           or full(props)
-
-def manual_post_proc(props):
-    """Returns whether a device supports MANUAL_POST_PROCESSING capabilities.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return    props.has_key("android.request.availableCapabilities") and \
-              2 in props["android.request.availableCapabilities"] \
-           or full(props)
-
-def raw(props):
-    """Returns whether a device supports RAW capabilities.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return props.has_key("android.request.availableCapabilities") and \
-           3 in props["android.request.availableCapabilities"]
-
-def raw16(props):
-    """Returns whether a device supports RAW16 output.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return len(its.objects.get_available_output_sizes("raw", props)) > 0
-
-def raw10(props):
-    """Returns whether a device supports RAW10 output.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return len(its.objects.get_available_output_sizes("raw10", props)) > 0
-
-def sensor_fusion(props):
-    """Returns whether the camera and motion sensor timestamps for the device
-    are in the same time domain and can be compared direcctly.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return props.has_key("android.sensor.info.timestampSource") and \
-           props["android.sensor.info.timestampSource"] == 1
-
-def read_3a(props):
-    """Return whether a device supports reading out the following 3A settings:
-        sensitivity
-        exposure time
-        awb gain
-        awb cct
-        focus distance
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    # TODO: check available result keys explicitly
-    return manual_sensor(props) and manual_post_proc(props)
-
-def compute_target_exposure(props):
-    """Return whether a device supports target exposure computation in its.target module.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        Boolean.
-    """
-    return manual_sensor(props) and manual_post_proc(props)
-
-class __UnitTest(unittest.TestCase):
-    """Run a suite of unit tests on this module.
-    """
-    # TODO: Add more unit tests.
-
-if __name__ == '__main__':
-    unittest.main()
-
diff --git a/apps/CameraITS/pymodules/its/device.py b/apps/CameraITS/pymodules/its/device.py
deleted file mode 100644
index 96c8618..0000000
--- a/apps/CameraITS/pymodules/its/device.py
+++ /dev/null
@@ -1,522 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.error
-import os
-import os.path
-import sys
-import re
-import json
-import time
-import unittest
-import socket
-import subprocess
-import hashlib
-import numpy
-
-class ItsSession(object):
-    """Controls a device over adb to run ITS scripts.
-
-    The script importing this module (on the host machine) prepares JSON
-    objects encoding CaptureRequests, specifying sets of parameters to use
-    when capturing an image using the Camera2 APIs. This class encapsualtes
-    sending the requests to the device, monitoring the device's progress, and
-    copying the resultant captures back to the host machine when done. TCP
-    forwarded over adb is the transport mechanism used.
-
-    The device must have ItsService.apk installed.
-
-    Attributes:
-        sock: The open socket.
-    """
-
-    # Open a connection to localhost:6000, forwarded to port 6000 on the device.
-    # TODO: Support multiple devices running over different TCP ports.
-    IPADDR = '127.0.0.1'
-    PORT = 6000
-    BUFFER_SIZE = 4096
-
-    # Seconds timeout on each socket operation.
-    SOCK_TIMEOUT = 10.0
-
-    PACKAGE = 'com.android.camera2.its'
-    INTENT_START = 'com.android.camera2.its.START'
-
-    # Definitions for some of the common output format options for do_capture().
-    # Each gets images of full resolution for each requested format.
-    CAP_RAW = {"format":"raw"}
-    CAP_DNG = {"format":"dng"}
-    CAP_YUV = {"format":"yuv"}
-    CAP_JPEG = {"format":"jpeg"}
-    CAP_RAW_YUV = [{"format":"raw"}, {"format":"yuv"}]
-    CAP_DNG_YUV = [{"format":"dng"}, {"format":"yuv"}]
-    CAP_RAW_JPEG = [{"format":"raw"}, {"format":"jpeg"}]
-    CAP_DNG_JPEG = [{"format":"dng"}, {"format":"jpeg"}]
-    CAP_YUV_JPEG = [{"format":"yuv"}, {"format":"jpeg"}]
-    CAP_RAW_YUV_JPEG = [{"format":"raw"}, {"format":"yuv"}, {"format":"jpeg"}]
-    CAP_DNG_YUV_JPEG = [{"format":"dng"}, {"format":"yuv"}, {"format":"jpeg"}]
-
-    # Method to handle the case where the service isn't already running.
-    # This occurs when a test is invoked directly from the command line, rather
-    # than as a part of a separate test harness which is setting up the device
-    # and the TCP forwarding.
-    def __pre_init(self):
-        # TODO: Handle multiple connected devices.
-        adb =  "adb -d"
-
-        # This also includes the optional reboot handling: if the user
-        # provides a "reboot" or "reboot=N" arg, then reboot the device,
-        # waiting for N seconds (default 30) before returning.
-        for s in sys.argv[1:]:
-            if s[:6] == "reboot":
-                duration = 30
-                if len(s) > 7 and s[6] == "=":
-                    duration = int(s[7:])
-                print "Rebooting device"
-                _run("%s reboot" % (adb));
-                _run("%s wait-for-device" % (adb))
-                time.sleep(duration)
-                print "Reboot complete"
-
-        # TODO: Figure out why "--user 0" is needed, and fix the problem.
-        _run('%s shell am force-stop --user 0 %s' % (adb, self.PACKAGE))
-        _run(('%s shell am startservice --user 0 -t text/plain '
-              '-a %s') % (adb, self.INTENT_START))
-
-        # Wait until the socket is ready to accept a connection.
-        proc = subprocess.Popen(
-                adb.split() + ["logcat"],
-                stdout=subprocess.PIPE)
-        logcat = proc.stdout
-        while True:
-            line = logcat.readline().strip()
-            if line.find('ItsService ready') >= 0:
-                break
-        proc.kill()
-
-        # Setup the TCP-over-ADB forwarding.
-        _run('%s forward tcp:%d tcp:%d' % (adb,self.PORT,self.PORT))
-
-    def __init__(self):
-        if "noinit" not in sys.argv:
-            self.__pre_init()
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.sock.connect((self.IPADDR, self.PORT))
-        self.sock.settimeout(self.SOCK_TIMEOUT)
-        self.__close_camera()
-        self.__open_camera()
-
-    def __del__(self):
-        if hasattr(self, 'sock') and self.sock:
-            self.__close_camera()
-            self.sock.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, type, value, traceback):
-        return False
-
-    def __read_response_from_socket(self):
-        # Read a line (newline-terminated) string serialization of JSON object.
-        chars = []
-        while len(chars) == 0 or chars[-1] != '\n':
-            ch = self.sock.recv(1)
-            if len(ch) == 0:
-                # Socket was probably closed; otherwise don't get empty strings
-                raise its.error.Error('Problem with socket on device side')
-            chars.append(ch)
-        line = ''.join(chars)
-        jobj = json.loads(line)
-        # Optionally read a binary buffer of a fixed size.
-        buf = None
-        if jobj.has_key("bufValueSize"):
-            n = jobj["bufValueSize"]
-            buf = bytearray(n)
-            view = memoryview(buf)
-            while n > 0:
-                nbytes = self.sock.recv_into(view, n)
-                view = view[nbytes:]
-                n -= nbytes
-            buf = numpy.frombuffer(buf, dtype=numpy.uint8)
-        return jobj, buf
-
-    def __open_camera(self):
-        # Get the camera ID to open as an argument.
-        camera_id = 0
-        for s in sys.argv[1:]:
-            if s[:7] == "camera=" and len(s) > 7:
-                camera_id = int(s[7:])
-        cmd = {"cmdName":"open", "cameraId":camera_id}
-        self.sock.send(json.dumps(cmd) + "\n")
-        data,_ = self.__read_response_from_socket()
-        if data['tag'] != 'cameraOpened':
-            raise its.error.Error('Invalid command response')
-
-    def __close_camera(self):
-        cmd = {"cmdName":"close"}
-        self.sock.send(json.dumps(cmd) + "\n")
-        data,_ = self.__read_response_from_socket()
-        if data['tag'] != 'cameraClosed':
-            raise its.error.Error('Invalid command response')
-
-    def do_vibrate(self, pattern):
-        """Cause the device to vibrate to a specific pattern.
-
-        Args:
-            pattern: Durations (ms) for which to turn on or off the vibrator.
-                The first value indicates the number of milliseconds to wait
-                before turning the vibrator on. The next value indicates the
-                number of milliseconds for which to keep the vibrator on
-                before turning it off. Subsequent values alternate between
-                durations in milliseconds to turn the vibrator off or to turn
-                the vibrator on.
-
-        Returns:
-            Nothing.
-        """
-        cmd = {}
-        cmd["cmdName"] = "doVibrate"
-        cmd["pattern"] = pattern
-        self.sock.send(json.dumps(cmd) + "\n")
-        data,_ = self.__read_response_from_socket()
-        if data['tag'] != 'vibrationStarted':
-            raise its.error.Error('Invalid command response')
-
-    def start_sensor_events(self):
-        """Start collecting sensor events on the device.
-
-        See get_sensor_events for more info.
-
-        Returns:
-            Nothing.
-        """
-        cmd = {}
-        cmd["cmdName"] = "startSensorEvents"
-        self.sock.send(json.dumps(cmd) + "\n")
-        data,_ = self.__read_response_from_socket()
-        if data['tag'] != 'sensorEventsStarted':
-            raise its.error.Error('Invalid command response')
-
-    def get_sensor_events(self):
-        """Get a trace of all sensor events on the device.
-
-        The trace starts when the start_sensor_events function is called. If
-        the test runs for a long time after this call, then the device's
-        internal memory can fill up. Calling get_sensor_events gets all events
-        from the device, and then stops the device from collecting events and
-        clears the internal buffer; to start again, the start_sensor_events
-        call must be used again.
-
-        Events from the accelerometer, compass, and gyro are returned; each
-        has a timestamp and x,y,z values.
-
-        Note that sensor events are only produced if the device isn't in its
-        standby mode (i.e.) if the screen is on.
-
-        Returns:
-            A Python dictionary with three keys ("accel", "mag", "gyro") each
-            of which maps to a list of objects containing "time","x","y","z"
-            keys.
-        """
-        cmd = {}
-        cmd["cmdName"] = "getSensorEvents"
-        self.sock.send(json.dumps(cmd) + "\n")
-        data,_ = self.__read_response_from_socket()
-        if data['tag'] != 'sensorEvents':
-            raise its.error.Error('Invalid command response')
-        return data['objValue']
-
-    def get_camera_properties(self):
-        """Get the camera properties object for the device.
-
-        Returns:
-            The Python dictionary object for the CameraProperties object.
-        """
-        cmd = {}
-        cmd["cmdName"] = "getCameraProperties"
-        self.sock.send(json.dumps(cmd) + "\n")
-        data,_ = self.__read_response_from_socket()
-        if data['tag'] != 'cameraProperties':
-            raise its.error.Error('Invalid command response')
-        return data['objValue']['cameraProperties']
-
-    def do_3a(self, regions_ae=[[0,0,1,1,1]],
-                    regions_awb=[[0,0,1,1,1]],
-                    regions_af=[[0,0,1,1,1]],
-                    do_ae=True, do_awb=True, do_af=True,
-                    lock_ae=False, lock_awb=False,
-                    get_results=False):
-        """Perform a 3A operation on the device.
-
-        Triggers some or all of AE, AWB, and AF, and returns once they have
-        converged. Uses the vendor 3A that is implemented inside the HAL.
-
-        Throws an assertion if 3A fails to converge.
-
-        Args:
-            regions_ae: List of weighted AE regions.
-            regions_awb: List of weighted AWB regions.
-            regions_af: List of weighted AF regions.
-            do_ae: Trigger AE and wait for it to converge.
-            do_awb: Wait for AWB to converge.
-            do_af: Trigger AF and wait for it to converge.
-            lock_ae: Request AE lock after convergence, and wait for it.
-            lock_awb: Request AWB lock after convergence, and wait for it.
-            get_results: Return the 3A results from this function.
-
-        Region format in args:
-            Arguments are lists of weighted regions; each weighted region is a
-            list of 5 values, [x,y,w,h, wgt], and each argument is a list of
-            these 5-value lists. The coordinates are given as normalized
-            rectangles (x,y,w,h) specifying the region. For example:
-                [[0.0, 0.0, 1.0, 0.5, 5], [0.0, 0.5, 1.0, 0.5, 10]].
-            Weights are non-negative integers.
-
-        Returns:
-            Five values are returned if get_results is true::
-            * AE sensitivity; None if do_ae is False
-            * AE exposure time; None if do_ae is False
-            * AWB gains (list); None if do_awb is False
-            * AWB transform (list); None if do_awb is false
-            * AF focus position; None if do_af is false
-            Otherwise, it returns five None values.
-        """
-        print "Running vendor 3A on device"
-        cmd = {}
-        cmd["cmdName"] = "do3A"
-        cmd["regions"] = {"ae": sum(regions_ae, []),
-                          "awb": sum(regions_awb, []),
-                          "af": sum(regions_af, [])}
-        cmd["triggers"] = {"ae": do_ae, "af": do_af}
-        if lock_ae:
-            cmd["aeLock"] = True
-        if lock_awb:
-            cmd["awbLock"] = True
-        self.sock.send(json.dumps(cmd) + "\n")
-
-        # Wait for each specified 3A to converge.
-        ae_sens = None
-        ae_exp = None
-        awb_gains = None
-        awb_transform = None
-        af_dist = None
-        converged = False
-        while True:
-            data,_ = self.__read_response_from_socket()
-            vals = data['strValue'].split()
-            if data['tag'] == 'aeResult':
-                ae_sens, ae_exp = [int(i) for i in vals]
-            elif data['tag'] == 'afResult':
-                af_dist = float(vals[0])
-            elif data['tag'] == 'awbResult':
-                awb_gains = [float(f) for f in vals[:4]]
-                awb_transform = [float(f) for f in vals[4:]]
-            elif data['tag'] == '3aConverged':
-                converged = True
-            elif data['tag'] == '3aDone':
-                break
-            else:
-                raise its.error.Error('Invalid command response')
-        if converged and not get_results:
-            return None,None,None,None,None
-        if (do_ae and ae_sens == None or do_awb and awb_gains == None
-                or do_af and af_dist == None or not converged):
-            raise its.error.Error('3A failed to converge')
-        return ae_sens, ae_exp, awb_gains, awb_transform, af_dist
-
-    def do_capture(self, cap_request, out_surfaces=None):
-        """Issue capture request(s), and read back the image(s) and metadata.
-
-        The main top-level function for capturing one or more images using the
-        device. Captures a single image if cap_request is a single object, and
-        captures a burst if it is a list of objects.
-
-        The out_surfaces field can specify the width(s), height(s), and
-        format(s) of the captured image. The formats may be "yuv", "jpeg",
-        "dng", "raw", or "raw10". The default is a YUV420 frame ("yuv")
-        corresponding to a full sensor frame.
-
-        Note that one or more surfaces can be specified, allowing a capture to
-        request images back in multiple formats (e.g.) raw+yuv, raw+jpeg,
-        yuv+jpeg, raw+yuv+jpeg. If the size is omitted for a surface, the
-        default is the largest resolution available for the format of that
-        surface. At most one output surface can be specified for a given format,
-        and raw+dng, raw10+dng, and raw+raw10 are not supported as combinations.
-
-        Example of a single capture request:
-
-            {
-                "android.sensor.exposureTime": 100*1000*1000,
-                "android.sensor.sensitivity": 100
-            }
-
-        Example of a list of capture requests:
-
-            [
-                {
-                    "android.sensor.exposureTime": 100*1000*1000,
-                    "android.sensor.sensitivity": 100
-                },
-                {
-                    "android.sensor.exposureTime": 100*1000*1000,
-                    "android.sensor.sensitivity": 200
-                }
-            ]
-
-        Examples of output surface specifications:
-
-            {
-                "width": 640,
-                "height": 480,
-                "format": "yuv"
-            }
-
-            [
-                {
-                    "format": "jpeg"
-                },
-                {
-                    "format": "raw"
-                }
-            ]
-
-        The following variables defined in this class are shortcuts for
-        specifying one or more formats where each output is the full size for
-        that format; they can be used as values for the out_surfaces arguments:
-
-            CAP_RAW
-            CAP_DNG
-            CAP_YUV
-            CAP_JPEG
-            CAP_RAW_YUV
-            CAP_DNG_YUV
-            CAP_RAW_JPEG
-            CAP_DNG_JPEG
-            CAP_YUV_JPEG
-            CAP_RAW_YUV_JPEG
-            CAP_DNG_YUV_JPEG
-
-        If multiple formats are specified, then this function returns multuple
-        capture objects, one for each requested format. If multiple formats and
-        multiple captures (i.e. a burst) are specified, then this function
-        returns multiple lists of capture objects. In both cases, the order of
-        the returned objects matches the order of the requested formats in the
-        out_surfaces parameter. For example:
-
-            yuv_cap            = do_capture( req1                           )
-            yuv_cap            = do_capture( req1,        yuv_fmt           )
-            yuv_cap,  raw_cap  = do_capture( req1,        [yuv_fmt,raw_fmt] )
-            yuv_caps           = do_capture( [req1,req2], yuv_fmt           )
-            yuv_caps, raw_caps = do_capture( [req1,req2], [yuv_fmt,raw_fmt] )
-
-        Args:
-            cap_request: The Python dict/list specifying the capture(s), which
-                will be converted to JSON and sent to the device.
-            out_surfaces: (Optional) specifications of the output image formats
-                and sizes to use for each capture.
-
-        Returns:
-            An object, list of objects, or list of lists of objects, where each
-            object contains the following fields:
-            * data: the image data as a numpy array of bytes.
-            * width: the width of the captured image.
-            * height: the height of the captured image.
-            * format: image the format, in ["yuv","jpeg","raw","raw10","dng"].
-            * metadata: the capture result object (Python dictionaty).
-        """
-        cmd = {}
-        cmd["cmdName"] = "doCapture"
-        if not isinstance(cap_request, list):
-            cmd["captureRequests"] = [cap_request]
-        else:
-            cmd["captureRequests"] = cap_request
-        if out_surfaces is not None:
-            if not isinstance(out_surfaces, list):
-                cmd["outputSurfaces"] = [out_surfaces]
-            else:
-                cmd["outputSurfaces"] = out_surfaces
-            formats = [c["format"] if c.has_key("format") else "yuv"
-                       for c in cmd["outputSurfaces"]]
-            formats = [s if s != "jpg" else "jpeg" for s in formats]
-        else:
-            formats = ['yuv']
-        ncap = len(cmd["captureRequests"])
-        nsurf = 1 if out_surfaces is None else len(cmd["outputSurfaces"])
-        if len(formats) > len(set(formats)):
-            raise its.error.Error('Duplicate format requested')
-        if "dng" in formats and "raw" in formats or \
-                "dng" in formats and "raw10" in formats or \
-                "raw" in formats and "raw10" in formats:
-            raise its.error.Error('Different raw formats not supported')
-        print "Capturing %d frame%s with %d format%s [%s]" % (
-                  ncap, "s" if ncap>1 else "", nsurf, "s" if nsurf>1 else "",
-                  ",".join(formats))
-        self.sock.send(json.dumps(cmd) + "\n")
-
-        # Wait for ncap*nsurf images and ncap metadata responses.
-        # Assume that captures come out in the same order as requested in
-        # the burst, however indifidual images of different formats ca come
-        # out in any order for that capture.
-        nbufs = 0
-        bufs = {"yuv":[], "raw":[], "raw10":[], "dng":[], "jpeg":[]}
-        mds = []
-        widths = None
-        heights = None
-        while nbufs < ncap*nsurf or len(mds) < ncap:
-            jsonObj,buf = self.__read_response_from_socket()
-            if jsonObj['tag'] in ['jpegImage', 'yuvImage', 'rawImage', \
-                    'raw10Image', 'dngImage'] and buf is not None:
-                fmt = jsonObj['tag'][:-5]
-                bufs[fmt].append(buf)
-                nbufs += 1
-            elif jsonObj['tag'] == 'captureResults':
-                mds.append(jsonObj['objValue']['captureResult'])
-                outputs = jsonObj['objValue']['outputs']
-                widths = [out['width'] for out in outputs]
-                heights = [out['height'] for out in outputs]
-            else:
-                # Just ignore other tags
-                None
-        rets = []
-        for j,fmt in enumerate(formats):
-            objs = []
-            for i in range(ncap):
-                obj = {}
-                obj["data"] = bufs[fmt][i]
-                obj["width"] = widths[j]
-                obj["height"] = heights[j]
-                obj["format"] = fmt
-                obj["metadata"] = mds[i]
-                objs.append(obj)
-            rets.append(objs if ncap>1 else objs[0])
-        return rets if len(rets)>1 else rets[0]
-
-def _run(cmd):
-    """Replacement for os.system, with hiding of stdout+stderr messages.
-    """
-    with open(os.devnull, 'wb') as devnull:
-        subprocess.check_call(
-                cmd.split(), stdout=devnull, stderr=subprocess.STDOUT)
-
-class __UnitTest(unittest.TestCase):
-    """Run a suite of unit tests on this module.
-    """
-
-    # TODO: Add some unit tests.
-    None
-
-if __name__ == '__main__':
-    unittest.main()
-
diff --git a/apps/CameraITS/pymodules/its/dng.py b/apps/CameraITS/pymodules/its/dng.py
deleted file mode 100644
index f331d02..0000000
--- a/apps/CameraITS/pymodules/its/dng.py
+++ /dev/null
@@ -1,174 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import numpy
-import numpy.linalg
-import unittest
-
-# Illuminant IDs
-A = 0
-D65 = 1
-
-def compute_cm_fm(illuminant, gains, ccm, cal):
-    """Compute the ColorMatrix (CM) and ForwardMatrix (FM).
-
-    Given a captured shot of a grey chart illuminated by either a D65 or a
-    standard A illuminant, the HAL will produce the WB gains and transform,
-    in the android.colorCorrection.gains and android.colorCorrection.transform
-    tags respectively. These values have both golden module and per-unit
-    calibration baked in.
-
-    This function is used to take the per-unit gains, ccm, and calibration
-    matrix, and compute the values that the DNG ColorMatrix and ForwardMatrix
-    for the specified illuminant should be. These CM and FM values should be
-    the same for all DNG files captured by all units of the same model (e.g.
-    all Nexus 5 units). The calibration matrix should be the same for all DNGs
-    saved by the same unit, but will differ unit-to-unit.
-
-    Args:
-        illuminant: 0 (A) or 1 (D65).
-        gains: White balance gains, as a list of 4 floats.
-        ccm: White balance transform matrix, as a list of 9 floats.
-        cal: Per-unit calibration matrix, as a list of 9 floats.
-
-    Returns:
-        CM: The 3x3 ColorMatrix for the specified illuminant, as a numpy array
-        FM: The 3x3 ForwardMatrix for the specified illuminant, as a numpy array
-    """
-
-    ###########################################################################
-    # Standard matrices.
-
-    # W is the matrix that maps sRGB to XYZ.
-    # See: http://www.brucelindbloom.com/
-    W = numpy.array([
-        [ 0.4124564,  0.3575761,  0.1804375],
-        [ 0.2126729,  0.7151522,  0.0721750],
-        [ 0.0193339,  0.1191920,  0.9503041]])
-
-    # HH is the chromatic adaptation matrix from D65 (since sRGB's ref white is
-    # D65) to D50 (since CIE XYZ's ref white is D50).
-    HH = numpy.array([
-        [ 1.0478112,  0.0228866, -0.0501270],
-        [ 0.0295424,  0.9904844, -0.0170491],
-        [-0.0092345,  0.0150436,  0.7521316]])
-
-    # H is a chromatic adaptation matrix from D65 (because sRGB's reference
-    # white is D65) to the calibration illuminant (which is a standard matrix
-    # depending on the illuminant). For a D65 illuminant, the matrix is the
-    # identity. For the A illuminant, the matrix uses the linear Bradford
-    # adaptation method to map from D65 to A.
-    # See: http://www.brucelindbloom.com/
-    H_D65 = numpy.array([
-        [ 1.0,        0.0,        0.0],
-        [ 0.0,        1.0,        0.0],
-        [ 0.0,        0.0,        1.0]])
-    H_A = numpy.array([
-        [ 1.2164557,  0.1109905, -0.1549325],
-        [ 0.1533326,  0.9152313, -0.0559953],
-        [-0.0239469,  0.0358984,  0.3147529]])
-    H = [H_A, H_D65][illuminant]
-
-    ###########################################################################
-    # Per-model matrices (that should be the same for all units of a particular
-    # phone/camera. These are statics in the HAL camera properties.
-
-    # G is formed by taking the r,g,b gains and putting them into a
-    # diagonal matrix.
-    G = numpy.array([[gains[0],0,0], [0,gains[1],0], [0,0,gains[3]]])
-
-    # S is just the CCM.
-    S = numpy.array([ccm[0:3], ccm[3:6], ccm[6:9]])
-
-    ###########################################################################
-    # Per-unit matrices.
-
-    # The per-unit calibration matrix for the given illuminant.
-    CC = numpy.array([cal[0:3],cal[3:6],cal[6:9]])
-
-    ###########################################################################
-    # Derived matrices. These should match up with DNG-related matrices
-    # provided by the HAL.
-
-    # The color matrix and forward matrix are computed as follows:
-    #   CM = inv(H * W * S * G * CC)
-    #   FM = HH * W * S
-    CM = numpy.linalg.inv(
-            numpy.dot(numpy.dot(numpy.dot(numpy.dot(H, W), S), G), CC))
-    FM = numpy.dot(numpy.dot(HH, W), S)
-
-    # The color matrix is normalized so that it maps the D50 (PCS) white
-    # point to a maximum component value of 1.
-    CM = CM / max(numpy.dot(CM, (0.9642957, 1.0, 0.8251046)))
-
-    return CM, FM
-
-def compute_asn(illuminant, cal, CM):
-    """Compute the AsShotNeutral DNG value.
-
-    This value is the only dynamic DNG value; the ForwardMatrix, ColorMatrix,
-    and CalibrationMatrix values should be the same for every DNG saved by
-    a given unit. The AsShotNeutral depends on the scene white balance
-    estimate.
-
-    This function computes what the DNG AsShotNeutral values should be, for
-    a given ColorMatrix (which is computed from the WB gains and CCM for a
-    shot taken of a grey chart under either A or D65 illuminants) and the
-    per-unit calibration matrix.
-
-    Args:
-        illuminant: 0 (A) or 1 (D65).
-        cal: Per-unit calibration matrix, as a list of 9 floats.
-        CM: The computed 3x3 ColorMatrix for the illuminant, as a numpy array.
-
-    Returns:
-        ASN: The AsShotNeutral value, as a length-3 numpy array.
-    """
-
-    ###########################################################################
-    # Standard matrices.
-
-    # XYZCAL is the  XYZ coordinate of calibration illuminant (so A or D65).
-    # See: Wyszecki & Stiles, "Color Science", second edition.
-    XYZCAL_A = numpy.array([1.098675, 1.0, 0.355916])
-    XYZCAL_D65 = numpy.array([0.950456, 1.0, 1.089058])
-    XYZCAL = [XYZCAL_A, XYZCAL_D65][illuminant]
-
-    ###########################################################################
-    # Per-unit matrices.
-
-    # The per-unit calibration matrix for the given illuminant.
-    CC = numpy.array([cal[0:3],cal[3:6],cal[6:9]])
-
-    ###########################################################################
-    # Derived matrices.
-
-    # The AsShotNeutral value is then the product of this final color matrix
-    # with the XYZ coordinate of calibration illuminant.
-    #   ASN = CC * CM * XYZCAL
-    ASN = numpy.dot(numpy.dot(CC, CM), XYZCAL)
-
-    # Normalize so the max vector element is 1.0.
-    ASN = ASN / max(ASN)
-
-    return ASN
-
-class __UnitTest(unittest.TestCase):
-    """Run a suite of unit tests on this module.
-    """
-    # TODO: Add more unit tests.
-
-if __name__ == '__main__':
-    unittest.main()
-
diff --git a/apps/CameraITS/pymodules/its/error.py b/apps/CameraITS/pymodules/its/error.py
deleted file mode 100644
index 884389b..0000000
--- a/apps/CameraITS/pymodules/its/error.py
+++ /dev/null
@@ -1,26 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-class Error(Exception):
-    pass
-
-class __UnitTest(unittest.TestCase):
-    """Run a suite of unit tests on this module.
-    """
-
-if __name__ == '__main__':
-    unittest.main()
-
diff --git a/apps/CameraITS/pymodules/its/image.py b/apps/CameraITS/pymodules/its/image.py
deleted file mode 100644
index a05c4e6..0000000
--- a/apps/CameraITS/pymodules/its/image.py
+++ /dev/null
@@ -1,745 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import matplotlib
-matplotlib.use('Agg')
-
-import its.error
-import pylab
-import sys
-import Image
-import numpy
-import math
-import unittest
-import cStringIO
-import scipy.stats
-import copy
-
-DEFAULT_YUV_TO_RGB_CCM = numpy.matrix([
-                                [1.000,  0.000,  1.402],
-                                [1.000, -0.344, -0.714],
-                                [1.000,  1.772,  0.000]])
-
-DEFAULT_YUV_OFFSETS = numpy.array([0, 128, 128])
-
-DEFAULT_GAMMA_LUT = numpy.array(
-        [math.floor(65535 * math.pow(i/65535.0, 1/2.2) + 0.5)
-         for i in xrange(65536)])
-
-DEFAULT_INVGAMMA_LUT = numpy.array(
-        [math.floor(65535 * math.pow(i/65535.0, 2.2) + 0.5)
-         for i in xrange(65536)])
-
-MAX_LUT_SIZE = 65536
-
-def convert_capture_to_rgb_image(cap,
-                                 ccm_yuv_to_rgb=DEFAULT_YUV_TO_RGB_CCM,
-                                 yuv_off=DEFAULT_YUV_OFFSETS,
-                                 props=None):
-    """Convert a captured image object to a RGB image.
-
-    Args:
-        cap: A capture object as returned by its.device.do_capture.
-        ccm_yuv_to_rgb: (Optional) the 3x3 CCM to convert from YUV to RGB.
-        yuv_off: (Optional) offsets to subtract from each of Y,U,V values.
-        props: (Optional) camera properties object (of static values);
-            required for processing raw images.
-
-    Returns:
-        RGB float-3 image array, with pixel values in [0.0, 1.0].
-    """
-    w = cap["width"]
-    h = cap["height"]
-    if cap["format"] == "raw10":
-        assert(props is not None)
-        cap = unpack_raw10_capture(cap, props)
-    if cap["format"] == "yuv":
-        y = cap["data"][0:w*h]
-        u = cap["data"][w*h:w*h*5/4]
-        v = cap["data"][w*h*5/4:w*h*6/4]
-        return convert_yuv420_to_rgb_image(y, u, v, w, h)
-    elif cap["format"] == "jpeg":
-        return decompress_jpeg_to_rgb_image(cap["data"])
-    elif cap["format"] == "raw":
-        assert(props is not None)
-        r,gr,gb,b = convert_capture_to_planes(cap, props)
-        return convert_raw_to_rgb_image(r,gr,gb,b, props, cap["metadata"])
-    else:
-        raise its.error.Error('Invalid format %s' % (cap["format"]))
-
-def unpack_raw10_capture(cap, props):
-    """Unpack a raw-10 capture to a raw-16 capture.
-
-    Args:
-        cap: A raw-10 capture object.
-        props: Camera propertis object.
-
-    Returns:
-        New capture object with raw-16 data.
-    """
-    # Data is packed as 4x10b pixels in 5 bytes, with the first 4 bytes holding
-    # the MSPs of the pixels, and the 5th byte holding 4x2b LSBs.
-    w,h = cap["width"], cap["height"]
-    if w % 4 != 0:
-        raise its.error.Error('Invalid raw-10 buffer width')
-    cap = copy.deepcopy(cap)
-    cap["data"] = unpack_raw10_image(cap["data"].reshape(h,w*5/4))
-    cap["format"] = "raw"
-    return cap
-
-def unpack_raw10_image(img):
-    """Unpack a raw-10 image to a raw-16 image.
-
-    Output image will have the 10 LSBs filled in each 16b word, and the 6 MSBs
-    will be set to zero.
-
-    Args:
-        img: A raw-10 image, as a uint8 numpy array.
-
-    Returns:
-        Image as a uint16 numpy array, with all row padding stripped.
-    """
-    if img.shape[1] % 5 != 0:
-        raise its.error.Error('Invalid raw-10 buffer width')
-    w = img.shape[1]*4/5
-    h = img.shape[0]
-    # Cut out the 4x8b MSBs and shift to bits [10:2] in 16b words.
-    msbs = numpy.delete(img, numpy.s_[4::5], 1)
-    msbs = msbs.astype(numpy.uint16)
-    msbs = numpy.left_shift(msbs, 2)
-    msbs = msbs.reshape(h,w)
-    # Cut out the 4x2b LSBs and put each in bits [2:0] of their own 8b words.
-    lsbs = img[::, 4::5].reshape(h,w/4)
-    lsbs = numpy.right_shift(
-            numpy.packbits(numpy.unpackbits(lsbs).reshape(h,w/4,4,2),3), 6)
-    lsbs = lsbs.reshape(h,w)
-    # Fuse the MSBs and LSBs back together
-    img16 = numpy.bitwise_or(msbs, lsbs).reshape(h,w)
-    return img16
-
-def convert_capture_to_planes(cap, props=None):
-    """Convert a captured image object to separate image planes.
-
-    Decompose an image into multiple images, corresponding to different planes.
-
-    For YUV420 captures ("yuv"):
-        Returns Y,U,V planes, where the Y plane is full-res and the U,V planes
-        are each 1/2 x 1/2 of the full res.
-
-    For Bayer captures ("raw" or "raw10"):
-        Returns planes in the order R,Gr,Gb,B, regardless of the Bayer pattern
-        layout. Each plane is 1/2 x 1/2 of the full res.
-
-    For JPEG captures ("jpeg"):
-        Returns R,G,B full-res planes.
-
-    Args:
-        cap: A capture object as returned by its.device.do_capture.
-        props: (Optional) camera properties object (of static values);
-            required for processing raw images.
-
-    Returns:
-        A tuple of float numpy arrays (one per plane), consisting of pixel
-            values in the range [0.0, 1.0].
-    """
-    w = cap["width"]
-    h = cap["height"]
-    if cap["format"] == "raw10":
-        assert(props is not None)
-        cap = unpack_raw10_capture(cap, props)
-    if cap["format"] == "yuv":
-        y = cap["data"][0:w*h]
-        u = cap["data"][w*h:w*h*5/4]
-        v = cap["data"][w*h*5/4:w*h*6/4]
-        return ((y.astype(numpy.float32) / 255.0).reshape(h, w, 1),
-                (u.astype(numpy.float32) / 255.0).reshape(h/2, w/2, 1),
-                (v.astype(numpy.float32) / 255.0).reshape(h/2, w/2, 1))
-    elif cap["format"] == "jpeg":
-        rgb = decompress_jpeg_to_rgb_image(cap["data"]).reshape(w*h*3)
-        return (rgb[::3].reshape(h,w,1),
-                rgb[1::3].reshape(h,w,1),
-                rgb[2::3].reshape(h,w,1))
-    elif cap["format"] == "raw":
-        assert(props is not None)
-        white_level = float(props['android.sensor.info.whiteLevel'])
-        img = numpy.ndarray(shape=(h*w,), dtype='<u2',
-                            buffer=cap["data"][0:w*h*2])
-        img = img.astype(numpy.float32).reshape(h,w) / white_level
-        imgs = [img[::2].reshape(w*h/2)[::2].reshape(h/2,w/2,1),
-                img[::2].reshape(w*h/2)[1::2].reshape(h/2,w/2,1),
-                img[1::2].reshape(w*h/2)[::2].reshape(h/2,w/2,1),
-                img[1::2].reshape(w*h/2)[1::2].reshape(h/2,w/2,1)]
-        idxs = get_canonical_cfa_order(props)
-        return [imgs[i] for i in idxs]
-    else:
-        raise its.error.Error('Invalid format %s' % (cap["format"]))
-
-def get_canonical_cfa_order(props):
-    """Returns a mapping from the Bayer 2x2 top-left grid in the CFA to
-    the standard order R,Gr,Gb,B.
-
-    Args:
-        props: Camera properties object.
-
-    Returns:
-        List of 4 integers, corresponding to the positions in the 2x2 top-
-            left Bayer grid of R,Gr,Gb,B, where the 2x2 grid is labeled as
-            0,1,2,3 in row major order.
-    """
-    # Note that raw streams aren't croppable, so the cropRegion doesn't need
-    # to be considered when determining the top-left pixel color.
-    cfa_pat = props['android.sensor.info.colorFilterArrangement']
-    if cfa_pat == 0:
-        # RGGB
-        return [0,1,2,3]
-    elif cfa_pat == 1:
-        # GRBG
-        return [1,0,3,2]
-    elif cfa_pat == 2:
-        # GBRG
-        return [2,3,0,1]
-    elif cfa_pat == 3:
-        # BGGR
-        return [3,2,1,0]
-    else:
-        raise its.error.Error("Not supported")
-
-def get_gains_in_canonical_order(props, gains):
-    """Reorders the gains tuple to the canonical R,Gr,Gb,B order.
-
-    Args:
-        props: Camera properties object.
-        gains: List of 4 values, in R,G_even,G_odd,B order.
-
-    Returns:
-        List of gains values, in R,Gr,Gb,B order.
-    """
-    cfa_pat = props['android.sensor.info.colorFilterArrangement']
-    if cfa_pat in [0,1]:
-        # RGGB or GRBG, so G_even is Gr
-        return gains
-    elif cfa_pat in [2,3]:
-        # GBRG or BGGR, so G_even is Gb
-        return [gains[0], gains[2], gains[1], gains[3]]
-    else:
-        raise its.error.Error("Not supported")
-
-def convert_raw_to_rgb_image(r_plane, gr_plane, gb_plane, b_plane,
-                             props, cap_res):
-    """Convert a Bayer raw-16 image to an RGB image.
-
-    Includes some extremely rudimentary demosaicking and color processing
-    operations; the output of this function shouldn't be used for any image
-    quality analysis.
-
-    Args:
-        r_plane,gr_plane,gb_plane,b_plane: Numpy arrays for each color plane
-            in the Bayer image, with pixels in the [0.0, 1.0] range.
-        props: Camera properties object.
-        cap_res: Capture result (metadata) object.
-
-    Returns:
-        RGB float-3 image array, with pixel values in [0.0, 1.0]
-    """
-    # Values required for the RAW to RGB conversion.
-    assert(props is not None)
-    white_level = float(props['android.sensor.info.whiteLevel'])
-    black_levels = props['android.sensor.blackLevelPattern']
-    gains = cap_res['android.colorCorrection.gains']
-    ccm = cap_res['android.colorCorrection.transform']
-
-    # Reorder black levels and gains to R,Gr,Gb,B, to match the order
-    # of the planes.
-    idxs = get_canonical_cfa_order(props)
-    black_levels = [black_levels[i] for i in idxs]
-    gains = get_gains_in_canonical_order(props, gains)
-
-    # Convert CCM from rational to float, as numpy arrays.
-    ccm = numpy.array(its.objects.rational_to_float(ccm)).reshape(3,3)
-
-    # Need to scale the image back to the full [0,1] range after subtracting
-    # the black level from each pixel.
-    scale = white_level / (white_level - max(black_levels))
-
-    # Three-channel black levels, normalized to [0,1] by white_level.
-    black_levels = numpy.array([b/white_level for b in [
-            black_levels[i] for i in [0,1,3]]])
-
-    # Three-channel gains.
-    gains = numpy.array([gains[i] for i in [0,1,3]])
-
-    h,w = r_plane.shape[:2]
-    img = numpy.dstack([r_plane,(gr_plane+gb_plane)/2.0,b_plane])
-    img = (((img.reshape(h,w,3) - black_levels) * scale) * gains).clip(0.0,1.0)
-    img = numpy.dot(img.reshape(w*h,3), ccm.T).reshape(h,w,3).clip(0.0,1.0)
-    return img
-
-def convert_yuv420_to_rgb_image(y_plane, u_plane, v_plane,
-                                w, h,
-                                ccm_yuv_to_rgb=DEFAULT_YUV_TO_RGB_CCM,
-                                yuv_off=DEFAULT_YUV_OFFSETS):
-    """Convert a YUV420 8-bit planar image to an RGB image.
-
-    Args:
-        y_plane: The packed 8-bit Y plane.
-        u_plane: The packed 8-bit U plane.
-        v_plane: The packed 8-bit V plane.
-        w: The width of the image.
-        h: The height of the image.
-        ccm_yuv_to_rgb: (Optional) the 3x3 CCM to convert from YUV to RGB.
-        yuv_off: (Optional) offsets to subtract from each of Y,U,V values.
-
-    Returns:
-        RGB float-3 image array, with pixel values in [0.0, 1.0].
-    """
-    y = numpy.subtract(y_plane, yuv_off[0])
-    u = numpy.subtract(u_plane, yuv_off[1]).view(numpy.int8)
-    v = numpy.subtract(v_plane, yuv_off[2]).view(numpy.int8)
-    u = u.reshape(h/2, w/2).repeat(2, axis=1).repeat(2, axis=0)
-    v = v.reshape(h/2, w/2).repeat(2, axis=1).repeat(2, axis=0)
-    yuv = numpy.dstack([y, u.reshape(w*h), v.reshape(w*h)])
-    flt = numpy.empty([h, w, 3], dtype=numpy.float32)
-    flt.reshape(w*h*3)[:] = yuv.reshape(h*w*3)[:]
-    flt = numpy.dot(flt.reshape(w*h,3), ccm_yuv_to_rgb.T).clip(0, 255)
-    rgb = numpy.empty([h, w, 3], dtype=numpy.uint8)
-    rgb.reshape(w*h*3)[:] = flt.reshape(w*h*3)[:]
-    return rgb.astype(numpy.float32) / 255.0
-
-def load_yuv420_to_rgb_image(yuv_fname,
-                             w, h,
-                             ccm_yuv_to_rgb=DEFAULT_YUV_TO_RGB_CCM,
-                             yuv_off=DEFAULT_YUV_OFFSETS):
-    """Load a YUV420 image file, and return as an RGB image.
-
-    Args:
-        yuv_fname: The path of the YUV420 file.
-        w: The width of the image.
-        h: The height of the image.
-        ccm_yuv_to_rgb: (Optional) the 3x3 CCM to convert from YUV to RGB.
-        yuv_off: (Optional) offsets to subtract from each of Y,U,V values.
-
-    Returns:
-        RGB float-3 image array, with pixel values in [0.0, 1.0].
-    """
-    with open(yuv_fname, "rb") as f:
-        y = numpy.fromfile(f, numpy.uint8, w*h, "")
-        v = numpy.fromfile(f, numpy.uint8, w*h/4, "")
-        u = numpy.fromfile(f, numpy.uint8, w*h/4, "")
-        return convert_yuv420_to_rgb_image(y,u,v,w,h,ccm_yuv_to_rgb,yuv_off)
-
-def load_yuv420_to_yuv_planes(yuv_fname, w, h):
-    """Load a YUV420 image file, and return separate Y, U, and V plane images.
-
-    Args:
-        yuv_fname: The path of the YUV420 file.
-        w: The width of the image.
-        h: The height of the image.
-
-    Returns:
-        Separate Y, U, and V images as float-1 Numpy arrays, pixels in [0,1].
-        Note that pixel (0,0,0) is not black, since U,V pixels are centered at
-        0.5, and also that the Y and U,V plane images returned are different
-        sizes (due to chroma subsampling in the YUV420 format).
-    """
-    with open(yuv_fname, "rb") as f:
-        y = numpy.fromfile(f, numpy.uint8, w*h, "")
-        v = numpy.fromfile(f, numpy.uint8, w*h/4, "")
-        u = numpy.fromfile(f, numpy.uint8, w*h/4, "")
-        return ((y.astype(numpy.float32) / 255.0).reshape(h, w, 1),
-                (u.astype(numpy.float32) / 255.0).reshape(h/2, w/2, 1),
-                (v.astype(numpy.float32) / 255.0).reshape(h/2, w/2, 1))
-
-def decompress_jpeg_to_rgb_image(jpeg_buffer):
-    """Decompress a JPEG-compressed image, returning as an RGB image.
-
-    Args:
-        jpeg_buffer: The JPEG stream.
-
-    Returns:
-        A numpy array for the RGB image, with pixels in [0,1].
-    """
-    img = Image.open(cStringIO.StringIO(jpeg_buffer))
-    w = img.size[0]
-    h = img.size[1]
-    return numpy.array(img).reshape(h,w,3) / 255.0
-
-def apply_lut_to_image(img, lut):
-    """Applies a LUT to every pixel in a float image array.
-
-    Internally converts to a 16b integer image, since the LUT can work with up
-    to 16b->16b mappings (i.e. values in the range [0,65535]). The lut can also
-    have fewer than 65536 entries, however it must be sized as a power of 2
-    (and for smaller luts, the scale must match the bitdepth).
-
-    For a 16b lut of 65536 entries, the operation performed is:
-
-        lut[r * 65535] / 65535 -> r'
-        lut[g * 65535] / 65535 -> g'
-        lut[b * 65535] / 65535 -> b'
-
-    For a 10b lut of 1024 entries, the operation becomes:
-
-        lut[r * 1023] / 1023 -> r'
-        lut[g * 1023] / 1023 -> g'
-        lut[b * 1023] / 1023 -> b'
-
-    Args:
-        img: Numpy float image array, with pixel values in [0,1].
-        lut: Numpy table encoding a LUT, mapping 16b integer values.
-
-    Returns:
-        Float image array after applying LUT to each pixel.
-    """
-    n = len(lut)
-    if n <= 0 or n > MAX_LUT_SIZE or (n & (n - 1)) != 0:
-        raise its.error.Error('Invalid arg LUT size: %d' % (n))
-    m = float(n-1)
-    return (lut[(img * m).astype(numpy.uint16)] / m).astype(numpy.float32)
-
-def apply_matrix_to_image(img, mat):
-    """Multiplies a 3x3 matrix with each float-3 image pixel.
-
-    Each pixel is considered a column vector, and is left-multiplied by
-    the given matrix:
-
-        [     ]   r    r'
-        [ mat ] * g -> g'
-        [     ]   b    b'
-
-    Args:
-        img: Numpy float image array, with pixel values in [0,1].
-        mat: Numpy 3x3 matrix.
-
-    Returns:
-        The numpy float-3 image array resulting from the matrix mult.
-    """
-    h = img.shape[0]
-    w = img.shape[1]
-    img2 = numpy.empty([h, w, 3], dtype=numpy.float32)
-    img2.reshape(w*h*3)[:] = (numpy.dot(img.reshape(h*w, 3), mat.T)
-                             ).reshape(w*h*3)[:]
-    return img2
-
-def get_image_patch(img, xnorm, ynorm, wnorm, hnorm):
-    """Get a patch (tile) of an image.
-
-    Args:
-        img: Numpy float image array, with pixel values in [0,1].
-        xnorm,ynorm,wnorm,hnorm: Normalized (in [0,1]) coords for the tile.
-
-    Returns:
-        Float image array of the patch.
-    """
-    hfull = img.shape[0]
-    wfull = img.shape[1]
-    xtile = math.ceil(xnorm * wfull)
-    ytile = math.ceil(ynorm * hfull)
-    wtile = math.floor(wnorm * wfull)
-    htile = math.floor(hnorm * hfull)
-    return img[ytile:ytile+htile,xtile:xtile+wtile,:].copy()
-
-def compute_image_means(img):
-    """Calculate the mean of each color channel in the image.
-
-    Args:
-        img: Numpy float image array, with pixel values in [0,1].
-
-    Returns:
-        A list of mean values, one per color channel in the image.
-    """
-    means = []
-    chans = img.shape[2]
-    for i in xrange(chans):
-        means.append(numpy.mean(img[:,:,i], dtype=numpy.float64))
-    return means
-
-def compute_image_variances(img):
-    """Calculate the variance of each color channel in the image.
-
-    Args:
-        img: Numpy float image array, with pixel values in [0,1].
-
-    Returns:
-        A list of mean values, one per color channel in the image.
-    """
-    variances = []
-    chans = img.shape[2]
-    for i in xrange(chans):
-        variances.append(numpy.var(img[:,:,i], dtype=numpy.float64))
-    return variances
-
-def write_image(img, fname, apply_gamma=False):
-    """Save a float-3 numpy array image to a file.
-
-    Supported formats: PNG, JPEG, and others; see PIL docs for more.
-
-    Image can be 3-channel, which is interpreted as RGB, or can be 1-channel,
-    which is greyscale.
-
-    Can optionally specify that the image should be gamma-encoded prior to
-    writing it out; this should be done if the image contains linear pixel
-    values, to make the image look "normal".
-
-    Args:
-        img: Numpy image array data.
-        fname: Path of file to save to; the extension specifies the format.
-        apply_gamma: (Optional) apply gamma to the image prior to writing it.
-    """
-    if apply_gamma:
-        img = apply_lut_to_image(img, DEFAULT_GAMMA_LUT)
-    (h, w, chans) = img.shape
-    if chans == 3:
-        Image.fromarray((img * 255.0).astype(numpy.uint8), "RGB").save(fname)
-    elif chans == 1:
-        img3 = (img * 255.0).astype(numpy.uint8).repeat(3).reshape(h,w,3)
-        Image.fromarray(img3, "RGB").save(fname)
-    else:
-        raise its.error.Error('Unsupported image type')
-
-def downscale_image(img, f):
-    """Shrink an image by a given integer factor.
-
-    This function computes output pixel values by averaging over rectangular
-    regions of the input image; it doesn't skip or sample pixels, and all input
-    image pixels are evenly weighted.
-
-    If the downscaling factor doesn't cleanly divide the width and/or height,
-    then the remaining pixels on the right or bottom edge are discarded prior
-    to the downscaling.
-
-    Args:
-        img: The input image as an ndarray.
-        f: The downscaling factor, which should be an integer.
-
-    Returns:
-        The new (downscaled) image, as an ndarray.
-    """
-    h,w,chans = img.shape
-    f = int(f)
-    assert(f >= 1)
-    h = (h/f)*f
-    w = (w/f)*f
-    img = img[0:h:,0:w:,::]
-    chs = []
-    for i in xrange(chans):
-        ch = img.reshape(h*w*chans)[i::chans].reshape(h,w)
-        ch = ch.reshape(h,w/f,f).mean(2).reshape(h,w/f)
-        ch = ch.T.reshape(w/f,h/f,f).mean(2).T.reshape(h/f,w/f)
-        chs.append(ch.reshape(h*w/(f*f)))
-    img = numpy.vstack(chs).T.reshape(h/f,w/f,chans)
-    return img
-
-def __measure_color_checker_patch(img, xc,yc, patch_size):
-    r = patch_size/2
-    tile = img[yc-r:yc+r+1:, xc-r:xc+r+1:, ::]
-    means = tile.mean(1).mean(0)
-    return means
-
-def get_color_checker_chart_patches(img, debug_fname_prefix=None):
-    """Return the center coords of each patch in a color checker chart.
-
-    Assumptions:
-    * Chart is vertical or horizontal w.r.t. camera, but not diagonal.
-    * Chart is (roughly) planar-parallel to the camera.
-    * Chart is centered in frame (roughly).
-    * Around/behind chart is white/grey background.
-    * The only black pixels in the image are from the chart.
-    * Chart is 100% visible and contained within image.
-    * No other objects within image.
-    * Image is well-exposed.
-    * Standard color checker chart with standard-sized black borders.
-
-    The values returned are in the coordinate system of the chart; that is,
-    the "origin" patch is the brown patch that is in the chart's top-left
-    corner when it is in the normal upright/horizontal orientation. (The chart
-    may be any of the four main orientations in the image.)
-
-    The chart is 6x4 patches in the normal upright orientation. The return
-    values of this function are the center coordinate of the top-left patch,
-    and the displacement vectors to the next patches to the right and below
-    the top-left patch. From these pieces of data, the center coordinates of
-    any of the patches can be computed.
-
-    Args:
-        img: Input image, as a numpy array with pixels in [0,1].
-        debug_fname_prefix: If not None, the (string) name of a file prefix to
-            use to save a number of debug images for visulaizing the output of
-            this function; can be used to see if the patches are being found
-            successfully.
-
-    Returns:
-        6x4 list of lists of integer (x,y) coords of the center of each patch,
-        ordered in the "chart order" (6x4 row major).
-    """
-
-    # Shrink the original image.
-    DOWNSCALE_FACTOR = 4
-    img_small = downscale_image(img, DOWNSCALE_FACTOR)
-
-    # Make a threshold image, which is 1.0 where the image is black,
-    # and 0.0 elsewhere.
-    BLACK_PIXEL_THRESH = 0.2
-    mask_img = scipy.stats.threshold(
-                img_small.max(2), BLACK_PIXEL_THRESH, 1.1, 0.0)
-    mask_img = 1.0 - scipy.stats.threshold(mask_img, -0.1, 0.1, 1.0)
-
-    if debug_fname_prefix is not None:
-        h,w = mask_img.shape
-        write_image(img, debug_fname_prefix+"_0.jpg")
-        write_image(mask_img.repeat(3).reshape(h,w,3),
-                debug_fname_prefix+"_1.jpg")
-
-    # Mask image flattened to a single row or column (by averaging).
-    # Also apply a threshold to these arrays.
-    FLAT_PIXEL_THRESH = 0.05
-    flat_row = mask_img.mean(0)
-    flat_col = mask_img.mean(1)
-    flat_row = [0 if v < FLAT_PIXEL_THRESH else 1 for v in flat_row]
-    flat_col = [0 if v < FLAT_PIXEL_THRESH else 1 for v in flat_col]
-
-    # Start and end of the non-zero region of the flattened row/column.
-    flat_row_nonzero = [i for i in range(len(flat_row)) if flat_row[i]>0]
-    flat_col_nonzero = [i for i in range(len(flat_col)) if flat_col[i]>0]
-    flat_row_min, flat_row_max = min(flat_row_nonzero), max(flat_row_nonzero)
-    flat_col_min, flat_col_max = min(flat_col_nonzero), max(flat_col_nonzero)
-
-    # Orientation of chart, and number of grid cells horz. and vertically.
-    orient = "h" if flat_row_max-flat_row_min>flat_col_max-flat_col_min else "v"
-    xgrids = 6 if orient=="h" else 4
-    ygrids = 6 if orient=="v" else 4
-
-    # Get better bounds on the patches region, lopping off some of the excess
-    # black border.
-    HRZ_BORDER_PAD_FRAC = 0.0138
-    VERT_BORDER_PAD_FRAC = 0.0395
-    xpad = HRZ_BORDER_PAD_FRAC if orient=="h" else VERT_BORDER_PAD_FRAC
-    ypad = HRZ_BORDER_PAD_FRAC if orient=="v" else VERT_BORDER_PAD_FRAC
-    xchart = flat_row_min + (flat_row_max - flat_row_min) * xpad
-    ychart = flat_col_min + (flat_col_max - flat_col_min) * ypad
-    wchart = (flat_row_max - flat_row_min) * (1 - 2*xpad)
-    hchart = (flat_col_max - flat_col_min) * (1 - 2*ypad)
-
-    # Get the colors of the 4 corner patches, in clockwise order, by measuring
-    # the average value of a small patch at each of the 4 patch centers.
-    colors = []
-    centers = []
-    for (x,y) in [(0,0), (xgrids-1,0), (xgrids-1,ygrids-1), (0,ygrids-1)]:
-        xc = xchart + (x + 0.5)*wchart/xgrids
-        yc = ychart + (y + 0.5)*hchart/ygrids
-        xc = int(xc * DOWNSCALE_FACTOR + 0.5)
-        yc = int(yc * DOWNSCALE_FACTOR + 0.5)
-        centers.append((xc,yc))
-        chan_means = __measure_color_checker_patch(img, xc,yc, 32)
-        colors.append(sum(chan_means) / len(chan_means))
-
-    # The brightest corner is the white patch, the darkest is the black patch.
-    # The black patch should be counter-clockwise from the white patch.
-    white_patch_index = None
-    for i in range(4):
-        if colors[i] == max(colors) and \
-                colors[(i-1+4)%4] == min(colors):
-            white_patch_index = i%4
-    assert(white_patch_index is not None)
-
-    # Return the coords of the origin (top-left when the chart is in the normal
-    # upright orientation) patch's center, and the vector displacement to the
-    # center of the second patch on the first row of the chart (when in the
-    # normal upright orienation).
-    origin_index = (white_patch_index+1)%4
-    prev_index = (origin_index-1+4)%4
-    next_index = (origin_index+1)%4
-    origin_center = centers[origin_index]
-    prev_center = centers[prev_index]
-    next_center = centers[next_index]
-    vec_across = tuple([(next_center[i]-origin_center[i])/5.0 for i in [0,1]])
-    vec_down = tuple([(prev_center[i]-origin_center[i])/3.0 for i in [0,1]])
-
-    # Compute the center of each patch.
-    patches = [[],[],[],[]]
-    for yi in range(4):
-        for xi in range(6):
-            x0,y0 = origin_center
-            dxh,dyh = vec_across
-            dxv,dyv = vec_down
-            xc = int(x0 + dxh*xi + dxv*yi)
-            yc = int(y0 + dyh*xi + dyv*yi)
-            patches[yi].append((xc,yc))
-
-    # Sanity check: test that the R,G,B,black,white patches are correct.
-    patch_info = [(2,2,[0]), # Red
-                  (2,1,[1]), # Green
-                  (2,0,[2]), # Blue
-                  (3,0,[0,1,2]), # White
-                  (3,5,[])] # Black
-    for i in range(len(patch_info)):
-        yi,xi,high_chans = patch_info[i]
-        low_chans = [i for i in [0,1,2] if i not in high_chans]
-        xc,yc = patches[yi][xi]
-        means = __measure_color_checker_patch(img, xc,yc, 64)
-        if (min([means[i] for i in high_chans]+[1]) < \
-                max([means[i] for i in low_chans]+[0])):
-            print "Color patch sanity check failed: patch", i
-            # If the debug info is requested, then don't assert that the patches
-            # are matched, to allow the caller to see the output.
-            if debug_fname_prefix is None:
-                assert(0)
-
-    if debug_fname_prefix is not None:
-        for (xc,yc) in sum(patches,[]):
-            img[yc,xc] = 1.0
-        write_image(img, debug_fname_prefix+"_2.jpg")
-
-    return patches
-
-class __UnitTest(unittest.TestCase):
-    """Run a suite of unit tests on this module.
-    """
-
-    # TODO: Add more unit tests.
-
-    def test_apply_matrix_to_image(self):
-        """Unit test for apply_matrix_to_image.
-
-        Test by using a canned set of values on a 1x1 pixel image.
-
-            [ 1 2 3 ]   [ 0.1 ]   [ 1.4 ]
-            [ 4 5 6 ] * [ 0.2 ] = [ 3.2 ]
-            [ 7 8 9 ]   [ 0.3 ]   [ 5.0 ]
-               mat         x         y
-        """
-        mat = numpy.array([[1,2,3],[4,5,6],[7,8,9]])
-        x = numpy.array([0.1,0.2,0.3]).reshape(1,1,3)
-        y = apply_matrix_to_image(x, mat).reshape(3).tolist()
-        y_ref = [1.4,3.2,5.0]
-        passed = all([math.fabs(y[i] - y_ref[i]) < 0.001 for i in xrange(3)])
-        self.assertTrue(passed)
-
-    def test_apply_lut_to_image(self):
-        """ Unit test for apply_lut_to_image.
-
-        Test by using a canned set of values on a 1x1 pixel image. The LUT will
-        simply double the value of the index:
-
-            lut[x] = 2*x
-        """
-        lut = numpy.array([2*i for i in xrange(65536)])
-        x = numpy.array([0.1,0.2,0.3]).reshape(1,1,3)
-        y = apply_lut_to_image(x, lut).reshape(3).tolist()
-        y_ref = [0.2,0.4,0.6]
-        passed = all([math.fabs(y[i] - y_ref[i]) < 0.001 for i in xrange(3)])
-        self.assertTrue(passed)
-
-if __name__ == '__main__':
-    unittest.main()
-
diff --git a/apps/CameraITS/pymodules/its/objects.py b/apps/CameraITS/pymodules/its/objects.py
deleted file mode 100644
index d11ef84..0000000
--- a/apps/CameraITS/pymodules/its/objects.py
+++ /dev/null
@@ -1,190 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import os.path
-import sys
-import re
-import json
-import tempfile
-import time
-import unittest
-import subprocess
-import math
-
-def int_to_rational(i):
-    """Function to convert Python integers to Camera2 rationals.
-
-    Args:
-        i: Python integer or list of integers.
-
-    Returns:
-        Python dictionary or list of dictionaries representing the given int(s)
-        as rationals with denominator=1.
-    """
-    if isinstance(i, list):
-        return [{"numerator":val, "denominator":1} for val in i]
-    else:
-        return {"numerator":i, "denominator":1}
-
-def float_to_rational(f, denom=128):
-    """Function to convert Python floats to Camera2 rationals.
-
-    Args:
-        f: Python float or list of floats.
-        denom: (Optonal) the denominator to use in the output rationals.
-
-    Returns:
-        Python dictionary or list of dictionaries representing the given
-        float(s) as rationals.
-    """
-    if isinstance(f, list):
-        return [{"numerator":math.floor(val*denom+0.5), "denominator":denom}
-                for val in f]
-    else:
-        return {"numerator":math.floor(f*denom+0.5), "denominator":denom}
-
-def rational_to_float(r):
-    """Function to convert Camera2 rational objects to Python floats.
-
-    Args:
-        r: Rational or list of rationals, as Python dictionaries.
-
-    Returns:
-        Float or list of floats.
-    """
-    if isinstance(r, list):
-        return [float(val["numerator"]) / float(val["denominator"])
-                for val in r]
-    else:
-        return float(r["numerator"]) / float(r["denominator"])
-
-def manual_capture_request(sensitivity, exp_time, linear_tonemap=False):
-    """Return a capture request with everything set to manual.
-
-    Uses identity/unit color correction, and the default tonemap curve.
-    Optionally, the tonemap can be specified as being linear.
-
-    Args:
-        sensitivity: The sensitivity value to populate the request with.
-        exp_time: The exposure time, in nanoseconds, to populate the request
-            with.
-        linear_tonemap: [Optional] whether a linear tonemap should be used
-            in this request.
-
-    Returns:
-        The default manual capture request, ready to be passed to the
-        its.device.do_capture function.
-    """
-    req = {
-        "android.control.mode": 0,
-        "android.control.aeMode": 0,
-        "android.control.awbMode": 0,
-        "android.control.afMode": 0,
-        "android.control.effectMode": 0,
-        "android.sensor.frameDuration": 0,
-        "android.sensor.sensitivity": sensitivity,
-        "android.sensor.exposureTime": exp_time,
-        "android.colorCorrection.mode": 0,
-        "android.colorCorrection.transform":
-                int_to_rational([1,0,0, 0,1,0, 0,0,1]),
-        "android.colorCorrection.gains": [1,1,1,1],
-        "android.tonemap.mode": 1,
-        }
-    if linear_tonemap:
-        req["android.tonemap.mode"] = 0
-        req["android.tonemap.curveRed"] = [0.0,0.0, 1.0,1.0]
-        req["android.tonemap.curveGreen"] = [0.0,0.0, 1.0,1.0]
-        req["android.tonemap.curveBlue"] = [0.0,0.0, 1.0,1.0]
-    return req
-
-def auto_capture_request():
-    """Return a capture request with everything set to auto.
-    """
-    return {
-        "android.control.mode": 1,
-        "android.control.aeMode": 1,
-        "android.control.awbMode": 1,
-        "android.control.afMode": 1,
-        "android.colorCorrection.mode": 1,
-        "android.tonemap.mode": 1,
-        }
-
-def get_available_output_sizes(fmt, props):
-    """Return a sorted list of available output sizes for a given format.
-
-    Args:
-        fmt: the output format, as a string in ["jpg", "yuv", "raw"].
-        props: the object returned from its.device.get_camera_properties().
-
-    Returns:
-        A sorted list of (w,h) tuples (sorted large-to-small).
-    """
-    fmt_codes = {"raw":0x20, "raw10":0x25, "yuv":0x23, "jpg":0x100, "jpeg":0x100}
-    configs = props['android.scaler.streamConfigurationMap']\
-                   ['availableStreamConfigurations']
-    fmt_configs = [cfg for cfg in configs if cfg['format'] == fmt_codes[fmt]]
-    out_configs = [cfg for cfg in fmt_configs if cfg['input'] == False]
-    out_sizes = [(cfg['width'],cfg['height']) for cfg in out_configs]
-    out_sizes.sort(reverse=True)
-    return out_sizes
-
-def get_fastest_manual_capture_settings(props):
-    """Return a capture request and format spec for the fastest capture.
-
-    Args:
-        props: the object returned from its.device.get_camera_properties().
-
-    Returns:
-        Two values, the first is a capture request, and the second is an output
-        format specification, for the fastest possible (legal) capture that
-        can be performed on this device (with the smallest output size).
-    """
-    fmt = "yuv"
-    size = get_available_output_sizes(fmt, props)[-1]
-    out_spec = {"format":fmt, "width":size[0], "height":size[1]}
-    s = min(props['android.sensor.info.sensitivityRange'])
-    e = min(props['android.sensor.info.exposureTimeRange'])
-    req = manual_capture_request(s,e)
-    return req, out_spec
-
-class __UnitTest(unittest.TestCase):
-    """Run a suite of unit tests on this module.
-    """
-
-    def test_int_to_rational(self):
-        """Unit test for int_to_rational.
-        """
-        self.assertEqual(int_to_rational(10),
-                         {"numerator":10,"denominator":1})
-        self.assertEqual(int_to_rational([1,2]),
-                         [{"numerator":1,"denominator":1},
-                          {"numerator":2,"denominator":1}])
-
-    def test_float_to_rational(self):
-        """Unit test for float_to_rational.
-        """
-        self.assertEqual(float_to_rational(0.5001, 64),
-                        {"numerator":32, "denominator":64})
-
-    def test_rational_to_float(self):
-        """Unit test for rational_to_float.
-        """
-        self.assertTrue(
-                abs(rational_to_float({"numerator":32,"denominator":64})-0.5)
-                < 0.0001)
-
-if __name__ == '__main__':
-    unittest.main()
-
diff --git a/apps/CameraITS/pymodules/its/target.py b/apps/CameraITS/pymodules/its/target.py
deleted file mode 100644
index 3715f34..0000000
--- a/apps/CameraITS/pymodules/its/target.py
+++ /dev/null
@@ -1,266 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.image
-import its.objects
-import os
-import os.path
-import sys
-import json
-import unittest
-import json
-
-CACHE_FILENAME = "its.target.cfg"
-
-def __do_target_exposure_measurement(its_session):
-    """Use device 3A and captured shots to determine scene exposure.
-
-    Creates a new ITS device session (so this function should not be called
-    while another session to the device is open).
-
-    Assumes that the camera is pointed at a scene that is reasonably uniform
-    and reasonably lit -- that is, an appropriate target for running the ITS
-    tests that assume such uniformity.
-
-    Measures the scene using device 3A and then by taking a shot to hone in on
-    the exact exposure level that will result in a center 10% by 10% patch of
-    the scene having a intensity level of 0.5 (in the pixel range of [0,1])
-    when a linear tonemap is used. That is, the pixels coming off the sensor
-    should be at approximately 50% intensity (however note that it's actually
-    the luma value in the YUV image that is being targeted to 50%).
-
-    The computed exposure value is the product of the sensitivity (ISO) and
-    exposure time (ns) to achieve that sensor exposure level.
-
-    Args:
-        its_session: Holds an open device session.
-
-    Returns:
-        The measured product of sensitivity and exposure time that results in
-            the luma channel of captured shots having an intensity of 0.5.
-    """
-    print "Measuring target exposure"
-
-    # Get AE+AWB lock first, so the auto values in the capture result are
-    # populated properly.
-    r = [[0.45, 0.45, 0.1, 0.1, 1]]
-    sens, exp_time, gains, xform, _ \
-            = its_session.do_3a(r,r,r,do_af=False,get_results=True)
-
-    # Convert the transform to rational.
-    xform_rat = [{"numerator":int(100*x),"denominator":100} for x in xform]
-
-    # Linear tonemap
-    tmap = sum([[i/63.0,i/63.0] for i in range(64)], [])
-
-    # Capture a manual shot with this exposure, using a linear tonemap.
-    # Use the gains+transform returned by the AWB pass.
-    req = its.objects.manual_capture_request(sens, exp_time)
-    req["android.tonemap.mode"] = 0
-    req["android.tonemap.curveRed"] = tmap
-    req["android.tonemap.curveGreen"] = tmap
-    req["android.tonemap.curveBlue"] = tmap
-    req["android.colorCorrection.transform"] = xform_rat
-    req["android.colorCorrection.gains"] = gains
-    cap = its_session.do_capture(req)
-
-    # Compute the mean luma of a center patch.
-    yimg,uimg,vimg = its.image.convert_capture_to_planes(cap)
-    tile = its.image.get_image_patch(yimg, 0.45, 0.45, 0.1, 0.1)
-    luma_mean = its.image.compute_image_means(tile)
-
-    # Compute the exposure value that would result in a luma of 0.5.
-    return sens * exp_time * 0.5 / luma_mean[0]
-
-def __set_cached_target_exposure(exposure):
-    """Saves the given exposure value to a cached location.
-
-    Once a value is cached, a call to __get_cached_target_exposure will return
-    the value, even from a subsequent test/script run. That is, the value is
-    persisted.
-
-    The value is persisted in a JSON file in the current directory (from which
-    the script calling this function is run).
-
-    Args:
-        exposure: The value to cache.
-    """
-    print "Setting cached target exposure"
-    with open(CACHE_FILENAME, "w") as f:
-        f.write(json.dumps({"exposure":exposure}))
-
-def __get_cached_target_exposure():
-    """Get the cached exposure value.
-
-    Returns:
-        The cached exposure value, or None if there is no valid cached value.
-    """
-    try:
-        with open(CACHE_FILENAME, "r") as f:
-            o = json.load(f)
-            return o["exposure"]
-    except:
-        return None
-
-def clear_cached_target_exposure():
-    """If there is a cached exposure value, clear it.
-    """
-    if os.path.isfile(CACHE_FILENAME):
-        os.remove(CACHE_FILENAME)
-
-def set_hardcoded_exposure(exposure):
-    """Set a hard-coded exposure value, rather than relying on measurements.
-
-    The exposure value is the product of sensitivity (ISO) and eposure time
-    (ns) that will result in a center-patch luma value of 0.5 (using a linear
-    tonemap) for the scene that the camera is pointing at.
-
-    If bringing up a new HAL implementation and the ability use the device to
-    measure the scene isn't there yet (e.g. device 3A doesn't work), then a
-    cache file of the appropriate name can be manually created and populated
-    with a hard-coded value using this function.
-
-    Args:
-        exposure: The hard-coded exposure value to set.
-    """
-    __set_cached_target_exposure(exposure)
-
-def get_target_exposure(its_session=None):
-    """Get the target exposure to use.
-
-    If there is a cached value and if the "target" command line parameter is
-    present, then return the cached value. Otherwise, measure a new value from
-    the scene, cache it, then return it.
-
-    Args:
-        its_session: Optional, holding an open device session.
-
-    Returns:
-        The target exposure value.
-    """
-    cached_exposure = None
-    for s in sys.argv[1:]:
-        if s == "target":
-            cached_exposure = __get_cached_target_exposure()
-    if cached_exposure is not None:
-        print "Using cached target exposure"
-        return cached_exposure
-    if its_session is None:
-        with its.device.ItsSession() as cam:
-            measured_exposure = __do_target_exposure_measurement(cam)
-    else:
-        measured_exposure = __do_target_exposure_measurement(its_session)
-    __set_cached_target_exposure(measured_exposure)
-    return measured_exposure
-
-def get_target_exposure_combos(its_session=None):
-    """Get a set of legal combinations of target (exposure time, sensitivity).
-
-    Gets the target exposure value, which is a product of sensitivity (ISO) and
-    exposure time, and returns equivalent tuples of (exposure time,sensitivity)
-    that are all legal and that correspond to the four extrema in this 2D param
-    space, as well as to two "middle" points.
-
-    Will open a device session if its_session is None.
-
-    Args:
-        its_session: Optional, holding an open device session.
-
-    Returns:
-        Object containing six legal (exposure time, sensitivity) tuples, keyed
-        by the following strings:
-            "minExposureTime"
-            "midExposureTime"
-            "maxExposureTime"
-            "minSensitivity"
-            "midSensitivity"
-            "maxSensitivity
-    """
-    if its_session is None:
-        with its.device.ItsSession() as cam:
-            exposure = get_target_exposure(cam)
-            props = cam.get_camera_properties()
-    else:
-        exposure = get_target_exposure(its_session)
-        props = its_session.get_camera_properties()
-
-    sens_range = props['android.sensor.info.sensitivityRange']
-    exp_time_range = props['android.sensor.info.exposureTimeRange']
-
-    # Combo 1: smallest legal exposure time.
-    e1_expt = exp_time_range[0]
-    e1_sens = exposure / e1_expt
-    if e1_sens > sens_range[1]:
-        e1_sens = sens_range[1]
-        e1_expt = exposure / e1_sens
-
-    # Combo 2: largest legal exposure time.
-    e2_expt = exp_time_range[1]
-    e2_sens = exposure / e2_expt
-    if e2_sens < sens_range[0]:
-        e2_sens = sens_range[0]
-        e2_expt = exposure / e2_sens
-
-    # Combo 3: smallest legal sensitivity.
-    e3_sens = sens_range[0]
-    e3_expt = exposure / e3_sens
-    if e3_expt > exp_time_range[1]:
-        e3_expt = exp_time_range[1]
-        e3_sens = exposure / e3_expt
-
-    # Combo 4: largest legal sensitivity.
-    e4_sens = sens_range[1]
-    e4_expt = exposure / e4_sens
-    if e4_expt < exp_time_range[0]:
-        e4_expt = exp_time_range[0]
-        e4_sens = exposure / e4_expt
-
-    # Combo 5: middle exposure time.
-    e5_expt = (exp_time_range[0] + exp_time_range[1]) / 2.0
-    e5_sens = exposure / e5_expt
-    if e5_sens > sens_range[1]:
-        e5_sens = sens_range[1]
-        e5_expt = exposure / e5_sens
-    if e5_sens < sens_range[0]:
-        e5_sens = sens_range[0]
-        e5_expt = exposure / e5_sens
-
-    # Combo 6: middle sensitivity.
-    e6_sens = (sens_range[0] + sens_range[1]) / 2.0
-    e6_expt = exposure / e6_sens
-    if e6_expt > exp_time_range[1]:
-        e6_expt = exp_time_range[1]
-        e6_sens = exposure / e6_expt
-    if e6_expt < exp_time_range[0]:
-        e6_expt = exp_time_range[0]
-        e6_sens = exposure / e6_expt
-
-    return {
-        "minExposureTime" : (int(e1_expt), int(e1_sens)),
-        "maxExposureTime" : (int(e2_expt), int(e2_sens)),
-        "minSensitivity" : (int(e3_expt), int(e3_sens)),
-        "maxSensitivity" : (int(e4_expt), int(e4_sens)),
-        "midExposureTime" : (int(e5_expt), int(e5_sens)),
-        "midSensitivity" : (int(e6_expt), int(e6_sens))
-        }
-
-class __UnitTest(unittest.TestCase):
-    """Run a suite of unit tests on this module.
-    """
-    # TODO: Add some unit tests.
-
-if __name__ == '__main__':
-    unittest.main()
-
diff --git a/apps/CameraITS/service/Android.mk b/apps/CameraITS/service/Android.mk
deleted file mode 100644
index 5bb67a1..0000000
--- a/apps/CameraITS/service/Android.mk
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright (C) 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-ifeq ($(TARGET_BUILD_JAVA_SUPPORT_LEVEL),platform)
-
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SDK_VERSION := current
-
-LOCAL_STATIC_JAVA_LIBRARIES := android-ex-camera2
-
-LOCAL_SRC_FILES := \
-	$(call all-java-files-under, src)
-
-LOCAL_PACKAGE_NAME := ItsService
-
-include $(BUILD_PACKAGE)
-
-endif
diff --git a/apps/CameraITS/service/AndroidManifest.xml b/apps/CameraITS/service/AndroidManifest.xml
deleted file mode 100644
index 1dcadd5..0000000
--- a/apps/CameraITS/service/AndroidManifest.xml
+++ /dev/null
@@ -1,52 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<!-- Copyright (C) 2013 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<manifest
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.android.camera2.its">
-  <uses-feature android:name="android.hardware.camera" android:required="true"/>
-  <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
-  <uses-feature android:name="android.hardware.camera.flash" android:required="false"/>
-  <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
-  <uses-feature android:name="android.hardware.sensor.accelerometer" android:required="true" />
-  <uses-feature android:name="android.hardware.sensor.compass" android:required="true" />
-  <uses-feature android:name="android.hardware.sensor.gyroscope" android:required="true" />
-  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-  <uses-permission android:name="android.permission.CAMERA" />
-  <uses-permission android:name="android.permission.INTERNET" />
-  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
-  <uses-permission android:name="android.permission.WAKE_LOCK" />
-  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
-  <uses-permission android:name="android.permission.VIBRATE" />
-  <application
-      android:label="@string/app_name"
-      android:largeHeap="true"
-      android:theme="@android:style/Theme.Holo"
-      >
-    <service
-        android:name=".ItsService"
-        android:label="@string/app_name"
-        >
-      <intent-filter>
-        <action android:name="com.android.camera2.its.START"/>
-        <category android:name="android.intent.category.DEFAULT" />
-        <data android:mimeType="text/plain" />
-      </intent-filter>
-    </service>
-  </application>
-</manifest>
-
diff --git a/apps/CameraITS/service/res/values/strings.xml b/apps/CameraITS/service/res/values/strings.xml
deleted file mode 100644
index bd70229..0000000
--- a/apps/CameraITS/service/res/values/strings.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<!-- Copyright (C) 2013 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<resources>
-    <string name="app_name">ItsService</string>
-</resources>
diff --git a/apps/CameraITS/service/src/com/android/camera2/its/ItsException.java b/apps/CameraITS/service/src/com/android/camera2/its/ItsException.java
deleted file mode 100644
index 87af0b5..0000000
--- a/apps/CameraITS/service/src/com/android/camera2/its/ItsException.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.camera2.its;
-
-/**
- * All exceptions are converted to ItsExceptions.
- */
-class ItsException extends Exception {
-    public ItsException(Throwable cause) {
-        super(cause);
-    }
-
-    public ItsException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public ItsException(String message) {
-        super(message);
-    }
-}
diff --git a/apps/CameraITS/service/src/com/android/camera2/its/ItsSerializer.java b/apps/CameraITS/service/src/com/android/camera2/its/ItsSerializer.java
deleted file mode 100644
index 943a73f..0000000
--- a/apps/CameraITS/service/src/com/android/camera2/its/ItsSerializer.java
+++ /dev/null
@@ -1,714 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.camera2.its;
-
-import android.graphics.Point;
-import android.graphics.Rect;
-import android.hardware.camera2.CameraCharacteristics;
-import android.hardware.camera2.CameraDevice;
-import android.hardware.camera2.CameraMetadata;
-import android.hardware.camera2.CaptureResult;
-import android.hardware.camera2.CaptureRequest;
-import android.hardware.camera2.TotalCaptureResult;
-import android.hardware.camera2.params.BlackLevelPattern;
-import android.hardware.camera2.params.ColorSpaceTransform;
-import android.hardware.camera2.params.Face;
-import android.hardware.camera2.params.LensShadingMap;
-import android.hardware.camera2.params.MeteringRectangle;
-import android.hardware.camera2.params.RggbChannelVector;
-import android.hardware.camera2.params.StreamConfigurationMap;
-import android.hardware.camera2.params.TonemapCurve;
-import android.location.Location;
-import android.util.Log;
-import android.util.Pair;
-import android.util.Rational;
-import android.util.Size;
-import android.util.SizeF;
-import android.util.Range;
-
-import org.json.JSONArray;
-import org.json.JSONObject;
-
-import java.lang.reflect.Array;
-import java.lang.reflect.Field;
-import java.lang.reflect.GenericArrayType;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-/**
- * Class to deal with serializing and deserializing between JSON and Camera2 objects.
- */
-public class ItsSerializer {
-    public static final String TAG = ItsSerializer.class.getSimpleName();
-
-    private static class MetadataEntry {
-        public MetadataEntry(String k, Object v) {
-            key = k;
-            value = v;
-        }
-        public String key;
-        public Object value;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeRational(Rational rat) throws org.json.JSONException {
-        JSONObject ratObj = new JSONObject();
-        ratObj.put("numerator", rat.getNumerator());
-        ratObj.put("denominator", rat.getDenominator());
-        return ratObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeSize(Size size) throws org.json.JSONException {
-        JSONObject sizeObj = new JSONObject();
-        sizeObj.put("width", size.getWidth());
-        sizeObj.put("height", size.getHeight());
-        return sizeObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeSizeF(SizeF size) throws org.json.JSONException {
-        JSONObject sizeObj = new JSONObject();
-        sizeObj.put("width", size.getWidth());
-        sizeObj.put("height", size.getHeight());
-        return sizeObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeRect(Rect rect) throws org.json.JSONException {
-        JSONObject rectObj = new JSONObject();
-        rectObj.put("left", rect.left);
-        rectObj.put("right", rect.right);
-        rectObj.put("top", rect.top);
-        rectObj.put("bottom", rect.bottom);
-        return rectObj;
-    }
-
-    private static Object serializePoint(Point point) throws org.json.JSONException {
-        JSONObject pointObj = new JSONObject();
-        pointObj.put("x", point.x);
-        pointObj.put("y", point.y);
-        return pointObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeFace(Face face)
-            throws org.json.JSONException {
-        JSONObject faceObj = new JSONObject();
-        faceObj.put("bounds", serializeRect(face.getBounds()));
-        faceObj.put("score", face.getScore());
-        faceObj.put("id", face.getId());
-        faceObj.put("leftEye", serializePoint(face.getLeftEyePosition()));
-        faceObj.put("rightEye", serializePoint(face.getRightEyePosition()));
-        faceObj.put("mouth", serializePoint(face.getMouthPosition()));
-        return faceObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeStreamConfigurationMap(
-            StreamConfigurationMap map)
-            throws org.json.JSONException {
-        // TODO: Serialize the rest of the StreamConfigurationMap fields.
-        JSONObject mapObj = new JSONObject();
-        JSONArray cfgArray = new JSONArray();
-        int fmts[] = map.getOutputFormats();
-        if (fmts != null) {
-            for (int fi = 0; fi < Array.getLength(fmts); fi++) {
-                Size sizes[] = map.getOutputSizes(fmts[fi]);
-                if (sizes != null) {
-                    for (int si = 0; si < Array.getLength(sizes); si++) {
-                        JSONObject obj = new JSONObject();
-                        obj.put("format", fmts[fi]);
-                        obj.put("width",sizes[si].getWidth());
-                        obj.put("height", sizes[si].getHeight());
-                        obj.put("input", false);
-                        obj.put("minFrameDuration",
-                                map.getOutputMinFrameDuration(fmts[fi],sizes[si]));
-                        cfgArray.put(obj);
-                    }
-                }
-            }
-        }
-        mapObj.put("availableStreamConfigurations", cfgArray);
-        return mapObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeMeteringRectangle(MeteringRectangle rect)
-            throws org.json.JSONException {
-        JSONObject rectObj = new JSONObject();
-        rectObj.put("x", rect.getX());
-        rectObj.put("y", rect.getY());
-        rectObj.put("width", rect.getWidth());
-        rectObj.put("height", rect.getHeight());
-        rectObj.put("weight", rect.getMeteringWeight());
-        return rectObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializePair(Pair pair)
-            throws org.json.JSONException {
-        JSONArray pairObj = new JSONArray();
-        pairObj.put(pair.first);
-        pairObj.put(pair.second);
-        return pairObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeRange(Range range)
-            throws org.json.JSONException {
-        JSONArray rangeObj = new JSONArray();
-        rangeObj.put(range.getLower());
-        rangeObj.put(range.getUpper());
-        return rangeObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeColorSpaceTransform(ColorSpaceTransform xform)
-            throws org.json.JSONException {
-        JSONArray xformObj = new JSONArray();
-        for (int row = 0; row < 3; row++) {
-            for (int col = 0; col < 3; col++) {
-                xformObj.put(serializeRational(xform.getElement(col,row)));
-            }
-        }
-        return xformObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeTonemapCurve(TonemapCurve curve)
-            throws org.json.JSONException {
-        JSONObject curveObj = new JSONObject();
-        String names[] = {"red", "green", "blue"};
-        for (int ch = 0; ch < 3; ch++) {
-            JSONArray curveArr = new JSONArray();
-            int len = curve.getPointCount(ch);
-            for (int i = 0; i < len; i++) {
-                curveArr.put(curve.getPoint(ch,i).x);
-                curveArr.put(curve.getPoint(ch,i).y);
-            }
-            curveObj.put(names[ch], curveArr);
-        }
-        return curveObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeRggbChannelVector(RggbChannelVector vec)
-            throws org.json.JSONException {
-        JSONArray vecObj = new JSONArray();
-        vecObj.put(vec.getRed());
-        vecObj.put(vec.getGreenEven());
-        vecObj.put(vec.getGreenOdd());
-        vecObj.put(vec.getBlue());
-        return vecObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeBlackLevelPattern(BlackLevelPattern pat)
-            throws org.json.JSONException {
-        int patVals[] = new int[4];
-        pat.copyTo(patVals, 0);
-        JSONArray patObj = new JSONArray();
-        patObj.put(patVals[0]);
-        patObj.put(patVals[1]);
-        patObj.put(patVals[2]);
-        patObj.put(patVals[3]);
-        return patObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeLocation(Location loc)
-            throws org.json.JSONException {
-        return loc.toString();
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Object serializeLensShadingMap(LensShadingMap map)
-            throws org.json.JSONException {
-        JSONArray mapObj = new JSONArray();
-        for (int row = 0; row < map.getRowCount(); row++) {
-            for (int col = 0; col < map.getColumnCount(); col++) {
-                for (int ch = 0; ch < 4; ch++) {
-                    mapObj.put(map.getGainFactor(ch, col, row));
-                }
-            }
-        }
-        return mapObj;
-    }
-
-    private static String getKeyName(Object keyObj) throws ItsException {
-        if (keyObj.getClass() == CaptureResult.Key.class
-                || keyObj.getClass() == TotalCaptureResult.class) {
-            return ((CaptureResult.Key)keyObj).getName();
-        } else if (keyObj.getClass() == CaptureRequest.Key.class) {
-            return ((CaptureRequest.Key)keyObj).getName();
-        } else if (keyObj.getClass() == CameraCharacteristics.Key.class) {
-            return ((CameraCharacteristics.Key)keyObj).getName();
-        }
-        throw new ItsException("Invalid key object");
-    }
-
-    private static Object getKeyValue(CameraMetadata md, Object keyObj) throws ItsException {
-        if (md.getClass() == CaptureResult.class || md.getClass() == TotalCaptureResult.class) {
-            return ((CaptureResult)md).get((CaptureResult.Key)keyObj);
-        } else if (md.getClass() == CaptureRequest.class) {
-            return ((CaptureRequest)md).get((CaptureRequest.Key)keyObj);
-        } else if (md.getClass() == CameraCharacteristics.class) {
-            return ((CameraCharacteristics)md).get((CameraCharacteristics.Key)keyObj);
-        }
-        throw new ItsException("Invalid key object");
-    }
-
-    @SuppressWarnings("unchecked")
-    private static MetadataEntry serializeEntry(Type keyType, Object keyObj, CameraMetadata md)
-            throws ItsException {
-        String keyName = getKeyName(keyObj);
-
-        try {
-            Object keyValue = getKeyValue(md, keyObj);
-            if (keyValue == null) {
-                return new MetadataEntry(keyName, JSONObject.NULL);
-            } else if (keyType == Float.class) {
-                // The JSON serializer doesn't handle floating point NaN or Inf.
-                if (((Float)keyValue).isInfinite() || ((Float)keyValue).isNaN()) {
-                    Logt.w(TAG, "Inf/NaN floating point value serialized: " + keyName);
-                    return null;
-                }
-                return new MetadataEntry(keyName, keyValue);
-            } else if (keyType == Integer.class || keyType == Long.class || keyType == Byte.class ||
-                       keyType == Boolean.class || keyType == String.class) {
-                return new MetadataEntry(keyName, keyValue);
-            } else if (keyType == Rational.class) {
-                return new MetadataEntry(keyName, serializeRational((Rational)keyValue));
-            } else if (keyType == Size.class) {
-                return new MetadataEntry(keyName, serializeSize((Size)keyValue));
-            } else if (keyType == SizeF.class) {
-                return new MetadataEntry(keyName, serializeSizeF((SizeF)keyValue));
-            } else if (keyType == Rect.class) {
-                return new MetadataEntry(keyName, serializeRect((Rect)keyValue));
-            } else if (keyType == Face.class) {
-                return new MetadataEntry(keyName, serializeFace((Face)keyValue));
-            } else if (keyType == StreamConfigurationMap.class) {
-                return new MetadataEntry(keyName,
-                        serializeStreamConfigurationMap((StreamConfigurationMap)keyValue));
-            } else if (keyType instanceof ParameterizedType &&
-                    ((ParameterizedType)keyType).getRawType() == Range.class) {
-                return new MetadataEntry(keyName, serializeRange((Range)keyValue));
-            } else if (keyType == ColorSpaceTransform.class) {
-                return new MetadataEntry(keyName,
-                        serializeColorSpaceTransform((ColorSpaceTransform)keyValue));
-            } else if (keyType == MeteringRectangle.class) {
-                return new MetadataEntry(keyName,
-                        serializeMeteringRectangle((MeteringRectangle)keyValue));
-            } else if (keyType == Location.class) {
-                return new MetadataEntry(keyName,
-                        serializeLocation((Location)keyValue));
-            } else if (keyType == RggbChannelVector.class) {
-                return new MetadataEntry(keyName,
-                        serializeRggbChannelVector((RggbChannelVector)keyValue));
-            } else if (keyType == BlackLevelPattern.class) {
-                return new MetadataEntry(keyName,
-                        serializeBlackLevelPattern((BlackLevelPattern)keyValue));
-            } else if (keyType == TonemapCurve.class) {
-                return new MetadataEntry(keyName,
-                        serializeTonemapCurve((TonemapCurve)keyValue));
-            } else if (keyType == Point.class) {
-                return new MetadataEntry(keyName,
-                        serializePoint((Point)keyValue));
-            } else if (keyType == LensShadingMap.class) {
-                return new MetadataEntry(keyName,
-                        serializeLensShadingMap((LensShadingMap)keyValue));
-            } else {
-                Logt.w(TAG, String.format("Serializing unsupported key type: " + keyType));
-                return null;
-            }
-        } catch (org.json.JSONException e) {
-            throw new ItsException("JSON error for key: " + keyName + ": ", e);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private static MetadataEntry serializeArrayEntry(Type keyType, Object keyObj, CameraMetadata md)
-            throws ItsException {
-        String keyName = getKeyName(keyObj);
-        try {
-            Object keyValue = getKeyValue(md, keyObj);
-            if (keyValue == null) {
-                return new MetadataEntry(keyName, JSONObject.NULL);
-            }
-            int arrayLen = Array.getLength(keyValue);
-            Type elmtType = ((GenericArrayType)keyType).getGenericComponentType();
-            if (elmtType == int.class  || elmtType == float.class || elmtType == byte.class ||
-                elmtType == long.class || elmtType == double.class || elmtType == boolean.class) {
-                return new MetadataEntry(keyName, new JSONArray(keyValue));
-            } else if (elmtType == Rational.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeRational((Rational)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == Size.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeSize((Size)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == Rect.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeRect((Rect)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == Face.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeFace((Face)Array.get(keyValue, i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == StreamConfigurationMap.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeStreamConfigurationMap(
-                            (StreamConfigurationMap)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType instanceof ParameterizedType &&
-                    ((ParameterizedType)elmtType).getRawType() == Range.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeRange((Range)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType instanceof ParameterizedType &&
-                    ((ParameterizedType)elmtType).getRawType() == Pair.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializePair((Pair)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == MeteringRectangle.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeMeteringRectangle(
-                            (MeteringRectangle)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == Location.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeLocation((Location)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == RggbChannelVector.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeRggbChannelVector(
-                            (RggbChannelVector)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == BlackLevelPattern.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializeBlackLevelPattern(
-                            (BlackLevelPattern)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else if (elmtType == Point.class) {
-                JSONArray jsonArray = new JSONArray();
-                for (int i = 0; i < arrayLen; i++) {
-                    jsonArray.put(serializePoint((Point)Array.get(keyValue,i)));
-                }
-                return new MetadataEntry(keyName, jsonArray);
-            } else {
-                Logt.w(TAG, String.format("Serializing unsupported array type: " + elmtType));
-                return null;
-            }
-        } catch (org.json.JSONException e) {
-            throw new ItsException("JSON error for key: " + keyName + ": ", e);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    public static JSONObject serialize(CameraMetadata md)
-            throws ItsException {
-        JSONObject jsonObj = new JSONObject();
-        Field[] allFields = md.getClass().getDeclaredFields();
-        if (md.getClass() == TotalCaptureResult.class) {
-            allFields = CaptureResult.class.getDeclaredFields();
-        }
-        for (Field field : allFields) {
-            if (Modifier.isPublic(field.getModifiers()) &&
-                    Modifier.isStatic(field.getModifiers()) &&
-                    (field.getType() == CaptureRequest.Key.class
-                      || field.getType() == CaptureResult.Key.class
-                      || field.getType() == TotalCaptureResult.Key.class
-                      || field.getType() == CameraCharacteristics.Key.class) &&
-                    field.getGenericType() instanceof ParameterizedType) {
-                ParameterizedType paramType = (ParameterizedType)field.getGenericType();
-                Type[] argTypes = paramType.getActualTypeArguments();
-                if (argTypes.length > 0) {
-                    try {
-                        Type keyType = argTypes[0];
-                        Object keyObj = field.get(md);
-                        MetadataEntry entry;
-                        if (keyType instanceof GenericArrayType) {
-                            entry = serializeArrayEntry(keyType, keyObj, md);
-                        } else {
-                            entry = serializeEntry(keyType, keyObj, md);
-                        }
-
-                        // TODO: Figure this weird case out.
-                        // There is a weird case where the entry is non-null but the toString
-                        // of the entry is null, and if this happens, the null-ness spreads like
-                        // a virus and makes the whole JSON object null from the top level down.
-                        // Not sure if it's a bug in the library or I'm just not using it right.
-                        // Workaround by checking for this case explicitly and not adding the
-                        // value to the jsonObj when it is detected.
-                        if (entry != null && entry.key != null && entry.value != null
-                                          && entry.value.toString() == null) {
-                            Logt.w(TAG, "Error encountered serializing value for key: " + entry.key);
-                        } else if (entry != null) {
-                            jsonObj.put(entry.key, entry.value);
-                        } else {
-                            // Ignore.
-                        }
-                    } catch (IllegalAccessException e) {
-                        throw new ItsException(
-                                "Access error for field: " + field + ": ", e);
-                    } catch (org.json.JSONException e) {
-                        throw new ItsException(
-                                "JSON error for field: " + field + ": ", e);
-                    }
-                }
-            }
-        }
-        return jsonObj;
-    }
-
-    @SuppressWarnings("unchecked")
-    public static CaptureRequest.Builder deserialize(CaptureRequest.Builder mdDefault,
-            JSONObject jsonReq) throws ItsException {
-        try {
-            Logt.i(TAG, "Parsing JSON capture request ...");
-
-            // Iterate over the CaptureRequest reflected fields.
-            CaptureRequest.Builder md = mdDefault;
-            Field[] allFields = CaptureRequest.class.getDeclaredFields();
-            for (Field field : allFields) {
-                if (Modifier.isPublic(field.getModifiers()) &&
-                        Modifier.isStatic(field.getModifiers()) &&
-                        field.getType() == CaptureRequest.Key.class &&
-                        field.getGenericType() instanceof ParameterizedType) {
-                    ParameterizedType paramType = (ParameterizedType)field.getGenericType();
-                    Type[] argTypes = paramType.getActualTypeArguments();
-                    if (argTypes.length > 0) {
-                        CaptureRequest.Key key = (CaptureRequest.Key)field.get(md);
-                        String keyName = key.getName();
-                        Type keyType = argTypes[0];
-
-                        // For each reflected CaptureRequest entry, look inside the JSON object
-                        // to see if it is being set. If it is found, remove the key from the
-                        // JSON object. After this process, there should be no keys left in the
-                        // JSON (otherwise an invalid key was specified).
-
-                        if (jsonReq.has(keyName) && !jsonReq.isNull(keyName)) {
-                            if (keyType instanceof GenericArrayType) {
-                                Type elmtType =
-                                        ((GenericArrayType)keyType).getGenericComponentType();
-                                JSONArray ja = jsonReq.getJSONArray(keyName);
-                                Object val[] = new Object[ja.length()];
-                                for (int i = 0; i < ja.length(); i++) {
-                                    if (elmtType == int.class) {
-                                        Array.set(val, i, ja.getInt(i));
-                                    } else if (elmtType == byte.class) {
-                                        Array.set(val, i, (byte)ja.getInt(i));
-                                    } else if (elmtType == float.class) {
-                                        Array.set(val, i, (float)ja.getDouble(i));
-                                    } else if (elmtType == long.class) {
-                                        Array.set(val, i, ja.getLong(i));
-                                    } else if (elmtType == double.class) {
-                                        Array.set(val, i, ja.getDouble(i));
-                                    } else if (elmtType == boolean.class) {
-                                        Array.set(val, i, ja.getBoolean(i));
-                                    } else if (elmtType == String.class) {
-                                        Array.set(val, i, ja.getString(i));
-                                    } else if (elmtType == Size.class){
-                                        JSONObject obj = ja.getJSONObject(i);
-                                        Array.set(val, i, new Size(
-                                                obj.getInt("width"), obj.getInt("height")));
-                                    } else if (elmtType == Rect.class) {
-                                        JSONObject obj = ja.getJSONObject(i);
-                                        Array.set(val, i, new Rect(
-                                                obj.getInt("left"), obj.getInt("top"),
-                                                obj.getInt("bottom"), obj.getInt("right")));
-                                    } else if (elmtType == Rational.class) {
-                                        JSONObject obj = ja.getJSONObject(i);
-                                        Array.set(val, i, new Rational(
-                                                obj.getInt("numerator"),
-                                                obj.getInt("denominator")));
-                                    } else if (elmtType == RggbChannelVector.class) {
-                                        JSONArray arr = ja.getJSONArray(i);
-                                        Array.set(val, i, new RggbChannelVector(
-                                                (float)arr.getDouble(0),
-                                                (float)arr.getDouble(1),
-                                                (float)arr.getDouble(2),
-                                                (float)arr.getDouble(3)));
-                                    } else if (elmtType == ColorSpaceTransform.class) {
-                                        JSONArray arr = ja.getJSONArray(i);
-                                        Rational xform[] = new Rational[9];
-                                        for (int j = 0; j < 9; j++) {
-                                            xform[j] = new Rational(
-                                                    arr.getJSONObject(j).getInt("numerator"),
-                                                    arr.getJSONObject(j).getInt("denominator"));
-                                        }
-                                        Array.set(val, i, new ColorSpaceTransform(xform));
-                                    } else if (elmtType == MeteringRectangle.class) {
-                                        JSONObject obj = ja.getJSONObject(i);
-                                        Array.set(val, i, new MeteringRectangle(
-                                                obj.getInt("x"),
-                                                obj.getInt("y"),
-                                                obj.getInt("width"),
-                                                obj.getInt("height"),
-                                                obj.getInt("weight")));
-                                    } else {
-                                        throw new ItsException(
-                                                "Failed to parse key from JSON: " + keyName);
-                                    }
-                                }
-                                if (val != null) {
-                                    Logt.i(TAG, "Set: "+keyName+" -> "+Arrays.toString(val));
-                                    md.set(key, val);
-                                    jsonReq.remove(keyName);
-                                }
-                            } else {
-                                Object val = null;
-                                if (keyType == Integer.class) {
-                                    val = jsonReq.getInt(keyName);
-                                } else if (keyType == Byte.class) {
-                                    val = (byte)jsonReq.getInt(keyName);
-                                } else if (keyType == Double.class) {
-                                    val = jsonReq.getDouble(keyName);
-                                } else if (keyType == Long.class) {
-                                    val = jsonReq.getLong(keyName);
-                                } else if (keyType == Float.class) {
-                                    val = (float)jsonReq.getDouble(keyName);
-                                } else if (keyType == Boolean.class) {
-                                    val = jsonReq.getBoolean(keyName);
-                                } else if (keyType == String.class) {
-                                    val = jsonReq.getString(keyName);
-                                } else if (keyType == Size.class) {
-                                    JSONObject obj = jsonReq.getJSONObject(keyName);
-                                    val = new Size(
-                                            obj.getInt("width"), obj.getInt("height"));
-                                } else if (keyType == Rect.class) {
-                                    JSONObject obj = jsonReq.getJSONObject(keyName);
-                                    val = new Rect(
-                                            obj.getInt("left"), obj.getInt("top"),
-                                            obj.getInt("right"), obj.getInt("bottom"));
-                                } else if (keyType == Rational.class) {
-                                    JSONObject obj = jsonReq.getJSONObject(keyName);
-                                    val = new Rational(obj.getInt("numerator"),
-                                                       obj.getInt("denominator"));
-                                } else if (keyType == RggbChannelVector.class) {
-                                    JSONObject obj = jsonReq.optJSONObject(keyName);
-                                    JSONArray arr = jsonReq.optJSONArray(keyName);
-                                    if (arr != null) {
-                                        val = new RggbChannelVector(
-                                                (float)arr.getDouble(0),
-                                                (float)arr.getDouble(1),
-                                                (float)arr.getDouble(2),
-                                                (float)arr.getDouble(3));
-                                    } else if (obj != null) {
-                                        val = new RggbChannelVector(
-                                                (float)obj.getDouble("red"),
-                                                (float)obj.getDouble("greenEven"),
-                                                (float)obj.getDouble("greenOdd"),
-                                                (float)obj.getDouble("blue"));
-                                    } else {
-                                        throw new ItsException("Invalid RggbChannelVector object");
-                                    }
-                                } else if (keyType == ColorSpaceTransform.class) {
-                                    JSONArray arr = jsonReq.getJSONArray(keyName);
-                                    Rational a[] = new Rational[9];
-                                    for (int i = 0; i < 9; i++) {
-                                        a[i] = new Rational(
-                                                arr.getJSONObject(i).getInt("numerator"),
-                                                arr.getJSONObject(i).getInt("denominator"));
-                                    }
-                                    val = new ColorSpaceTransform(a);
-                                } else if (keyType instanceof ParameterizedType &&
-                                        ((ParameterizedType)keyType).getRawType() == Range.class &&
-                                        ((ParameterizedType)keyType).getActualTypeArguments().length == 1 &&
-                                        ((ParameterizedType)keyType).getActualTypeArguments()[0] == Integer.class) {
-                                    JSONArray arr = jsonReq.getJSONArray(keyName);
-                                    val = new Range<Integer>(arr.getInt(0), arr.getInt(1));
-                                } else {
-                                    throw new ItsException(
-                                            "Failed to parse key from JSON: " +
-                                            keyName + ", " + keyType);
-                                }
-                                if (val != null) {
-                                    Logt.i(TAG, "Set: " + keyName + " -> " + val);
-                                    md.set(key ,val);
-                                    jsonReq.remove(keyName);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Ensure that there were no invalid keys in the JSON request object.
-            if (jsonReq.length() != 0) {
-                throw new ItsException("Invalid JSON key(s): " + jsonReq.toString());
-            }
-
-            Logt.i(TAG, "Parsing JSON capture request completed");
-            return md;
-        } catch (java.lang.IllegalAccessException e) {
-            throw new ItsException("Access error: ", e);
-        } catch (org.json.JSONException e) {
-            throw new ItsException("JSON error: ", e);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    public static List<CaptureRequest.Builder> deserializeRequestList(
-            CameraDevice device, JSONObject jsonObjTop)
-            throws ItsException {
-        try {
-            List<CaptureRequest.Builder> requests = null;
-            JSONArray jsonReqs = jsonObjTop.getJSONArray("captureRequests");
-            requests = new LinkedList<CaptureRequest.Builder>();
-            for (int i = 0; i < jsonReqs.length(); i++) {
-                CaptureRequest.Builder templateReq = device.createCaptureRequest(
-                        CameraDevice.TEMPLATE_STILL_CAPTURE);
-                requests.add(
-                    deserialize(templateReq, jsonReqs.getJSONObject(i)));
-            }
-            return requests;
-        } catch (org.json.JSONException e) {
-            throw new ItsException("JSON error: ", e);
-        } catch (android.hardware.camera2.CameraAccessException e) {
-            throw new ItsException("Access error: ", e);
-        }
-    }
-}
diff --git a/apps/CameraITS/service/src/com/android/camera2/its/ItsService.java b/apps/CameraITS/service/src/com/android/camera2/its/ItsService.java
deleted file mode 100644
index 1c497ea..0000000
--- a/apps/CameraITS/service/src/com/android/camera2/its/ItsService.java
+++ /dev/null
@@ -1,1319 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.camera2.its;
-
-import android.app.Service;
-import android.content.Context;
-import android.content.Intent;
-import android.graphics.ImageFormat;
-import android.hardware.camera2.CameraCaptureSession;
-import android.hardware.camera2.CameraAccessException;
-import android.hardware.camera2.CameraCharacteristics;
-import android.hardware.camera2.CameraDevice;
-import android.hardware.camera2.CameraManager;
-import android.hardware.camera2.CaptureFailure;
-import android.hardware.camera2.CaptureRequest;
-import android.hardware.camera2.CaptureResult;
-import android.hardware.camera2.DngCreator;
-import android.hardware.camera2.TotalCaptureResult;
-import android.hardware.camera2.params.MeteringRectangle;
-import android.hardware.Sensor;
-import android.hardware.SensorEvent;
-import android.hardware.SensorEventListener;
-import android.hardware.SensorManager;
-import android.media.Image;
-import android.media.ImageReader;
-import android.net.Uri;
-import android.os.ConditionVariable;
-import android.os.Handler;
-import android.os.HandlerThread;
-import android.os.IBinder;
-import android.os.Message;
-import android.os.Vibrator;
-import android.util.Log;
-import android.util.Rational;
-import android.util.Size;
-import android.view.Surface;
-
-import com.android.ex.camera2.blocking.BlockingCameraManager;
-import com.android.ex.camera2.blocking.BlockingCameraManager.BlockingOpenException;
-import com.android.ex.camera2.blocking.BlockingStateCallback;
-import com.android.ex.camera2.blocking.BlockingSessionCallback;
-
-import org.json.JSONArray;
-import org.json.JSONObject;
-
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.math.BigInteger;
-import java.net.ServerSocket;
-import java.net.Socket;
-import java.net.SocketTimeoutException;
-import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
-import java.security.MessageDigest;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.LinkedBlockingDeque;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-
-public class ItsService extends Service implements SensorEventListener {
-    public static final String TAG = ItsService.class.getSimpleName();
-
-    // Timeouts, in seconds.
-    public static final int TIMEOUT_CALLBACK = 3;
-    public static final int TIMEOUT_3A = 10;
-
-    // State transition timeouts, in ms.
-    private static final long TIMEOUT_IDLE_MS = 2000;
-    private static final long TIMEOUT_STATE_MS = 500;
-
-    // Timeout to wait for a capture result after the capture buffer has arrived, in ms.
-    private static final long TIMEOUT_CAP_RES = 2000;
-
-    private static final int MAX_CONCURRENT_READER_BUFFERS = 8;
-
-    // Supports at most RAW+YUV+JPEG, one surface each.
-    private static final int MAX_NUM_OUTPUT_SURFACES = 3;
-
-    public static final int SERVERPORT = 6000;
-
-    public static final String REGION_KEY = "regions";
-    public static final String REGION_AE_KEY = "ae";
-    public static final String REGION_AWB_KEY = "awb";
-    public static final String REGION_AF_KEY = "af";
-    public static final String LOCK_AE_KEY = "aeLock";
-    public static final String LOCK_AWB_KEY = "awbLock";
-    public static final String TRIGGER_KEY = "triggers";
-    public static final String TRIGGER_AE_KEY = "ae";
-    public static final String TRIGGER_AF_KEY = "af";
-    public static final String VIB_PATTERN_KEY = "pattern";
-
-    private CameraManager mCameraManager = null;
-    private HandlerThread mCameraThread = null;
-    private Handler mCameraHandler = null;
-    private BlockingCameraManager mBlockingCameraManager = null;
-    private BlockingStateCallback mCameraListener = null;
-    private CameraDevice mCamera = null;
-    private CameraCaptureSession mSession = null;
-    private ImageReader[] mCaptureReaders = null;
-    private CameraCharacteristics mCameraCharacteristics = null;
-
-    private Vibrator mVibrator = null;
-
-    private HandlerThread mSaveThreads[] = new HandlerThread[MAX_NUM_OUTPUT_SURFACES];
-    private Handler mSaveHandlers[] = new Handler[MAX_NUM_OUTPUT_SURFACES];
-    private HandlerThread mResultThread = null;
-    private Handler mResultHandler = null;
-
-    private volatile boolean mThreadExitFlag = false;
-
-    private volatile ServerSocket mSocket = null;
-    private volatile SocketRunnable mSocketRunnableObj = null;
-    private volatile BlockingQueue<ByteBuffer> mSocketWriteQueue =
-            new LinkedBlockingDeque<ByteBuffer>();
-    private final Object mSocketWriteEnqueueLock = new Object();
-    private final Object mSocketWriteDrainLock = new Object();
-
-    private volatile BlockingQueue<Object[]> mSerializerQueue =
-            new LinkedBlockingDeque<Object[]>();
-
-    private AtomicInteger mCountCallbacksRemaining = new AtomicInteger();
-    private AtomicInteger mCountRawOrDng = new AtomicInteger();
-    private AtomicInteger mCountRaw10 = new AtomicInteger();
-    private AtomicInteger mCountJpg = new AtomicInteger();
-    private AtomicInteger mCountYuv = new AtomicInteger();
-    private AtomicInteger mCountCapRes = new AtomicInteger();
-    private boolean mCaptureRawIsDng;
-    private CaptureResult mCaptureResults[] = null;
-
-    private volatile ConditionVariable mInterlock3A = new ConditionVariable(true);
-    private volatile boolean mIssuedRequest3A = false;
-    private volatile boolean mConvergedAE = false;
-    private volatile boolean mConvergedAF = false;
-    private volatile boolean mConvergedAWB = false;
-    private volatile boolean mLockedAE = false;
-    private volatile boolean mLockedAWB = false;
-    private volatile boolean mNeedsLockedAE = false;
-    private volatile boolean mNeedsLockedAWB = false;
-
-    class MySensorEvent {
-        public Sensor sensor;
-        public int accuracy;
-        public long timestamp;
-        public float values[];
-    }
-
-    // For capturing motion sensor traces.
-    private SensorManager mSensorManager = null;
-    private Sensor mAccelSensor = null;
-    private Sensor mMagSensor = null;
-    private Sensor mGyroSensor = null;
-    private volatile LinkedList<MySensorEvent> mEvents = null;
-    private volatile Object mEventLock = new Object();
-    private volatile boolean mEventsEnabled = false;
-
-    public interface CaptureCallback {
-        void onCaptureAvailable(Image capture);
-    }
-
-    public abstract class CaptureResultListener extends CameraCaptureSession.CaptureCallback {}
-
-    @Override
-    public IBinder onBind(Intent intent) {
-        return null;
-    }
-
-    @Override
-    public void onCreate() {
-        try {
-            mThreadExitFlag = false;
-
-            // Get handle to camera manager.
-            mCameraManager = (CameraManager) this.getSystemService(Context.CAMERA_SERVICE);
-            if (mCameraManager == null) {
-                throw new ItsException("Failed to connect to camera manager");
-            }
-            mBlockingCameraManager = new BlockingCameraManager(mCameraManager);
-            mCameraListener = new BlockingStateCallback();
-
-            // Register for motion events.
-            mEvents = new LinkedList<MySensorEvent>();
-            mSensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
-            mAccelSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
-            mMagSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
-            mGyroSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
-            mSensorManager.registerListener(this, mAccelSensor, SensorManager.SENSOR_DELAY_FASTEST);
-            mSensorManager.registerListener(this, mMagSensor, SensorManager.SENSOR_DELAY_FASTEST);
-            mSensorManager.registerListener(this, mGyroSensor, SensorManager.SENSOR_DELAY_FASTEST);
-
-            // Get a handle to the system vibrator.
-            mVibrator = (Vibrator)getSystemService(Context.VIBRATOR_SERVICE);
-
-            // Create threads to receive images and save them.
-            for (int i = 0; i < MAX_NUM_OUTPUT_SURFACES; i++) {
-                mSaveThreads[i] = new HandlerThread("SaveThread" + i);
-                mSaveThreads[i].start();
-                mSaveHandlers[i] = new Handler(mSaveThreads[i].getLooper());
-            }
-
-            // Create a thread to handle object serialization.
-            (new Thread(new SerializerRunnable())).start();;
-
-            // Create a thread to receive capture results and process them.
-            mResultThread = new HandlerThread("ResultThread");
-            mResultThread.start();
-            mResultHandler = new Handler(mResultThread.getLooper());
-
-            // Create a thread for the camera device.
-            mCameraThread = new HandlerThread("ItsCameraThread");
-            mCameraThread.start();
-            mCameraHandler = new Handler(mCameraThread.getLooper());
-
-            // Create a thread to process commands, listening on a TCP socket.
-            mSocketRunnableObj = new SocketRunnable();
-            (new Thread(mSocketRunnableObj)).start();
-        } catch (ItsException e) {
-            Logt.e(TAG, "Service failed to start: ", e);
-        }
-    }
-
-    @Override
-    public int onStartCommand(Intent intent, int flags, int startId) {
-        try {
-            // Just log a message indicating that the service is running and is able to accept
-            // socket connections.
-            while (!mThreadExitFlag && mSocket==null) {
-                Thread.sleep(1);
-            }
-            if (!mThreadExitFlag){
-                Logt.i(TAG, "ItsService ready");
-            } else {
-                Logt.e(TAG, "Starting ItsService in bad state");
-            }
-        } catch (java.lang.InterruptedException e) {
-            Logt.e(TAG, "Error starting ItsService (interrupted)", e);
-        }
-        return START_STICKY;
-    }
-
-    @Override
-    public void onDestroy() {
-        mThreadExitFlag = true;
-        for (int i = 0; i < MAX_NUM_OUTPUT_SURFACES; i++) {
-            if (mSaveThreads[i] != null) {
-                mSaveThreads[i].quit();
-                mSaveThreads[i] = null;
-            }
-        }
-        if (mResultThread != null) {
-            mResultThread.quitSafely();
-            mResultThread = null;
-        }
-        if (mCameraThread != null) {
-            mCameraThread.quitSafely();
-            mCameraThread = null;
-        }
-    }
-
-    public void openCameraDevice(int cameraId) throws ItsException {
-        Logt.i(TAG, String.format("Opening camera %d", cameraId));
-
-        String[] devices;
-        try {
-            devices = mCameraManager.getCameraIdList();
-            if (devices == null || devices.length == 0) {
-                throw new ItsException("No camera devices");
-            }
-        } catch (CameraAccessException e) {
-            throw new ItsException("Failed to get device ID list", e);
-        }
-
-        try {
-            mCamera = mBlockingCameraManager.openCamera(devices[cameraId],
-                    mCameraListener, mCameraHandler);
-            mCameraCharacteristics = mCameraManager.getCameraCharacteristics(
-                    devices[cameraId]);
-        } catch (CameraAccessException e) {
-            throw new ItsException("Failed to open camera", e);
-        } catch (BlockingOpenException e) {
-            throw new ItsException("Failed to open camera (after blocking)", e);
-        }
-        mSocketRunnableObj.sendResponse("cameraOpened", "");
-    }
-
-    public void closeCameraDevice() throws ItsException {
-        try {
-            if (mCamera != null) {
-                Logt.i(TAG, "Closing camera");
-                mCamera.close();
-                mCamera = null;
-            }
-        } catch (Exception e) {
-            throw new ItsException("Failed to close device");
-        }
-        mSocketRunnableObj.sendResponse("cameraClosed", "");
-    }
-
-    class SerializerRunnable implements Runnable {
-        // Use a separate thread to perform JSON serialization (since this can be slow due to
-        // the reflection).
-        @Override
-        public void run() {
-            Logt.i(TAG, "Serializer thread starting");
-            while (! mThreadExitFlag) {
-                try {
-                    Object objs[] = mSerializerQueue.take();
-                    JSONObject jsonObj = new JSONObject();
-                    String tag = null;
-                    for (int i = 0; i < objs.length; i++) {
-                        Object obj = objs[i];
-                        if (obj instanceof String) {
-                            if (tag != null) {
-                                throw new ItsException("Multiple tags for socket response");
-                            }
-                            tag = (String)obj;
-                        } else if (obj instanceof CameraCharacteristics) {
-                            jsonObj.put("cameraProperties", ItsSerializer.serialize(
-                                    (CameraCharacteristics)obj));
-                        } else if (obj instanceof CaptureRequest) {
-                            jsonObj.put("captureRequest", ItsSerializer.serialize(
-                                    (CaptureRequest)obj));
-                        } else if (obj instanceof CaptureResult) {
-                            jsonObj.put("captureResult", ItsSerializer.serialize(
-                                    (CaptureResult)obj));
-                        } else if (obj instanceof JSONArray) {
-                            jsonObj.put("outputs", (JSONArray)obj);
-                        } else {
-                            throw new ItsException("Invalid object received for serialiation");
-                        }
-                    }
-                    if (tag == null) {
-                        throw new ItsException("No tag provided for socket response");
-                    }
-                    mSocketRunnableObj.sendResponse(tag, null, jsonObj, null);
-                    Logt.i(TAG, String.format("Serialized %s", tag));
-                } catch (org.json.JSONException e) {
-                    Logt.e(TAG, "Error serializing object", e);
-                    break;
-                } catch (ItsException e) {
-                    Logt.e(TAG, "Error serializing object", e);
-                    break;
-                } catch (java.lang.InterruptedException e) {
-                    Logt.e(TAG, "Error serializing object (interrupted)", e);
-                    break;
-                }
-            }
-            Logt.i(TAG, "Serializer thread terminated");
-        }
-    }
-
-    class SocketWriteRunnable implements Runnable {
-
-        // Use a separate thread to service a queue of objects to be written to the socket,
-        // writing each sequentially in order. This is needed since different handler functions
-        // (called on different threads) will need to send data back to the host script.
-
-        public Socket mOpenSocket = null;
-
-        public SocketWriteRunnable(Socket openSocket) {
-            mOpenSocket = openSocket;
-        }
-
-        public void setOpenSocket(Socket openSocket) {
-            mOpenSocket = openSocket;
-        }
-
-        @Override
-        public void run() {
-            Logt.i(TAG, "Socket writer thread starting");
-            while (true) {
-                try {
-                    ByteBuffer b = mSocketWriteQueue.take();
-                    synchronized(mSocketWriteDrainLock) {
-                        if (mOpenSocket == null) {
-                            continue;
-                        }
-                        if (b.hasArray()) {
-                            mOpenSocket.getOutputStream().write(b.array());
-                        } else {
-                            byte[] barray = new byte[b.capacity()];
-                            b.get(barray);
-                            mOpenSocket.getOutputStream().write(barray);
-                        }
-                        mOpenSocket.getOutputStream().flush();
-                        Logt.i(TAG, String.format("Wrote to socket: %d bytes", b.capacity()));
-                    }
-                } catch (IOException e) {
-                    Logt.e(TAG, "Error writing to socket", e);
-                    break;
-                } catch (java.lang.InterruptedException e) {
-                    Logt.e(TAG, "Error writing to socket (interrupted)", e);
-                    break;
-                }
-            }
-            Logt.i(TAG, "Socket writer thread terminated");
-        }
-    }
-
-    class SocketRunnable implements Runnable {
-
-        // Format of sent messages (over the socket):
-        // * Serialized JSON object on a single line (newline-terminated)
-        // * For byte buffers, the binary data then follows
-        //
-        // Format of received messages (from the socket):
-        // * Serialized JSON object on a single line (newline-terminated)
-
-        private Socket mOpenSocket = null;
-        private SocketWriteRunnable mSocketWriteRunnable = null;
-
-        @Override
-        public void run() {
-            Logt.i(TAG, "Socket thread starting");
-            try {
-                mSocket = new ServerSocket(SERVERPORT);
-            } catch (IOException e) {
-                Logt.e(TAG, "Failed to create socket", e);
-            }
-
-            // Create a new thread to handle writes to this socket.
-            mSocketWriteRunnable = new SocketWriteRunnable(null);
-            (new Thread(mSocketWriteRunnable)).start();
-
-            while (!mThreadExitFlag) {
-                // Receive the socket-open request from the host.
-                try {
-                    Logt.i(TAG, "Waiting for client to connect to socket");
-                    mOpenSocket = mSocket.accept();
-                    if (mOpenSocket == null) {
-                        Logt.e(TAG, "Socket connection error");
-                        break;
-                    }
-                    mSocketWriteQueue.clear();
-                    mSocketWriteRunnable.setOpenSocket(mOpenSocket);
-                    Logt.i(TAG, "Socket connected");
-                } catch (IOException e) {
-                    Logt.e(TAG, "Socket open error: ", e);
-                    break;
-                }
-
-                // Process commands over the open socket.
-                while (!mThreadExitFlag) {
-                    try {
-                        BufferedReader input = new BufferedReader(
-                                new InputStreamReader(mOpenSocket.getInputStream()));
-                        if (input == null) {
-                            Logt.e(TAG, "Failed to get socket input stream");
-                            break;
-                        }
-                        String line = input.readLine();
-                        if (line == null) {
-                            Logt.i(TAG, "Socket readline retuned null (host disconnected)");
-                            break;
-                        }
-                        processSocketCommand(line);
-                    } catch (IOException e) {
-                        Logt.e(TAG, "Socket read error: ", e);
-                        break;
-                    } catch (ItsException e) {
-                        Logt.e(TAG, "Script error: ", e);
-                        break;
-                    }
-                }
-
-                // Close socket and go back to waiting for a new connection.
-                try {
-                    synchronized(mSocketWriteDrainLock) {
-                        mSocketWriteQueue.clear();
-                        mOpenSocket.close();
-                        mOpenSocket = null;
-                        Logt.i(TAG, "Socket disconnected");
-                    }
-                } catch (java.io.IOException e) {
-                    Logt.e(TAG, "Exception closing socket");
-                }
-            }
-
-            // It's an overall error state if the code gets here; no recevery.
-            // Try to do some cleanup, but the service probably needs to be restarted.
-            Logt.i(TAG, "Socket server loop exited");
-            mThreadExitFlag = true;
-            try {
-                if (mOpenSocket != null) {
-                    mOpenSocket.close();
-                    mOpenSocket = null;
-                }
-            } catch (java.io.IOException e) {
-                Logt.w(TAG, "Exception closing socket");
-            }
-            try {
-                if (mSocket != null) {
-                    mSocket.close();
-                    mSocket = null;
-                }
-            } catch (java.io.IOException e) {
-                Logt.w(TAG, "Exception closing socket");
-            }
-        }
-
-        public void processSocketCommand(String cmd)
-                throws ItsException {
-            // Each command is a serialized JSON object.
-            try {
-                JSONObject cmdObj = new JSONObject(cmd);
-                if ("open".equals(cmdObj.getString("cmdName"))) {
-                    int cameraId = cmdObj.getInt("cameraId");
-                    openCameraDevice(cameraId);
-                } else if ("close".equals(cmdObj.getString("cmdName"))) {
-                    closeCameraDevice();
-                } else if ("getCameraProperties".equals(cmdObj.getString("cmdName"))) {
-                    doGetProps();
-                } else if ("startSensorEvents".equals(cmdObj.getString("cmdName"))) {
-                    doStartSensorEvents();
-                } else if ("getSensorEvents".equals(cmdObj.getString("cmdName"))) {
-                    doGetSensorEvents();
-                } else if ("do3A".equals(cmdObj.getString("cmdName"))) {
-                    do3A(cmdObj);
-                } else if ("doCapture".equals(cmdObj.getString("cmdName"))) {
-                    doCapture(cmdObj);
-                } else if ("doVibrate".equals(cmdObj.getString("cmdName"))) {
-                    doVibrate(cmdObj);
-                } else {
-                    throw new ItsException("Unknown command: " + cmd);
-                }
-            } catch (org.json.JSONException e) {
-                Logt.e(TAG, "Invalid command: ", e);
-            }
-        }
-
-        public void sendResponse(String tag, String str, JSONObject obj, ByteBuffer bbuf)
-                throws ItsException {
-            try {
-                JSONObject jsonObj = new JSONObject();
-                jsonObj.put("tag", tag);
-                if (str != null) {
-                    jsonObj.put("strValue", str);
-                }
-                if (obj != null) {
-                    jsonObj.put("objValue", obj);
-                }
-                if (bbuf != null) {
-                    jsonObj.put("bufValueSize", bbuf.capacity());
-                }
-                ByteBuffer bstr = ByteBuffer.wrap(
-                        (jsonObj.toString()+"\n").getBytes(Charset.defaultCharset()));
-                synchronized(mSocketWriteEnqueueLock) {
-                    if (bstr != null) {
-                        mSocketWriteQueue.put(bstr);
-                    }
-                    if (bbuf != null) {
-                        mSocketWriteQueue.put(bbuf);
-                    }
-                }
-            } catch (org.json.JSONException e) {
-                throw new ItsException("JSON error: ", e);
-            } catch (java.lang.InterruptedException e) {
-                throw new ItsException("Socket error: ", e);
-            }
-        }
-
-        public void sendResponse(String tag, String str)
-                throws ItsException {
-            sendResponse(tag, str, null, null);
-        }
-
-        public void sendResponse(String tag, JSONObject obj)
-                throws ItsException {
-            sendResponse(tag, null, obj, null);
-        }
-
-        public void sendResponseCaptureBuffer(String tag, ByteBuffer bbuf)
-                throws ItsException {
-            sendResponse(tag, null, null, bbuf);
-        }
-
-        public void sendResponse(LinkedList<MySensorEvent> events)
-                throws ItsException {
-            try {
-                JSONArray accels = new JSONArray();
-                JSONArray mags = new JSONArray();
-                JSONArray gyros = new JSONArray();
-                for (MySensorEvent event : events) {
-                    JSONObject obj = new JSONObject();
-                    obj.put("time", event.timestamp);
-                    obj.put("x", event.values[0]);
-                    obj.put("y", event.values[1]);
-                    obj.put("z", event.values[2]);
-                    if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
-                        accels.put(obj);
-                    } else if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
-                        mags.put(obj);
-                    } else if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
-                        gyros.put(obj);
-                    }
-                }
-                JSONObject obj = new JSONObject();
-                obj.put("accel", accels);
-                obj.put("mag", mags);
-                obj.put("gyro", gyros);
-                sendResponse("sensorEvents", null, obj, null);
-            } catch (org.json.JSONException e) {
-                throw new ItsException("JSON error: ", e);
-            }
-        }
-
-        public void sendResponse(CameraCharacteristics props)
-                throws ItsException {
-            try {
-                Object objs[] = new Object[2];
-                objs[0] = "cameraProperties";
-                objs[1] = props;
-                mSerializerQueue.put(objs);
-            } catch (InterruptedException e) {
-                throw new ItsException("Interrupted: ", e);
-            }
-        }
-
-        public void sendResponseCaptureResult(CameraCharacteristics props,
-                                              CaptureRequest request,
-                                              CaptureResult result,
-                                              ImageReader[] readers)
-                throws ItsException {
-            try {
-                JSONArray jsonSurfaces = new JSONArray();
-                for (int i = 0; i < readers.length; i++) {
-                    JSONObject jsonSurface = new JSONObject();
-                    jsonSurface.put("width", readers[i].getWidth());
-                    jsonSurface.put("height", readers[i].getHeight());
-                    int format = readers[i].getImageFormat();
-                    if (format == ImageFormat.RAW_SENSOR) {
-                        jsonSurface.put("format", "raw");
-                    } else if (format == ImageFormat.RAW10) {
-                        jsonSurface.put("format", "raw10");
-                    } else if (format == ImageFormat.JPEG) {
-                        jsonSurface.put("format", "jpeg");
-                    } else if (format == ImageFormat.YUV_420_888) {
-                        jsonSurface.put("format", "yuv");
-                    } else {
-                        throw new ItsException("Invalid format");
-                    }
-                    jsonSurfaces.put(jsonSurface);
-                }
-
-                Object objs[] = new Object[5];
-                objs[0] = "captureResults";
-                objs[1] = props;
-                objs[2] = request;
-                objs[3] = result;
-                objs[4] = jsonSurfaces;
-                mSerializerQueue.put(objs);
-            } catch (org.json.JSONException e) {
-                throw new ItsException("JSON error: ", e);
-            } catch (InterruptedException e) {
-                throw new ItsException("Interrupted: ", e);
-            }
-        }
-    }
-
-    public ImageReader.OnImageAvailableListener
-            createAvailableListener(final CaptureCallback listener) {
-        return new ImageReader.OnImageAvailableListener() {
-            @Override
-            public void onImageAvailable(ImageReader reader) {
-                Image i = null;
-                try {
-                    i = reader.acquireNextImage();
-                    listener.onCaptureAvailable(i);
-                } finally {
-                    if (i != null) {
-                        i.close();
-                    }
-                }
-            }
-        };
-    }
-
-    private ImageReader.OnImageAvailableListener
-            createAvailableListenerDropper(final CaptureCallback listener) {
-        return new ImageReader.OnImageAvailableListener() {
-            @Override
-            public void onImageAvailable(ImageReader reader) {
-                Image i = reader.acquireNextImage();
-                i.close();
-            }
-        };
-    }
-
-    private void doStartSensorEvents() throws ItsException {
-        synchronized(mEventLock) {
-            mEventsEnabled = true;
-        }
-        mSocketRunnableObj.sendResponse("sensorEventsStarted", "");
-    }
-
-    private void doGetSensorEvents() throws ItsException {
-        synchronized(mEventLock) {
-            mSocketRunnableObj.sendResponse(mEvents);
-            mEvents.clear();
-            mEventsEnabled = false;
-        }
-    }
-
-    private void doGetProps() throws ItsException {
-        mSocketRunnableObj.sendResponse(mCameraCharacteristics);
-    }
-
-    private void prepareCaptureReader(int[] widths, int[] heights, int formats[], int numSurfaces) {
-        if (mCaptureReaders != null) {
-            for (int i = 0; i < mCaptureReaders.length; i++) {
-                if (mCaptureReaders[i] != null) {
-                    mCaptureReaders[i].close();
-                }
-            }
-        }
-        mCaptureReaders = new ImageReader[numSurfaces];
-        for (int i = 0; i < numSurfaces; i++) {
-            mCaptureReaders[i] = ImageReader.newInstance(widths[i], heights[i], formats[i],
-                    MAX_CONCURRENT_READER_BUFFERS);
-        }
-    }
-
-    private void do3A(JSONObject params) throws ItsException {
-        try {
-            // Start a 3A action, and wait for it to converge.
-            // Get the converged values for each "A", and package into JSON result for caller.
-
-            // 3A happens on full-res frames.
-            Size sizes[] = ItsUtils.getYuvOutputSizes(mCameraCharacteristics);
-            int widths[] = new int[1];
-            int heights[] = new int[1];
-            int formats[] = new int[1];
-            widths[0] = sizes[0].getWidth();
-            heights[0] = sizes[0].getHeight();
-            formats[0] = ImageFormat.YUV_420_888;
-            int width = widths[0];
-            int height = heights[0];
-
-            prepareCaptureReader(widths, heights, formats, 1);
-            List<Surface> outputSurfaces = new ArrayList<Surface>(1);
-            outputSurfaces.add(mCaptureReaders[0].getSurface());
-            BlockingSessionCallback sessionListener = new BlockingSessionCallback();
-            mCamera.createCaptureSession(outputSurfaces, sessionListener, mCameraHandler);
-            mSession = sessionListener.waitAndGetSession(TIMEOUT_IDLE_MS);
-
-            // Add a listener that just recycles buffers; they aren't saved anywhere.
-            ImageReader.OnImageAvailableListener readerListener =
-                    createAvailableListenerDropper(mCaptureCallback);
-            mCaptureReaders[0].setOnImageAvailableListener(readerListener, mSaveHandlers[0]);
-
-            // Get the user-specified regions for AE, AWB, AF.
-            // Note that the user specifies normalized [x,y,w,h], which is converted below
-            // to an [x0,y0,x1,y1] region in sensor coords. The capture request region
-            // also has a fifth "weight" element: [x0,y0,x1,y1,w].
-            MeteringRectangle[] regionAE = new MeteringRectangle[]{
-                    new MeteringRectangle(0,0,width,height,1)};
-            MeteringRectangle[] regionAF = new MeteringRectangle[]{
-                    new MeteringRectangle(0,0,width,height,1)};
-            MeteringRectangle[] regionAWB = new MeteringRectangle[]{
-                    new MeteringRectangle(0,0,width,height,1)};
-            if (params.has(REGION_KEY)) {
-                JSONObject regions = params.getJSONObject(REGION_KEY);
-                if (regions.has(REGION_AE_KEY)) {
-                    regionAE = ItsUtils.getJsonWeightedRectsFromArray(
-                            regions.getJSONArray(REGION_AE_KEY), true, width, height);
-                }
-                if (regions.has(REGION_AF_KEY)) {
-                    regionAF = ItsUtils.getJsonWeightedRectsFromArray(
-                            regions.getJSONArray(REGION_AF_KEY), true, width, height);
-                }
-                if (regions.has(REGION_AWB_KEY)) {
-                    regionAWB = ItsUtils.getJsonWeightedRectsFromArray(
-                            regions.getJSONArray(REGION_AWB_KEY), true, width, height);
-                }
-            }
-
-            // If AE or AWB lock is specified, then the 3A will converge first and then lock these
-            // values, waiting until the HAL has reported that the lock was successful.
-            mNeedsLockedAE = params.optBoolean(LOCK_AE_KEY, false);
-            mNeedsLockedAWB = params.optBoolean(LOCK_AWB_KEY, false);
-
-            // By default, AE and AF both get triggered, but the user can optionally override this.
-            // Also, AF won't get triggered if the lens is fixed-focus.
-            boolean doAE = true;
-            boolean doAF = true;
-            if (params.has(TRIGGER_KEY)) {
-                JSONObject triggers = params.getJSONObject(TRIGGER_KEY);
-                if (triggers.has(TRIGGER_AE_KEY)) {
-                    doAE = triggers.getBoolean(TRIGGER_AE_KEY);
-                }
-                if (triggers.has(TRIGGER_AF_KEY)) {
-                    doAF = triggers.getBoolean(TRIGGER_AF_KEY);
-                }
-            }
-            if (doAF && mCameraCharacteristics.get(
-                            CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE) == 0) {
-                // Send a dummy result back for the code that is waiting for this message to see
-                // that AF has converged.
-                Logt.i(TAG, "Ignoring request for AF on fixed-focus camera");
-                mSocketRunnableObj.sendResponse("afResult", "0.0");
-                doAF = false;
-            }
-
-            mInterlock3A.open();
-            mIssuedRequest3A = false;
-            mConvergedAE = false;
-            mConvergedAWB = false;
-            mConvergedAF = false;
-            mLockedAE = false;
-            mLockedAWB = false;
-            long tstart = System.currentTimeMillis();
-            boolean triggeredAE = false;
-            boolean triggeredAF = false;
-
-            Logt.i(TAG, String.format("Initiating 3A: AE:%d, AF:%d, AWB:1, AELOCK:%d, AWBLOCK:%d",
-                    doAE?1:0, doAF?1:0, mNeedsLockedAE?1:0, mNeedsLockedAWB?1:0));
-
-            // Keep issuing capture requests until 3A has converged.
-            while (true) {
-
-                // Block until can take the next 3A frame. Only want one outstanding frame
-                // at a time, to simplify the logic here.
-                if (!mInterlock3A.block(TIMEOUT_3A * 1000) ||
-                        System.currentTimeMillis() - tstart > TIMEOUT_3A * 1000) {
-                    throw new ItsException("3A failed to converge (timeout)");
-                }
-                mInterlock3A.close();
-
-                // If not converged yet, issue another capture request.
-                if (       (doAE && (!triggeredAE || !mConvergedAE))
-                        || !mConvergedAWB
-                        || (doAF && (!triggeredAF || !mConvergedAF))
-                        || (doAE && mNeedsLockedAE && !mLockedAE)
-                        || (mNeedsLockedAWB && !mLockedAWB)) {
-
-                    // Baseline capture request for 3A.
-                    CaptureRequest.Builder req = mCamera.createCaptureRequest(
-                            CameraDevice.TEMPLATE_PREVIEW);
-                    req.set(CaptureRequest.FLASH_MODE, CaptureRequest.FLASH_MODE_OFF);
-                    req.set(CaptureRequest.CONTROL_MODE, CaptureRequest.CONTROL_MODE_AUTO);
-                    req.set(CaptureRequest.CONTROL_CAPTURE_INTENT,
-                            CaptureRequest.CONTROL_CAPTURE_INTENT_PREVIEW);
-                    req.set(CaptureRequest.CONTROL_AE_MODE,
-                            CaptureRequest.CONTROL_AE_MODE_ON);
-                    req.set(CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, 0);
-                    req.set(CaptureRequest.CONTROL_AE_LOCK, false);
-                    req.set(CaptureRequest.CONTROL_AE_REGIONS, regionAE);
-                    req.set(CaptureRequest.CONTROL_AF_MODE,
-                            CaptureRequest.CONTROL_AF_MODE_AUTO);
-                    req.set(CaptureRequest.CONTROL_AF_REGIONS, regionAF);
-                    req.set(CaptureRequest.CONTROL_AWB_MODE,
-                            CaptureRequest.CONTROL_AWB_MODE_AUTO);
-                    req.set(CaptureRequest.CONTROL_AWB_LOCK, false);
-                    req.set(CaptureRequest.CONTROL_AWB_REGIONS, regionAWB);
-
-                    if (mConvergedAE && mNeedsLockedAE) {
-                        req.set(CaptureRequest.CONTROL_AE_LOCK, true);
-                    }
-                    if (mConvergedAWB && mNeedsLockedAWB) {
-                        req.set(CaptureRequest.CONTROL_AWB_LOCK, true);
-                    }
-
-                    // Trigger AE first.
-                    if (doAE && !triggeredAE) {
-                        Logt.i(TAG, "Triggering AE");
-                        req.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,
-                                CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START);
-                        triggeredAE = true;
-                    }
-
-                    // After AE has converged, trigger AF.
-                    if (doAF && !triggeredAF && (!doAE || (triggeredAE && mConvergedAE))) {
-                        Logt.i(TAG, "Triggering AF");
-                        req.set(CaptureRequest.CONTROL_AF_TRIGGER,
-                                CaptureRequest.CONTROL_AF_TRIGGER_START);
-                        triggeredAF = true;
-                    }
-
-                    req.addTarget(mCaptureReaders[0].getSurface());
-
-                    mIssuedRequest3A = true;
-                    mSession.capture(req.build(), mCaptureResultListener, mResultHandler);
-                } else {
-                    mSocketRunnableObj.sendResponse("3aConverged", "");
-                    Logt.i(TAG, "3A converged");
-                    break;
-                }
-            }
-        } catch (android.hardware.camera2.CameraAccessException e) {
-            throw new ItsException("Access error: ", e);
-        } catch (org.json.JSONException e) {
-            throw new ItsException("JSON error: ", e);
-        } finally {
-            mSocketRunnableObj.sendResponse("3aDone", "");
-        }
-    }
-
-    private void doVibrate(JSONObject params) throws ItsException {
-        try {
-            if (mVibrator == null) {
-                throw new ItsException("Unable to start vibrator");
-            }
-            JSONArray patternArray = params.getJSONArray(VIB_PATTERN_KEY);
-            int len = patternArray.length();
-            long pattern[] = new long[len];
-            for (int i = 0; i < len; i++) {
-                pattern[i] = patternArray.getLong(i);
-            }
-            Logt.i(TAG, String.format("Starting vibrator, pattern length %d",len));
-            mVibrator.vibrate(pattern, -1);
-            mSocketRunnableObj.sendResponse("vibrationStarted", "");
-        } catch (org.json.JSONException e) {
-            throw new ItsException("JSON error: ", e);
-        }
-    }
-
-    private void doCapture(JSONObject params) throws ItsException {
-        try {
-            // Parse the JSON to get the list of capture requests.
-            List<CaptureRequest.Builder> requests = ItsSerializer.deserializeRequestList(
-                    mCamera, params);
-
-            // Set the output surface(s) and listeners.
-            int widths[] = new int[MAX_NUM_OUTPUT_SURFACES];
-            int heights[] = new int[MAX_NUM_OUTPUT_SURFACES];
-            int formats[] = new int[MAX_NUM_OUTPUT_SURFACES];
-            int numSurfaces = 0;
-            try {
-                mCountRawOrDng.set(0);
-                mCountJpg.set(0);
-                mCountYuv.set(0);
-                mCountRaw10.set(0);
-                mCountCapRes.set(0);
-                mCaptureRawIsDng = false;
-                mCaptureResults = new CaptureResult[requests.size()];
-
-                JSONArray jsonOutputSpecs = ItsUtils.getOutputSpecs(params);
-                if (jsonOutputSpecs != null) {
-                    numSurfaces = jsonOutputSpecs.length();
-                    if (numSurfaces > MAX_NUM_OUTPUT_SURFACES) {
-                        throw new ItsException("Too many output surfaces");
-                    }
-                    for (int i = 0; i < numSurfaces; i++) {
-                        // Get the specified surface.
-                        JSONObject surfaceObj = jsonOutputSpecs.getJSONObject(i);
-                        String sformat = surfaceObj.optString("format");
-                        Size sizes[];
-                        if ("yuv".equals(sformat) || "".equals(sformat)) {
-                            // Default to YUV if no format is specified.
-                            formats[i] = ImageFormat.YUV_420_888;
-                            sizes = ItsUtils.getYuvOutputSizes(mCameraCharacteristics);
-                        } else if ("jpg".equals(sformat) || "jpeg".equals(sformat)) {
-                            formats[i] = ImageFormat.JPEG;
-                            sizes = ItsUtils.getJpegOutputSizes(mCameraCharacteristics);
-                        } else if ("raw".equals(sformat)) {
-                            formats[i] = ImageFormat.RAW_SENSOR;
-                            sizes = ItsUtils.getRawOutputSizes(mCameraCharacteristics);
-                        } else if ("raw10".equals(sformat)) {
-                            formats[i] = ImageFormat.RAW10;
-                            sizes = ItsUtils.getRawOutputSizes(mCameraCharacteristics);
-                        } else if ("dng".equals(sformat)) {
-                            formats[i] = ImageFormat.RAW_SENSOR;
-                            sizes = ItsUtils.getRawOutputSizes(mCameraCharacteristics);
-                            mCaptureRawIsDng = true;
-                        } else {
-                            throw new ItsException("Unsupported format: " + sformat);
-                        }
-                        // If the size is omitted, then default to the largest allowed size for the
-                        // format.
-                        widths[i] = surfaceObj.optInt("width");
-                        heights[i] = surfaceObj.optInt("height");
-                        if (widths[i] <= 0) {
-                            if (sizes == null || sizes.length == 0) {
-                                throw new ItsException(String.format(
-                                        "Zero stream configs available for requested format: %s",
-                                        sformat));
-                            }
-                            widths[i] = sizes[0].getWidth();
-                        }
-                        if (heights[i] <= 0) {
-                            heights[i] = sizes[0].getHeight();
-                        }
-                    }
-                } else {
-                    // No surface(s) specified at all.
-                    // Default: a single output surface which is full-res YUV.
-                    Size sizes[] =
-                            ItsUtils.getYuvOutputSizes(mCameraCharacteristics);
-                    numSurfaces = 1;
-                    widths[0] = sizes[0].getWidth();
-                    heights[0] = sizes[0].getHeight();
-                    formats[0] = ImageFormat.YUV_420_888;
-                }
-
-                prepareCaptureReader(widths, heights, formats, numSurfaces);
-                List<Surface> outputSurfaces = new ArrayList<Surface>(numSurfaces);
-                for (int i = 0; i < numSurfaces; i++) {
-                    outputSurfaces.add(mCaptureReaders[i].getSurface());
-                }
-                BlockingSessionCallback sessionListener = new BlockingSessionCallback();
-                mCamera.createCaptureSession(outputSurfaces, sessionListener, mCameraHandler);
-                mSession = sessionListener.waitAndGetSession(TIMEOUT_IDLE_MS);
-
-                for (int i = 0; i < numSurfaces; i++) {
-                    ImageReader.OnImageAvailableListener readerListener =
-                            createAvailableListener(mCaptureCallback);
-                    mCaptureReaders[i].setOnImageAvailableListener(readerListener,mSaveHandlers[i]);
-                }
-
-                // Plan for how many callbacks need to be received throughout the duration of this
-                // sequence of capture requests. There is one callback per image surface, and one
-                // callback for the CaptureResult, for each capture.
-                int numCaptures = requests.size();
-                mCountCallbacksRemaining.set(numCaptures * (numSurfaces + 1));
-
-            } catch (CameraAccessException e) {
-                throw new ItsException("Error configuring outputs", e);
-            } catch (org.json.JSONException e) {
-                throw new ItsException("JSON error", e);
-            }
-
-            // Initiate the captures.
-            for (int i = 0; i < requests.size(); i++) {
-                // For DNG captures, need the LSC map to be available.
-                if (mCaptureRawIsDng) {
-                    requests.get(i).set(CaptureRequest.STATISTICS_LENS_SHADING_MAP_MODE, 1);
-                }
-
-                CaptureRequest.Builder req = requests.get(i);
-                for (int j = 0; j < numSurfaces; j++) {
-                    req.addTarget(mCaptureReaders[j].getSurface());
-                }
-                mSession.capture(req.build(), mCaptureResultListener, mResultHandler);
-            }
-
-            // Make sure all callbacks have been hit (wait until captures are done).
-            // If no timeouts are received after a timeout, then fail.
-            int currentCount = mCountCallbacksRemaining.get();
-            while (currentCount > 0) {
-                try {
-                    Thread.sleep(TIMEOUT_CALLBACK*1000);
-                } catch (InterruptedException e) {
-                    throw new ItsException("Timeout failure", e);
-                }
-                int newCount = mCountCallbacksRemaining.get();
-                if (newCount == currentCount) {
-                    throw new ItsException(
-                            "No callback received within timeout");
-                }
-                currentCount = newCount;
-            }
-        } catch (android.hardware.camera2.CameraAccessException e) {
-            throw new ItsException("Access error: ", e);
-        }
-    }
-
-    @Override
-    public final void onSensorChanged(SensorEvent event) {
-        synchronized(mEventLock) {
-            if (mEventsEnabled) {
-                MySensorEvent ev2 = new MySensorEvent();
-                ev2.sensor = event.sensor;
-                ev2.accuracy = event.accuracy;
-                ev2.timestamp = event.timestamp;
-                ev2.values = new float[event.values.length];
-                System.arraycopy(event.values, 0, ev2.values, 0, event.values.length);
-                mEvents.add(ev2);
-            }
-        }
-    }
-
-    @Override
-    public final void onAccuracyChanged(Sensor sensor, int accuracy) {
-    }
-
-    private final CaptureCallback mCaptureCallback = new CaptureCallback() {
-        @Override
-        public void onCaptureAvailable(Image capture) {
-            try {
-                int format = capture.getFormat();
-                if (format == ImageFormat.JPEG) {
-                    Logt.i(TAG, "Received JPEG capture");
-                    byte[] img = ItsUtils.getDataFromImage(capture);
-                    ByteBuffer buf = ByteBuffer.wrap(img);
-                    int count = mCountJpg.getAndIncrement();
-                    mSocketRunnableObj.sendResponseCaptureBuffer("jpegImage", buf);
-                } else if (format == ImageFormat.YUV_420_888) {
-                    Logt.i(TAG, "Received YUV capture");
-                    byte[] img = ItsUtils.getDataFromImage(capture);
-                    ByteBuffer buf = ByteBuffer.wrap(img);
-                    int count = mCountYuv.getAndIncrement();
-                    mSocketRunnableObj.sendResponseCaptureBuffer("yuvImage", buf);
-                } else if (format == ImageFormat.RAW10) {
-                    Logt.i(TAG, "Received RAW10 capture");
-                    byte[] img = ItsUtils.getDataFromImage(capture);
-                    ByteBuffer buf = ByteBuffer.wrap(img);
-                    int count = mCountRaw10.getAndIncrement();
-                    mSocketRunnableObj.sendResponseCaptureBuffer("raw10Image", buf);
-                } else if (format == ImageFormat.RAW_SENSOR) {
-                    Logt.i(TAG, "Received RAW16 capture");
-                    int count = mCountRawOrDng.getAndIncrement();
-                    if (! mCaptureRawIsDng) {
-                        byte[] img = ItsUtils.getDataFromImage(capture);
-                        ByteBuffer buf = ByteBuffer.wrap(img);
-                        mSocketRunnableObj.sendResponseCaptureBuffer("rawImage", buf);
-                    } else {
-                        // Wait until the corresponding capture result is ready, up to a timeout.
-                        long t0 = android.os.SystemClock.elapsedRealtime();
-                        while (! mThreadExitFlag
-                                && android.os.SystemClock.elapsedRealtime()-t0 < TIMEOUT_CAP_RES) {
-                            if (mCaptureResults[count] != null) {
-                                Logt.i(TAG, "Writing capture as DNG");
-                                DngCreator dngCreator = new DngCreator(
-                                        mCameraCharacteristics, mCaptureResults[count]);
-                                ByteArrayOutputStream dngStream = new ByteArrayOutputStream();
-                                dngCreator.writeImage(dngStream, capture);
-                                byte[] dngArray = dngStream.toByteArray();
-                                ByteBuffer dngBuf = ByteBuffer.wrap(dngArray);
-                                mSocketRunnableObj.sendResponseCaptureBuffer("dngImage", dngBuf);
-                                break;
-                            } else {
-                                Thread.sleep(1);
-                            }
-                        }
-                    }
-                } else {
-                    throw new ItsException("Unsupported image format: " + format);
-                }
-                mCountCallbacksRemaining.decrementAndGet();
-            } catch (IOException e) {
-                Logt.e(TAG, "Script error: ", e);
-            } catch (InterruptedException e) {
-                Logt.e(TAG, "Script error: ", e);
-            } catch (ItsException e) {
-                Logt.e(TAG, "Script error: ", e);
-            }
-        }
-    };
-
-    private static float r2f(Rational r) {
-        return (float)r.getNumerator() / (float)r.getDenominator();
-    }
-
-    private final CaptureResultListener mCaptureResultListener = new CaptureResultListener() {
-        @Override
-        public void onCaptureStarted(CameraCaptureSession session, CaptureRequest request,
-                long timestamp, long frameNumber) {
-        }
-
-        @Override
-        public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request,
-                TotalCaptureResult result) {
-            try {
-                // Currently result has all 0 values.
-                if (request == null || result == null) {
-                    throw new ItsException("Request/result is invalid");
-                }
-
-                StringBuilder logMsg = new StringBuilder();
-                logMsg.append(String.format(
-                        "Capt result: AE=%d, AF=%d, AWB=%d, sens=%d, exp=%.1fms, dur=%.1fms, ",
-                        result.get(CaptureResult.CONTROL_AE_STATE),
-                        result.get(CaptureResult.CONTROL_AF_STATE),
-                        result.get(CaptureResult.CONTROL_AWB_STATE),
-                        result.get(CaptureResult.SENSOR_SENSITIVITY),
-                        result.get(CaptureResult.SENSOR_EXPOSURE_TIME).intValue() / 1000000.0f,
-                        result.get(CaptureResult.SENSOR_FRAME_DURATION).intValue() / 1000000.0f));
-                if (result.get(CaptureResult.COLOR_CORRECTION_GAINS) != null) {
-                    logMsg.append(String.format(
-                            "gains=[%.1f, %.1f, %.1f, %.1f], ",
-                            result.get(CaptureResult.COLOR_CORRECTION_GAINS).getRed(),
-                            result.get(CaptureResult.COLOR_CORRECTION_GAINS).getGreenEven(),
-                            result.get(CaptureResult.COLOR_CORRECTION_GAINS).getGreenOdd(),
-                            result.get(CaptureResult.COLOR_CORRECTION_GAINS).getBlue()));
-                } else {
-                    logMsg.append("gains=[], ");
-                }
-                if (result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM) != null) {
-                    logMsg.append(String.format(
-                            "xform=[%.1f, %.1f, %.1f, %.1f, %.1f, %.1f, %.1f, %.1f, %.1f], ",
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(0,0)),
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(1,0)),
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(2,0)),
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(0,1)),
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(1,1)),
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(2,1)),
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(0,2)),
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(1,2)),
-                            r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(2,2))));
-                } else {
-                    logMsg.append("xform=[], ");
-                }
-                logMsg.append(String.format(
-                        "foc=%.1f",
-                        result.get(CaptureResult.LENS_FOCUS_DISTANCE)));
-                Logt.i(TAG, logMsg.toString());
-
-                if (result.get(CaptureResult.CONTROL_AE_STATE) != null) {
-                    mConvergedAE = result.get(CaptureResult.CONTROL_AE_STATE) ==
-                                              CaptureResult.CONTROL_AE_STATE_CONVERGED ||
-                                   result.get(CaptureResult.CONTROL_AE_STATE) ==
-                                              CaptureResult.CONTROL_AE_STATE_FLASH_REQUIRED ||
-                                   result.get(CaptureResult.CONTROL_AE_STATE) ==
-                                              CaptureResult.CONTROL_AE_STATE_LOCKED;
-                    mLockedAE = result.get(CaptureResult.CONTROL_AE_STATE) ==
-                                           CaptureResult.CONTROL_AE_STATE_LOCKED;
-                }
-                if (result.get(CaptureResult.CONTROL_AF_STATE) != null) {
-                    mConvergedAF = result.get(CaptureResult.CONTROL_AF_STATE) ==
-                                              CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED;
-                }
-                if (result.get(CaptureResult.CONTROL_AWB_STATE) != null) {
-                    mConvergedAWB = result.get(CaptureResult.CONTROL_AWB_STATE) ==
-                                               CaptureResult.CONTROL_AWB_STATE_CONVERGED ||
-                                    result.get(CaptureResult.CONTROL_AWB_STATE) ==
-                                               CaptureResult.CONTROL_AWB_STATE_LOCKED;
-                    mLockedAWB = result.get(CaptureResult.CONTROL_AWB_STATE) ==
-                                            CaptureResult.CONTROL_AWB_STATE_LOCKED;
-                }
-
-                if (mConvergedAE && (!mNeedsLockedAE || mLockedAE)) {
-                    if (result.get(CaptureResult.SENSOR_SENSITIVITY) != null
-                            && result.get(CaptureResult.SENSOR_EXPOSURE_TIME) != null) {
-                        mSocketRunnableObj.sendResponse("aeResult", String.format("%d %d",
-                                result.get(CaptureResult.SENSOR_SENSITIVITY).intValue(),
-                                result.get(CaptureResult.SENSOR_EXPOSURE_TIME).intValue()
-                                ));
-                    } else {
-                        Logt.i(TAG, String.format(
-                                "AE converged but NULL exposure values, sensitivity:%b, expTime:%b",
-                                result.get(CaptureResult.SENSOR_SENSITIVITY) == null,
-                                result.get(CaptureResult.SENSOR_EXPOSURE_TIME) == null));
-                    }
-                }
-
-                if (mConvergedAF) {
-                    if (result.get(CaptureResult.LENS_FOCUS_DISTANCE) != null) {
-                        mSocketRunnableObj.sendResponse("afResult", String.format("%f",
-                                result.get(CaptureResult.LENS_FOCUS_DISTANCE)
-                                ));
-                    } else {
-                        Logt.i(TAG, "AF converged but NULL focus distance values");
-                    }
-                }
-
-                if (mConvergedAWB && (!mNeedsLockedAWB || mLockedAWB)) {
-                    if (result.get(CaptureResult.COLOR_CORRECTION_GAINS) != null
-                            && result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM) != null) {
-                        mSocketRunnableObj.sendResponse("awbResult", String.format(
-                                "%f %f %f %f %f %f %f %f %f %f %f %f %f",
-                                result.get(CaptureResult.COLOR_CORRECTION_GAINS).getRed(),
-                                result.get(CaptureResult.COLOR_CORRECTION_GAINS).getGreenEven(),
-                                result.get(CaptureResult.COLOR_CORRECTION_GAINS).getGreenOdd(),
-                                result.get(CaptureResult.COLOR_CORRECTION_GAINS).getBlue(),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(0,0)),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(1,0)),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(2,0)),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(0,1)),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(1,1)),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(2,1)),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(0,2)),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(1,2)),
-                                r2f(result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM).getElement(2,2))
-                                ));
-                    } else {
-                        Logt.i(TAG, String.format(
-                                "AWB converged but NULL color correction values, gains:%b, ccm:%b",
-                                result.get(CaptureResult.COLOR_CORRECTION_GAINS) == null,
-                                result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM) == null));
-                    }
-                }
-
-                if (mIssuedRequest3A) {
-                    mIssuedRequest3A = false;
-                    mInterlock3A.open();
-                } else {
-                    int count = mCountCapRes.getAndIncrement();
-                    mCaptureResults[count] = result;
-                    mSocketRunnableObj.sendResponseCaptureResult(mCameraCharacteristics,
-                            request, result, mCaptureReaders);
-                    mCountCallbacksRemaining.decrementAndGet();
-                }
-            } catch (ItsException e) {
-                Logt.e(TAG, "Script error: ", e);
-            } catch (Exception e) {
-                Logt.e(TAG, "Script error: ", e);
-            }
-        }
-
-        @Override
-        public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request,
-                CaptureFailure failure) {
-            Logt.e(TAG, "Script error: capture failed");
-        }
-    };
-}
diff --git a/apps/CameraITS/service/src/com/android/camera2/its/ItsUtils.java b/apps/CameraITS/service/src/com/android/camera2/its/ItsUtils.java
deleted file mode 100644
index 8d330cf..0000000
--- a/apps/CameraITS/service/src/com/android/camera2/its/ItsUtils.java
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.camera2.its;
-
-import android.content.Context;
-import android.graphics.ImageFormat;
-import android.hardware.camera2.CameraDevice;
-import android.hardware.camera2.CameraCharacteristics;
-import android.hardware.camera2.CaptureRequest;
-import android.hardware.camera2.CaptureResult;
-import android.hardware.camera2.params.MeteringRectangle;
-import android.hardware.camera2.params.StreamConfigurationMap;
-import android.media.Image;
-import android.media.Image.Plane;
-import android.net.Uri;
-import android.os.Environment;
-import android.util.Log;
-import android.util.Size;
-
-import org.json.JSONArray;
-import org.json.JSONObject;
-
-import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.List;
-
-public class ItsUtils {
-    public static final String TAG = ItsUtils.class.getSimpleName();
-
-    public static ByteBuffer jsonToByteBuffer(JSONObject jsonObj) {
-        return ByteBuffer.wrap(jsonObj.toString().getBytes(Charset.defaultCharset()));
-    }
-
-    public static MeteringRectangle[] getJsonWeightedRectsFromArray(
-            JSONArray a, boolean normalized, int width, int height)
-            throws ItsException {
-        try {
-            // Returns [x0,y0,x1,y1,wgt,  x0,y0,x1,y1,wgt,  x0,y0,x1,y1,wgt,  ...]
-            assert(a.length() % 5 == 0);
-            MeteringRectangle[] ma = new MeteringRectangle[a.length() / 5];
-            for (int i = 0; i < a.length(); i += 5) {
-                int x,y,w,h;
-                if (normalized) {
-                    x = (int)Math.floor(a.getDouble(i+0) * width + 0.5f);
-                    y = (int)Math.floor(a.getDouble(i+1) * height + 0.5f);
-                    w = (int)Math.floor(a.getDouble(i+2) * width + 0.5f);
-                    h = (int)Math.floor(a.getDouble(i+3) * height + 0.5f);
-                } else {
-                    x = a.getInt(i+0);
-                    y = a.getInt(i+1);
-                    w = a.getInt(i+2);
-                    h = a.getInt(i+3);
-                }
-                x = Math.max(x, 0);
-                y = Math.max(y, 0);
-                w = Math.min(w, width-x);
-                h = Math.min(h, height-y);
-                int wgt = a.getInt(i+4);
-                ma[i/5] = new MeteringRectangle(x,y,w,h,wgt);
-            }
-            return ma;
-        } catch (org.json.JSONException e) {
-            throw new ItsException("JSON error: ", e);
-        }
-    }
-
-    public static JSONArray getOutputSpecs(JSONObject jsonObjTop)
-            throws ItsException {
-        try {
-            if (jsonObjTop.has("outputSurfaces")) {
-                return jsonObjTop.getJSONArray("outputSurfaces");
-            }
-            return null;
-        } catch (org.json.JSONException e) {
-            throw new ItsException("JSON error: ", e);
-        }
-    }
-
-    public static Size[] getRawOutputSizes(CameraCharacteristics ccs)
-            throws ItsException {
-        return getOutputSizes(ccs, ImageFormat.RAW_SENSOR);
-    }
-
-    public static Size[] getJpegOutputSizes(CameraCharacteristics ccs)
-            throws ItsException {
-        return getOutputSizes(ccs, ImageFormat.JPEG);
-    }
-
-    public static Size[] getYuvOutputSizes(CameraCharacteristics ccs)
-            throws ItsException {
-        return getOutputSizes(ccs, ImageFormat.YUV_420_888);
-    }
-
-    private static Size[] getOutputSizes(CameraCharacteristics ccs, int format)
-            throws ItsException {
-        StreamConfigurationMap configMap = ccs.get(
-                CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
-        if (configMap == null) {
-            throw new ItsException("Failed to get stream config");
-        }
-        return configMap.getOutputSizes(format);
-    }
-
-    public static byte[] getDataFromImage(Image image)
-            throws ItsException {
-        int format = image.getFormat();
-        int width = image.getWidth();
-        int height = image.getHeight();
-        byte[] data = null;
-
-        // Read image data
-        Plane[] planes = image.getPlanes();
-
-        // Check image validity
-        if (!checkAndroidImageFormat(image)) {
-            throw new ItsException(
-                    "Invalid image format passed to getDataFromImage: " + image.getFormat());
-        }
-
-        if (format == ImageFormat.JPEG) {
-            // JPEG doesn't have pixelstride and rowstride, treat it as 1D buffer.
-            ByteBuffer buffer = planes[0].getBuffer();
-            data = new byte[buffer.capacity()];
-            buffer.get(data);
-            return data;
-        } else if (format == ImageFormat.YUV_420_888 || format == ImageFormat.RAW_SENSOR
-                || format == ImageFormat.RAW10) {
-            int offset = 0;
-            data = new byte[width * height * ImageFormat.getBitsPerPixel(format) / 8];
-            byte[] rowData = new byte[planes[0].getRowStride()];
-            for (int i = 0; i < planes.length; i++) {
-                ByteBuffer buffer = planes[i].getBuffer();
-                int rowStride = planes[i].getRowStride();
-                int pixelStride = planes[i].getPixelStride();
-                int bytesPerPixel = ImageFormat.getBitsPerPixel(format) / 8;
-                Logt.i(TAG, String.format(
-                        "Reading image: fmt %d, plane %d, w %d, h %d, rowStride %d, pixStride %d",
-                        format, i, width, height, rowStride, pixelStride));
-                // For multi-planar yuv images, assuming yuv420 with 2x2 chroma subsampling.
-                int w = (i == 0) ? width : width / 2;
-                int h = (i == 0) ? height : height / 2;
-                for (int row = 0; row < h; row++) {
-                    if (pixelStride == bytesPerPixel) {
-                        // Special case: optimized read of the entire row
-                        int length = w * bytesPerPixel;
-                        buffer.get(data, offset, length);
-                        // Advance buffer the remainder of the row stride
-                        buffer.position(buffer.position() + rowStride - length);
-                        offset += length;
-                    } else {
-                        // Generic case: should work for any pixelStride but slower.
-                        // Use intermediate buffer to avoid read byte-by-byte from
-                        // DirectByteBuffer, which is very bad for performance.
-                        // Also need avoid access out of bound by only reading the available
-                        // bytes in the bytebuffer.
-                        int readSize = rowStride;
-                        if (buffer.remaining() < readSize) {
-                            readSize = buffer.remaining();
-                        }
-                        buffer.get(rowData, 0, readSize);
-                        if (pixelStride >= 1) {
-                            for (int col = 0; col < w; col++) {
-                                data[offset++] = rowData[col * pixelStride];
-                            }
-                        } else {
-                            // PixelStride of 0 can mean pixel isn't a multiple of 8 bits, for
-                            // example with RAW10. Just copy the buffer, dropping any padding at
-                            // the end of the row.
-                            int length = (w * ImageFormat.getBitsPerPixel(format)) / 8;
-                            System.arraycopy(rowData,0,data,offset,length);
-                            offset += length;
-                        }
-                    }
-                }
-            }
-            Logt.i(TAG, String.format("Done reading image, format %d", format));
-            return data;
-        } else {
-            throw new ItsException("Unsupported image format: " + format);
-        }
-    }
-
-    private static boolean checkAndroidImageFormat(Image image) {
-        int format = image.getFormat();
-        Plane[] planes = image.getPlanes();
-        switch (format) {
-            case ImageFormat.YUV_420_888:
-            case ImageFormat.NV21:
-            case ImageFormat.YV12:
-                return 3 == planes.length;
-            case ImageFormat.RAW_SENSOR:
-            case ImageFormat.RAW10:
-            case ImageFormat.JPEG:
-                return 1 == planes.length;
-            default:
-                return false;
-        }
-    }
-}
-
diff --git a/apps/CameraITS/service/src/com/android/camera2/its/Logt.java b/apps/CameraITS/service/src/com/android/camera2/its/Logt.java
deleted file mode 100644
index 2fc5399..0000000
--- a/apps/CameraITS/service/src/com/android/camera2/its/Logt.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.camera2.its;
-
-import android.util.Log;
-
-public class Logt {
-    public static void i(String tag, String msg) {
-        long t = android.os.SystemClock.elapsedRealtime();
-        Log.i(tag, String.format("[%d] %s", t, msg));
-    }
-    public static void e(String tag, String msg) {
-        long t = android.os.SystemClock.elapsedRealtime();
-        Log.e(tag, String.format("[%d] %s", t, msg));
-    }
-    public static void w(String tag, String msg) {
-        long t = android.os.SystemClock.elapsedRealtime();
-        Log.w(tag, String.format("[%d] %s", t, msg));
-    }
-    public static void e(String tag, String msg, Throwable tr) {
-        long t = android.os.SystemClock.elapsedRealtime();
-        Log.e(tag, String.format("[%d] %s", t, msg), tr);
-    }
-}
-
diff --git a/apps/CameraITS/tests/inprog/scene2/README b/apps/CameraITS/tests/inprog/scene2/README
deleted file mode 100644
index 3a0953f..0000000
--- a/apps/CameraITS/tests/inprog/scene2/README
+++ /dev/null
@@ -1,8 +0,0 @@
-Scene 2 requires a camera lab with controlled illuminants, for example
-light sources capable of producing D65, D50, A, TL84, etc. illumination.
-Specific charts may also be required, for example grey cards, color
-checker charts, and resolution charts. The individual tests will specify
-the setup that they require.
-
-If a test requires that the camera be in any particular orientaion, it will
-specify this too. Otherwise, the camara can be in either portrait or lanscape.
diff --git a/apps/CameraITS/tests/inprog/scene2/test_dng_tags.py b/apps/CameraITS/tests/inprog/scene2/test_dng_tags.py
deleted file mode 100644
index 0c96ca7..0000000
--- a/apps/CameraITS/tests/inprog/scene2/test_dng_tags.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.dng
-import its.objects
-import numpy
-import os.path
-
-def main():
-    """Test that the DNG tags are internally self-consistent.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-
-        # Assumes that illuminant 1 is D65, and illuminant 2 is standard A.
-        # TODO: Generalize DNG tags check for any provided illuminants.
-        illum_code = [21, 17] # D65, A
-        illum_str = ['D65', 'A']
-        ref_str = ['android.sensor.referenceIlluminant%d'%(i) for i in [1,2]]
-        cm_str = ['android.sensor.colorTransform%d'%(i) for i in [1,2]]
-        fm_str = ['android.sensor.forwardMatrix%d'%(i) for i in [1,2]]
-        cal_str = ['android.sensor.calibrationTransform%d'%(i) for i in [1,2]]
-        dng_illum = [its.dng.D65, its.dng.A]
-
-        for i in [0,1]:
-            assert(props[ref_str[i]] == illum_code[i])
-            raw_input("\n[Point camera at grey card under %s and press ENTER]"%(
-                    illum_str[i]))
-
-            cam.do_3a(do_af=False)
-            cap = cam.do_capture(its.objects.auto_capture_request())
-            gains = cap["metadata"]["android.colorCorrection.gains"]
-            ccm = its.objects.rational_to_float(
-                    cap["metadata"]["android.colorCorrection.transform"])
-            cal = its.objects.rational_to_float(props[cal_str[i]])
-            print "HAL reported gains:\n", numpy.array(gains)
-            print "HAL reported ccm:\n", numpy.array(ccm).reshape(3,3)
-            print "HAL reported cal:\n", numpy.array(cal).reshape(3,3)
-
-            # Dump the image.
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_%s.jpg" % (NAME, illum_str[i]))
-
-            # Compute the matrices that are expected under this illuminant from
-            # the HAL-reported WB gains, CCM, and calibration matrix.
-            cm, fm = its.dng.compute_cm_fm(dng_illum[i], gains, ccm, cal)
-            asn = its.dng.compute_asn(dng_illum[i], cal, cm)
-            print "Expected ColorMatrix:\n", cm
-            print "Expected ForwardMatrix:\n", fm
-            print "Expected AsShotNeutral:\n", asn
-
-            # Get the matrices that are reported by the HAL for this
-            # illuminant.
-            cm_ref = numpy.array(its.objects.rational_to_float(
-                    props[cm_str[i]])).reshape(3,3)
-            fm_ref = numpy.array(its.objects.rational_to_float(
-                    props[fm_str[i]])).reshape(3,3)
-            asn_ref = numpy.array(its.objects.rational_to_float(
-                    cap['metadata']['android.sensor.neutralColorPoint']))
-            print "Reported ColorMatrix:\n", cm_ref
-            print "Reported ForwardMatrix:\n", fm_ref
-            print "Reported AsShotNeutral:\n", asn_ref
-
-            # The color matrix may be scaled (between the reported and
-            # expected values).
-            cm_scale = cm.mean(1).mean(0) / cm_ref.mean(1).mean(0)
-            print "ColorMatrix scale factor:", cm_scale
-
-            # Compute the deltas between reported and expected.
-            print "Ratios in ColorMatrix:\n", cm / cm_ref
-            print "Deltas in ColorMatrix (after normalizing):\n", cm/cm_scale - cm_ref
-            print "Deltas in ForwardMatrix:\n", fm - fm_ref
-            print "Deltas in AsShotNeutral:\n", asn - asn_ref
-
-            # TODO: Add pass/fail test on DNG matrices.
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_3a_remote.py b/apps/CameraITS/tests/inprog/test_3a_remote.py
deleted file mode 100644
index c76ff6d..0000000
--- a/apps/CameraITS/tests/inprog/test_3a_remote.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import os.path
-import pprint
-import math
-import numpy
-import matplotlib.pyplot
-import mpl_toolkits.mplot3d
-
-def main():
-    """Run 3A remotely (from this script).
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        w_map = props["android.lens.info.shadingMapSize"]["width"]
-        h_map = props["android.lens.info.shadingMapSize"]["height"]
-
-        # TODO: Test for 3A convergence, and exit this test once converged.
-
-        triggered = False
-        while True:
-            req = its.objects.auto_capture_request()
-            req["android.statistics.lensShadingMapMode"] = 1
-            req['android.control.aePrecaptureTrigger'] = (0 if triggered else 1)
-            req['android.control.afTrigger'] = (0 if triggered else 1)
-            triggered = True
-
-            cap = cam.do_capture(req)
-
-            ae_state = cap["metadata"]["android.control.aeState"]
-            awb_state = cap["metadata"]["android.control.awbState"]
-            af_state = cap["metadata"]["android.control.afState"]
-            gains = cap["metadata"]["android.colorCorrection.gains"]
-            transform = cap["metadata"]["android.colorCorrection.transform"]
-            exp_time = cap["metadata"]['android.sensor.exposureTime']
-            lsc_map = cap["metadata"]["android.statistics.lensShadingMap"]
-            foc_dist = cap["metadata"]['android.lens.focusDistance']
-            foc_range = cap["metadata"]['android.lens.focusRange']
-
-            print "States (AE,AWB,AF):", ae_state, awb_state, af_state
-            print "Gains:", gains
-            print "Transform:", [its.objects.rational_to_float(t)
-                                 for t in transform]
-            print "AE region:", cap["metadata"]['android.control.aeRegions']
-            print "AF region:", cap["metadata"]['android.control.afRegions']
-            print "AWB region:", cap["metadata"]['android.control.awbRegions']
-            print "LSC map:", w_map, h_map, lsc_map[:8]
-            print "Focus (dist,range):", foc_dist, foc_range
-            print ""
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_black_level.py b/apps/CameraITS/tests/inprog/test_black_level.py
deleted file mode 100644
index 37dab94..0000000
--- a/apps/CameraITS/tests/inprog/test_black_level.py
+++ /dev/null
@@ -1,99 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-import numpy
-
-def main():
-    """Black level consistence test.
-
-    Test: capture dark frames and check if black level correction is done
-    correctly.
-    1. Black level should be roughly consistent for repeating shots.
-    2. Noise distribution should be roughly centered at black level.
-
-    Shoot with the camera covered (i.e.) dark/black. The test varies the
-    sensitivity parameter.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    NUM_REPEAT = 3
-    NUM_STEPS = 3
-
-    # Only check the center part where LSC has little effects.
-    R = 200
-
-    # The most frequent pixel value in each image; assume this is the black
-    # level, since the images are all dark (shot with the lens covered).
-    ymodes = []
-    umodes = []
-    vmodes = []
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        sens_range = props['android.sensor.info.sensitivityRange']
-        sens_step = (sens_range[1] - sens_range[0]) / float(NUM_STEPS-1)
-        sensitivities = [sens_range[0] + i*sens_step for i in range(NUM_STEPS)]
-        print "Sensitivities:", sensitivities
-
-        for si, s in enumerate(sensitivities):
-            for rep in xrange(NUM_REPEAT):
-                req = its.objects.manual_capture_request(100, 1*1000*1000)
-                req["android.blackLevel.lock"] = True
-                req["android.sensor.sensitivity"] = s
-                cap = cam.do_capture(req)
-                yimg,uimg,vimg = its.image.convert_capture_to_planes(cap)
-                w = cap["width"]
-                h = cap["height"]
-
-                # Magnify the noise in saved images to help visualize.
-                its.image.write_image(yimg * 2,
-                                      "%s_s=%05d_y.jpg" % (NAME, s), True)
-                its.image.write_image(numpy.absolute(uimg - 0.5) * 2,
-                                      "%s_s=%05d_u.jpg" % (NAME, s), True)
-
-                yimg = yimg[w/2-R:w/2+R, h/2-R:h/2+R]
-                uimg = uimg[w/4-R/2:w/4+R/2, w/4-R/2:w/4+R/2]
-                vimg = vimg[w/4-R/2:w/4+R/2, w/4-R/2:w/4+R/2]
-                yhist,_ = numpy.histogram(yimg*255, 256, (0,256))
-                ymodes.append(numpy.argmax(yhist))
-                uhist,_ = numpy.histogram(uimg*255, 256, (0,256))
-                umodes.append(numpy.argmax(uhist))
-                vhist,_ = numpy.histogram(vimg*255, 256, (0,256))
-                vmodes.append(numpy.argmax(vhist))
-
-                # Take 32 bins from Y, U, and V.
-                # Histograms of U and V are cropped at the center of 128.
-                pylab.plot(range(32), yhist.tolist()[0:32], 'rgb'[si])
-                pylab.plot(range(32), uhist.tolist()[112:144], 'rgb'[si]+'--')
-                pylab.plot(range(32), vhist.tolist()[112:144], 'rgb'[si]+'--')
-
-    pylab.xlabel("DN: Y[0:32], U[112:144], V[112:144]")
-    pylab.ylabel("Pixel count")
-    pylab.title("Histograms for different sensitivities")
-    matplotlib.pyplot.savefig("%s_plot_histograms.png" % (NAME))
-
-    print "Y black levels:", ymodes
-    print "U black levels:", umodes
-    print "V black levels:", vmodes
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_blc_lsc.py b/apps/CameraITS/tests/inprog/test_blc_lsc.py
deleted file mode 100644
index ce120a2..0000000
--- a/apps/CameraITS/tests/inprog/test_blc_lsc.py
+++ /dev/null
@@ -1,106 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that BLC and LSC look reasonable.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    r_means_center = []
-    g_means_center = []
-    b_means_center = []
-    r_means_corner = []
-    g_means_corner = []
-    b_means_corner = []
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        expt_range = props['android.sensor.info.exposureTimeRange']
-
-        # Get AE+AWB lock first, so the auto values in the capture result are
-        # populated properly.
-        r = [[0,0,1,1,1]]
-        ae_sen,ae_exp,awb_gains,awb_transform,_ \
-                = cam.do_3a(r,r,r,do_af=False,get_results=True)
-        print "AE:", ae_sen, ae_exp / 1000000.0
-        print "AWB:", awb_gains, awb_transform
-
-        # Set analog gain (sensitivity) to 800
-        ae_exp = ae_exp * ae_sen / 800
-        ae_sen = 800
-
-        # Capture range of exposures from 1/100x to 4x of AE estimate.
-        exposures = [ae_exp*x/100.0 for x in [1]+range(10,401,40)]
-        exposures = [e for e in exposures
-                     if e >= expt_range[0] and e <= expt_range[1]]
-
-        # Convert the transform back to rational.
-        awb_transform_rat = its.objects.float_to_rational(awb_transform)
-
-        # Linear tonemap
-        tmap = sum([[i/63.0,i/63.0] for i in range(64)], [])
-
-        reqs = []
-        for e in exposures:
-            req = its.objects.manual_capture_request(ae_sen,e)
-            req["android.tonemap.mode"] = 0
-            req["android.tonemap.curveRed"] = tmap
-            req["android.tonemap.curveGreen"] = tmap
-            req["android.tonemap.curveBlue"] = tmap
-            req["android.colorCorrection.transform"] = awb_transform_rat
-            req["android.colorCorrection.gains"] = awb_gains
-            reqs.append(req)
-
-        caps = cam.do_capture(reqs)
-        for i,cap in enumerate(caps):
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_i=%d.jpg"%(NAME, i))
-
-            tile_center = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means = its.image.compute_image_means(tile_center)
-            r_means_center.append(rgb_means[0])
-            g_means_center.append(rgb_means[1])
-            b_means_center.append(rgb_means[2])
-
-            tile_corner = its.image.get_image_patch(img, 0.0, 0.0, 0.1, 0.1)
-            rgb_means = its.image.compute_image_means(tile_corner)
-            r_means_corner.append(rgb_means[0])
-            g_means_corner.append(rgb_means[1])
-            b_means_corner.append(rgb_means[2])
-
-    fig = matplotlib.pyplot.figure()
-    pylab.plot(exposures, r_means_center, 'r')
-    pylab.plot(exposures, g_means_center, 'g')
-    pylab.plot(exposures, b_means_center, 'b')
-    pylab.ylim([0,1])
-    matplotlib.pyplot.savefig("%s_plot_means_center.png" % (NAME))
-
-    fig = matplotlib.pyplot.figure()
-    pylab.plot(exposures, r_means_corner, 'r')
-    pylab.plot(exposures, g_means_corner, 'g')
-    pylab.plot(exposures, b_means_corner, 'b')
-    pylab.ylim([0,1])
-    matplotlib.pyplot.savefig("%s_plot_means_corner.png" % (NAME))
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_burst_sameness_auto.py b/apps/CameraITS/tests/inprog/test_burst_sameness_auto.py
deleted file mode 100644
index f3d49be..0000000
--- a/apps/CameraITS/tests/inprog/test_burst_sameness_auto.py
+++ /dev/null
@@ -1,93 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import os.path
-import numpy
-
-def main():
-    """Take long bursts of images and check that they're all identical.
-
-    Assumes a static scene. Can be used to idenfity if there are sporadic
-    frames that are processed differently or have artifacts, or if 3A isn't
-    stable, since this test converges 3A at the start but doesn't lock 3A
-    throughout capture.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    BURST_LEN = 50
-    BURSTS = 5
-    FRAMES = BURST_LEN * BURSTS
-
-    SPREAD_THRESH = 0.03
-
-    with its.device.ItsSession() as cam:
-
-        # Capture at the smallest resolution.
-        props = cam.get_camera_properties()
-        if not its.caps.manual_sensor(props):
-            print "Test skipped"
-            return
-
-        _, fmt = its.objects.get_fastest_manual_capture_settings(props)
-        w,h = fmt["width"], fmt["height"]
-
-        # Converge 3A prior to capture.
-        cam.do_3a(lock_ae=True, lock_awb=True)
-
-        # After 3A has converged, lock AE+AWB for the duration of the test.
-        req = its.objects.auto_capture_request()
-        req["android.blackLevel.lock"] = True
-        req["android.control.awbLock"] = True
-        req["android.control.aeLock"] = True
-
-        # Capture bursts of YUV shots.
-        # Get the mean values of a center patch for each.
-        # Also build a 4D array, which is an array of all RGB images.
-        r_means = []
-        g_means = []
-        b_means = []
-        imgs = numpy.empty([FRAMES,h,w,3])
-        for j in range(BURSTS):
-            caps = cam.do_capture([req]*BURST_LEN, [fmt])
-            for i,cap in enumerate(caps):
-                n = j*BURST_LEN + i
-                imgs[n] = its.image.convert_capture_to_rgb_image(cap)
-                tile = its.image.get_image_patch(imgs[n], 0.45, 0.45, 0.1, 0.1)
-                means = its.image.compute_image_means(tile)
-                r_means.append(means[0])
-                g_means.append(means[1])
-                b_means.append(means[2])
-
-        # Dump all images.
-        print "Dumping images"
-        for i in range(FRAMES):
-            its.image.write_image(imgs[i], "%s_frame%03d.jpg"%(NAME,i))
-
-        # The mean image.
-        img_mean = imgs.mean(0)
-        its.image.write_image(img_mean, "%s_mean.jpg"%(NAME))
-
-        # Pass/fail based on center patch similarity.
-        for means in [r_means, g_means, b_means]:
-            spread = max(means) - min(means)
-            print spread
-            assert(spread < SPREAD_THRESH)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_burst_sameness_fullres_auto.py b/apps/CameraITS/tests/inprog/test_burst_sameness_fullres_auto.py
deleted file mode 100644
index a8d1d45..0000000
--- a/apps/CameraITS/tests/inprog/test_burst_sameness_fullres_auto.py
+++ /dev/null
@@ -1,91 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import os.path
-import numpy
-import pylab
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Take long bursts of images and check that they're all identical.
-
-    Assumes a static scene. Can be used to idenfity if there are sporadic
-    frames that are processed differently or have artifacts, or if 3A isn't
-    stable, since this test converges 3A at the start but doesn't lock 3A
-    throughout capture.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    BURST_LEN = 6
-    BURSTS = 2
-    FRAMES = BURST_LEN * BURSTS
-
-    DELTA_THRESH = 0.1
-
-    with its.device.ItsSession() as cam:
-
-        # Capture at full resolution.
-        props = cam.get_camera_properties()
-        w,h = its.objects.get_available_output_sizes("yuv", props)[0]
-
-        # Converge 3A prior to capture.
-        cam.do_3a(lock_ae=True, lock_awb=True)
-
-        # After 3A has converged, lock AE+AWB for the duration of the test.
-        req = its.objects.auto_capture_request()
-        req["android.blackLevel.lock"] = True
-        req["android.control.awbLock"] = True
-        req["android.control.aeLock"] = True
-
-        # Capture bursts of YUV shots.
-        # Build a 4D array, which is an array of all RGB images after down-
-        # scaling them by a factor of 4x4.
-        imgs = numpy.empty([FRAMES,h/4,w/4,3])
-        for j in range(BURSTS):
-            caps = cam.do_capture([req]*BURST_LEN)
-            for i,cap in enumerate(caps):
-                n = j*BURST_LEN + i
-                imgs[n] = its.image.downscale_image(
-                        its.image.convert_capture_to_rgb_image(cap), 4)
-
-        # Dump all images.
-        print "Dumping images"
-        for i in range(FRAMES):
-            its.image.write_image(imgs[i], "%s_frame%03d.jpg"%(NAME,i))
-
-        # The mean image.
-        img_mean = imgs.mean(0)
-        its.image.write_image(img_mean, "%s_mean.jpg"%(NAME))
-
-        # Compute the deltas of each image from the mean image; this test
-        # passes if none of the deltas are large.
-        print "Computing frame differences"
-        delta_maxes = []
-        for i in range(FRAMES):
-            deltas = (imgs[i] - img_mean).reshape(h*w*3/16)
-            delta_max_pos = numpy.max(deltas)
-            delta_max_neg = numpy.min(deltas)
-            delta_maxes.append(max(abs(delta_max_pos), abs(delta_max_neg)))
-        max_delta_max = max(delta_maxes)
-        print "Frame %d has largest diff %f" % (
-                delta_maxes.index(max_delta_max), max_delta_max)
-        assert(max_delta_max < DELTA_THRESH)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_crop_region.py b/apps/CameraITS/tests/inprog/test_crop_region.py
deleted file mode 100644
index 396603f..0000000
--- a/apps/CameraITS/tests/inprog/test_crop_region.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import its.image
-import its.device
-import its.objects
-
-
-def main():
-    """Takes shots with different sensor crop regions.
-    """
-    name = os.path.basename(__file__).split(".")[0]
-
-    # Regions specified here in x,y,w,h normalized form.
-    regions = [[0.0, 0.0, 0.5, 0.5], # top left
-               [0.0, 0.5, 0.5, 0.5], # bottom left
-               [0.1, 0.9, 0.5, 1.0]] # right side (top + bottom)
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        r = props['android.sensor.info.pixelArraySize']
-        w = r['width']
-        h = r['height']
-
-        # Capture a full frame first.
-        reqs = [its.objects.auto_capture_request()]
-        print "Capturing img0 with the full sensor region"
-
-        # Capture a frame for each of the regions.
-        for i,region in enumerate(regions):
-            req = its.objects.auto_capture_request()
-            req['android.scaler.cropRegion'] = {
-                    "left": int(region[0] * w),
-                    "top": int(region[1] * h),
-                    "right": int((region[0]+region[2])*w),
-                    "bottom": int((region[1]+region[3])*h)}
-            reqs.append(req)
-            crop = req['android.scaler.cropRegion']
-            print "Capturing img%d with crop: %d,%d %dx%d"%(i+1,
-                    crop["left"],crop["top"],
-                    crop["right"]-crop["left"],crop["bottom"]-crop["top"])
-
-        cam.do_3a()
-        caps = cam.do_capture(reqs)
-
-        for i,cap in enumerate(caps):
-            img = its.image.convert_capture_to_rgb_image(cap)
-            crop = cap["metadata"]['android.scaler.cropRegion']
-            its.image.write_image(img, "%s_img%d.jpg"%(name,i))
-            print "Captured img%d with crop: %d,%d %dx%d"%(i,
-                    crop["left"],crop["top"],
-                    crop["right"]-crop["left"],crop["bottom"]-crop["top"])
-
-if __name__ == '__main__':
-    main()
diff --git a/apps/CameraITS/tests/inprog/test_ev_compensation.py b/apps/CameraITS/tests/inprog/test_ev_compensation.py
deleted file mode 100644
index f9b0cd3..0000000
--- a/apps/CameraITS/tests/inprog/test_ev_compensation.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import os.path
-import pylab
-import matplotlib
-import matplotlib.pyplot
-import numpy
-
-def main():
-    """Tests that EV compensation is applied.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    MAX_LUMA_DELTA_THRESH = 0.01
-    AVG_LUMA_DELTA_THRESH = 0.001
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        cam.do_3a()
-
-        # Capture auto shots, but with a linear tonemap.
-        req = its.objects.auto_capture_request()
-        req["android.tonemap.mode"] = 0
-        req["android.tonemap.curveRed"] = (0.0, 0.0, 1.0, 1.0)
-        req["android.tonemap.curveGreen"] = (0.0, 0.0, 1.0, 1.0)
-        req["android.tonemap.curveBlue"] = (0.0, 0.0, 1.0, 1.0)
-
-        evs = range(-4,5)
-        lumas = []
-        for ev in evs:
-            req['android.control.aeExposureCompensation'] = ev
-            cap = cam.do_capture(req)
-            y = its.image.convert_capture_to_planes(cap)[0]
-            tile = its.image.get_image_patch(y, 0.45,0.45,0.1,0.1)
-            lumas.append(its.image.compute_image_means(tile)[0])
-
-        ev_step_size_in_stops = its.objects.rational_to_float(
-                props['android.control.aeCompensationStep'])
-        luma_increase_per_step = pow(2, ev_step_size_in_stops)
-        expected_lumas = [lumas[0] * pow(luma_increase_per_step, i) \
-                for i in range(len(evs))]
-
-        pylab.plot(evs, lumas, 'r')
-        pylab.plot(evs, expected_lumas, 'b')
-        matplotlib.pyplot.savefig("%s_plot_means.png" % (NAME))
-
-        luma_diffs = [expected_lumas[i] - lumas[i] for i in range(len(evs))]
-        max_diff = max(luma_diffs)
-        avg_diff = sum(luma_diffs) / len(luma_diffs)
-        print "Max delta between modeled and measured lumas:", max_diff
-        print "Avg delta between modeled and measured lumas:", avg_diff
-        assert(max_diff < MAX_LUMA_DELTA_THRESH)
-        assert(avg_diff < AVG_LUMA_DELTA_THRESH)
-
-if __name__ == '__main__':
-    main()
diff --git a/apps/CameraITS/tests/inprog/test_faces.py b/apps/CameraITS/tests/inprog/test_faces.py
deleted file mode 100644
index 228dac8..0000000
--- a/apps/CameraITS/tests/inprog/test_faces.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import os.path
-
-def main():
-    """Test face detection.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        cam.do_3a()
-        req = its.objects.auto_capture_request()
-        req['android.statistics.faceDetectMode'] = 2
-        caps = cam.do_capture([req]*5)
-        for i,cap in enumerate(caps):
-            md = cap['metadata']
-            print "Frame %d face metadata:" % i
-            print "  Ids:", md['android.statistics.faceIds']
-            print "  Landmarks:", md['android.statistics.faceLandmarks']
-            print "  Rectangles:", md['android.statistics.faceRectangles']
-            print "  Scores:", md['android.statistics.faceScores']
-            print ""
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_param_black_level_lock.py b/apps/CameraITS/tests/inprog/test_param_black_level_lock.py
deleted file mode 100644
index 7d0be92..0000000
--- a/apps/CameraITS/tests/inprog/test_param_black_level_lock.py
+++ /dev/null
@@ -1,76 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-import numpy
-
-def main():
-    """Test that when the black level is locked, it doesn't change.
-
-    Shoot with the camera covered (i.e.) dark/black. The test varies the
-    sensitivity parameter and checks if the black level changes.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    NUM_STEPS = 5
-
-    req = {
-        "android.blackLevel.lock": True,
-        "android.control.mode": 0,
-        "android.control.aeMode": 0,
-        "android.control.awbMode": 0,
-        "android.control.afMode": 0,
-        "android.sensor.frameDuration": 0,
-        "android.sensor.exposureTime": 10*1000*1000
-        }
-
-    # The most frequent pixel value in each image; assume this is the black
-    # level, since the images are all dark (shot with the lens covered).
-    modes = []
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        sens_range = props['android.sensor.info.sensitivityRange']
-        sensitivities = range(sens_range[0],
-                              sens_range[1]+1,
-                              int((sens_range[1] - sens_range[0]) / NUM_STEPS))
-        for si, s in enumerate(sensitivities):
-            req["android.sensor.sensitivity"] = s
-            cap = cam.do_capture(req)
-            yimg,_,_ = its.image.convert_capture_to_planes(cap)
-            hist,_ = numpy.histogram(yimg*255, 256, (0,256))
-            modes.append(numpy.argmax(hist))
-
-            # Add this histogram to a plot; solid for shots without BL
-            # lock, dashes for shots with BL lock
-            pylab.plot(range(16), hist.tolist()[:16])
-
-    pylab.xlabel("Luma DN, showing [0:16] out of full [0:256] range")
-    pylab.ylabel("Pixel count")
-    pylab.title("Histograms for different sensitivities")
-    matplotlib.pyplot.savefig("%s_plot_histograms.png" % (NAME))
-
-    # Check that the black levels are all the same.
-    print "Black levels:", modes
-    assert(all([modes[i] == modes[0] for i in range(len(modes))]))
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_param_edge_mode.py b/apps/CameraITS/tests/inprog/test_param_edge_mode.py
deleted file mode 100644
index e928f21..0000000
--- a/apps/CameraITS/tests/inprog/test_param_edge_mode.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that the android.edge.mode parameter is applied.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    req = {
-        "android.control.mode": 0,
-        "android.control.aeMode": 0,
-        "android.control.awbMode": 0,
-        "android.control.afMode": 0,
-        "android.sensor.frameDuration": 0,
-        "android.sensor.exposureTime": 30*1000*1000,
-        "android.sensor.sensitivity": 100
-        }
-
-    with its.device.ItsSession() as cam:
-        sens, exp, gains, xform, focus = cam.do_3a(get_results=True)
-        for e in [0,1,2]:
-            req["android.edge.mode"] = e
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_mode=%d.jpg" % (NAME, e))
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/inprog/test_test_patterns.py b/apps/CameraITS/tests/inprog/test_test_patterns.py
deleted file mode 100644
index f75b141..0000000
--- a/apps/CameraITS/tests/inprog/test_test_patterns.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import os.path
-
-def main():
-    """Test sensor test patterns.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        caps = []
-        for i in range(1,6):
-            req = its.objects.manual_capture_request(100, 10*1000*1000)
-            req['android.sensor.testPatternData'] = [40, 100, 160, 220]
-            req['android.sensor.testPatternMode'] = i
-
-            # Capture the shot twice, and use the second one, so the pattern
-            # will have stabilized.
-            caps = cam.do_capture([req]*2)
-
-            img = its.image.convert_capture_to_rgb_image(caps[1])
-            its.image.write_image(img, "%s_pattern=%d.jpg" % (NAME, i))
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene0/README b/apps/CameraITS/tests/scene0/README
deleted file mode 100644
index 50be04a..0000000
--- a/apps/CameraITS/tests/scene0/README
+++ /dev/null
@@ -1,3 +0,0 @@
-This scene has no requirements; scene 0 tests don't actually
-look at the image content, and the camera can be pointed at
-any target (or even flat on the desk).
diff --git a/apps/CameraITS/tests/scene0/test_camera_properties.py b/apps/CameraITS/tests/scene0/test_camera_properties.py
deleted file mode 100644
index 05fc364..0000000
--- a/apps/CameraITS/tests/scene0/test_camera_properties.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.caps
-import its.device
-import its.objects
-import pprint
-
-def main():
-    """Basic test to query and print out camera properties.
-    """
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-
-        pprint.pprint(props)
-
-        # Test that a handful of required keys are present.
-        if its.caps.manual_sensor(props):
-            assert(props.has_key('android.sensor.info.sensitivityRange'))
-
-        assert(props.has_key('android.sensor.orientation'))
-        assert(props.has_key('android.scaler.streamConfigurationMap'))
-        assert(props.has_key('android.lens.facing'))
-
-        print "JPG sizes:", its.objects.get_available_output_sizes("jpg", props)
-        print "RAW sizes:", its.objects.get_available_output_sizes("raw", props)
-        print "YUV sizes:", its.objects.get_available_output_sizes("yuv", props)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene0/test_capture_result_dump.py b/apps/CameraITS/tests/scene0/test_capture_result_dump.py
deleted file mode 100644
index c8b1f8f..0000000
--- a/apps/CameraITS/tests/scene0/test_capture_result_dump.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.caps
-import its.image
-import its.device
-import its.objects
-import its.target
-import pprint
-
-def main():
-    """Test that a capture result is returned from a manual capture; dump it.
-    """
-
-    with its.device.ItsSession() as cam:
-        # Arbitrary capture request exposure values; image content is not
-        # important for this test, only the metadata.
-        props = cam.get_camera_properties()
-        if not its.caps.manual_sensor(props):
-            print "Test skipped"
-            return
-
-        req,fmt = its.objects.get_fastest_manual_capture_settings(props)
-        cap = cam.do_capture(req, fmt)
-        pprint.pprint(cap["metadata"])
-
-        # No pass/fail check; test passes if it completes.
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene0/test_gyro_bias.py b/apps/CameraITS/tests/scene0/test_gyro_bias.py
deleted file mode 100644
index 64a5ff0..0000000
--- a/apps/CameraITS/tests/scene0/test_gyro_bias.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import time
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-import numpy
-
-def main():
-    """Test if the gyro has stable output when device is stationary.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    # Number of samples averaged together, in the plot.
-    N = 20
-
-    # Pass/fail thresholds for gyro drift
-    MEAN_THRESH = 0.01
-    VAR_THRESH = 0.001
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        # Only run test if the appropriate caps are claimed.
-        if not its.caps.sensor_fusion(props):
-            print "Test skipped"
-            return
-
-        print "Collecting gyro events"
-        cam.start_sensor_events()
-        time.sleep(5)
-        gyro_events = cam.get_sensor_events()["gyro"]
-
-    nevents = (len(gyro_events) / N) * N
-    gyro_events = gyro_events[:nevents]
-    times = numpy.array([(e["time"] - gyro_events[0]["time"])/1000000000.0
-                         for e in gyro_events])
-    xs = numpy.array([e["x"] for e in gyro_events])
-    ys = numpy.array([e["y"] for e in gyro_events])
-    zs = numpy.array([e["z"] for e in gyro_events])
-
-    # Group samples into size-N groups and average each together, to get rid
-    # of individual rnadom spikes in the data.
-    times = times[N/2::N]
-    xs = xs.reshape(nevents/N, N).mean(1)
-    ys = ys.reshape(nevents/N, N).mean(1)
-    zs = zs.reshape(nevents/N, N).mean(1)
-
-    pylab.plot(times, xs, 'r', label="x")
-    pylab.plot(times, ys, 'g', label="y")
-    pylab.plot(times, zs, 'b', label="z")
-    pylab.xlabel("Time (seconds)")
-    pylab.ylabel("Gyro readings (mean of %d samples)"%(N))
-    pylab.legend()
-    matplotlib.pyplot.savefig("%s_plot.png" % (NAME))
-
-    for samples in [xs,ys,zs]:
-        assert(samples.mean() < MEAN_THRESH)
-        assert(numpy.var(samples) < VAR_THRESH)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene0/test_jitter.py b/apps/CameraITS/tests/scene0/test_jitter.py
deleted file mode 100644
index 29b3047..0000000
--- a/apps/CameraITS/tests/scene0/test_jitter.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import os.path
-import pylab
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Measure jitter in camera timestamps.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    # Pass/fail thresholds
-    MIN_AVG_FRAME_DELTA = 30 # at least 30ms delta between frames
-    MAX_VAR_FRAME_DELTA = 0.01 # variance of frame deltas
-    MAX_FRAME_DELTA_JITTER = 0.3 # max ms gap from the average frame delta
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.manual_sensor(props):
-            print "Test skipped"
-            return
-
-        req, fmt = its.objects.get_fastest_manual_capture_settings(props)
-        caps = cam.do_capture([req]*50, [fmt])
-
-        # Print out the millisecond delta between the start of each exposure
-        tstamps = [c['metadata']['android.sensor.timestamp'] for c in caps]
-        deltas = [tstamps[i]-tstamps[i-1] for i in range(1,len(tstamps))]
-        deltas_ms = [d/1000000.0 for d in deltas]
-        avg = sum(deltas_ms) / len(deltas_ms)
-        var = sum([d*d for d in deltas_ms]) / len(deltas_ms) - avg * avg
-        range0 = min(deltas_ms) - avg
-        range1 = max(deltas_ms) - avg
-        print "Average:", avg
-        print "Variance:", var
-        print "Jitter range:", range0, "to", range1
-
-        # Draw a plot.
-        pylab.plot(range(len(deltas_ms)), deltas_ms)
-        matplotlib.pyplot.savefig("%s_deltas.png" % (NAME))
-
-        # Test for pass/fail.
-        assert(avg > MIN_AVG_FRAME_DELTA)
-        assert(var < MAX_VAR_FRAME_DELTA)
-        assert(abs(range0) < MAX_FRAME_DELTA_JITTER)
-        assert(abs(range1) < MAX_FRAME_DELTA_JITTER)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene0/test_metadata.py b/apps/CameraITS/tests/scene0/test_metadata.py
deleted file mode 100644
index b4ca4cb..0000000
--- a/apps/CameraITS/tests/scene0/test_metadata.py
+++ /dev/null
@@ -1,98 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import its.target
-import its.caps
-
-def main():
-    """Test the validity of some metadata entries.
-
-    Looks at capture results and at the camera characteristics objects.
-    """
-    global md, props, failed
-
-    with its.device.ItsSession() as cam:
-        # Arbitrary capture request exposure values; image content is not
-        # important for this test, only the metadata.
-        props = cam.get_camera_properties()
-        auto_req = its.objects.auto_capture_request()
-        cap = cam.do_capture(auto_req)
-        md = cap["metadata"]
-
-    print "Hardware level"
-    print "  Legacy:", its.caps.legacy(props)
-    print "  Limited:", its.caps.limited(props)
-    print "  Full:", its.caps.full(props)
-    print "Capabilities"
-    print "  Manual sensor:", its.caps.manual_sensor(props)
-    print "  Manual post-proc:", its.caps.manual_post_proc(props)
-    print "  Raw:", its.caps.raw(props)
-    print "  Sensor fusion:", its.caps.sensor_fusion(props)
-
-    # Test: hardware level should be a valid value.
-    check('props.has_key("android.info.supportedHardwareLevel")')
-    check('props["android.info.supportedHardwareLevel"] is not None')
-    check('props["android.info.supportedHardwareLevel"] in [0,1,2]')
-    full = getval('props["android.info.supportedHardwareLevel"]') == 1
-
-    # Test: rollingShutterSkew, and frameDuration tags must all be present,
-    # and rollingShutterSkew must be greater than zero and smaller than all
-    # of the possible frame durations.
-    check('md.has_key("android.sensor.frameDuration")')
-    check('md["android.sensor.frameDuration"] is not None')
-    check('md.has_key("android.sensor.rollingShutterSkew")')
-    check('md["android.sensor.rollingShutterSkew"] is not None')
-    check('md["android.sensor.frameDuration"] > '
-          'md["android.sensor.rollingShutterSkew"] > 0')
-
-    # Test: timestampSource must be a valid value.
-    check('props.has_key("android.sensor.info.timestampSource")')
-    check('props["android.sensor.info.timestampSource"] is not None')
-    check('props["android.sensor.info.timestampSource"] in [0,1]')
-
-    # Test: croppingType must be a valid value, and for full devices, it
-    # must be FREEFORM=1.
-    check('props.has_key("android.scaler.croppingType")')
-    check('props["android.scaler.croppingType"] is not None')
-    check('props["android.scaler.croppingType"] in [0,1]')
-    if full:
-        check('props["android.scaler.croppingType"] == 1')
-
-    assert(not failed)
-
-def getval(expr, default=None):
-    try:
-        return eval(expr)
-    except:
-        return default
-
-failed = False
-def check(expr):
-    global md, props, failed
-    try:
-        if eval(expr):
-            print "Passed>", expr
-        else:
-            print "Failed>>", expr
-            failed = True
-    except:
-        print "Failed>>", expr
-        failed = True
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene0/test_param_sensitivity_burst.py b/apps/CameraITS/tests/scene0/test_param_sensitivity_burst.py
deleted file mode 100644
index eb9a3c1..0000000
--- a/apps/CameraITS/tests/scene0/test_param_sensitivity_burst.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-
-def main():
-    """Test that the android.sensor.sensitivity parameter is applied properly
-    within a burst. Inspects the output metadata only (not the image data).
-    """
-
-    NUM_STEPS = 3
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.manual_sensor(props):
-            print "Test skipped"
-            return
-
-        sens_range = props['android.sensor.info.sensitivityRange']
-        sens_step = (sens_range[1] - sens_range[0]) / NUM_STEPS
-        sens_list = range(sens_range[0], sens_range[1], sens_step)
-        e = min(props['android.sensor.info.exposureTimeRange'])
-        reqs = [its.objects.manual_capture_request(s,e) for s in sens_list]
-        _,fmt = its.objects.get_fastest_manual_capture_settings(props)
-
-        caps = cam.do_capture(reqs, fmt)
-        for i,cap in enumerate(caps):
-            s_req = sens_list[i]
-            s_res = cap["metadata"]["android.sensor.sensitivity"]
-            assert(s_req == s_res)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene0/test_sensor_events.py b/apps/CameraITS/tests/scene0/test_sensor_events.py
deleted file mode 100644
index 61f0383..0000000
--- a/apps/CameraITS/tests/scene0/test_sensor_events.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.caps
-import time
-
-def main():
-    """Basic test to query and print out sensor events.
-
-    Test will only work if the screen is on (i.e.) the device isn't in standby.
-    Pass if some of each event are received.
-    """
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        # Only run test if the appropriate caps are claimed.
-        if not its.caps.sensor_fusion(props):
-            print "Test skipped"
-            return
-
-        cam.start_sensor_events()
-        time.sleep(1)
-        events = cam.get_sensor_events()
-        print "Events over 1s: %d gyro, %d accel, %d mag"%(
-                len(events["gyro"]), len(events["accel"]), len(events["mag"]))
-        assert(len(events["gyro"]) > 0)
-        assert(len(events["accel"]) > 0)
-        assert(len(events["mag"]) > 0)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene0/test_unified_timestamps.py b/apps/CameraITS/tests/scene0/test_unified_timestamps.py
deleted file mode 100644
index cdc9567..0000000
--- a/apps/CameraITS/tests/scene0/test_unified_timestamps.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.objects
-import its.caps
-import time
-
-def main():
-    """Test if image and motion sensor events are in the same time domain.
-    """
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-
-        # Only run test if the appropriate caps are claimed.
-        if not its.caps.sensor_fusion(props):
-            print "Test skipped"
-            return
-
-        # Get the timestamp of a captured image.
-        req, fmt = its.objects.get_fastest_manual_capture_settings(props)
-        cap = cam.do_capture(req, fmt)
-        ts_image0 = cap['metadata']['android.sensor.timestamp']
-
-        # Get the timestamps of motion events.
-        print "Reading sensor measurements"
-        cam.start_sensor_events()
-        time.sleep(0.5)
-        events = cam.get_sensor_events()
-        assert(len(events["gyro"]) > 0)
-        assert(len(events["accel"]) > 0)
-        assert(len(events["mag"]) > 0)
-        ts_gyro0 = events["gyro"][0]["time"]
-        ts_gyro1 = events["gyro"][-1]["time"]
-        ts_accel0 = events["accel"][0]["time"]
-        ts_accel1 = events["accel"][-1]["time"]
-        ts_mag0 = events["mag"][0]["time"]
-        ts_mag1 = events["mag"][-1]["time"]
-
-        # Get the timestamp of another image.
-        cap = cam.do_capture(req, fmt)
-        ts_image1 = cap['metadata']['android.sensor.timestamp']
-
-        print "Image timestamps:", ts_image0, ts_image1
-        print "Gyro timestamps:", ts_gyro0, ts_gyro1
-        print "Accel timestamps:", ts_accel0, ts_accel1
-        print "Mag timestamps:", ts_mag0, ts_mag1
-
-        # The motion timestamps must be between the two image timestamps.
-        assert ts_image0 < min(ts_gyro0, ts_accel0, ts_mag0) < ts_image1
-        assert ts_image0 < max(ts_gyro1, ts_accel1, ts_mag1) < ts_image1
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/README b/apps/CameraITS/tests/scene1/README
deleted file mode 100755
index 93543d9..0000000
--- a/apps/CameraITS/tests/scene1/README
+++ /dev/null
@@ -1,16 +0,0 @@
-Scene 1 description:
-* Camera on tripod in portrait or landscape orientation
-* Scene mostly filled by grey card, with white background behind grey card
-* Illuminated by simple light source, for example a desk lamp
-* Uniformity of lighting and target positioning need not be precise
-
-This is intended to be a very simple setup that can be recreated on an
-engineer's desk without any large or expensive equipment. The tests for this
-scene in general only look at a patch in the middle of the image (which is
-assumed to be within the bounds of the grey card).
-
-Note that the scene should not be completely uniform; don't have the grey card
-100% fill the field of view and use a high quality uniform light source, for
-example, and don't use a diffuser on top of the camera to simulate a grey
-scene.
-
diff --git a/apps/CameraITS/tests/scene1/test_3a.py b/apps/CameraITS/tests/scene1/test_3a.py
deleted file mode 100644
index b53fc73..0000000
--- a/apps/CameraITS/tests/scene1/test_3a.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.caps
-
-def main():
-    """Basic test for bring-up of 3A.
-
-    To pass, 3A must converge. Check that the returned 3A values are legal.
-    """
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.read_3a(props):
-            print "Test skipped"
-            return
-
-        sens, exp, gains, xform, focus = cam.do_3a(get_results=True)
-        print "AE: sensitivity %d, exposure %dms" % (sens, exp/1000000)
-        print "AWB: gains", gains, "transform", xform
-        print "AF: distance", focus
-        assert(sens > 0)
-        assert(exp > 0)
-        assert(len(gains) == 4)
-        assert(len(xform) == 9)
-        assert(focus >= 0)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_ae_precapture_trigger.py b/apps/CameraITS/tests/scene1/test_ae_precapture_trigger.py
deleted file mode 100644
index 59b7db1..0000000
--- a/apps/CameraITS/tests/scene1/test_ae_precapture_trigger.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.caps
-import its.objects
-import its.target
-
-def main():
-    """Test the AE state machine when using the precapture trigger.
-    """
-
-    INACTIVE = 0
-    SEARCHING = 1
-    CONVERGED = 2
-    LOCKED = 3
-    FLASHREQUIRED = 4
-    PRECAPTURE = 5
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        _,fmt = its.objects.get_fastest_manual_capture_settings(props)
-
-        # Capture 5 manual requests, with AE disabled, and the last request
-        # has an AE precapture trigger (which should be ignored since AE is
-        # disabled).
-        manual_reqs = []
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        manual_req = its.objects.manual_capture_request(s,e)
-        manual_req['android.control.aeMode'] = 0 # Off
-        manual_reqs += [manual_req]*4
-        precap_req = its.objects.manual_capture_request(s,e)
-        precap_req['android.control.aeMode'] = 0 # Off
-        precap_req['android.control.aePrecaptureTrigger'] = 1 # Start
-        manual_reqs.append(precap_req)
-        caps = cam.do_capture(manual_reqs, fmt)
-        for cap in caps:
-            assert(cap['metadata']['android.control.aeState'] == INACTIVE)
-
-        # Capture an auto request and verify the AE state; no trigger.
-        auto_req = its.objects.auto_capture_request()
-        auto_req['android.control.aeMode'] = 1  # On
-        cap = cam.do_capture(auto_req, fmt)
-        state = cap['metadata']['android.control.aeState']
-        print "AE state after auto request:", state
-        assert(state in [SEARCHING, CONVERGED])
-
-        # Capture with auto request with a precapture trigger.
-        auto_req['android.control.aePrecaptureTrigger'] = 1  # Start
-        cap = cam.do_capture(auto_req, fmt)
-        state = cap['metadata']['android.control.aeState']
-        print "AE state after auto request with precapture trigger:", state
-        assert(state in [SEARCHING, CONVERGED, PRECAPTURE])
-
-        # Capture some more auto requests, and AE should converge.
-        auto_req['android.control.aePrecaptureTrigger'] = 0
-        caps = cam.do_capture([auto_req]*5, fmt)
-        state = caps[-1]['metadata']['android.control.aeState']
-        print "AE state after auto request:", state
-        assert(state == CONVERGED)
-
-if __name__ == '__main__':
-    main()
diff --git a/apps/CameraITS/tests/scene1/test_auto_vs_manual.py b/apps/CameraITS/tests/scene1/test_auto_vs_manual.py
deleted file mode 100644
index a9d5ce4..0000000
--- a/apps/CameraITS/tests/scene1/test_auto_vs_manual.py
+++ /dev/null
@@ -1,95 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import os.path
-import math
-
-def main():
-    """Capture auto and manual shots that should look the same.
-
-    Manual shots taken with just manual WB, and also with manual WB+tonemap.
-
-    In all cases, the general color/look of the shots should be the same,
-    however there can be variations in brightness/contrast due to different
-    "auto" ISP blocks that may be disabled in the manual flows.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if (not its.caps.manual_sensor(props) or
-            not its.caps.manual_post_proc(props)):
-            print "Test skipped"
-            return
-
-        # Converge 3A and get the estimates.
-        sens, exp, gains, xform, focus = cam.do_3a(get_results=True)
-        xform_rat = its.objects.float_to_rational(xform)
-        print "AE sensitivity %d, exposure %dms" % (sens, exp/1000000.0)
-        print "AWB gains", gains
-        print "AWB transform", xform
-        print "AF distance", focus
-
-        # Auto capture.
-        req = its.objects.auto_capture_request()
-        cap_auto = cam.do_capture(req)
-        img_auto = its.image.convert_capture_to_rgb_image(cap_auto)
-        its.image.write_image(img_auto, "%s_auto.jpg" % (NAME))
-        xform_a = its.objects.rational_to_float(
-                cap_auto["metadata"]["android.colorCorrection.transform"])
-        gains_a = cap_auto["metadata"]["android.colorCorrection.gains"]
-        print "Auto gains:", gains_a
-        print "Auto transform:", xform_a
-
-        # Manual capture 1: WB
-        req = its.objects.manual_capture_request(sens, exp)
-        req["android.colorCorrection.transform"] = xform_rat
-        req["android.colorCorrection.gains"] = gains
-        cap_man1 = cam.do_capture(req)
-        img_man1 = its.image.convert_capture_to_rgb_image(cap_man1)
-        its.image.write_image(img_man1, "%s_manual_wb.jpg" % (NAME))
-        xform_m1 = its.objects.rational_to_float(
-                cap_man1["metadata"]["android.colorCorrection.transform"])
-        gains_m1 = cap_man1["metadata"]["android.colorCorrection.gains"]
-        print "Manual wb gains:", gains_m1
-        print "Manual wb transform:", xform_m1
-
-        # Manual capture 2: WB + tonemap
-        gamma = sum([[i/63.0,math.pow(i/63.0,1/2.2)] for i in xrange(64)],[])
-        req["android.tonemap.mode"] = 0
-        req["android.tonemap.curveRed"] = gamma
-        req["android.tonemap.curveGreen"] = gamma
-        req["android.tonemap.curveBlue"] = gamma
-        cap_man2 = cam.do_capture(req)
-        img_man2 = its.image.convert_capture_to_rgb_image(cap_man2)
-        its.image.write_image(img_man2, "%s_manual_wb_tm.jpg" % (NAME))
-        xform_m2 = its.objects.rational_to_float(
-                cap_man2["metadata"]["android.colorCorrection.transform"])
-        gains_m2 = cap_man2["metadata"]["android.colorCorrection.gains"]
-        print "Manual wb+tm gains:", gains_m2
-        print "Manual wb+tm transform:", xform_m2
-
-        # Check that the WB gains and transform reported in each capture
-        # result match with the original AWB estimate from do_3a.
-        for g,x in [(gains_a,xform_a),(gains_m1,xform_m1),(gains_m2,xform_m2)]:
-            assert(all([abs(xform[i] - x[i]) < 0.05 for i in range(9)]))
-            assert(all([abs(gains[i] - g[i]) < 0.05 for i in range(4)]))
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_black_white.py b/apps/CameraITS/tests/scene1/test_black_white.py
deleted file mode 100644
index e471602..0000000
--- a/apps/CameraITS/tests/scene1/test_black_white.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that the device will produce full black+white images.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    r_means = []
-    g_means = []
-    b_means = []
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.manual_sensor(props):
-            print "Test skipped"
-            return
-
-        expt_range = props['android.sensor.info.exposureTimeRange']
-        sens_range = props['android.sensor.info.sensitivityRange']
-
-        # Take a shot with very low ISO and exposure time. Expect it to
-        # be black.
-        print "Black shot: sens = %d, exp time = %.4fms" % (
-                sens_range[0], expt_range[0]/1000000.0)
-        req = its.objects.manual_capture_request(sens_range[0], expt_range[0])
-        cap = cam.do_capture(req)
-        img = its.image.convert_capture_to_rgb_image(cap)
-        its.image.write_image(img, "%s_black.jpg" % (NAME))
-        tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-        black_means = its.image.compute_image_means(tile)
-        r_means.append(black_means[0])
-        g_means.append(black_means[1])
-        b_means.append(black_means[2])
-        print "Dark pixel means:", black_means
-
-        # Take a shot with very high ISO and exposure time. Expect it to
-        # be white.
-        print "White shot: sens = %d, exp time = %.2fms" % (
-                sens_range[1], expt_range[1]/1000000.0)
-        req = its.objects.manual_capture_request(sens_range[1], expt_range[1])
-        cap = cam.do_capture(req)
-        img = its.image.convert_capture_to_rgb_image(cap)
-        its.image.write_image(img, "%s_white.jpg" % (NAME))
-        tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-        white_means = its.image.compute_image_means(tile)
-        r_means.append(white_means[0])
-        g_means.append(white_means[1])
-        b_means.append(white_means[2])
-        print "Bright pixel means:", white_means
-
-        # Draw a plot.
-        pylab.plot([0,1], r_means, 'r')
-        pylab.plot([0,1], g_means, 'g')
-        pylab.plot([0,1], b_means, 'b')
-        pylab.ylim([0,1])
-        matplotlib.pyplot.savefig("%s_plot_means.png" % (NAME))
-
-        for val in black_means:
-            assert(val < 0.025)
-        for val in white_means:
-            assert(val > 0.975)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_burst_sameness_manual.py b/apps/CameraITS/tests/scene1/test_burst_sameness_manual.py
deleted file mode 100644
index 3858c0c..0000000
--- a/apps/CameraITS/tests/scene1/test_burst_sameness_manual.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os.path
-import numpy
-
-def main():
-    """Take long bursts of images and check that they're all identical.
-
-    Assumes a static scene. Can be used to idenfity if there are sporadic
-    frames that are processed differently or have artifacts. Uses manual
-    capture settings.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    BURST_LEN = 50
-    BURSTS = 5
-    FRAMES = BURST_LEN * BURSTS
-
-    SPREAD_THRESH = 0.03
-
-    with its.device.ItsSession() as cam:
-
-        # Capture at the smallest resolution.
-        props = cam.get_camera_properties()
-        if not its.caps.manual_sensor(props):
-            print "Test skipped"
-            return
-
-        _, fmt = its.objects.get_fastest_manual_capture_settings(props)
-        e, s = its.target.get_target_exposure_combos(cam)["minSensitivity"]
-        req = its.objects.manual_capture_request(s, e)
-        w,h = fmt["width"], fmt["height"]
-
-        # Capture bursts of YUV shots.
-        # Get the mean values of a center patch for each.
-        # Also build a 4D array, which is an array of all RGB images.
-        r_means = []
-        g_means = []
-        b_means = []
-        imgs = numpy.empty([FRAMES,h,w,3])
-        for j in range(BURSTS):
-            caps = cam.do_capture([req]*BURST_LEN, [fmt])
-            for i,cap in enumerate(caps):
-                n = j*BURST_LEN + i
-                imgs[n] = its.image.convert_capture_to_rgb_image(cap)
-                tile = its.image.get_image_patch(imgs[n], 0.45, 0.45, 0.1, 0.1)
-                means = its.image.compute_image_means(tile)
-                r_means.append(means[0])
-                g_means.append(means[1])
-                b_means.append(means[2])
-
-        # Dump all images.
-        print "Dumping images"
-        for i in range(FRAMES):
-            its.image.write_image(imgs[i], "%s_frame%03d.jpg"%(NAME,i))
-
-        # The mean image.
-        img_mean = imgs.mean(0)
-        its.image.write_image(img_mean, "%s_mean.jpg"%(NAME))
-
-        # Pass/fail based on center patch similarity.
-        for means in [r_means, g_means, b_means]:
-            spread = max(means) - min(means)
-            print spread
-            assert(spread < SPREAD_THRESH)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_capture_result.py b/apps/CameraITS/tests/scene1/test_capture_result.py
deleted file mode 100644
index 304e811..0000000
--- a/apps/CameraITS/tests/scene1/test_capture_result.py
+++ /dev/null
@@ -1,214 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import os.path
-import numpy
-import matplotlib.pyplot
-
-# Required for 3d plot to work
-import mpl_toolkits.mplot3d
-
-def main():
-    """Test that valid data comes back in CaptureResult objects.
-    """
-    global NAME, auto_req, manual_req, w_map, h_map
-    global manual_tonemap, manual_transform, manual_gains, manual_region
-    global manual_exp_time, manual_sensitivity, manual_gains_ok
-
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if (not its.caps.manual_sensor(props) or
-            not its.caps.manual_post_proc(props)):
-            print "Test skipped"
-            return
-
-        manual_tonemap = [0,0, 1,1] # Linear
-        manual_transform = its.objects.int_to_rational([1,2,3, 4,5,6, 7,8,9])
-        manual_gains = [1,2,3,4]
-        manual_region = [{"x":8,"y":8,"width":128,"height":128,"weight":1}]
-        manual_exp_time = min(props['android.sensor.info.exposureTimeRange'])
-        manual_sensitivity = min(props['android.sensor.info.sensitivityRange'])
-
-        # The camera HAL may not support different gains for two G channels.
-        manual_gains_ok = [[1,2,3,4],[1,2,2,4],[1,3,3,4]]
-
-        auto_req = its.objects.auto_capture_request()
-        auto_req["android.statistics.lensShadingMapMode"] = 1
-
-        manual_req = {
-            "android.control.mode": 0,
-            "android.control.aeMode": 0,
-            "android.control.awbMode": 0,
-            "android.control.afMode": 0,
-            "android.sensor.frameDuration": 0,
-            "android.sensor.sensitivity": manual_sensitivity,
-            "android.sensor.exposureTime": manual_exp_time,
-            "android.colorCorrection.mode": 0,
-            "android.colorCorrection.transform": manual_transform,
-            "android.colorCorrection.gains": manual_gains,
-            "android.tonemap.mode": 0,
-            "android.tonemap.curveRed": manual_tonemap,
-            "android.tonemap.curveGreen": manual_tonemap,
-            "android.tonemap.curveBlue": manual_tonemap,
-            "android.control.aeRegions": manual_region,
-            "android.control.afRegions": manual_region,
-            "android.control.awbRegions": manual_region,
-            "android.statistics.lensShadingMapMode":1
-            }
-
-        w_map = props["android.lens.info.shadingMapSize"]["width"]
-        h_map = props["android.lens.info.shadingMapSize"]["height"]
-
-        print "Testing auto capture results"
-        lsc_map_auto = test_auto(cam, w_map, h_map)
-        print "Testing manual capture results"
-        test_manual(cam, w_map, h_map, lsc_map_auto)
-        print "Testing auto capture results again"
-        test_auto(cam, w_map, h_map)
-
-# A very loose definition for two floats being close to each other;
-# there may be different interpolation and rounding used to get the
-# two values, and all this test is looking at is whether there is
-# something obviously broken; it's not looking for a perfect match.
-def is_close_float(n1, n2):
-    return abs(n1 - n2) < 0.05
-
-def is_close_rational(n1, n2):
-    return is_close_float(its.objects.rational_to_float(n1),
-                          its.objects.rational_to_float(n2))
-
-def draw_lsc_plot(w_map, h_map, lsc_map, name):
-    for ch in range(4):
-        fig = matplotlib.pyplot.figure()
-        ax = fig.gca(projection='3d')
-        xs = numpy.array([range(w_map)] * h_map).reshape(h_map, w_map)
-        ys = numpy.array([[i]*w_map for i in range(h_map)]).reshape(
-                h_map, w_map)
-        zs = numpy.array(lsc_map[ch::4]).reshape(h_map, w_map)
-        ax.plot_wireframe(xs, ys, zs)
-        matplotlib.pyplot.savefig("%s_plot_lsc_%s_ch%d.png"%(NAME,name,ch))
-
-def test_auto(cam, w_map, h_map):
-    # Get 3A lock first, so the auto values in the capture result are
-    # populated properly.
-    rect = [[0,0,1,1,1]]
-    cam.do_3a(rect, rect, rect, do_af=False)
-
-    cap = cam.do_capture(auto_req)
-    cap_res = cap["metadata"]
-
-    gains = cap_res["android.colorCorrection.gains"]
-    transform = cap_res["android.colorCorrection.transform"]
-    exp_time = cap_res['android.sensor.exposureTime']
-    lsc_map = cap_res["android.statistics.lensShadingMap"]
-    ctrl_mode = cap_res["android.control.mode"]
-
-    print "Control mode:", ctrl_mode
-    print "Gains:", gains
-    print "Transform:", [its.objects.rational_to_float(t)
-                         for t in transform]
-    print "AE region:", cap_res['android.control.aeRegions']
-    print "AF region:", cap_res['android.control.afRegions']
-    print "AWB region:", cap_res['android.control.awbRegions']
-    print "LSC map:", w_map, h_map, lsc_map[:8]
-
-    assert(ctrl_mode == 1)
-
-    # Color correction gain and transform must be valid.
-    assert(len(gains) == 4)
-    assert(len(transform) == 9)
-    assert(all([g > 0 for g in gains]))
-    assert(all([t["denominator"] != 0 for t in transform]))
-
-    # Color correction should not match the manual settings.
-    assert(any([not is_close_float(gains[i], manual_gains[i])
-                for i in xrange(4)]))
-    assert(any([not is_close_rational(transform[i], manual_transform[i])
-                for i in xrange(9)]))
-
-    # Exposure time must be valid.
-    assert(exp_time > 0)
-
-    # Lens shading map must be valid.
-    assert(w_map > 0 and h_map > 0 and w_map * h_map * 4 == len(lsc_map))
-    assert(all([m >= 1 for m in lsc_map]))
-
-    draw_lsc_plot(w_map, h_map, lsc_map, "auto")
-
-    return lsc_map
-
-def test_manual(cam, w_map, h_map, lsc_map_auto):
-    cap = cam.do_capture(manual_req)
-    cap_res = cap["metadata"]
-
-    gains = cap_res["android.colorCorrection.gains"]
-    transform = cap_res["android.colorCorrection.transform"]
-    curves = [cap_res["android.tonemap.curveRed"],
-              cap_res["android.tonemap.curveGreen"],
-              cap_res["android.tonemap.curveBlue"]]
-    exp_time = cap_res['android.sensor.exposureTime']
-    lsc_map = cap_res["android.statistics.lensShadingMap"]
-    ctrl_mode = cap_res["android.control.mode"]
-
-    print "Control mode:", ctrl_mode
-    print "Gains:", gains
-    print "Transform:", [its.objects.rational_to_float(t)
-                         for t in transform]
-    print "Tonemap:", curves[0][1::16]
-    print "AE region:", cap_res['android.control.aeRegions']
-    print "AF region:", cap_res['android.control.afRegions']
-    print "AWB region:", cap_res['android.control.awbRegions']
-    print "LSC map:", w_map, h_map, lsc_map[:8]
-
-    assert(ctrl_mode == 0)
-
-    # Color correction gain and transform must be valid.
-    # Color correction gains and transform should be the same size and
-    # values as the manually set values.
-    assert(len(gains) == 4)
-    assert(len(transform) == 9)
-    assert( all([is_close_float(gains[i], manual_gains_ok[0][i])
-                 for i in xrange(4)]) or
-            all([is_close_float(gains[i], manual_gains_ok[1][i])
-                 for i in xrange(4)]) or
-            all([is_close_float(gains[i], manual_gains_ok[2][i])
-                 for i in xrange(4)]))
-    assert(all([is_close_rational(transform[i], manual_transform[i])
-                for i in xrange(9)]))
-
-    # Tonemap must be valid.
-    # The returned tonemap must be linear.
-    for c in curves:
-        assert(len(c) > 0)
-        assert(all([is_close_float(c[i], c[i+1])
-                    for i in xrange(0,len(c),2)]))
-
-    # Exposure time must be close to the requested exposure time.
-    assert(is_close_float(exp_time/1000000.0, manual_exp_time/1000000.0))
-
-    # Lens shading map must be valid.
-    assert(w_map > 0 and h_map > 0 and w_map * h_map * 4 == len(lsc_map))
-    assert(all([m >= 1 for m in lsc_map]))
-
-    draw_lsc_plot(w_map, h_map, lsc_map, "manual")
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_crop_region_raw.py b/apps/CameraITS/tests/scene1/test_crop_region_raw.py
deleted file mode 100644
index 94c8e2b..0000000
--- a/apps/CameraITS/tests/scene1/test_crop_region_raw.py
+++ /dev/null
@@ -1,116 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import numpy
-import os.path
-
-def main():
-    """Test that raw streams are not croppable.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    DIFF_THRESH = 0.05
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if (not its.caps.compute_target_exposure(props) or
-            not its.caps.raw16(props)):
-            print "Test skipped"
-            return
-
-        a = props['android.sensor.info.activeArraySize']
-        ax, ay = a["left"], a["top"]
-        aw, ah = a["right"] - a["left"], a["bottom"] - a["top"]
-        print "Active sensor region: (%d,%d %dx%d)" % (ax, ay, aw, ah)
-
-        # Capture without a crop region.
-        # Use a manual request with a linear tonemap so that the YUV and RAW
-        # should look the same (once converted by the its.image module).
-        e, s = its.target.get_target_exposure_combos(cam)["minSensitivity"]
-        req = its.objects.manual_capture_request(s,e, True)
-        cap1_raw, cap1_yuv = cam.do_capture(req, cam.CAP_RAW_YUV)
-
-        # Capture with a center crop region.
-        req["android.scaler.cropRegion"] = {
-                "top": ay + ah/3,
-                "left": ax + aw/3,
-                "right": ax + 2*aw/3,
-                "bottom": ay + 2*ah/3}
-        cap2_raw, cap2_yuv = cam.do_capture(req, cam.CAP_RAW_YUV)
-
-        reported_crops = []
-        imgs = {}
-        for s,cap in [("yuv_full",cap1_yuv), ("raw_full",cap1_raw),
-                ("yuv_crop",cap2_yuv), ("raw_crop",cap2_raw)]:
-            img = its.image.convert_capture_to_rgb_image(cap, props=props)
-            its.image.write_image(img, "%s_%s.jpg" % (NAME, s))
-            r = cap["metadata"]["android.scaler.cropRegion"]
-            x, y = a["left"], a["top"]
-            w, h = a["right"] - a["left"], a["bottom"] - a["top"]
-            reported_crops.append((x,y,w,h))
-            imgs[s] = img
-            print "Crop on %s: (%d,%d %dx%d)" % (s, x,y,w,h)
-
-        # The metadata should report uncropped for all shots (since there is
-        # at least 1 uncropped stream in each case).
-        for (x,y,w,h) in reported_crops:
-            assert((ax,ay,aw,ah) == (x,y,w,h))
-
-        # Also check the image content; 3 of the 4 shots should match.
-        # Note that all the shots are RGB below; the variable names correspond
-        # to what was captured.
-        # Average the images down 4x4 -> 1 prior to comparison to smooth out
-        # noise.
-        # Shrink the YUV images an additional 2x2 -> 1 to account for the size
-        # reduction that the raw images went through in the RGB conversion.
-        imgs2 = {}
-        for s,img in imgs.iteritems():
-            h,w,ch = img.shape
-            m = 4
-            if s in ["yuv_full", "yuv_crop"]:
-                m = 8
-            img = img.reshape(h/m,m,w/m,m,3).mean(3).mean(1).reshape(h/m,w/m,3)
-            imgs2[s] = img
-            print s, img.shape
-
-        # Strip any border pixels from the raw shots (since the raw images may
-        # be larger than the YUV images). Assume a symmetric padded border.
-        xpad = (imgs2["raw_full"].shape[1] - imgs2["yuv_full"].shape[1]) / 2
-        ypad = (imgs2["raw_full"].shape[0] - imgs2["yuv_full"].shape[0]) / 2
-        wyuv = imgs2["yuv_full"].shape[1]
-        hyuv = imgs2["yuv_full"].shape[0]
-        imgs2["raw_full"]=imgs2["raw_full"][ypad:ypad+hyuv:,xpad:xpad+wyuv:,::]
-        imgs2["raw_crop"]=imgs2["raw_crop"][ypad:ypad+hyuv:,xpad:xpad+wyuv:,::]
-        print "Stripping padding before comparison:", xpad, ypad
-
-        for s,img in imgs2.iteritems():
-            its.image.write_image(img, "%s_comp_%s.jpg" % (NAME, s))
-
-        # Compute image diffs.
-        diff_yuv = numpy.fabs((imgs2["yuv_full"] - imgs2["yuv_crop"])).mean()
-        diff_raw = numpy.fabs((imgs2["raw_full"] - imgs2["raw_crop"])).mean()
-        print "YUV diff (crop vs. non-crop):", diff_yuv
-        print "RAW diff (crop vs. non-crop):", diff_raw
-
-        assert(diff_yuv > DIFF_THRESH)
-        assert(diff_raw < DIFF_THRESH)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_crop_regions.py b/apps/CameraITS/tests/scene1/test_crop_regions.py
deleted file mode 100644
index da0cd0a..0000000
--- a/apps/CameraITS/tests/scene1/test_crop_regions.py
+++ /dev/null
@@ -1,106 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os.path
-import numpy
-
-def main():
-    """Test that crop regions work.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    # A list of 5 regions, specified in normalized (x,y,w,h) coords.
-    # The regions correspond to: TL, TR, BL, BR, CENT
-    REGIONS = [(0.0, 0.0, 0.5, 0.5),
-               (0.5, 0.0, 0.5, 0.5),
-               (0.0, 0.5, 0.5, 0.5),
-               (0.5, 0.5, 0.5, 0.5),
-               (0.25, 0.25, 0.5, 0.5)]
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        a = props['android.sensor.info.activeArraySize']
-        ax, ay = a["left"], a["top"]
-        aw, ah = a["right"] - a["left"], a["bottom"] - a["top"]
-        e, s = its.target.get_target_exposure_combos(cam)["minSensitivity"]
-        print "Active sensor region (%d,%d %dx%d)" % (ax, ay, aw, ah)
-
-        # Uses a 2x digital zoom.
-        assert(props['android.scaler.availableMaxDigitalZoom'] >= 2)
-
-        # Capture a full frame.
-        req = its.objects.manual_capture_request(s,e)
-        cap_full = cam.do_capture(req)
-        img_full = its.image.convert_capture_to_rgb_image(cap_full)
-        its.image.write_image(img_full, "%s_full.jpg" % (NAME))
-        wfull, hfull = cap_full["width"], cap_full["height"]
-
-        # Capture a burst of crop region frames.
-        # Note that each region is 1/2x1/2 of the full frame, and is digitally
-        # zoomed into the full size output image, so must be downscaled (below)
-        # by 2x when compared to a tile of the full image.
-        reqs = []
-        for x,y,w,h in REGIONS:
-            req = its.objects.manual_capture_request(s,e)
-            req["android.scaler.cropRegion"] = {
-                    "top": int(ah * y),
-                    "left": int(aw * x),
-                    "right": int(aw * (x + w)),
-                    "bottom": int(ah * (y + h))}
-            reqs.append(req)
-        caps_regions = cam.do_capture(reqs)
-        match_failed = False
-        for i,cap in enumerate(caps_regions):
-            a = cap["metadata"]["android.scaler.cropRegion"]
-            ax, ay = a["left"], a["top"]
-            aw, ah = a["right"] - a["left"], a["bottom"] - a["top"]
-
-            # Match this crop image against each of the five regions of
-            # the full image, to find the best match (which should be
-            # the region that corresponds to this crop image).
-            img_crop = its.image.convert_capture_to_rgb_image(cap)
-            img_crop = its.image.downscale_image(img_crop, 2)
-            its.image.write_image(img_crop, "%s_crop%d.jpg" % (NAME, i))
-            min_diff = None
-            min_diff_region = None
-            for j,(x,y,w,h) in enumerate(REGIONS):
-                tile_full = its.image.get_image_patch(img_full, x,y,w,h)
-                wtest = min(tile_full.shape[1], aw)
-                htest = min(tile_full.shape[0], ah)
-                tile_full = tile_full[0:htest:, 0:wtest:, ::]
-                tile_crop = img_crop[0:htest:, 0:wtest:, ::]
-                its.image.write_image(tile_full, "%s_fullregion%d.jpg"%(NAME,j))
-                diff = numpy.fabs(tile_full - tile_crop).mean()
-                if min_diff is None or diff < min_diff:
-                    min_diff = diff
-                    min_diff_region = j
-            if i != min_diff_region:
-                match_failed = True
-            print "Crop image %d (%d,%d %dx%d) best match with region %d"%(
-                    i, ax, ay, aw, ah, min_diff_region)
-
-        assert(not match_failed)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_exposure.py b/apps/CameraITS/tests/scene1/test_exposure.py
deleted file mode 100644
index 8676358..0000000
--- a/apps/CameraITS/tests/scene1/test_exposure.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import pylab
-import numpy
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that a constant exposure is seen as ISO and exposure time vary.
-
-    Take a series of shots that have ISO and exposure time chosen to balance
-    each other; result should be the same brightness, but over the sequence
-    the images should get noisier.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    THRESHOLD_MAX_OUTLIER_DIFF = 0.1
-    THRESHOLD_MIN_LEVEL = 0.1
-    THRESHOLD_MAX_LEVEL = 0.9
-    THRESHOLD_MAX_ABS_GRAD = 0.001
-
-    mults = []
-    r_means = []
-    g_means = []
-    b_means = []
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        e,s = its.target.get_target_exposure_combos(cam)["minSensitivity"]
-        expt_range = props['android.sensor.info.exposureTimeRange']
-        sens_range = props['android.sensor.info.sensitivityRange']
-
-        m = 1
-        while s*m < sens_range[1] and e/m > expt_range[0]:
-            mults.append(m)
-            req = its.objects.manual_capture_request(s*m, e/m)
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_mult=%02d.jpg" % (NAME, m))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means = its.image.compute_image_means(tile)
-            r_means.append(rgb_means[0])
-            g_means.append(rgb_means[1])
-            b_means.append(rgb_means[2])
-            m = m + 4
-
-    # Draw a plot.
-    pylab.plot(mults, r_means, 'r')
-    pylab.plot(mults, g_means, 'g')
-    pylab.plot(mults, b_means, 'b')
-    pylab.ylim([0,1])
-    matplotlib.pyplot.savefig("%s_plot_means.png" % (NAME))
-
-    # Check for linearity. For each R,G,B channel, fit a line y=mx+b, and
-    # assert that the gradient is close to 0 (flat) and that there are no
-    # crazy outliers. Also ensure that the images aren't clamped to 0 or 1
-    # (which would make them look like flat lines).
-    for chan in xrange(3):
-        values = [r_means, g_means, b_means][chan]
-        m, b = numpy.polyfit(mults, values, 1).tolist()
-        print "Channel %d line fit (y = mx+b): m = %f, b = %f" % (chan, m, b)
-        assert(abs(m) < THRESHOLD_MAX_ABS_GRAD)
-        assert(b > THRESHOLD_MIN_LEVEL and b < THRESHOLD_MAX_LEVEL)
-        for v in values:
-            assert(v > THRESHOLD_MIN_LEVEL and v < THRESHOLD_MAX_LEVEL)
-            assert(abs(v - b) < THRESHOLD_MAX_OUTLIER_DIFF)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_format_combos.py b/apps/CameraITS/tests/scene1/test_format_combos.py
deleted file mode 100644
index a021102..0000000
--- a/apps/CameraITS/tests/scene1/test_format_combos.py
+++ /dev/null
@@ -1,126 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.error
-import its.target
-import sys
-import os
-import os.path
-
-# Change this to True, to have the test break at the first failure.
-stop_at_first_failure = False
-
-def main():
-    """Test different combinations of output formats.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-
-        props = cam.get_camera_properties()
-        if (not its.caps.compute_target_exposure(props) or
-            not its.caps.raw16(props)):
-            print "Test skipped"
-            return
-
-        successes = []
-        failures = []
-
-        # Two different requests: auto, and manual.
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        req_aut = its.objects.auto_capture_request()
-        req_man = its.objects.manual_capture_request(s, e)
-        reqs = [req_aut, # R0
-                req_man] # R1
-
-        # 10 different combos of output formats; some are single surfaces, and
-        # some are multiple surfaces.
-        wyuv,hyuv = its.objects.get_available_output_sizes("yuv", props)[-1]
-        wjpg,hjpg = its.objects.get_available_output_sizes("jpg", props)[-1]
-        fmt_yuv_prev = {"format":"yuv", "width":wyuv, "height":hyuv}
-        fmt_yuv_full = {"format":"yuv"}
-        fmt_jpg_prev = {"format":"jpeg","width":wjpg, "height":hjpg}
-        fmt_jpg_full = {"format":"jpeg"}
-        fmt_raw_full = {"format":"raw"}
-        fmt_combos =[
-                [fmt_yuv_prev],                             # F0
-                [fmt_yuv_full],                             # F1
-                [fmt_jpg_prev],                             # F2
-                [fmt_jpg_full],                             # F3
-                [fmt_raw_full],                             # F4
-                [fmt_yuv_prev, fmt_jpg_prev],               # F5
-                [fmt_yuv_prev, fmt_jpg_full],               # F6
-                [fmt_yuv_prev, fmt_raw_full],               # F7
-                [fmt_yuv_prev, fmt_jpg_prev, fmt_raw_full], # F8
-                [fmt_yuv_prev, fmt_jpg_full, fmt_raw_full]] # F9
-
-        # Two different burst lengths: single frame, and 3 frames.
-        burst_lens = [1, # B0
-                      3] # B1
-
-        # There are 2x10x2=40 different combinations. Run through them all.
-        n = 0
-        for r,req in enumerate(reqs):
-            for f,fmt_combo in enumerate(fmt_combos):
-                for b,burst_len in enumerate(burst_lens):
-                    try:
-                        caps = cam.do_capture([req]*burst_len, fmt_combo)
-                        successes.append((n,r,f,b))
-                        print "==> Success[%02d]: R%d F%d B%d" % (n,r,f,b)
-
-                        # Dump the captures out to jpegs.
-                        if not isinstance(caps, list):
-                            caps = [caps]
-                        elif isinstance(caps[0], list):
-                            caps = sum(caps, [])
-                        for c,cap in enumerate(caps):
-                            img = its.image.convert_capture_to_rgb_image(cap,
-                                    props=props)
-                            its.image.write_image(img,
-                                    "%s_n%02d_r%d_f%d_b%d_c%d.jpg"%(NAME,n,r,f,b,c))
-
-                    except Exception as e:
-                        print e
-                        print "==> Failure[%02d]: R%d F%d B%d" % (n,r,f,b)
-                        failures.append((n,r,f,b))
-                        if stop_at_first_failure:
-                            sys.exit(0)
-                    n += 1
-
-        num_fail = len(failures)
-        num_success = len(successes)
-        num_total = len(reqs)*len(fmt_combos)*len(burst_lens)
-        num_not_run = num_total - num_success - num_fail
-
-        print "\nFailures (%d / %d):" % (num_fail, num_total)
-        for (n,r,f,b) in failures:
-            print "  %02d: R%d F%d B%d" % (n,r,f,b)
-        print "\nSuccesses (%d / %d):" % (num_success, num_total)
-        for (n,r,f,b) in successes:
-            print "  %02d: R%d F%d B%d" % (n,r,f,b)
-        if num_not_run > 0:
-            print "\nNumber of tests not run: %d / %d" % (num_not_run, num_total)
-        print ""
-
-        # The test passes if all the combinations successfully capture.
-        assert(num_fail == 0)
-        assert(num_success == num_total)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_jpeg.py b/apps/CameraITS/tests/scene1/test_jpeg.py
deleted file mode 100644
index bc2d64e..0000000
--- a/apps/CameraITS/tests/scene1/test_jpeg.py
+++ /dev/null
@@ -1,64 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os.path
-import math
-
-def main():
-    """Test that converted YUV images and device JPEG images look the same.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    THRESHOLD_MAX_RMS_DIFF = 0.01
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        req = its.objects.manual_capture_request(s, e, True)
-
-        # YUV
-        size = its.objects.get_available_output_sizes("yuv", props)[0]
-        out_surface = {"width":size[0], "height":size[1], "format":"yuv"}
-        cap = cam.do_capture(req, out_surface)
-        img = its.image.convert_capture_to_rgb_image(cap)
-        its.image.write_image(img, "%s_fmt=yuv.jpg" % (NAME))
-        tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-        rgb0 = its.image.compute_image_means(tile)
-
-        # JPEG
-        size = its.objects.get_available_output_sizes("jpg", props)[0]
-        out_surface = {"width":size[0], "height":size[1], "format":"jpg"}
-        cap = cam.do_capture(req, out_surface)
-        img = its.image.decompress_jpeg_to_rgb_image(cap["data"])
-        its.image.write_image(img, "%s_fmt=jpg.jpg" % (NAME))
-        tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-        rgb1 = its.image.compute_image_means(tile)
-
-        rms_diff = math.sqrt(
-                sum([pow(rgb0[i] - rgb1[i], 2.0) for i in range(3)]) / 3.0)
-        print "RMS difference:", rms_diff
-        assert(rms_diff < THRESHOLD_MAX_RMS_DIFF)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_latching.py b/apps/CameraITS/tests/scene1/test_latching.py
deleted file mode 100644
index bef41ac..0000000
--- a/apps/CameraITS/tests/scene1/test_latching.py
+++ /dev/null
@@ -1,91 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that settings latch on the right frame.
-
-    Takes a bunch of shots using back-to-back requests, varying the capture
-    request parameters between shots. Checks that the images that come back
-    have the expected properties.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.full(props):
-            print "Test skipped"
-            return
-
-        _,fmt = its.objects.get_fastest_manual_capture_settings(props)
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        e /= 2.0
-
-        r_means = []
-        g_means = []
-        b_means = []
-
-        reqs = [
-            its.objects.manual_capture_request(s,  e,   True),
-            its.objects.manual_capture_request(s,  e,   True),
-            its.objects.manual_capture_request(s*2,e,   True),
-            its.objects.manual_capture_request(s*2,e,   True),
-            its.objects.manual_capture_request(s,  e,   True),
-            its.objects.manual_capture_request(s,  e,   True),
-            its.objects.manual_capture_request(s,  e*2, True),
-            its.objects.manual_capture_request(s,  e,   True),
-            its.objects.manual_capture_request(s*2,e,   True),
-            its.objects.manual_capture_request(s,  e,   True),
-            its.objects.manual_capture_request(s,  e*2, True),
-            its.objects.manual_capture_request(s,  e,   True),
-            its.objects.manual_capture_request(s,  e*2, True),
-            its.objects.manual_capture_request(s,  e*2, True),
-            ]
-
-        caps = cam.do_capture(reqs, fmt)
-        for i,cap in enumerate(caps):
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_i=%02d.jpg" % (NAME, i))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means = its.image.compute_image_means(tile)
-            r_means.append(rgb_means[0])
-            g_means.append(rgb_means[1])
-            b_means.append(rgb_means[2])
-
-        # Draw a plot.
-        idxs = range(len(r_means))
-        pylab.plot(idxs, r_means, 'r')
-        pylab.plot(idxs, g_means, 'g')
-        pylab.plot(idxs, b_means, 'b')
-        pylab.ylim([0,1])
-        matplotlib.pyplot.savefig("%s_plot_means.png" % (NAME))
-
-        g_avg = sum(g_means) / len(g_means)
-        g_ratios = [g / g_avg for g in g_means]
-        g_hilo = [g>1.0 for g in g_ratios]
-        assert(g_hilo == [False, False, True, True, False, False, True,
-                          False, True, False, True, False, True, True])
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_linearity.py b/apps/CameraITS/tests/scene1/test_linearity.py
deleted file mode 100644
index fed0324..0000000
--- a/apps/CameraITS/tests/scene1/test_linearity.py
+++ /dev/null
@@ -1,99 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import numpy
-import math
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that device processing can be inverted to linear pixels.
-
-    Captures a sequence of shots with the device pointed at a uniform
-    target. Attempts to invert all the ISP processing to get back to
-    linear R,G,B pixel data.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    RESIDUAL_THRESHOLD = 0.00005
-
-    # The HAL3.2 spec requires that curves up to 64 control points in length
-    # must be supported.
-    L = 64
-    LM1 = float(L-1)
-
-    gamma_lut = numpy.array(
-            sum([[i/LM1, math.pow(i/LM1, 1/2.2)] for i in xrange(L)], []))
-    inv_gamma_lut = numpy.array(
-            sum([[i/LM1, math.pow(i/LM1, 2.2)] for i in xrange(L)], []))
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        e,s = its.target.get_target_exposure_combos(cam)["midSensitivity"]
-        s /= 2
-        sens_range = props['android.sensor.info.sensitivityRange']
-        sensitivities = [s*1.0/3.0, s*2.0/3.0, s, s*4.0/3.0, s*5.0/3.0]
-        sensitivities = [s for s in sensitivities
-                if s > sens_range[0] and s < sens_range[1]]
-
-        req = its.objects.manual_capture_request(0, e)
-        req["android.blackLevel.lock"] = True
-        req["android.tonemap.mode"] = 0
-        req["android.tonemap.curveRed"] = gamma_lut.tolist()
-        req["android.tonemap.curveGreen"] = gamma_lut.tolist()
-        req["android.tonemap.curveBlue"] = gamma_lut.tolist()
-
-        r_means = []
-        g_means = []
-        b_means = []
-
-        for sens in sensitivities:
-            req["android.sensor.sensitivity"] = sens
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(
-                    img, "%s_sens=%04d.jpg" % (NAME, sens))
-            img = its.image.apply_lut_to_image(img, inv_gamma_lut[1::2] * LM1)
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means = its.image.compute_image_means(tile)
-            r_means.append(rgb_means[0])
-            g_means.append(rgb_means[1])
-            b_means.append(rgb_means[2])
-
-        pylab.plot(sensitivities, r_means, 'r')
-        pylab.plot(sensitivities, g_means, 'g')
-        pylab.plot(sensitivities, b_means, 'b')
-        pylab.ylim([0,1])
-        matplotlib.pyplot.savefig("%s_plot_means.png" % (NAME))
-
-        # Check that each plot is actually linear.
-        for means in [r_means, g_means, b_means]:
-            line,residuals,_,_,_  = numpy.polyfit(range(5),means,1,full=True)
-            print "Line: m=%f, b=%f, resid=%f"%(line[0], line[1], residuals[0])
-            assert(residuals[0] < RESIDUAL_THRESHOLD)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_locked_burst.py b/apps/CameraITS/tests/scene1/test_locked_burst.py
deleted file mode 100644
index 83cfa25..0000000
--- a/apps/CameraITS/tests/scene1/test_locked_burst.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.device
-import its.objects
-import os.path
-import numpy
-import pylab
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test 3A lock + YUV burst (using auto settings).
-
-    This is a test that is designed to pass even on limited devices that
-    don't have MANUAL_SENSOR or PER_FRAME_CONTROLS. (They must be able to
-    capture bursts with full res @ full frame rate to pass, however).
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    BURST_LEN = 10
-    SPREAD_THRESH = 0.005
-    FPS_MAX_DIFF = 2.0
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-
-        # Converge 3A prior to capture.
-        cam.do_3a(do_af=False, lock_ae=True, lock_awb=True)
-
-        # After 3A has converged, lock AE+AWB for the duration of the test.
-        req = its.objects.auto_capture_request()
-        req["android.control.awbLock"] = True
-        req["android.control.aeLock"] = True
-
-        # Capture bursts of YUV shots.
-        # Get the mean values of a center patch for each.
-        r_means = []
-        g_means = []
-        b_means = []
-        caps = cam.do_capture([req]*BURST_LEN)
-        for i,cap in enumerate(caps):
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_frame%d.jpg"%(NAME,i))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            means = its.image.compute_image_means(tile)
-            r_means.append(means[0])
-            g_means.append(means[1])
-            b_means.append(means[2])
-
-        # Pass/fail based on center patch similarity.
-        for means in [r_means, g_means, b_means]:
-            spread = max(means) - min(means)
-            print "Patch mean spread", spread
-            assert(spread < SPREAD_THRESH)
-
-        # Also ensure that the burst was at full frame rate.
-        fmt_code = 0x23
-        configs = props['android.scaler.streamConfigurationMap']\
-                       ['availableStreamConfigurations']
-        min_duration = None
-        for cfg in configs:
-            if cfg['format'] == fmt_code and cfg['input'] == False and \
-                    cfg['width'] == caps[0]["width"] and \
-                    cfg['height'] == caps[0]["height"]:
-                min_duration = cfg["minFrameDuration"]
-        assert(min_duration is not None)
-        tstamps = [c['metadata']['android.sensor.timestamp'] for c in caps]
-        deltas = [tstamps[i]-tstamps[i-1] for i in range(1,len(tstamps))]
-        actual_fps = 1.0 / (max(deltas) / 1000000000.0)
-        max_fps = 1.0 / (min_duration / 1000000000.0)
-        print "FPS measured %.1f, max advertized %.1f" %(actual_fps, max_fps)
-        assert(max_fps - FPS_MAX_DIFF <= actual_fps <= max_fps)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_param_color_correction.py b/apps/CameraITS/tests/scene1/test_param_color_correction.py
deleted file mode 100644
index 82f2342..0000000
--- a/apps/CameraITS/tests/scene1/test_param_color_correction.py
+++ /dev/null
@@ -1,105 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that the android.colorCorrection.* params are applied when set.
-
-    Takes shots with different transform and gains values, and tests that
-    they look correspondingly different. The transform and gains are chosen
-    to make the output go redder or bluer.
-
-    Uses a linear tonemap.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    THRESHOLD_MAX_DIFF = 0.1
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        # Baseline request
-        e, s = its.target.get_target_exposure_combos(cam)["midSensitivity"]
-        req = its.objects.manual_capture_request(s, e, True)
-        req["android.colorCorrection.mode"] = 0
-
-        # Transforms:
-        # 1. Identity
-        # 2. Identity
-        # 3. Boost blue
-        transforms = [its.objects.int_to_rational([1,0,0, 0,1,0, 0,0,1]),
-                      its.objects.int_to_rational([1,0,0, 0,1,0, 0,0,1]),
-                      its.objects.int_to_rational([1,0,0, 0,1,0, 0,0,2])]
-
-        # Gains:
-        # 1. Unit
-        # 2. Boost red
-        # 3. Unit
-        gains = [[1,1,1,1], [2,1,1,1], [1,1,1,1]]
-
-        r_means = []
-        g_means = []
-        b_means = []
-
-        # Capture requests:
-        # 1. With unit gains, and identity transform.
-        # 2. With a higher red gain, and identity transform.
-        # 3. With unit gains, and a transform that boosts blue.
-        for i in range(len(transforms)):
-            req["android.colorCorrection.transform"] = transforms[i]
-            req["android.colorCorrection.gains"] = gains[i]
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_req=%d.jpg" % (NAME, i))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means = its.image.compute_image_means(tile)
-            r_means.append(rgb_means[0])
-            g_means.append(rgb_means[1])
-            b_means.append(rgb_means[2])
-            ratios = [rgb_means[0] / rgb_means[1], rgb_means[2] / rgb_means[1]]
-            print "Means = ", rgb_means, "   Ratios =", ratios
-
-        # Draw a plot.
-        domain = range(len(transforms))
-        pylab.plot(domain, r_means, 'r')
-        pylab.plot(domain, g_means, 'g')
-        pylab.plot(domain, b_means, 'b')
-        pylab.ylim([0,1])
-        matplotlib.pyplot.savefig("%s_plot_means.png" % (NAME))
-
-        # Expect G0 == G1 == G2, R0 == 0.5*R1 == R2, B0 == B1 == 0.5*B2
-        # Also need to ensure that the imasge is not clamped to white/black.
-        assert(all(g_means[i] > 0.2 and g_means[i] < 0.8 for i in xrange(3)))
-        assert(abs(g_means[1] - g_means[0]) < THRESHOLD_MAX_DIFF)
-        assert(abs(g_means[2] - g_means[1]) < THRESHOLD_MAX_DIFF)
-        assert(abs(r_means[2] - r_means[0]) < THRESHOLD_MAX_DIFF)
-        assert(abs(r_means[1] - 2.0 * r_means[0]) < THRESHOLD_MAX_DIFF)
-        assert(abs(b_means[1] - b_means[0]) < THRESHOLD_MAX_DIFF)
-        assert(abs(b_means[2] - 2.0 * b_means[0]) < THRESHOLD_MAX_DIFF)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_param_exposure_time.py b/apps/CameraITS/tests/scene1/test_param_exposure_time.py
deleted file mode 100644
index 390fd3c..0000000
--- a/apps/CameraITS/tests/scene1/test_param_exposure_time.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that the android.sensor.exposureTime parameter is applied.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    exp_times = []
-    r_means = []
-    g_means = []
-    b_means = []
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        e,s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        for i,e_mult in enumerate([0.8, 0.9, 1.0, 1.1, 1.2]):
-            req = its.objects.manual_capture_request(s, e * e_mult, True)
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(
-                    img, "%s_frame%d.jpg" % (NAME, i))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means = its.image.compute_image_means(tile)
-            exp_times.append(e * e_mult)
-            r_means.append(rgb_means[0])
-            g_means.append(rgb_means[1])
-            b_means.append(rgb_means[2])
-
-    # Draw a plot.
-    pylab.plot(exp_times, r_means, 'r')
-    pylab.plot(exp_times, g_means, 'g')
-    pylab.plot(exp_times, b_means, 'b')
-    pylab.ylim([0,1])
-    matplotlib.pyplot.savefig("%s_plot_means.png" % (NAME))
-
-    # Test for pass/fail: check that each shot is brighter than the previous.
-    for means in [r_means, g_means, b_means]:
-        for i in range(len(means)-1):
-            assert(means[i+1] > means[i])
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_param_flash_mode.py b/apps/CameraITS/tests/scene1/test_param_flash_mode.py
deleted file mode 100644
index 6d1be4f..0000000
--- a/apps/CameraITS/tests/scene1/test_param_flash_mode.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os.path
-
-def main():
-    """Test that the android.flash.mode parameter is applied.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        flash_modes_reported = []
-        flash_states_reported = []
-        g_means = []
-
-        # Manually set the exposure to be a little on the dark side, so that
-        # it should be obvious whether the flash fired or not, and use a
-        # linear tonemap.
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        e /= 4
-        req = its.objects.manual_capture_request(s, e, True)
-
-        for f in [0,1,2]:
-            req["android.flash.mode"] = f
-            cap = cam.do_capture(req)
-            flash_modes_reported.append(cap["metadata"]["android.flash.mode"])
-            flash_states_reported.append(cap["metadata"]["android.flash.state"])
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_mode=%d.jpg" % (NAME, f))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb = its.image.compute_image_means(tile)
-            g_means.append(rgb[1])
-
-        assert(flash_modes_reported == [0,1,2])
-        assert(flash_states_reported[0] not in [3,4])
-        assert(flash_states_reported[1] in [3,4])
-        assert(flash_states_reported[2] in [3,4])
-
-        print "G brightnesses:", g_means
-        assert(g_means[1] > g_means[0])
-        assert(g_means[2] > g_means[0])
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_param_noise_reduction.py b/apps/CameraITS/tests/scene1/test_param_noise_reduction.py
deleted file mode 100644
index 618f8a7..0000000
--- a/apps/CameraITS/tests/scene1/test_param_noise_reduction.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that the android.noiseReduction.mode param is applied when set.
-
-    Capture images with the camera dimly lit. Uses a high analog gain to
-    ensure the captured image is noisy.
-
-    Captures three images, for NR off, "fast", and "high quality".
-    Also captures an image with low gain and NR off, and uses the variance
-    of this as the baseline.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    # List of variances for Y,U,V.
-    variances = [[],[],[]]
-
-    # Reference (baseline) variance for each of Y,U,V.
-    ref_variance = []
-
-    nr_modes_reported = []
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        # NR mode 0 with low gain
-        e, s = its.target.get_target_exposure_combos(cam)["minSensitivity"]
-        req = its.objects.manual_capture_request(s, e)
-        req["android.noiseReduction.mode"] = 0
-        cap = cam.do_capture(req)
-        its.image.write_image(
-                its.image.convert_capture_to_rgb_image(cap),
-                "%s_low_gain.jpg" % (NAME))
-        planes = its.image.convert_capture_to_planes(cap)
-        for j in range(3):
-            img = planes[j]
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            ref_variance.append(its.image.compute_image_variances(tile)[0])
-        print "Ref variances:", ref_variance
-
-        for i in range(3):
-            # NR modes 0, 1, 2 with high gain
-            e, s = its.target.get_target_exposure_combos(cam)["maxSensitivity"]
-            req = its.objects.manual_capture_request(s, e)
-            req["android.noiseReduction.mode"] = i
-            cap = cam.do_capture(req)
-            nr_modes_reported.append(
-                    cap["metadata"]["android.noiseReduction.mode"])
-            its.image.write_image(
-                    its.image.convert_capture_to_rgb_image(cap),
-                    "%s_high_gain_nr=%d.jpg" % (NAME, i))
-            planes = its.image.convert_capture_to_planes(cap)
-            for j in range(3):
-                img = planes[j]
-                tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-                variance = its.image.compute_image_variances(tile)[0]
-                variances[j].append(variance / ref_variance[j])
-        print "Variances with NR mode [0,1,2]:", variances
-
-    # Draw a plot.
-    for j in range(3):
-        pylab.plot(range(3), variances[j], "rgb"[j])
-    matplotlib.pyplot.savefig("%s_plot_variances.png" % (NAME))
-
-    assert(nr_modes_reported == [0,1,2])
-
-    # Check that the variance of the NR=0 image is higher than for the
-    # NR=1 and NR=2 images.
-    for j in range(3):
-        for i in range(1,3):
-            assert(variances[j][i] < variances[j][0])
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_param_sensitivity.py b/apps/CameraITS/tests/scene1/test_param_sensitivity.py
deleted file mode 100644
index c26e9f9..0000000
--- a/apps/CameraITS/tests/scene1/test_param_sensitivity.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Test that the android.sensor.sensitivity parameter is applied.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    NUM_STEPS = 5
-
-    sensitivities = None
-    r_means = []
-    g_means = []
-    b_means = []
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        expt,_ = its.target.get_target_exposure_combos(cam)["midSensitivity"]
-        sens_range = props['android.sensor.info.sensitivityRange']
-        sens_step = (sens_range[1] - sens_range[0]) / float(NUM_STEPS-1)
-        sensitivities = [sens_range[0] + i * sens_step for i in range(NUM_STEPS)]
-
-        for s in sensitivities:
-            req = its.objects.manual_capture_request(s, expt)
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(
-                    img, "%s_iso=%04d.jpg" % (NAME, s))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means = its.image.compute_image_means(tile)
-            r_means.append(rgb_means[0])
-            g_means.append(rgb_means[1])
-            b_means.append(rgb_means[2])
-
-    # Draw a plot.
-    pylab.plot(sensitivities, r_means, 'r')
-    pylab.plot(sensitivities, g_means, 'g')
-    pylab.plot(sensitivities, b_means, 'b')
-    pylab.ylim([0,1])
-    matplotlib.pyplot.savefig("%s_plot_means.png" % (NAME))
-
-    # Test for pass/fail: check that each shot is brighter than the previous.
-    for means in [r_means, g_means, b_means]:
-        for i in range(len(means)-1):
-            assert(means[i+1] > means[i])
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_param_tonemap_mode.py b/apps/CameraITS/tests/scene1/test_param_tonemap_mode.py
deleted file mode 100644
index fbd452c..0000000
--- a/apps/CameraITS/tests/scene1/test_param_tonemap_mode.py
+++ /dev/null
@@ -1,104 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os
-import os.path
-
-def main():
-    """Test that the android.tonemap.mode param is applied.
-
-    Applies different tonemap curves to each R,G,B channel, and checks
-    that the output images are modified as expected.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    THRESHOLD_RATIO_MIN_DIFF = 0.1
-    THRESHOLD_DIFF_MAX_DIFF = 0.05
-
-    # The HAL3.2 spec requires that curves up to 64 control points in length
-    # must be supported.
-    L = 32
-    LM1 = float(L-1)
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        e /= 2
-
-        # Test 1: that the tonemap curves have the expected effect. Take two
-        # shots, with n in [0,1], where each has a linear tonemap, with the
-        # n=1 shot having a steeper gradient. The gradient for each R,G,B
-        # channel increases (i.e.) R[n=1] should be brighter than R[n=0],
-        # and G[n=1] should be brighter than G[n=0] by a larger margin, etc.
-        rgb_means = []
-
-        for n in [0,1]:
-            req = its.objects.manual_capture_request(s,e)
-            req["android.tonemap.mode"] = 0
-            req["android.tonemap.curveRed"] = (
-                    sum([[i/LM1, min(1.0,(1+0.5*n)*i/LM1)] for i in range(L)], []))
-            req["android.tonemap.curveGreen"] = (
-                    sum([[i/LM1, min(1.0,(1+1.0*n)*i/LM1)] for i in range(L)], []))
-            req["android.tonemap.curveBlue"] = (
-                    sum([[i/LM1, min(1.0,(1+1.5*n)*i/LM1)] for i in range(L)], []))
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(
-                    img, "%s_n=%d.jpg" %(NAME, n))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means.append(its.image.compute_image_means(tile))
-
-        rgb_ratios = [rgb_means[1][i] / rgb_means[0][i] for i in xrange(3)]
-        print "Test 1: RGB ratios:", rgb_ratios
-        assert(rgb_ratios[0] + THRESHOLD_RATIO_MIN_DIFF < rgb_ratios[1])
-        assert(rgb_ratios[1] + THRESHOLD_RATIO_MIN_DIFF < rgb_ratios[2])
-
-
-        # Test 2: that the length of the tonemap curve (i.e. number of control
-        # points) doesn't affect the output.
-        rgb_means = []
-
-        for size in [32,64]:
-            m = float(size-1)
-            curve = sum([[i/m, i/m] for i in range(size)], [])
-            req = its.objects.manual_capture_request(s,e)
-            req["android.tonemap.mode"] = 0
-            req["android.tonemap.curveRed"] = curve
-            req["android.tonemap.curveGreen"] = curve
-            req["android.tonemap.curveBlue"] = curve
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(
-                    img, "%s_size=%02d.jpg" %(NAME, size))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb_means.append(its.image.compute_image_means(tile))
-
-        rgb_diffs = [rgb_means[1][i] - rgb_means[0][i] for i in xrange(3)]
-        print "Test 2: RGB diffs:", rgb_diffs
-        assert(abs(rgb_diffs[0]) < THRESHOLD_DIFF_MAX_DIFF)
-        assert(abs(rgb_diffs[1]) < THRESHOLD_DIFF_MAX_DIFF)
-        assert(abs(rgb_diffs[2]) < THRESHOLD_DIFF_MAX_DIFF)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_raw_burst_sensitivity.py b/apps/CameraITS/tests/scene1/test_raw_burst_sensitivity.py
deleted file mode 100644
index bf0e2ea..0000000
--- a/apps/CameraITS/tests/scene1/test_raw_burst_sensitivity.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.caps
-import its.objects
-import its.image
-import os.path
-import pylab
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Capture a set of raw images with increasing gains and measure the noise.
-
-    Capture raw-only, in a burst.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    # Each shot must be 1% noisier (by the variance metric) than the previous
-    # one.
-    VAR_THRESH = 1.01
-
-    NUM_STEPS = 5
-
-    with its.device.ItsSession() as cam:
-
-        props = cam.get_camera_properties()
-        if not its.caps.raw16(props) or \
-           not its.caps.manual_sensor(props) or \
-           not its.caps.read_3a(props):
-            print "Test skipped"
-            return
-
-        # Expose for the scene with min sensitivity
-        sens_min, sens_max = props['android.sensor.info.sensitivityRange']
-        sens_step = (sens_max - sens_min) / NUM_STEPS
-        s_ae,e_ae,_,_,_  = cam.do_3a(get_results=True)
-        s_e_prod = s_ae * e_ae
-
-        reqs = []
-        settings = []
-        for s in range(sens_min, sens_max, sens_step):
-            e = int(s_e_prod / float(s))
-            req = its.objects.manual_capture_request(s, e)
-            reqs.append(req)
-            settings.append((s,e))
-
-        caps = cam.do_capture(reqs, cam.CAP_RAW)
-
-        variances = []
-        for i,cap in enumerate(caps):
-            (s,e) = settings[i]
-
-            # Measure the variance. Each shot should be noisier than the
-            # previous shot (as the gain is increasing).
-            plane = its.image.convert_capture_to_planes(cap, props)[1]
-            tile = its.image.get_image_patch(plane, 0.45,0.45,0.1,0.1)
-            var = its.image.compute_image_variances(tile)[0]
-            variances.append(var)
-
-            img = its.image.convert_capture_to_rgb_image(cap, props=props)
-            its.image.write_image(img, "%s_s=%05d_var=%f.jpg" % (NAME,s,var))
-            print "s=%d, e=%d, var=%e"%(s,e,var)
-
-        pylab.plot(range(len(variances)), variances)
-        matplotlib.pyplot.savefig("%s_variances.png" % (NAME))
-
-        # Test that each shot is noisier than the previous one.
-        for i in range(len(variances) - 1):
-            assert(variances[i] < variances[i+1] / VAR_THRESH)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_raw_sensitivity.py b/apps/CameraITS/tests/scene1/test_raw_sensitivity.py
deleted file mode 100644
index 8e36219..0000000
--- a/apps/CameraITS/tests/scene1/test_raw_sensitivity.py
+++ /dev/null
@@ -1,79 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.caps
-import its.objects
-import its.image
-import os.path
-import pylab
-import matplotlib
-import matplotlib.pyplot
-
-def main():
-    """Capture a set of raw images with increasing gains and measure the noise.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    # Each shot must be 1% noisier (by the variance metric) than the previous
-    # one.
-    VAR_THRESH = 1.01
-
-    NUM_STEPS = 5
-
-    with its.device.ItsSession() as cam:
-
-        props = cam.get_camera_properties()
-        if (not its.caps.raw16(props) or
-            not its.caps.manual_sensor(props) or
-            not its.caps.read_3a(props)):
-            print "Test skipped"
-            return
-
-        # Expose for the scene with min sensitivity
-        sens_min, sens_max = props['android.sensor.info.sensitivityRange']
-        sens_step = (sens_max - sens_min) / NUM_STEPS
-        s_ae,e_ae,_,_,_  = cam.do_3a(get_results=True)
-        s_e_prod = s_ae * e_ae
-
-        variances = []
-        for s in range(sens_min, sens_max, sens_step):
-
-            e = int(s_e_prod / float(s))
-            req = its.objects.manual_capture_request(s, e)
-
-            # Capture raw+yuv, but only look at the raw.
-            cap,_ = cam.do_capture(req, cam.CAP_RAW_YUV)
-
-            # Measure the variance. Each shot should be noisier than the
-            # previous shot (as the gain is increasing).
-            plane = its.image.convert_capture_to_planes(cap, props)[1]
-            tile = its.image.get_image_patch(plane, 0.45,0.45,0.1,0.1)
-            var = its.image.compute_image_variances(tile)[0]
-            variances.append(var)
-
-            img = its.image.convert_capture_to_rgb_image(cap, props=props)
-            its.image.write_image(img, "%s_s=%05d_var=%f.jpg" % (NAME,s,var))
-            print "s=%d, e=%d, var=%e"%(s,e,var)
-
-        pylab.plot(range(len(variances)), variances)
-        matplotlib.pyplot.savefig("%s_variances.png" % (NAME))
-
-        # Test that each shot is noisier than the previous one.
-        for i in range(len(variances) - 1):
-            assert(variances[i] < variances[i+1] / VAR_THRESH)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_tonemap_sequence.py b/apps/CameraITS/tests/scene1/test_tonemap_sequence.py
deleted file mode 100644
index 7af51c5..0000000
--- a/apps/CameraITS/tests/scene1/test_tonemap_sequence.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import os.path
-import numpy
-
-def main():
-    """Test a sequence of shots with different tonemap curves.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    # There should be 3 identical frames followed by a different set of
-    # 3 identical frames.
-    MAX_SAME_DELTA = 0.01
-    MIN_DIFF_DELTA = 0.10
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if (not its.caps.manual_sensor(props) or
-            not its.caps.manual_post_proc(props)):
-            print "Test skipped"
-            return
-
-        sens, exp_time, _,_,_ = cam.do_3a(do_af=False,get_results=True)
-
-        means = []
-
-        # Capture 3 manual shots with a linear tonemap.
-        req = its.objects.manual_capture_request(sens, exp_time, True)
-        for i in [0,1,2]:
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_i=%d.jpg" % (NAME, i))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            means.append(tile.mean(0).mean(0))
-
-        # Capture 3 manual shots with the default tonemap.
-        req = its.objects.manual_capture_request(sens, exp_time, False)
-        for i in [3,4,5]:
-            cap = cam.do_capture(req)
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_i=%d.jpg" % (NAME, i))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            means.append(tile.mean(0).mean(0))
-
-        # Compute the delta between each consecutive frame pair.
-        deltas = [numpy.max(numpy.fabs(means[i+1]-means[i])) \
-                  for i in range(len(means)-1)]
-        print "Deltas between consecutive frames:", deltas
-
-        assert(all([abs(deltas[i]) < MAX_SAME_DELTA for i in [0,1,3,4]]))
-        assert(abs(deltas[2]) > MIN_DIFF_DELTA)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_yuv_jpeg_all.py b/apps/CameraITS/tests/scene1/test_yuv_jpeg_all.py
deleted file mode 100644
index 2367ca2..0000000
--- a/apps/CameraITS/tests/scene1/test_yuv_jpeg_all.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os.path
-import math
-
-def main():
-    """Test that the reported sizes and formats for image capture work.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    THRESHOLD_MAX_RMS_DIFF = 0.03
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        # Use a manual request with a linear tonemap so that the YUV and JPEG
-        # should look the same (once converted by the its.image module).
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        req = its.objects.manual_capture_request(s, e, True)
-
-        rgbs = []
-
-        for size in its.objects.get_available_output_sizes("yuv", props):
-            out_surface = {"width":size[0], "height":size[1], "format":"yuv"}
-            cap = cam.do_capture(req, out_surface)
-            assert(cap["format"] == "yuv")
-            assert(cap["width"] == size[0])
-            assert(cap["height"] == size[1])
-            print "Captured YUV %dx%d" % (cap["width"], cap["height"])
-            img = its.image.convert_capture_to_rgb_image(cap)
-            its.image.write_image(img, "%s_yuv_w%d_h%d.jpg"%(
-                    NAME,size[0],size[1]))
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb = its.image.compute_image_means(tile)
-            rgbs.append(rgb)
-
-        for size in its.objects.get_available_output_sizes("jpg", props):
-            out_surface = {"width":size[0], "height":size[1], "format":"jpg"}
-            cap = cam.do_capture(req, out_surface)
-            assert(cap["format"] == "jpeg")
-            assert(cap["width"] == size[0])
-            assert(cap["height"] == size[1])
-            img = its.image.decompress_jpeg_to_rgb_image(cap["data"])
-            its.image.write_image(img, "%s_jpg_w%d_h%d.jpg"%(
-                    NAME,size[0], size[1]))
-            assert(img.shape[0] == size[1])
-            assert(img.shape[1] == size[0])
-            assert(img.shape[2] == 3)
-            print "Captured JPEG %dx%d" % (cap["width"], cap["height"])
-            tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-            rgb = its.image.compute_image_means(tile)
-            rgbs.append(rgb)
-
-        max_diff = 0
-        rgb0 = rgbs[0]
-        for rgb1 in rgbs[1:]:
-            rms_diff = math.sqrt(
-                    sum([pow(rgb0[i] - rgb1[i], 2.0) for i in range(3)]) / 3.0)
-            max_diff = max(max_diff, rms_diff)
-        print "Max RMS difference:", max_diff
-        assert(rms_diff < THRESHOLD_MAX_RMS_DIFF)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_yuv_plus_dng.py b/apps/CameraITS/tests/scene1/test_yuv_plus_dng.py
deleted file mode 100644
index 4924c7b..0000000
--- a/apps/CameraITS/tests/scene1/test_yuv_plus_dng.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import os.path
-
-def main():
-    """Test capturing a single frame as both DNG and YUV outputs.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if (not its.caps.raw(props) or
-            not its.caps.read_3a(props)):
-            print "Test skipped"
-            return
-
-        cam.do_3a()
-
-        req = its.objects.auto_capture_request()
-        cap_dng, cap_yuv = cam.do_capture(req, cam.CAP_DNG_YUV)
-
-        img = its.image.convert_capture_to_rgb_image(cap_yuv)
-        its.image.write_image(img, "%s.jpg" % (NAME))
-
-        with open("%s.dng"%(NAME), "wb") as f:
-            f.write(cap_dng["data"])
-
-        # No specific pass/fail check; test is assumed to have succeeded if
-        # it completes.
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_yuv_plus_jpeg.py b/apps/CameraITS/tests/scene1/test_yuv_plus_jpeg.py
deleted file mode 100644
index 15aa17c..0000000
--- a/apps/CameraITS/tests/scene1/test_yuv_plus_jpeg.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os.path
-import math
-
-def main():
-    """Test capturing a single frame as both YUV and JPEG outputs.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    THRESHOLD_MAX_RMS_DIFF = 0.01
-
-    fmt_yuv =  {"format":"yuv"}
-    fmt_jpeg = {"format":"jpeg"}
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if not its.caps.compute_target_exposure(props):
-            print "Test skipped"
-            return
-
-        # Use a manual request with a linear tonemap so that the YUV and JPEG
-        # should look the same (once converted by the its.image module).
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        req = its.objects.manual_capture_request(s, e, True)
-
-        cap_yuv, cap_jpeg = cam.do_capture(req, [fmt_yuv, fmt_jpeg])
-
-        img = its.image.convert_capture_to_rgb_image(cap_yuv, True)
-        its.image.write_image(img, "%s_yuv.jpg" % (NAME))
-        tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-        rgb0 = its.image.compute_image_means(tile)
-
-        img = its.image.convert_capture_to_rgb_image(cap_jpeg, True)
-        its.image.write_image(img, "%s_jpeg.jpg" % (NAME))
-        tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-        rgb1 = its.image.compute_image_means(tile)
-
-        rms_diff = math.sqrt(
-                sum([pow(rgb0[i] - rgb1[i], 2.0) for i in range(3)]) / 3.0)
-        print "RMS difference:", rms_diff
-        assert(rms_diff < THRESHOLD_MAX_RMS_DIFF)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_yuv_plus_raw.py b/apps/CameraITS/tests/scene1/test_yuv_plus_raw.py
deleted file mode 100644
index 7a345c9..0000000
--- a/apps/CameraITS/tests/scene1/test_yuv_plus_raw.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os.path
-import math
-
-def main():
-    """Test capturing a single frame as both RAW and YUV outputs.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    THRESHOLD_MAX_RMS_DIFF = 0.02
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-        if (not its.caps.compute_target_exposure(props) or
-            not its.caps.raw16(props)):
-            print "Test skipped"
-            return
-
-        # Use a manual request with a linear tonemap so that the YUV and RAW
-        # should look the same (once converted by the its.image module).
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        req = its.objects.manual_capture_request(s, e, True)
-
-        cap_raw, cap_yuv = cam.do_capture(req, cam.CAP_RAW_YUV)
-
-        img = its.image.convert_capture_to_rgb_image(cap_yuv)
-        its.image.write_image(img, "%s_yuv.jpg" % (NAME), True)
-        tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-        rgb0 = its.image.compute_image_means(tile)
-
-        # Raw shots are 1/2 x 1/2 smaller after conversion to RGB, so scale the
-        # tile appropriately.
-        img = its.image.convert_capture_to_rgb_image(cap_raw, props=props)
-        its.image.write_image(img, "%s_raw.jpg" % (NAME), True)
-        tile = its.image.get_image_patch(img, 0.475, 0.475, 0.05, 0.05)
-        rgb1 = its.image.compute_image_means(tile)
-
-        rms_diff = math.sqrt(
-                sum([pow(rgb0[i] - rgb1[i], 2.0) for i in range(3)]) / 3.0)
-        print "RMS difference:", rms_diff
-        assert(rms_diff < THRESHOLD_MAX_RMS_DIFF)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/scene1/test_yuv_plus_raw10.py b/apps/CameraITS/tests/scene1/test_yuv_plus_raw10.py
deleted file mode 100644
index 15612c5..0000000
--- a/apps/CameraITS/tests/scene1/test_yuv_plus_raw10.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.image
-import its.caps
-import its.device
-import its.objects
-import its.target
-import os.path
-import math
-
-def main():
-    """Test capturing a single frame as both RAW10 and YUV outputs.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    THRESHOLD_MAX_RMS_DIFF = 0.02
-
-    with its.device.ItsSession() as cam:
-        props = cam.get_camera_properties()
-
-        if (not its.caps.compute_target_exposure(props) or
-            not its.caps.raw10(props)):
-            print "Test skipped"
-            return
-
-        # Use a manual request with a linear tonemap so that the YUV and RAW
-        # should look the same (once converted by the its.image module).
-        e, s = its.target.get_target_exposure_combos(cam)["midExposureTime"]
-        req = its.objects.manual_capture_request(s, e, True)
-
-        cap_raw, cap_yuv = cam.do_capture(req,
-                [{"format":"raw10"}, {"format":"yuv"}])
-
-        img = its.image.convert_capture_to_rgb_image(cap_yuv)
-        its.image.write_image(img, "%s_yuv.jpg" % (NAME), True)
-        tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1)
-        rgb0 = its.image.compute_image_means(tile)
-
-        # Raw shots are 1/2 x 1/2 smaller after conversion to RGB, so scale the
-        # tile appropriately.
-        img = its.image.convert_capture_to_rgb_image(cap_raw, props=props)
-        its.image.write_image(img, "%s_raw.jpg" % (NAME), True)
-        tile = its.image.get_image_patch(img, 0.475, 0.475, 0.05, 0.05)
-        rgb1 = its.image.compute_image_means(tile)
-
-        rms_diff = math.sqrt(
-                sum([pow(rgb0[i] - rgb1[i], 2.0) for i in range(3)]) / 3.0)
-        print "RMS difference:", rms_diff
-        assert(rms_diff < THRESHOLD_MAX_RMS_DIFF)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tests/tutorial.py b/apps/CameraITS/tests/tutorial.py
deleted file mode 100644
index 1b1999e..0000000
--- a/apps/CameraITS/tests/tutorial.py
+++ /dev/null
@@ -1,188 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# --------------------------------------------------------------------------- #
-# The Google Python style guide should be used for scripts:                   #
-# http://google-styleguide.googlecode.com/svn/trunk/pyguide.html              #
-# --------------------------------------------------------------------------- #
-
-# The ITS modules that are in the pymodules/its/ directory. To see formatted
-# docs, use the "pydoc" command:
-#
-# > pydoc its.image
-#
-import its.image
-import its.device
-import its.objects
-import its.target
-
-# Standard Python modules.
-import os.path
-import pprint
-import math
-
-# Modules from the numpy, scipy, and matplotlib libraries. These are used for
-# the image processing code, and images are represented as numpy arrays.
-import pylab
-import numpy
-import matplotlib
-import matplotlib.pyplot
-
-# Each script has a "main" function.
-def main():
-
-    # Each script has a string description of what it does. This is the first
-    # entry inside the main function.
-    """Tutorial script to show how to use the ITS infrastructure.
-    """
-
-    # A convention in each script is to use the filename (without the extension)
-    # as the name of the test, when printing results to the screen or dumping
-    # files.
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    # The standard way to open a session with a connected camera device. This
-    # creates a cam object which encapsulates the session and which is active
-    # within the scope of the "with" block; when the block exits, the camera
-    # session is closed.
-    with its.device.ItsSession() as cam:
-
-        # Get the static properties of the camera device. Returns a Python
-        # associative array object; print it to the console.
-        props = cam.get_camera_properties()
-        pprint.pprint(props)
-
-        # Grab a YUV frame with manual exposure of sensitivity = 200, exposure
-        # duration = 50ms.
-        req = its.objects.manual_capture_request(200, 50*1000*1000)
-        cap = cam.do_capture(req)
-
-        # Print the properties of the captured frame; width and height are
-        # integers, and the metadata is a Python associative array object.
-        print "Captured image width:", cap["width"]
-        print "Captured image height:", cap["height"]
-        pprint.pprint(cap["metadata"])
-
-        # The captured image is YUV420. Convert to RGB, and save as a file.
-        rgbimg = its.image.convert_capture_to_rgb_image(cap)
-        its.image.write_image(rgbimg, "%s_rgb_1.jpg" % (NAME))
-
-        # Can also get the Y,U,V planes separately; save these to greyscale
-        # files.
-        yimg,uimg,vimg = its.image.convert_capture_to_planes(cap)
-        its.image.write_image(yimg, "%s_y_plane_1.jpg" % (NAME))
-        its.image.write_image(uimg, "%s_u_plane_1.jpg" % (NAME))
-        its.image.write_image(vimg, "%s_v_plane_1.jpg" % (NAME))
-
-        # Run 3A on the device. In this case, just use the entire image as the
-        # 3A region, and run each of AWB,AE,AF. Can also change the region and
-        # specify independently for each of AE,AWB,AF whether it should run.
-        #
-        # NOTE: This may fail, if the camera isn't pointed at a reasonable
-        # target scene. If it fails, the script will end. The logcat messages
-        # can be inspected to see the status of 3A running on the device.
-        #
-        # > adb logcat -s 'ItsService:v'
-        #
-        # If this keeps on failing, try also rebooting the device before
-        # running the test.
-        sens, exp, gains, xform, focus = cam.do_3a(get_results=True)
-        print "AE: sensitivity %d, exposure %dms" % (sens, exp/1000000.0)
-        print "AWB: gains", gains, "transform", xform
-        print "AF: distance", focus
-
-        # Grab a new manual frame, using the 3A values, and convert it to RGB
-        # and save it to a file too. Note that the "req" object is just a
-        # Python dictionary that is pre-populated by the its.objets module
-        # functions (in this case a default manual capture), and the key/value
-        # pairs in the object can be used to set any field of the capture
-        # request. Here, the AWB gains and transform (CCM) are being used.
-        # Note that the CCM transform is in a rational format in capture
-        # requests, meaning it is an object with integer numerators and
-        # denominators. The 3A routine returns simple floats instead, however,
-        # so a conversion from float to rational must be performed.
-        req = its.objects.manual_capture_request(sens, exp)
-        xform_rat = its.objects.float_to_rational(xform)
-
-        req["android.colorCorrection.transform"] = xform_rat
-        req["android.colorCorrection.gains"] = gains
-        cap = cam.do_capture(req)
-        rgbimg = its.image.convert_capture_to_rgb_image(cap)
-        its.image.write_image(rgbimg, "%s_rgb_2.jpg" % (NAME))
-
-        # Print out the actual capture request object that was used.
-        pprint.pprint(req)
-
-        # Images are numpy arrays. The dimensions are (h,w,3) when indexing,
-        # in the case of RGB images. Greyscale images are (h,w,1). Pixels are
-        # generally float32 values in the [0,1] range, however some of the
-        # helper functions in its.image deal with the packed YUV420 and other
-        # formats of images that come from the device (and convert them to
-        # float32).
-        # Print the dimensions of the image, and the top-left pixel value,
-        # which is an array of 3 floats.
-        print "RGB image dimensions:", rgbimg.shape
-        print "RGB image top-left pixel:", rgbimg[0,0]
-
-        # Grab a center tile from the image; this returns a new image. Save
-        # this tile image. In this case, the tile is the middle 10% x 10%
-        # rectangle.
-        tile = its.image.get_image_patch(rgbimg, 0.45, 0.45, 0.1, 0.1)
-        its.image.write_image(tile, "%s_rgb_2_tile.jpg" % (NAME))
-
-        # Compute the mean values of the center tile image.
-        rgb_means = its.image.compute_image_means(tile)
-        print "RGB means:", rgb_means
-
-        # Apply a lookup table to the image, and save the new version. The LUT
-        # is basically a tonemap, and can be used to implement a gamma curve.
-        # In this case, the LUT is used to double the value of each pixel.
-        lut = numpy.array([2*i for i in xrange(65536)])
-        rgbimg_lut = its.image.apply_lut_to_image(rgbimg, lut)
-        its.image.write_image(rgbimg_lut, "%s_rgb_2_lut.jpg" % (NAME))
-
-        # Apply a 3x3 matrix to the image, and save the new version. The matrix
-        # is a numpy array, in row major order, and the pixel values are right-
-        # multipled to it (when considered as column vectors). The example
-        # matrix here just boosts the blue channel by 10%.
-        mat = numpy.array([[1, 0, 0  ],
-                           [0, 1, 0  ],
-                           [0, 0, 1.1]])
-        rgbimg_mat = its.image.apply_matrix_to_image(rgbimg, mat)
-        its.image.write_image(rgbimg_mat, "%s_rgb_2_mat.jpg" % (NAME))
-
-        # Compute a histogram of the luma image, in 256 buckeits.
-        yimg,_,_ = its.image.convert_capture_to_planes(cap)
-        hist,_ = numpy.histogram(yimg*255, 256, (0,256))
-
-        # Plot the histogram using matplotlib, and save as a PNG image.
-        pylab.plot(range(256), hist.tolist())
-        pylab.xlabel("Luma DN")
-        pylab.ylabel("Pixel count")
-        pylab.title("Histogram of luma channel of captured image")
-        matplotlib.pyplot.savefig("%s_histogram.png" % (NAME))
-
-        # Capture a frame to be returned as a JPEG. Load it as an RGB image,
-        # then save it back as a JPEG.
-        cap = cam.do_capture(req, cam.CAP_JPEG)
-        rgbimg = its.image.convert_capture_to_rgb_image(cap)
-        its.image.write_image(rgbimg, "%s_jpg.jpg" % (NAME))
-        r,g,b = its.image.convert_capture_to_planes(cap)
-        its.image.write_image(r, "%s_r.jpg" % (NAME))
-
-# This is the standard boilerplate in each test that allows the script to both
-# be executed directly and imported as a module.
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tools/compute_dng_noise_model.py b/apps/CameraITS/tools/compute_dng_noise_model.py
deleted file mode 100644
index e089ffc..0000000
--- a/apps/CameraITS/tools/compute_dng_noise_model.py
+++ /dev/null
@@ -1,175 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.objects
-import its.image
-import pprint
-import pylab
-import os.path
-import matplotlib
-import matplotlib.pyplot
-import numpy
-import math
-
-def main():
-    """Compute the DNG noise model from a color checker chart.
-
-    TODO: Make this more robust; some manual futzing may be needed.
-    """
-    NAME = os.path.basename(__file__).split(".")[0]
-
-    with its.device.ItsSession() as cam:
-
-        props = cam.get_camera_properties()
-
-        white_level = float(props['android.sensor.info.whiteLevel'])
-        black_levels = props['android.sensor.blackLevelPattern']
-        idxs = its.image.get_canonical_cfa_order(props)
-        black_levels = [black_levels[i] for i in idxs]
-
-        # Expose for the scene with min sensitivity
-        sens_min, sens_max = props['android.sensor.info.sensitivityRange']
-        s_ae,e_ae,awb_gains,awb_ccm,_  = cam.do_3a(get_results=True)
-        s_e_prod = s_ae * e_ae
-
-        # Make the image brighter since the script looks at linear Bayer
-        # raw patches rather than gamma-encoded YUV patches (and the AE
-        # probably under-exposes a little for this use-case).
-        s_e_prod *= 2
-
-        # Capture raw frames across the full sensitivity range.
-        NUM_SENS_STEPS = 15
-        sens_step = int((sens_max - sens_min - 1) / float(NUM_SENS_STEPS))
-        reqs = []
-        sens = []
-        for s in range(sens_min, sens_max, sens_step):
-            e = int(s_e_prod / float(s))
-            req = its.objects.manual_capture_request(s, e)
-            req["android.colorCorrection.transform"] = \
-                    its.objects.float_to_rational(awb_ccm)
-            req["android.colorCorrection.gains"] = awb_gains
-            reqs.append(req)
-            sens.append(s)
-
-        caps = cam.do_capture(reqs, cam.CAP_RAW)
-
-        # A list of the (x,y) coords of the center pixel of a collection of
-        # patches of a color checker chart. Each patch should be uniform,
-        # however the actual color doesn't matter. Note that the coords are
-        # relative to the *converted* RGB image, which is 1/2 x 1/2 of the
-        # full size; convert back to full.
-        img = its.image.convert_capture_to_rgb_image(caps[0], props=props)
-        patches = its.image.get_color_checker_chart_patches(img, NAME+"_debug")
-        patches = [(2*x,2*y) for (x,y) in sum(patches,[])]
-
-        lines = []
-        for (s,cap) in zip(sens,caps):
-            # For each capture, compute the mean value in each patch, for each
-            # Bayer plane; discard patches where pixels are close to clamped.
-            # Also compute the variance.
-            CLAMP_THRESH = 0.2
-            planes = its.image.convert_capture_to_planes(cap, props)
-            points = []
-            for i,plane in enumerate(planes):
-                plane = (plane * white_level - black_levels[i]) / (
-                        white_level - black_levels[i])
-                for j,(x,y) in enumerate(patches):
-                    tile = plane[y/2-16:y/2+16:,x/2-16:x/2+16:,::]
-                    mean = its.image.compute_image_means(tile)[0]
-                    var = its.image.compute_image_variances(tile)[0]
-                    if (mean > CLAMP_THRESH and mean < 1.0-CLAMP_THRESH):
-                        # Each point is a (mean,variance) tuple for a patch;
-                        # for a given ISO, there should be a linear
-                        # relationship between these values.
-                        points.append((mean,var))
-
-            # Fit a line to the points, with a line equation: y = mx + b.
-            # This line is the relationship between mean and variance (i.e.)
-            # between signal level and noise, for this particular sensor.
-            # In the DNG noise model, the gradient (m) is "S", and the offset
-            # (b) is "O".
-            points.sort()
-            xs = [x for (x,y) in points]
-            ys = [y for (x,y) in points]
-            m,b = numpy.polyfit(xs, ys, 1)
-            lines.append((s,m,b))
-            print s, "->", m, b
-
-            # TODO: Clean up these checks (which currently fail in some cases).
-            # Some sanity checks:
-            # * Noise levels should increase with brightness.
-            # * Extrapolating to a black image, the noise should be positive.
-            # Basically, the "b" value should correspnd to the read noise,
-            # which is the noise level if the sensor was operating in zero
-            # light.
-            #assert(m > 0)
-            #assert(b >= 0)
-
-            # Draw a plot.
-            pylab.plot(xs, ys, 'r')
-            pylab.plot([0,xs[-1]],[b,m*xs[-1]+b],'b')
-            matplotlib.pyplot.savefig("%s_plot_mean_vs_variance.png" % (NAME))
-
-        # Now fit a line across the (m,b) line parameters for each sensitivity.
-        # The gradient (m) params are fit to the "S" line, and the offset (b)
-        # params are fit to the "O" line, both as a function of sensitivity.
-        gains = [d[0] for d in lines]
-        Ss = [d[1] for d in lines]
-        Os = [d[2] for d in lines]
-        mS,bS = numpy.polyfit(gains, Ss, 1)
-        mO,bO = numpy.polyfit(gains, Os, 1)
-
-        # Plot curve "O" as 10x, so it fits in the same scale as curve "S".
-        pylab.plot(gains, [10*o for o in Os], 'r')
-        pylab.plot([gains[0],gains[-1]],
-                [10*mO*gains[0]+10*bO, 10*mO*gains[-1]+10*bO], 'b')
-        pylab.plot(gains, Ss, 'r')
-        pylab.plot([gains[0],gains[-1]], [mS*gains[0]+bS, mS*gains[-1]+bS], 'b')
-        matplotlib.pyplot.savefig("%s_plot_S_O.png" % (NAME))
-
-        print """
-        /* Generated test code to dump a table of data for external validation
-         * of the noise model parameters.
-         */
-        #include <stdio.h>
-        #include <assert.h>
-        double compute_noise_model_entry_S(int sens);
-        double compute_noise_model_entry_O(int sens);
-        int main(void) {
-            int sens;
-            for (sens = %d; sens <= %d; sens += 100) {
-                double o = compute_noise_model_entry_O(sens);
-                double s = compute_noise_model_entry_S(sens);
-                printf("%%d,%%lf,%%lf\\n", sens, o, s);
-            }
-            return 0;
-        }
-
-        /* Generated functions to map a given sensitivity to the O and S noise
-         * model parameters in the DNG noise model.
-         */
-        double compute_noise_model_entry_S(int sens) {
-            double s = %e * sens + %e;
-            return s < 0.0 ? 0.0 : s;
-        }
-        double compute_noise_model_entry_O(int sens) {
-            double o = %e * sens + %e;
-            return o < 0.0 ? 0.0 : o;
-        }
-        """%(sens_min,sens_max,mS,bS,mO,bO)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tools/config.py b/apps/CameraITS/tools/config.py
deleted file mode 100644
index 6e83412..0000000
--- a/apps/CameraITS/tools/config.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# Copyright 2013 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import its.device
-import its.target
-import sys
-
-def main():
-    """Set the target exposure.
-
-    This program is just a wrapper around the its.target module, to allow the
-    functions in it to be invoked from the command line.
-
-    Usage:
-        python config.py        - Measure the target exposure, and cache it.
-        python config.py EXP    - Hard-code (and cache) the target exposure.
-
-    The "reboot" or "reboot=<N>" and "camera=<N>" arguments may also be
-    provided, just as with all the test scripts. The "target" argument is
-    may also be provided but it has no effect on this script since the cached
-    exposure value is cleared regardless.
-
-    If no exposure value is provided, the camera will be used to measure
-    the scene and set a level that will result in the luma (with linear
-    tonemap) being at the 0.5 level. This requires camera 3A and capture
-    to be functioning.
-
-    For bring-up purposes, the exposure value may be manually set to a hard-
-    coded value, without the camera having to be able to perform 3A (or even
-    capture a shot reliably).
-    """
-
-    # Command line args, ignoring any args that will be passed down to the
-    # ItsSession constructor.
-    args = [s for s in sys.argv if s[:6] not in \
-            ["reboot", "camera", "target", "noinit"]]
-
-    if len(args) == 1:
-        with its.device.ItsSession() as cam:
-            # Automatically measure target exposure.
-            its.target.clear_cached_target_exposure()
-            exposure = its.target.get_target_exposure(cam)
-    elif len(args) == 2:
-        # Hard-code the target exposure.
-        exposure = int(args[1])
-        its.target.set_hardcoded_exposure(exposure)
-    else:
-        print "Usage: python %s [EXPOSURE]"
-        sys.exit(0)
-    print "New target exposure set to", exposure
-    print "This corresponds to %dms at ISO 100" % int(exposure/100/1000000.0)
-
-if __name__ == '__main__':
-    main()
-
diff --git a/apps/CameraITS/tools/run_all_tests.py b/apps/CameraITS/tools/run_all_tests.py
deleted file mode 100644
index 4677331..0000000
--- a/apps/CameraITS/tools/run_all_tests.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# Copyright 2014 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import os.path
-import tempfile
-import subprocess
-import time
-import sys
-
-def main():
-    """Run all the automated tests, saving intermediate files, and producing
-    a summary/report of the results.
-
-    Script should be run from the top-level CameraITS directory.
-    """
-
-    # Get all the scene0 and scene1 tests, which can be run using the same
-    # physical setup.
-    scenes = ["scene0", "scene1"]
-    tests = []
-    for d in scenes:
-        tests += [(d,s[:-3],os.path.join("tests", d, s))
-                  for s in os.listdir(os.path.join("tests",d))
-                  if s[-3:] == ".py"]
-    tests.sort()
-
-    # Make output directories to hold the generated files.
-    topdir = tempfile.mkdtemp()
-    for d in scenes:
-        os.mkdir(os.path.join(topdir, d))
-    print "Saving output files to:", topdir, "\n"
-
-    # Run each test, capturing stdout and stderr.
-    numpass = 0
-    for (scene,testname,testpath) in tests:
-        cmd = ['python', os.path.join(os.getcwd(),testpath)] + sys.argv[1:]
-        outdir = os.path.join(topdir,scene)
-        outpath = os.path.join(outdir,testname+"_stdout.txt")
-        errpath = os.path.join(outdir,testname+"_stderr.txt")
-        t0 = time.time()
-        with open(outpath,"w") as fout, open(errpath,"w") as ferr:
-            retcode = subprocess.call(cmd,stderr=ferr,stdout=fout,cwd=outdir)
-        t1 = time.time()
-        print "%s %s/%s [%.1fs]" % (
-                "PASS" if retcode==0 else "FAIL", scene, testname, t1-t0)
-        if retcode == 0:
-            numpass += 1
-
-    print "\n%d / %d tests passed (%.1f%%)" % (
-            numpass, len(tests), 100.0*float(numpass)/len(tests))
-
-if __name__ == '__main__':
-    main()
-