android/android-emu/android/camera/CameraFormatConverters_unittest.cpp - platform/external/qemu - Git at Google

 // Copyright (C) 2017 The Android Open Source Project
 //
 // This software is licensed under the terms of the GNU General Public
 // License version 2, as published by the Free Software Foundation, and
 // may be copied, distributed, and modified under those terms.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.

 #include "android/camera/camera-format-converters.h"

 #include <gtest/gtest.h>

 #include <vector>

 // An arbitrary color that's easily recognizable in hex and different for each
 // channel.
 static constexpr uint8_t kAlpha = 0xFF;
 static constexpr uint8_t kRed = 0x00;
 static constexpr uint8_t kGreen = 0x66;
 static constexpr uint8_t kBlue = 0xCC;

 static constexpr float kDefaultColorScale = 1.0f;
 static constexpr float kDefaultExpComp = 1.0f;

 // Difference squared per pixel.  Libyuv produces slightly different color
 // values for each pixel, allow a slight difference.
 static constexpr double kDifferenceSq = 2.0;

 // For exposure compensation, allow a slightly more lenient error to compensate
 // for rounding errors.
 static constexpr double kLenientDifferenceSq = 4.0;

 // Max value that a pixel could differ, used to exclude edge pixel differences.
 static constexpr double kCompletelyDifferentSq = 256.0 * 256.0;

 // A list of all of the source formats that convert_frame_slow understands,
 // taken from camera-format-converters.c's _PIXFormats.
 static constexpr uint32_t kSupportedSourceFormats[] = {
         // RGB formats.
         V4L2_PIX_FMT_ARGB32, V4L2_PIX_FMT_RGB32, V4L2_PIX_FMT_BGR32,
         V4L2_PIX_FMT_RGB565, V4L2_PIX_FMT_RGB24, V4L2_PIX_FMT_BGR24,

         // YUV 4:2:0 formats.
         V4L2_PIX_FMT_YVU420, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_NV12,
         V4L2_PIX_FMT_NV21,

         // YUV 4:2:2 formats.
         V4L2_PIX_FMT_YUYV, V4L2_PIX_FMT_YYUV, V4L2_PIX_FMT_YVYU,
         V4L2_PIX_FMT_UYVY, V4L2_PIX_FMT_VYUY, V4L2_PIX_FMT_YYVU,
         // Aliases for V4L2_PIX_FMT_YUYV.
         V4L2_PIX_FMT_YUY2, V4L2_PIX_FMT_YUNV, V4L2_PIX_FMT_V422,

         // Exclude bayer formats, they are not available in the fast-path so
         // they don't need comparative testing.
 };

 // A list of supported output formats, taken from camera-service.c's
 // calculate_frame_size.
 static constexpr uint32_t kSupportedDestinationFormats[] = {
         V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_YVU420, V4L2_PIX_FMT_NV12,
         V4L2_PIX_FMT_NV21,   V4L2_PIX_FMT_RGB32,  V4L2_PIX_FMT_RGB24,
 };

 enum class FramebufferCompare { Default, IgnoreEdges };

 struct FramebufferSizeParam {
     int width;
     int height;
     FramebufferCompare options;

     FramebufferSizeParam(
             int width,
             int height,
             FramebufferCompare options = FramebufferCompare::Default)
         : width(width), height(height), options(options) {}

     double getThreshold() const {
         if (options == FramebufferCompare::IgnoreEdges) {
             return lerpThreshold(kDifferenceSq, kCompletelyDifferentSq,
                                  edgePixelPercent());
         } else {
             return kDifferenceSq;
         }
     }

     double getThresholdForResize() const {
         // Ignore edges and increase the maximum difference since this is for
         // two convert operations.
         return lerpThreshold(kDifferenceSq * 2, kCompletelyDifferentSq,
                              edgePixelPercent());
     }

 private:
     // Edge pixels are the bottom- and right-most rows/columns. For YUV images,
     // there are three planes (each at half-resolution), so for the last row
     // (width) + 2 * (width / 2) pixels can be different. This is simplified to
     // 2 * width.
     double edgePixelPercent() const {
         return (2.0 * width + 2.0 * height) / (width * height);
     }

     static double lerpThreshold(double a, double b, double t) {
         return (1.0 - t) * a + t * b;
     }
 };

 static void PrintTo(const FramebufferSizeParam& param, std::ostream* os) {
     *os << "FramebufferSizeParam(" << param.width << "x" << param.height
         << ", threshold=" << param.getThreshold() << ")";
 }

 namespace std {
 void PrintTo(const vector<uint8_t>& vec, ostream* os) {
     ios::fmtflags origFlags(os->flags());

     *os << '{';
     size_t count = 0;
     for (vector<uint8_t>::const_iterator it = vec.begin(); it != vec.end();
          ++it, ++count) {
         if (count > 0) {
             *os << ", ";
         }
         if ((count % 16) == 0) {
             *os << "\n";
         }

         if (*it == 0) {
             *os << "    ";
         } else {
             *os << "0x" << std::hex << std::uppercase << std::setw(2)
                 << std::setfill('0') << int(*it) << std::dec;
         }
     }

     *os << '}';

     os->flags(origFlags);
 }
 }

 static size_t bufferSize(uint32_t format, int width, int height) {
     size_t size = 0;
     EXPECT_TRUE(calculate_framebuffer_size(format, width, height, &size));
     return size;
 }

 static std::string fourccToString(uint32_t fourcc) {
     return std::string(reinterpret_cast<const char*>(&fourcc),
                        sizeof(uint32_t));
 }

 // Generate a framebuffer filled with the given color (in rgb) and converted
 // to the target colorspace.
 static std::vector<uint8_t> generateFramebuffer(uint32_t format,
                                                 int width,
                                                 int height,
                                                 uint8_t a,
                                                 uint8_t r,
                                                 uint8_t g,
                                                 uint8_t b) {
     uint32_t argbColor;
     uint8_t* rgbPtr = reinterpret_cast<uint8_t*>(&argbColor);
     rgbPtr[0] = a;
     rgbPtr[1] = r;
     rgbPtr[2] = g;
     rgbPtr[3] = b;

     const size_t srcSize = bufferSize(V4L2_PIX_FMT_ARGB32, width, height);
     const size_t destSize = bufferSize(format, width, height);
     std::vector<uint8_t> src(srcSize);
     std::vector<uint8_t> dest(destSize);

     // Fill src with the argbColor
     uint32_t* src32 = reinterpret_cast<uint32_t*>(src.data());
     for (size_t i = 0; i < srcSize / 4; ++i) {
         src32[i] = argbColor;
     }

     ClientFrameBuffer framebuffer = {};
     framebuffer.pixel_format = format;
     framebuffer.framebuffer = dest.data();

     EXPECT_EQ(0, convert_frame_slow(src.data(), V4L2_PIX_FMT_ARGB32, src.size(),
                                     width, height, &framebuffer, 1,
                                     kDefaultColorScale, kDefaultColorScale,
                                     kDefaultColorScale, kDefaultExpComp))
             << "convert_frame_slow, source="
             << fourccToString(V4L2_PIX_FMT_ARGB32)
             << " dest=" << fourccToString(format);

     return dest;
 }

 static void compareSumOfSquaredDifferences(const std::vector<uint8_t>& src,
                                            const std::vector<uint8_t>& dest,
                                            double threshold) {
     ASSERT_EQ(src.size(), dest.size());

     double sum = 0.0;
     for (size_t i = 0; i < src.size(); ++i) {
         double diff = static_cast<double>(src[i]) - dest[i];
         sum += diff * diff;
     }

     EXPECT_LE(sum, threshold * src.size());
     if (sum > threshold * src.size()) {
         // Fall back to standard EXPECT_EQ for better error output.
         ASSERT_EQ(src, dest);
     }
 }

 class ConvertWithSize : public testing::TestWithParam<FramebufferSizeParam> {};

 // Validate identity conversions.
 TEST_P(ConvertWithSize, SlowPathIdentity) {
     const FramebufferSizeParam param = GetParam();

     for (uint32_t format : kSupportedDestinationFormats) {
         SCOPED_TRACE(testing::Message() << "source=" << fourccToString(format)
                                         << " dest=" << fourccToString(format));

         std::vector<uint8_t> src = generateFramebuffer(
                 format, param.width, param.height, kAlpha, kRed, kGreen, kBlue);
         const size_t destSize = bufferSize(format, param.width, param.height);
         std::vector<uint8_t> dest(destSize);

         ClientFrameBuffer framebuffer = {};
         framebuffer.pixel_format = format;
         framebuffer.framebuffer = dest.data();

         EXPECT_EQ(0,
                   convert_frame_slow(src.data(), format, src.size(),
                                      param.width, param.height, &framebuffer, 1,
                                      kDefaultColorScale, kDefaultColorScale,
                                      kDefaultColorScale, kDefaultExpComp));

         compareSumOfSquaredDifferences(src, dest, param.getThreshold());

         if (HasFatalFailure()) {
             return;
         }
     }
 }

 TEST_P(ConvertWithSize, FastPathIdentity) {
     const FramebufferSizeParam param = GetParam();
     uint8_t* stagingFramebuffer = nullptr;
     size_t stagingFramebufferSize = 0;

     for (uint32_t format : kSupportedDestinationFormats) {
         SCOPED_TRACE(testing::Message() << "source=" << fourccToString(format)
                                         << " dest=" << fourccToString(format));

         std::vector<uint8_t> src = generateFramebuffer(
                 format, param.width, param.height, kAlpha, kRed, kGreen, kBlue);
         const size_t destSize = bufferSize(format, param.width, param.height);
         std::vector<uint8_t> dest(destSize);

         ClientFrameBuffer framebuffer = {};
         framebuffer.pixel_format = format;
         framebuffer.framebuffer = dest.data();

         ClientFrame resultFrame = {};
         resultFrame.framebuffers = &framebuffer;
         resultFrame.framebuffers_count = 1;
         resultFrame.staging_framebuffer = &stagingFramebuffer;
         resultFrame.staging_framebuffer_size = &stagingFramebufferSize;

         EXPECT_EQ(0, convert_frame_fast(src.data(), format, src.size(),
                                         param.width, param.height, param.width,
                                         param.height, &resultFrame,
                                         kDefaultExpComp));

         compareSumOfSquaredDifferences(src, dest, param.getThreshold());

         if (HasFatalFailure()) {
             return;
         }
     }

     free(stagingFramebuffer);
 }

 TEST_P(ConvertWithSize, Resize) {
     static constexpr size_t kScaleAmount = 4;

     const FramebufferSizeParam param = GetParam();
     uint8_t* stagingFramebuffer = nullptr;
     size_t stagingFramebufferSize = 0;

     for (uint32_t format : kSupportedDestinationFormats) {
         SCOPED_TRACE(testing::Message() << "source=" << fourccToString(format)
                                         << " dest=" << fourccToString(format));

         std::vector<uint8_t> src = generateFramebuffer(
                 format, param.width, param.height, kAlpha, kRed, kGreen, kBlue);

         const size_t intermediateSize =
                 bufferSize(format, param.width / kScaleAmount,
                            param.height / kScaleAmount);
         std::vector<uint8_t> intermediate(intermediateSize);

         const size_t destSize = bufferSize(format, param.width, param.height);
         std::vector<uint8_t> dest(destSize);

         ClientFrameBuffer framebuffer = {};
         framebuffer.pixel_format = format;
         framebuffer.framebuffer = intermediate.data();

         ClientFrame resultFrame = {};
         resultFrame.framebuffers = &framebuffer;
         resultFrame.framebuffers_count = 1;
         resultFrame.staging_framebuffer = &stagingFramebuffer;
         resultFrame.staging_framebuffer_size = &stagingFramebufferSize;

         EXPECT_EQ(0, convert_frame_fast(src.data(), format, src.size(),
                                         param.width, param.height,
                                         param.width / kScaleAmount,
                                         param.height / kScaleAmount,
                                         &resultFrame, kDefaultExpComp));

         memset(stagingFramebuffer, 0, stagingFramebufferSize);

         framebuffer.framebuffer = dest.data();
         EXPECT_EQ(0, convert_frame_fast(
                              intermediate.data(), format, intermediate.size(),
                              param.width / kScaleAmount,
                              param.height / kScaleAmount, param.width,
                              param.height, &resultFrame, kDefaultExpComp));

         compareSumOfSquaredDifferences(src, dest,
                                        param.getThresholdForResize());

         if (HasFatalFailure()) {
             return;
         }
     }

     free(stagingFramebuffer);
 }

 // Validate conversions from all source formats to all dest formats.
 TEST_P(ConvertWithSize, SourceToDest) {
     const FramebufferSizeParam param = GetParam();
     uint8_t* stagingFramebuffer = nullptr;
     size_t stagingFramebufferSize = 0;

     for (uint32_t src_format : kSupportedSourceFormats) {
         std::vector<uint8_t> src =
                 generateFramebuffer(src_format, param.width, param.height,
                                     kAlpha, kRed, kGreen, kBlue);

         for (uint32_t dest_format : kSupportedDestinationFormats) {
             SCOPED_TRACE(testing::Message()
                          << "source=" << fourccToString(src_format)
                          << " dest=" << fourccToString(dest_format));

             const size_t destSize =
                     bufferSize(dest_format, param.width, param.height);
             std::vector<uint8_t> dest(destSize);

             ClientFrameBuffer framebuffer = {};
             framebuffer.pixel_format = dest_format;
             framebuffer.framebuffer = dest.data();

             ClientFrame resultFrame = {};
             resultFrame.framebuffers = &framebuffer;
             resultFrame.framebuffers_count = 1;
             resultFrame.staging_framebuffer = &stagingFramebuffer;
             resultFrame.staging_framebuffer_size = &stagingFramebufferSize;

             EXPECT_EQ(0, convert_frame(src.data(), src_format, src.size(),
                                        param.width, param.height, &resultFrame,
                                        kDefaultColorScale, kDefaultColorScale,
                                        kDefaultColorScale, kDefaultExpComp));

             std::vector<uint8_t> destBaseline(destSize);
             ClientFrameBuffer baselineFramebuffer = {};
             baselineFramebuffer.pixel_format = dest_format;
             baselineFramebuffer.framebuffer = destBaseline.data();

             EXPECT_EQ(0,
                       convert_frame_slow(src.data(), src_format, src.size(),
                                          param.width, param.height,
                                          &baselineFramebuffer, 1,
                                          kDefaultColorScale, kDefaultColorScale,
                                          kDefaultColorScale, kDefaultExpComp));

             compareSumOfSquaredDifferences(destBaseline, dest,
                                            param.getThreshold());

             if (HasFatalFailure()) {
                 return;
             }
         }
     }

     free(stagingFramebuffer);
 }

 INSTANTIATE_TEST_CASE_P(
         CameraFormatConverters,
         ConvertWithSize,
         testing::Values(
                 // Even dimensions may have slight differences per
                 // pixel.
                 FramebufferSizeParam(4, 4),
                 FramebufferSizeParam(8, 8),
                 FramebufferSizeParam(16, 16),
                 FramebufferSizeParam(18, 18),
                 FramebufferSizeParam(20, 20),
                 FramebufferSizeParam(32, 32),
                 // The fast and slow path handle boundary pixels for
                 // odd dimensions differently, allow them to be
                 // different with a larger threshold.
                 FramebufferSizeParam(5, 5, FramebufferCompare::IgnoreEdges),
                 FramebufferSizeParam(7, 7, FramebufferCompare::IgnoreEdges),
                 FramebufferSizeParam(15, 15, FramebufferCompare::IgnoreEdges),
                 FramebufferSizeParam(17, 17, FramebufferCompare::IgnoreEdges)));

 class FrameModifiers : public testing::TestWithParam<float> {};

 TEST_P(FrameModifiers, ExpComp) {
     constexpr int kWidth = 4;
     constexpr int kHeight = 4;

     const float expComp = GetParam();

     uint8_t* stagingFramebuffer = nullptr;
     size_t stagingFramebufferSize = 0;

     for (uint32_t src_format : kSupportedSourceFormats) {
         std::vector<uint8_t> src = generateFramebuffer(
                 src_format, kWidth, kHeight, kAlpha, kRed, kGreen, kBlue);

         for (uint32_t dest_format : kSupportedDestinationFormats) {
             SCOPED_TRACE(testing::Message()
                          << "source=" << fourccToString(src_format)
                          << " dest=" << fourccToString(dest_format));

             const size_t destSize = bufferSize(dest_format, kWidth, kHeight);
             std::vector<uint8_t> dest(destSize);

             ClientFrameBuffer framebuffer = {};
             framebuffer.pixel_format = dest_format;
             framebuffer.framebuffer = dest.data();

             ClientFrame resultFrame = {};
             resultFrame.framebuffers = &framebuffer;
             resultFrame.framebuffers_count = 1;
             resultFrame.staging_framebuffer = &stagingFramebuffer;
             resultFrame.staging_framebuffer_size = &stagingFramebufferSize;

             EXPECT_EQ(0, convert_frame(src.data(), src_format, src.size(),
                                        kWidth, kHeight, &resultFrame,
                                        kDefaultColorScale, kDefaultColorScale,
                                        kDefaultColorScale, expComp));

             std::vector<uint8_t> destBaseline(destSize);
             ClientFrameBuffer baselineFramebuffer = {};
             baselineFramebuffer.pixel_format = dest_format;
             baselineFramebuffer.framebuffer = destBaseline.data();

             EXPECT_EQ(0, convert_frame_slow(
                                  src.data(), src_format, src.size(), kWidth,
                                  kHeight, &baselineFramebuffer, 1,
                                  kDefaultColorScale, kDefaultColorScale,
                                  kDefaultColorScale, expComp));

             compareSumOfSquaredDifferences(destBaseline, dest,
                                            kLenientDifferenceSq);

             if (HasFatalFailure()) {
                 return;
             }
         }
     }

     free(stagingFramebuffer);
 }

 INSTANTIATE_TEST_CASE_P(CameraFormatConverters,
                         FrameModifiers,
                         testing::Values(1.0f, 0.0f, 0.5f, -1.0f, 2.0f));
	// Copyright (C) 2017 The Android Open Source Project
	//
	// This software is licensed under the terms of the GNU General Public
	// License version 2, as published by the Free Software Foundation, and
	// may be copied, distributed, and modified under those terms.
	//
	// This program is distributed in the hope that it will be useful,
	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	// GNU General Public License for more details.

	#include "android/camera/camera-format-converters.h"

	#include <gtest/gtest.h>

	#include <vector>

	// An arbitrary color that's easily recognizable in hex and different for each
	// channel.
	static constexpr uint8_t kAlpha = 0xFF;
	static constexpr uint8_t kRed = 0x00;
	static constexpr uint8_t kGreen = 0x66;
	static constexpr uint8_t kBlue = 0xCC;

	static constexpr float kDefaultColorScale = 1.0f;
	static constexpr float kDefaultExpComp = 1.0f;

	// Difference squared per pixel. Libyuv produces slightly different color
	// values for each pixel, allow a slight difference.
	static constexpr double kDifferenceSq = 2.0;

	// For exposure compensation, allow a slightly more lenient error to compensate
	// for rounding errors.
	static constexpr double kLenientDifferenceSq = 4.0;

	// Max value that a pixel could differ, used to exclude edge pixel differences.
	static constexpr double kCompletelyDifferentSq = 256.0 * 256.0;

	// A list of all of the source formats that convert_frame_slow understands,
	// taken from camera-format-converters.c's _PIXFormats.
	static constexpr uint32_t kSupportedSourceFormats[] = {
	// RGB formats.
	V4L2_PIX_FMT_ARGB32, V4L2_PIX_FMT_RGB32, V4L2_PIX_FMT_BGR32,
	V4L2_PIX_FMT_RGB565, V4L2_PIX_FMT_RGB24, V4L2_PIX_FMT_BGR24,

	// YUV 4:2:0 formats.
	V4L2_PIX_FMT_YVU420, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_NV12,
	V4L2_PIX_FMT_NV21,

	// YUV 4:2:2 formats.
	V4L2_PIX_FMT_YUYV, V4L2_PIX_FMT_YYUV, V4L2_PIX_FMT_YVYU,
	V4L2_PIX_FMT_UYVY, V4L2_PIX_FMT_VYUY, V4L2_PIX_FMT_YYVU,
	// Aliases for V4L2_PIX_FMT_YUYV.
	V4L2_PIX_FMT_YUY2, V4L2_PIX_FMT_YUNV, V4L2_PIX_FMT_V422,

	// Exclude bayer formats, they are not available in the fast-path so
	// they don't need comparative testing.
	};

	// A list of supported output formats, taken from camera-service.c's
	// calculate_frame_size.
	static constexpr uint32_t kSupportedDestinationFormats[] = {
	V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_YVU420, V4L2_PIX_FMT_NV12,
	V4L2_PIX_FMT_NV21, V4L2_PIX_FMT_RGB32, V4L2_PIX_FMT_RGB24,
	};

	enum class FramebufferCompare { Default, IgnoreEdges };

	struct FramebufferSizeParam {
	int width;
	int height;
	FramebufferCompare options;

	FramebufferSizeParam(
	int width,
	int height,
	FramebufferCompare options = FramebufferCompare::Default)
	: width(width), height(height), options(options) {}

	double getThreshold() const {
	if (options == FramebufferCompare::IgnoreEdges) {
	return lerpThreshold(kDifferenceSq, kCompletelyDifferentSq,
	edgePixelPercent());
	} else {
	return kDifferenceSq;
	}
	}

	double getThresholdForResize() const {
	// Ignore edges and increase the maximum difference since this is for
	// two convert operations.
	return lerpThreshold(kDifferenceSq * 2, kCompletelyDifferentSq,
	edgePixelPercent());
	}

	private:
	// Edge pixels are the bottom- and right-most rows/columns. For YUV images,
	// there are three planes (each at half-resolution), so for the last row
	// (width) + 2 * (width / 2) pixels can be different. This is simplified to
	// 2 * width.
	double edgePixelPercent() const {
	return (2.0 * width + 2.0 * height) / (width * height);
	}

	static double lerpThreshold(double a, double b, double t) {
	return (1.0 - t) * a + t * b;
	}
	};

	static void PrintTo(const FramebufferSizeParam& param, std::ostream* os) {
	*os << "FramebufferSizeParam(" << param.width << "x" << param.height
	<< ", threshold=" << param.getThreshold() << ")";
	}

	namespace std {
	void PrintTo(const vector<uint8_t>& vec, ostream* os) {
	ios::fmtflags origFlags(os->flags());

	*os << '{';
	size_t count = 0;
	for (vector<uint8_t>::const_iterator it = vec.begin(); it != vec.end();
	++it, ++count) {
	if (count > 0) {
	*os << ", ";
	}
	if ((count % 16) == 0) {
	*os << "\n";
	}

	if (*it == 0) {
	*os << " ";
	} else {
	*os << "0x" << std::hex << std::uppercase << std::setw(2)
	<< std::setfill('0') << int(*it) << std::dec;
	}
	}

	*os << '}';

	os->flags(origFlags);
	}
	}

	static size_t bufferSize(uint32_t format, int width, int height) {
	size_t size = 0;
	EXPECT_TRUE(calculate_framebuffer_size(format, width, height, &size));
	return size;
	}

	static std::string fourccToString(uint32_t fourcc) {
	return std::string(reinterpret_cast<const char*>(&fourcc),
	sizeof(uint32_t));
	}

	// Generate a framebuffer filled with the given color (in rgb) and converted
	// to the target colorspace.
	static std::vector<uint8_t> generateFramebuffer(uint32_t format,
	int width,
	int height,
	uint8_t a,
	uint8_t r,
	uint8_t g,
	uint8_t b) {
	uint32_t argbColor;
	uint8_t* rgbPtr = reinterpret_cast<uint8_t*>(&argbColor);
	rgbPtr[0] = a;
	rgbPtr[1] = r;
	rgbPtr[2] = g;
	rgbPtr[3] = b;

	const size_t srcSize = bufferSize(V4L2_PIX_FMT_ARGB32, width, height);
	const size_t destSize = bufferSize(format, width, height);
	std::vector<uint8_t> src(srcSize);
	std::vector<uint8_t> dest(destSize);

	// Fill src with the argbColor
	uint32_t* src32 = reinterpret_cast<uint32_t*>(src.data());
	for (size_t i = 0; i < srcSize / 4; ++i) {
	src32[i] = argbColor;
	}

	ClientFrameBuffer framebuffer = {};
	framebuffer.pixel_format = format;
	framebuffer.framebuffer = dest.data();

	EXPECT_EQ(0, convert_frame_slow(src.data(), V4L2_PIX_FMT_ARGB32, src.size(),
	width, height, &framebuffer, 1,
	kDefaultColorScale, kDefaultColorScale,
	kDefaultColorScale, kDefaultExpComp))
	<< "convert_frame_slow, source="
	<< fourccToString(V4L2_PIX_FMT_ARGB32)
	<< " dest=" << fourccToString(format);

	return dest;
	}

	static void compareSumOfSquaredDifferences(const std::vector<uint8_t>& src,
	const std::vector<uint8_t>& dest,
	double threshold) {
	ASSERT_EQ(src.size(), dest.size());

	double sum = 0.0;
	for (size_t i = 0; i < src.size(); ++i) {
	double diff = static_cast<double>(src[i]) - dest[i];
	sum += diff * diff;
	}

	EXPECT_LE(sum, threshold * src.size());
	if (sum > threshold * src.size()) {
	// Fall back to standard EXPECT_EQ for better error output.
	ASSERT_EQ(src, dest);
	}
	}

	class ConvertWithSize : public testing::TestWithParam<FramebufferSizeParam> {};

	// Validate identity conversions.
	TEST_P(ConvertWithSize, SlowPathIdentity) {
	const FramebufferSizeParam param = GetParam();

	for (uint32_t format : kSupportedDestinationFormats) {
	SCOPED_TRACE(testing::Message() << "source=" << fourccToString(format)
	<< " dest=" << fourccToString(format));

	std::vector<uint8_t> src = generateFramebuffer(
	format, param.width, param.height, kAlpha, kRed, kGreen, kBlue);
	const size_t destSize = bufferSize(format, param.width, param.height);
	std::vector<uint8_t> dest(destSize);

	ClientFrameBuffer framebuffer = {};
	framebuffer.pixel_format = format;
	framebuffer.framebuffer = dest.data();

	EXPECT_EQ(0,
	convert_frame_slow(src.data(), format, src.size(),
	param.width, param.height, &framebuffer, 1,
	kDefaultColorScale, kDefaultColorScale,
	kDefaultColorScale, kDefaultExpComp));

	compareSumOfSquaredDifferences(src, dest, param.getThreshold());

	if (HasFatalFailure()) {
	return;
	}
	}
	}

	TEST_P(ConvertWithSize, FastPathIdentity) {
	const FramebufferSizeParam param = GetParam();
	uint8_t* stagingFramebuffer = nullptr;
	size_t stagingFramebufferSize = 0;

	for (uint32_t format : kSupportedDestinationFormats) {
	SCOPED_TRACE(testing::Message() << "source=" << fourccToString(format)
	<< " dest=" << fourccToString(format));

	std::vector<uint8_t> src = generateFramebuffer(
	format, param.width, param.height, kAlpha, kRed, kGreen, kBlue);
	const size_t destSize = bufferSize(format, param.width, param.height);
	std::vector<uint8_t> dest(destSize);

	ClientFrameBuffer framebuffer = {};
	framebuffer.pixel_format = format;
	framebuffer.framebuffer = dest.data();

	ClientFrame resultFrame = {};
	resultFrame.framebuffers = &framebuffer;
	resultFrame.framebuffers_count = 1;
	resultFrame.staging_framebuffer = &stagingFramebuffer;
	resultFrame.staging_framebuffer_size = &stagingFramebufferSize;

	EXPECT_EQ(0, convert_frame_fast(src.data(), format, src.size(),
	param.width, param.height, param.width,
	param.height, &resultFrame,
	kDefaultExpComp));

	compareSumOfSquaredDifferences(src, dest, param.getThreshold());

	if (HasFatalFailure()) {
	return;
	}
	}

	free(stagingFramebuffer);
	}

	TEST_P(ConvertWithSize, Resize) {
	static constexpr size_t kScaleAmount = 4;

	const FramebufferSizeParam param = GetParam();
	uint8_t* stagingFramebuffer = nullptr;
	size_t stagingFramebufferSize = 0;

	for (uint32_t format : kSupportedDestinationFormats) {
	SCOPED_TRACE(testing::Message() << "source=" << fourccToString(format)
	<< " dest=" << fourccToString(format));

	std::vector<uint8_t> src = generateFramebuffer(
	format, param.width, param.height, kAlpha, kRed, kGreen, kBlue);

	const size_t intermediateSize =
	bufferSize(format, param.width / kScaleAmount,
	param.height / kScaleAmount);
	std::vector<uint8_t> intermediate(intermediateSize);

	const size_t destSize = bufferSize(format, param.width, param.height);
	std::vector<uint8_t> dest(destSize);

	ClientFrameBuffer framebuffer = {};
	framebuffer.pixel_format = format;
	framebuffer.framebuffer = intermediate.data();

	ClientFrame resultFrame = {};
	resultFrame.framebuffers = &framebuffer;
	resultFrame.framebuffers_count = 1;
	resultFrame.staging_framebuffer = &stagingFramebuffer;
	resultFrame.staging_framebuffer_size = &stagingFramebufferSize;

	EXPECT_EQ(0, convert_frame_fast(src.data(), format, src.size(),
	param.width, param.height,
	param.width / kScaleAmount,
	param.height / kScaleAmount,
	&resultFrame, kDefaultExpComp));

	memset(stagingFramebuffer, 0, stagingFramebufferSize);

	framebuffer.framebuffer = dest.data();
	EXPECT_EQ(0, convert_frame_fast(
	intermediate.data(), format, intermediate.size(),
	param.width / kScaleAmount,
	param.height / kScaleAmount, param.width,
	param.height, &resultFrame, kDefaultExpComp));

	compareSumOfSquaredDifferences(src, dest,
	param.getThresholdForResize());

	if (HasFatalFailure()) {
	return;
	}
	}

	free(stagingFramebuffer);
	}

	// Validate conversions from all source formats to all dest formats.
	TEST_P(ConvertWithSize, SourceToDest) {
	const FramebufferSizeParam param = GetParam();
	uint8_t* stagingFramebuffer = nullptr;
	size_t stagingFramebufferSize = 0;

	for (uint32_t src_format : kSupportedSourceFormats) {
	std::vector<uint8_t> src =
	generateFramebuffer(src_format, param.width, param.height,
	kAlpha, kRed, kGreen, kBlue);

	for (uint32_t dest_format : kSupportedDestinationFormats) {
	SCOPED_TRACE(testing::Message()
	<< "source=" << fourccToString(src_format)
	<< " dest=" << fourccToString(dest_format));

	const size_t destSize =
	bufferSize(dest_format, param.width, param.height);
	std::vector<uint8_t> dest(destSize);

	ClientFrameBuffer framebuffer = {};
	framebuffer.pixel_format = dest_format;
	framebuffer.framebuffer = dest.data();

	ClientFrame resultFrame = {};
	resultFrame.framebuffers = &framebuffer;
	resultFrame.framebuffers_count = 1;
	resultFrame.staging_framebuffer = &stagingFramebuffer;
	resultFrame.staging_framebuffer_size = &stagingFramebufferSize;

	EXPECT_EQ(0, convert_frame(src.data(), src_format, src.size(),
	param.width, param.height, &resultFrame,
	kDefaultColorScale, kDefaultColorScale,
	kDefaultColorScale, kDefaultExpComp));

	std::vector<uint8_t> destBaseline(destSize);
	ClientFrameBuffer baselineFramebuffer = {};
	baselineFramebuffer.pixel_format = dest_format;
	baselineFramebuffer.framebuffer = destBaseline.data();

	EXPECT_EQ(0,
	convert_frame_slow(src.data(), src_format, src.size(),
	param.width, param.height,
	&baselineFramebuffer, 1,
	kDefaultColorScale, kDefaultColorScale,
	kDefaultColorScale, kDefaultExpComp));

	compareSumOfSquaredDifferences(destBaseline, dest,
	param.getThreshold());

	if (HasFatalFailure()) {
	return;
	}
	}
	}

	free(stagingFramebuffer);
	}

	INSTANTIATE_TEST_CASE_P(
	CameraFormatConverters,
	ConvertWithSize,
	testing::Values(
	// Even dimensions may have slight differences per
	// pixel.
	FramebufferSizeParam(4, 4),
	FramebufferSizeParam(8, 8),
	FramebufferSizeParam(16, 16),
	FramebufferSizeParam(18, 18),
	FramebufferSizeParam(20, 20),
	FramebufferSizeParam(32, 32),
	// The fast and slow path handle boundary pixels for
	// odd dimensions differently, allow them to be
	// different with a larger threshold.
	FramebufferSizeParam(5, 5, FramebufferCompare::IgnoreEdges),
	FramebufferSizeParam(7, 7, FramebufferCompare::IgnoreEdges),
	FramebufferSizeParam(15, 15, FramebufferCompare::IgnoreEdges),
	FramebufferSizeParam(17, 17, FramebufferCompare::IgnoreEdges)));

	class FrameModifiers : public testing::TestWithParam<float> {};

	TEST_P(FrameModifiers, ExpComp) {
	constexpr int kWidth = 4;
	constexpr int kHeight = 4;

	const float expComp = GetParam();

	uint8_t* stagingFramebuffer = nullptr;
	size_t stagingFramebufferSize = 0;

	for (uint32_t src_format : kSupportedSourceFormats) {
	std::vector<uint8_t> src = generateFramebuffer(
	src_format, kWidth, kHeight, kAlpha, kRed, kGreen, kBlue);

	for (uint32_t dest_format : kSupportedDestinationFormats) {
	SCOPED_TRACE(testing::Message()
	<< "source=" << fourccToString(src_format)
	<< " dest=" << fourccToString(dest_format));

	const size_t destSize = bufferSize(dest_format, kWidth, kHeight);
	std::vector<uint8_t> dest(destSize);

	ClientFrameBuffer framebuffer = {};
	framebuffer.pixel_format = dest_format;
	framebuffer.framebuffer = dest.data();

	ClientFrame resultFrame = {};
	resultFrame.framebuffers = &framebuffer;
	resultFrame.framebuffers_count = 1;
	resultFrame.staging_framebuffer = &stagingFramebuffer;
	resultFrame.staging_framebuffer_size = &stagingFramebufferSize;

	EXPECT_EQ(0, convert_frame(src.data(), src_format, src.size(),
	kWidth, kHeight, &resultFrame,
	kDefaultColorScale, kDefaultColorScale,
	kDefaultColorScale, expComp));

	std::vector<uint8_t> destBaseline(destSize);
	ClientFrameBuffer baselineFramebuffer = {};
	baselineFramebuffer.pixel_format = dest_format;
	baselineFramebuffer.framebuffer = destBaseline.data();

	EXPECT_EQ(0, convert_frame_slow(
	src.data(), src_format, src.size(), kWidth,
	kHeight, &baselineFramebuffer, 1,
	kDefaultColorScale, kDefaultColorScale,
	kDefaultColorScale, expComp));

	compareSumOfSquaredDifferences(destBaseline, dest,
	kLenientDifferenceSq);

	if (HasFatalFailure()) {
	return;
	}
	}
	}

	free(stagingFramebuffer);
	}

	INSTANTIATE_TEST_CASE_P(CameraFormatConverters,
	FrameModifiers,
	testing::Values(1.0f, 0.0f, 0.5f, -1.0f, 2.0f));