android: Introduce CameraCapabilties class

The camera_device.cpp has grown a little too much, and it has quickly
become hard to maintain. Break out the handling of the static
information collected at camera initialization time to a new
CameraCapabilities class.

Break out from the camera_device.cpp file all the functions related to:
- Initialization of supported stream configurations
- Initialization of static metadata
- Initialization of request templates

Signed-off-by: Jacopo Mondi <jacopo@jmondi.org>
Acked-by: Paul Elder <paul.elder@ideasonboard.com>
Tested-by: Paul Elder <paul.elder@ideasonboard.com>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Hirokazu Honda <hiroh@chromium.org>

1 files changed, 12 insertions, 1135 deletions

diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
index 8c71fd06..4bd125d7 100644
--- a/src/android/camera_device.cpp
+++ b/src/android/camera_device.cpp
@@ -10,11 +10,8 @@
 #include "camera_ops.h"
 #include "post_processor.h"
 
-#include <array>
-#include <cmath>
 #include <fstream>
 #include <sys/mman.h>
-#include <tuple>
 #include <unistd.h>
 #include <vector>
 
@@ -23,7 +20,6 @@
 #include <libcamera/formats.h>
 #include <libcamera/property_ids.h>
 
-#include "libcamera/internal/formats.h"
 #include "libcamera/internal/log.h"
 #include "libcamera/internal/thread.h"
 #include "libcamera/internal/utils.h"
