src/camera/lib/image_utils/raw12_writer_unittest.cc - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "src/camera/lib/image_utils/raw12_writer.h"

 #include <array>
 #include <vector>

 #include <gtest/gtest.h>

 namespace camera {
 namespace {

 // All widths/heights are in double-pixels, i.e. a width of 500 means a row of '500 *
 // kBytesPerDoublePixel' bytes.
 constexpr uint32_t kWidth = 2;
 constexpr uint32_t kHeight = 2;
 constexpr size_t kSquareImageSize = kWidth * kHeight * kBytesPerDoublePixel;
 constexpr uint32_t kDoubleWidth = kWidth * 2;
 constexpr uint32_t kDoubleHeight = kHeight * 2;
 constexpr uint32_t kHalfWidth = kWidth / 2;
 constexpr uint32_t kHalfHeight = kHeight / 2;
 constexpr size_t kLongImageSize = kHalfWidth * kDoubleHeight * kBytesPerDoublePixel;
 constexpr size_t kWideImageSize = kDoubleWidth * kHalfHeight * kBytesPerDoublePixel;
 const std::array<uint8_t, kSquareImageSize> kSquareImage = {0x80, 0x00, 0x00, 0x80, 0x00, 0x00,
                                                             0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xFF};
 const std::array<uint8_t, kLongImageSize> kLongImage = {0x80, 0x00, 0x00, 0x55, 0x00, 0x05,
                                                         0x80, 0xAA, 0xA0, 0xFF, 0x00, 0x0F};
 const std::array<uint8_t, kWideImageSize> kWideImage = {0x80, 0x00, 0x00, 0x80, 0x00, 0x00,
                                                         0x80, 0x00, 0x00, 0x80, 0x00, 0x00};

 constexpr uint32_t kExhaustiveWidth = 500;
 constexpr uint32_t kExhaustiveHeight = 500;
 constexpr uint32_t kExhaustiveImageSize =
     kExhaustiveWidth * kExhaustiveHeight * kBytesPerDoublePixel;

 // Padding is in bytes.
 constexpr uint32_t kPadding = 1000;

 TEST(Raw12WriterTest, Constructor) { Raw12Writer::Create(kWidth, kHeight); }

 TEST(Raw12WriterTest, ConstructorCheckFailsWithZeroWidth) {
   ASSERT_TRUE(Raw12Writer::Create(0, kHeight).is_error());
 }
 TEST(Raw12WriterTest, ConstructorCheckFailsWithZeroHeight) {
   ASSERT_TRUE(Raw12Writer::Create(kWidth, 0).is_error());
 }

 // Helper method to initialize a Raw12Writer and write an image of specified width/height.
 void ReadTestImage(std::vector<uint8_t>* buf, uint32_t width, uint32_t height) {
   auto result = Raw12Writer::Create(width, height);
   ASSERT_TRUE(result.is_ok());
   auto image_writer = result.take_value();

   zx_status_t status;
   zx::vmo vmo;

   status = image_writer->Write(&vmo, kRedPixel, kMaxVal, kMaxVal);
   ASSERT_EQ(status, ZX_OK);

   status = vmo.read(&buf->front(), 0, image_writer->vmo_size());
   ASSERT_EQ(status, ZX_OK);
 }

 // Helper method to retrieve a double-pixel byte array from a specific x and y position in an image.
 // Width and height provided to calculate scaling factors.
 std::array<uint8_t, kBytesPerDoublePixel> GetDoublePixelAtPostion(uint32_t width, uint32_t height,
                                                                   uint32_t x_pos, uint32_t y_pos) {
   if (x_pos >= width || y_pos >= height) {
     return std::array<uint8_t, kBytesPerDoublePixel>();
   }

   const uint16_t kRowStep = kMaxVal / (width - 1);
   const uint16_t kHeightStep = kMaxVal / (height - 1);

   uint16_t blue_pixel = static_cast<uint16_t>(kRowStep * x_pos);
   uint16_t green_pixel = static_cast<uint16_t>(kHeightStep * y_pos);

   return (y_pos % 2 == 0) ? PixelValuesToDoublePixel(kRedPixel, green_pixel)
                           : PixelValuesToDoublePixel(green_pixel, blue_pixel);
 }

 // Helper method to copy a target pixel from one array/vector to the other.
 void CopyDoublePixel(uint8_t* target, const uint8_t* source, uint32_t target_index,
                      uint32_t source_index = 0) {
   target[target_index] = source[source_index + 0];
   target[target_index + 1] = source[source_index + 1];
   target[target_index + 2] = source[source_index + 2];
 }

 TEST(Raw12WriterTest, WriteSquareImage) {
   std::vector<uint8_t> buf(kSquareImageSize);
   ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kWidth, kHeight));

   auto expected_buf = std::vector<uint8_t>(kSquareImage.begin(), kSquareImage.end());

   EXPECT_TRUE(buf == expected_buf);
 }

 TEST(Raw12WriterTest, WriteLongImage) {
   std::vector<uint8_t> buf(kLongImageSize);
   ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kHalfWidth, kDoubleHeight));

   auto expected_buf = std::vector<uint8_t>(kLongImage.begin(), kLongImage.end());

   EXPECT_TRUE(buf == expected_buf);
 }

 TEST(Raw12WriterTest, WriteWideImage) {
   std::vector<uint8_t> buf(kWideImageSize);
   ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kDoubleWidth, kHalfHeight));

   auto expected_buf = std::vector<uint8_t>(kWideImage.begin(), kWideImage.end());

   EXPECT_TRUE(buf == expected_buf);
 }

 TEST(Raw12WriterTest, WriteExhaustiveImage) {
   std::vector<uint8_t> buf(kExhaustiveImageSize);
   ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kExhaustiveWidth, kExhaustiveHeight));

   // Test byte value at the center.
   const uint32_t kCenterWidth = kExhaustiveWidth / 2;
   const uint32_t kCenterHeight = kExhaustiveHeight / 2;
   uint32_t index = (kExhaustiveWidth * kCenterHeight + kCenterWidth) * kBytesPerDoublePixel;

   auto double_pixel =
       std::array<uint8_t, kBytesPerDoublePixel>({buf[index], buf[index + 1], buf[index + 2]});
   auto expected_double_pixel =
       GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, kCenterWidth, kCenterHeight);

   EXPECT_TRUE(expected_double_pixel == double_pixel);

   const size_t kBorderSize = kExhaustiveWidth * kBytesPerDoublePixel;
   std::vector<uint8_t> expected_top_border(kBorderSize);
   std::vector<uint8_t> expected_bottom_border(kBorderSize);
   std::vector<uint8_t> expected_left_border(kBorderSize);
   std::vector<uint8_t> expected_right_border(kBorderSize);
   std::vector<uint8_t> actual_left_border(kBorderSize);
   std::vector<uint8_t> actual_right_border(kBorderSize);
   index = 0;
   for (uint32_t i = 0; i < kExhaustiveWidth; i++) {
     // Test byte values along the top and bottom rows.
     expected_double_pixel = GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, i, 0);
     CopyDoublePixel(&expected_top_border[0], &expected_double_pixel[0], index);

     expected_double_pixel =
         GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, i, kExhaustiveHeight - 1);
     CopyDoublePixel(&expected_bottom_border[0], &expected_double_pixel[0], index);

     // Test byte values along the left and right columns.
     uint32_t first_column_byte_offset = i * kExhaustiveWidth * kBytesPerDoublePixel;
     uint32_t last_column_byte_offset =
         first_column_byte_offset + (kExhaustiveWidth - 1) * kBytesPerDoublePixel;

     expected_double_pixel = GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, 0, i);
     CopyDoublePixel(&expected_left_border[0], &expected_double_pixel[0], index);
     CopyDoublePixel(&actual_left_border[0], &buf[0], index, first_column_byte_offset);

     expected_double_pixel =
         GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, kExhaustiveWidth - 1, i);
     CopyDoublePixel(&expected_right_border[0], &expected_double_pixel[0], index);
     CopyDoublePixel(&actual_right_border[0], &buf[0], index, last_column_byte_offset);

     index += kBytesPerDoublePixel;
   }

   // std::equal needed for the first two comparisons as it automatically factors in buf size.
   EXPECT_TRUE(std::equal(expected_top_border.begin(), expected_top_border.end(), buf.begin()));
   EXPECT_TRUE(
       std::equal(expected_bottom_border.begin(), expected_bottom_border.end(),
                  buf.begin() + kExhaustiveWidth * (kExhaustiveHeight - 1) * kBytesPerDoublePixel));
   EXPECT_TRUE(actual_left_border == expected_left_border);
   EXPECT_TRUE(actual_right_border == expected_right_border);
 }

 TEST(Raw12WriterTest, WriteDoesNotOverwriteBytesPastImage) {
   // Add some padding to the buffer (after the image).
   std::vector<uint8_t> buf(kExhaustiveImageSize + kPadding);
   ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kExhaustiveWidth, kExhaustiveHeight));

   // Compare it to a buffer of zeroes of equal length to the padding.
   const std::array<uint8_t, kPadding> kExpectedBuf = {};

   // Check that the last byte in the image is not 0.
   EXPECT_NE(0x0, buf[kExhaustiveImageSize - 1]);
   // Compares kExpectedBuf to end of buf + size of kExpectedBuf.
   EXPECT_TRUE(
       std::equal(kExpectedBuf.begin(), kExpectedBuf.end(), buf.begin() + kExhaustiveImageSize));
 }

 TEST(Raw12WriterTest, PixelValuesToDoublePixelWorksCorrectly) {
   const std::array<uint8_t, kBytesPerDoublePixel> kExpectedZeroBuf = {};
   const std::array<uint8_t, kBytesPerDoublePixel> kExpectedFullBuf = {0xFF, 0xFF, 0xFF};
   const std::array<uint8_t, kBytesPerDoublePixel> kExpectedRandomBuf = {0x3C, 0x09, 0xD1};

   EXPECT_EQ(kExpectedZeroBuf, PixelValuesToDoublePixel(0x0, 0x0));
   EXPECT_EQ(kExpectedFullBuf, PixelValuesToDoublePixel(0xFFF, 0xFFF));
   EXPECT_EQ(kExpectedRandomBuf, PixelValuesToDoublePixel(0x3C1, 0x09D));
 }

 TEST(Raw12WriterTest, DoublePixelToPixelValuesWorksCorrectly) {
   const std::array<uint8_t, kBytesPerDoublePixel> kZeroBuf = {};
   const std::array<uint8_t, kBytesPerDoublePixel> kFullBuf = {0xFF, 0xFF, 0xFF};
   const std::array<uint8_t, kBytesPerDoublePixel> kRandomBuf = {0x3C, 0x09, 0xD1};
   const std::pair<uint16_t, uint16_t> kExpectedZeroPair(0x0, 0x0);
   const std::pair<uint16_t, uint16_t> kExpectedFullPair(0xFFF, 0xFFF);
   const std::pair<uint16_t, uint16_t> kExpectedRandomPair(0x3C1, 0x09D);

   EXPECT_EQ(kExpectedZeroPair, DoublePixelToPixelValues(kZeroBuf));
   EXPECT_EQ(kExpectedFullPair, DoublePixelToPixelValues(kFullBuf));
   EXPECT_EQ(kExpectedRandomPair, DoublePixelToPixelValues(kRandomBuf));
 }

 }  // namespace
 }  // namespace camera
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "src/camera/lib/image_utils/raw12_writer.h"

	#include <array>
	#include <vector>

	#include <gtest/gtest.h>

	namespace camera {
	namespace {

	// All widths/heights are in double-pixels, i.e. a width of 500 means a row of '500 *
	// kBytesPerDoublePixel' bytes.
	constexpr uint32_t kWidth = 2;
	constexpr uint32_t kHeight = 2;
	constexpr size_t kSquareImageSize = kWidth * kHeight * kBytesPerDoublePixel;
	constexpr uint32_t kDoubleWidth = kWidth * 2;
	constexpr uint32_t kDoubleHeight = kHeight * 2;
	constexpr uint32_t kHalfWidth = kWidth / 2;
	constexpr uint32_t kHalfHeight = kHeight / 2;
	constexpr size_t kLongImageSize = kHalfWidth * kDoubleHeight * kBytesPerDoublePixel;
	constexpr size_t kWideImageSize = kDoubleWidth * kHalfHeight * kBytesPerDoublePixel;
	const std::array<uint8_t, kSquareImageSize> kSquareImage = {0x80, 0x00, 0x00, 0x80, 0x00, 0x00,
	0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xFF};
	const std::array<uint8_t, kLongImageSize> kLongImage = {0x80, 0x00, 0x00, 0x55, 0x00, 0x05,
	0x80, 0xAA, 0xA0, 0xFF, 0x00, 0x0F};
	const std::array<uint8_t, kWideImageSize> kWideImage = {0x80, 0x00, 0x00, 0x80, 0x00, 0x00,
	0x80, 0x00, 0x00, 0x80, 0x00, 0x00};

	constexpr uint32_t kExhaustiveWidth = 500;
	constexpr uint32_t kExhaustiveHeight = 500;
	constexpr uint32_t kExhaustiveImageSize =
	kExhaustiveWidth * kExhaustiveHeight * kBytesPerDoublePixel;

	// Padding is in bytes.
	constexpr uint32_t kPadding = 1000;

	TEST(Raw12WriterTest, Constructor) { Raw12Writer::Create(kWidth, kHeight); }

	TEST(Raw12WriterTest, ConstructorCheckFailsWithZeroWidth) {
	ASSERT_TRUE(Raw12Writer::Create(0, kHeight).is_error());
	}
	TEST(Raw12WriterTest, ConstructorCheckFailsWithZeroHeight) {
	ASSERT_TRUE(Raw12Writer::Create(kWidth, 0).is_error());
	}

	// Helper method to initialize a Raw12Writer and write an image of specified width/height.
	void ReadTestImage(std::vector<uint8_t>* buf, uint32_t width, uint32_t height) {
	auto result = Raw12Writer::Create(width, height);
	ASSERT_TRUE(result.is_ok());
	auto image_writer = result.take_value();

	zx_status_t status;
	zx::vmo vmo;

	status = image_writer->Write(&vmo, kRedPixel, kMaxVal, kMaxVal);
	ASSERT_EQ(status, ZX_OK);

	status = vmo.read(&buf->front(), 0, image_writer->vmo_size());
	ASSERT_EQ(status, ZX_OK);
	}

	// Helper method to retrieve a double-pixel byte array from a specific x and y position in an image.
	// Width and height provided to calculate scaling factors.
	std::array<uint8_t, kBytesPerDoublePixel> GetDoublePixelAtPostion(uint32_t width, uint32_t height,
	uint32_t x_pos, uint32_t y_pos) {
	if (x_pos >= width \|\| y_pos >= height) {
	return std::array<uint8_t, kBytesPerDoublePixel>();
	}

	const uint16_t kRowStep = kMaxVal / (width - 1);
	const uint16_t kHeightStep = kMaxVal / (height - 1);

	uint16_t blue_pixel = static_cast<uint16_t>(kRowStep * x_pos);
	uint16_t green_pixel = static_cast<uint16_t>(kHeightStep * y_pos);

	return (y_pos % 2 == 0) ? PixelValuesToDoublePixel(kRedPixel, green_pixel)
	: PixelValuesToDoublePixel(green_pixel, blue_pixel);
	}

	// Helper method to copy a target pixel from one array/vector to the other.
	void CopyDoublePixel(uint8_t* target, const uint8_t* source, uint32_t target_index,
	uint32_t source_index = 0) {
	target[target_index] = source[source_index + 0];
	target[target_index + 1] = source[source_index + 1];
	target[target_index + 2] = source[source_index + 2];
	}

	TEST(Raw12WriterTest, WriteSquareImage) {
	std::vector<uint8_t> buf(kSquareImageSize);
	ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kWidth, kHeight));

	auto expected_buf = std::vector<uint8_t>(kSquareImage.begin(), kSquareImage.end());

	EXPECT_TRUE(buf == expected_buf);
	}

	TEST(Raw12WriterTest, WriteLongImage) {
	std::vector<uint8_t> buf(kLongImageSize);
	ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kHalfWidth, kDoubleHeight));

	auto expected_buf = std::vector<uint8_t>(kLongImage.begin(), kLongImage.end());

	EXPECT_TRUE(buf == expected_buf);
	}

	TEST(Raw12WriterTest, WriteWideImage) {
	std::vector<uint8_t> buf(kWideImageSize);
	ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kDoubleWidth, kHalfHeight));

	auto expected_buf = std::vector<uint8_t>(kWideImage.begin(), kWideImage.end());

	EXPECT_TRUE(buf == expected_buf);
	}

	TEST(Raw12WriterTest, WriteExhaustiveImage) {
	std::vector<uint8_t> buf(kExhaustiveImageSize);
	ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kExhaustiveWidth, kExhaustiveHeight));

	// Test byte value at the center.
	const uint32_t kCenterWidth = kExhaustiveWidth / 2;
	const uint32_t kCenterHeight = kExhaustiveHeight / 2;
	uint32_t index = (kExhaustiveWidth * kCenterHeight + kCenterWidth) * kBytesPerDoublePixel;

	auto double_pixel =
	std::array<uint8_t, kBytesPerDoublePixel>({buf[index], buf[index + 1], buf[index + 2]});
	auto expected_double_pixel =
	GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, kCenterWidth, kCenterHeight);

	EXPECT_TRUE(expected_double_pixel == double_pixel);

	const size_t kBorderSize = kExhaustiveWidth * kBytesPerDoublePixel;
	std::vector<uint8_t> expected_top_border(kBorderSize);
	std::vector<uint8_t> expected_bottom_border(kBorderSize);
	std::vector<uint8_t> expected_left_border(kBorderSize);
	std::vector<uint8_t> expected_right_border(kBorderSize);
	std::vector<uint8_t> actual_left_border(kBorderSize);
	std::vector<uint8_t> actual_right_border(kBorderSize);
	index = 0;
	for (uint32_t i = 0; i < kExhaustiveWidth; i++) {
	// Test byte values along the top and bottom rows.
	expected_double_pixel = GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, i, 0);
	CopyDoublePixel(&expected_top_border[0], &expected_double_pixel[0], index);

	expected_double_pixel =
	GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, i, kExhaustiveHeight - 1);
	CopyDoublePixel(&expected_bottom_border[0], &expected_double_pixel[0], index);

	// Test byte values along the left and right columns.
	uint32_t first_column_byte_offset = i * kExhaustiveWidth * kBytesPerDoublePixel;
	uint32_t last_column_byte_offset =
	first_column_byte_offset + (kExhaustiveWidth - 1) * kBytesPerDoublePixel;

	expected_double_pixel = GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, 0, i);
	CopyDoublePixel(&expected_left_border[0], &expected_double_pixel[0], index);
	CopyDoublePixel(&actual_left_border[0], &buf[0], index, first_column_byte_offset);

	expected_double_pixel =
	GetDoublePixelAtPostion(kExhaustiveWidth, kExhaustiveHeight, kExhaustiveWidth - 1, i);
	CopyDoublePixel(&expected_right_border[0], &expected_double_pixel[0], index);
	CopyDoublePixel(&actual_right_border[0], &buf[0], index, last_column_byte_offset);

	index += kBytesPerDoublePixel;
	}

	// std::equal needed for the first two comparisons as it automatically factors in buf size.
	EXPECT_TRUE(std::equal(expected_top_border.begin(), expected_top_border.end(), buf.begin()));
	EXPECT_TRUE(
	std::equal(expected_bottom_border.begin(), expected_bottom_border.end(),
	buf.begin() + kExhaustiveWidth * (kExhaustiveHeight - 1) * kBytesPerDoublePixel));
	EXPECT_TRUE(actual_left_border == expected_left_border);
	EXPECT_TRUE(actual_right_border == expected_right_border);
	}

	TEST(Raw12WriterTest, WriteDoesNotOverwriteBytesPastImage) {
	// Add some padding to the buffer (after the image).
	std::vector<uint8_t> buf(kExhaustiveImageSize + kPadding);
	ASSERT_NO_FATAL_FAILURE(ReadTestImage(&buf, kExhaustiveWidth, kExhaustiveHeight));

	// Compare it to a buffer of zeroes of equal length to the padding.
	const std::array<uint8_t, kPadding> kExpectedBuf = {};

	// Check that the last byte in the image is not 0.
	EXPECT_NE(0x0, buf[kExhaustiveImageSize - 1]);
	// Compares kExpectedBuf to end of buf + size of kExpectedBuf.
	EXPECT_TRUE(
	std::equal(kExpectedBuf.begin(), kExpectedBuf.end(), buf.begin() + kExhaustiveImageSize));
	}

	TEST(Raw12WriterTest, PixelValuesToDoublePixelWorksCorrectly) {
	const std::array<uint8_t, kBytesPerDoublePixel> kExpectedZeroBuf = {};
	const std::array<uint8_t, kBytesPerDoublePixel> kExpectedFullBuf = {0xFF, 0xFF, 0xFF};
	const std::array<uint8_t, kBytesPerDoublePixel> kExpectedRandomBuf = {0x3C, 0x09, 0xD1};

	EXPECT_EQ(kExpectedZeroBuf, PixelValuesToDoublePixel(0x0, 0x0));
	EXPECT_EQ(kExpectedFullBuf, PixelValuesToDoublePixel(0xFFF, 0xFFF));
	EXPECT_EQ(kExpectedRandomBuf, PixelValuesToDoublePixel(0x3C1, 0x09D));
	}

	TEST(Raw12WriterTest, DoublePixelToPixelValuesWorksCorrectly) {
	const std::array<uint8_t, kBytesPerDoublePixel> kZeroBuf = {};
	const std::array<uint8_t, kBytesPerDoublePixel> kFullBuf = {0xFF, 0xFF, 0xFF};
	const std::array<uint8_t, kBytesPerDoublePixel> kRandomBuf = {0x3C, 0x09, 0xD1};
	const std::pair<uint16_t, uint16_t> kExpectedZeroPair(0x0, 0x0);
	const std::pair<uint16_t, uint16_t> kExpectedFullPair(0xFFF, 0xFFF);
	const std::pair<uint16_t, uint16_t> kExpectedRandomPair(0x3C1, 0x09D);

	EXPECT_EQ(kExpectedZeroPair, DoublePixelToPixelValues(kZeroBuf));
	EXPECT_EQ(kExpectedFullPair, DoublePixelToPixelValues(kFullBuf));
	EXPECT_EQ(kExpectedRandomPair, DoublePixelToPixelValues(kRandomBuf));
	}

	} // namespace
	} // namespace camera