Camera: ProCameraTests: clean up a bit, still needs more cleanup (dcb07d51) · Commits · e / devices / smdk4412 / android_frameworks_av

camera/tests/ProCameraTests.cpp

+116 −79

Original line number	Original line	Diff line number	Diff line
	@@ -31,6 +31,7 @@

	#include <system/camera_metadata.h>		#include <system/camera_metadata.h>
	#include <hardware/camera2.h> // for CAMERA2_TEMPLATE_PREVIEW only		#include <hardware/camera2.h> // for CAMERA2_TEMPLATE_PREVIEW only
			#include <camera/CameraMetadata.h>

	namespace android {		namespace android {
	namespace camera2 {		namespace camera2 {
	@@ -46,6 +47,11 @@ namespace client {
	#define TEST_FORMAT_MAIN HAL_PIXEL_FORMAT_Y8		#define TEST_FORMAT_MAIN HAL_PIXEL_FORMAT_Y8
	#define TEST_FORMAT_DEPTH HAL_PIXEL_FORMAT_Y16		#define TEST_FORMAT_DEPTH HAL_PIXEL_FORMAT_Y16

			// defaults for display "test"
			#define TEST_DISPLAY_FORMAT HAL_PIXEL_FORMAT_Y16
			#define TEST_DISPLAY_WIDTH 1280
			#define TEST_DISPLAY_HEIGHT 960

	#define TEST_CPU_FRAME_COUNT 2		#define TEST_CPU_FRAME_COUNT 2
	#define TEST_CPU_HEAP_COUNT 5		#define TEST_CPU_HEAP_COUNT 5

	@@ -233,6 +239,42 @@ class ProCameraTest : public ::testing::Test {

	public:		public:
	ProCameraTest() {		ProCameraTest() {
			char* displaySecsEnv = getenv("TEST_DISPLAY_SECS");
			if (displaySecsEnv != NULL) {
			mDisplaySecs = atoi(displaySecsEnv);
			if (mDisplaySecs < 0) {
			mDisplaySecs = 0;
			}
			} else {
			mDisplaySecs = 0;
			}

			char* displayFmtEnv = getenv("TEST_DISPLAY_FORMAT");
			if (displayFmtEnv != NULL) {
			mDisplayFmt = FormatFromString(displayFmtEnv);
			} else {
			mDisplayFmt = TEST_DISPLAY_FORMAT;
			}

			char* displayWidthEnv = getenv("TEST_DISPLAY_WIDTH");
			if (displayWidthEnv != NULL) {
			mDisplayW = atoi(displayWidthEnv);
			if (mDisplayW < 0) {
			mDisplayW = 0;
			}
			} else {
			mDisplayW = TEST_DISPLAY_WIDTH;
			}

			char* displayHeightEnv = getenv("TEST_DISPLAY_HEIGHT");
			if (displayHeightEnv != NULL) {
			mDisplayH = atoi(displayHeightEnv);
			if (mDisplayH < 0) {
			mDisplayH = 0;
			}
			} else {
			mDisplayH = TEST_DISPLAY_HEIGHT;
			}
	}		}

	static void SetUpTestCase() {		static void SetUpTestCase() {
	@@ -261,6 +303,10 @@ protected:
	static sp<Thread> mTestThread;		static sp<Thread> mTestThread;

	int mDisplaySecs;		int mDisplaySecs;
			int mDisplayFmt;
			int mDisplayW;
			int mDisplayH;

	sp<SurfaceComposerClient> mComposerClient;		sp<SurfaceComposerClient> mComposerClient;
	sp<SurfaceControl> mSurfaceControl;		sp<SurfaceControl> mSurfaceControl;

	@@ -283,7 +329,7 @@ protected:
	getSurfaceWidth(), getSurfaceHeight(),		getSurfaceWidth(), getSurfaceHeight(),
	PIXEL_FORMAT_RGB_888, 0);		PIXEL_FORMAT_RGB_888, 0);

	mSurfaceControl->setPosition(640, 0);		mSurfaceControl->setPosition(0, 0);

	ASSERT_TRUE(mSurfaceControl != NULL);		ASSERT_TRUE(mSurfaceControl != NULL);
	ASSERT_TRUE(mSurfaceControl->isValid());		ASSERT_TRUE(mSurfaceControl->isValid());
	@@ -325,7 +371,11 @@ protected:
	}		}

	template <typename T>		template <typename T>
	static bool FindItem(T needle, T* array, size_t count) {		static bool ExistsItem(T needle, T* array, size_t count) {
			if (!array) {
			return false;
			}

	for (int i = 0; i < count; ++i) {		for (int i = 0; i < count; ++i) {
	if (array[i] == needle) {		if (array[i] == needle) {
	return true;		return true;
	@@ -334,6 +384,53 @@ protected:
	return false;		return false;
	}		}


			static int FormatFromString(const char* str) {
			std::string s(str);

			#define CMP_STR(x, y) \
			if (s == #x) return HAL_PIXEL_FORMAT_ ## y;
			#define CMP_STR_SAME(x) CMP_STR(x, x)

			CMP_STR_SAME( Y16);
			CMP_STR_SAME( Y8);
			CMP_STR_SAME( YV12);
			CMP_STR(NV16, YCbCr_422_SP);
			CMP_STR(NV21, YCrCb_420_SP);
			CMP_STR(YUY2, YCbCr_422_I);
			CMP_STR(RAW, RAW_SENSOR);
			CMP_STR(RGBA, RGBA_8888);

			std::cerr << "Unknown format string " << str << std::endl;
			return -1;

			}

			/**
			* Creating a streaming request for these output streams from a template,
			* and submit it
			*/
			void createSubmitRequestForStreams(uint8_t* streamIds, size_t count) {

			ASSERT_NE((void*)NULL, streamIds);
			ASSERT_LT(0, count);

			camera_metadata_t *requestTmp = NULL;
			EXPECT_OK(mCamera->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
			/out/&requestTmp));
			ASSERT_NE((void*)NULL, requestTmp);
			CameraMetadata request(requestTmp);

			// set the output streams. default is empty

			uint32_t tag = static_cast<uint32_t>(ANDROID_REQUEST_OUTPUT_STREAMS);
			request.update(tag, streamIds, count);

			requestTmp = request.release();
			EXPECT_OK(mCamera->submitRequest(requestTmp, /streaming/true));
			request.acquire(requestTmp);
			}

	};		};

	sp<Thread> ProCameraTest::mTestThread;		sp<Thread> ProCameraTest::mTestThread;
	@@ -343,19 +440,17 @@ TEST_F(ProCameraTest, AvailableFormats) {
	return;		return;
	}		}

	camera_metadata_t* info = mCamera->getCameraInfo(CAMERA_ID);		CameraMetadata staticInfo = mCamera->getCameraInfo(CAMERA_ID);
	ASSERT_NE((void*)NULL, info);		ASSERT_FALSE(staticInfo.isEmpty());

	camera_metadata_entry_t entry;
	uint32_t tag = static_cast<uint32_t>(ANDROID_SCALER_AVAILABLE_FORMATS);		uint32_t tag = static_cast<uint32_t>(ANDROID_SCALER_AVAILABLE_FORMATS);
	EXPECT_EQ(OK, find_camera_metadata_entry(info, tag, &entry));		EXPECT_TRUE(staticInfo.exists(tag));
			camera_metadata_entry_t entry = staticInfo.find(tag);

	EXPECT_TRUE(FindItem<int32_t>(HAL_PIXEL_FORMAT_YV12,		EXPECT_TRUE(ExistsItem<int32_t>(HAL_PIXEL_FORMAT_YV12,
	entry.data.i32, entry.count));		entry.data.i32, entry.count));
	EXPECT_TRUE(FindItem<int32_t>(HAL_PIXEL_FORMAT_YCrCb_420_SP,		EXPECT_TRUE(ExistsItem<int32_t>(HAL_PIXEL_FORMAT_YCrCb_420_SP,
	entry.data.i32, entry.count));		entry.data.i32, entry.count));

	free_camera_metadata(info);
	}		}

	// test around exclusiveTryLock (immediate locking)		// test around exclusiveTryLock (immediate locking)
	@@ -421,78 +516,30 @@ TEST_F(ProCameraTest, DISABLED_StreamingImageSingle) {
	if (HasFatalFailure()) {		if (HasFatalFailure()) {
	return;		return;
	}		}
	char* displaySecsEnv = getenv("TEST_DISPLAY_SECS");
	if (displaySecsEnv != NULL) {
	mDisplaySecs = atoi(displaySecsEnv);
	if (mDisplaySecs < 0) {
	mDisplaySecs = 0;
	}
	} else {
	mDisplaySecs = 0;
	}

	sp<Surface> depthSurface;		sp<Surface> surface;
	if (mDisplaySecs > 0) {		if (mDisplaySecs > 0) {
	createDepthOnScreenSurface(/out/depthSurface);		createOnScreenSurface(/out/surface);
			}
			else {
			dout << "Skipping, will not render to screen" << std::endl;
			return;
	}		}

	int depthStreamId = -1;		int depthStreamId = -1;
	EXPECT_OK(mCamera->createStream(/width/320, /height/240,		EXPECT_OK(mCamera->createStream(mDisplayW, mDisplayH, mDisplayFmt, surface,
	TEST_FORMAT_DEPTH, depthSurface, &depthStreamId));		&depthStreamId));
	EXPECT_NE(-1, depthStreamId);		EXPECT_NE(-1, depthStreamId);

	EXPECT_OK(mCamera->exclusiveTryLock());		EXPECT_OK(mCamera->exclusiveTryLock());
	/* iterate in a loop submitting requests every frame.
	* what kind of requests doesnt really matter, just whatever.
	*/

	// it would probably be better to use CameraMetadata from camera service.		uint8_t streams[] = { depthStreamId };
	camera_metadata_t *request = NULL;		ASSERT_NO_FATAL_FAILURE(createSubmitRequestForStreams(streams, /count/1));
	EXPECT_OK(mCamera->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
	/out/&request));
	EXPECT_NE((void*)NULL, request);

	/* FIXME: dont need this later, at which point the above should become an
	ASSERT_NE*/
	if(request == NULL) request = allocate_camera_metadata(10, 100);

	// set the output streams to just this stream ID

	// wow what a verbose API.
	// i would give a loaf of bread for
	// metadata->updateOrInsert(keys.request.output.streams, streamId);
	uint8_t allStreams[] = { depthStreamId };
	size_t streamCount = sizeof(allStreams) / sizeof(allStreams[0]);

	camera_metadata_entry_t entry;
	uint32_t tag = static_cast<uint32_t>(ANDROID_REQUEST_OUTPUT_STREAMS);
	int find = find_camera_metadata_entry(request, tag, &entry);
	if (find == -ENOENT) {
	if (add_camera_metadata_entry(request, tag, &allStreams,
	/data_count/streamCount) != OK) {
	camera_metadata_t *tmp = allocate_camera_metadata(1000, 10000);
	ASSERT_OK(append_camera_metadata(tmp, request));
	free_camera_metadata(request);
	request = tmp;

	ASSERT_OK(add_camera_metadata_entry(request, tag, &allStreams,
	/data_count/streamCount));
	}
	} else {
	ASSERT_OK(update_camera_metadata_entry(request, entry.index,
	&allStreams, /data_count/streamCount, &entry));
	}

	EXPECT_OK(mCamera->submitRequest(request, /streaming/true));

	dout << "will sleep now for " << mDisplaySecs << std::endl;		dout << "will sleep now for " << mDisplaySecs << std::endl;
	sleep(mDisplaySecs);		sleep(mDisplaySecs);

	free_camera_metadata(request);		EXPECT_OK(mCamera->deleteStream(depthStreamId));

	for (int i = 0; i < streamCount; ++i) {
	EXPECT_OK(mCamera->deleteStream(allStreams[i]));
	}
	EXPECT_OK(mCamera->exclusiveUnlock());		EXPECT_OK(mCamera->exclusiveUnlock());
	}		}

	@@ -501,16 +548,6 @@ TEST_F(ProCameraTest, DISABLED_StreamingImageDual) {
	if (HasFatalFailure()) {		if (HasFatalFailure()) {
	return;		return;
	}		}
	char* displaySecsEnv = getenv("TEST_DISPLAY_SECS");
	if (displaySecsEnv != NULL) {
	mDisplaySecs = atoi(displaySecsEnv);
	if (mDisplaySecs < 0) {
	mDisplaySecs = 0;
	}
	} else {
	mDisplaySecs = 0;
	}

	sp<Surface> surface;		sp<Surface> surface;
	sp<Surface> depthSurface;		sp<Surface> depthSurface;
	if (mDisplaySecs > 0) {		if (mDisplaySecs > 0) {