@@ -37,94 +33,6 @@ LOG_DECLARE_CATEGORY(HAL)
 namespace {
 
 /*
- * \var camera3Resolutions
- * \brief The list of image resolutions defined as mandatory to be supported by
- * the Android Camera3 specification
- */
-const std::vector<Size> camera3Resolutions = {
-	{ 320, 240 },
-	{ 640, 480 },
-	{ 1280, 720 },
-	{ 1920, 1080 }
-};
-
-/*
- * \struct Camera3Format
- * \brief Data associated with an Android format identifier
- * \var libcameraFormats List of libcamera pixel formats compatible with the
- * Android format
- * \var name The human-readable representation of the Android format code
- */
-struct Camera3Format {
-	std::vector<PixelFormat> libcameraFormats;
-	bool mandatory;
-	const char *name;
-};
-
-/*
- * \var camera3FormatsMap
- * \brief Associate Android format code with ancillary data
- */
-const std::map<int, const Camera3Format> camera3FormatsMap = {
-	{
-		HAL_PIXEL_FORMAT_BLOB, {
-			{ formats::MJPEG },
-			true,
-			"BLOB"
-		}
-	}, {
-		HAL_PIXEL_FORMAT_YCbCr_420_888, {
-			{ formats::NV12, formats::NV21 },
-			true,
-			"YCbCr_420_888"
-		}
-	}, {
-		/*
-		 * \todo Translate IMPLEMENTATION_DEFINED inspecting the gralloc
-		 * usage flag. For now, copy the YCbCr_420 configuration.
-		 */
-		HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, {
-			{ formats::NV12, formats::NV21 },
-			true,
-			"IMPLEMENTATION_DEFINED"
-		}
-	}, {
-		HAL_PIXEL_FORMAT_RAW10, {
-			{
-				formats::SBGGR10_CSI2P,
-				formats::SGBRG10_CSI2P,
-				formats::SGRBG10_CSI2P,
-				formats::SRGGB10_CSI2P
-			},
-			false,
-			"RAW10"
-		}
-	}, {
-		HAL_PIXEL_FORMAT_RAW12, {
-			{
-				formats::SBGGR12_CSI2P,
-				formats::SGBRG12_CSI2P,
-				formats::SGRBG12_CSI2P,
-				formats::SRGGB12_CSI2P
-			},
-			false,
-			"RAW12"
-		}
-	}, {
-		HAL_PIXEL_FORMAT_RAW16, {
-			{
-				formats::SBGGR16,
-				formats::SGBRG16,
-				formats::SGRBG16,
-				formats::SRGGB16
-			},
-			false,
-			"RAW16"
-		}
-	},
-};
-
-/*
  * \struct Camera3StreamConfig
  * \brief Data to store StreamConfiguration associated with camera3_stream(s)
  * \var streams List of the pairs of a stream requested by Android HAL client
@@ -512,242 +420,7 @@ int CameraDevice::initialize(const CameraConfigData *cameraConfigData)
 		orientation_ = 0;
 	}
 
-	/* Acquire the camera and initialize available stream configurations. */
-	int ret = camera_->acquire();
-	if (ret) {
-		LOG(HAL, Error) << "Failed to temporarily acquire the camera";
-		return ret;
-	}
-
-	ret = initializeStreamConfigurations();
-	camera_->release();
-	return ret;
-}
-
-std::vector<Size> CameraDevice::getYUVResolutions(CameraConfiguration *cameraConfig,
-						  const PixelFormat &pixelFormat,
-						  const std::vector<Size> &resolutions)
-{
-	std::vector<Size> supportedResolutions;
-
-	StreamConfiguration &cfg = cameraConfig->at(0);
-	for (const Size &res : resolutions) {
-		cfg.pixelFormat = pixelFormat;
-		cfg.size = res;
-
-		CameraConfiguration::Status status = cameraConfig->validate();
-		if (status != CameraConfiguration::Valid) {
-			LOG(HAL, Debug) << cfg.toString() << " not supported";
-			continue;
-		}
-
-		LOG(HAL, Debug) << cfg.toString() << " supported";
-
-		supportedResolutions.push_back(res);
-	}
-
-	return supportedResolutions;
-}
-
-std::vector<Size> CameraDevice::getRawResolutions(const libcamera::PixelFormat &pixelFormat)
-{
-	std::unique_ptr<CameraConfiguration> cameraConfig =
-		camera_->generateConfiguration({ StreamRole::Raw });
-	StreamConfiguration &cfg = cameraConfig->at(0);
-	const StreamFormats &formats = cfg.formats();
-	std::vector<Size> supportedResolutions = formats.sizes(pixelFormat);
-
-	return supportedResolutions;
-}
-
-/*
- * Initialize the format conversion map to translate from Android format
- * identifier to libcamera pixel formats and fill in the list of supported
- * stream configurations to be reported to the Android camera framework through
- * the static stream configuration metadata.
- */
-int CameraDevice::initializeStreamConfigurations()
-{
-	/*
-	 * Get the maximum output resolutions
-	 * \todo Get this from the camera properties once defined
-	 */
-	std::unique_ptr<CameraConfiguration> cameraConfig =
-		camera_->generateConfiguration({ StillCapture });
-	if (!cameraConfig) {
-		LOG(HAL, Error) << "Failed to get maximum resolution";
-		return -EINVAL;
-	}
-	StreamConfiguration &cfg = cameraConfig->at(0);
-
-	/*
-	 * \todo JPEG - Adjust the maximum available resolution by taking the
-	 * JPEG encoder requirements into account (alignment and aspect ratio).
-	 */
-	const Size maxRes = cfg.size;
-	LOG(HAL, Debug) << "Maximum supported resolution: " << maxRes.toString();
-
-	/*
-	 * Build the list of supported image resolutions.
-	 *
-	 * The resolutions listed in camera3Resolution are mandatory to be
-	 * supported, up to the camera maximum resolution.
-	 *
-	 * Augment the list by adding resolutions calculated from the camera
-	 * maximum one.
-	 */
-	std::vector<Size> cameraResolutions;
-	std::copy_if(camera3Resolutions.begin(), camera3Resolutions.end(),
-		     std::back_inserter(cameraResolutions),
-		     [&](const Size &res) { return res < maxRes; });
-
-	/*
-	 * The Camera3 specification suggests adding 1/2 and 1/4 of the maximum
-	 * resolution.
-	 */
-	for (unsigned int divider = 2;; divider <<= 1) {
-		Size derivedSize{
-			maxRes.width / divider,
-			maxRes.height / divider,
-		};
-
-		if (derivedSize.width < 320 ||
-		    derivedSize.height < 240)
-			break;
-
-		cameraResolutions.push_back(derivedSize);
-	}
-	cameraResolutions.push_back(maxRes);
-
-	/* Remove duplicated entries from the list of supported resolutions. */
-	std::sort(cameraResolutions.begin(), cameraResolutions.end());
-	auto last = std::unique(cameraResolutions.begin(), cameraResolutions.end());
-	cameraResolutions.erase(last, cameraResolutions.end());
-
-	/*
-	 * Build the list of supported camera formats.
-	 *
-	 * To each Android format a list of compatible libcamera formats is
-	 * associated. The first libcamera format that tests successful is added
-	 * to the format translation map used when configuring the streams.
-	 * It is then tested against the list of supported camera resolutions to
-	 * build the stream configuration map reported through the camera static
-	 * metadata.
-	 */
-	Size maxJpegSize;
-	for (const auto &format : camera3FormatsMap) {
-		int androidFormat = format.first;
-		const Camera3Format &camera3Format = format.second;
-		const std::vector<PixelFormat> &libcameraFormats =
-			camera3Format.libcameraFormats;
-
-		LOG(HAL, Debug) << "Trying to map Android format "
-				<< camera3Format.name;
-
-		/*
-		 * JPEG is always supported, either produced directly by the
-		 * camera, or encoded in the HAL.
-		 */
-		if (androidFormat == HAL_PIXEL_FORMAT_BLOB) {
-			formatsMap_[androidFormat] = formats::MJPEG;
-			LOG(HAL, Debug) << "Mapped Android format "
-					<< camera3Format.name << " to "
-					<< formats::MJPEG.toString()
-					<< " (fixed mapping)";
-			continue;
-		}
-
-		/*
-		 * Test the libcamera formats that can produce images
-		 * compatible with the format defined by Android.
-		 */
-		PixelFormat mappedFormat;
-		for (const PixelFormat &pixelFormat : libcameraFormats) {
-
-			LOG(HAL, Debug) << "Testing " << pixelFormat.toString();
-
-			/*
-			 * The stream configuration size can be adjusted,
-			 * not the pixel format.
-			 *
-			 * \todo This could be simplified once all pipeline
-			 * handlers will report the StreamFormats list of
-			 * supported formats.
-			 */
-			cfg.pixelFormat = pixelFormat;
-
-			CameraConfiguration::Status status = cameraConfig->validate();
-			if (status != CameraConfiguration::Invalid &&
-			    cfg.pixelFormat == pixelFormat) {
-				mappedFormat = pixelFormat;
-				break;
-			}
-		}
-
-		if (!mappedFormat.isValid()) {
-			/* If the format is not mandatory, skip it. */
-			if (!camera3Format.mandatory)
-				continue;
-
-			LOG(HAL, Error)
-				<< "Failed to map mandatory Android format "
-				<< camera3Format.name << " ("
-				<< utils::hex(androidFormat) << "): aborting";
-			return -EINVAL;
-		}
-
-		/*
-		 * Record the mapping and then proceed to generate the
-		 * stream configurations map, by testing the image resolutions.
-		 */
-		formatsMap_[androidFormat] = mappedFormat;
-		LOG(HAL, Debug) << "Mapped Android format "
-				<< camera3Format.name << " to "
-				<< mappedFormat.toString();
-
-		std::vector<Size> resolutions;
-		const PixelFormatInfo &info = PixelFormatInfo::info(mappedFormat);
-		if (info.colourEncoding == PixelFormatInfo::ColourEncodingRAW)
-			resolutions = getRawResolutions(mappedFormat);
-		else
-			resolutions = getYUVResolutions(cameraConfig.get(),
-							mappedFormat,
-							cameraResolutions);
-
-		for (const Size &res : resolutions) {
-			streamConfigurations_.push_back({ res, androidFormat });
-
-			/*
-			 * If the format is HAL_PIXEL_FORMAT_YCbCr_420_888
-			 * from which JPEG is produced, add an entry for
-			 * the JPEG stream.
-			 *
-			 * \todo Wire the JPEG encoder to query the supported
-			 * sizes provided a list of formats it can encode.
-			 *
-			 * \todo Support JPEG streams produced by the Camera
-			 * natively.
-			 */
-			if (androidFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
-				streamConfigurations_.push_back(
-					{ res, HAL_PIXEL_FORMAT_BLOB });
-				maxJpegSize = std::max(maxJpegSize, res);
-			}
-		}
-
-		/*
-		 * \todo Calculate the maximum JPEG buffer size by asking the
-		 * encoder giving the maximum frame size required.
-		 */
-		maxJpegBufferSize_ = maxJpegSize.width * maxJpegSize.height * 1.5;
-	}
-
-	LOG(HAL, Debug) << "Collected stream configuration map: ";
-	for (const auto &entry : streamConfigurations_)
-		LOG(HAL, Debug) << "{ " << entry.resolution.toString() << " - "
-				<< utils::hex(entry.androidFormat) << " }";
-
-	return 0;
+	return capabilities_.initialize(camera_, orientation_, facing_);
 }
 
 /*
@@ -817,802 +490,19 @@ void CameraDevice::stop()
 	state_ = State::Stopped;
 }
 
-void CameraDevice::setCallbacks(const camera3_callback_ops_t *callbacks)
+unsigned int CameraDevice::maxJpegBufferSize() const
 {
-	callbacks_ = callbacks;
+	return capabilities_.maxJpegBufferSize();
 }
 
-/*
- * Return static information for the camera.
- */
-const camera_metadata_t *CameraDevice::getStaticMetadata()
-{
-	if (staticMetadata_)
-		return staticMetadata_->get();
-
-	staticMetadata_ = std::make_unique<CameraMetadata>(64, 1024);
-	if (!staticMetadata_->isValid()) {
-		LOG(HAL, Error) << "Failed to allocate static metadata";
-		staticMetadata_.reset();
-		return nullptr;
-	}
-
-	const ControlInfoMap &controlsInfo = camera_->controls();
-	const ControlList &properties = camera_->properties();
-
-	/* Color correction static metadata. */
-	{
-		std::vector<uint8_t> data;
-		data.reserve(3);
-		const auto &infoMap = controlsInfo.find(&controls::draft::ColorCorrectionAberrationMode);
-		if (infoMap != controlsInfo.end()) {
-			for (const auto &value : infoMap->second.values())
-				data.push_back(value.get<int32_t>());
-		} else {
-			data.push_back(ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF);
-		}
-		staticMetadata_->addEntry(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
-					  data);
-	}
-
-	/* Control static metadata. */
-	std::vector<uint8_t> aeAvailableAntiBandingModes = {
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ,
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ,
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
-				  aeAvailableAntiBandingModes);
-
-	std::vector<uint8_t> aeAvailableModes = {
-		ANDROID_CONTROL_AE_MODE_ON,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_MODES,
-				  aeAvailableModes);
-
-	int64_t minFrameDurationNsec = -1;
-	int64_t maxFrameDurationNsec = -1;
-	const auto frameDurationsInfo = controlsInfo.find(&controls::FrameDurationLimits);
-	if (frameDurationsInfo != controlsInfo.end()) {
-		minFrameDurationNsec = frameDurationsInfo->second.min().get<int64_t>() * 1000;
-		maxFrameDurationNsec = frameDurationsInfo->second.max().get<int64_t>() * 1000;
-
-		/*
-		 * Adjust the minimum frame duration to comply with Android
-		 * requirements. The camera service mandates all preview/record
-		 * streams to have a minimum frame duration < 33,366 milliseconds
-		 * (see MAX_PREVIEW_RECORD_DURATION_NS in the camera service
-		 * implementation).
-		 *
-		 * If we're close enough (+ 500 useconds) to that value, round
-		 * the minimum frame duration of the camera to an accepted
-		 * value.
-		 */
-		static constexpr int64_t MAX_PREVIEW_RECORD_DURATION_NS = 1e9 / 29.97;
-		if (minFrameDurationNsec > MAX_PREVIEW_RECORD_DURATION_NS &&
-		    minFrameDurationNsec < MAX_PREVIEW_RECORD_DURATION_NS + 500000)
-			minFrameDurationNsec = MAX_PREVIEW_RECORD_DURATION_NS - 1000;
-
-		/*
-		 * The AE routine frame rate limits are computed using the frame
-		 * duration limits, as libcamera clips the AE routine to the
-		 * frame durations.
-		 */
-		int32_t maxFps = std::round(1e9 / minFrameDurationNsec);
-		int32_t minFps = std::round(1e9 / maxFrameDurationNsec);
-		minFps = std::max(1, minFps);
-
-		/*
-		 * Force rounding errors so that we have the proper frame
-		 * durations for when we reuse these variables later
-		 */
-		minFrameDurationNsec = 1e9 / maxFps;
-		maxFrameDurationNsec = 1e9 / minFps;
-
-		/*
-		 * Register to the camera service {min, max} and {max, max}
-		 * intervals as requested by the metadata documentation.
-		 */
-		int32_t availableAeFpsTarget[] = {
-			minFps, maxFps, maxFps, maxFps
-		};
-		staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
-					  availableAeFpsTarget);
-	}
-
-	std::vector<int32_t> aeCompensationRange = {
-		0, 0,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
-				  aeCompensationRange);
-
-	const camera_metadata_rational_t aeCompensationStep[] = {
-		{ 0, 1 }
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AE_COMPENSATION_STEP,
-				  aeCompensationStep);
-
-	std::vector<uint8_t> availableAfModes = {
-		ANDROID_CONTROL_AF_MODE_OFF,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AF_AVAILABLE_MODES,
-				  availableAfModes);
-
-	std::vector<uint8_t> availableEffects = {
-		ANDROID_CONTROL_EFFECT_MODE_OFF,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_EFFECTS,
-				  availableEffects);
-
-	std::vector<uint8_t> availableSceneModes = {
-		ANDROID_CONTROL_SCENE_MODE_DISABLED,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
-				  availableSceneModes);
-
-	std::vector<uint8_t> availableStabilizationModes = {
-		ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
-				  availableStabilizationModes);
-
-	/*
-	 * \todo Inspect the Camera capabilities to report the available
-	 * AWB modes. Default to AUTO as CTS tests require it.
-	 */
-	std::vector<uint8_t> availableAwbModes = {
-		ANDROID_CONTROL_AWB_MODE_AUTO,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
-				  availableAwbModes);
-
-	std::vector<int32_t> availableMaxRegions = {
-		0, 0, 0,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_MAX_REGIONS,
-				  availableMaxRegions);
-
-	std::vector<uint8_t> sceneModesOverride = {
-		ANDROID_CONTROL_AE_MODE_ON,
-		ANDROID_CONTROL_AWB_MODE_AUTO,
-		ANDROID_CONTROL_AF_MODE_OFF,
-	};
-	staticMetadata_->addEntry(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
-				  sceneModesOverride);
-
-	uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;
-	staticMetadata_->addEntry(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
-				  aeLockAvailable);
-
-	uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
-	staticMetadata_->addEntry(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
-				  awbLockAvailable);
-
-	char availableControlModes = ANDROID_CONTROL_MODE_AUTO;
-	staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_MODES,
-				  availableControlModes);
-
-	/* JPEG static metadata. */
-
-	/*
-	 * Create the list of supported thumbnail sizes by inspecting the
-	 * available JPEG resolutions collected in streamConfigurations_ and
-	 * generate one entry for each aspect ratio.
-	 *
-	 * The JPEG thumbnailer can freely scale, so pick an arbitrary
-	 * (160, 160) size as the bounding rectangle, which is then cropped to
-	 * the different supported aspect ratios.
-	 */
-	constexpr Size maxJpegThumbnail(160, 160);
-	std::vector<Size> thumbnailSizes;
-	thumbnailSizes.push_back({ 0, 0 });
-	for (const auto &entry : streamConfigurations_) {
-		if (entry.androidFormat != HAL_PIXEL_FORMAT_BLOB)
-			continue;
-
-		Size thumbnailSize = maxJpegThumbnail
-				     .boundedToAspectRatio({ entry.resolution.width,
-							     entry.resolution.height });
-		thumbnailSizes.push_back(thumbnailSize);
-	}
-
-	std::sort(thumbnailSizes.begin(), thumbnailSizes.end());
-	auto last = std::unique(thumbnailSizes.begin(), thumbnailSizes.end());
-	thumbnailSizes.erase(last, thumbnailSizes.end());
-
-	/* Transform sizes in to a list of integers that can be consumed. */
-	std::vector<int32_t> thumbnailEntries;
-	thumbnailEntries.reserve(thumbnailSizes.size() * 2);
-	for (const auto &size : thumbnailSizes) {
-		thumbnailEntries.push_back(size.width);
-		thumbnailEntries.push_back(size.height);
-	}
-	staticMetadata_->addEntry(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
-				  thumbnailEntries);
-
-	staticMetadata_->addEntry(ANDROID_JPEG_MAX_SIZE, maxJpegBufferSize_);
-
-	/* Sensor static metadata. */
-	std::array<int32_t, 2> pixelArraySize;
-	{
-		const Size &size = properties.get(properties::PixelArraySize);
-		pixelArraySize[0] = size.width;
-		pixelArraySize[1] = size.height;
-		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
-					  pixelArraySize);
-	}
-
-	if (properties.contains(properties::UnitCellSize)) {
-		const Size &cellSize = properties.get<Size>(properties::UnitCellSize);
-		std::array<float, 2> physicalSize{
-			cellSize.width * pixelArraySize[0] / 1e6f,
-			cellSize.height * pixelArraySize[1] / 1e6f
-		};
-		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
-					  physicalSize);
-	}
-
-	{
-		const Span<const Rectangle> &rects =
-			properties.get(properties::PixelArrayActiveAreas);
-		std::vector<int32_t> data{
-			static_cast<int32_t>(rects[0].x),
-			static_cast<int32_t>(rects[0].y),
-			static_cast<int32_t>(rects[0].width),
-			static_cast<int32_t>(rects[0].height),
-		};
-		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
-					  data);
-	}
-
-	int32_t sensitivityRange[] = {
-		32, 2400,
-	};
-	staticMetadata_->addEntry(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
-				  sensitivityRange);
-
-	/* Report the color filter arrangement if the camera reports it. */
-	if (properties.contains(properties::draft::ColorFilterArrangement)) {
-		uint8_t filterArr = properties.get(properties::draft::ColorFilterArrangement);
-		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
-					  filterArr);
-	}
-
-	const auto &exposureInfo = controlsInfo.find(&controls::ExposureTime);
-	if (exposureInfo != controlsInfo.end()) {
-		int64_t exposureTimeRange[2] = {
-			exposureInfo->second.min().get<int32_t>() * 1000LL,
-			exposureInfo->second.max().get<int32_t>() * 1000LL,
-		};
-		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
-					  exposureTimeRange, 2);
-	}
-
-	staticMetadata_->addEntry(ANDROID_SENSOR_ORIENTATION, orientation_);
-
-	std::vector<int32_t> testPatternModes = {
-		ANDROID_SENSOR_TEST_PATTERN_MODE_OFF
-	};
-	const auto &testPatternsInfo =
-		controlsInfo.find(&controls::draft::TestPatternMode);
-	if (testPatternsInfo != controlsInfo.end()) {
-		const auto &values = testPatternsInfo->second.values();
-		ASSERT(!values.empty());
-		for (const auto &value : values) {
-			switch (value.get<int32_t>()) {
-			case controls::draft::TestPatternModeOff:
-				/*
-				 * ANDROID_SENSOR_TEST_PATTERN_MODE_OFF is
-				 * already in testPatternModes.
-				 */
-				break;
-
-			case controls::draft::TestPatternModeSolidColor:
-				testPatternModes.push_back(
-					ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR);
-				break;
-
-			case controls::draft::TestPatternModeColorBars:
-				testPatternModes.push_back(
-					ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS);
-				break;
-
-			case controls::draft::TestPatternModeColorBarsFadeToGray:
-				testPatternModes.push_back(
-					ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY);
-				break;
-
-			case controls::draft::TestPatternModePn9:
-				testPatternModes.push_back(
-					ANDROID_SENSOR_TEST_PATTERN_MODE_PN9);
-				break;
-
-			case controls::draft::TestPatternModeCustom1:
-				/* We don't support this yet. */
-				break;
-
-			default:
-				LOG(HAL, Error) << "Unknown test pattern mode: "
-						<< value.get<int32_t>();
-				continue;
-			}
-		}
-	}
-	staticMetadata_->addEntry(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
-				  testPatternModes);
-
-	uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;
-	staticMetadata_->addEntry(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
-				  timestampSource);
-
-	if (maxFrameDurationNsec > 0)
-		staticMetadata_->addEntry(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
-					  maxFrameDurationNsec);
-
-	/* Statistics static metadata. */
-	uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
-	staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
-				  faceDetectMode);
-
-	int32_t maxFaceCount = 0;
-	staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
-				  maxFaceCount);
-
-	{
-		std::vector<uint8_t> data;
-		data.reserve(2);
-		const auto &infoMap = controlsInfo.find(&controls::draft::LensShadingMapMode);
-		if (infoMap != controlsInfo.end()) {
-			for (const auto &value : infoMap->second.values())
-				data.push_back(value.get<int32_t>());
-		} else {
-			data.push_back(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);
-		}
-		staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
-					  data);
-	}
-
-	/* Sync static metadata. */
-	int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
-	staticMetadata_->addEntry(ANDROID_SYNC_MAX_LATENCY, maxLatency);
-
-	/* Flash static metadata. */
-	char flashAvailable = ANDROID_FLASH_INFO_AVAILABLE_FALSE;
-	staticMetadata_->addEntry(ANDROID_FLASH_INFO_AVAILABLE,
-				  flashAvailable);
-
-	/* Lens static metadata. */
-	std::vector<float> lensApertures = {
-		2.53 / 100,
-	};
-	staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
-				  lensApertures);
-
-	uint8_t lensFacing;
-	switch (facing_) {
-	default:
-	case CAMERA_FACING_FRONT:
-		lensFacing = ANDROID_LENS_FACING_FRONT;
-		break;
-	case CAMERA_FACING_BACK:
-		lensFacing = ANDROID_LENS_FACING_BACK;
-		break;
-	case CAMERA_FACING_EXTERNAL:
-		lensFacing = ANDROID_LENS_FACING_EXTERNAL;
-		break;
-	}
-	staticMetadata_->addEntry(ANDROID_LENS_FACING, lensFacing);
-
-	std::vector<float> lensFocalLengths = {
-		1,
-	};
-	staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
-				  lensFocalLengths);
-
-	std::vector<uint8_t> opticalStabilizations = {
-		ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF,
-	};
-	staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
-				  opticalStabilizations);
-
-	float hypeFocalDistance = 0;
-	staticMetadata_->addEntry(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
-				  hypeFocalDistance);
-
-	float minFocusDistance = 0;
-	staticMetadata_->addEntry(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
-				  minFocusDistance);
-
-	/* Noise reduction modes. */
-	{
-		std::vector<uint8_t> data;
-		data.reserve(5);
-		const auto &infoMap = controlsInfo.find(&controls::draft::NoiseReductionMode);
-		if (infoMap != controlsInfo.end()) {
-			for (const auto &value : infoMap->second.values())
-				data.push_back(value.get<int32_t>());
-		} else {
-			data.push_back(ANDROID_NOISE_REDUCTION_MODE_OFF);
-		}
-		staticMetadata_->addEntry(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
-					  data);
-	}
-
-	/* Scaler static metadata. */
-
-	/*
-	 * \todo The digital zoom factor is a property that depends on the
-	 * desired output configuration and the sensor frame size input to the
-	 * ISP. This information is not available to the Android HAL, not at
-	 * initialization time at least.
-	 *
-	 * As a workaround rely on pipeline handlers initializing the
-	 * ScalerCrop control with the camera default configuration and use the
-	 * maximum and minimum crop rectangles to calculate the digital zoom
-	 * factor.
-	 */
-	float maxZoom = 1.0f;
-	const auto scalerCrop = controlsInfo.find(&controls::ScalerCrop);
-	if (scalerCrop != controlsInfo.end()) {
-		Rectangle min = scalerCrop->second.min().get<Rectangle>();
-		Rectangle max = scalerCrop->second.max().get<Rectangle>();
-		maxZoom = std::min(1.0f * max.width / min.width,
-				   1.0f * max.height / min.height);
-	}
-	staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
-				  maxZoom);
-
-	std::vector<uint32_t> availableStreamConfigurations;
-	availableStreamConfigurations.reserve(streamConfigurations_.size() * 4);
-	for (const auto &entry : streamConfigurations_) {
-		availableStreamConfigurations.push_back(entry.androidFormat);
-		availableStreamConfigurations.push_back(entry.resolution.width);
-		availableStreamConfigurations.push_back(entry.resolution.height);
-		availableStreamConfigurations.push_back(
-			ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT);
-	}
-	staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
-				  availableStreamConfigurations);
-
-	std::vector<int64_t> availableStallDurations = {
-		ANDROID_SCALER_AVAILABLE_FORMATS_BLOB, 2560, 1920, 33333333,
-	};
-	staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
-				  availableStallDurations);
-
-	/* Use the minimum frame duration for all the YUV/RGB formats. */
-	if (minFrameDurationNsec > 0) {
-		std::vector<int64_t> minFrameDurations;
-		minFrameDurations.reserve(streamConfigurations_.size() * 4);
-		for (const auto &entry : streamConfigurations_) {
-			minFrameDurations.push_back(entry.androidFormat);
-			minFrameDurations.push_back(entry.resolution.width);
-			minFrameDurations.push_back(entry.resolution.height);
-			minFrameDurations.push_back(minFrameDurationNsec);
-		}
-		staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
-					  minFrameDurations);
-	}
-
-	uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY;
-	staticMetadata_->addEntry(ANDROID_SCALER_CROPPING_TYPE, croppingType);
-
-	/* Info static metadata. */
-	uint8_t supportedHWLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
-	staticMetadata_->addEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
-				  supportedHWLevel);
-
-	/* Request static metadata. */
-	int32_t partialResultCount = 1;
-	staticMetadata_->addEntry(ANDROID_REQUEST_PARTIAL_RESULT_COUNT,
-				  partialResultCount);
-
-	{
-		/* Default the value to 2 if not reported by the camera. */
-		uint8_t maxPipelineDepth = 2;
-		const auto &infoMap = controlsInfo.find(&controls::draft::PipelineDepth);
-		if (infoMap != controlsInfo.end())
-			maxPipelineDepth = infoMap->second.max().get<int32_t>();
-		staticMetadata_->addEntry(ANDROID_REQUEST_PIPELINE_MAX_DEPTH,
-					  maxPipelineDepth);
-	}
-
-	/* LIMITED does not support reprocessing. */
-	uint32_t maxNumInputStreams = 0;
-	staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS,
-				  maxNumInputStreams);
-
-	std::vector<uint8_t> availableCapabilities = {
-		ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
-	};
-
-	/* Report if camera supports RAW. */
-	bool rawStreamAvailable = false;
-	std::unique_ptr<CameraConfiguration> cameraConfig =
-		camera_->generateConfiguration({ StreamRole::Raw });
-	if (cameraConfig && !cameraConfig->empty()) {
-		const PixelFormatInfo &info =
-			PixelFormatInfo::info(cameraConfig->at(0).pixelFormat);
-		/* Only advertise RAW support if RAW16 is possible. */
-		if (info.colourEncoding == PixelFormatInfo::ColourEncodingRAW &&
-		    info.bitsPerPixel == 16) {
-			rawStreamAvailable = true;
-			availableCapabilities.push_back(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW);
-		}
-	}
-
-	/* Number of { RAW, YUV, JPEG } supported output streams */
-	int32_t numOutStreams[] = { rawStreamAvailable, 2, 1 };
-	staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
-				  numOutStreams);
-
-	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
-				  availableCapabilities);
-
-	std::vector<int32_t> availableCharacteristicsKeys = {
-		ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
-		ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
-		ANDROID_CONTROL_AE_AVAILABLE_MODES,
-		ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
-		ANDROID_CONTROL_AE_COMPENSATION_RANGE,
-		ANDROID_CONTROL_AE_COMPENSATION_STEP,
-		ANDROID_CONTROL_AE_LOCK_AVAILABLE,
-		ANDROID_CONTROL_AF_AVAILABLE_MODES,
-		ANDROID_CONTROL_AVAILABLE_EFFECTS,
-		ANDROID_CONTROL_AVAILABLE_MODES,
-		ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
-		ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
-		ANDROID_CONTROL_AWB_AVAILABLE_MODES,
-		ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
-		ANDROID_CONTROL_MAX_REGIONS,
-		ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
-		ANDROID_FLASH_INFO_AVAILABLE,
-		ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
-		ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
-		ANDROID_JPEG_MAX_SIZE,
-		ANDROID_LENS_FACING,
-		ANDROID_LENS_INFO_AVAILABLE_APERTURES,
-		ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
-		ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
-		ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
-		ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
-		ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
-		ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
-		ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS,
-		ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
-		ANDROID_REQUEST_PARTIAL_RESULT_COUNT,
-		ANDROID_REQUEST_PIPELINE_MAX_DEPTH,
-		ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
-		ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
-		ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
-		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
-		ANDROID_SCALER_CROPPING_TYPE,
-		ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
-		ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
-		ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
-		ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
-		ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
-		ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
-		ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
-		ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
-		ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
-		ANDROID_SENSOR_ORIENTATION,
-		ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
-		ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
-		ANDROID_SYNC_MAX_LATENCY,
-	};
-	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
-				  availableCharacteristicsKeys);
-
-	std::vector<int32_t> availableRequestKeys = {
-		ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE,
-		ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
-		ANDROID_CONTROL_AE_LOCK,
-		ANDROID_CONTROL_AE_MODE,
-		ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
-		ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
-		ANDROID_CONTROL_AF_MODE,
-		ANDROID_CONTROL_AF_TRIGGER,
-		ANDROID_CONTROL_AWB_LOCK,
-		ANDROID_CONTROL_AWB_MODE,
-		ANDROID_CONTROL_CAPTURE_INTENT,
-		ANDROID_CONTROL_EFFECT_MODE,
-		ANDROID_CONTROL_MODE,
-		ANDROID_CONTROL_SCENE_MODE,
-		ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
-		ANDROID_FLASH_MODE,
-		ANDROID_JPEG_ORIENTATION,
-		ANDROID_JPEG_QUALITY,
-		ANDROID_JPEG_THUMBNAIL_QUALITY,
-		ANDROID_JPEG_THUMBNAIL_SIZE,
-		ANDROID_LENS_APERTURE,
-		ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
-		ANDROID_NOISE_REDUCTION_MODE,
-		ANDROID_SCALER_CROP_REGION,
-		ANDROID_STATISTICS_FACE_DETECT_MODE
-	};
-	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
-				  availableRequestKeys);
-
-	std::vector<int32_t> availableResultKeys = {
-		ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
-		ANDROID_CONTROL_AE_ANTIBANDING_MODE,
-		ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
-		ANDROID_CONTROL_AE_LOCK,
-		ANDROID_CONTROL_AE_MODE,
-		ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
-		ANDROID_CONTROL_AE_STATE,
-		ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
-		ANDROID_CONTROL_AF_MODE,
-		ANDROID_CONTROL_AF_STATE,
-		ANDROID_CONTROL_AF_TRIGGER,
-		ANDROID_CONTROL_AWB_LOCK,
-		ANDROID_CONTROL_AWB_MODE,
-		ANDROID_CONTROL_AWB_STATE,
-		ANDROID_CONTROL_CAPTURE_INTENT,
-		ANDROID_CONTROL_EFFECT_MODE,
-		ANDROID_CONTROL_MODE,
-		ANDROID_CONTROL_SCENE_MODE,
-		ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
-		ANDROID_FLASH_MODE,
-		ANDROID_FLASH_STATE,
-		ANDROID_JPEG_GPS_COORDINATES,
-		ANDROID_JPEG_GPS_PROCESSING_METHOD,
-		ANDROID_JPEG_GPS_TIMESTAMP,
-		ANDROID_JPEG_ORIENTATION,
-		ANDROID_JPEG_QUALITY,
-		ANDROID_JPEG_SIZE,
-		ANDROID_JPEG_THUMBNAIL_QUALITY,
-		ANDROID_JPEG_THUMBNAIL_SIZE,
-		ANDROID_LENS_APERTURE,
-		ANDROID_LENS_FOCAL_LENGTH,
-		ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
-		ANDROID_LENS_STATE,
-		ANDROID_NOISE_REDUCTION_MODE,
-		ANDROID_REQUEST_PIPELINE_DEPTH,
-		ANDROID_SCALER_CROP_REGION,
-		ANDROID_SENSOR_EXPOSURE_TIME,
-		ANDROID_SENSOR_FRAME_DURATION,
-		ANDROID_SENSOR_ROLLING_SHUTTER_SKEW,
-		ANDROID_SENSOR_TEST_PATTERN_MODE,
-		ANDROID_SENSOR_TIMESTAMP,
-		ANDROID_STATISTICS_FACE_DETECT_MODE,
-		ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
-		ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
-		ANDROID_STATISTICS_SCENE_FLICKER,
-	};
-	staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
-				  availableResultKeys);
-
-	if (!staticMetadata_->isValid()) {
-		LOG(HAL, Error) << "Failed to construct static metadata";
-		staticMetadata_.reset();
-		return nullptr;
-	}
-
-	if (staticMetadata_->resized()) {
-		auto [entryCount, dataCount] = staticMetadata_->usage();
-		LOG(HAL, Info)
-			<< "Static metadata resized: " << entryCount
-			<< " entries and " << dataCount << " bytes used";
-	}
-
-	return staticMetadata_->get();
-}
-
-std::unique_ptr<CameraMetadata> CameraDevice::requestTemplatePreview()
+void CameraDevice::setCallbacks(const camera3_callback_ops_t *callbacks)
 {
-	/*
-	 * \todo Keep this in sync with the actual number of entries.
-	 * Currently: 20 entries, 35 bytes
-	 */
-	auto requestTemplate = std::make_unique<CameraMetadata>(21, 36);
-	if (!requestTemplate->isValid()) {
-		return nullptr;
-	}
-
-	/* Get the FPS range registered in the static metadata. */
-	camera_metadata_ro_entry_t entry;
-	bool found = staticMetadata_->getEntry(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
-					       &entry);
-	if (!found) {
-		LOG(HAL, Error) << "Cannot create capture template without FPS range";
-		return nullptr;
-	}
-
-	/*
-	 * Assume the AE_AVAILABLE_TARGET_FPS_RANGE static metadata
-	 * has been assembled as {{min, max} {max, max}}.
-	 */
-	requestTemplate->addEntry(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
-				  entry.data.i32, 2);
-
-	uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
-	requestTemplate->addEntry(ANDROID_CONTROL_AE_MODE, aeMode);
-
-	int32_t aeExposureCompensation = 0;
-	requestTemplate->addEntry(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
-				  aeExposureCompensation);
-
-	uint8_t aePrecaptureTrigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
-	requestTemplate->addEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
-				  aePrecaptureTrigger);
-
-	uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF;
-	requestTemplate->addEntry(ANDROID_CONTROL_AE_LOCK, aeLock);
-
-	uint8_t aeAntibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
-	requestTemplate->addEntry(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
-				  aeAntibandingMode);
-
-	uint8_t afMode = ANDROID_CONTROL_AF_MODE_OFF;
-	requestTemplate->addEntry(ANDROID_CONTROL_AF_MODE, afMode);
-
-	uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE;
-	requestTemplate->addEntry(ANDROID_CONTROL_AF_TRIGGER, afTrigger);
-
-	uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO;
-	requestTemplate->addEntry(ANDROID_CONTROL_AWB_MODE, awbMode);
-
-	uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF;
-	requestTemplate->addEntry(ANDROID_CONTROL_AWB_LOCK, awbLock);
-
-	uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
-	requestTemplate->addEntry(ANDROID_FLASH_MODE, flashMode);
-
-	uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
-	requestTemplate->addEntry(ANDROID_STATISTICS_FACE_DETECT_MODE,
-				  faceDetectMode);
-
-	uint8_t noiseReduction = ANDROID_NOISE_REDUCTION_MODE_OFF;
-	requestTemplate->addEntry(ANDROID_NOISE_REDUCTION_MODE,
-				  noiseReduction);
-
-	uint8_t aberrationMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF;
-	requestTemplate->addEntry(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
-				  aberrationMode);
-
-	uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
-	requestTemplate->addEntry(ANDROID_CONTROL_MODE, controlMode);
-
-	float lensAperture = 2.53 / 100;
-	requestTemplate->addEntry(ANDROID_LENS_APERTURE, lensAperture);
-
-	uint8_t opticalStabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
-	requestTemplate->addEntry(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
-				  opticalStabilization);
-
-	uint8_t captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
-	requestTemplate->addEntry(ANDROID_CONTROL_CAPTURE_INTENT,
-				  captureIntent);
-
-	return requestTemplate;
+	callbacks_ = callbacks;
 }
 
