void assertArrayNotEmpty(T arr, String message) {
assertTrue(message, arr != null && Array.getLength(arr) > 0);
}
/**
* Check if the format is a legal YUV format camera supported.
*/
public static void checkYuvFormat(int format) {
if ((format != ImageFormat.YUV_420_888) &&
(format != ImageFormat.NV21) &&
(format != ImageFormat.YV12)) {
fail("Wrong formats: " + format);
}
}
/**
* Check if image size and format match given size and format.
*/
public static void checkImage(Image image, int width, int height, int format) {
// Image reader will wrap YV12/NV21 image by YUV_420_888
if (format == ImageFormat.NV21 || format == ImageFormat.YV12) {
format = ImageFormat.YUV_420_888;
}
assertNotNull("Input image is invalid", image);
assertEquals("Format doesn't match", format, image.getFormat());
assertEquals("Width doesn't match", width, image.getWidth());
assertEquals("Height doesn't match", height, image.getHeight());
}
/**
* Read data from all planes of an Image into a contiguous unpadded, unpacked
* 1-D linear byte array, such that it can be write into disk, or accessed by
* software conveniently. It supports YUV_420_888/NV21/YV12 and JPEG input
* Image format.
*
* For YUV_420_888/NV21/YV12/Y8/Y16, it returns a byte array that contains
* the Y plane data first, followed by U(Cb), V(Cr) planes if there is any
* (xstride = width, ystride = height for chroma and luma components).
*
* For JPEG, it returns a 1-D byte array contains a complete JPEG image.
*/
public static byte[] getDataFromImage(Image image) {
assertNotNull("Invalid image:", image);
int format = image.getFormat();
int width = image.getWidth();
int height = image.getHeight();
int rowStride, pixelStride;
byte[] data = null;
// Read image data
Plane[] planes = image.getPlanes();
assertTrue("Fail to get image planes", planes != null && planes.length > 0);
// Check image validity
checkAndroidImageFormat(image);
ByteBuffer buffer = null;
// JPEG doesn't have pixelstride and rowstride, treat it as 1D buffer.
// Same goes for DEPTH_POINT_CLOUD, RAW_PRIVATE, DEPTH_JPEG, and HEIC
if (format == ImageFormat.JPEG || format == ImageFormat.DEPTH_POINT_CLOUD ||
format == ImageFormat.RAW_PRIVATE || format == ImageFormat.DEPTH_JPEG ||
format == ImageFormat.HEIC) {
buffer = planes[0].getBuffer();
assertNotNull("Fail to get jpeg/depth/heic ByteBuffer", buffer);
data = new byte[buffer.remaining()];
buffer.get(data);
buffer.rewind();
return data;
}
int offset = 0;
data = new byte[width * height * ImageFormat.getBitsPerPixel(format) / 8];
int maxRowSize = planes[0].getRowStride();
for (int i = 0; i < planes.length; i++) {
if (maxRowSize < planes[i].getRowStride()) {
maxRowSize = planes[i].getRowStride();
}
}
byte[] rowData = new byte[maxRowSize];
if(VERBOSE) Log.v(TAG, "get data from " + planes.length + " planes");
for (int i = 0; i < planes.length; i++) {
buffer = planes[i].getBuffer();
assertNotNull("Fail to get bytebuffer from plane", buffer);
rowStride = planes[i].getRowStride();
pixelStride = planes[i].getPixelStride();
assertTrue("pixel stride " + pixelStride + " is invalid", pixelStride > 0);
if (VERBOSE) {
Log.v(TAG, "pixelStride " + pixelStride);
Log.v(TAG, "rowStride " + rowStride);
Log.v(TAG, "width " + width);
Log.v(TAG, "height " + height);
}
// 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;
assertTrue("rowStride " + rowStride + " should be >= width " + w , rowStride >= w);
for (int row = 0; row < h; row++) {
int bytesPerPixel = ImageFormat.getBitsPerPixel(format) / 8;
int length;
if (pixelStride == bytesPerPixel) {
// Special case: optimized read of the entire row
length = w * bytesPerPixel;
buffer.get(data, offset, 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
length = (w - 1) * pixelStride + bytesPerPixel;
buffer.get(rowData, 0, length);
for (int col = 0; col < w; col++) {
data[offset++] = rowData[col * pixelStride];
}
}
// Advance buffer the remainder of the row stride
if (row < h - 1) {
buffer.position(buffer.position() + rowStride - length);
}
}
if (VERBOSE) Log.v(TAG, "Finished reading data from plane " + i);
buffer.rewind();
}
return data;
}
/**
* Check android image format validity for an image, only support below formats:
*
* YUV_420_888/NV21/YV12, can add more for future
*/
public static void checkAndroidImageFormat(Image image) {
int format = image.getFormat();
Plane[] planes = image.getPlanes();
switch (format) {
case ImageFormat.YUV_420_888:
case ImageFormat.NV21:
case ImageFormat.YV12:
assertEquals("YUV420 format Images should have 3 planes", 3, planes.length);
break;
case ImageFormat.JPEG:
case ImageFormat.RAW_SENSOR:
case ImageFormat.RAW_PRIVATE:
case ImageFormat.DEPTH16:
case ImageFormat.DEPTH_POINT_CLOUD:
case ImageFormat.DEPTH_JPEG:
case ImageFormat.Y8:
case ImageFormat.HEIC:
assertEquals("JPEG/RAW/depth/Y8 Images should have one plane", 1, planes.length);
break;
default:
fail("Unsupported Image Format: " + format);
}
}
public static void dumpFile(String fileName, Bitmap data) {
FileOutputStream outStream;
try {
Log.v(TAG, "output will be saved as " + fileName);
outStream = new FileOutputStream(fileName);
} catch (IOException ioe) {
throw new RuntimeException("Unable to create debug output file " + fileName, ioe);
}
try {
data.compress(Bitmap.CompressFormat.JPEG, /*quality*/90, outStream);
outStream.close();
} catch (IOException ioe) {
throw new RuntimeException("failed writing data to file " + fileName, ioe);
}
}
public static void dumpFile(String fileName, byte[] data) {
FileOutputStream outStream;
try {
Log.v(TAG, "output will be saved as " + fileName);
outStream = new FileOutputStream(fileName);
} catch (IOException ioe) {
throw new RuntimeException("Unable to create debug output file " + fileName, ioe);
}
try {
outStream.write(data);
outStream.close();
} catch (IOException ioe) {
throw new RuntimeException("failed writing data to file " + fileName, ioe);
}
}
/**
* Get the available output sizes for the user-defined {@code format}.
*
* Note that implementation-defined/hidden formats are not supported.
*/
public static Size[] getSupportedSizeForFormat(int format, String cameraId,
CameraManager cameraManager) throws CameraAccessException {
CameraCharacteristics properties = cameraManager.getCameraCharacteristics(cameraId);
assertNotNull("Can't get camera characteristics!", properties);
if (VERBOSE) {
Log.v(TAG, "get camera characteristics for camera: " + cameraId);
}
StreamConfigurationMap configMap =
properties.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
Size[] availableSizes = configMap.getOutputSizes(format);
assertArrayNotEmpty(availableSizes, "availableSizes should not be empty for format: "
+ format);
Size[] highResAvailableSizes = configMap.getHighResolutionOutputSizes(format);
if (highResAvailableSizes != null && highResAvailableSizes.length > 0) {
Size[] allSizes = new Size[availableSizes.length + highResAvailableSizes.length];
System.arraycopy(availableSizes, 0, allSizes, 0,
availableSizes.length);
System.arraycopy(highResAvailableSizes, 0, allSizes, availableSizes.length,
highResAvailableSizes.length);
availableSizes = allSizes;
}
if (VERBOSE) Log.v(TAG, "Supported sizes are: " + Arrays.deepToString(availableSizes));
return availableSizes;
}
/**
* Get the available output sizes for the given class.
*
*/
public static Size[] getSupportedSizeForClass(Class klass, String cameraId,
CameraManager cameraManager) throws CameraAccessException {
CameraCharacteristics properties = cameraManager.getCameraCharacteristics(cameraId);
assertNotNull("Can't get camera characteristics!", properties);
if (VERBOSE) {
Log.v(TAG, "get camera characteristics for camera: " + cameraId);
}
StreamConfigurationMap configMap =
properties.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
Size[] availableSizes = configMap.getOutputSizes(klass);
assertArrayNotEmpty(availableSizes, "availableSizes should not be empty for class: "
+ klass);
Size[] highResAvailableSizes = configMap.getHighResolutionOutputSizes(ImageFormat.PRIVATE);
if (highResAvailableSizes != null && highResAvailableSizes.length > 0) {
Size[] allSizes = new Size[availableSizes.length + highResAvailableSizes.length];
System.arraycopy(availableSizes, 0, allSizes, 0,
availableSizes.length);
System.arraycopy(highResAvailableSizes, 0, allSizes, availableSizes.length,
highResAvailableSizes.length);
availableSizes = allSizes;
}
if (VERBOSE) Log.v(TAG, "Supported sizes are: " + Arrays.deepToString(availableSizes));
return availableSizes;
}
/**
* Size comparator that compares the number of pixels it covers.
*
* If two the areas of two sizes are same, compare the widths.
*/
public static class SizeComparator implements Comparator {
@Override
public int compare(Size lhs, Size rhs) {
return CameraUtils
.compareSizes(lhs.getWidth(), lhs.getHeight(), rhs.getWidth(), rhs.getHeight());
}
}
/**
* Get sorted size list in descending order. Remove the sizes larger than
* the bound. If the bound is null, don't do the size bound filtering.
*/
static public List getSupportedPreviewSizes(String cameraId,
CameraManager cameraManager, Size bound) throws CameraAccessException {
Size[] rawSizes = getSupportedSizeForClass(android.view.SurfaceHolder.class, cameraId,
cameraManager);
assertArrayNotEmpty(rawSizes,
"Available sizes for SurfaceHolder class should not be empty");
if (VERBOSE) {
Log.v(TAG, "Supported sizes are: " + Arrays.deepToString(rawSizes));
}
if (bound == null) {
return getAscendingOrderSizes(Arrays.asList(rawSizes), /*ascending*/false);
}
List sizes = new ArrayList();
for (Size sz: rawSizes) {
if (sz.getWidth() <= bound.getWidth() && sz.getHeight() <= bound.getHeight()) {
sizes.add(sz);
}
}
return getAscendingOrderSizes(sizes, /*ascending*/false);
}
/**
* Get a sorted list of sizes from a given size list.
*
*
* The size is compare by area it covers, if the areas are same, then
* compare the widths.
*
*
* @param sizeList The input size list to be sorted
* @param ascending True if the order is ascending, otherwise descending order
* @return The ordered list of sizes
*/
static public List getAscendingOrderSizes(final List sizeList, boolean ascending) {
if (sizeList == null) {
throw new IllegalArgumentException("sizeList shouldn't be null");
}
Comparator comparator = new SizeComparator();
List sortedSizes = new ArrayList();
sortedSizes.addAll(sizeList);
Collections.sort(sortedSizes, comparator);
if (!ascending) {
Collections.reverse(sortedSizes);
}
return sortedSizes;
}
/**
* Get sorted (descending order) size list for given format. Remove the sizes larger than
* the bound. If the bound is null, don't do the size bound filtering.
*/
static public List getSortedSizesForFormat(String cameraId,
CameraManager cameraManager, int format, Size bound) throws CameraAccessException {
Comparator comparator = new SizeComparator();
Size[] sizes = getSupportedSizeForFormat(format, cameraId, cameraManager);
List sortedSizes = null;
if (bound != null) {
sortedSizes = new ArrayList(/*capacity*/1);
for (Size sz : sizes) {
if (comparator.compare(sz, bound) <= 0) {
sortedSizes.add(sz);
}
}
} else {
sortedSizes = Arrays.asList(sizes);
}
assertTrue("Supported size list should have at least one element",
sortedSizes.size() > 0);
Collections.sort(sortedSizes, comparator);
// Make it in descending order.
Collections.reverse(sortedSizes);
return sortedSizes;
}
/**
* Get supported video size list for a given camera device.
*
*
* Filter out the sizes that are larger than the bound. If the bound is
* null, don't do the size bound filtering.
*
*/
static public List getSupportedVideoSizes(String cameraId,
CameraManager cameraManager, Size bound) throws CameraAccessException {
Size[] rawSizes = getSupportedSizeForClass(android.media.MediaRecorder.class,
cameraId, cameraManager);
assertArrayNotEmpty(rawSizes,
"Available sizes for MediaRecorder class should not be empty");
if (VERBOSE) {
Log.v(TAG, "Supported sizes are: " + Arrays.deepToString(rawSizes));
}
if (bound == null) {
return getAscendingOrderSizes(Arrays.asList(rawSizes), /*ascending*/false);
}
List sizes = new ArrayList();
for (Size sz: rawSizes) {
if (sz.getWidth() <= bound.getWidth() && sz.getHeight() <= bound.getHeight()) {
sizes.add(sz);
}
}
return getAscendingOrderSizes(sizes, /*ascending*/false);
}
/**
* Get supported video size list (descending order) for a given camera device.
*
*
* Filter out the sizes that are larger than the bound. If the bound is
* null, don't do the size bound filtering.
*
*/
static public List getSupportedStillSizes(String cameraId,
CameraManager cameraManager, Size bound) throws CameraAccessException {
return getSortedSizesForFormat(cameraId, cameraManager, ImageFormat.JPEG, bound);
}
static public List getSupportedHeicSizes(String cameraId,
CameraManager cameraManager, Size bound) throws CameraAccessException {
return getSortedSizesForFormat(cameraId, cameraManager, ImageFormat.HEIC, bound);
}
static public Size getMinPreviewSize(String cameraId, CameraManager cameraManager)
throws CameraAccessException {
List sizes = getSupportedPreviewSizes(cameraId, cameraManager, null);
return sizes.get(sizes.size() - 1);
}
/**
* Get max supported preview size for a camera device.
*/
static public Size getMaxPreviewSize(String cameraId, CameraManager cameraManager)
throws CameraAccessException {
return getMaxPreviewSize(cameraId, cameraManager, /*bound*/null);
}
/**
* Get max preview size for a camera device in the supported sizes that are no larger
* than the bound.
*/
static public Size getMaxPreviewSize(String cameraId, CameraManager cameraManager, Size bound)
throws CameraAccessException {
List sizes = getSupportedPreviewSizes(cameraId, cameraManager, bound);
return sizes.get(0);
}
/**
* Get max depth size for a camera device.
*/
static public Size getMaxDepthSize(String cameraId, CameraManager cameraManager)
throws CameraAccessException {
List sizes = getSortedSizesForFormat(cameraId, cameraManager, ImageFormat.DEPTH16,
/*bound*/ null);
return sizes.get(0);
}
/**
* Get the largest size by area.
*
* @param sizes an array of sizes, must have at least 1 element
*
* @return Largest Size
*
* @throws IllegalArgumentException if sizes was null or had 0 elements
*/
public static Size getMaxSize(Size... sizes) {
if (sizes == null || sizes.length == 0) {
throw new IllegalArgumentException("sizes was empty");
}
Size sz = sizes[0];
for (Size size : sizes) {
if (size.getWidth() * size.getHeight() > sz.getWidth() * sz.getHeight()) {
sz = size;
}
}
return sz;
}
/**
* Get the largest size by area within (less than) bound
*
* @param sizes an array of sizes, must have at least 1 element
*
* @return Largest Size. Null if no such size exists within bound.
*
* @throws IllegalArgumentException if sizes was null or had 0 elements, or bound is invalid.
*/
public static Size getMaxSizeWithBound(Size[] sizes, int bound) {
if (sizes == null || sizes.length == 0) {
throw new IllegalArgumentException("sizes was empty");
}
if (bound <= 0) {
throw new IllegalArgumentException("bound is invalid");
}
Size sz = null;
for (Size size : sizes) {
if (size.getWidth() * size.getHeight() >= bound) {
continue;
}
if (sz == null ||
size.getWidth() * size.getHeight() > sz.getWidth() * sz.getHeight()) {
sz = size;
}
}
return sz;
}
/**
* Returns true if the given {@code array} contains the given element.
*
* @param array {@code array} to check for {@code elem}
* @param elem {@code elem} to test for
* @return {@code true} if the given element is contained
*/
public static boolean contains(int[] array, int elem) {
if (array == null) return false;
for (int i = 0; i < array.length; i++) {
if (elem == array[i]) return true;
}
return false;
}
/**
* Get object array from byte array.
*
* @param array Input byte array to be converted
* @return Byte object array converted from input byte array
*/
public static Byte[] toObject(byte[] array) {
return convertPrimitiveArrayToObjectArray(array, Byte.class);
}
/**
* Get object array from int array.
*
* @param array Input int array to be converted
* @return Integer object array converted from input int array
*/
public static Integer[] toObject(int[] array) {
return convertPrimitiveArrayToObjectArray(array, Integer.class);
}
/**
* Get object array from float array.
*
* @param array Input float array to be converted
* @return Float object array converted from input float array
*/
public static Float[] toObject(float[] array) {
return convertPrimitiveArrayToObjectArray(array, Float.class);
}
/**
* Get object array from double array.
*
* @param array Input double array to be converted
* @return Double object array converted from input double array
*/
public static Double[] toObject(double[] array) {
return convertPrimitiveArrayToObjectArray(array, Double.class);
}
/**
* Convert a primitive input array into its object array version (e.g. from int[] to Integer[]).
*
* @param array Input array object
* @param wrapperClass The boxed class it converts to
* @return Boxed version of primitive array
*/
private static T[] convertPrimitiveArrayToObjectArray(final Object array,
final Class wrapperClass) {
// getLength does the null check and isArray check already.
int arrayLength = Array.getLength(array);
if (arrayLength == 0) {
throw new IllegalArgumentException("Input array shouldn't be empty");
}
@SuppressWarnings("unchecked")
final T[] result = (T[]) Array.newInstance(wrapperClass, arrayLength);
for (int i = 0; i < arrayLength; i++) {
Array.set(result, i, Array.get(array, i));
}
return result;
}
/**
* Validate image based on format and size.
*
* @param image The image to be validated.
* @param width The image width.
* @param height The image height.
* @param format The image format.
* @param filePath The debug dump file path, null if don't want to dump to
* file.
* @throws UnsupportedOperationException if calling with an unknown format
*/
public static void validateImage(Image image, int width, int height, int format,
String filePath) {
checkImage(image, width, height, format);
/**
* TODO: validate timestamp:
* 1. capture result timestamp against the image timestamp (need
* consider frame drops)
* 2. timestamps should be monotonically increasing for different requests
*/
if(VERBOSE) Log.v(TAG, "validating Image");
byte[] data = getDataFromImage(image);
assertTrue("Invalid image data", data != null && data.length > 0);
switch (format) {
// Clients must be able to process and handle depth jpeg images like any other
// regular jpeg.
case ImageFormat.DEPTH_JPEG:
case ImageFormat.JPEG:
validateJpegData(data, width, height, filePath);
break;
case ImageFormat.YUV_420_888:
case ImageFormat.YV12:
validateYuvData(data, width, height, format, image.getTimestamp(), filePath);
break;
case ImageFormat.RAW_SENSOR:
validateRaw16Data(data, width, height, format, image.getTimestamp(), filePath);
break;
case ImageFormat.DEPTH16:
validateDepth16Data(data, width, height, format, image.getTimestamp(), filePath);
break;
case ImageFormat.DEPTH_POINT_CLOUD:
validateDepthPointCloudData(data, width, height, format, image.getTimestamp(), filePath);
break;
case ImageFormat.RAW_PRIVATE:
validateRawPrivateData(data, width, height, image.getTimestamp(), filePath);
break;
case ImageFormat.Y8:
validateY8Data(data, width, height, format, image.getTimestamp(), filePath);
break;
case ImageFormat.HEIC:
validateHeicData(data, width, height, filePath);
break;
default:
throw new UnsupportedOperationException("Unsupported format for validation: "
+ format);
}
}
public static class HandlerExecutor implements Executor {
private final Handler mHandler;
public HandlerExecutor(Handler handler) {
assertNotNull("handler must be valid", handler);
mHandler = handler;
}
@Override
public void execute(Runnable runCmd) {
mHandler.post(runCmd);
}
}
/**
* Provide a mock for {@link CameraDevice.StateCallback}.
*
* Only useful because mockito can't mock {@link CameraDevice.StateCallback} which is an
* abstract class.
*
*
* Use this instead of other classes when needing to verify interactions, since
* trying to spy on {@link BlockingStateCallback} (or others) will cause unnecessary extra
* interactions which will cause false test failures.
*
*
*/
public static class MockStateCallback extends CameraDevice.StateCallback {
@Override
public void onOpened(CameraDevice camera) {
}
@Override
public void onDisconnected(CameraDevice camera) {
}
@Override
public void onError(CameraDevice camera, int error) {
}
private MockStateCallback() {}
/**
* Create a Mockito-ready mocked StateCallback.
*/
public static MockStateCallback mock() {
return Mockito.spy(new MockStateCallback());
}
}
private static void validateJpegData(byte[] jpegData, int width, int height, String filePath) {
BitmapFactory.Options bmpOptions = new BitmapFactory.Options();
// DecodeBound mode: only parse the frame header to get width/height.
// it doesn't decode the pixel.
bmpOptions.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(jpegData, 0, jpegData.length, bmpOptions);
assertEquals(width, bmpOptions.outWidth);
assertEquals(height, bmpOptions.outHeight);
// Pixel decoding mode: decode whole image. check if the image data
// is decodable here.
assertNotNull("Decoding jpeg failed",
BitmapFactory.decodeByteArray(jpegData, 0, jpegData.length));
if (DEBUG && filePath != null) {
String fileName =
filePath + "/" + width + "x" + height + ".jpeg";
dumpFile(fileName, jpegData);
}
}
private static void validateYuvData(byte[] yuvData, int width, int height, int format,
long ts, String filePath) {
checkYuvFormat(format);
if (VERBOSE) Log.v(TAG, "Validating YUV data");
int expectedSize = width * height * ImageFormat.getBitsPerPixel(format) / 8;
assertEquals("Yuv data doesn't match", expectedSize, yuvData.length);
// TODO: Can add data validation for test pattern.
if (DEBUG && filePath != null) {
String fileName =
filePath + "/" + width + "x" + height + "_" + ts / 1e6 + ".yuv";
dumpFile(fileName, yuvData);
}
}
private static void validateRaw16Data(byte[] rawData, int width, int height, int format,
long ts, String filePath) {
if (VERBOSE) Log.v(TAG, "Validating raw data");
int expectedSize = width * height * ImageFormat.getBitsPerPixel(format) / 8;
assertEquals("Raw data doesn't match", expectedSize, rawData.length);
// TODO: Can add data validation for test pattern.
if (DEBUG && filePath != null) {
String fileName =
filePath + "/" + width + "x" + height + "_" + ts / 1e6 + ".raw16";
dumpFile(fileName, rawData);
}
return;
}
private static void validateY8Data(byte[] rawData, int width, int height, int format,
long ts, String filePath) {
if (VERBOSE) Log.v(TAG, "Validating Y8 data");
int expectedSize = width * height * ImageFormat.getBitsPerPixel(format) / 8;
assertEquals("Y8 data doesn't match", expectedSize, rawData.length);
// TODO: Can add data validation for test pattern.
if (DEBUG && filePath != null) {
String fileName =
filePath + "/" + width + "x" + height + "_" + ts / 1e6 + ".y8";
dumpFile(fileName, rawData);
}
return;
}
private static void validateRawPrivateData(byte[] rawData, int width, int height,
long ts, String filePath) {
if (VERBOSE) Log.v(TAG, "Validating private raw data");
// Expect each RAW pixel should occupy at least one byte and no more than 30 bytes
int expectedSizeMin = width * height;
int expectedSizeMax = width * height * 30;
assertTrue("Opaque RAW size " + rawData.length + "out of normal bound [" +
expectedSizeMin + "," + expectedSizeMax + "]",
expectedSizeMin <= rawData.length && rawData.length <= expectedSizeMax);
if (DEBUG && filePath != null) {
String fileName =
filePath + "/" + width + "x" + height + "_" + ts / 1e6 + ".rawPriv";
dumpFile(fileName, rawData);
}
return;
}
private static void validateDepth16Data(byte[] depthData, int width, int height, int format,
long ts, String filePath) {
if (VERBOSE) Log.v(TAG, "Validating depth16 data");
int expectedSize = width * height * ImageFormat.getBitsPerPixel(format) / 8;
assertEquals("Depth data doesn't match", expectedSize, depthData.length);
if (DEBUG && filePath != null) {
String fileName =
filePath + "/" + width + "x" + height + "_" + ts / 1e6 + ".depth16";
dumpFile(fileName, depthData);
}
return;
}
private static void validateDepthPointCloudData(byte[] depthData, int width, int height, int format,
long ts, String filePath) {
if (VERBOSE) Log.v(TAG, "Validating depth point cloud data");
// Can't validate size since it is variable
if (DEBUG && filePath != null) {
String fileName =
filePath + "/" + width + "x" + height + "_" + ts / 1e6 + ".depth_point_cloud";
dumpFile(fileName, depthData);
}
return;
}
private static void validateHeicData(byte[] heicData, int width, int height, String filePath) {
BitmapFactory.Options bmpOptions = new BitmapFactory.Options();
// DecodeBound mode: only parse the frame header to get width/height.
// it doesn't decode the pixel.
bmpOptions.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(heicData, 0, heicData.length, bmpOptions);
assertEquals(width, bmpOptions.outWidth);
assertEquals(height, bmpOptions.outHeight);
// Pixel decoding mode: decode whole image. check if the image data
// is decodable here.
assertNotNull("Decoding heic failed",
BitmapFactory.decodeByteArray(heicData, 0, heicData.length));
if (DEBUG && filePath != null) {
String fileName =
filePath + "/" + width + "x" + height + ".heic";
dumpFile(fileName, heicData);
}
}
public static T getValueNotNull(CaptureResult result, CaptureResult.Key key) {
if (result == null) {
throw new IllegalArgumentException("Result must not be null");
}
T value = result.get(key);
assertNotNull("Value of Key " + key.getName() + "shouldn't be null", value);
return value;
}
public static T getValueNotNull(CameraCharacteristics characteristics,
CameraCharacteristics.Key key) {
if (characteristics == null) {
throw new IllegalArgumentException("Camera characteristics must not be null");
}
T value = characteristics.get(key);
assertNotNull("Value of Key " + key.getName() + "shouldn't be null", value);
return value;
}
/**
* Get a crop region for a given zoom factor and center position.
*
* The center position is normalized position in range of [0, 1.0], where
* (0, 0) represents top left corner, (1.0. 1.0) represents bottom right
* corner. The center position could limit the effective minimal zoom
* factor, for example, if the center position is (0.75, 0.75), the
* effective minimal zoom position becomes 2.0. If the requested zoom factor
* is smaller than 2.0, a crop region with 2.0 zoom factor will be returned.
*
*
* The aspect ratio of the crop region is maintained the same as the aspect
* ratio of active array.
*
*
* @param zoomFactor The zoom factor to generate the crop region, it must be
* >= 1.0
* @param center The normalized zoom center point that is in the range of [0, 1].
* @param maxZoom The max zoom factor supported by this device.
* @param activeArray The active array size of this device.
* @return crop region for the given normalized center and zoom factor.
*/
public static Rect getCropRegionForZoom(float zoomFactor, final PointF center,
final float maxZoom, final Rect activeArray) {
if (zoomFactor < 1.0) {
throw new IllegalArgumentException("zoom factor " + zoomFactor + " should be >= 1.0");
}
if (center.x > 1.0 || center.x < 0) {
throw new IllegalArgumentException("center.x " + center.x
+ " should be in range of [0, 1.0]");
}
if (center.y > 1.0 || center.y < 0) {
throw new IllegalArgumentException("center.y " + center.y
+ " should be in range of [0, 1.0]");
}
if (maxZoom < 1.0) {
throw new IllegalArgumentException("max zoom factor " + maxZoom + " should be >= 1.0");
}
if (activeArray == null) {
throw new IllegalArgumentException("activeArray must not be null");
}
float minCenterLength = Math.min(Math.min(center.x, 1.0f - center.x),
Math.min(center.y, 1.0f - center.y));
float minEffectiveZoom = 0.5f / minCenterLength;
if (minEffectiveZoom > maxZoom) {
throw new IllegalArgumentException("Requested center " + center.toString() +
" has minimal zoomable factor " + minEffectiveZoom + ", which exceeds max"
+ " zoom factor " + maxZoom);
}
if (zoomFactor < minEffectiveZoom) {
Log.w(TAG, "Requested zoomFactor " + zoomFactor + " < minimal zoomable factor "
+ minEffectiveZoom + ". It will be overwritten by " + minEffectiveZoom);
zoomFactor = minEffectiveZoom;
}
int cropCenterX = (int)(activeArray.width() * center.x);
int cropCenterY = (int)(activeArray.height() * center.y);
int cropWidth = (int) (activeArray.width() / zoomFactor);
int cropHeight = (int) (activeArray.height() / zoomFactor);
return new Rect(
/*left*/cropCenterX - cropWidth / 2,
/*top*/cropCenterY - cropHeight / 2,
/*right*/ cropCenterX + cropWidth / 2 - 1,
/*bottom*/cropCenterY + cropHeight / 2 - 1);
}
/**
* Get AeAvailableTargetFpsRanges and sort them in descending order by max fps
*
* @param staticInfo camera static metadata
* @return AeAvailableTargetFpsRanges in descending order by max fps
*/
public static Range[] getDescendingTargetFpsRanges(StaticMetadata staticInfo) {
Range[] fpsRanges = staticInfo.getAeAvailableTargetFpsRangesChecked();
Arrays.sort(fpsRanges, new Comparator>() {
public int compare(Range r1, Range r2) {
return r2.getUpper() - r1.getUpper();
}
});
return fpsRanges;
}
/**
* Get AeAvailableTargetFpsRanges with max fps not exceeding 30
*
* @param staticInfo camera static metadata
* @return AeAvailableTargetFpsRanges with max fps not exceeding 30
*/
public static List> getTargetFpsRangesUpTo30(StaticMetadata staticInfo) {
Range[] fpsRanges = staticInfo.getAeAvailableTargetFpsRangesChecked();
ArrayList> fpsRangesUpTo30 = new ArrayList>();
for (Range fpsRange : fpsRanges) {
if (fpsRange.getUpper() <= 30) {
fpsRangesUpTo30.add(fpsRange);
}
}
return fpsRangesUpTo30;
}
/**
* Get AeAvailableTargetFpsRanges with max fps greater than 30
*
* @param staticInfo camera static metadata
* @return AeAvailableTargetFpsRanges with max fps greater than 30
*/
public static List> getTargetFpsRangesGreaterThan30(StaticMetadata staticInfo) {
Range[] fpsRanges = staticInfo.getAeAvailableTargetFpsRangesChecked();
ArrayList> fpsRangesGreaterThan30 = new ArrayList>();
for (Range fpsRange : fpsRanges) {
if (fpsRange.getUpper() > 30) {
fpsRangesGreaterThan30.add(fpsRange);
}
}
return fpsRangesGreaterThan30;
}
/**
* Calculate output 3A region from the intersection of input 3A region and cropped region.
*
* @param requestRegions The input 3A regions
* @param cropRect The cropped region
* @return expected 3A regions output in capture result
*/
public static MeteringRectangle[] getExpectedOutputRegion(
MeteringRectangle[] requestRegions, Rect cropRect){
MeteringRectangle[] resultRegions = new MeteringRectangle[requestRegions.length];
for (int i = 0; i < requestRegions.length; i++) {
Rect requestRect = requestRegions[i].getRect();
Rect resultRect = new Rect();
assertTrue("Input 3A region must intersect cropped region",
resultRect.setIntersect(requestRect, cropRect));
resultRegions[i] = new MeteringRectangle(
resultRect,
requestRegions[i].getMeteringWeight());
}
return resultRegions;
}
/**
* Copy source image data to destination image.
*
* @param src The source image to be copied from.
* @param dst The destination image to be copied to.
* @throws IllegalArgumentException If the source and destination images have
* different format, size, or one of the images is not copyable.
*/
public static void imageCopy(Image src, Image dst) {
if (src == null || dst == null) {
throw new IllegalArgumentException("Images should be non-null");
}
if (src.getFormat() != dst.getFormat()) {
throw new IllegalArgumentException("Src and dst images should have the same format");
}
if (src.getFormat() == ImageFormat.PRIVATE ||
dst.getFormat() == ImageFormat.PRIVATE) {
throw new IllegalArgumentException("PRIVATE format images are not copyable");
}
Size srcSize = new Size(src.getWidth(), src.getHeight());
Size dstSize = new Size(dst.getWidth(), dst.getHeight());
if (!srcSize.equals(dstSize)) {
throw new IllegalArgumentException("source image size " + srcSize + " is different"
+ " with " + "destination image size " + dstSize);
}
// TODO: check the owner of the dst image, it must be from ImageWriter, other source may
// not be writable. Maybe we should add an isWritable() method in image class.
Plane[] srcPlanes = src.getPlanes();
Plane[] dstPlanes = dst.getPlanes();
ByteBuffer srcBuffer = null;
ByteBuffer dstBuffer = null;
for (int i = 0; i < srcPlanes.length; i++) {
srcBuffer = srcPlanes[i].getBuffer();
dstBuffer = dstPlanes[i].getBuffer();
int srcPos = srcBuffer.position();
srcBuffer.rewind();
dstBuffer.rewind();
int srcRowStride = srcPlanes[i].getRowStride();
int dstRowStride = dstPlanes[i].getRowStride();
int srcPixStride = srcPlanes[i].getPixelStride();
int dstPixStride = dstPlanes[i].getPixelStride();
if (srcPixStride > 2 || dstPixStride > 2) {
throw new IllegalArgumentException("source pixel stride " + srcPixStride +
" with destination pixel stride " + dstPixStride +
" is not supported");
}
if (srcRowStride == dstRowStride && srcPixStride == dstPixStride) {
// Fast path, just copy the content in the byteBuffer all together.
dstBuffer.put(srcBuffer);
} else {
Size effectivePlaneSize = getEffectivePlaneSizeForImage(src, i);
int srcRowByteCount = srcRowStride;
int dstRowByteCount = dstRowStride;
byte[] srcDataRow = new byte[srcRowByteCount];
if (srcPixStride == dstPixStride) {
// Row by row copy case
for (int row = 0; row < effectivePlaneSize.getHeight(); row++) {
if (row == effectivePlaneSize.getHeight() - 1) {
// Special case for interleaved planes: need handle the last row
// carefully to avoid memory corruption. Check if we have enough bytes
// to copy.
int remainingBytes = srcBuffer.remaining();
if (srcRowByteCount > remainingBytes) {
srcRowByteCount = remainingBytes;
}
}
srcBuffer.get(srcDataRow, /*offset*/0, srcRowByteCount);
dstBuffer.put(srcDataRow, /*offset*/0,
Math.min(srcRowByteCount, dstRowByteCount));
}
} else {
// Row by row per pixel copy case
byte[] dstDataRow = new byte[dstRowByteCount];
for (int row = 0; row < effectivePlaneSize.getHeight(); row++) {
if (row == effectivePlaneSize.getHeight() - 1) {
// Special case for interleaved planes: need handle the last row
// carefully to avoid memory corruption. Check if we have enough bytes
// to copy.
int remainingBytes = srcBuffer.remaining();
if (srcRowByteCount > remainingBytes) {
srcRowByteCount = remainingBytes;
}
remainingBytes = dstBuffer.remaining();
if (dstRowByteCount > remainingBytes) {
dstRowByteCount = remainingBytes;
}
}
srcBuffer.get(srcDataRow, /*offset*/0, srcRowByteCount);
int pos = dstBuffer.position();
dstBuffer.get(dstDataRow, /*offset*/0, dstRowByteCount);
dstBuffer.position(pos);
for (int x = 0; x < effectivePlaneSize.getWidth(); x++) {
dstDataRow[x * dstPixStride] = srcDataRow[x * srcPixStride];
}
dstBuffer.put(dstDataRow, /*offset*/0, dstRowByteCount);
}
}
}
srcBuffer.position(srcPos);
dstBuffer.rewind();
}
}
private static Size getEffectivePlaneSizeForImage(Image image, int planeIdx) {
switch (image.getFormat()) {
case ImageFormat.YUV_420_888:
if (planeIdx == 0) {
return new Size(image.getWidth(), image.getHeight());
} else {
return new Size(image.getWidth() / 2, image.getHeight() / 2);
}
case ImageFormat.JPEG:
case ImageFormat.RAW_SENSOR:
case ImageFormat.RAW10:
case ImageFormat.RAW12:
case ImageFormat.DEPTH16:
return new Size(image.getWidth(), image.getHeight());
case ImageFormat.PRIVATE:
return new Size(0, 0);
default:
throw new UnsupportedOperationException(
String.format("Invalid image format %d", image.getFormat()));
}
}
/**
*
* Checks whether the two images are strongly equal.
*
*
* Two images are strongly equal if and only if the data, formats, sizes,
* and timestamps are same. For {@link ImageFormat#PRIVATE PRIVATE} format
* images, the image data is not not accessible thus the data comparison is
* effectively skipped as the number of planes is zero.
*
*
* Note that this method compares the pixel data even outside of the crop
* region, which may not be necessary for general use case.
*
*
* @param lhsImg First image to be compared with.
* @param rhsImg Second image to be compared with.
* @return true if the two images are equal, false otherwise.
* @throws IllegalArgumentException If either of image is null.
*/
public static boolean isImageStronglyEqual(Image lhsImg, Image rhsImg) {
if (lhsImg == null || rhsImg == null) {
throw new IllegalArgumentException("Images should be non-null");
}
if (lhsImg.getFormat() != rhsImg.getFormat()) {
Log.i(TAG, "lhsImg format " + lhsImg.getFormat() + " is different with rhsImg format "
+ rhsImg.getFormat());
return false;
}
if (lhsImg.getWidth() != rhsImg.getWidth()) {
Log.i(TAG, "lhsImg width " + lhsImg.getWidth() + " is different with rhsImg width "
+ rhsImg.getWidth());
return false;
}
if (lhsImg.getHeight() != rhsImg.getHeight()) {
Log.i(TAG, "lhsImg height " + lhsImg.getHeight() + " is different with rhsImg height "
+ rhsImg.getHeight());
return false;
}
if (lhsImg.getTimestamp() != rhsImg.getTimestamp()) {
Log.i(TAG, "lhsImg timestamp " + lhsImg.getTimestamp()
+ " is different with rhsImg timestamp " + rhsImg.getTimestamp());
return false;
}
if (!lhsImg.getCropRect().equals(rhsImg.getCropRect())) {
Log.i(TAG, "lhsImg crop rect " + lhsImg.getCropRect()
+ " is different with rhsImg crop rect " + rhsImg.getCropRect());
return false;
}
// Compare data inside of the image.
Plane[] lhsPlanes = lhsImg.getPlanes();
Plane[] rhsPlanes = rhsImg.getPlanes();
ByteBuffer lhsBuffer = null;
ByteBuffer rhsBuffer = null;
for (int i = 0; i < lhsPlanes.length; i++) {
lhsBuffer = lhsPlanes[i].getBuffer();
rhsBuffer = rhsPlanes[i].getBuffer();
lhsBuffer.rewind();
rhsBuffer.rewind();
// Special case for YUV420_888 buffer with different layout
if (lhsImg.getFormat() == ImageFormat.YUV_420_888 &&
(lhsPlanes[i].getPixelStride() != rhsPlanes[i].getPixelStride() ||
lhsPlanes[i].getRowStride() != rhsPlanes[i].getRowStride())) {
int width = getEffectivePlaneSizeForImage(lhsImg, i).getWidth();
int height = getEffectivePlaneSizeForImage(lhsImg, i).getHeight();
int rowSizeL = lhsPlanes[i].getRowStride();
int rowSizeR = rhsPlanes[i].getRowStride();
byte[] lhsRow = new byte[rowSizeL];
byte[] rhsRow = new byte[rowSizeR];
int pixStrideL = lhsPlanes[i].getPixelStride();
int pixStrideR = rhsPlanes[i].getPixelStride();
for (int r = 0; r < height; r++) {
if (r == height -1) {
rowSizeL = lhsBuffer.remaining();
rowSizeR = rhsBuffer.remaining();
}
lhsBuffer.get(lhsRow, /*offset*/0, rowSizeL);
rhsBuffer.get(rhsRow, /*offset*/0, rowSizeR);
for (int c = 0; c < width; c++) {
if (lhsRow[c * pixStrideL] != rhsRow[c * pixStrideR]) {
Log.i(TAG, String.format(
"byte buffers for plane %d row %d col %d don't match.",
i, r, c));
return false;
}
}
}
} else {
// Compare entire buffer directly
if (!lhsBuffer.equals(rhsBuffer)) {
Log.i(TAG, "byte buffers for plane " + i + " don't match.");
return false;
}
}
}
return true;
}
/**
* Set jpeg related keys in a capture request builder.
*
* @param builder The capture request builder to set the keys inl
* @param exifData The exif data to set.
* @param thumbnailSize The thumbnail size to set.
* @param collector The camera error collector to collect errors.
*/
public static void setJpegKeys(CaptureRequest.Builder builder, ExifTestData exifData,
Size thumbnailSize, CameraErrorCollector collector) {
builder.set(CaptureRequest.JPEG_THUMBNAIL_SIZE, thumbnailSize);
builder.set(CaptureRequest.JPEG_GPS_LOCATION, exifData.gpsLocation);
builder.set(CaptureRequest.JPEG_ORIENTATION, exifData.jpegOrientation);
builder.set(CaptureRequest.JPEG_QUALITY, exifData.jpegQuality);
builder.set(CaptureRequest.JPEG_THUMBNAIL_QUALITY,
exifData.thumbnailQuality);
// Validate request set and get.
collector.expectEquals("JPEG thumbnail size request set and get should match",
thumbnailSize, builder.get(CaptureRequest.JPEG_THUMBNAIL_SIZE));
collector.expectTrue("GPS locations request set and get should match.",
areGpsFieldsEqual(exifData.gpsLocation,
builder.get(CaptureRequest.JPEG_GPS_LOCATION)));
collector.expectEquals("JPEG orientation request set and get should match",
exifData.jpegOrientation,
builder.get(CaptureRequest.JPEG_ORIENTATION));
collector.expectEquals("JPEG quality request set and get should match",
exifData.jpegQuality, builder.get(CaptureRequest.JPEG_QUALITY));
collector.expectEquals("JPEG thumbnail quality request set and get should match",
exifData.thumbnailQuality,
builder.get(CaptureRequest.JPEG_THUMBNAIL_QUALITY));
}
/**
* Simple validation of JPEG image size and format.
*
* Only validate the image object sanity. It is fast, but doesn't actually
* check the buffer data. Assert is used here as it make no sense to
* continue the test if the jpeg image captured has some serious failures.
*
*
* @param image The captured JPEG/HEIC image
* @param expectedSize Expected capture JEPG/HEIC size
* @param format JPEG/HEIC image format
*/
public static void basicValidateBlobImage(Image image, Size expectedSize, int format) {
Size imageSz = new Size(image.getWidth(), image.getHeight());
assertTrue(
String.format("Image size doesn't match (expected %s, actual %s) ",
expectedSize.toString(), imageSz.toString()), expectedSize.equals(imageSz));
assertEquals("Image format should be " + ((format == ImageFormat.HEIC) ? "HEIC" : "JPEG"),
format, image.getFormat());
assertNotNull("Image plane shouldn't be null", image.getPlanes());
assertEquals("Image plane number should be 1", 1, image.getPlanes().length);
// Jpeg/Heic decoding validate was done in ImageReaderTest,
// no need to duplicate the test here.
}
/**
* Verify the EXIF and JPEG related keys in a capture result are expected.
* - Capture request get values are same as were set.
* - capture result's exif data is the same as was set by
* the capture request.
* - new tags in the result set by the camera service are
* present and semantically correct.
*
* @param image The output JPEG/HEIC image to verify.
* @param captureResult The capture result to verify.
* @param expectedSize The expected JPEG/HEIC size.
* @param expectedThumbnailSize The expected thumbnail size.
* @param expectedExifData The expected EXIF data
* @param staticInfo The static metadata for the camera device.
* @param blobFilename The filename to dump the jpeg/heic to.
* @param collector The camera error collector to collect errors.
* @param format JPEG/HEIC format
*/
public static void verifyJpegKeys(Image image, CaptureResult captureResult, Size expectedSize,
Size expectedThumbnailSize, ExifTestData expectedExifData, StaticMetadata staticInfo,
CameraErrorCollector collector, String debugFileNameBase, int format) throws Exception {
basicValidateBlobImage(image, expectedSize, format);
byte[] blobBuffer = getDataFromImage(image);
// Have to dump into a file to be able to use ExifInterface
String filePostfix = (format == ImageFormat.HEIC ? ".heic" : ".jpeg");
String blobFilename = debugFileNameBase + "/verifyJpegKeys" + filePostfix;
dumpFile(blobFilename, blobBuffer);
ExifInterface exif = new ExifInterface(blobFilename);
if (expectedThumbnailSize.equals(new Size(0,0))) {
collector.expectTrue("Jpeg shouldn't have thumbnail when thumbnail size is (0, 0)",
!exif.hasThumbnail());
} else {
collector.expectTrue("Jpeg must have thumbnail for thumbnail size " +
expectedThumbnailSize, exif.hasThumbnail());
}
// Validate capture result vs. request
Size resultThumbnailSize = captureResult.get(CaptureResult.JPEG_THUMBNAIL_SIZE);
int orientationTested = expectedExifData.jpegOrientation;
// Legacy shim always doesn't rotate thumbnail size
if ((orientationTested == 90 || orientationTested == 270) &&
staticInfo.isHardwareLevelAtLeastLimited()) {
int exifOrientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
/*defaultValue*/-1);
if (exifOrientation == ExifInterface.ORIENTATION_UNDEFINED) {
// Device physically rotated image+thumbnail data
// Expect thumbnail size to be also rotated
resultThumbnailSize = new Size(resultThumbnailSize.getHeight(),
resultThumbnailSize.getWidth());
}
}
collector.expectEquals("JPEG thumbnail size result and request should match",
expectedThumbnailSize, resultThumbnailSize);
if (collector.expectKeyValueNotNull(captureResult, CaptureResult.JPEG_GPS_LOCATION) !=
null) {
collector.expectTrue("GPS location result and request should match.",
areGpsFieldsEqual(expectedExifData.gpsLocation,
captureResult.get(CaptureResult.JPEG_GPS_LOCATION)));
}
collector.expectEquals("JPEG orientation result and request should match",
expectedExifData.jpegOrientation,
captureResult.get(CaptureResult.JPEG_ORIENTATION));
collector.expectEquals("JPEG quality result and request should match",
expectedExifData.jpegQuality, captureResult.get(CaptureResult.JPEG_QUALITY));
collector.expectEquals("JPEG thumbnail quality result and request should match",
expectedExifData.thumbnailQuality,
captureResult.get(CaptureResult.JPEG_THUMBNAIL_QUALITY));
// Validate other exif tags for all non-legacy devices
if (!staticInfo.isHardwareLevelLegacy()) {
verifyJpegExifExtraTags(exif, expectedSize, captureResult, staticInfo, collector,
expectedExifData);
}
}
/**
* Get the degree of an EXIF orientation.
*/
private static int getExifOrientationInDegree(int exifOrientation,
CameraErrorCollector collector) {
switch (exifOrientation) {
case ExifInterface.ORIENTATION_NORMAL:
return 0;
case ExifInterface.ORIENTATION_ROTATE_90:
return 90;
case ExifInterface.ORIENTATION_ROTATE_180:
return 180;
case ExifInterface.ORIENTATION_ROTATE_270:
return 270;
default:
collector.addMessage("It is impossible to get non 0, 90, 180, 270 degress exif" +
"info based on the request orientation range");
return 0;
}
}
/**
* Validate and return the focal length.
*
* @param result Capture result to get the focal length
* @return Focal length from capture result or -1 if focal length is not available.
*/
private static float validateFocalLength(CaptureResult result, StaticMetadata staticInfo,
CameraErrorCollector collector) {
float[] focalLengths = staticInfo.getAvailableFocalLengthsChecked();
Float resultFocalLength = result.get(CaptureResult.LENS_FOCAL_LENGTH);
if (collector.expectTrue("Focal length is invalid",
resultFocalLength != null && resultFocalLength > 0)) {
List focalLengthList =
Arrays.asList(CameraTestUtils.toObject(focalLengths));
collector.expectTrue("Focal length should be one of the available focal length",
focalLengthList.contains(resultFocalLength));
return resultFocalLength;
}
return -1;
}
/**
* Validate and return the aperture.
*
* @param result Capture result to get the aperture
* @return Aperture from capture result or -1 if aperture is not available.
*/
private static float validateAperture(CaptureResult result, StaticMetadata staticInfo,
CameraErrorCollector collector) {
float[] apertures = staticInfo.getAvailableAperturesChecked();
Float resultAperture = result.get(CaptureResult.LENS_APERTURE);
if (collector.expectTrue("Capture result aperture is invalid",
resultAperture != null && resultAperture > 0)) {
List apertureList =
Arrays.asList(CameraTestUtils.toObject(apertures));
collector.expectTrue("Aperture should be one of the available apertures",
apertureList.contains(resultAperture));
return resultAperture;
}
return -1;
}
/**
* Return the closest value in an array of floats.
*/
private static float getClosestValueInArray(float[] values, float target) {
int minIdx = 0;
float minDistance = Math.abs(values[0] - target);
for(int i = 0; i < values.length; i++) {
float distance = Math.abs(values[i] - target);
if (minDistance > distance) {
minDistance = distance;
minIdx = i;
}
}
return values[minIdx];
}
/**
* Return if two Location's GPS field are the same.
*/
private static boolean areGpsFieldsEqual(Location a, Location b) {
if (a == null || b == null) {
return false;
}
return a.getTime() == b.getTime() && a.getLatitude() == b.getLatitude() &&
a.getLongitude() == b.getLongitude() && a.getAltitude() == b.getAltitude() &&
a.getProvider() == b.getProvider();
}
/**
* Verify extra tags in JPEG EXIF
*/
private static void verifyJpegExifExtraTags(ExifInterface exif, Size jpegSize,
CaptureResult result, StaticMetadata staticInfo, CameraErrorCollector collector,
ExifTestData expectedExifData)
throws ParseException {
/**
* TAG_IMAGE_WIDTH and TAG_IMAGE_LENGTH and TAG_ORIENTATION.
* Orientation and exif width/height need to be tested carefully, two cases:
*
* 1. Device rotate the image buffer physically, then exif width/height may not match
* the requested still capture size, we need swap them to check.
*
* 2. Device use the exif tag to record the image orientation, it doesn't rotate
* the jpeg image buffer itself. In this case, the exif width/height should always match
* the requested still capture size, and the exif orientation should always match the
* requested orientation.
*
*/
int exifWidth = exif.getAttributeInt(ExifInterface.TAG_IMAGE_WIDTH, /*defaultValue*/0);
int exifHeight = exif.getAttributeInt(ExifInterface.TAG_IMAGE_LENGTH, /*defaultValue*/0);
Size exifSize = new Size(exifWidth, exifHeight);
// Orientation could be missing, which is ok, default to 0.
int exifOrientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
/*defaultValue*/-1);
// Get requested orientation from result, because they should be same.
if (collector.expectKeyValueNotNull(result, CaptureResult.JPEG_ORIENTATION) != null) {
int requestedOrientation = result.get(CaptureResult.JPEG_ORIENTATION);
final int ORIENTATION_MIN = ExifInterface.ORIENTATION_UNDEFINED;
final int ORIENTATION_MAX = ExifInterface.ORIENTATION_ROTATE_270;
boolean orientationValid = collector.expectTrue(String.format(
"Exif orientation must be in range of [%d, %d]",
ORIENTATION_MIN, ORIENTATION_MAX),
exifOrientation >= ORIENTATION_MIN && exifOrientation <= ORIENTATION_MAX);
if (orientationValid) {
/**
* Device captured image doesn't respect the requested orientation,
* which means it rotates the image buffer physically. Then we
* should swap the exif width/height accordingly to compare.
*/
boolean deviceRotatedImage = exifOrientation == ExifInterface.ORIENTATION_UNDEFINED;
if (deviceRotatedImage) {
// Case 1.
boolean needSwap = (requestedOrientation % 180 == 90);
if (needSwap) {
exifSize = new Size(exifHeight, exifWidth);
}
} else {
// Case 2.
collector.expectEquals("Exif orientaiton should match requested orientation",
requestedOrientation, getExifOrientationInDegree(exifOrientation,
collector));
}
}
}
/**
* Ideally, need check exifSize == jpegSize == actual buffer size. But
* jpegSize == jpeg decode bounds size(from jpeg jpeg frame
* header, not exif) was validated in ImageReaderTest, no need to
* validate again here.
*/
collector.expectEquals("Exif size should match jpeg capture size", jpegSize, exifSize);
// TAG_DATETIME, it should be local time
long currentTimeInMs = System.currentTimeMillis();
long currentTimeInSecond = currentTimeInMs / 1000;
Date date = new Date(currentTimeInMs);
String localDatetime = new SimpleDateFormat("yyyy:MM:dd HH:").format(date);
String dateTime = exif.getAttribute(ExifInterface.TAG_DATETIME);
if (collector.expectTrue("Exif TAG_DATETIME shouldn't be null", dateTime != null)) {
collector.expectTrue("Exif TAG_DATETIME is wrong",
dateTime.length() == EXIF_DATETIME_LENGTH);
long exifTimeInSecond =
new SimpleDateFormat("yyyy:MM:dd HH:mm:ss").parse(dateTime).getTime() / 1000;
long delta = currentTimeInSecond - exifTimeInSecond;
collector.expectTrue("Capture time deviates too much from the current time",
Math.abs(delta) < EXIF_DATETIME_ERROR_MARGIN_SEC);
// It should be local time.
collector.expectTrue("Exif date time should be local time",
dateTime.startsWith(localDatetime));
}
boolean isExternalCamera = staticInfo.isExternalCamera();
if (!isExternalCamera) {
// TAG_FOCAL_LENGTH.
float[] focalLengths = staticInfo.getAvailableFocalLengthsChecked();
float exifFocalLength = (float)exif.getAttributeDouble(
ExifInterface.TAG_FOCAL_LENGTH, -1);
collector.expectEquals("Focal length should match",
getClosestValueInArray(focalLengths, exifFocalLength),
exifFocalLength, EXIF_FOCAL_LENGTH_ERROR_MARGIN);
// More checks for focal length.
collector.expectEquals("Exif focal length should match capture result",
validateFocalLength(result, staticInfo, collector),
exifFocalLength, EXIF_FOCAL_LENGTH_ERROR_MARGIN);
// TAG_EXPOSURE_TIME
// ExifInterface API gives exposure time value in the form of float instead of rational
String exposureTime = exif.getAttribute(ExifInterface.TAG_EXPOSURE_TIME);
collector.expectNotNull("Exif TAG_EXPOSURE_TIME shouldn't be null", exposureTime);
if (staticInfo.areKeysAvailable(CaptureResult.SENSOR_EXPOSURE_TIME)) {
if (exposureTime != null) {
double exposureTimeValue = Double.parseDouble(exposureTime);
long expTimeResult = result.get(CaptureResult.SENSOR_EXPOSURE_TIME);
double expected = expTimeResult / 1e9;
double tolerance = expected * EXIF_EXPOSURE_TIME_ERROR_MARGIN_RATIO;
tolerance = Math.max(tolerance, EXIF_EXPOSURE_TIME_MIN_ERROR_MARGIN_SEC);
collector.expectEquals("Exif exposure time doesn't match", expected,
exposureTimeValue, tolerance);
}
}
// TAG_APERTURE
// ExifInterface API gives aperture value in the form of float instead of rational
String exifAperture = exif.getAttribute(ExifInterface.TAG_APERTURE);
collector.expectNotNull("Exif TAG_APERTURE shouldn't be null", exifAperture);
if (staticInfo.areKeysAvailable(CameraCharacteristics.LENS_INFO_AVAILABLE_APERTURES)) {
float[] apertures = staticInfo.getAvailableAperturesChecked();
if (exifAperture != null) {
float apertureValue = Float.parseFloat(exifAperture);
collector.expectEquals("Aperture value should match",
getClosestValueInArray(apertures, apertureValue),
apertureValue, EXIF_APERTURE_ERROR_MARGIN);
// More checks for aperture.
collector.expectEquals("Exif aperture length should match capture result",
validateAperture(result, staticInfo, collector),
apertureValue, EXIF_APERTURE_ERROR_MARGIN);
}
}
// TAG_MAKE
String make = exif.getAttribute(ExifInterface.TAG_MAKE);
collector.expectEquals("Exif TAG_MAKE is incorrect", Build.MANUFACTURER, make);
// TAG_MODEL
String model = exif.getAttribute(ExifInterface.TAG_MODEL);
collector.expectEquals("Exif TAG_MODEL is incorrect", Build.MODEL, model);
// TAG_ISO
int iso = exif.getAttributeInt(ExifInterface.TAG_ISO, /*defaultValue*/-1);
if (staticInfo.areKeysAvailable(CaptureResult.SENSOR_SENSITIVITY) ||
staticInfo.areKeysAvailable(CaptureResult.CONTROL_POST_RAW_SENSITIVITY_BOOST)) {
int expectedIso = 100;
if (staticInfo.areKeysAvailable(CaptureResult.SENSOR_SENSITIVITY)) {
expectedIso = result.get(CaptureResult.SENSOR_SENSITIVITY);
}
if (staticInfo.areKeysAvailable(CaptureResult.CONTROL_POST_RAW_SENSITIVITY_BOOST)) {
expectedIso = expectedIso *
result.get(CaptureResult.CONTROL_POST_RAW_SENSITIVITY_BOOST);
} else {
expectedIso *= 100;
}
collector.expectInRange("Exif TAG_ISO is incorrect", iso,
expectedIso/100, (expectedIso+50)/100);
}
} else {
// External camera specific checks
// TAG_MAKE
String make = exif.getAttribute(ExifInterface.TAG_MAKE);
collector.expectNotNull("Exif TAG_MAKE is null", make);
// TAG_MODEL
String model = exif.getAttribute(ExifInterface.TAG_MODEL);
collector.expectNotNull("Exif TAG_MODEL is nuill", model);
}
/**
* TAG_FLASH. TODO: For full devices, can check a lot more info
* (http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/EXIF.html#Flash)
*/
String flash = exif.getAttribute(ExifInterface.TAG_FLASH);
collector.expectNotNull("Exif TAG_FLASH shouldn't be null", flash);
/**
* TAG_WHITE_BALANCE. TODO: For full devices, with the DNG tags, we
* should be able to cross-check android.sensor.referenceIlluminant.
*/
String whiteBalance = exif.getAttribute(ExifInterface.TAG_WHITE_BALANCE);
collector.expectNotNull("Exif TAG_WHITE_BALANCE shouldn't be null", whiteBalance);
// TAG_DATETIME_DIGITIZED (a.k.a Create time for digital cameras).
String digitizedTime = exif.getAttribute(ExifInterface.TAG_DATETIME_DIGITIZED);
collector.expectNotNull("Exif TAG_DATETIME_DIGITIZED shouldn't be null", digitizedTime);
if (digitizedTime != null) {
String expectedDateTime = exif.getAttribute(ExifInterface.TAG_DATETIME);
collector.expectNotNull("Exif TAG_DATETIME shouldn't be null", expectedDateTime);
if (expectedDateTime != null) {
collector.expectEquals("dataTime should match digitizedTime",
expectedDateTime, digitizedTime);
}
}
/**
* TAG_SUBSEC_TIME. Since the sub second tag strings are truncated to at
* most 9 digits in ExifInterface implementation, use getAttributeInt to
* sanitize it. When the default value -1 is returned, it means that
* this exif tag either doesn't exist or is a non-numerical invalid
* string. Same rule applies to the rest of sub second tags.
*/
int subSecTime = exif.getAttributeInt(ExifInterface.TAG_SUBSEC_TIME, /*defaultValue*/-1);
collector.expectTrue("Exif TAG_SUBSEC_TIME value is null or invalid!", subSecTime >= 0);
// TAG_SUBSEC_TIME_ORIG
int subSecTimeOrig = exif.getAttributeInt(ExifInterface.TAG_SUBSEC_TIME_ORIG,
/*defaultValue*/-1);
collector.expectTrue("Exif TAG_SUBSEC_TIME_ORIG value is null or invalid!",
subSecTimeOrig >= 0);
// TAG_SUBSEC_TIME_DIG
int subSecTimeDig = exif.getAttributeInt(ExifInterface.TAG_SUBSEC_TIME_DIG,
/*defaultValue*/-1);
collector.expectTrue(
"Exif TAG_SUBSEC_TIME_DIG value is null or invalid!", subSecTimeDig >= 0);
/**
* TAG_GPS_DATESTAMP & TAG_GPS_TIMESTAMP.
* The GPS timestamp information should be in seconds UTC time.
*/
String gpsDatestamp = exif.getAttribute(ExifInterface.TAG_GPS_DATESTAMP);
collector.expectNotNull("Exif TAG_GPS_DATESTAMP shouldn't be null", gpsDatestamp);
String gpsTimestamp = exif.getAttribute(ExifInterface.TAG_GPS_TIMESTAMP);
collector.expectNotNull("Exif TAG_GPS_TIMESTAMP shouldn't be null", gpsTimestamp);
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy:MM:dd hh:mm:ss z");
String gpsExifTimeString = gpsDatestamp + " " + gpsTimestamp + " UTC";
Date gpsDateTime = dateFormat.parse(gpsExifTimeString);
Date expected = new Date(expectedExifData.gpsLocation.getTime());
collector.expectEquals("Jpeg EXIF GPS time should match", expected, gpsDateTime);
}
/**
* Immutable class wrapping the exif test data.
*/
public static class ExifTestData {
public final Location gpsLocation;
public final int jpegOrientation;
public final byte jpegQuality;
public final byte thumbnailQuality;
public ExifTestData(Location location, int orientation,
byte jpgQuality, byte thumbQuality) {
gpsLocation = location;
jpegOrientation = orientation;
jpegQuality = jpgQuality;
thumbnailQuality = thumbQuality;
}
}
public static Size getPreviewSizeBound(WindowManager windowManager, Size bound) {
Display display = windowManager.getDefaultDisplay();
int width = display.getWidth();
int height = display.getHeight();
if (height > width) {
height = width;
width = display.getHeight();
}
if (bound.getWidth() <= width &&
bound.getHeight() <= height)
return bound;
else
return new Size(width, height);
}
/**
* Check if a particular stream configuration is supported by configuring it
* to the device.
*/
public static boolean isStreamConfigurationSupported(CameraDevice camera,
List outputSurfaces,
CameraCaptureSession.StateCallback listener, Handler handler) {
try {
configureCameraSession(camera, outputSurfaces, listener, handler);
return true;
} catch (Exception e) {
Log.i(TAG, "This stream configuration is not supported due to " + e.getMessage());
return false;
}
}
public final static class SessionConfigSupport {
public final boolean error;
public final boolean callSupported;
public final boolean configSupported;
public SessionConfigSupport(boolean error,
boolean callSupported, boolean configSupported) {
this.error = error;
this.callSupported = callSupported;
this.configSupported = configSupported;
}
}
/**
* Query whether a particular stream combination is supported.
*/
public static void checkSessionConfigurationWithSurfaces(CameraDevice camera,
Handler handler, List outputSurfaces, InputConfiguration inputConfig,
int operatingMode, boolean defaultSupport, String msg) {
List outConfigurations = new ArrayList<>(outputSurfaces.size());
for (Surface surface : outputSurfaces) {
outConfigurations.add(new OutputConfiguration(surface));
}
checkSessionConfigurationSupported(camera, handler, outConfigurations,
inputConfig, operatingMode, defaultSupport, msg);
}
public static void checkSessionConfigurationSupported(CameraDevice camera,
Handler handler, List outputConfigs,
InputConfiguration inputConfig, int operatingMode, boolean defaultSupport,
String msg) {
SessionConfigSupport sessionConfigSupported =
isSessionConfigSupported(camera, handler, outputConfigs, inputConfig,
operatingMode, defaultSupport);
assertTrue(msg, !sessionConfigSupported.error && sessionConfigSupported.configSupported);
}
/**
* Query whether a particular stream combination is supported.
*/
public static SessionConfigSupport isSessionConfigSupported(CameraDevice camera,
Handler handler, List outputConfigs,
InputConfiguration inputConfig, int operatingMode, boolean defaultSupport) {
boolean ret;
BlockingSessionCallback sessionListener = new BlockingSessionCallback();
SessionConfiguration sessionConfig = new SessionConfiguration(operatingMode, outputConfigs,
new HandlerExecutor(handler), sessionListener);
if (inputConfig != null) {
sessionConfig.setInputConfiguration(inputConfig);
}
try {
ret = camera.isSessionConfigurationSupported(sessionConfig);
} catch (UnsupportedOperationException e) {
// Camera doesn't support session configuration query
return new SessionConfigSupport(false/*error*/,
false/*callSupported*/, defaultSupport/*configSupported*/);
} catch (IllegalArgumentException e) {
return new SessionConfigSupport(true/*error*/,
false/*callSupported*/, false/*configSupported*/);
} catch (android.hardware.camera2.CameraAccessException e) {
return new SessionConfigSupport(true/*error*/,
false/*callSupported*/, false/*configSupported*/);
}
return new SessionConfigSupport(false/*error*/,
true/*callSupported*/, ret/*configSupported*/);
}
/**
* Wait for numResultWait frames
*
* @param resultListener The capture listener to get capture result back.
* @param numResultsWait Number of frame to wait
* @param timeout Wait timeout in ms.
*
* @return the last result, or {@code null} if there was none
*/
public static CaptureResult waitForNumResults(SimpleCaptureCallback resultListener,
int numResultsWait, int timeout) {
if (numResultsWait < 0 || resultListener == null) {
throw new IllegalArgumentException(
"Input must be positive number and listener must be non-null");
}
CaptureResult result = null;
for (int i = 0; i < numResultsWait; i++) {
result = resultListener.getCaptureResult(timeout);
}
return result;
}
/**
* Wait for any expected result key values available in a certain number of results.
*
*
* Check the result immediately if numFramesWait is 0.
*
*
* @param listener The capture listener to get capture result.
* @param resultKey The capture result key associated with the result value.
* @param expectedValues The list of result value need to be waited for,
* return immediately if the list is empty.
* @param numResultsWait Number of frame to wait before times out.
* @param timeout result wait time out in ms.
* @throws TimeoutRuntimeException If more than numResultsWait results are.
* seen before the result matching myRequest arrives, or each individual wait
* for result times out after 'timeout' ms.
*/
public static void waitForAnyResultValue(SimpleCaptureCallback listener,
CaptureResult.Key resultKey, List expectedValues, int numResultsWait,
int timeout) {
if (numResultsWait < 0 || listener == null || expectedValues == null) {
throw new IllegalArgumentException(
"Input must be non-negative number and listener/expectedValues "
+ "must be non-null");
}
int i = 0;
CaptureResult result;
do {
result = listener.getCaptureResult(timeout);
T value = result.get(resultKey);
for ( T expectedValue : expectedValues) {
if (VERBOSE) {
Log.v(TAG, "Current result value for key " + resultKey.getName() + " is: "
+ value.toString());
}
if (value.equals(expectedValue)) {
return;
}
}
} while (i++ < numResultsWait);
throw new TimeoutRuntimeException(
"Unable to get the expected result value " + expectedValues + " for key " +
resultKey.getName() + " after waiting for " + numResultsWait + " results");
}
/**
* Wait for expected result key value available in a certain number of results.
*
*
* Check the result immediately if numFramesWait is 0.
*
*
* @param listener The capture listener to get capture result
* @param resultKey The capture result key associated with the result value
* @param expectedValue The result value need to be waited for
* @param numResultsWait Number of frame to wait before times out
* @param timeout Wait time out.
* @throws TimeoutRuntimeException If more than numResultsWait results are
* seen before the result matching myRequest arrives, or each individual wait
* for result times out after 'timeout' ms.
*/
public static void waitForResultValue(SimpleCaptureCallback listener,
CaptureResult.Key resultKey, T expectedValue, int numResultsWait, int timeout) {
List expectedValues = new ArrayList();
expectedValues.add(expectedValue);
waitForAnyResultValue(listener, resultKey, expectedValues, numResultsWait, timeout);
}
/**
* Wait for AE to be stabilized before capture: CONVERGED or FLASH_REQUIRED.
*
* Waits for {@code android.sync.maxLatency} number of results first, to make sure
* that the result is synchronized (or {@code numResultWaitForUnknownLatency} if the latency
* is unknown.
*
* This is a no-op for {@code LEGACY} devices since they don't report
* the {@code aeState} result.
*
* @param resultListener The capture listener to get capture result back.
* @param numResultWaitForUnknownLatency Number of frame to wait if camera device latency is
* unknown.
* @param staticInfo corresponding camera device static metadata.
* @param settingsTimeout wait timeout for settings application in ms.
* @param resultTimeout wait timeout for result in ms.
* @param numResultsWait Number of frame to wait before times out.
*/
public static void waitForAeStable(SimpleCaptureCallback resultListener,
int numResultWaitForUnknownLatency, StaticMetadata staticInfo,
int settingsTimeout, int numResultWait) {
waitForSettingsApplied(resultListener, numResultWaitForUnknownLatency, staticInfo,
settingsTimeout);
if (!staticInfo.isHardwareLevelAtLeastLimited()) {
// No-op for metadata
return;
}
List expectedAeStates = new ArrayList();
expectedAeStates.add(new Integer(CaptureResult.CONTROL_AE_STATE_CONVERGED));
expectedAeStates.add(new Integer(CaptureResult.CONTROL_AE_STATE_FLASH_REQUIRED));
waitForAnyResultValue(resultListener, CaptureResult.CONTROL_AE_STATE, expectedAeStates,
numResultWait, settingsTimeout);
}
/**
* Wait for enough results for settings to be applied
*
* @param resultListener The capture listener to get capture result back.
* @param numResultWaitForUnknownLatency Number of frame to wait if camera device latency is
* unknown.
* @param staticInfo corresponding camera device static metadata.
* @param timeout wait timeout in ms.
*/
public static void waitForSettingsApplied(SimpleCaptureCallback resultListener,
int numResultWaitForUnknownLatency, StaticMetadata staticInfo, int timeout) {
int maxLatency = staticInfo.getSyncMaxLatency();
if (maxLatency == CameraMetadata.SYNC_MAX_LATENCY_UNKNOWN) {
maxLatency = numResultWaitForUnknownLatency;
}
// Wait for settings to take effect
waitForNumResults(resultListener, maxLatency, timeout);
}
public static Range getSuitableFpsRangeForDuration(String cameraId,
long frameDuration, StaticMetadata staticInfo) {
// Add 0.05 here so Fps like 29.99 evaluated to 30
int minBurstFps = (int) Math.floor(1e9 / frameDuration + 0.05f);
boolean foundConstantMaxYUVRange = false;
boolean foundYUVStreamingRange = false;
boolean isExternalCamera = staticInfo.isExternalCamera();
boolean isNIR = staticInfo.isNIRColorFilter();
// Find suitable target FPS range - as high as possible that covers the max YUV rate
// Also verify that there's a good preview rate as well
List > fpsRanges = Arrays.asList(
staticInfo.getAeAvailableTargetFpsRangesChecked());
Range targetRange = null;
for (Range fpsRange : fpsRanges) {
if (fpsRange.getLower() == minBurstFps && fpsRange.getUpper() == minBurstFps) {
foundConstantMaxYUVRange = true;
targetRange = fpsRange;
} else if (isExternalCamera && fpsRange.getUpper() == minBurstFps) {
targetRange = fpsRange;
}
if (fpsRange.getLower() <= 15 && fpsRange.getUpper() == minBurstFps) {
foundYUVStreamingRange = true;
}
}
if (!isExternalCamera) {
assertTrue(String.format("Cam %s: Target FPS range of (%d, %d) must be supported",
cameraId, minBurstFps, minBurstFps), foundConstantMaxYUVRange);
}
if (!isNIR) {
assertTrue(String.format(
"Cam %s: Target FPS range of (x, %d) where x <= 15 must be supported",
cameraId, minBurstFps), foundYUVStreamingRange);
}
return targetRange;
}
}