[libcamera-devel,2/2] android: Introduce CameraCapabilties class

12670 diff mbox series

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 relative 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>
---
 src/android/camera_capabilities.cpp | 1164 +++++++++++++++++++++++++++
 src/android/camera_capabilities.h   |   65 ++
 src/android/camera_device.cpp       | 1147 +-------------------------
 src/android/camera_device.h         |   27 +-
 src/android/meson.build             |    1 +
 5 files changed, 1245 insertions(+), 1159 deletions(-)
 create mode 100644 src/android/camera_capabilities.cpp
 create mode 100644 src/android/camera_capabilities.h

Hi Jacopo, thank you for the patch.

I failed to apply the patch on the top of the latest tree to review.
Could you tell me the parent commit which I can apply this patch?

-Hiro
On Tue, Jun 22, 2021 at 12:29 AM Jacopo Mondi <jacopo@jmondi.org> wrote:

> 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 relative 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>
> ---
>  src/android/camera_capabilities.cpp | 1164 +++++++++++++++++++++++++++
>  src/android/camera_capabilities.h   |   65 ++
>  src/android/camera_device.cpp       | 1147 +-------------------------
>  src/android/camera_device.h         |   27 +-
>  src/android/meson.build             |    1 +
>  5 files changed, 1245 insertions(+), 1159 deletions(-)
>  create mode 100644 src/android/camera_capabilities.cpp
>  create mode 100644 src/android/camera_capabilities.h
>
> diff --git a/src/android/camera_capabilities.cpp
> b/src/android/camera_capabilities.cpp
> new file mode 100644
> index 000000000000..311a2c839586
> --- /dev/null
> +++ b/src/android/camera_capabilities.cpp
> @@ -0,0 +1,1164 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2021, Google Inc.
> + *
> + * camera_capabilities.cpp - Camera static properties manager
> + */
> +
> +#include "camera_capabilities.h"
> +
> +#include <array>
> +#include <cmath>
> +
> +#include <hardware/camera3.h>
> +
> +#include <libcamera/control_ids.h>
> +#include <libcamera/controls.h>
> +#include <libcamera/property_ids.h>
> +
> +#include "libcamera/internal/formats.h"
> +#include "libcamera/internal/log.h"
> +
> +using namespace libcamera;
> +
> +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"
> +               }
> +       },
> +};
> +
> +} /* namespace */
> +
> +int CameraCapabilities::initialize(std::shared_ptr<libcamera::Camera>
> camera,
> +                                  int orientation, int facing)
> +{
> +       camera_ = camera;
> +       orientation_ = orientation;
> +       facing_ = facing;
> +
> +       /* 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();
> +       if (ret)
> +               return ret;
> +
> +       return initializeStaticMetadata();
> +}
> +
> +std::vector<Size>
> CameraCapabilities::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> CameraCapabilities::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 Camera static metadata.
> + */
> +int CameraCapabilities::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;
> +}
> +
> +int CameraCapabilities::initializeStaticMetadata()
> +{
> +       staticMetadata_ = std::make_unique<CameraMetadata>(64, 1024);
> +       if (!staticMetadata_->isValid()) {
> +               LOG(HAL, Error) << "Failed to allocate static metadata";
> +               staticMetadata_.reset();
> +               return -EINVAL;
> +       }
> +
> +       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 -EINVAL;
> +       }
> +
> +       if (staticMetadata_->resized()) {
> +               auto [entryCount, dataCount] = staticMetadata_->usage();
> +               LOG(HAL, Info)
> +                       << "Static metadata resized: " << entryCount
> +                       << " entries and " << dataCount << " bytes used";
> +       }
> +
> +       return 0;
> +}
> +
> +/* Translate Android format code to libcamera pixel format. */
> +PixelFormat CameraCapabilities::toPixelFormat(int format) const
> +{
> +       auto it = formatsMap_.find(format);
> +       if (it == formatsMap_.end()) {
> +               LOG(HAL, Error) << "Requested format " <<
> utils::hex(format)
> +                               << " not supported";
> +               return PixelFormat();
> +       }
> +
> +       return it->second;
> +}
> +
> +std::unique_ptr<CameraMetadata>
> CameraCapabilities::requestTemplatePreview() const
> +{
> +       /*
> +        * \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;
> +}
> +
> +std::unique_ptr<CameraMetadata>
> CameraCapabilities::requestTemplateVideo() const
> +{
> +       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;
> +}
> diff --git a/src/android/camera_capabilities.h
> b/src/android/camera_capabilities.h
> new file mode 100644
> index 000000000000..f511607bbd90
> --- /dev/null
> +++ b/src/android/camera_capabilities.h
> @@ -0,0 +1,65 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2021, Google Inc.
> + *
> + * camera_capabilities.h - Camera static properties manager
> + */
> +#ifndef __ANDROID_CAMERA_CAPABILITIES_H__
> +#define __ANDROID_CAMERA_CAPABILITIES_H__
> +
> +#include <map>
> +#include <memory>
> +#include <vector>
> +
> +#include <libcamera/camera.h>
> +#include <libcamera/class.h>
> +#include <libcamera/formats.h>
> +#include <libcamera/geometry.h>
> +
> +#include "camera_metadata.h"
> +
> +class CameraCapabilities
> +{
> +public:
> +       CameraCapabilities() = default;
> +
> +       int initialize(std::shared_ptr<libcamera::Camera> camera,
> +                      int orientation, int facing);
> +
> +       CameraMetadata *staticMetadata() const { return
> staticMetadata_.get(); }
> +       libcamera::PixelFormat toPixelFormat(int format) const;
> +       unsigned int maxJpegBufferSize() const { return
> maxJpegBufferSize_; }
> +
> +       std::unique_ptr<CameraMetadata> requestTemplatePreview() const;
> +       std::unique_ptr<CameraMetadata> requestTemplateVideo() const;
> +
> +private:
> +       LIBCAMERA_DISABLE_COPY_AND_MOVE(CameraCapabilities)
> +
> +       struct Camera3StreamConfiguration {
> +               libcamera::Size resolution;
> +               int androidFormat;
> +       };
> +
> +       std::vector<libcamera::Size>
> +       getYUVResolutions(libcamera::CameraConfiguration *cameraConfig,
> +                         const libcamera::PixelFormat &pixelFormat,
> +                         const std::vector<libcamera::Size> &resolutions);
> +       std::vector<libcamera::Size>
> +       getRawResolutions(const libcamera::PixelFormat &pixelFormat);
> +       int initializeStreamConfigurations();
> +
> +       int initializeStaticMetadata();
> +
> +       std::shared_ptr<libcamera::Camera> camera_;
> +
> +       int facing_;
> +       int orientation_;
> +
> +       std::vector<Camera3StreamConfiguration> streamConfigurations_;
> +       std::map<int, libcamera::PixelFormat> formatsMap_;
> +       std::unique_ptr<CameraMetadata> staticMetadata_;
> +       unsigned int maxJpegBufferSize_;
> +};
> +
> +#endif /* __ANDROID_CAMERA_CAPABILITIES_H__ */
> diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
> index 8c71fd0675d3..4bd125d7020a 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"
> @@ -36,94 +32,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)
> @@ -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
> diff --git a/src/android/camera_device.h b/src/android/camera_device.h
> index 4aadb27c562c..090fe28a551e 100644
> --- a/src/android/camera_device.h
> +++ b/src/android/camera_device.h
> @@ -10,14 +10,12 @@
>  #include <map>
>  #include <memory>
>  #include <mutex>
> -#include <tuple>
>  #include <vector>
>
>  #include <hardware/camera3.h>
>
>  #include <libcamera/buffer.h>
>  #include <libcamera/camera.h>
> -#include <libcamera/geometry.h>
>  #include <libcamera/request.h>
>  #include <libcamera/stream.h>
>
> @@ -26,6 +24,7 @@
>  #include "libcamera/internal/message.h"
>  #include "libcamera/internal/thread.h"
>
> +#include "camera_capabilities.h"
>  #include "camera_metadata.h"
>  #include "camera_stream.h"
>  #include "camera_worker.h"
> @@ -57,7 +56,7 @@ public:
>         const std::string &model() const { return model_; }
>         int facing() const { return facing_; }
>         int orientation() const { return orientation_; }
> -       unsigned int maxJpegBufferSize() const { return
> maxJpegBufferSize_; }
> +       unsigned int maxJpegBufferSize() const;
>
>         void setCallbacks(const camera3_callback_ops_t *callbacks);
>         const camera_metadata_t *getStaticMetadata();
> @@ -86,11 +85,6 @@ private:
>                 std::unique_ptr<CaptureRequest> request_;
>         };
>
> -       struct Camera3StreamConfiguration {
> -               libcamera::Size resolution;
> -               int androidFormat;
> -       };
> -
>         enum class State {
>                 Stopped,
>                 Flushing,
> @@ -99,22 +93,11 @@ private:
>
>         void stop();
>
> -       int initializeStreamConfigurations();
> -       std::vector<libcamera::Size>
> -       getYUVResolutions(libcamera::CameraConfiguration *cameraConfig,
> -                         const libcamera::PixelFormat &pixelFormat,
> -                         const std::vector<libcamera::Size> &resolutions);
> -       std::vector<libcamera::Size>
> -       getRawResolutions(const libcamera::PixelFormat &pixelFormat);
> -
>         libcamera::FrameBuffer *createFrameBuffer(const buffer_handle_t
> camera3buffer);
>         void abortRequest(camera3_capture_request_t *request);
>         void notifyShutter(uint32_t frameNumber, uint64_t timestamp);
>         void notifyError(uint32_t frameNumber, camera3_stream_t *stream,
>                          camera3_error_msg_code code);
> -       std::unique_ptr<CameraMetadata> requestTemplatePreview();
> -       std::unique_ptr<CameraMetadata> requestTemplateVideo();
> -       libcamera::PixelFormat toPixelFormat(int format) const;
>         int processControls(Camera3RequestDescriptor *descriptor);
>         std::unique_ptr<CameraMetadata> getResultMetadata(
>                 const Camera3RequestDescriptor &descriptor) const;
> @@ -129,13 +112,11 @@ private:
>
>         std::shared_ptr<libcamera::Camera> camera_;
>         std::unique_ptr<libcamera::CameraConfiguration> config_;
> +       CameraCapabilities capabilities_;
>
> -       std::unique_ptr<CameraMetadata> staticMetadata_;
>         std::map<unsigned int, std::unique_ptr<CameraMetadata>>
> requestTemplates_;
>         const camera3_callback_ops_t *callbacks_;
>
> -       std::vector<Camera3StreamConfiguration> streamConfigurations_;
> -       std::map<int, libcamera::PixelFormat> formatsMap_;
>         std::vector<CameraStream> streams_;
>
>         libcamera::Mutex descriptorsMutex_; /* Protects descriptors_. */
> @@ -147,8 +128,6 @@ private:
>         int facing_;
>         int orientation_;
>
> -       unsigned int maxJpegBufferSize_;
> -
>         CameraMetadata lastSettings_;
>  };
>
> diff --git a/src/android/meson.build b/src/android/meson.build
> index f27fd5316705..6270fb201338 100644
> --- a/src/android/meson.build
> +++ b/src/android/meson.build
> @@ -44,6 +44,7 @@ subdir('cros')
>
>  android_hal_sources = files([
>      'camera3_hal.cpp',
> +    'camera_capabilities.cpp',
>      'camera_device.cpp',
>      'camera_hal_config.cpp',
>      'camera_hal_manager.cpp',
> --
> 2.31.1
>
>

Hi Hiro,

On Tue, Jun 22, 2021 at 10:34:27AM +0900, Hirokazu Honda wrote:
> Hi Jacopo, thank you for the patch.
>
> I failed to apply the patch on the top of the latest tree to review.
> Could you tell me the parent commit which I can apply this patch?

weird, I just applied these two patches cleanly on the latest
master which for me is
969da3189439 ("libcamera: utils: Support systems that lack secure_getenv and issetugid"

>
> -Hiro
> On Tue, Jun 22, 2021 at 12:29 AM Jacopo Mondi <jacopo@jmondi.org> wrote:
>
> > 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 relative 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>
> > ---
> >  src/android/camera_capabilities.cpp | 1164 +++++++++++++++++++++++++++
> >  src/android/camera_capabilities.h   |   65 ++
> >  src/android/camera_device.cpp       | 1147 +-------------------------
> >  src/android/camera_device.h         |   27 +-
> >  src/android/meson.build             |    1 +
> >  5 files changed, 1245 insertions(+), 1159 deletions(-)
> >  create mode 100644 src/android/camera_capabilities.cpp
> >  create mode 100644 src/android/camera_capabilities.h
> >
> > diff --git a/src/android/camera_capabilities.cpp
> > b/src/android/camera_capabilities.cpp
> > new file mode 100644
> > index 000000000000..311a2c839586
> > --- /dev/null
> > +++ b/src/android/camera_capabilities.cpp
> > @@ -0,0 +1,1164 @@
> > +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> > +/*
> > + * Copyright (C) 2021, Google Inc.
> > + *
> > + * camera_capabilities.cpp - Camera static properties manager
> > + */
> > +
> > +#include "camera_capabilities.h"
> > +
> > +#include <array>
> > +#include <cmath>
> > +
> > +#include <hardware/camera3.h>
> > +
> > +#include <libcamera/control_ids.h>
> > +#include <libcamera/controls.h>
> > +#include <libcamera/property_ids.h>
> > +
> > +#include "libcamera/internal/formats.h"
> > +#include "libcamera/internal/log.h"
> > +
> > +using namespace libcamera;
> > +
> > +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"
> > +               }
> > +       },
> > +};
> > +
> > +} /* namespace */
> > +
> > +int CameraCapabilities::initialize(std::shared_ptr<libcamera::Camera>
> > camera,
> > +                                  int orientation, int facing)
> > +{
> > +       camera_ = camera;
> > +       orientation_ = orientation;
> > +       facing_ = facing;
> > +
> > +       /* 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();
> > +       if (ret)
> > +               return ret;
> > +
> > +       return initializeStaticMetadata();
> > +}
> > +
> > +std::vector<Size>
> > CameraCapabilities::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> CameraCapabilities::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 Camera static metadata.
> > + */
> > +int CameraCapabilities::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;
> > +}
> > +
> > +int CameraCapabilities::initializeStaticMetadata()
> > +{
> > +       staticMetadata_ = std::make_unique<CameraMetadata>(64, 1024);
> > +       if (!staticMetadata_->isValid()) {
> > +               LOG(HAL, Error) << "Failed to allocate static metadata";
> > +               staticMetadata_.reset();
> > +               return -EINVAL;
> > +       }
> > +
> > +       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 -EINVAL;
> > +       }
> > +
> > +       if (staticMetadata_->resized()) {
> > +               auto [entryCount, dataCount] = staticMetadata_->usage();
> > +               LOG(HAL, Info)
> > +                       << "Static metadata resized: " << entryCount
> > +                       << " entries and " << dataCount << " bytes used";
> > +       }
> > +
> > +       return 0;
> > +}
> > +
> > +/* Translate Android format code to libcamera pixel format. */
> > +PixelFormat CameraCapabilities::toPixelFormat(int format) const
> > +{
> > +       auto it = formatsMap_.find(format);
> > +       if (it == formatsMap_.end()) {
> > +               LOG(HAL, Error) << "Requested format " <<
> > utils::hex(format)
> > +                               << " not supported";
> > +               return PixelFormat();
> > +       }
> > +
> > +       return it->second;
> > +}
> > +
> > +std::unique_ptr<CameraMetadata>
> > CameraCapabilities::requestTemplatePreview() const
> > +{
> > +       /*
> > +        * \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;
> > +}
> > +
> > +std::unique_ptr<CameraMetadata>
> > CameraCapabilities::requestTemplateVideo() const
> > +{
> > +       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;
> > +}
> > diff --git a/src/android/camera_capabilities.h
> > b/src/android/camera_capabilities.h
> > new file mode 100644
> > index 000000000000..f511607bbd90
> > --- /dev/null
> > +++ b/src/android/camera_capabilities.h
> > @@ -0,0 +1,65 @@
> > +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> > +/*
> > + * Copyright (C) 2021, Google Inc.
> > + *
> > + * camera_capabilities.h - Camera static properties manager
> > + */
> > +#ifndef __ANDROID_CAMERA_CAPABILITIES_H__
> > +#define __ANDROID_CAMERA_CAPABILITIES_H__
> > +
> > +#include <map>
> > +#include <memory>
> > +#include <vector>
> > +
> > +#include <libcamera/camera.h>
> > +#include <libcamera/class.h>
> > +#include <libcamera/formats.h>
> > +#include <libcamera/geometry.h>
> > +
> > +#include "camera_metadata.h"
> > +
> > +class CameraCapabilities
> > +{
> > +public:
> > +       CameraCapabilities() = default;
> > +
> > +       int initialize(std::shared_ptr<libcamera::Camera> camera,
> > +                      int orientation, int facing);
> > +
> > +       CameraMetadata *staticMetadata() const { return
> > staticMetadata_.get(); }
> > +       libcamera::PixelFormat toPixelFormat(int format) const;
> > +       unsigned int maxJpegBufferSize() const { return
> > maxJpegBufferSize_; }
> > +
> > +       std::unique_ptr<CameraMetadata> requestTemplatePreview() const;
> > +       std::unique_ptr<CameraMetadata> requestTemplateVideo() const;
> > +
> > +private:
> > +       LIBCAMERA_DISABLE_COPY_AND_MOVE(CameraCapabilities)
> > +
> > +       struct Camera3StreamConfiguration {
> > +               libcamera::Size resolution;
> > +               int androidFormat;
> > +       };
> > +
> > +       std::vector<libcamera::Size>
> > +       getYUVResolutions(libcamera::CameraConfiguration *cameraConfig,
> > +                         const libcamera::PixelFormat &pixelFormat,
> > +                         const std::vector<libcamera::Size> &resolutions);
> > +       std::vector<libcamera::Size>
> > +       getRawResolutions(const libcamera::PixelFormat &pixelFormat);
> > +       int initializeStreamConfigurations();
> > +
> > +       int initializeStaticMetadata();
> > +
> > +       std::shared_ptr<libcamera::Camera> camera_;
> > +
> > +       int facing_;
> > +       int orientation_;
> > +
> > +       std::vector<Camera3StreamConfiguration> streamConfigurations_;
> > +       std::map<int, libcamera::PixelFormat> formatsMap_;
> > +       std::unique_ptr<CameraMetadata> staticMetadata_;
> > +       unsigned int maxJpegBufferSize_;
> > +};
> > +
> > +#endif /* __ANDROID_CAMERA_CAPABILITIES_H__ */
> > diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
> > index 8c71fd0675d3..4bd125d7020a 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"
> > @@ -36,94 +32,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)
> > @@ -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
> > diff --git a/src/android/camera_device.h b/src/android/camera_device.h
> > index 4aadb27c562c..090fe28a551e 100644
> > --- a/src/android/camera_device.h
> > +++ b/src/android/camera_device.h
> > @@ -10,14 +10,12 @@
> >  #include <map>
> >  #include <memory>
> >  #include <mutex>
> > -#include <tuple>
> >  #include <vector>
> >
> >  #include <hardware/camera3.h>
> >
> >  #include <libcamera/buffer.h>
> >  #include <libcamera/camera.h>
> > -#include <libcamera/geometry.h>
> >  #include <libcamera/request.h>
> >  #include <libcamera/stream.h>
> >
> > @@ -26,6 +24,7 @@
> >  #include "libcamera/internal/message.h"
> >  #include "libcamera/internal/thread.h"
> >
> > +#include "camera_capabilities.h"
> >  #include "camera_metadata.h"
> >  #include "camera_stream.h"
> >  #include "camera_worker.h"
> > @@ -57,7 +56,7 @@ public:
> >         const std::string &model() const { return model_; }
> >         int facing() const { return facing_; }
> >         int orientation() const { return orientation_; }
> > -       unsigned int maxJpegBufferSize() const { return
> > maxJpegBufferSize_; }
> > +       unsigned int maxJpegBufferSize() const;
> >
> >         void setCallbacks(const camera3_callback_ops_t *callbacks);
> >         const camera_metadata_t *getStaticMetadata();
> > @@ -86,11 +85,6 @@ private:
> >                 std::unique_ptr<CaptureRequest> request_;
> >         };
> >
> > -       struct Camera3StreamConfiguration {
> > -               libcamera::Size resolution;
> > -               int androidFormat;
> > -       };
> > -
> >         enum class State {
> >                 Stopped,
> >                 Flushing,
> > @@ -99,22 +93,11 @@ private:
> >
> >         void stop();
> >
> > -       int initializeStreamConfigurations();
> > -       std::vector<libcamera::Size>
> > -       getYUVResolutions(libcamera::CameraConfiguration *cameraConfig,
> > -                         const libcamera::PixelFormat &pixelFormat,
> > -                         const std::vector<libcamera::Size> &resolutions);
> > -       std::vector<libcamera::Size>
> > -       getRawResolutions(const libcamera::PixelFormat &pixelFormat);
> > -
> >         libcamera::FrameBuffer *createFrameBuffer(const buffer_handle_t
> > camera3buffer);
> >         void abortRequest(camera3_capture_request_t *request);
> >         void notifyShutter(uint32_t frameNumber, uint64_t timestamp);
> >         void notifyError(uint32_t frameNumber, camera3_stream_t *stream,
> >                          camera3_error_msg_code code);
> > -       std::unique_ptr<CameraMetadata> requestTemplatePreview();
> > -       std::unique_ptr<CameraMetadata> requestTemplateVideo();
> > -       libcamera::PixelFormat toPixelFormat(int format) const;
> >         int processControls(Camera3RequestDescriptor *descriptor);
> >         std::unique_ptr<CameraMetadata> getResultMetadata(
> >                 const Camera3RequestDescriptor &descriptor) const;
> > @@ -129,13 +112,11 @@ private:
> >
> >         std::shared_ptr<libcamera::Camera> camera_;
> >         std::unique_ptr<libcamera::CameraConfiguration> config_;
> > +       CameraCapabilities capabilities_;
> >
> > -       std::unique_ptr<CameraMetadata> staticMetadata_;
> >         std::map<unsigned int, std::unique_ptr<CameraMetadata>>
> > requestTemplates_;
> >         const camera3_callback_ops_t *callbacks_;
> >
> > -       std::vector<Camera3StreamConfiguration> streamConfigurations_;
> > -       std::map<int, libcamera::PixelFormat> formatsMap_;
> >         std::vector<CameraStream> streams_;
> >
> >         libcamera::Mutex descriptorsMutex_; /* Protects descriptors_. */
> > @@ -147,8 +128,6 @@ private:
> >         int facing_;
> >         int orientation_;
> >
> > -       unsigned int maxJpegBufferSize_;
> > -
> >         CameraMetadata lastSettings_;
> >  };
> >
> > diff --git a/src/android/meson.build b/src/android/meson.build
> > index f27fd5316705..6270fb201338 100644
> > --- a/src/android/meson.build
> > +++ b/src/android/meson.build
> > @@ -44,6 +44,7 @@ subdir('cros')
> >
> >  android_hal_sources = files([
> >      'camera3_hal.cpp',
> > +    'camera_capabilities.cpp',
> >      'camera_device.cpp',
> >      'camera_hal_config.cpp',
> >      'camera_hal_manager.cpp',
> > --
> > 2.31.1
> >
> >

Hi Jacopo,

Thank you for the patch.

On Mon, Jun 21, 2021 at 05:29:54PM +0200, Jacopo Mondi wrote:
> 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 relative to:

s/relative/related/

> - 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>
> ---
>  src/android/camera_capabilities.cpp | 1164 +++++++++++++++++++++++++++
>  src/android/camera_capabilities.h   |   65 ++
>  src/android/camera_device.cpp       | 1147 +-------------------------
>  src/android/camera_device.h         |   27 +-
>  src/android/meson.build             |    1 +
>  5 files changed, 1245 insertions(+), 1159 deletions(-)
>  create mode 100644 src/android/camera_capabilities.cpp
>  create mode 100644 src/android/camera_capabilities.h
> 
> diff --git a/src/android/camera_capabilities.cpp b/src/android/camera_capabilities.cpp
> new file mode 100644
> index 000000000000..311a2c839586
> --- /dev/null
> +++ b/src/android/camera_capabilities.cpp
> @@ -0,0 +1,1164 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2021, Google Inc.
> + *
> + * camera_capabilities.cpp - Camera static properties manager
> + */
> +
> +#include "camera_capabilities.h"
> +
> +#include <array>
> +#include <cmath>
> +
> +#include <hardware/camera3.h>
> +
> +#include <libcamera/control_ids.h>
> +#include <libcamera/controls.h>
> +#include <libcamera/property_ids.h>
> +
> +#include "libcamera/internal/formats.h"
> +#include "libcamera/internal/log.h"
> +
> +using namespace libcamera;
> +
> +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"
> +		}
> +	},
> +};
> +
> +} /* namespace */
> +
> +int CameraCapabilities::initialize(std::shared_ptr<libcamera::Camera> camera,
> +				   int orientation, int facing)
> +{
> +	camera_ = camera;
> +	orientation_ = orientation;
> +	facing_ = facing;
> +
> +	/* 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();
> +	if (ret)
> +		return ret;
> +
> +	return initializeStaticMetadata();
> +}
> +
> +std::vector<Size> CameraCapabilities::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> CameraCapabilities::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 Camera static metadata.

Did you mean s/Camera/camera/ as it's not a class name ?

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

> + */
> +int CameraCapabilities::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;
> +}
> +
> +int CameraCapabilities::initializeStaticMetadata()
> +{
> +	staticMetadata_ = std::make_unique<CameraMetadata>(64, 1024);
> +	if (!staticMetadata_->isValid()) {
> +		LOG(HAL, Error) << "Failed to allocate static metadata";
> +		staticMetadata_.reset();
> +		return -EINVAL;
> +	}
> +
> +	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 -EINVAL;
> +	}
> +
> +	if (staticMetadata_->resized()) {
> +		auto [entryCount, dataCount] = staticMetadata_->usage();
> +		LOG(HAL, Info)
> +			<< "Static metadata resized: " << entryCount
> +			<< " entries and " << dataCount << " bytes used";
> +	}
> +
> +	return 0;
> +}
> +
> +/* Translate Android format code to libcamera pixel format. */
> +PixelFormat CameraCapabilities::toPixelFormat(int format) const
> +{
> +	auto it = formatsMap_.find(format);
> +	if (it == formatsMap_.end()) {
> +		LOG(HAL, Error) << "Requested format " << utils::hex(format)
> +				<< " not supported";
> +		return PixelFormat();
> +	}
> +
> +	return it->second;
> +}
> +
> +std::unique_ptr<CameraMetadata> CameraCapabilities::requestTemplatePreview() const
> +{
> +	/*
> +	 * \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;
> +}
> +
> +std::unique_ptr<CameraMetadata> CameraCapabilities::requestTemplateVideo() const
> +{
> +	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;
> +}
> diff --git a/src/android/camera_capabilities.h b/src/android/camera_capabilities.h
> new file mode 100644
> index 000000000000..f511607bbd90
> --- /dev/null
> +++ b/src/android/camera_capabilities.h
> @@ -0,0 +1,65 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2021, Google Inc.
> + *
> + * camera_capabilities.h - Camera static properties manager
> + */
> +#ifndef __ANDROID_CAMERA_CAPABILITIES_H__
> +#define __ANDROID_CAMERA_CAPABILITIES_H__
> +
> +#include <map>
> +#include <memory>
> +#include <vector>
> +
> +#include <libcamera/camera.h>
> +#include <libcamera/class.h>
> +#include <libcamera/formats.h>
> +#include <libcamera/geometry.h>
> +
> +#include "camera_metadata.h"
> +
> +class CameraCapabilities
> +{
> +public:
> +	CameraCapabilities() = default;
> +
> +	int initialize(std::shared_ptr<libcamera::Camera> camera,
> +		       int orientation, int facing);
> +
> +	CameraMetadata *staticMetadata() const { return staticMetadata_.get(); }
> +	libcamera::PixelFormat toPixelFormat(int format) const;
> +	unsigned int maxJpegBufferSize() const { return maxJpegBufferSize_; }
> +
> +	std::unique_ptr<CameraMetadata> requestTemplatePreview() const;
> +	std::unique_ptr<CameraMetadata> requestTemplateVideo() const;
> +
> +private:
> +	LIBCAMERA_DISABLE_COPY_AND_MOVE(CameraCapabilities)
> +
> +	struct Camera3StreamConfiguration {
> +		libcamera::Size resolution;
> +		int androidFormat;
> +	};
> +
> +	std::vector<libcamera::Size>
> +	getYUVResolutions(libcamera::CameraConfiguration *cameraConfig,
> +			  const libcamera::PixelFormat &pixelFormat,
> +			  const std::vector<libcamera::Size> &resolutions);
> +	std::vector<libcamera::Size>
> +	getRawResolutions(const libcamera::PixelFormat &pixelFormat);
> +	int initializeStreamConfigurations();
> +
> +	int initializeStaticMetadata();
> +
> +	std::shared_ptr<libcamera::Camera> camera_;
> +
> +	int facing_;
> +	int orientation_;
> +
> +	std::vector<Camera3StreamConfiguration> streamConfigurations_;
> +	std::map<int, libcamera::PixelFormat> formatsMap_;
> +	std::unique_ptr<CameraMetadata> staticMetadata_;
> +	unsigned int maxJpegBufferSize_;
> +};
> +
> +#endif /* __ANDROID_CAMERA_CAPABILITIES_H__ */
> diff --git a/src/android/camera_device.cpp b/src/android/camera_device.cpp
> index 8c71fd0675d3..4bd125d7020a 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"
> @@ -36,94 +32,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)
> @@ -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
> diff --git a/src/android/camera_device.h b/src/android/camera_device.h
> index 4aadb27c562c..090fe28a551e 100644
> --- a/src/android/camera_device.h
> +++ b/src/android/camera_device.h
> @@ -10,14 +10,12 @@
>  #include <map>
>  #include <memory>
>  #include <mutex>
> -#include <tuple>
>  #include <vector>
>  
>  #include <hardware/camera3.h>
>  
>  #include <libcamera/buffer.h>
>  #include <libcamera/camera.h>
> -#include <libcamera/geometry.h>
>  #include <libcamera/request.h>
>  #include <libcamera/stream.h>
>  
> @@ -26,6 +24,7 @@
>  #include "libcamera/internal/message.h"
>  #include "libcamera/internal/thread.h"
>  
> +#include "camera_capabilities.h"
>  #include "camera_metadata.h"
>  #include "camera_stream.h"
>  #include "camera_worker.h"
> @@ -57,7 +56,7 @@ public:
>  	const std::string &model() const { return model_; }
>  	int facing() const { return facing_; }
>  	int orientation() const { return orientation_; }
> -	unsigned int maxJpegBufferSize() const { return maxJpegBufferSize_; }
> +	unsigned int maxJpegBufferSize() const;
>  
>  	void setCallbacks(const camera3_callback_ops_t *callbacks);
>  	const camera_metadata_t *getStaticMetadata();
> @@ -86,11 +85,6 @@ private:
>  		std::unique_ptr<CaptureRequest> request_;
>  	};
>  
> -	struct Camera3StreamConfiguration {
> -		libcamera::Size resolution;
> -		int androidFormat;
> -	};
> -
>  	enum class State {
>  		Stopped,
>  		Flushing,
> @@ -99,22 +93,11 @@ private:
>  
>  	void stop();
>  
> -	int initializeStreamConfigurations();
> -	std::vector<libcamera::Size>
> -	getYUVResolutions(libcamera::CameraConfiguration *cameraConfig,
> -			  const libcamera::PixelFormat &pixelFormat,
> -			  const std::vector<libcamera::Size> &resolutions);
> -	std::vector<libcamera::Size>
> -	getRawResolutions(const libcamera::PixelFormat &pixelFormat);
> -
>  	libcamera::FrameBuffer *createFrameBuffer(const buffer_handle_t camera3buffer);
>  	void abortRequest(camera3_capture_request_t *request);
>  	void notifyShutter(uint32_t frameNumber, uint64_t timestamp);
>  	void notifyError(uint32_t frameNumber, camera3_stream_t *stream,
>  			 camera3_error_msg_code code);
> -	std::unique_ptr<CameraMetadata> requestTemplatePreview();
> -	std::unique_ptr<CameraMetadata> requestTemplateVideo();
> -	libcamera::PixelFormat toPixelFormat(int format) const;
>  	int processControls(Camera3RequestDescriptor *descriptor);
>  	std::unique_ptr<CameraMetadata> getResultMetadata(
>  		const Camera3RequestDescriptor &descriptor) const;
> @@ -129,13 +112,11 @@ private:
>  
>  	std::shared_ptr<libcamera::Camera> camera_;
>  	std::unique_ptr<libcamera::CameraConfiguration> config_;
> +	CameraCapabilities capabilities_;
>  
> -	std::unique_ptr<CameraMetadata> staticMetadata_;
>  	std::map<unsigned int, std::unique_ptr<CameraMetadata>> requestTemplates_;
>  	const camera3_callback_ops_t *callbacks_;
>  
> -	std::vector<Camera3StreamConfiguration> streamConfigurations_;
> -	std::map<int, libcamera::PixelFormat> formatsMap_;
>  	std::vector<CameraStream> streams_;
>  
>  	libcamera::Mutex descriptorsMutex_; /* Protects descriptors_. */
> @@ -147,8 +128,6 @@ private:
>  	int facing_;
>  	int orientation_;
>  
> -	unsigned int maxJpegBufferSize_;
> -
>  	CameraMetadata lastSettings_;
>  };
>  
> diff --git a/src/android/meson.build b/src/android/meson.build
> index f27fd5316705..6270fb201338 100644
> --- a/src/android/meson.build
> +++ b/src/android/meson.build
> @@ -44,6 +44,7 @@ subdir('cros')
>  
>  android_hal_sources = files([
>      'camera3_hal.cpp',
> +    'camera_capabilities.cpp',
>      'camera_device.cpp',
>      'camera_hal_config.cpp',
>      'camera_hal_manager.cpp',
>