-std::unique_ptr<CameraMetadata> CameraDevice::requestTemplateVideo()
+const camera_metadata_t *CameraDevice::getStaticMetadata()
 {
-	std::unique_ptr<CameraMetadata> previewTemplate = requestTemplatePreview();
-	if (!previewTemplate)
-		return nullptr;
-
-	/*
-	 * The video template requires a fixed FPS range. Everything else
-	 * stays the same as the preview template.
-	 */
-	camera_metadata_ro_entry_t entry;
-	staticMetadata_->getEntry(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
-				  &entry);
-
-	/*
-	 * Assume the AE_AVAILABLE_TARGET_FPS_RANGE static metadata
-	 * has been assembled as {{min, max} {max, max}}.
-	 */
-	previewTemplate->updateEntry(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
-				     entry.data.i32 + 2, 2);
-
-	return previewTemplate;
+	return capabilities_.staticMetadata()->get();
 }
 
 /*
@@ -1630,7 +520,7 @@ const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type)
 	switch (type) {
 	case CAMERA3_TEMPLATE_PREVIEW:
 		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
-		requestTemplate = requestTemplatePreview();
+		requestTemplate = capabilities_.requestTemplatePreview();
 		break;
 	case CAMERA3_TEMPLATE_STILL_CAPTURE:
 		/*
@@ -1638,15 +528,15 @@ const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type)
 		 * for the torch mode we currently do not support.
 		 */
 		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
-		requestTemplate = requestTemplatePreview();
+		requestTemplate = capabilities_.requestTemplatePreview();
 		break;
 	case CAMERA3_TEMPLATE_VIDEO_RECORD:
 		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
-		requestTemplate = requestTemplateVideo();
+		requestTemplate = capabilities_.requestTemplateVideo();
 		break;
 	case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
 		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
-		requestTemplate = requestTemplateVideo();
+		requestTemplate = capabilities_.requestTemplateVideo();
 		break;
 	/* \todo Implement templates generation for the remaining use cases. */
 	case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
@@ -1668,19 +558,6 @@ const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type)
 	return requestTemplates_[type]->get();
 }
 
-PixelFormat CameraDevice::toPixelFormat(int format) const
-{
-	/* Translate Android format code to libcamera pixel format. */
-	auto it = formatsMap_.find(format);
-	if (it == formatsMap_.end()) {
-		LOG(HAL, Error) << "Requested format " << utils::hex(format)
-				<< " not supported";
-		return PixelFormat();
-	}
-
-	return it->second;
-}
-
 /*
  * Inspect the stream_list to produce a list of StreamConfiguration to
  * be use to configure the Camera.
@@ -1727,7 +604,7 @@ int CameraDevice::configureStreams(camera3_stream_configuration_t *stream_list)
 		camera3_stream_t *stream = stream_list->streams[i];
 		Size size(stream->width, stream->height);
 
-		PixelFormat format = toPixelFormat(stream->format);
+		PixelFormat format = capabilities_.toPixelFormat(stream->format);
 
 		LOG(HAL, Info) << "Stream #" << i
 			       << ", direction: " << stream->stream_type