{"id":27133,"url":"https://patchwork.libcamera.org/api/patches/27133/?format=json","web_url":"https://patchwork.libcamera.org/patch/27133/","project":{"id":1,"url":"https://patchwork.libcamera.org/api/projects/1/?format=json","name":"libcamera","link_name":"libcamera","list_id":"libcamera_core","list_email":"libcamera-devel@lists.libcamera.org","web_url":"","scm_url":"","webscm_url":""},"msgid":"<20260629163017.863145-50-barnabas.pocze@ideasonboard.com>","date":"2026-06-29T16:30:12","name":"[RFC,v1,49/54] android: Update imported files","commit_ref":null,"pull_url":null,"state":"new","archived":false,"hash":"b40982279e1c4506f123fe77772580d5faac7c6c","submitter":{"id":216,"url":"https://patchwork.libcamera.org/api/people/216/?format=json","name":"Barnabás Pőcze","email":"barnabas.pocze@ideasonboard.com"},"delegate":null,"mbox":"https://patchwork.libcamera.org/patch/27133/mbox/","series":[{"id":6025,"url":"https://patchwork.libcamera.org/api/series/6025/?format=json","web_url":"https://patchwork.libcamera.org/project/libcamera/list/?series=6025","date":"2026-06-29T16:29:23","name":"libcamera: Split requests and buffers","version":1,"mbox":"https://patchwork.libcamera.org/series/6025/mbox/"}],"comments":"https://patchwork.libcamera.org/api/patches/27133/comments/","check":"pending","checks":"https://patchwork.libcamera.org/api/patches/27133/checks/","tags":{},"headers":{"Return-Path":"","X-Original-To":"parsemail@patchwork.libcamera.org","Delivered-To":"parsemail@patchwork.libcamera.org","Received":["from lancelot.ideasonboard.com (lancelot.ideasonboard.com\n\t[92.243.16.209])\n\tby patchwork.libcamera.org (Postfix) with ESMTPS id CABF6C3264\n\tfor ;\n\tMon, 29 Jun 2026 16:40:43 +0000 (UTC)","from lancelot.ideasonboard.com (localhost [IPv6:::1])\n\tby lancelot.ideasonboard.com (Postfix) with ESMTP id 7809E65F4A;\n\tMon, 29 Jun 2026 18:40:43 +0200 (CEST)","from perceval.ideasonboard.com (perceval.ideasonboard.com\n\t[213.167.242.64])\n\tby lancelot.ideasonboard.com (Postfix) with ESMTPS id 67E3865F73\n\tfor ;\n\tMon, 29 Jun 2026 18:30:33 +0200 (CEST)","from pb-laptop.local (185.221.140.128.nat.pool.zt.hu\n\t[185.221.140.128])\n\tby perceval.ideasonboard.com (Postfix) with ESMTPSA id 4FBF78D4\n\tfor ;\n\tMon, 29 Jun 2026 18:29:49 +0200 (CEST)"],"Authentication-Results":"lancelot.ideasonboard.com; dkim=pass (1024-bit key;\n\tunprotected) header.d=ideasonboard.com header.i=@ideasonboard.com\n\theader.b=\"envWavue\"; dkim-atps=neutral","DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com;\n\ts=mail; t=1782750590;\n\tbh=0YwRqVc4R63sYZt5n6gxdPiyT3znhwgxNofyeqfF8Js=;\n\th=From:To:Subject:Date:In-Reply-To:References:From;\n\tb=envWavuewiUr3oi5ZAFd81dHHYObOHbqEJgQanhtEv1BcIAIg5Zobi3oMLpRPV87q\n\t+xUBZModZ+a3vQyzU0q+LqBPdCNPbqSWcX1xQ3PBRkvQSCN70ce0DRcG8bjvrWGcr0\n\tNjbkb5VmWEyC9mM/a44NE7x7hlyLsQJXQ0OXzkMk=","From":"=?utf-8?q?Barnab=C3=A1s_P=C5=91cze?= ","To":"libcamera-devel@lists.libcamera.org","Subject":"[RFC PATCH v1 49/54] android: Update imported files","Date":"Mon, 29 Jun 2026 18:30:12 +0200","Message-ID":"<20260629163017.863145-50-barnabas.pocze@ideasonboard.com>","X-Mailer":"git-send-email 2.54.0","In-Reply-To":"<20260629163017.863145-1-barnabas.pocze@ideasonboard.com>","References":"<20260629163017.863145-1-barnabas.pocze@ideasonboard.com>","MIME-Version":"1.0","Content-Type":"text/plain; charset=UTF-8","Content-Transfer-Encoding":"8bit","X-Mailman-Approved-At":"Mon, 29 Jun 2026 18:40:42 +0200","X-BeenThere":"libcamera-devel@lists.libcamera.org","X-Mailman-Version":"2.1.29","Precedence":"list","List-Id":"","List-Unsubscribe":",\n\t","List-Archive":"","List-Post":"","List-Help":"","List-Subscribe":",\n\t","Errors-To":"libcamera-devel-bounces@lists.libcamera.org","Sender":"\"libcamera-devel\" "},"content":"Update the android headers and source files from the android repositories:\n\n * https://android.googlesource.com/platform/hardware/libhardware/\n * https://android.googlesource.com/platform/system/core/\n * https://android.googlesource.com/platform/system/logging/\n * https://android.googlesource.com/platform/system/media/\n\nall from tag `android-17.0.0_r1`.\n\nThe SPDX license identifiers are kept or added for new files.\nCertain new struct members also need to be initialized for the\ncompilation to succeed.\n\nSigned-off-by: Barnabás Pőcze \n---\n .../libhardware/include/hardware/camera3.h | 360 +-\n .../include/hardware/camera_common.h | 304 +-\n .../libhardware/include/hardware/gralloc.h | 99 +-\n .../android/metadata/camera_metadata_hidden.h | 11 +-\n .../android/metadata/system/camera_metadata.h | 41 +-\n .../metadata/system/camera_metadata_tags.h | 633 +-\n .../metadata/system/camera_vendor_tags.h | 10 +-\n .../android/system/core/include/android/log.h | 450 +-\n .../core/include/cutils/native_handle.h | 62 +-\n .../system/core/include/system/camera.h | 4 +-\n .../core/include/system/graphics-base-v1.2.h | 36 +\n .../core/include/system/graphics-base.h | 1 +\n .../system/core/include/system/graphics.h | 10 +-\n src/android/camera3_hal.cpp | 3 +\n src/android/camera_ops.cpp | 4 +-\n src/android/metadata/camera_metadata.c | 183 +-\n .../metadata/camera_metadata_tag_info.c | 5478 ++++++++++++++++-\n 17 files changed, 7437 insertions(+), 252 deletions(-)\n create mode 100644 include/android/system/core/include/system/graphics-base-v1.2.h","diff":"diff --git a/include/android/hardware/libhardware/include/hardware/camera3.h b/include/android/hardware/libhardware/include/hardware/camera3.h\nindex fd1e2072ad..fe7285f904 100644\n--- a/include/android/hardware/libhardware/include/hardware/camera3.h\n+++ b/include/android/hardware/libhardware/include/hardware/camera3.h\n@@ -22,7 +22,7 @@\n #include \"camera_common.h\"\n \n /**\n- * Camera device HAL 3.5[ CAMERA_DEVICE_API_VERSION_3_5 ]\n+ * Camera device HAL 3.6[ CAMERA_DEVICE_API_VERSION_3_6 ]\n *\n * This is the current recommended version of the camera device HAL.\n *\n@@ -30,7 +30,7 @@\n * android.hardware.camera2 API as LIMITED or above hardware level.\n *\n * Camera devices that support this version of the HAL must return\n- * CAMERA_DEVICE_API_VERSION_3_5 in camera_device_t.common.version and in\n+ * CAMERA_DEVICE_API_VERSION_3_6 in camera_device_t.common.version and in\n * camera_info_t.device_version (from camera_module_t.get_camera_info).\n *\n * CAMERA_DEVICE_API_VERSION_3_3 and above:\n@@ -184,6 +184,25 @@\n * for a logical multi camera, the application has the option to specify individual\n * settings for a particular physical device.\n *\n+ * 3.6: Minor revisions to support HAL buffer management APIs:\n+ *\n+ * - Add ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION static metadata, which allows HAL to\n+ * opt in to the new buffer management APIs described below.\n+ *\n+ * - Add request_stream_buffers() and return_stream_buffers() to camera3_callback_ops_t for HAL to\n+ * request and return output buffers from camera service.\n+ *\n+ * - Add signal_stream_flush() to camera3_device_ops_t for camera service to notify HAL an\n+ * upcoming configure_streams() call requires HAL to return buffers of certain streams.\n+ *\n+ * - Add CAMERA3_JPEG_APP_SEGMENTS_BLOB_ID to support BLOB with only JPEG apps\n+ * segments and thumbnail (without main image bitstream). Camera framework\n+ * uses such stream togerther with a HAL YUV_420_888/IMPLEMENTATION_DEFINED\n+ * stream to encode HEIC (ISO/IEC 23008-12) image.\n+ *\n+ * - Add is_reconfiguration_required() to camera3_device_ops_t to enable HAL to skip or\n+ * trigger stream reconfiguration depending on new session parameter values.\n+ *\n */\n \n /**\n@@ -1314,7 +1333,7 @@\n * To avoid excessive amount of noise reduction and insufficient amount of edge enhancement\n * being applied to the input buffer, the application can hint the HAL how much effective\n * exposure time improvement has been done by the application, then the HAL can adjust the\n- * noise reduction and edge enhancement paramters to get best reprocessed image quality.\n+ * noise reduction and edge enhancement parameters to get best reprocessed image quality.\n * Below tag can be used for this purpose:\n * - android.reprocess.effectiveExposureFactor\n * The value would be exposure time increase factor applied to the original output image,\n@@ -1737,24 +1756,8 @@ typedef struct camera3_stream {\n */\n const char* physical_camera_id;\n \n- /**\n- * This should be one of the camera3_stream_rotation_t values except for\n- * CAMERA3_STREAM_ROTATION_180.\n- * When setting to CAMERA3_STREAM_ROTATION_90 or CAMERA3_STREAM_ROTATION_270, HAL would crop,\n- * rotate the frame by the specified degrees clockwise and scale it up to original size.\n- * In Chrome OS, it's possible to have a portrait activity run in a landscape screen with\n- * landscape-mounted camera. The activity would show stretched or rotated preview because it\n- * does not expect to receive landscape preview frames. To solve this problem, we ask HAL to\n- * crop, rotate and scale the frames and modify CameraCharacteristics.SENSOR_ORIENTATION\n- * accordingly to imitate a portrait camera.\n- * Setting it to CAMERA3_STREAM_ROTATION_0 means no crop-rotate-scale would be performed.\n- * |cros_rotate_scale_degrees| in all camera3_stream_t of a configure_streams() call must be\n- * identical. The HAL should return -EINVAL if the degrees are not the same for all the streams.\n- */\n- int crop_rotate_scale_degrees;\n-\n /* reserved for future use */\n- void *reserved[5];\n+ void *reserved[6];\n \n } camera3_stream_t;\n \n@@ -1958,21 +1961,25 @@ typedef struct camera3_stream_buffer_set {\n /**\n * camera3_jpeg_blob:\n *\n- * Transport header for compressed JPEG buffers in output streams.\n+ * Transport header for compressed JPEG or JPEG_APP_SEGMENTS buffers in output streams.\n *\n- * To capture JPEG images, a stream is created using the pixel format\n+ * To capture JPEG or JPEG_APP_SEGMENTS images, a stream is created using the pixel format\n * HAL_PIXEL_FORMAT_BLOB. The buffer size for the stream is calculated by the\n- * framework, based on the static metadata field android.jpeg.maxSize. Since\n- * compressed JPEG images are of variable size, the HAL needs to include the\n- * final size of the compressed image using this structure inside the output\n- * stream buffer. The JPEG blob ID field must be set to CAMERA3_JPEG_BLOB_ID.\n+ * framework, based on the static metadata field android.jpeg.maxSize for JPEG,\n+ * and android.jpeg.maxAppsSegments for JPEG_APP_SEGMENTS.\n *\n- * Transport header should be at the end of the JPEG output stream buffer. That\n+ * Since compressed JPEG/JPEG_APP_SEGMENTS images are of variable size, the HAL needs to\n+ * include the final size of the image using this structure inside the output\n+ * stream buffer. The JPEG blob ID field must be set to CAMERA3_JPEG_BLOB_ID for\n+ * JPEG and CAMERA3_JPEG_APP_SEGMENTS_BLOB_ID for APP segments.\n+ *\n+ * Transport header should be at the end of the output stream buffer. That\n * means the jpeg_blob_id must start at byte[buffer_size -\n * sizeof(camera3_jpeg_blob)], where the buffer_size is the size of gralloc buffer.\n- * Any HAL using this transport header must account for it in android.jpeg.maxSize\n- * The JPEG data itself starts at the beginning of the buffer and should be\n- * jpeg_size bytes long.\n+ * The blob data itself starts at the beginning of the buffer and should be\n+ * jpeg_size bytes long. HAL using this transport header for JPEG must account for\n+ * it in android.jpeg.maxSize. For JPEG APP segments, camera framework makes\n+ * sure that the output stream buffer is large enough for the transport header.\n */\n typedef struct camera3_jpeg_blob {\n uint16_t jpeg_blob_id;\n@@ -1980,7 +1987,8 @@ typedef struct camera3_jpeg_blob {\n } camera3_jpeg_blob_t;\n \n enum {\n- CAMERA3_JPEG_BLOB_ID = 0x00FF\n+ CAMERA3_JPEG_BLOB_ID = 0x00FF,\n+ CAMERA3_JPEG_APP_SEGMENTS_BLOB_ID = 0x0100,\n };\n \n /**********************************************************************\n@@ -2046,6 +2054,14 @@ typedef enum camera3_error_msg_code {\n * available. Subsequent requests are unaffected, and the device remains\n * operational. The frame_number field specifies the request for which\n * result metadata won't be available.\n+ *\n+ * >= CAMERA_DEVICE_API_VERSION_3_6:\n+ *\n+ * In case the result metadata is absent for a logical camera device, then the\n+ * error_stream pointer must be set to NULL.\n+ * If the result metadata cannot be produced for a physical camera device, then\n+ * error_stream must contain a pointer to a respective stream associated with\n+ * that physical device.\n */\n CAMERA3_MSG_ERROR_RESULT = 3,\n \n@@ -2143,6 +2159,153 @@ typedef struct camera3_notify_msg {\n \n } camera3_notify_msg_t;\n \n+\n+/**********************************************************************\n+ *\n+ * Types definition for request_stream_buffers() callback.\n+ *\n+ */\n+\n+/**\n+ * camera3_buffer_request_status_t:\n+ *\n+ * The overall buffer request status returned by request_stream_buffers()\n+ */\n+typedef enum camera3_buffer_request_status {\n+ /**\n+ * request_stream_buffers() call succeeded and all requested buffers are\n+ * returned.\n+ */\n+ CAMERA3_BUF_REQ_OK = 0,\n+\n+ /**\n+ * request_stream_buffers() call failed for some streams.\n+ * Check per stream status for each returned camera3_stream_buffer_ret_t.\n+ */\n+ CAMERA3_BUF_REQ_FAILED_PARTIAL = 1,\n+\n+ /**\n+ * request_stream_buffers() call failed for all streams and no buffers are\n+ * returned at all. Camera service is about to or is performing\n+ * configure_streams() call. HAL must wait until next configure_streams()\n+ * call is finished before requesting buffers again.\n+ */\n+ CAMERA3_BUF_REQ_FAILED_CONFIGURING = 2,\n+\n+ /**\n+ * request_stream_buffers() call failed for all streams and no buffers are\n+ * returned at all. Failure due to bad camera3_buffer_request input, eg:\n+ * unknown stream or repeated stream in the list of buffer requests.\n+ */\n+ CAMERA3_BUF_REQ_FAILED_ILLEGAL_ARGUMENTS = 3,\n+\n+ /**\n+ * request_stream_buffers() call failed for all streams and no buffers are\n+ * returned at all. This can happen for unknown reasons or a combination\n+ * of different failure reasons per stream. For the latter case, caller can\n+ * check per stream failure reason returned in camera3_stream_buffer_ret.\n+ */\n+ CAMERA3_BUF_REQ_FAILED_UNKNOWN = 4,\n+\n+ /**\n+ * Number of buffer request status\n+ */\n+ CAMERA3_BUF_REQ_NUM_STATUS\n+\n+} camera3_buffer_request_status_t;\n+\n+/**\n+ * camera3_stream_buffer_req_status_t:\n+ *\n+ * The per stream buffer request status returned by request_stream_buffers()\n+ */\n+typedef enum camera3_stream_buffer_req_status {\n+ /**\n+ * Get buffer succeeds and all requested buffers are returned.\n+ */\n+ CAMERA3_PS_BUF_REQ_OK = 0,\n+\n+ /**\n+ * Get buffer failed due to timeout waiting for an available buffer. This is\n+ * likely due to the client application holding too many buffers, or the\n+ * system is under memory pressure.\n+ * This is not a fatal error. HAL can try to request buffer for this stream\n+ * later. If HAL cannot get a buffer for certain capture request in time\n+ * due to this error, HAL can send an ERROR_REQUEST to camera service and\n+ * drop processing that request.\n+ */\n+ CAMERA3_PS_BUF_REQ_NO_BUFFER_AVAILABLE = 1,\n+\n+ /**\n+ * Get buffer failed due to HAL has reached its maxBuffer count. This is not\n+ * a fatal error. HAL can try to request buffer for this stream again after\n+ * it returns at least one buffer of that stream to camera service.\n+ */\n+ CAMERA3_PS_BUF_REQ_MAX_BUFFER_EXCEEDED = 2,\n+\n+ /**\n+ * Get buffer failed due to the stream is disconnected by client\n+ * application, has been removed, or not recognized by camera service.\n+ * This means application is no longer interested in this stream.\n+ * Requesting buffer for this stream will never succeed after this error is\n+ * returned. HAL must safely return all buffers of this stream after\n+ * getting this error. If HAL gets another capture request later targeting\n+ * a disconnected stream, HAL must send an ERROR_REQUEST to camera service\n+ * and drop processing that request.\n+ */\n+ CAMERA3_PS_BUF_REQ_STREAM_DISCONNECTED = 3,\n+\n+ /**\n+ * Get buffer failed for unknown reason. This is a fatal error and HAL must\n+ * send ERROR_DEVICE to camera service and be ready to be closed.\n+ */\n+ CAMERA3_PS_BUF_REQ_UNKNOWN_ERROR = 4,\n+\n+ /**\n+ * Number of buffer request status\n+ */\n+ CAMERA3_PS_BUF_REQ_NUM_STATUS\n+} camera3_stream_buffer_req_status_t;\n+\n+typedef struct camera3_buffer_request {\n+ /**\n+ * The stream HAL wants to request buffer from\n+ */\n+ camera3_stream_t *stream;\n+\n+ /**\n+ * The number of buffers HAL requested\n+ */\n+ uint32_t num_buffers_requested;\n+} camera3_buffer_request_t;\n+\n+typedef struct camera3_stream_buffer_ret {\n+ /**\n+ * The stream HAL wants to request buffer from\n+ */\n+ camera3_stream_t *stream;\n+\n+ /**\n+ * The status of buffer request of this stream\n+ */\n+ camera3_stream_buffer_req_status_t status;\n+\n+ /**\n+ * Number of output buffers returned. Must be 0 when above status is not\n+ * CAMERA3_PS_BUF_REQ_OK; otherwise the value must be equal to\n+ * num_buffers_requested in the corresponding camera3_buffer_request_t\n+ */\n+ uint32_t num_output_buffers;\n+\n+ /**\n+ * The returned output buffers for the stream.\n+ * Caller of request_stream_buffers() should supply this with enough memory\n+ * (num_buffers_requested * sizeof(camera3_stream_buffer_t))\n+ */\n+ camera3_stream_buffer_t *output_buffers;\n+} camera3_stream_buffer_ret_t;\n+\n+\n /**********************************************************************\n *\n * Capture request/result definitions for the HAL process_capture_request()\n@@ -2660,6 +2823,65 @@ typedef struct camera3_callback_ops {\n void (*notify)(const struct camera3_callback_ops *,\n const camera3_notify_msg_t *msg);\n \n+ /**\n+ * request_stream_buffers:\n+ *\n+ * <= CAMERA_DEVICE_API_VERISON_3_5:\n+ *\n+ * DO NOT USE: not defined and must be NULL.\n+ *\n+ * >= CAMERA_DEVICE_API_VERISON_3_6:\n+ *\n+ * Synchronous callback for HAL to ask for output buffer from camera service.\n+ *\n+ * This call may be serialized in camera service so it is strongly\n+ * recommended to only call this method from one thread.\n+ *\n+ * When camera device advertises\n+ * (android.info.supportedBufferManagementVersion ==\n+ * ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5), HAL\n+ * can use this method to request buffers from camera service.\n+ *\n+ * Caller is responsible for allocating enough memory for returned_buf_reqs\n+ * argument (num_buffer_reqs * sizeof(camera3_stream_buffer_ret_t)) bytes\n+ * and also the memory for the output_buffers field in each\n+ * camera3_stream_buffer_ret_t\n+ * (num_buffers_requested * sizeof(camera3_stream_buffer_t)) bytes\n+ *\n+ * Performance requirements:\n+ * This is a blocking call that takes more time with more buffers requested.\n+ * HAL should not request large amount of buffers on a latency critical code\n+ * path. It is highly recommended to use a dedicated thread to perform\n+ * all requestStreamBuffer calls, and adjust the thread priority and/or\n+ * timing of making the call in order for buffers to arrive before HAL is\n+ * ready to fill the buffer.\n+ */\n+ camera3_buffer_request_status_t (*request_stream_buffers)(\n+ const struct camera3_callback_ops *,\n+ uint32_t num_buffer_reqs,\n+ const camera3_buffer_request_t *buffer_reqs,\n+ /*out*/uint32_t *num_returned_buf_reqs,\n+ /*out*/camera3_stream_buffer_ret_t *returned_buf_reqs);\n+\n+ /**\n+ * return_stream_buffers:\n+ *\n+ * <= CAMERA_DEVICE_API_VERISON_3_5:\n+ *\n+ * DO NOT USE: not defined and must be NULL.\n+ *\n+ * >= CAMERA_DEVICE_API_VERISON_3_6:\n+ *\n+ * Synchronous callback for HAL to return output buffers to camera service.\n+ *\n+ * If this method is called during a configure_streams() call, it will be\n+ * blocked until camera service finishes the ongoing configure_streams() call.\n+ */\n+ void (*return_stream_buffers)(\n+ const struct camera3_callback_ops *,\n+ uint32_t num_buffers,\n+ const camera3_stream_buffer_t* const* buffers);\n+\n } camera3_callback_ops_t;\n \n /**********************************************************************\n@@ -3238,8 +3460,82 @@ typedef struct camera3_device_ops {\n */\n int (*flush)(const struct camera3_device *);\n \n+ /**\n+ * signal_stream_flush:\n+ *\n+ * <= CAMERA_DEVICE_API_VERISON_3_5:\n+ *\n+ * Not defined and must be NULL\n+ *\n+ * >= CAMERA_DEVICE_API_VERISON_3_6:\n+ *\n+ * Signaling HAL camera service is about to perform configure_streams() call\n+ * and HAL must return all buffers of designated streams. HAL must finish\n+ * inflight requests normally and return all buffers belonging to the\n+ * designated streams through process_capture_result() or\n+ * return_stream_buffers() API in a timely manner, or camera service will run\n+ * into a fatal error.\n+ *\n+ * Note that this call serves as an optional hint and camera service may\n+ * skip calling this if all buffers are already returned.\n+ *\n+ */\n+ void (*signal_stream_flush)(const struct camera3_device*,\n+ uint32_t num_streams,\n+ const camera3_stream_t* const* streams);\n+\n+ /**\n+ * is_reconfiguration_required:\n+ *\n+ * <= CAMERA_DEVICE_API_VERISON_3_5:\n+ *\n+ * Not defined and must be NULL\n+ *\n+ * >= CAMERA_DEVICE_API_VERISON_3_6:\n+ *\n+ * Check whether complete stream reconfiguration is required for possible new session\n+ * parameter values.\n+ *\n+ * This method must be called by the camera framework in case the client changes\n+ * the value of any advertised session parameters. Depending on the specific values\n+ * the HAL can decide whether a complete stream reconfiguration is required. In case\n+ * the HAL returns -ENVAL, the camera framework must skip the internal reconfiguration.\n+ * In case Hal returns 0, the framework must reconfigure the streams and pass the\n+ * new session parameter values accordingly.\n+ * This call may be done by the framework some time before the request with new parameters\n+ * is submitted to the HAL, and the request may be cancelled before it ever gets submitted.\n+ * Therefore, the HAL must not use this query as an indication to change its behavior in any\n+ * way.\n+ * ------------------------------------------------------------------------\n+ *\n+ * Preconditions:\n+ *\n+ * The framework can call this method at any time after active\n+ * session configuration. There must be no impact on the performance of\n+ * pending camera requests in any way. In particular there must not be\n+ * any glitches or delays during normal camera streaming.\n+ *\n+ * Performance requirements:\n+ * HW and SW camera settings must not be changed and there must not be\n+ * a user-visible impact on camera performance.\n+ *\n+ * @param oldSessionParams The currently applied session parameters.\n+ * @param newSessionParams The new session parameters set by client.\n+ *\n+ * @return Status Status code for the operation, one of:\n+ * 0: In case the stream reconfiguration is required\n+ *\n+ * -EINVAL: In case the stream reconfiguration is not required.\n+ *\n+ * -ENOSYS: In case the camera device does not support the\n+ * reconfiguration query.\n+ */\n+ int (*is_reconfiguration_required)(const struct camera3_device*,\n+ const camera_metadata_t* old_session_params,\n+ const camera_metadata_t* new_session_params);\n+\n /* reserved for future use */\n- void *reserved[8];\n+ void *reserved[6];\n } camera3_device_ops_t;\n \n /**********************************************************************\ndiff --git a/include/android/hardware/libhardware/include/hardware/camera_common.h b/include/android/hardware/libhardware/include/hardware/camera_common.h\nindex 5c9bc06fe0..1d4a02a199 100644\n--- a/include/android/hardware/libhardware/include/hardware/camera_common.h\n+++ b/include/android/hardware/libhardware/include/hardware/camera_common.h\n@@ -118,6 +118,22 @@ __BEGIN_DECLS\n * 4. Module initialization method. This will be called by the camera service\n * right after the HAL module is loaded, to allow for one-time initialization\n * of the HAL. It is called before any other module methods are invoked.\n+ *\n+ *******************************************************************************\n+ * Version: 2.5 [CAMERA_MODULE_API_VERSION_2_5]\n+ *\n+ * This camera module version adds below API changes:\n+ *\n+ * 1. Support to query characteristics of a non-standalone physical camera, which can\n+ * only be accessed as part of a logical camera. It also adds camera stream combination\n+ * query.\n+ *\n+ * 2. Ability to query whether a particular camera stream combination is\n+ * supported by the camera device.\n+ *\n+ * 3. Device state change notification. This module version also supports\n+ * notification about the overall device state change, such as\n+ * folding/unfolding, or covering/uncovering of shutter.\n */\n \n /**\n@@ -134,8 +150,9 @@ __BEGIN_DECLS\n #define CAMERA_MODULE_API_VERSION_2_2 HARDWARE_MODULE_API_VERSION(2, 2)\n #define CAMERA_MODULE_API_VERSION_2_3 HARDWARE_MODULE_API_VERSION(2, 3)\n #define CAMERA_MODULE_API_VERSION_2_4 HARDWARE_MODULE_API_VERSION(2, 4)\n+#define CAMERA_MODULE_API_VERSION_2_5 HARDWARE_MODULE_API_VERSION(2, 5)\n \n-#define CAMERA_MODULE_API_VERSION_CURRENT CAMERA_MODULE_API_VERSION_2_4\n+#define CAMERA_MODULE_API_VERSION_CURRENT CAMERA_MODULE_API_VERSION_2_5\n \n /**\n * All device versions <= HARDWARE_DEVICE_API_VERSION(1, 0xFF) must be treated\n@@ -150,6 +167,7 @@ __BEGIN_DECLS\n #define CAMERA_DEVICE_API_VERSION_3_3 HARDWARE_DEVICE_API_VERSION(3, 3)\n #define CAMERA_DEVICE_API_VERSION_3_4 HARDWARE_DEVICE_API_VERSION(3, 4)\n #define CAMERA_DEVICE_API_VERSION_3_5 HARDWARE_DEVICE_API_VERSION(3, 5)\n+#define CAMERA_DEVICE_API_VERSION_3_6 HARDWARE_DEVICE_API_VERSION(3, 6)\n \n // Device version 3.5 is current, older HAL camera device versions are not\n // recommended for new devices.\n@@ -645,6 +663,192 @@ typedef struct camera_module_callbacks {\n \n } camera_module_callbacks_t;\n \n+/**\n+ * camera_stream_t:\n+ *\n+ * A handle to a single camera input or output stream. A stream is defined by\n+ * the framework by its buffer resolution and format and gralloc usage flags.\n+ *\n+ * The stream structures are owned by the framework and pointers to a\n+ * camera_stream passed into the HAL by is_stream_combination_supported() are\n+ * only valid within the scope of the call.\n+ *\n+ * All camera_stream members are immutable.\n+ */\n+typedef struct camera_stream {\n+ /**\n+ * The type of the stream, one of the camera3_stream_type_t values.\n+ */\n+ int stream_type;\n+\n+ /**\n+ * The width in pixels of the buffers in this stream\n+ */\n+ uint32_t width;\n+\n+ /**\n+ * The height in pixels of the buffers in this stream\n+ */\n+ uint32_t height;\n+\n+ /**\n+ * The pixel format for the buffers in this stream. Format is a value from\n+ * the HAL_PIXEL_FORMAT_* list in system/core/include/system/graphics.h, or\n+ * from device-specific headers.\n+ *\n+ * If HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED is used, then the platform\n+ * gralloc module will select a format based on the usage flags provided by\n+ * the camera device and the other endpoint of the stream.\n+ *\n+ */\n+ int format;\n+\n+ /**\n+ * The gralloc usage flags for this stream, as needed by the HAL. The usage\n+ * flags are defined in gralloc.h (GRALLOC_USAGE_*), or in device-specific\n+ * headers.\n+ *\n+ * For output streams, these are the HAL's producer usage flags. For input\n+ * streams, these are the HAL's consumer usage flags. The usage flags from\n+ * the producer and the consumer will be combined together and then passed\n+ * to the platform gralloc HAL module for allocating the gralloc buffers for\n+ * each stream.\n+ *\n+ * The usage flag for an output stream may be bitwise\n+ * combination of usage flags for multiple consumers, for the purpose of\n+ * sharing one camera stream between those consumers. The HAL must fail\n+ * the stream combination query call with -EINVAL if the combined flags cannot be\n+ * supported due to imcompatible buffer format, dataSpace, or other hardware\n+ * limitations.\n+ */\n+ uint32_t usage;\n+\n+ /**\n+ * A field that describes the contents of the buffer. The format and buffer\n+ * dimensions define the memory layout and structure of the stream buffers,\n+ * while dataSpace defines the meaning of the data within the buffer.\n+ *\n+ * For most formats, dataSpace defines the color space of the image data.\n+ * In addition, for some formats, dataSpace indicates whether image- or\n+ * depth-based data is requested. See system/core/include/system/graphics.h\n+ * for details of formats and valid dataSpace values for each format.\n+ *\n+ * Always set by the camera service. The dataspace values are set\n+ * using the V0 dataspace definitions in graphics.h\n+ */\n+ android_dataspace_t data_space;\n+\n+ /**\n+ * The required output rotation of the stream, one of\n+ * the camera3_stream_rotation_t values. This must be inspected by HAL along\n+ * with stream width and height. For example, if the rotation is 90 degree\n+ * and the stream width and height is 720 and 1280 respectively, camera service\n+ * will supply buffers of size 720x1280, and HAL should capture a 1280x720 image\n+ * and rotate the image by 90 degree counterclockwise. The rotation field is\n+ * no-op when the stream type is input. Camera HAL must ignore the rotation\n+ * field for an input stream.\n+ *\n+ * Always set by camera service. HAL must inspect this field during stream\n+ * combination query and return -EINVAL if it cannot perform such rotation.\n+ * HAL must always support CAMERA3_STREAM_ROTATION_0, so a\n+ * is_stream_combination_supported() call must not fail for unsupported rotation if\n+ * rotation field of all streams is CAMERA3_STREAM_ROTATION_0.\n+ *\n+ */\n+ int rotation;\n+\n+ /**\n+ * The physical camera id this stream belongs to.\n+ * Always set by camera service. If the camera device is not a logical\n+ * multi camera, or if the camera is a logical multi camera but the stream\n+ * is not a physical output stream, this field will point to a 0-length\n+ * string.\n+ *\n+ * A logical multi camera is a camera device backed by multiple physical\n+ * cameras that are also exposed to the application. And for a logical\n+ * multi camera, a physical output stream is an output stream specifically\n+ * requested on an underlying physical camera.\n+ *\n+ * For an input stream, this field is guaranteed to be a 0-length string.\n+ */\n+ const char* physical_camera_id;\n+\n+} camera_stream_t;\n+\n+/**\n+ * camera_stream_combination_t:\n+ *\n+ * A structure of stream definitions, used by is_stream_combination_supported(). This\n+ * structure defines all the input & output streams for specific camera use case.\n+ */\n+typedef struct camera_stream_combination {\n+ /**\n+ * The total number of streams by the framework. This includes\n+ * both input and output streams. The number of streams will be at least 1,\n+ * and there will be at least one output-capable stream.\n+ */\n+ uint32_t num_streams;\n+\n+ /**\n+ * An array of camera streams, defining the input/output\n+ * stream combination for the camera HAL device.\n+ *\n+ * At most one input-capable stream may be defined.\n+ *\n+ * At least one output-capable stream must be defined.\n+ */\n+ camera_stream_t *streams;\n+\n+ /**\n+ * The operation mode of streams in this stream combination, one of the value\n+ * defined in camera3_stream_configuration_mode_t.\n+ *\n+ */\n+ uint32_t operation_mode;\n+\n+} camera_stream_combination_t;\n+\n+/**\n+ * device_state_t:\n+ *\n+ * Possible physical states of the overall device, for use with\n+ * notify_device_state_change.\n+ */\n+typedef enum device_state {\n+ /**\n+ * The device is in its normal physical configuration. This is the default if the\n+ * device does not support multiple different states.\n+ */\n+ NORMAL = 0,\n+\n+ /**\n+ * Camera device(s) facing backward are covered.\n+ */\n+ BACK_COVERED = 1 << 0,\n+\n+ /**\n+ * Camera device(s) facing foward are covered.\n+ */\n+ FRONT_COVERED = 1 << 1,\n+\n+ /**\n+ * The device is folded. If not set, the device is unfolded or does not\n+ * support folding.\n+ *\n+ * The exact point when this status change happens during the folding\n+ * operation is device-specific.\n+ */\n+ FOLDED = 1 << 2,\n+\n+ /**\n+ * First vendor-specific device state. All bits above and including this one\n+ * are for vendor state values. Values below this one must only be used\n+ * for framework-defined states.\n+ */\n+ VENDOR_STATE_START = 1LL << 32\n+\n+} device_state_t;\n+\n typedef struct camera_module {\n /**\n * Common methods of the camera module. This *must* be the first member of\n@@ -910,8 +1114,104 @@ typedef struct camera_module {\n */\n int (*init)();\n \n+ /**\n+ * get_physical_camera_info:\n+ *\n+ * Return the static metadata for a physical camera as a part of a logical\n+ * camera device. This function is only called for those physical camera\n+ * ID(s) that are not exposed independently. In other words, camera_id will\n+ * be greater or equal to the return value of get_number_of_cameras().\n+ *\n+ * Return values:\n+ *\n+ * 0: On a successful operation\n+ *\n+ * -ENODEV: The information cannot be provided due to an internal\n+ * error.\n+ *\n+ * -EINVAL: The input arguments are invalid, i.e. the id is invalid,\n+ * and/or the module is invalid.\n+ *\n+ * Version information (based on camera_module_t.common.module_api_version):\n+ *\n+ * CAMERA_MODULE_API_VERSION_1_x/2_0/2_1/2_2/2_3/2_4:\n+ * Not provided by HAL module. Framework will not call this function.\n+ *\n+ * CAMERA_MODULE_API_VERSION_2_5 or higher:\n+ * If any of the camera devices accessible through this camera module is\n+ * a logical multi-camera, and at least one of the physical cameras isn't\n+ * a stand-alone camera device, this function will be called by the camera\n+ * framework. Calling this function with invalid physical_camera_id will\n+ * get -EINVAL, and NULL static_metadata.\n+ */\n+ int (*get_physical_camera_info)(int physical_camera_id,\n+ camera_metadata_t **static_metadata);\n+\n+ /**\n+ * is_stream_combination_supported:\n+ *\n+ * Check for device support of specific camera stream combination.\n+ *\n+ * Return values:\n+ *\n+ * 0: In case the stream combination is supported.\n+ *\n+ * -EINVAL: In case the stream combination is not supported.\n+ *\n+ * -ENOSYS: In case stream combination query is not supported.\n+ *\n+ * Version information (based on camera_module_t.common.module_api_version):\n+ *\n+ * CAMERA_MODULE_API_VERSION_1_x/2_0/2_1/2_2/2_3/2_4:\n+ * Not provided by HAL module. Framework will not call this function.\n+ *\n+ * CAMERA_MODULE_API_VERSION_2_5 or higher:\n+ * Valid to be called by the framework.\n+ */\n+ int (*is_stream_combination_supported)(int camera_id,\n+ const camera_stream_combination_t *streams);\n+\n+ /**\n+ * notify_device_state_change:\n+ *\n+ * Notify the camera module that the state of the overall device has\n+ * changed in some way that the HAL may want to know about.\n+ *\n+ * For example, a physical shutter may have been uncovered or covered,\n+ * or a camera may have been covered or uncovered by an add-on keyboard\n+ * or other accessory.\n+ *\n+ * The state is a bitfield of potential states, and some physical configurations\n+ * could plausibly correspond to multiple different combinations of state bits.\n+ * The HAL must ignore any state bits it is not actively using to determine\n+ * the appropriate camera configuration.\n+ *\n+ * For example, on some devices the FOLDED state could mean that\n+ * backward-facing cameras are covered by the fold, so FOLDED by itself implies\n+ * BACK_COVERED. But other devices may support folding but not cover any cameras\n+ * when folded, so for those FOLDED would not imply any of the other flags.\n+ * Since these relationships are very device-specific, it is difficult to specify\n+ * a comprehensive policy. But as a recommendation, it is suggested that if a flag\n+ * necessarily implies other flags are set as well, then those flags should be set.\n+ * So even though FOLDED would be enough to infer BACK_COVERED on some devices, the\n+ * BACK_COVERED flag should also be set for clarity.\n+ *\n+ * This method may be invoked by the HAL client at any time. It must not\n+ * cause any active camera device sessions to be closed, but may dynamically\n+ * change which physical camera a logical multi-camera is using for its\n+ * active and future output.\n+ *\n+ * The method must be invoked by the HAL client at least once before the\n+ * client calls ICameraDevice::open on any camera device interfaces listed\n+ * by this provider, to establish the initial device state.\n+ *\n+ * Note that the deviceState is 64-bit bitmask, with system defined states in\n+ * lower 32-bit and vendor defined states in upper 32-bit.\n+ */\n+ void (*notify_device_state_change)(uint64_t deviceState);\n+\n /* reserved for future use */\n- void* reserved[5];\n+ void* reserved[2];\n } camera_module_t;\n \n __END_DECLS\ndiff --git a/include/android/hardware/libhardware/include/hardware/gralloc.h b/include/android/hardware/libhardware/include/hardware/gralloc.h\nindex 01a7672747..2c5514b8ec 100644\n--- a/include/android/hardware/libhardware/include/hardware/gralloc.h\n+++ b/include/android/hardware/libhardware/include/hardware/gralloc.h\n@@ -19,8 +19,8 @@\n #ifndef ANDROID_GRALLOC_INTERFACE_H\n #define ANDROID_GRALLOC_INTERFACE_H\n \n-#include \n #include \n+#include \n \n #include \n #include \n@@ -28,8 +28,8 @@\n \n #include \n \n-#include \n #include \n+#include \n \n __BEGIN_DECLS\n \n@@ -132,6 +132,9 @@ enum {\n * handle this flag. */\n GRALLOC_USAGE_FOREIGN_BUFFERS = 0x00200000U,\n \n+ /* buffer will be used as input to HW HEIC image encoder */\n+ GRALLOC_USAGE_HW_IMAGE_ENCODER = 0x08000000U,\n+\n /* Mask of all flags which could be passed to a gralloc module for buffer\n * allocation. Any flags not in this mask do not need to be handled by\n * gralloc modules. */\n@@ -154,20 +157,20 @@ enum {\n */\n typedef struct gralloc_module_t {\n struct hw_module_t common;\n- \n+\n /*\n * (*registerBuffer)() must be called before a buffer_handle_t that has not\n * been created with (*alloc_device_t::alloc)() can be used.\n- * \n+ *\n * This is intended to be used with buffer_handle_t's that have been\n * received in this process through IPC.\n- * \n+ *\n * This function checks that the handle is indeed a valid one and prepares\n * it for use with (*lock)() and (*unlock)().\n- * \n- * It is not necessary to call (*registerBuffer)() on a handle created \n+ *\n+ * It is not necessary to call (*registerBuffer)() on a handle created\n * with (*alloc_device_t::alloc)().\n- * \n+ *\n * returns an error if this buffer_handle_t is not valid.\n */\n int (*registerBuffer)(struct gralloc_module_t const* module,\n@@ -177,25 +180,25 @@ typedef struct gralloc_module_t {\n * (*unregisterBuffer)() is called once this handle is no longer needed in\n * this process. After this call, it is an error to call (*lock)(),\n * (*unlock)(), or (*registerBuffer)().\n- * \n+ *\n * This function doesn't close or free the handle itself; this is done\n * by other means, usually through libcutils's native_handle_close() and\n- * native_handle_free(). \n- * \n+ * native_handle_free().\n+ *\n * It is an error to call (*unregisterBuffer)() on a buffer that wasn't\n * explicitly registered first.\n */\n int (*unregisterBuffer)(struct gralloc_module_t const* module,\n buffer_handle_t handle);\n- \n+\n /*\n- * The (*lock)() method is called before a buffer is accessed for the \n+ * The (*lock)() method is called before a buffer is accessed for the\n * specified usage. This call may block, for instance if the h/w needs\n * to finish rendering or if CPU caches need to be synchronized.\n- * \n- * The caller promises to modify only pixels in the area specified \n+ *\n+ * The caller promises to modify only pixels in the area specified\n * by (l,t,w,h).\n- * \n+ *\n * The content of the buffer outside of the specified area is NOT modified\n * by this call.\n *\n@@ -208,9 +211,9 @@ typedef struct gralloc_module_t {\n *\n * THREADING CONSIDERATIONS:\n *\n- * It is legal for several different threads to lock a buffer from \n+ * It is legal for several different threads to lock a buffer from\n * read access, none of the threads are blocked.\n- * \n+ *\n * However, locking a buffer simultaneously for write or read/write is\n * undefined, but:\n * - shall not result in termination of the process\n@@ -219,21 +222,21 @@ typedef struct gralloc_module_t {\n * into an indeterminate state.\n *\n * If the buffer was created with a usage mask incompatible with the\n- * requested usage flags here, -EINVAL is returned. \n- * \n+ * requested usage flags here, -EINVAL is returned.\n+ *\n */\n- \n+\n int (*lock)(struct gralloc_module_t const* module,\n buffer_handle_t handle, int usage,\n int l, int t, int w, int h,\n void** vaddr);\n \n- \n+\n /*\n * The (*unlock)() method must be called after all changes to the buffer\n * are completed.\n */\n- \n+\n int (*unlock)(struct gralloc_module_t const* module,\n buffer_handle_t handle);\n \n@@ -312,8 +315,38 @@ typedef struct gralloc_module_t {\n int l, int t, int w, int h,\n struct android_ycbcr *ycbcr, int fenceFd);\n \n+ /* getTransportSize(..., outNumFds, outNumInts)\n+ * This function is mandatory on devices running IMapper2.1 or higher.\n+ *\n+ * Get the transport size of a buffer. An imported buffer handle is a raw\n+ * buffer handle with the process-local runtime data appended. This\n+ * function, for example, allows a caller to omit the process-local\n+ * runtime data at the tail when serializing the imported buffer handle.\n+ *\n+ * Note that a client might or might not omit the process-local runtime\n+ * data when sending an imported buffer handle. The mapper must support\n+ * both cases on the receiving end.\n+ */\n+ int32_t (*getTransportSize)(\n+ struct gralloc_module_t const* module, buffer_handle_t handle, uint32_t *outNumFds,\n+ uint32_t *outNumInts);\n+\n+ /* validateBufferSize(..., w, h, format, usage, stride)\n+ * This function is mandatory on devices running IMapper2.1 or higher.\n+ *\n+ * Validate that the buffer can be safely accessed by a caller who assumes\n+ * the specified width, height, format, usage, and stride. This must at least validate\n+ * that the buffer size is large enough. Validating the buffer against\n+ * individual buffer attributes is optional.\n+ */\n+ int32_t (*validateBufferSize)(\n+ struct gralloc_module_t const* device, buffer_handle_t handle,\n+ uint32_t w, uint32_t h, int32_t format, int usage,\n+ uint32_t stride);\n+\n /* reserved for future use */\n- void* reserved_proc[3];\n+ void* reserved_proc[1];\n+\n } gralloc_module_t;\n \n /*****************************************************************************/\n@@ -326,32 +359,32 @@ typedef struct gralloc_module_t {\n typedef struct alloc_device_t {\n struct hw_device_t common;\n \n- /* \n+ /*\n * (*alloc)() Allocates a buffer in graphic memory with the requested\n * parameters and returns a buffer_handle_t and the stride in pixels to\n * allow the implementation to satisfy hardware constraints on the width\n- * of a pixmap (eg: it may have to be multiple of 8 pixels). \n+ * of a pixmap (eg: it may have to be multiple of 8 pixels).\n * The CALLER TAKES OWNERSHIP of the buffer_handle_t.\n *\n * If format is HAL_PIXEL_FORMAT_YCbCr_420_888, the returned stride must be\n * 0, since the actual strides are available from the android_ycbcr\n * structure.\n- * \n+ *\n * Returns 0 on success or -errno on error.\n */\n- \n+\n int (*alloc)(struct alloc_device_t* dev,\n int w, int h, int format, int usage,\n buffer_handle_t* handle, int* stride);\n \n /*\n- * (*free)() Frees a previously allocated buffer. \n+ * (*free)() Frees a previously allocated buffer.\n * Behavior is undefined if the buffer is still mapped in any process,\n * but shall not result in termination of the program or security breaches\n * (allowing a process to get access to another process' buffers).\n * THIS FUNCTION TAKES OWNERSHIP of the buffer_handle_t which becomes\n- * invalid after the call. \n- * \n+ * invalid after the call.\n+ *\n * Returns 0 on success or -errno on error.\n */\n int (*free)(struct alloc_device_t* dev,\n@@ -369,9 +402,9 @@ typedef struct alloc_device_t {\n \n /** convenience API for opening and closing a supported device */\n \n-static inline int gralloc_open(const struct hw_module_t* module, \n+static inline int gralloc_open(const struct hw_module_t* module,\n struct alloc_device_t** device) {\n- return module->methods->open(module, \n+ return module->methods->open(module,\n GRALLOC_HARDWARE_GPU0, TO_HW_DEVICE_T_OPEN(device));\n }\n \ndiff --git a/include/android/metadata/camera_metadata_hidden.h b/include/android/metadata/camera_metadata_hidden.h\nindex 91b11e4346..5629f7981b 100644\n--- a/include/android/metadata/camera_metadata_hidden.h\n+++ b/include/android/metadata/camera_metadata_hidden.h\n@@ -18,6 +18,9 @@\n #ifndef SYSTEM_MEDIA_PRIVATE_INCLUDE_CAMERA_METADATA_HIDDEN_H\n #define SYSTEM_MEDIA_PRIVATE_INCLUDE_CAMERA_METADATA_HIDDEN_H\n \n+#include \n+#include \n+#include \n #include \n \n /**\n@@ -35,14 +38,6 @@ extern \"C\" {\n #endif\n /** **These are private functions for use only by the camera framework.** **/\n \n-/**\n- * Set the global vendor tag operations object used to define vendor tag\n- * structure when parsing camera metadata with functions defined in\n- * system/media/camera/include/camera_metadata.h.\n- */\n-ANDROID_API\n-int set_camera_metadata_vendor_ops(const vendor_tag_ops_t *query_ops);\n-\n /**\n * Set the global vendor tag cache operations object used to define vendor tag\n * structure when parsing camera metadata with functions defined in\ndiff --git a/include/android/metadata/system/camera_metadata.h b/include/android/metadata/system/camera_metadata.h\nindex 1672b09ee9..44c836144f 100644\n--- a/include/android/metadata/system/camera_metadata.h\n+++ b/include/android/metadata/system/camera_metadata.h\n@@ -18,13 +18,13 @@\n #ifndef SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_METADATA_H\n #define SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_METADATA_H\n \n+#include \n #include \n #include \n #include \n+#include \n \n-#ifdef __cplusplus\n-extern \"C\" {\n-#endif\n+__BEGIN_DECLS\n \n /**\n * Tag hierarchy and enum definitions for camera_metadata_entry\n@@ -287,7 +287,7 @@ enum {\n };\n \n /**\n- * Validate that a metadata is structurally sane. That is, its internal\n+ * Validate that a metadata is structurally correct. That is, its internal\n * state is such that we won't get buffer overflows or run into other\n * 'impossible' issues when calling the other API functions.\n *\n@@ -481,6 +481,12 @@ ANDROID_API\n int get_local_camera_metadata_tag_type(uint32_t tag,\n const camera_metadata_t *meta);\n \n+/**\n+ * Retrieve all tags that need permission.\n+ */\n+ANDROID_API\n+const int32_t *get_camera_metadata_permission_needed(uint32_t *tag_count);\n+\n /**\n * Set up vendor-specific tag query methods. These are needed to properly add\n * entries with vendor-specified tags and to use the\n@@ -574,8 +580,29 @@ int camera_metadata_enum_snprint(uint32_t tag,\n char *dst,\n size_t size);\n \n-#ifdef __cplusplus\n-}\n-#endif\n+/**\n+ * Retrieves back the binary value of a given tag enum entry name. Only works for enum tags.\n+ * Returns 0 on success, -1 on failure.\n+ */\n+ANDROID_API\n+int camera_metadata_enum_value(uint32_t tag /*in*/,\n+ const char* name /*in*/,\n+ size_t size /*in*/,\n+ uint32_t *value /*out*/);\n+\n+/**\n+ * Set the global vendor tag operations object used to define vendor tag\n+ * structure when parsing camera metadata with functions defined in\n+ * system/media/camera/include/camera_metadata.h.\n+ *\n+ * Note: this is moved from system/media/private/camera/include/camera_metadata_hidden.h.\n+ * Every process that needs to read or write vendor tags has to call this method before\n+ * attempting to use them. The OS will handle standard app and system service processes,\n+ * but OEMs may need to invoke this method in HALs that process camera data.\n+ */\n+ANDROID_API\n+int set_camera_metadata_vendor_ops(const vendor_tag_ops_t *query_ops);\n+\n+__END_DECLS\n \n #endif\ndiff --git a/include/android/metadata/system/camera_metadata_tags.h b/include/android/metadata/system/camera_metadata_tags.h\nindex e0f2f5a37a..af6d5258ae 100644\n--- a/include/android/metadata/system/camera_metadata_tags.h\n+++ b/include/android/metadata/system/camera_metadata_tags.h\n@@ -64,6 +64,14 @@ typedef enum camera_metadata_section {\n ANDROID_DEPTH,\n ANDROID_LOGICAL_MULTI_CAMERA,\n ANDROID_DISTORTION_CORRECTION,\n+ ANDROID_HEIC,\n+ ANDROID_HEIC_INFO,\n+ ANDROID_AUTOMOTIVE,\n+ ANDROID_AUTOMOTIVE_LENS,\n+ ANDROID_EXTENSION,\n+ ANDROID_JPEGR,\n+ ANDROID_SHARED_SESSION,\n+ ANDROID_DESKTOP_EFFECTS,\n ANDROID_SECTION_COUNT,\n \n VENDOR_SECTION = 0x8000\n@@ -106,6 +114,14 @@ typedef enum camera_metadata_section_start {\n ANDROID_DISTORTION_CORRECTION_START\n = ANDROID_DISTORTION_CORRECTION\n << 16,\n+ ANDROID_HEIC_START = ANDROID_HEIC << 16,\n+ ANDROID_HEIC_INFO_START = ANDROID_HEIC_INFO << 16,\n+ ANDROID_AUTOMOTIVE_START = ANDROID_AUTOMOTIVE << 16,\n+ ANDROID_AUTOMOTIVE_LENS_START = ANDROID_AUTOMOTIVE_LENS << 16,\n+ ANDROID_EXTENSION_START = ANDROID_EXTENSION << 16,\n+ ANDROID_JPEGR_START = ANDROID_JPEGR << 16,\n+ ANDROID_SHARED_SESSION_START = ANDROID_SHARED_SESSION << 16,\n+ ANDROID_DESKTOP_EFFECTS_START = ANDROID_DESKTOP_EFFECTS << 16,\n VENDOR_SECTION_START = VENDOR_SECTION << 16\n } camera_metadata_section_start_t;\n \n@@ -123,6 +139,10 @@ typedef enum camera_metadata_tag {\n ANDROID_COLOR_CORRECTION_ABERRATION_MODE, // enum | public | HIDL v3.2\n ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,\n // byte[] | public | HIDL v3.2\n+ ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE, // int32 | public | HIDL v3.11\n+ ANDROID_COLOR_CORRECTION_COLOR_TINT, // int32 | public | HIDL v3.11\n+ ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE_RANGE, // int32[] | public | HIDL v3.11\n+ ANDROID_COLOR_CORRECTION_AVAILABLE_MODES, // byte[] | public | HIDL v3.11\n ANDROID_COLOR_CORRECTION_END,\n \n ANDROID_CONTROL_AE_ANTIBANDING_MODE = // enum | public | HIDL v3.2\n@@ -171,6 +191,30 @@ typedef enum camera_metadata_tag {\n ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST, // int32 | public | HIDL v3.2\n ANDROID_CONTROL_ENABLE_ZSL, // enum | public | HIDL v3.2\n ANDROID_CONTROL_AF_SCENE_CHANGE, // enum | public | HIDL v3.3\n+ ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES,\n+ // int32[] | ndk_public | HIDL v3.5\n+ ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES,\n+ // float[] | ndk_public | HIDL v3.5\n+ ANDROID_CONTROL_EXTENDED_SCENE_MODE, // enum | public | HIDL v3.5\n+ ANDROID_CONTROL_ZOOM_RATIO_RANGE, // float[] | public | HIDL v3.5\n+ ANDROID_CONTROL_ZOOM_RATIO, // float | public | HIDL v3.5\n+ ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION,\n+ // int32[] | hidden | HIDL v3.6\n+ ANDROID_CONTROL_AF_REGIONS_SET, // enum | fwk_only\n+ ANDROID_CONTROL_AE_REGIONS_SET, // enum | fwk_only\n+ ANDROID_CONTROL_AWB_REGIONS_SET, // enum | fwk_only\n+ ANDROID_CONTROL_SETTINGS_OVERRIDE, // enum | public | HIDL v3.9\n+ ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES, // int32[] | public | HIDL v3.9\n+ ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER, // int32 | system | HIDL v3.9\n+ ANDROID_CONTROL_AUTOFRAMING, // enum | public | HIDL v3.9\n+ ANDROID_CONTROL_AUTOFRAMING_AVAILABLE, // enum | public | HIDL v3.9\n+ ANDROID_CONTROL_AUTOFRAMING_STATE, // enum | public | HIDL v3.9\n+ ANDROID_CONTROL_LOW_LIGHT_BOOST_INFO_LUMINANCE_RANGE,\n+ // float[] | public | HIDL v3.10\n+ ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE, // enum | public | HIDL v3.10\n+ ANDROID_CONTROL_ZOOM_METHOD, // enum | fwk_public\n+ ANDROID_CONTROL_AE_PRIORITY_MODE, // enum | public | HIDL v3.11\n+ ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES, // byte[] | public | HIDL v3.11\n ANDROID_CONTROL_END,\n \n ANDROID_DEMOSAIC_MODE = // enum | system | HIDL v3.2\n@@ -190,11 +234,18 @@ typedef enum camera_metadata_tag {\n ANDROID_FLASH_COLOR_TEMPERATURE, // byte | system | HIDL v3.2\n ANDROID_FLASH_MAX_ENERGY, // byte | system | HIDL v3.2\n ANDROID_FLASH_STATE, // enum | public | HIDL v3.2\n+ ANDROID_FLASH_STRENGTH_LEVEL, // int32 | public | HIDL v3.10\n+ ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL, // int32 | public | HIDL v3.10\n+ ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL, // int32 | public | HIDL v3.10\n+ ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL, // int32 | public | HIDL v3.10\n+ ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL, // int32 | public | HIDL v3.10\n ANDROID_FLASH_END,\n \n ANDROID_FLASH_INFO_AVAILABLE = // enum | public | HIDL v3.2\n ANDROID_FLASH_INFO_START,\n ANDROID_FLASH_INFO_CHARGE_DURATION, // int64 | system | HIDL v3.2\n+ ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL, // int32 | public | HIDL v3.8\n+ ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL, // int32 | public | HIDL v3.8\n ANDROID_FLASH_INFO_END,\n \n ANDROID_HOT_PIXEL_MODE = // enum | public | HIDL v3.2\n@@ -230,6 +281,9 @@ typedef enum camera_metadata_tag {\n ANDROID_LENS_RADIAL_DISTORTION, // float[] | public | HIDL v3.2\n ANDROID_LENS_POSE_REFERENCE, // enum | public | HIDL v3.3\n ANDROID_LENS_DISTORTION, // float[] | public | HIDL v3.3\n+ ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION, // float[] | public | HIDL v3.6\n+ ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION,\n+ // float[] | public | HIDL v3.6\n ANDROID_LENS_END,\n \n ANDROID_LENS_INFO_AVAILABLE_APERTURES = // float[] | public | HIDL v3.2\n@@ -277,7 +331,15 @@ typedef enum camera_metadata_tag {\n ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, // int32[] | ndk_public | HIDL v3.2\n ANDROID_REQUEST_AVAILABLE_SESSION_KEYS, // int32[] | ndk_public | HIDL v3.3\n ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS,\n- // int32[] | hidden | HIDL v3.3\n+ // int32[] | ndk_public | HIDL v3.3\n+ ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION,\n+ // int32[] | hidden | HIDL v3.4\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP,\n+ // enum[] | ndk_public | HIDL v3.8\n+ ANDROID_REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE,\n+ // int64 | java_public | HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP,\n+ // enum[] | ndk_public | HIDL v3.9\n ANDROID_REQUEST_END,\n \n ANDROID_SCALER_CROP_REGION = // int32[] | public | HIDL v3.2\n@@ -295,6 +357,29 @@ typedef enum camera_metadata_tag {\n ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, // int64[] | ndk_public | HIDL v3.2\n ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, // int64[] | ndk_public | HIDL v3.2\n ANDROID_SCALER_CROPPING_TYPE, // enum | public | HIDL v3.2\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS,\n+ // enum[] | ndk_public | HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP,\n+ // int32 | ndk_public | HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES, // byte[] | public | HIDL v3.5\n+ ANDROID_SCALER_ROTATE_AND_CROP, // enum | public | HIDL v3.5\n+ ANDROID_SCALER_DEFAULT_SECURE_IMAGE_SIZE, // int32[] | public | HIDL v3.6\n+ ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS,\n+ // enum[] | ndk_public | HIDL v3.6\n+ ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,\n+ // enum[] | ndk_public | HIDL v3.6\n+ ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.6\n+ ANDROID_SCALER_AVAILABLE_STALL_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.6\n+ ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION,\n+ // int32 | hidden | HIDL v3.6\n+ ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED, // enum | ndk_public | HIDL v3.6\n+ ANDROID_SCALER_CROP_REGION_SET, // enum | fwk_only\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES, // enum[] | public | HIDL v3.8\n+ ANDROID_SCALER_RAW_CROP_REGION, // int32[] | public | HIDL v3.9\n+ ANDROID_SCALER_CONCURRENT_MULTI_RESOLUTION_FORMATS,\n+ // int32[] | ndk_public | HIDL v3.12\n ANDROID_SCALER_END,\n \n ANDROID_SENSOR_EXPOSURE_TIME = // int64 | public | HIDL v3.2\n@@ -329,6 +414,10 @@ typedef enum camera_metadata_tag {\n ANDROID_SENSOR_DYNAMIC_BLACK_LEVEL, // float[] | public | HIDL v3.2\n ANDROID_SENSOR_DYNAMIC_WHITE_LEVEL, // int32 | public | HIDL v3.2\n ANDROID_SENSOR_OPAQUE_RAW_SIZE, // int32[] | system | HIDL v3.2\n+ ANDROID_SENSOR_OPAQUE_RAW_SIZE_MAXIMUM_RESOLUTION,// int32[] | system | HIDL v3.6\n+ ANDROID_SENSOR_PIXEL_MODE, // enum | public | HIDL v3.6\n+ ANDROID_SENSOR_RAW_BINNING_FACTOR_USED, // enum | public | HIDL v3.6\n+ ANDROID_SENSOR_READOUT_TIMESTAMP, // enum | java_public | HIDL v3.8\n ANDROID_SENSOR_END,\n \n ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE = // int32[] | public | HIDL v3.2\n@@ -344,6 +433,13 @@ typedef enum camera_metadata_tag {\n ANDROID_SENSOR_INFO_LENS_SHADING_APPLIED, // enum | public | HIDL v3.2\n ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE,\n // int32[] | public | HIDL v3.2\n+ ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION,\n+ // int32[] | public | HIDL v3.6\n+ ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION,\n+ // int32[] | public | HIDL v3.6\n+ ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION,\n+ // int32[] | public | HIDL v3.6\n+ ANDROID_SENSOR_INFO_BINNING_FACTOR, // int32[] | public | HIDL v3.6\n ANDROID_SENSOR_INFO_END,\n \n ANDROID_SHADING_MODE = // enum | public | HIDL v3.2\n@@ -374,9 +470,11 @@ typedef enum camera_metadata_tag {\n ANDROID_STATISTICS_OIS_TIMESTAMPS, // int64[] | ndk_public | HIDL v3.3\n ANDROID_STATISTICS_OIS_X_SHIFTS, // float[] | ndk_public | HIDL v3.3\n ANDROID_STATISTICS_OIS_Y_SHIFTS, // float[] | ndk_public | HIDL v3.3\n+ ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS, // int64[] | ndk_public | HIDL v3.10\n+ ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES, // float[] | ndk_public | HIDL v3.10\n ANDROID_STATISTICS_END,\n \n- ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES = \n+ ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES =\n // byte[] | public | HIDL v3.2\n ANDROID_STATISTICS_INFO_START,\n ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, // int32 | system | HIDL v3.2\n@@ -410,6 +508,11 @@ typedef enum camera_metadata_tag {\n ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL = // enum | public | HIDL v3.2\n ANDROID_INFO_START,\n ANDROID_INFO_VERSION, // byte | public | HIDL v3.3\n+ ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, // enum | system | HIDL v3.4\n+ ANDROID_INFO_DEVICE_STATE_ORIENTATIONS, // int64[] | ndk_public | HIDL v3.7\n+ ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION, // enum | fwk_java_public\n+ ANDROID_INFO_DEVICE_ID, // int32 | fwk_only\n+ ANDROID_INFO_DEVICE_TYPE, // enum | public | HIDL v3.12\n ANDROID_INFO_END,\n \n ANDROID_BLACK_LEVEL_LOCK = // enum | public | HIDL v3.2\n@@ -433,11 +536,35 @@ typedef enum camera_metadata_tag {\n ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS,// int64[] | ndk_public | HIDL v3.2\n ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, // int64[] | ndk_public | HIDL v3.2\n ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE, // enum | public | HIDL v3.2\n+ ANDROID_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS,\n+ // int32[] | ndk_public | HIDL v3.4\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS,\n+ // enum[] | ndk_public | HIDL v3.4\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS,\n+ // int64[] | ndk_public | HIDL v3.4\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS,\n+ // int64[] | ndk_public | HIDL v3.4\n+ ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,\n+ // enum[] | ndk_public | HIDL v3.6\n+ ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.6\n+ ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.6\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,\n+ // enum[] | ndk_public | HIDL v3.6\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.6\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.6\n ANDROID_DEPTH_END,\n \n- ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS = // byte[] | hidden | HIDL v3.3\n+ ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS = // byte[] | ndk_public | HIDL v3.3\n ANDROID_LOGICAL_MULTI_CAMERA_START,\n ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE, // enum | public | HIDL v3.3\n+ ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID, // byte | public | HIDL v3.4\n+ ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION,\n+ // int32[] | public | HIDL v3.10\n+ ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS, // enum | public | HIDL v3.12\n ANDROID_LOGICAL_MULTI_CAMERA_END,\n \n ANDROID_DISTORTION_CORRECTION_MODE = // enum | public | HIDL v3.3\n@@ -445,6 +572,78 @@ typedef enum camera_metadata_tag {\n ANDROID_DISTORTION_CORRECTION_AVAILABLE_MODES, // byte[] | public | HIDL v3.3\n ANDROID_DISTORTION_CORRECTION_END,\n \n+ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS =\n+ // enum[] | ndk_public | HIDL v3.4\n+ ANDROID_HEIC_START,\n+ ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS, // int64[] | ndk_public | HIDL v3.4\n+ ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS, // int64[] | ndk_public | HIDL v3.4\n+ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,\n+ // enum[] | ndk_public | HIDL v3.6\n+ ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.6\n+ ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.6\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS,\n+ // enum[] | ndk_public | HIDL v3.11\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS,\n+ // int64[] | ndk_public | HIDL v3.11\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS,\n+ // int64[] | ndk_public | HIDL v3.11\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,\n+ // enum[] | ndk_public | HIDL v3.11\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.11\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.11\n+ ANDROID_HEIC_END,\n+\n+ ANDROID_HEIC_INFO_SUPPORTED = // enum | system | HIDL v3.4\n+ ANDROID_HEIC_INFO_START,\n+ ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT, // byte | system | HIDL v3.4\n+ ANDROID_HEIC_INFO_END,\n+\n+ ANDROID_AUTOMOTIVE_LOCATION = // enum | public | HIDL v3.8\n+ ANDROID_AUTOMOTIVE_START,\n+ ANDROID_AUTOMOTIVE_END,\n+\n+ ANDROID_AUTOMOTIVE_LENS_FACING = // enum[] | public | HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_START,\n+ ANDROID_AUTOMOTIVE_LENS_END,\n+\n+ ANDROID_EXTENSION_STRENGTH = // int32 | extension_passthrough | HIDL v3.9\n+ ANDROID_EXTENSION_START,\n+ ANDROID_EXTENSION_CURRENT_TYPE, // int32 | fwk_java_public\n+ ANDROID_EXTENSION_NIGHT_MODE_INDICATOR, // enum | public | HIDL v3.11\n+ ANDROID_EXTENSION_END,\n+\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS =\n+ // enum[] | ndk_public | HIDL v3.9\n+ ANDROID_JPEGR_START,\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS,\n+ // int64[] | ndk_public | HIDL v3.9\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS, // int64[] | ndk_public | HIDL v3.9\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION,\n+ // enum[] | ndk_public | HIDL v3.9\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.9\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS_MAXIMUM_RESOLUTION,\n+ // int64[] | ndk_public | HIDL v3.9\n+ ANDROID_JPEGR_END,\n+\n+ ANDROID_SHARED_SESSION_COLOR_SPACE = // enum | fwk_only\n+ ANDROID_SHARED_SESSION_START,\n+ ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS, // int64[] | fwk_only\n+ ANDROID_SHARED_SESSION_END,\n+\n+ ANDROID_DESKTOP_EFFECTS_CAPABILITIES = // enum[] | system | HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_START,\n+ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODES, // byte[] | system | HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE, // enum | system | HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE, // enum | system | HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_STRENGTH, // byte | system | HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE, // enum | system | HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_END,\n+\n } camera_metadata_tag_t;\n \n /**\n@@ -456,6 +655,7 @@ typedef enum camera_metadata_enum_android_color_correction_mode {\n ANDROID_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX , // HIDL v3.2\n ANDROID_COLOR_CORRECTION_MODE_FAST , // HIDL v3.2\n ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY , // HIDL v3.2\n+ ANDROID_COLOR_CORRECTION_MODE_CCT , // HIDL v3.11\n } camera_metadata_enum_android_color_correction_mode_t;\n \n // ANDROID_COLOR_CORRECTION_ABERRATION_MODE\n@@ -488,6 +688,7 @@ typedef enum camera_metadata_enum_android_control_ae_mode {\n ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH , // HIDL v3.2\n ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE , // HIDL v3.2\n ANDROID_CONTROL_AE_MODE_ON_EXTERNAL_FLASH , // HIDL v3.3\n+ ANDROID_CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY , // HIDL v3.10\n } camera_metadata_enum_android_control_ae_mode_t;\n \n // ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER\n@@ -564,6 +765,7 @@ typedef enum camera_metadata_enum_android_control_mode {\n ANDROID_CONTROL_MODE_AUTO , // HIDL v3.2\n ANDROID_CONTROL_MODE_USE_SCENE_MODE , // HIDL v3.2\n ANDROID_CONTROL_MODE_OFF_KEEP_STATE , // HIDL v3.2\n+ ANDROID_CONTROL_MODE_USE_EXTENDED_SCENE_MODE , // HIDL v3.5\n } camera_metadata_enum_android_control_mode_t;\n \n // ANDROID_CONTROL_SCENE_MODE\n@@ -596,6 +798,7 @@ typedef enum camera_metadata_enum_android_control_scene_mode {\n typedef enum camera_metadata_enum_android_control_video_stabilization_mode {\n ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF , // HIDL v3.2\n ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON , // HIDL v3.2\n+ ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION , // HIDL v3.8\n } camera_metadata_enum_android_control_video_stabilization_mode_t;\n \n // ANDROID_CONTROL_AE_STATE\n@@ -651,6 +854,78 @@ typedef enum camera_metadata_enum_android_control_af_scene_change {\n ANDROID_CONTROL_AF_SCENE_CHANGE_DETECTED , // HIDL v3.3\n } camera_metadata_enum_android_control_af_scene_change_t;\n \n+// ANDROID_CONTROL_EXTENDED_SCENE_MODE\n+typedef enum camera_metadata_enum_android_control_extended_scene_mode {\n+ ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED = 0, // HIDL v3.5\n+ ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_STILL_CAPTURE , // HIDL v3.5\n+ ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS , // HIDL v3.5\n+ ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START = 0x40, // HIDL v3.5\n+} camera_metadata_enum_android_control_extended_scene_mode_t;\n+\n+// ANDROID_CONTROL_AF_REGIONS_SET\n+typedef enum camera_metadata_enum_android_control_af_regions_set {\n+ ANDROID_CONTROL_AF_REGIONS_SET_FALSE ,\n+ ANDROID_CONTROL_AF_REGIONS_SET_TRUE ,\n+} camera_metadata_enum_android_control_af_regions_set_t;\n+\n+// ANDROID_CONTROL_AE_REGIONS_SET\n+typedef enum camera_metadata_enum_android_control_ae_regions_set {\n+ ANDROID_CONTROL_AE_REGIONS_SET_FALSE ,\n+ ANDROID_CONTROL_AE_REGIONS_SET_TRUE ,\n+} camera_metadata_enum_android_control_ae_regions_set_t;\n+\n+// ANDROID_CONTROL_AWB_REGIONS_SET\n+typedef enum camera_metadata_enum_android_control_awb_regions_set {\n+ ANDROID_CONTROL_AWB_REGIONS_SET_FALSE ,\n+ ANDROID_CONTROL_AWB_REGIONS_SET_TRUE ,\n+} camera_metadata_enum_android_control_awb_regions_set_t;\n+\n+// ANDROID_CONTROL_SETTINGS_OVERRIDE\n+typedef enum camera_metadata_enum_android_control_settings_override {\n+ ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF , // HIDL v3.9\n+ ANDROID_CONTROL_SETTINGS_OVERRIDE_ZOOM , // HIDL v3.9\n+ ANDROID_CONTROL_SETTINGS_OVERRIDE_VENDOR_START = 0x4000, // HIDL v3.9\n+} camera_metadata_enum_android_control_settings_override_t;\n+\n+// ANDROID_CONTROL_AUTOFRAMING\n+typedef enum camera_metadata_enum_android_control_autoframing {\n+ ANDROID_CONTROL_AUTOFRAMING_OFF , // HIDL v3.9\n+ ANDROID_CONTROL_AUTOFRAMING_ON , // HIDL v3.9\n+ ANDROID_CONTROL_AUTOFRAMING_AUTO , // HIDL v3.9\n+} camera_metadata_enum_android_control_autoframing_t;\n+\n+// ANDROID_CONTROL_AUTOFRAMING_AVAILABLE\n+typedef enum camera_metadata_enum_android_control_autoframing_available {\n+ ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_FALSE , // HIDL v3.9\n+ ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_TRUE , // HIDL v3.9\n+} camera_metadata_enum_android_control_autoframing_available_t;\n+\n+// ANDROID_CONTROL_AUTOFRAMING_STATE\n+typedef enum camera_metadata_enum_android_control_autoframing_state {\n+ ANDROID_CONTROL_AUTOFRAMING_STATE_INACTIVE , // HIDL v3.9\n+ ANDROID_CONTROL_AUTOFRAMING_STATE_FRAMING , // HIDL v3.9\n+ ANDROID_CONTROL_AUTOFRAMING_STATE_CONVERGED , // HIDL v3.9\n+} camera_metadata_enum_android_control_autoframing_state_t;\n+\n+// ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE\n+typedef enum camera_metadata_enum_android_control_low_light_boost_state {\n+ ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_INACTIVE , // HIDL v3.10\n+ ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_ACTIVE , // HIDL v3.10\n+} camera_metadata_enum_android_control_low_light_boost_state_t;\n+\n+// ANDROID_CONTROL_ZOOM_METHOD\n+typedef enum camera_metadata_enum_android_control_zoom_method {\n+ ANDROID_CONTROL_ZOOM_METHOD_AUTO = 0,\n+ ANDROID_CONTROL_ZOOM_METHOD_ZOOM_RATIO = 1,\n+} camera_metadata_enum_android_control_zoom_method_t;\n+\n+// ANDROID_CONTROL_AE_PRIORITY_MODE\n+typedef enum camera_metadata_enum_android_control_ae_priority_mode {\n+ ANDROID_CONTROL_AE_PRIORITY_MODE_OFF , // HIDL v3.11\n+ ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_SENSITIVITY_PRIORITY , // HIDL v3.11\n+ ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_EXPOSURE_TIME_PRIORITY , // HIDL v3.11\n+} camera_metadata_enum_android_control_ae_priority_mode_t;\n+\n \n // ANDROID_DEMOSAIC_MODE\n typedef enum camera_metadata_enum_android_demosaic_mode {\n@@ -724,6 +999,8 @@ typedef enum camera_metadata_enum_android_lens_state {\n typedef enum camera_metadata_enum_android_lens_pose_reference {\n ANDROID_LENS_POSE_REFERENCE_PRIMARY_CAMERA , // HIDL v3.3\n ANDROID_LENS_POSE_REFERENCE_GYROSCOPE , // HIDL v3.3\n+ ANDROID_LENS_POSE_REFERENCE_UNDEFINED , // HIDL v3.5\n+ ANDROID_LENS_POSE_REFERENCE_AUTOMOTIVE , // HIDL v3.8\n } camera_metadata_enum_android_lens_pose_reference_t;\n \n \n@@ -780,8 +1057,75 @@ typedef enum camera_metadata_enum_android_request_available_capabilities {\n ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING , // HIDL v3.3\n ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA , // HIDL v3.3\n ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME , // HIDL v3.3\n+ ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA , // HIDL v3.4\n+ ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA , // HIDL v3.5\n+ ANDROID_REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING , // HIDL v3.5\n+ ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR\n+ , // HIDL v3.6\n+ ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING , // HIDL v3.6\n+ ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT , // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE , // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_CAPABILITIES_COLOR_SPACE_PROFILES , // HIDL v3.9\n } camera_metadata_enum_android_request_available_capabilities_t;\n \n+// ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP\n+typedef enum camera_metadata_enum_android_request_available_dynamic_range_profiles_map {\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD = 0x1, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10 = 0x2, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10 = 0x4, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS = 0x8, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF\n+ = 0x10, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO\n+ = 0x20, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM\n+ = 0x40, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO\n+ = 0x80, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF\n+ = 0x100, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO\n+ = 0x200, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM\n+ = 0x400, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO\n+ = 0x800, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX = 0x1000, // HIDL v3.8\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD_SMPTE_2094_50\n+ = 0x2000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10_SMPTE_2094_50\n+ = 0x4000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_SMPTE_2094_50\n+ = 0x8000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS_SMPTE_2094_50\n+ = 0x10000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50\n+ = 0x20000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50\n+ = 0x40000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50\n+ = 0x80000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50\n+ = 0x100000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50\n+ = 0x200000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50\n+ = 0x400000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50\n+ = 0x800000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50\n+ = 0x1000000, // HIDL v3.12\n+ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX_312 = 0x2000000, // HIDL v3.12\n+} camera_metadata_enum_android_request_available_dynamic_range_profiles_map_t;\n+\n+// ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP\n+typedef enum camera_metadata_enum_android_request_available_color_space_profiles_map {\n+ ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED = -1, // HIDL v3.9\n+ ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB = 0, // HIDL v3.9\n+ ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3 = 7, // HIDL v3.9\n+ ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_BT2020_HLG = 16, // HIDL v3.9\n+} camera_metadata_enum_android_request_available_color_space_profiles_map_t;\n+\n \n // ANDROID_SCALER_AVAILABLE_FORMATS\n typedef enum camera_metadata_enum_android_scaler_available_formats {\n@@ -792,6 +1136,10 @@ typedef enum camera_metadata_enum_android_scaler_available_formats {\n ANDROID_SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED = 0x22, // HIDL v3.2\n ANDROID_SCALER_AVAILABLE_FORMATS_YCbCr_420_888 = 0x23, // HIDL v3.2\n ANDROID_SCALER_AVAILABLE_FORMATS_BLOB = 0x21, // HIDL v3.2\n+ ANDROID_SCALER_AVAILABLE_FORMATS_RAW10 = 0x25, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_FORMATS_RAW12 = 0x26, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_FORMATS_RAW14 = 0x2C, // HIDL v3.12\n+ ANDROID_SCALER_AVAILABLE_FORMATS_Y8 = 0x20203859, // HIDL v3.4\n } camera_metadata_enum_android_scaler_available_formats_t;\n \n // ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS\n@@ -806,6 +1154,79 @@ typedef enum camera_metadata_enum_android_scaler_cropping_type {\n ANDROID_SCALER_CROPPING_TYPE_FREEFORM , // HIDL v3.2\n } camera_metadata_enum_android_scaler_cropping_type_t;\n \n+// ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS\n+typedef enum camera_metadata_enum_android_scaler_available_recommended_stream_configurations {\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW\n+ = 0x0, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD\n+ = 0x1, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VIDEO_SNAPSHOT\n+ = 0x2, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT\n+ = 0x3, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_ZSL = 0x4, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RAW = 0x5, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_LOW_LATENCY_SNAPSHOT\n+ = 0x6, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END\n+ = 0x7, // HIDL v3.4\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_10BIT_OUTPUT\n+ = 0x8, // HIDL v3.8\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END_3_8\n+ = 0x9, // HIDL v3.8\n+ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VENDOR_START\n+ = 0x18, // HIDL v3.4\n+} camera_metadata_enum_android_scaler_available_recommended_stream_configurations_t;\n+\n+// ANDROID_SCALER_ROTATE_AND_CROP\n+typedef enum camera_metadata_enum_android_scaler_rotate_and_crop {\n+ ANDROID_SCALER_ROTATE_AND_CROP_NONE , // HIDL v3.5\n+ ANDROID_SCALER_ROTATE_AND_CROP_90 , // HIDL v3.5\n+ ANDROID_SCALER_ROTATE_AND_CROP_180 , // HIDL v3.5\n+ ANDROID_SCALER_ROTATE_AND_CROP_270 , // HIDL v3.5\n+ ANDROID_SCALER_ROTATE_AND_CROP_AUTO , // HIDL v3.5\n+} camera_metadata_enum_android_scaler_rotate_and_crop_t;\n+\n+// ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS\n+typedef enum camera_metadata_enum_android_scaler_physical_camera_multi_resolution_stream_configurations {\n+ ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_OUTPUT\n+ , // HIDL v3.6\n+ ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_INPUT\n+ , // HIDL v3.6\n+} camera_metadata_enum_android_scaler_physical_camera_multi_resolution_stream_configurations_t;\n+\n+// ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION\n+typedef enum camera_metadata_enum_android_scaler_available_stream_configurations_maximum_resolution {\n+ ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT\n+ , // HIDL v3.6\n+ ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT\n+ , // HIDL v3.6\n+} camera_metadata_enum_android_scaler_available_stream_configurations_maximum_resolution_t;\n+\n+// ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED\n+typedef enum camera_metadata_enum_android_scaler_multi_resolution_stream_supported {\n+ ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_FALSE , // HIDL v3.6\n+ ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_TRUE , // HIDL v3.6\n+} camera_metadata_enum_android_scaler_multi_resolution_stream_supported_t;\n+\n+// ANDROID_SCALER_CROP_REGION_SET\n+typedef enum camera_metadata_enum_android_scaler_crop_region_set {\n+ ANDROID_SCALER_CROP_REGION_SET_FALSE ,\n+ ANDROID_SCALER_CROP_REGION_SET_TRUE ,\n+} camera_metadata_enum_android_scaler_crop_region_set_t;\n+\n+// ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES\n+typedef enum camera_metadata_enum_android_scaler_available_stream_use_cases {\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT = 0x0, // HIDL v3.8\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW = 0x1, // HIDL v3.8\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE = 0x2, // HIDL v3.8\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD = 0x3, // HIDL v3.8\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL = 0x4, // HIDL v3.8\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL = 0x5, // HIDL v3.8\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW = 0x6, // HIDL v3.9\n+ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START = 0x10000, // HIDL v3.8\n+} camera_metadata_enum_android_scaler_available_stream_use_cases_t;\n+\n \n // ANDROID_SENSOR_REFERENCE_ILLUMINANT1\n typedef enum camera_metadata_enum_android_sensor_reference_illuminant1 {\n@@ -837,9 +1258,28 @@ typedef enum camera_metadata_enum_android_sensor_test_pattern_mode {\n ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS , // HIDL v3.2\n ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY , // HIDL v3.2\n ANDROID_SENSOR_TEST_PATTERN_MODE_PN9 , // HIDL v3.2\n+ ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK , // HIDL v3.6\n ANDROID_SENSOR_TEST_PATTERN_MODE_CUSTOM1 = 256, // HIDL v3.2\n } camera_metadata_enum_android_sensor_test_pattern_mode_t;\n \n+// ANDROID_SENSOR_PIXEL_MODE\n+typedef enum camera_metadata_enum_android_sensor_pixel_mode {\n+ ANDROID_SENSOR_PIXEL_MODE_DEFAULT , // HIDL v3.6\n+ ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION , // HIDL v3.6\n+} camera_metadata_enum_android_sensor_pixel_mode_t;\n+\n+// ANDROID_SENSOR_RAW_BINNING_FACTOR_USED\n+typedef enum camera_metadata_enum_android_sensor_raw_binning_factor_used {\n+ ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_TRUE , // HIDL v3.6\n+ ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_FALSE , // HIDL v3.6\n+} camera_metadata_enum_android_sensor_raw_binning_factor_used_t;\n+\n+// ANDROID_SENSOR_READOUT_TIMESTAMP\n+typedef enum camera_metadata_enum_android_sensor_readout_timestamp {\n+ ANDROID_SENSOR_READOUT_TIMESTAMP_NOT_SUPPORTED , // HIDL v3.8\n+ ANDROID_SENSOR_READOUT_TIMESTAMP_HARDWARE , // HIDL v3.8\n+} camera_metadata_enum_android_sensor_readout_timestamp_t;\n+\n \n // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT\n typedef enum camera_metadata_enum_android_sensor_info_color_filter_arrangement {\n@@ -848,6 +1288,8 @@ typedef enum camera_metadata_enum_android_sensor_info_color_filter_arrangement {\n ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG , // HIDL v3.2\n ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR , // HIDL v3.2\n ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB , // HIDL v3.2\n+ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO , // HIDL v3.4\n+ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR , // HIDL v3.4\n } camera_metadata_enum_android_sensor_info_color_filter_arrangement_t;\n \n // ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE\n@@ -954,6 +1396,30 @@ typedef enum camera_metadata_enum_android_info_supported_hardware_level {\n ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL , // HIDL v3.3\n } camera_metadata_enum_android_info_supported_hardware_level_t;\n \n+// ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION\n+typedef enum camera_metadata_enum_android_info_supported_buffer_management_version {\n+ ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5, // HIDL v3.4\n+ ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE\n+ , // HIDL v3.10\n+} camera_metadata_enum_android_info_supported_buffer_management_version_t;\n+\n+// ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION\n+typedef enum camera_metadata_enum_android_info_session_configuration_query_version {\n+ ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_UPSIDE_DOWN_CAKE\n+ = 34,\n+ ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_VANILLA_ICE_CREAM\n+ = 35,\n+ ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_BAKLAVA = 36,\n+} camera_metadata_enum_android_info_session_configuration_query_version_t;\n+\n+// ANDROID_INFO_DEVICE_TYPE\n+typedef enum camera_metadata_enum_android_info_device_type {\n+ ANDROID_INFO_DEVICE_TYPE_BUILT_IN , // HIDL v3.12\n+ ANDROID_INFO_DEVICE_TYPE_EXTERNAL , // HIDL v3.12\n+ ANDROID_INFO_DEVICE_TYPE_VIRTUAL , // HIDL v3.12\n+ ANDROID_INFO_DEVICE_TYPE_UNKNOWN , // HIDL v3.12\n+} camera_metadata_enum_android_info_device_type_t;\n+\n \n // ANDROID_BLACK_LEVEL_LOCK\n typedef enum camera_metadata_enum_android_black_level_lock {\n@@ -988,6 +1454,30 @@ typedef enum camera_metadata_enum_android_depth_depth_is_exclusive {\n ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_TRUE , // HIDL v3.2\n } camera_metadata_enum_android_depth_depth_is_exclusive_t;\n \n+// ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS\n+typedef enum camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations {\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_OUTPUT\n+ , // HIDL v3.4\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_INPUT\n+ , // HIDL v3.4\n+} camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations_t;\n+\n+// ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION\n+typedef enum camera_metadata_enum_android_depth_available_depth_stream_configurations_maximum_resolution {\n+ ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT\n+ , // HIDL v3.6\n+ ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT\n+ , // HIDL v3.6\n+} camera_metadata_enum_android_depth_available_depth_stream_configurations_maximum_resolution_t;\n+\n+// ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION\n+typedef enum camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations_maximum_resolution {\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT\n+ , // HIDL v3.6\n+ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT\n+ , // HIDL v3.6\n+} camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations_maximum_resolution_t;\n+\n \n // ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE\n typedef enum camera_metadata_enum_android_logical_multi_camera_sensor_sync_type {\n@@ -995,6 +1485,12 @@ typedef enum camera_metadata_enum_android_logical_multi_camera_sensor_sync_type\n ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_CALIBRATED , // HIDL v3.3\n } camera_metadata_enum_android_logical_multi_camera_sensor_sync_type_t;\n \n+// ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS\n+typedef enum camera_metadata_enum_android_logical_multi_camera_additional_results {\n+ ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_OFF , // HIDL v3.12\n+ ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_ON , // HIDL v3.12\n+} camera_metadata_enum_android_logical_multi_camera_additional_results_t;\n+\n \n // ANDROID_DISTORTION_CORRECTION_MODE\n typedef enum camera_metadata_enum_android_distortion_correction_mode {\n@@ -1004,3 +1500,134 @@ typedef enum camera_metadata_enum_android_distortion_correction_mode {\n } camera_metadata_enum_android_distortion_correction_mode_t;\n \n \n+// ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS\n+typedef enum camera_metadata_enum_android_heic_available_heic_stream_configurations {\n+ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT , // HIDL v3.4\n+ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_INPUT , // HIDL v3.4\n+} camera_metadata_enum_android_heic_available_heic_stream_configurations_t;\n+\n+// ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION\n+typedef enum camera_metadata_enum_android_heic_available_heic_stream_configurations_maximum_resolution {\n+ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT\n+ , // HIDL v3.6\n+ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT\n+ , // HIDL v3.6\n+} camera_metadata_enum_android_heic_available_heic_stream_configurations_maximum_resolution_t;\n+\n+// ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS\n+typedef enum camera_metadata_enum_android_heic_available_heic_ultra_hdr_stream_configurations {\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_OUTPUT\n+ , // HIDL v3.11\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_INPUT\n+ , // HIDL v3.11\n+} camera_metadata_enum_android_heic_available_heic_ultra_hdr_stream_configurations_t;\n+\n+// ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION\n+typedef enum camera_metadata_enum_android_heic_available_heic_ultra_hdr_stream_configurations_maximum_resolution {\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT\n+ , // HIDL v3.11\n+ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT\n+ , // HIDL v3.11\n+} camera_metadata_enum_android_heic_available_heic_ultra_hdr_stream_configurations_maximum_resolution_t;\n+\n+\n+// ANDROID_HEIC_INFO_SUPPORTED\n+typedef enum camera_metadata_enum_android_heic_info_supported {\n+ ANDROID_HEIC_INFO_SUPPORTED_FALSE , // HIDL v3.4\n+ ANDROID_HEIC_INFO_SUPPORTED_TRUE , // HIDL v3.4\n+} camera_metadata_enum_android_heic_info_supported_t;\n+\n+\n+// ANDROID_AUTOMOTIVE_LOCATION\n+typedef enum camera_metadata_enum_android_automotive_location {\n+ ANDROID_AUTOMOTIVE_LOCATION_INTERIOR , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_OTHER , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_FRONT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_REAR , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_LEFT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_RIGHT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTRA_OTHER , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTRA_FRONT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTRA_REAR , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTRA_LEFT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LOCATION_EXTRA_RIGHT , // HIDL v3.8\n+} camera_metadata_enum_android_automotive_location_t;\n+\n+\n+// ANDROID_AUTOMOTIVE_LENS_FACING\n+typedef enum camera_metadata_enum_android_automotive_lens_facing {\n+ ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_OTHER , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_FRONT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_REAR , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_LEFT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_RIGHT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_OTHER , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_LEFT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_CENTER , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_RIGHT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_LEFT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_CENTER , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_RIGHT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_LEFT , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_CENTER , // HIDL v3.8\n+ ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_RIGHT , // HIDL v3.8\n+} camera_metadata_enum_android_automotive_lens_facing_t;\n+\n+\n+// ANDROID_EXTENSION_NIGHT_MODE_INDICATOR\n+typedef enum camera_metadata_enum_android_extension_night_mode_indicator {\n+ ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_UNKNOWN , // HIDL v3.11\n+ ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_OFF , // HIDL v3.11\n+ ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_ON , // HIDL v3.11\n+} camera_metadata_enum_android_extension_night_mode_indicator_t;\n+\n+\n+// ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS\n+typedef enum camera_metadata_enum_android_jpegr_available_jpeg_r_stream_configurations {\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_OUTPUT , // HIDL v3.9\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_INPUT , // HIDL v3.9\n+} camera_metadata_enum_android_jpegr_available_jpeg_r_stream_configurations_t;\n+\n+// ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION\n+typedef enum camera_metadata_enum_android_jpegr_available_jpeg_r_stream_configurations_maximum_resolution {\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT\n+ , // HIDL v3.9\n+ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT\n+ , // HIDL v3.9\n+} camera_metadata_enum_android_jpegr_available_jpeg_r_stream_configurations_maximum_resolution_t;\n+\n+\n+// ANDROID_SHARED_SESSION_COLOR_SPACE\n+typedef enum camera_metadata_enum_android_shared_session_color_space {\n+ ANDROID_SHARED_SESSION_COLOR_SPACE_UNSPECIFIED = -1,\n+ ANDROID_SHARED_SESSION_COLOR_SPACE_SRGB = 0,\n+ ANDROID_SHARED_SESSION_COLOR_SPACE_DISPLAY_P3 = 7,\n+ ANDROID_SHARED_SESSION_COLOR_SPACE_BT2020_HLG = 16,\n+} camera_metadata_enum_android_shared_session_color_space_t;\n+\n+\n+// ANDROID_DESKTOP_EFFECTS_CAPABILITIES\n+typedef enum camera_metadata_enum_android_desktop_effects_capabilities {\n+ ANDROID_DESKTOP_EFFECTS_CAPABILITIES_BACKGROUND_BLUR , // HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_CAPABILITIES_FACE_RETOUCH , // HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_CAPABILITIES_PORTRAIT_RELIGHT , // HIDL v3.2\n+} camera_metadata_enum_android_desktop_effects_capabilities_t;\n+\n+// ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE\n+typedef enum camera_metadata_enum_android_desktop_effects_background_blur_mode {\n+ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_OFF , // HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_LIGHT , // HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_FULL , // HIDL v3.2\n+} camera_metadata_enum_android_desktop_effects_background_blur_mode_t;\n+\n+// ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE\n+typedef enum camera_metadata_enum_android_desktop_effects_face_retouch_mode {\n+ ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_OFF , // HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_ON , // HIDL v3.2\n+} camera_metadata_enum_android_desktop_effects_face_retouch_mode_t;\n+\n+// ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE\n+typedef enum camera_metadata_enum_android_desktop_effects_portrait_relight_mode {\n+ ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_OFF , // HIDL v3.2\n+ ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_ON , // HIDL v3.2\n+} camera_metadata_enum_android_desktop_effects_portrait_relight_mode_t;\ndiff --git a/include/android/metadata/system/camera_vendor_tags.h b/include/android/metadata/system/camera_vendor_tags.h\nindex 167ff7393a..52d0e9bbc0 100644\n--- a/include/android/metadata/system/camera_vendor_tags.h\n+++ b/include/android/metadata/system/camera_vendor_tags.h\n@@ -18,9 +18,9 @@\n #ifndef SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_VENDOR_TAGS_H\n #define SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_VENDOR_TAGS_H\n \n-#ifdef __cplusplus\n-extern \"C\" {\n-#endif\n+#include \n+\n+__BEGIN_DECLS\n \n #define CAMERA_METADATA_VENDOR_TAG_BOUNDARY 0x80000000u\n #define CAMERA_METADATA_INVALID_VENDOR_ID UINT64_MAX\n@@ -151,9 +151,7 @@ struct vendor_tag_cache_ops {\n void* reserved[8];\n };\n \n-#ifdef __cplusplus\n-} /* extern \"C\" */\n-#endif\n+__END_DECLS\n \n #endif /* SYSTEM_MEDIA_INCLUDE_ANDROID_CAMERA_VENDOR_TAGS_H */\n \ndiff --git a/include/android/system/core/include/android/log.h b/include/android/system/core/include/android/log.h\nindex dbad9dd18a..b5d725c7db 100644\n--- a/include/android/system/core/include/android/log.h\n+++ b/include/android/system/core/include/android/log.h\n@@ -15,29 +15,18 @@\n * limitations under the License.\n */\n \n-#ifndef _ANDROID_LOG_H\n-#define _ANDROID_LOG_H\n+#pragma once\n \n-/******************************************************************\n- *\n- * IMPORTANT NOTICE:\n- *\n- * This file is part of Android's set of stable system headers\n- * exposed by the Android NDK (Native Development Kit) since\n- * platform release 1.5\n- *\n- * Third-party source AND binary code relies on the definitions\n- * here to be FROZEN ON ALL UPCOMING PLATFORM RELEASES.\n- *\n- * - DO NOT MODIFY ENUMS (EXCEPT IF YOU ADD NEW 32-BIT VALUES)\n- * - DO NOT MODIFY CONSTANTS OR FUNCTIONAL MACROS\n- * - DO NOT CHANGE THE SIGNATURE OF FUNCTIONS IN ANY WAY\n- * - DO NOT CHANGE THE LAYOUT OR SIZE OF STRUCTURES\n+/**\n+ * @addtogroup Logging\n+ * @{\n */\n \n-/*\n- * Support routines to send messages to the Android in-kernel log buffer,\n- * which can later be accessed through the 'logcat' utility.\n+/**\n+ * \\file\n+ *\n+ * Support routines to send messages to the Android log buffer,\n+ * which can later be accessed through the `logcat` utility.\n *\n * Each log message must have\n * - a priority\n@@ -48,98 +37,393 @@\n * and should be reasonably small.\n *\n * Log message text may be truncated to less than an implementation-specific\n- * limit (e.g. 1023 characters max).\n+ * limit (1023 bytes).\n *\n * Note that a newline character (\"\\n\") will be appended automatically to your\n- * log message, if not already there. It is not possible to send several messages\n- * and have them appear on a single line in logcat.\n+ * log message, if not already there. It is not possible to send several\n+ * messages and have them appear on a single line in logcat.\n *\n- * PLEASE USE LOGS WITH MODERATION:\n+ * Please use logging in moderation:\n *\n * - Sending log messages eats CPU and slow down your application and the\n * system.\n *\n- * - The circular log buffer is pretty small (<64KB), sending many messages\n- * might push off other important log messages from the rest of the system.\n+ * - The circular log buffer is pretty small, so sending many messages\n+ * will hide other important log messages.\n *\n * - In release builds, only send log messages to account for exceptional\n * conditions.\n- *\n- * NOTE: These functions MUST be implemented by /system/lib/liblog.so\n */\n \n #include \n+#include \n+#include \n+#include \n+#include \n+#include \n+\n+#if !defined(__BIONIC__) && !defined(__INTRODUCED_IN)\n+#define __INTRODUCED_IN(x)\n+#endif\n \n #ifdef __cplusplus\n extern \"C\" {\n #endif\n \n-/*\n- * Android log priority values, in ascending priority order.\n+/**\n+ * Android log priority values, in increasing order of priority.\n */\n typedef enum android_LogPriority {\n- ANDROID_LOG_UNKNOWN = 0,\n- ANDROID_LOG_DEFAULT, /* only for SetMinPriority() */\n- ANDROID_LOG_VERBOSE,\n- ANDROID_LOG_DEBUG,\n- ANDROID_LOG_INFO,\n- ANDROID_LOG_WARN,\n- ANDROID_LOG_ERROR,\n- ANDROID_LOG_FATAL,\n- ANDROID_LOG_SILENT, /* only for SetMinPriority(); must be last */\n+ /** For internal use only. */\n+ ANDROID_LOG_UNKNOWN = 0,\n+ /** The default priority, for internal use only. */\n+ ANDROID_LOG_DEFAULT, /* only for SetMinPriority() */\n+ /** Verbose logging. Should typically be disabled for a release apk. */\n+ ANDROID_LOG_VERBOSE,\n+ /** Debug logging. Should typically be disabled for a release apk. */\n+ ANDROID_LOG_DEBUG,\n+ /** Informational logging. Should typically be disabled for a release apk. */\n+ ANDROID_LOG_INFO,\n+ /** Warning logging. For use with recoverable failures. */\n+ ANDROID_LOG_WARN,\n+ /** Error logging. For use with unrecoverable failures. */\n+ ANDROID_LOG_ERROR,\n+ /** Fatal logging. For use when aborting. */\n+ ANDROID_LOG_FATAL,\n+ /** For internal use only. */\n+ ANDROID_LOG_SILENT, /* only for SetMinPriority(); must be last */\n } android_LogPriority;\n \n-/*\n- * Send a simple string to the log.\n+/**\n+ * Identifies a specific log buffer for __android_log_buf_write()\n+ * and __android_log_buf_print().\n */\n-int __android_log_write(int prio, const char *tag, const char *text);\n+typedef enum log_id {\n+ /** For internal use only. */\n+ LOG_ID_MIN = 0,\n \n-/*\n- * Send a formatted string to the log, used like printf(fmt,...)\n- */\n-int __android_log_print(int prio, const char *tag, const char *fmt, ...)\n-#if defined(__GNUC__)\n-#ifdef __USE_MINGW_ANSI_STDIO\n-#if __USE_MINGW_ANSI_STDIO\n- __attribute__ ((format(gnu_printf, 3, 4)))\n-#else\n- __attribute__ ((format(printf, 3, 4)))\n-#endif\n-#else\n- __attribute__ ((format(printf, 3, 4)))\n-#endif\n-#endif\n- ;\n+ /** The main log buffer. This is the only log buffer available to apps. */\n+ LOG_ID_MAIN = 0,\n+ /** The radio log buffer. */\n+ LOG_ID_RADIO = 1,\n+ /** The event log buffer. */\n+ LOG_ID_EVENTS = 2,\n+ /** The system log buffer. */\n+ LOG_ID_SYSTEM = 3,\n+ /** The crash log buffer. */\n+ LOG_ID_CRASH = 4,\n+ /** The statistics log buffer. */\n+ LOG_ID_STATS = 5,\n+ /** The security log buffer. */\n+ LOG_ID_SECURITY = 6,\n+ /** The kernel log buffer. */\n+ LOG_ID_KERNEL = 7,\n \n-/*\n- * A variant of __android_log_print() that takes a va_list to list\n- * additional parameters.\n+ /** For internal use only. */\n+ LOG_ID_MAX,\n+\n+ /**\n+ * Let the logging library choose the best log target in cases where it's\n+ * unclear. This is useful if you're generic library code that can't know\n+ * which log your caller should use.\n+ */\n+ LOG_ID_DEFAULT = 0x7FFFFFFF\n+} log_id_t;\n+\n+static inline bool __android_log_id_is_valid(log_id_t log_id) {\n+ return log_id >= LOG_ID_MIN && log_id < LOG_ID_MAX;\n+}\n+\n+/**\n+ * Writes the constant string `text` to the main log buffer,\n+ * with priority `prio` (one of the `android_LogPriority` values) and tag `tag`.\n+ *\n+ * See __android_log_buf_write() to write to a different log buffer.\n+ *\n+ * @return 1 if the message was written to the log, or -EPERM if it was not; see\n+ * __android_log_is_loggable().\n */\n-int __android_log_vprint(int prio, const char *tag,\n- const char *fmt, va_list ap);\n+int __android_log_write(int prio, const char* tag, const char* text);\n \n-/*\n- * Log an assertion failure and abort the process to have a chance\n- * to inspect it if a debugger is attached. This uses the FATAL priority.\n- */\n-void __android_log_assert(const char *cond, const char *tag,\n- const char *fmt, ...)\n-#if defined(__GNUC__)\n- __attribute__ ((noreturn))\n-#ifdef __USE_MINGW_ANSI_STDIO\n-#if __USE_MINGW_ANSI_STDIO\n- __attribute__ ((format(gnu_printf, 3, 4)))\n-#else\n- __attribute__ ((format(printf, 3, 4)))\n-#endif\n-#else\n- __attribute__ ((format(printf, 3, 4)))\n-#endif\n-#endif\n- ;\n+/**\n+ * Writes the string `text` to the log buffer `log_id` (one of the `log_id_t` values),\n+ * with priority `prio` (one of the `android_LogPriority` values) and tag `tag`.\n+ *\n+ * Apps should use __android_log_write() instead because LOG_ID_MAIN is the\n+ * only log buffer available to them.\n+ *\n+ * @return 1 if the message was written to the log, or -EPERM if it was not; see\n+ * __android_log_is_loggable().\n+ */\n+int __android_log_buf_write(int log_id, int prio, const char* tag, const char* text);\n+\n+/**\n+ * Writes a formatted string to the main log buffer,\n+ * with priority `prio` (one of the `android_LogPriority` values) and tag `tag`.\n+ *\n+ * The details of formatting are the same as for\n+ * [printf(3)](http://man7.org/linux/man-pages/man3/printf.3.html).\n+ *\n+ * See __android_log_buf_print() to write to a different log buffer.\n+ *\n+ * @return 1 if the message was written to the log, or -EPERM if it was not; see\n+ * __android_log_is_loggable().\n+ */\n+int __android_log_print(int prio, const char* tag, const char* fmt, ...)\n+ __attribute__((__format__(printf, 3, 4)));\n+\n+/**\n+ * Writes a formatted string to the log buffer `log_id` (one of the `log_id_t` values),\n+ * with priority `prio` (one of the `android_LogPriority` values) and tag `tag`.\n+ *\n+ * The details of formatting are the same as for\n+ * [printf(3)](http://man7.org/linux/man-pages/man3/printf.3.html).\n+ *\n+ * Apps should use __android_log_print() instead because LOG_ID_MAIN is the\n+ * only log buffer available to them.\n+ *\n+ * @return 1 if the message was written to the log, or -EPERM if it was not; see\n+ * __android_log_is_loggable().\n+ */\n+int __android_log_buf_print(int log_id, int prio, const char* tag, const char* fmt, ...)\n+ __attribute__((__format__(printf, 4, 5)));\n+\n+/**\n+ * Equivalent to __android_log_print(), but taking a `va_list`.\n+ * (If __android_log_print() is like printf(), this is like vprintf().)\n+ *\n+ * @return 1 if the message was written to the log, or -EPERM if it was not; see\n+ * __android_log_is_loggable().\n+ */\n+int __android_log_vprint(int prio, const char* tag, const char* fmt, va_list ap)\n+ __attribute__((__format__(printf, 3, 0)));\n+\n+/**\n+ * Writes an assertion failure to the main log buffer\n+ * with priority `ANDROID_LOG_FATAL` -- and also to stderr -- before calling\n+ * [abort(3)](http://man7.org/linux/man-pages/man3/abort.3.html).\n+ *\n+ * If `fmt` is non-null, `cond` is unused. If `fmt` is null, the string\n+ * `Assertion failed: %s` is used with `cond` as the string argument.\n+ * If both `fmt` and `cond` are null, a default string is provided.\n+ *\n+ * Most callers should use\n+ * [assert(3)](http://man7.org/linux/man-pages/man3/assert.3.html) from\n+ * `<assert.h>` instead, or the `__assert` and `__assert2` functions\n+ * provided by bionic if more control is needed. They support automatically\n+ * including the source filename and line number more conveniently than this\n+ * function.\n+ */\n+void __android_log_assert(const char* cond, const char* tag, const char* fmt, ...)\n+ __attribute__((__noreturn__)) __attribute__((__format__(printf, 3, 4)));\n+\n+/**\n+ * Logger data struct used for writing log messages to liblog via __android_log_write_logger_data()\n+ * and sending log messages to user defined loggers specified in __android_log_set_logger().\n+ */\n+struct __android_log_message {\n+ /** Must be set to `sizeof(__android_log_message)` and is used for versioning. */\n+ size_t struct_size;\n+\n+ /** {@link log_id_t} values. */\n+ int32_t buffer_id;\n+\n+ /** {@link android_LogPriority} values. */\n+ int32_t priority;\n+\n+ /** The tag for the log message. */\n+ const char* tag;\n+\n+ /** Optional file name, may be set to nullptr. */\n+ const char* file;\n+\n+ /** Optional line number, ignore if file is nullptr. */\n+ uint32_t line;\n+\n+ /** The log message itself. */\n+ const char* message;\n+};\n+\n+/**\n+ * Prototype for the 'logger' function that is called for every log message.\n+ */\n+typedef void (*__android_logger_function)(const struct __android_log_message* log_message);\n+\n+/**\n+ * Prototype for the 'abort' function that is called when liblog will abort due to\n+ * __android_log_assert() failures.\n+ */\n+typedef void (*__android_aborter_function)(const char* abort_message);\n+\n+/**\n+ * Writes the log message specified by log_message. log_message includes additional file name and\n+ * line number information that a logger may use. log_message is versioned for backwards\n+ * compatibility.\n+ * This assumes that loggability has already been checked through __android_log_is_loggable().\n+ * Higher level logging libraries, such as libbase, first check loggability, then format their\n+ * buffers, then pass the message to liblog via this function, and therefore we do not want to\n+ * duplicate the loggability check here.\n+ *\n+ * @param log_message the log message itself, see {@link __android_log_message}.\n+ *\n+ * Available since API level 30.\n+ */\n+void __android_log_write_log_message(struct __android_log_message* log_message) __INTRODUCED_IN(30);\n+\n+/**\n+ * Sets a user defined logger function. All log messages sent to liblog will be set to the\n+ * function pointer specified by logger for processing. It is not expected that log messages are\n+ * already terminated with a new line. This function should add new lines if required for line\n+ * separation.\n+ *\n+ * @param logger the new function that will handle log messages.\n+ *\n+ * Available since API level 30.\n+ */\n+void __android_log_set_logger(__android_logger_function logger) __INTRODUCED_IN(30);\n+\n+/**\n+ * Writes the log message to logd. This is an {@link __android_logger_function} and can be provided to\n+ * __android_log_set_logger(). It is the default logger when running liblog on a device.\n+ *\n+ * @param log_message the log message to write, see {@link __android_log_message}.\n+ *\n+ * Available since API level 30.\n+ */\n+void __android_log_logd_logger(const struct __android_log_message* log_message) __INTRODUCED_IN(30);\n+\n+/**\n+ * Writes the log message to logd using the passed in timestamp. The messages are stored\n+ * in logd in the order received not in order by timestamp. When displaying the log, there is no\n+ * guarantee that messages are in timestamp order and might cause messages with different times to\n+ * be interleaved. Filtering the log using a timestamp will work properly even if out of time\n+ * order messages are present.\n+ *\n+ * @param log_message the log message to write, see {@link __android_log_message}.\n+ * @param timestamp the time to use for this log message. The value is interpreted as a\n+ * CLOCK_REALTIME value.\n+ *\n+ * Available since API level 37.\n+ */\n+void __android_log_logd_logger_with_timestamp(const struct __android_log_message* log_message,\n+ const struct timespec* timestamp) __INTRODUCED_IN(37);\n+\n+/**\n+ * Writes the log message to stderr. This is an {@link __android_logger_function} and can be provided to\n+ * __android_log_set_logger(). It is the default logger when running liblog on host.\n+ *\n+ * @param log_message the log message to write, see {@link __android_log_message}.\n+ *\n+ * Available since API level 30.\n+ */\n+void __android_log_stderr_logger(const struct __android_log_message* log_message)\n+ __INTRODUCED_IN(30);\n+\n+/**\n+ * Sets a user defined aborter function that is called for __android_log_assert() failures. This\n+ * user defined aborter function is highly recommended to abort and be noreturn, but is not strictly\n+ * required to.\n+ *\n+ * @param aborter the new aborter function, see {@link __android_aborter_function}.\n+ *\n+ * Available since API level 30.\n+ */\n+void __android_log_set_aborter(__android_aborter_function aborter) __INTRODUCED_IN(30);\n+\n+/**\n+ * Calls the stored aborter function. This allows for other logging libraries to use the same\n+ * aborter function by calling this function in liblog.\n+ *\n+ * @param abort_message an additional message supplied when aborting, for example this is used to\n+ * call android_set_abort_message() in __android_log_default_aborter().\n+ *\n+ * Available since API level 30.\n+ */\n+void __android_log_call_aborter(const char* abort_message) __INTRODUCED_IN(30);\n+\n+/**\n+ * Sets android_set_abort_message() on device then aborts(). This is the default aborter.\n+ *\n+ * @param abort_message an additional message supplied when aborting. This functions calls\n+ * android_set_abort_message() with its contents.\n+ *\n+ * Available since API level 30.\n+ */\n+void __android_log_default_aborter(const char* abort_message) __attribute__((noreturn))\n+__INTRODUCED_IN(30);\n+\n+/**\n+ * Use the per-tag properties \"log.tag.\" along with the minimum priority from\n+ * __android_log_set_minimum_priority() to determine if a log message with a given prio and tag will\n+ * be printed. A non-zero result indicates yes, zero indicates false.\n+ *\n+ * If both a priority for a tag and a minimum priority are set by\n+ * __android_log_set_minimum_priority(), then the lowest of the two values are to determine the\n+ * minimum priority needed to log. If only one is set, then that value is used to determine the\n+ * minimum priority needed. If none are set, then default_priority is used.\n+ *\n+ * @param prio the priority to test, takes {@link android_LogPriority} values.\n+ * @param tag the tag to test.\n+ * @param default_prio the default priority to use if no properties or minimum priority are set.\n+ * @return an integer where 1 indicates that the message is loggable and 0 indicates that it is not.\n+ *\n+ * Available since API level 30.\n+ */\n+int __android_log_is_loggable(int prio, const char* tag, int default_prio) __INTRODUCED_IN(30);\n+\n+/**\n+ * Use the per-tag properties \"log.tag.\" along with the minimum priority from\n+ * __android_log_set_minimum_priority() to determine if a log message with a given prio and tag will\n+ * be printed. A non-zero result indicates yes, zero indicates false.\n+ *\n+ * If both a priority for a tag and a minimum priority are set by\n+ * __android_log_set_minimum_priority(), then the lowest of the two values are to determine the\n+ * minimum priority needed to log. If only one is set, then that value is used to determine the\n+ * minimum priority needed. If none are set, then default_priority is used.\n+ *\n+ * @param prio the priority to test, takes {@link android_LogPriority} values.\n+ * @param tag the tag to test.\n+ * @param len the length of the tag.\n+ * @param default_prio the default priority to use if no properties or minimum priority are set.\n+ * @return an integer where 1 indicates that the message is loggable and 0 indicates that it is not.\n+ *\n+ * Available since API level 30.\n+ */\n+int __android_log_is_loggable_len(int prio, const char* tag, size_t len, int default_prio)\n+ __INTRODUCED_IN(30);\n+\n+/**\n+ * Sets the minimum priority that will be logged for this process.\n+ *\n+ * @param priority the new minimum priority to set, takes {@link android_LogPriority} values.\n+ * @return the previous set minimum priority, or `ANDROID_LOG_DEFAULT` if none was set.\n+ *\n+ * Available since API level 30.\n+ */\n+int32_t __android_log_set_minimum_priority(int32_t priority) __INTRODUCED_IN(30);\n+\n+/**\n+ * Gets the minimum priority that will be logged for this process.\n+ *\n+ * @return the current minimum priority, or `ANDROID_LOG_DEFAULT` if none is set.\n+ *\n+ * Available since API level 30.\n+ */\n+int32_t __android_log_get_minimum_priority(void) __INTRODUCED_IN(30);\n+\n+/**\n+ * Sets the default tag if no tag is provided when writing a log message. Defaults to\n+ * getprogname(). This truncates tag to the maximum log message size, though appropriate tags\n+ * should be much smaller.\n+ *\n+ * @param tag the new log tag.\n+ *\n+ * Available since API level 30.\n+ */\n+void __android_log_set_default_tag(const char* tag) __INTRODUCED_IN(30);\n \n #ifdef __cplusplus\n }\n #endif\n \n-#endif /* _ANDROID_LOG_H */\n+/** @} */\ndiff --git a/include/android/system/core/include/cutils/native_handle.h b/include/android/system/core/include/cutils/native_handle.h\nindex dbd37672f0..d6014efd92 100644\n--- a/include/android/system/core/include/cutils/native_handle.h\n+++ b/include/android/system/core/include/cutils/native_handle.h\n@@ -50,18 +50,28 @@ typedef struct native_handle\n typedef const native_handle_t* buffer_handle_t;\n \n /*\n- * native_handle_close\n- * \n- * closes the file descriptors contained in this native_handle_t\n- * \n+ * Closes the file descriptors contained in this native_handle_t, which may\n+ * either be untagged or tagged for ownership by this native_handle_t via\n+ * native_handle_set_tag(). Mixing untagged and tagged fds in the same\n+ * native_handle_t is not permitted and triggers an fdsan exception, but\n+ * native_handle_set_fdsan_tag() can be used to bring consistency if this is\n+ * intentional.\n+ *\n+ * If it's known that fds are tagged, prefer native_handle_close_with_tag() for\n+ * better safety.\n+ *\n * return 0 on success, or a negative error code on failure\n- * \n */\n int native_handle_close(const native_handle_t* h);\n \n /*\n- * native_handle_init\n- *\n+ * Equivalent to native_handle_close(), but throws an fdsan exception if the fds\n+ * are untagged. Use if it's known that the fds in this native_handle_t were\n+ * previously tagged via native_handle_set_tag().\n+ */\n+int native_handle_close_with_tag(const native_handle_t* h);\n+\n+/*\n * Initializes a native_handle_t from storage. storage must be declared with\n * NATIVE_HANDLE_DECLARE_STORAGE. numFds and numInts must not respectively\n * exceed maxFds and maxInts used to declare the storage.\n@@ -69,32 +79,42 @@ int native_handle_close(const native_handle_t* h);\n native_handle_t* native_handle_init(char* storage, int numFds, int numInts);\n \n /*\n- * native_handle_create\n- * \n- * creates a native_handle_t and initializes it. must be destroyed with\n- * native_handle_delete().\n- * \n+ * Creates a native_handle_t and initializes it. Must be destroyed with\n+ * native_handle_delete(). Note that numFds must be <= NATIVE_HANDLE_MAX_FDS,\n+ * numInts must be <= NATIVE_HANDLE_MAX_INTS, and both must be >= 0.\n */\n native_handle_t* native_handle_create(int numFds, int numInts);\n \n /*\n- * native_handle_clone\n- *\n- * creates a native_handle_t and initializes it from another native_handle_t.\n+ * Updates the fdsan tag for any file descriptors contained in the supplied\n+ * handle to indicate that they are owned by this handle and should only be\n+ * closed via native_handle_close()/native_handle_close_with_tag(). Each fd in\n+ * the handle must have a tag of either 0 (unset) or the tag associated with\n+ * this handle, otherwise an fdsan exception will be triggered.\n+ */\n+void native_handle_set_fdsan_tag(const native_handle_t* handle);\n+\n+/*\n+ * Clears the fdsan tag for any file descriptors contained in the supplied\n+ * native_handle_t. Use if this native_handle_t is giving up ownership of its\n+ * fds, but the fdsan tags were previously set. Each fd in the handle must have\n+ * a tag of either 0 (unset) or the tag associated with this handle, otherwise\n+ * an fdsan exception will be triggered.\n+ */\n+void native_handle_unset_fdsan_tag(const native_handle_t* handle);\n+\n+/*\n+ * Creates a native_handle_t and initializes it from another native_handle_t.\n * Must be destroyed with native_handle_delete().\n- *\n */\n native_handle_t* native_handle_clone(const native_handle_t* handle);\n \n /*\n- * native_handle_delete\n- * \n- * frees a native_handle_t allocated with native_handle_create().\n+ * Frees a native_handle_t allocated with native_handle_create().\n * This ONLY frees the memory allocated for the native_handle_t, but doesn't\n * close the file descriptors; which can be achieved with native_handle_close().\n- * \n+ *\n * return 0 on success, or a negative error code on failure\n- * \n */\n int native_handle_delete(native_handle_t* h);\n \ndiff --git a/include/android/system/core/include/system/camera.h b/include/android/system/core/include/system/camera.h\nindex 9d69588f98..b625aada70 100644\n--- a/include/android/system/core/include/system/camera.h\n+++ b/include/android/system/core/include/system/camera.h\n@@ -159,8 +159,8 @@ enum {\n *\n * When any camera method returns error, the client can use ping command\n * to see if the camera has been taken away by other clients. If the result\n- * is NO_ERROR, it means the camera hardware is not released. If the result\n- * is not NO_ERROR, the camera has been released and the existing client\n+ * is OK, it means the camera hardware is not released. If the result\n+ * is not OK, the camera has been released and the existing client\n * can silently finish itself or show a dialog.\n */\n CAMERA_CMD_PING = 9,\ndiff --git a/include/android/system/core/include/system/graphics-base-v1.2.h b/include/android/system/core/include/system/graphics-base-v1.2.h\nnew file mode 100644\nindex 0000000000..372284ad73\n--- /dev/null\n+++ b/include/android/system/core/include/system/graphics-base-v1.2.h\n@@ -0,0 +1,36 @@\n+/* SPDX-License-Identifier: Apache-2.0 */\n+// This file is autogenerated by hidl-gen. Do not edit manually.\n+// Source: android.hardware.graphics.common@1.2\n+// Location: hardware/interfaces/graphics/common/1.2/\n+\n+#ifndef HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_\n+#define HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_\n+\n+#ifdef __cplusplus\n+extern \"C\" {\n+#endif\n+\n+typedef enum {\n+ HAL_HDR_HDR10_PLUS = 4,\n+} android_hdr_v1_2_t;\n+\n+typedef enum {\n+ HAL_DATASPACE_DISPLAY_BT2020 = 142999552 /* STANDARD_BT2020 | TRANSFER_SRGB | RANGE_FULL */,\n+ HAL_DATASPACE_DYNAMIC_DEPTH = 4098 /* 0x1002 */,\n+ HAL_DATASPACE_JPEG_APP_SEGMENTS = 4099 /* 0x1003 */,\n+ HAL_DATASPACE_HEIF = 4100 /* 0x1004 */,\n+} android_dataspace_v1_2_t;\n+\n+typedef enum {\n+ HAL_COLOR_MODE_DISPLAY_BT2020 = 13,\n+} android_color_mode_v1_2_t;\n+\n+typedef enum {\n+ HAL_PIXEL_FORMAT_HSV_888 = 55 /* 0x37 */,\n+} android_pixel_format_v1_2_t;\n+\n+#ifdef __cplusplus\n+}\n+#endif\n+\n+#endif // HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_\ndiff --git a/include/android/system/core/include/system/graphics-base.h b/include/android/system/core/include/system/graphics-base.h\nindex d01e9874f9..3db0bbc526 100644\n--- a/include/android/system/core/include/system/graphics-base.h\n+++ b/include/android/system/core/include/system/graphics-base.h\n@@ -4,5 +4,6 @@\n \n #include \"graphics-base-v1.0.h\"\n #include \"graphics-base-v1.1.h\"\n+#include \"graphics-base-v1.2.h\"\n \n #endif // SYSTEM_CORE_GRAPHICS_BASE_H_\ndiff --git a/include/android/system/core/include/system/graphics.h b/include/android/system/core/include/system/graphics.h\nindex 6341e642d5..34159e127a 100644\n--- a/include/android/system/core/include/system/graphics.h\n+++ b/include/android/system/core/include/system/graphics.h\n@@ -60,12 +60,14 @@ typedef android_hdr_t android_hdr;\n \n /*\n * Structure for describing YCbCr formats for consumption by applications.\n- * This is used with HAL_PIXEL_FORMAT_YCbCr_*_888.\n+ * This is used with HAL_PIXEL_FORMAT_YCbCr_*.\n *\n * Buffer chroma subsampling is defined in the format.\n * e.g. HAL_PIXEL_FORMAT_YCbCr_420_888 has subsampling 4:2:0.\n *\n- * Buffers must have a 8 bit depth.\n+ * Buffers must have a byte aligned channel depth or a byte aligned packed\n+ * channel depth (e.g. 10 bits packed into 16 bits for\n+ * HAL_PIXEL_FORMAT_YCbCr_P010).\n *\n * y, cb, and cr point to the first byte of their respective planes.\n *\n@@ -76,8 +78,8 @@ typedef android_hdr_t android_hdr;\n * cstride is the stride of the chroma planes.\n *\n * chroma_step is the distance in bytes from one chroma pixel value to the\n- * next. This is 2 bytes for semiplanar (because chroma values are interleaved\n- * and each chroma value is one byte) and 1 for planar.\n+ * next. This is `2 * channel depth` bytes for semiplanar (because chroma\n+ * values are interleaved) and `1 * channel depth` bytes for planar.\n */\n \n struct android_ycbcr {\ndiff --git a/src/android/camera3_hal.cpp b/src/android/camera3_hal.cpp\nindex a5ad2374a9..ce313ebace 100644\n--- a/src/android/camera3_hal.cpp\n+++ b/src/android/camera3_hal.cpp\n@@ -112,5 +112,8 @@ camera_module_t HAL_MODULE_INFO_SYM = {\n \t.open_legacy = hal_open_legacy,\n \t.set_torch_mode = hal_set_torch_mode,\n \t.init = hal_init,\n+\t.get_physical_camera_info = nullptr,\n+\t.is_stream_combination_supported = nullptr,\n+\t.notify_device_state_change = nullptr,\n \t.reserved = {},\n };\ndiff --git a/src/android/camera_ops.cpp b/src/android/camera_ops.cpp\nindex ecaac5a31c..1656fac7ab 100644\n--- a/src/android/camera_ops.cpp\n+++ b/src/android/camera_ops.cpp\n@@ -99,5 +99,7 @@ camera3_device_ops hal_dev_ops = {\n \t.get_metadata_vendor_tag_ops = nullptr,\n \t.dump = hal_dev_dump,\n \t.flush = hal_dev_flush,\n-\t.reserved = { nullptr },\n+\t.signal_stream_flush = nullptr,\n+\t.is_reconfiguration_required = nullptr,\n+\t.reserved = {},\n };\ndiff --git a/src/android/metadata/camera_metadata.c b/src/android/metadata/camera_metadata.c\nindex b86586a7e6..fc695bcadd 100644\n--- a/src/android/metadata/camera_metadata.c\n+++ b/src/android/metadata/camera_metadata.c\n@@ -103,10 +103,10 @@ struct camera_metadata {\n uint32_t version;\n uint32_t flags;\n metadata_size_t entry_count;\n- metadata_size_t entry_capacity;\n+ metadata_size_t entry_capacity; // Number of entries that can be stored\n metadata_uptrdiff_t entries_start; // Offset from camera_metadata\n metadata_size_t data_count;\n- metadata_size_t data_capacity;\n+ metadata_size_t data_capacity; // Number of data bytes that can be stored\n metadata_uptrdiff_t data_start; // Offset from camera_metadata\n uint32_t padding; // padding to 8 bytes boundary\n metadata_vendor_id_t vendor_id;\n@@ -241,7 +241,7 @@ camera_metadata_t *allocate_copy_camera_metadata_checked(\n return NULL;\n }\n \n- void *buffer = malloc(src_size);\n+ void *buffer = calloc(1, src_size);\n memcpy(buffer, src, src_size);\n \n camera_metadata_t *metadata = (camera_metadata_t*) buffer;\n@@ -258,7 +258,7 @@ camera_metadata_t *allocate_camera_metadata(size_t entry_capacity,\n \n size_t memory_needed = calculate_camera_metadata_size(entry_capacity,\n data_capacity);\n- void *buffer = malloc(memory_needed);\n+ void *buffer = calloc(1, memory_needed);\n camera_metadata_t *metadata = place_camera_metadata(\n buffer, memory_needed, entry_capacity, data_capacity);\n if (!metadata) {\n@@ -278,7 +278,11 @@ camera_metadata_t *place_camera_metadata(void *dst,\n \n size_t memory_needed = calculate_camera_metadata_size(entry_capacity,\n data_capacity);\n- if (memory_needed > dst_size) return NULL;\n+ if (memory_needed > dst_size) {\n+ ALOGE(\"%s: Memory needed to place camera metadata (%zu) > dst size (%zu)\", __FUNCTION__,\n+ memory_needed, dst_size);\n+ return NULL;\n+ }\n \n camera_metadata_t *metadata = (camera_metadata_t*)dst;\n metadata->version = CURRENT_METADATA_VERSION;\n@@ -350,7 +354,11 @@ camera_metadata_t* copy_camera_metadata(void *dst, size_t dst_size,\n size_t memory_needed = get_camera_metadata_compact_size(src);\n \n if (dst == NULL) return NULL;\n- if (dst_size < memory_needed) return NULL;\n+ if (dst_size < memory_needed) {\n+ ALOGE(\"%s: Memory needed to place camera metadata (%zu) > dst size (%zu)\", __FUNCTION__,\n+ memory_needed, dst_size);\n+ return NULL;\n+ }\n \n camera_metadata_t *metadata =\n place_camera_metadata(dst, dst_size, src->entry_count, src->data_count);\n@@ -433,14 +441,14 @@ int validate_camera_metadata_structure(const camera_metadata_t *metadata,\n };\n \n for (size_t i = 0; i < sizeof(alignments)/sizeof(alignments[0]); ++i) {\n- uintptr_t aligned_ptr = ALIGN_TO((uintptr_t) metadata + alignmentOffset,\n+ uintptr_t aligned_ptr_section = ALIGN_TO((uintptr_t) metadata + alignmentOffset,\n alignments[i].alignment);\n \n- if ((uintptr_t)metadata + alignmentOffset != aligned_ptr) {\n+ if ((uintptr_t)metadata + alignmentOffset != aligned_ptr_section) {\n ALOGE(\"%s: Metadata pointer is not aligned (actual %p, \"\n \"expected %p, offset %\" PRIuPTR \") to type %s\",\n __FUNCTION__, metadata,\n- (void*)aligned_ptr, alignmentOffset, alignments[i].name);\n+ (void*)aligned_ptr_section, alignmentOffset, alignments[i].name);\n return CAMERA_METADATA_VALIDATION_ERROR;\n }\n }\n@@ -449,56 +457,86 @@ int validate_camera_metadata_structure(const camera_metadata_t *metadata,\n /**\n * Check that the metadata contents are correct\n */\n+ if (expected_size != NULL && sizeof(camera_metadata_t) > *expected_size) {\n+ ALOGE(\"%s: Metadata size (%zu) should be <= expected size (%zu)\",\n+ __FUNCTION__, sizeof(camera_metadata_t), *expected_size);\n+ return CAMERA_METADATA_VALIDATION_ERROR;\n+ }\n+\n+ // Create an aligned header\n+ camera_metadata_t headerCopy;\n+ const camera_metadata_t *header;\n+ if (alignmentOffset != 0) {\n+ memcpy(&headerCopy, metadata, sizeof(camera_metadata_t));\n+ header = &headerCopy;\n+ } else {\n+ header = metadata;\n+ }\n \n- if (expected_size != NULL && metadata->size > *expected_size) {\n+ if (expected_size != NULL && header->size > *expected_size) {\n ALOGE(\"%s: Metadata size (%\" PRIu32 \") should be <= expected size (%zu)\",\n- __FUNCTION__, metadata->size, *expected_size);\n+ __FUNCTION__, header->size, *expected_size);\n return CAMERA_METADATA_VALIDATION_ERROR;\n }\n \n- if (metadata->entry_count > metadata->entry_capacity) {\n+ if (header->entry_count > header->entry_capacity) {\n ALOGE(\"%s: Entry count (%\" PRIu32 \") should be <= entry capacity \"\n \"(%\" PRIu32 \")\",\n- __FUNCTION__, metadata->entry_count, metadata->entry_capacity);\n+ __FUNCTION__, header->entry_count, header->entry_capacity);\n return CAMERA_METADATA_VALIDATION_ERROR;\n }\n \n- if (metadata->data_count > metadata->data_capacity) {\n+ if (header->data_count > header->data_capacity) {\n ALOGE(\"%s: Data count (%\" PRIu32 \") should be <= data capacity \"\n \"(%\" PRIu32 \")\",\n- __FUNCTION__, metadata->data_count, metadata->data_capacity);\n+ __FUNCTION__, header->data_count, header->data_capacity);\n // android_errorWriteLog(SN_EVENT_LOG_ID, \"30591838\");\n return CAMERA_METADATA_VALIDATION_ERROR;\n }\n \n+ // Check for overflow when calculating entry capacity bytes.\n+ // (metadata_size_t)~0 represents the maximum representable value of metadata_size_t.\n+ if (header->entry_capacity > (metadata_size_t)~0 / sizeof(camera_metadata_buffer_entry_t)) {\n+ ALOGE(\"%s: Entry capacity (%\" PRIu32 \") is too large\",\n+ __FUNCTION__, header->entry_capacity);\n+ return CAMERA_METADATA_VALIDATION_ERROR;\n+ }\n+\n+ metadata_size_t entries_capacity_bytes =\n+ sizeof(camera_metadata_buffer_entry_t) * header->entry_capacity;\n const metadata_uptrdiff_t entries_end =\n- metadata->entries_start + metadata->entry_capacity;\n- if (entries_end < metadata->entries_start || // overflow check\n- entries_end > metadata->data_start) {\n+ header->entries_start + entries_capacity_bytes;\n+\n+ if (entries_end < header->entries_start) {\n+ ALOGE(\"%s: Entry start (%\" PRIu32 \") + capacity bytes (%\" PRIu32 \") \"\n+ \"overflows\", __FUNCTION__, header->entries_start, entries_capacity_bytes);\n+ return CAMERA_METADATA_VALIDATION_ERROR;\n+ }\n \n+ if (entries_end > header->data_start) {\n ALOGE(\"%s: Entry start + capacity (%\" PRIu32 \") should be <= data start \"\n \"(%\" PRIu32 \")\",\n __FUNCTION__,\n- (metadata->entries_start + metadata->entry_capacity),\n- metadata->data_start);\n+ entries_end,\n+ header->data_start);\n return CAMERA_METADATA_VALIDATION_ERROR;\n }\n \n const metadata_uptrdiff_t data_end =\n- metadata->data_start + metadata->data_capacity;\n- if (data_end < metadata->data_start || // overflow check\n- data_end > metadata->size) {\n+ header->data_start + header->data_capacity;\n+ if (data_end < header->data_start || // overflow check\n+ data_end > header->size) {\n \n ALOGE(\"%s: Data start + capacity (%\" PRIu32 \") should be <= total size \"\n \"(%\" PRIu32 \")\",\n __FUNCTION__,\n- (metadata->data_start + metadata->data_capacity),\n- metadata->size);\n+ (header->data_start + header->data_capacity),\n+ header->size);\n return CAMERA_METADATA_VALIDATION_ERROR;\n }\n \n // Validate each entry\n- const metadata_size_t entry_count = metadata->entry_count;\n+ const metadata_size_t entry_count = header->entry_count;\n camera_metadata_buffer_entry_t *entries = get_entries(metadata);\n \n for (size_t i = 0; i < entry_count; ++i) {\n@@ -511,7 +549,12 @@ int validate_camera_metadata_structure(const camera_metadata_t *metadata,\n return CAMERA_METADATA_VALIDATION_ERROR;\n }\n \n- camera_metadata_buffer_entry_t entry = entries[i];\n+ camera_metadata_buffer_entry_t entry;\n+ if (alignmentOffset != 0) {\n+ memcpy(&entry, entries + i, sizeof(camera_metadata_buffer_entry_t));\n+ } else {\n+ entry = entries[i];\n+ }\n \n if (entry.type >= NUM_TYPES) {\n ALOGE(\"%s: Entry index %zu had a bad type %d\",\n@@ -522,10 +565,10 @@ int validate_camera_metadata_structure(const camera_metadata_t *metadata,\n // TODO: fix vendor_tag_ops across processes so we don't need to special\n // case vendor-specific tags\n uint32_t tag_section = entry.tag >> 16;\n- int tag_type = get_local_camera_metadata_tag_type(entry.tag, metadata);\n+ int tag_type = get_local_camera_metadata_tag_type(entry.tag, header);\n if (tag_type != (int)entry.type && tag_section < VENDOR_SECTION) {\n- ALOGE(\"%s: Entry index %zu had tag type %d, but the type was %d\",\n- __FUNCTION__, i, tag_type, entry.type);\n+ ALOGE(\"%s: Entry index %zu (0x%x) had tag type %d, but the type was %d\",\n+ __FUNCTION__, i, entry.tag, tag_type, entry.type);\n return CAMERA_METADATA_VALIDATION_ERROR;\n }\n \n@@ -1005,6 +1048,15 @@ int get_local_camera_metadata_tag_type(uint32_t tag,\n return get_local_camera_metadata_tag_type_vendor_id(tag, id);\n }\n \n+const int32_t *get_camera_metadata_permission_needed(uint32_t *tag_count) {\n+ if (NULL == tag_count) {\n+ return NULL;\n+ }\n+\n+ *tag_count = sizeof(tag_permission_needed) / sizeof(tag_permission_needed[0]);\n+ return tag_permission_needed;\n+}\n+\n int set_camera_metadata_vendor_tag_ops(const vendor_tag_query_ops_t* ops) {\n // **DEPRECATED**\n (void) ops;\n@@ -1046,8 +1098,7 @@ metadata_vendor_id_t get_camera_metadata_vendor_id(\n }\n \n static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag, int type,\n- int count,\n- int indentation);\n+ metadata_vendor_id_t vendor_id, int count, int indentation);\n \n void dump_camera_metadata(const camera_metadata_t *metadata,\n int fd,\n@@ -1120,12 +1171,13 @@ void dump_indented_camera_metadata(const camera_metadata_t *metadata,\n int count = entry->count;\n if (verbosity < 2 && count > 16) count = 16;\n \n- print_data(fd, data_ptr, entry->tag, entry->type, count, indentation);\n+ print_data(fd, data_ptr, entry->tag, entry->type, get_camera_metadata_vendor_id(metadata),\n+ count, indentation);\n }\n }\n \n-static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,\n- int type, int count, int indentation) {\n+static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag, int type,\n+ metadata_vendor_id_t vendor_id, int count, int indentation) {\n static int values_per_line[NUM_TYPES] = {\n [TYPE_BYTE] = 16,\n [TYPE_INT32] = 4,\n@@ -1137,6 +1189,33 @@ static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,\n size_t type_size = camera_metadata_type_size[type];\n char value_string_tmp[CAMERA_METADATA_ENUM_STRING_MAX_SIZE];\n uint32_t value;\n+ size_t value_offset;\n+ size_t entry_size;\n+ // It is possible that the tag value is only found at specific\n+ // offset. The rest of the data must not be enumerated.\n+ switch (tag) {\n+ case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS:\n+ case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS:\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS:\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS:\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS:\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION:\n+ case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS:\n+ value_offset = 3 * type_size;\n+ entry_size = 4 * type_size;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS:\n+ value_offset = 4 * type_size;\n+ entry_size = 5 * type_size;\n+ break;\n+ default:\n+ value_offset = 0;\n+ entry_size = 0;\n+ }\n \n int lines = count / values_per_line[type];\n if (count % values_per_line[type] != 0) lines++;\n@@ -1158,14 +1237,24 @@ static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,\n sizeof(value_string_tmp))\n == OK) {\n dprintf(fd, \"%s \", value_string_tmp);\n+ } else if (tag == ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS) {\n+ if (value != 0) {\n+ dprintf(fd, \"%c \",\n+ *(data_ptr + index));\n+ }\n } else {\n dprintf(fd, \"%hhu \",\n *(data_ptr + index));\n }\n break;\n case TYPE_INT32:\n- value =\n- *(int32_t*)(data_ptr + index);\n+ value = *(int32_t*)(data_ptr + index);\n+\n+ if ((entry_size > 0) && ((index % entry_size ) != value_offset)) {\n+ dprintf(fd, \"%\" PRId32 \" \", value);\n+ break;\n+ }\n+\n if (camera_metadata_enum_snprint(tag,\n value,\n value_string_tmp,\n@@ -1173,8 +1262,24 @@ static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,\n == OK) {\n dprintf(fd, \"%s \", value_string_tmp);\n } else {\n- dprintf(fd, \"%\" PRId32 \" \",\n- *(int32_t*)(data_ptr + index));\n+ dprintf(fd, \"%\" PRId32 \" \", value);\n+ if (tag == ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS ||\n+ tag == ANDROID_REQUEST_AVAILABLE_RESULT_KEYS ||\n+ tag == ANDROID_REQUEST_AVAILABLE_SESSION_KEYS ||\n+ tag == ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS ||\n+ tag == ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS) {\n+ const char *camera_metadata_tag_name =\n+ get_camera_metadata_tag_name(value);\n+ if (camera_metadata_tag_name != NULL) {\n+ dprintf(fd, \"(%s) \", camera_metadata_tag_name);\n+ } else {\n+ const char *camera_metadata_tag_vendor_id =\n+ get_local_camera_metadata_tag_name_vendor_id(value, vendor_id);\n+ if (camera_metadata_tag_vendor_id != NULL) {\n+ dprintf(fd, \"(%s) \", camera_metadata_tag_vendor_id);\n+ }\n+ }\n+ }\n }\n break;\n case TYPE_FLOAT:\ndiff --git a/src/android/metadata/camera_metadata_tag_info.c b/src/android/metadata/camera_metadata_tag_info.c\nindex e1b81f6d15..3db3bb7f55 100644\n--- a/src/android/metadata/camera_metadata_tag_info.c\n+++ b/src/android/metadata/camera_metadata_tag_info.c\n@@ -61,6 +61,14 @@ const char *camera_metadata_section_names[ANDROID_SECTION_COUNT] = {\n [ANDROID_LOGICAL_MULTI_CAMERA] = \"android.logicalMultiCamera\",\n [ANDROID_DISTORTION_CORRECTION]\n = \"android.distortionCorrection\",\n+ [ANDROID_HEIC] = \"android.heic\",\n+ [ANDROID_HEIC_INFO] = \"android.heic.info\",\n+ [ANDROID_AUTOMOTIVE] = \"android.automotive\",\n+ [ANDROID_AUTOMOTIVE_LENS] = \"android.automotive.lens\",\n+ [ANDROID_EXTENSION] = \"android.extension\",\n+ [ANDROID_JPEGR] = \"android.jpegr\",\n+ [ANDROID_SHARED_SESSION] = \"android.sharedSession\",\n+ [ANDROID_DESKTOP_EFFECTS] = \"android.desktopEffects\",\n };\n \n unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {\n@@ -121,6 +129,22 @@ unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {\n [ANDROID_DISTORTION_CORRECTION]\n = { ANDROID_DISTORTION_CORRECTION_START,\n ANDROID_DISTORTION_CORRECTION_END },\n+ [ANDROID_HEIC] = { ANDROID_HEIC_START,\n+ ANDROID_HEIC_END },\n+ [ANDROID_HEIC_INFO] = { ANDROID_HEIC_INFO_START,\n+ ANDROID_HEIC_INFO_END },\n+ [ANDROID_AUTOMOTIVE] = { ANDROID_AUTOMOTIVE_START,\n+ ANDROID_AUTOMOTIVE_END },\n+ [ANDROID_AUTOMOTIVE_LENS] = { ANDROID_AUTOMOTIVE_LENS_START,\n+ ANDROID_AUTOMOTIVE_LENS_END },\n+ [ANDROID_EXTENSION] = { ANDROID_EXTENSION_START,\n+ ANDROID_EXTENSION_END },\n+ [ANDROID_JPEGR] = { ANDROID_JPEGR_START,\n+ ANDROID_JPEGR_END },\n+ [ANDROID_SHARED_SESSION] = { ANDROID_SHARED_SESSION_START,\n+ ANDROID_SHARED_SESSION_END },\n+ [ANDROID_DESKTOP_EFFECTS] = { ANDROID_DESKTOP_EFFECTS_START,\n+ ANDROID_DESKTOP_EFFECTS_END },\n };\n \n static tag_info_t android_color_correction[ANDROID_COLOR_CORRECTION_END -\n@@ -136,6 +160,14 @@ static tag_info_t android_color_correction[ANDROID_COLOR_CORRECTION_END -\n { \"aberrationMode\", TYPE_BYTE },\n [ ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES - ANDROID_COLOR_CORRECTION_START ] =\n { \"availableAberrationModes\", TYPE_BYTE },\n+ [ ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE - ANDROID_COLOR_CORRECTION_START ] =\n+ { \"colorTemperature\", TYPE_INT32 },\n+ [ ANDROID_COLOR_CORRECTION_COLOR_TINT - ANDROID_COLOR_CORRECTION_START ] =\n+ { \"colorTint\", TYPE_INT32 },\n+ [ ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE_RANGE - ANDROID_COLOR_CORRECTION_START ] =\n+ { \"colorTemperatureRange\", TYPE_INT32 },\n+ [ ANDROID_COLOR_CORRECTION_AVAILABLE_MODES - ANDROID_COLOR_CORRECTION_START ] =\n+ { \"availableModes\", TYPE_BYTE },\n };\n \n static tag_info_t android_control[ANDROID_CONTROL_END -\n@@ -229,6 +261,50 @@ static tag_info_t android_control[ANDROID_CONTROL_END -\n { \"enableZsl\", TYPE_BYTE },\n [ ANDROID_CONTROL_AF_SCENE_CHANGE - ANDROID_CONTROL_START ] =\n { \"afSceneChange\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES - ANDROID_CONTROL_START ] =\n+ { \"availableExtendedSceneModeMaxSizes\",\n+ TYPE_INT32 },\n+ [ ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES - ANDROID_CONTROL_START ] =\n+ { \"availableExtendedSceneModeZoomRatioRanges\",\n+ TYPE_FLOAT },\n+ [ ANDROID_CONTROL_EXTENDED_SCENE_MODE - ANDROID_CONTROL_START ] =\n+ { \"extendedSceneMode\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_ZOOM_RATIO_RANGE - ANDROID_CONTROL_START ] =\n+ { \"zoomRatioRange\", TYPE_FLOAT },\n+ [ ANDROID_CONTROL_ZOOM_RATIO - ANDROID_CONTROL_START ] =\n+ { \"zoomRatio\", TYPE_FLOAT },\n+ [ ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_CONTROL_START ] =\n+ { \"availableHighSpeedVideoConfigurationsMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_CONTROL_AF_REGIONS_SET - ANDROID_CONTROL_START ] =\n+ { \"afRegionsSet\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_AE_REGIONS_SET - ANDROID_CONTROL_START ] =\n+ { \"aeRegionsSet\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_AWB_REGIONS_SET - ANDROID_CONTROL_START ] =\n+ { \"awbRegionsSet\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_SETTINGS_OVERRIDE - ANDROID_CONTROL_START ] =\n+ { \"settingsOverride\", TYPE_INT32 },\n+ [ ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES - ANDROID_CONTROL_START ] =\n+ { \"availableSettingsOverrides\", TYPE_INT32 },\n+ [ ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER - ANDROID_CONTROL_START ] =\n+ { \"settingsOverridingFrameNumber\", TYPE_INT32 },\n+ [ ANDROID_CONTROL_AUTOFRAMING - ANDROID_CONTROL_START ] =\n+ { \"autoframing\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_AUTOFRAMING_AVAILABLE - ANDROID_CONTROL_START ] =\n+ { \"autoframingAvailable\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_AUTOFRAMING_STATE - ANDROID_CONTROL_START ] =\n+ { \"autoframingState\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_LOW_LIGHT_BOOST_INFO_LUMINANCE_RANGE - ANDROID_CONTROL_START ] =\n+ { \"lowLightBoostInfoLuminanceRange\",\n+ TYPE_FLOAT },\n+ [ ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE - ANDROID_CONTROL_START ] =\n+ { \"lowLightBoostState\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_ZOOM_METHOD - ANDROID_CONTROL_START ] =\n+ { \"zoomMethod\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_AE_PRIORITY_MODE - ANDROID_CONTROL_START ] =\n+ { \"aePriorityMode\", TYPE_BYTE },\n+ [ ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES - ANDROID_CONTROL_START ] =\n+ { \"aeAvailablePriorityModes\", TYPE_BYTE },\n };\n \n static tag_info_t android_demosaic[ANDROID_DEMOSAIC_END -\n@@ -261,6 +337,16 @@ static tag_info_t android_flash[ANDROID_FLASH_END -\n { \"maxEnergy\", TYPE_BYTE },\n [ ANDROID_FLASH_STATE - ANDROID_FLASH_START ] =\n { \"state\", TYPE_BYTE },\n+ [ ANDROID_FLASH_STRENGTH_LEVEL - ANDROID_FLASH_START ] =\n+ { \"strengthLevel\", TYPE_INT32 },\n+ [ ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL - ANDROID_FLASH_START ] =\n+ { \"singleStrengthMaxLevel\", TYPE_INT32 },\n+ [ ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL - ANDROID_FLASH_START ] =\n+ { \"singleStrengthDefaultLevel\", TYPE_INT32 },\n+ [ ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL - ANDROID_FLASH_START ] =\n+ { \"torchStrengthMaxLevel\", TYPE_INT32 },\n+ [ ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL - ANDROID_FLASH_START ] =\n+ { \"torchStrengthDefaultLevel\", TYPE_INT32 },\n };\n \n static tag_info_t android_flash_info[ANDROID_FLASH_INFO_END -\n@@ -269,6 +355,10 @@ static tag_info_t android_flash_info[ANDROID_FLASH_INFO_END -\n { \"available\", TYPE_BYTE },\n [ ANDROID_FLASH_INFO_CHARGE_DURATION - ANDROID_FLASH_INFO_START ] =\n { \"chargeDuration\", TYPE_INT64 },\n+ [ ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL - ANDROID_FLASH_INFO_START ] =\n+ { \"strengthMaximumLevel\", TYPE_INT32 },\n+ [ ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL - ANDROID_FLASH_INFO_START ] =\n+ { \"strengthDefaultLevel\", TYPE_INT32 },\n };\n \n static tag_info_t android_hot_pixel[ANDROID_HOT_PIXEL_END -\n@@ -333,6 +423,11 @@ static tag_info_t android_lens[ANDROID_LENS_END -\n { \"poseReference\", TYPE_BYTE },\n [ ANDROID_LENS_DISTORTION - ANDROID_LENS_START ] =\n { \"distortion\", TYPE_FLOAT },\n+ [ ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION - ANDROID_LENS_START ] =\n+ { \"distortionMaximumResolution\", TYPE_FLOAT },\n+ [ ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION - ANDROID_LENS_START ] =\n+ { \"intrinsicCalibrationMaximumResolution\",\n+ TYPE_FLOAT },\n };\n \n static tag_info_t android_lens_info[ANDROID_LENS_INFO_END -\n@@ -418,6 +513,18 @@ static tag_info_t android_request[ANDROID_REQUEST_END -\n [ ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS - ANDROID_REQUEST_START ] =\n { \"availablePhysicalCameraRequestKeys\",\n TYPE_INT32 },\n+ [ ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION - ANDROID_REQUEST_START ] =\n+ { \"characteristicKeysNeedingPermission\",\n+ TYPE_INT32 },\n+ [ ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP - ANDROID_REQUEST_START ] =\n+ { \"availableDynamicRangeProfilesMap\",\n+ TYPE_INT64 },\n+ [ ANDROID_REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE - ANDROID_REQUEST_START ] =\n+ { \"recommendedTenBitDynamicRangeProfile\",\n+ TYPE_INT64 },\n+ [ ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP - ANDROID_REQUEST_START ] =\n+ { \"availableColorSpaceProfilesMap\",\n+ TYPE_INT64 },\n };\n \n static tag_info_t android_scaler[ANDROID_SCALER_END -\n@@ -452,6 +559,45 @@ static tag_info_t android_scaler[ANDROID_SCALER_END -\n { \"availableStallDurations\", TYPE_INT64 },\n [ ANDROID_SCALER_CROPPING_TYPE - ANDROID_SCALER_START ] =\n { \"croppingType\", TYPE_BYTE },\n+ [ ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS - ANDROID_SCALER_START ] =\n+ { \"availableRecommendedStreamConfigurations\",\n+ TYPE_INT32 },\n+ [ ANDROID_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP - ANDROID_SCALER_START ] =\n+ { \"availableRecommendedInputOutputFormatsMap\",\n+ TYPE_INT32 },\n+ [ ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES - ANDROID_SCALER_START ] =\n+ { \"availableRotateAndCropModes\", TYPE_BYTE },\n+ [ ANDROID_SCALER_ROTATE_AND_CROP - ANDROID_SCALER_START ] =\n+ { \"rotateAndCrop\", TYPE_BYTE },\n+ [ ANDROID_SCALER_DEFAULT_SECURE_IMAGE_SIZE - ANDROID_SCALER_START ] =\n+ { \"defaultSecureImageSize\", TYPE_INT32 },\n+ [ ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS - ANDROID_SCALER_START ] =\n+ { \"physicalCameraMultiResolutionStreamConfigurations\",\n+ TYPE_INT32 },\n+ [ ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_SCALER_START ] =\n+ { \"availableStreamConfigurationsMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_SCALER_START ] =\n+ { \"availableMinFrameDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_SCALER_AVAILABLE_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_SCALER_START ] =\n+ { \"availableStallDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION - ANDROID_SCALER_START ] =\n+ { \"availableInputOutputFormatsMapMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED - ANDROID_SCALER_START ] =\n+ { \"multiResolutionStreamSupported\",\n+ TYPE_BYTE },\n+ [ ANDROID_SCALER_CROP_REGION_SET - ANDROID_SCALER_START ] =\n+ { \"cropRegionSet\", TYPE_BYTE },\n+ [ ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES - ANDROID_SCALER_START ] =\n+ { \"availableStreamUseCases\", TYPE_INT64 },\n+ [ ANDROID_SCALER_RAW_CROP_REGION - ANDROID_SCALER_START ] =\n+ { \"rawCropRegion\", TYPE_INT32 },\n+ [ ANDROID_SCALER_CONCURRENT_MULTI_RESOLUTION_FORMATS - ANDROID_SCALER_START ] =\n+ { \"concurrentMultiResolutionFormats\",\n+ TYPE_INT32 },\n };\n \n static tag_info_t android_sensor[ANDROID_SENSOR_END -\n@@ -526,6 +672,15 @@ static tag_info_t android_sensor[ANDROID_SENSOR_END -\n { \"dynamicWhiteLevel\", TYPE_INT32 },\n [ ANDROID_SENSOR_OPAQUE_RAW_SIZE - ANDROID_SENSOR_START ] =\n { \"opaqueRawSize\", TYPE_INT32 },\n+ [ ANDROID_SENSOR_OPAQUE_RAW_SIZE_MAXIMUM_RESOLUTION - ANDROID_SENSOR_START ] =\n+ { \"opaqueRawSizeMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_SENSOR_PIXEL_MODE - ANDROID_SENSOR_START ] =\n+ { \"pixelMode\", TYPE_BYTE },\n+ [ ANDROID_SENSOR_RAW_BINNING_FACTOR_USED - ANDROID_SENSOR_START ] =\n+ { \"rawBinningFactorUsed\", TYPE_BYTE },\n+ [ ANDROID_SENSOR_READOUT_TIMESTAMP - ANDROID_SENSOR_START ] =\n+ { \"readoutTimestamp\", TYPE_BYTE },\n };\n \n static tag_info_t android_sensor_info[ANDROID_SENSOR_INFO_END -\n@@ -552,6 +707,17 @@ static tag_info_t android_sensor_info[ANDROID_SENSOR_INFO_END -\n { \"lensShadingApplied\", TYPE_BYTE },\n [ ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE - ANDROID_SENSOR_INFO_START ] =\n { \"preCorrectionActiveArraySize\", TYPE_INT32 },\n+ [ ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION - ANDROID_SENSOR_INFO_START ] =\n+ { \"activeArraySizeMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION - ANDROID_SENSOR_INFO_START ] =\n+ { \"pixelArraySizeMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION - ANDROID_SENSOR_INFO_START ] =\n+ { \"preCorrectionActiveArraySizeMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_SENSOR_INFO_BINNING_FACTOR - ANDROID_SENSOR_INFO_START ] =\n+ { \"binningFactor\", TYPE_INT32 },\n };\n \n static tag_info_t android_shading[ANDROID_SHADING_END -\n@@ -609,6 +775,10 @@ static tag_info_t android_statistics[ANDROID_STATISTICS_END -\n { \"oisXShifts\", TYPE_FLOAT },\n [ ANDROID_STATISTICS_OIS_Y_SHIFTS - ANDROID_STATISTICS_START ] =\n { \"oisYShifts\", TYPE_FLOAT },\n+ [ ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS - ANDROID_STATISTICS_START ] =\n+ { \"lensIntrinsicTimestamps\", TYPE_INT64 },\n+ [ ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES - ANDROID_STATISTICS_START ] =\n+ { \"lensIntrinsicSamples\", TYPE_FLOAT },\n };\n \n static tag_info_t android_statistics_info[ANDROID_STATISTICS_INFO_END -\n@@ -667,6 +837,18 @@ static tag_info_t android_info[ANDROID_INFO_END -\n { \"supportedHardwareLevel\", TYPE_BYTE },\n [ ANDROID_INFO_VERSION - ANDROID_INFO_START ] =\n { \"version\", TYPE_BYTE },\n+ [ ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION - ANDROID_INFO_START ] =\n+ { \"supportedBufferManagementVersion\",\n+ TYPE_BYTE },\n+ [ ANDROID_INFO_DEVICE_STATE_ORIENTATIONS - ANDROID_INFO_START ] =\n+ { \"deviceStateOrientations\", TYPE_INT64 },\n+ [ ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION - ANDROID_INFO_START ] =\n+ { \"sessionConfigurationQueryVersion\",\n+ TYPE_INT32 },\n+ [ ANDROID_INFO_DEVICE_ID - ANDROID_INFO_START ] =\n+ { \"deviceId\", TYPE_INT32 },\n+ [ ANDROID_INFO_DEVICE_TYPE - ANDROID_INFO_START ] =\n+ { \"deviceType\", TYPE_BYTE },\n };\n \n static tag_info_t android_black_level[ANDROID_BLACK_LEVEL_END -\n@@ -705,6 +887,36 @@ static tag_info_t android_depth[ANDROID_DEPTH_END -\n { \"availableDepthStallDurations\", TYPE_INT64 },\n [ ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE - ANDROID_DEPTH_START ] =\n { \"depthIsExclusive\", TYPE_BYTE },\n+ [ ANDROID_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS - ANDROID_DEPTH_START ] =\n+ { \"availableRecommendedDepthStreamConfigurations\",\n+ TYPE_INT32 },\n+ [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS - ANDROID_DEPTH_START ] =\n+ { \"availableDynamicDepthStreamConfigurations\",\n+ TYPE_INT32 },\n+ [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS - ANDROID_DEPTH_START ] =\n+ { \"availableDynamicDepthMinFrameDurations\",\n+ TYPE_INT64 },\n+ [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS - ANDROID_DEPTH_START ] =\n+ { \"availableDynamicDepthStallDurations\",\n+ TYPE_INT64 },\n+ [ ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =\n+ { \"availableDepthStreamConfigurationsMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =\n+ { \"availableDepthMinFrameDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =\n+ { \"availableDepthStallDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =\n+ { \"availableDynamicDepthStreamConfigurationsMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =\n+ { \"availableDynamicDepthMinFrameDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_DEPTH_START ] =\n+ { \"availableDynamicDepthStallDurationsMaximumResolution\",\n+ TYPE_INT64 },\n };\n \n static tag_info_t android_logical_multi_camera[ANDROID_LOGICAL_MULTI_CAMERA_END -\n@@ -713,6 +925,13 @@ static tag_info_t android_logical_multi_camera[ANDROID_LOGICAL_MULTI_CAMERA_END\n { \"physicalIds\", TYPE_BYTE },\n [ ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE - ANDROID_LOGICAL_MULTI_CAMERA_START ] =\n { \"sensorSyncType\", TYPE_BYTE },\n+ [ ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID - ANDROID_LOGICAL_MULTI_CAMERA_START ] =\n+ { \"activePhysicalId\", TYPE_BYTE },\n+ [ ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION - ANDROID_LOGICAL_MULTI_CAMERA_START ] =\n+ { \"activePhysicalSensorCropRegion\",\n+ TYPE_INT32 },\n+ [ ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS - ANDROID_LOGICAL_MULTI_CAMERA_START ] =\n+ { \"additionalResults\", TYPE_BYTE },\n };\n \n static tag_info_t android_distortion_correction[ANDROID_DISTORTION_CORRECTION_END -\n@@ -723,6 +942,120 @@ static tag_info_t android_distortion_correction[ANDROID_DISTORTION_CORRECTION_EN\n { \"availableModes\", TYPE_BYTE },\n };\n \n+static tag_info_t android_heic[ANDROID_HEIC_END -\n+ ANDROID_HEIC_START] = {\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS - ANDROID_HEIC_START ] =\n+ { \"availableHeicStreamConfigurations\",\n+ TYPE_INT32 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS - ANDROID_HEIC_START ] =\n+ { \"availableHeicMinFrameDurations\",\n+ TYPE_INT64 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS - ANDROID_HEIC_START ] =\n+ { \"availableHeicStallDurations\", TYPE_INT64 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =\n+ { \"availableHeicStreamConfigurationsMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =\n+ { \"availableHeicMinFrameDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =\n+ { \"availableHeicStallDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS - ANDROID_HEIC_START ] =\n+ { \"availableHeicUltraHdrStreamConfigurations\",\n+ TYPE_INT32 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS - ANDROID_HEIC_START ] =\n+ { \"availableHeicUltraHdrMinFrameDurations\",\n+ TYPE_INT64 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS - ANDROID_HEIC_START ] =\n+ { \"availableHeicUltraHdrStallDurations\",\n+ TYPE_INT64 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =\n+ { \"availableHeicUltraHdrStreamConfigurationsMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =\n+ { \"availableHeicUltraHdrMinFrameDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_HEIC_START ] =\n+ { \"availableHeicUltraHdrStallDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+};\n+\n+static tag_info_t android_heic_info[ANDROID_HEIC_INFO_END -\n+ ANDROID_HEIC_INFO_START] = {\n+ [ ANDROID_HEIC_INFO_SUPPORTED - ANDROID_HEIC_INFO_START ] =\n+ { \"supported\", TYPE_BYTE },\n+ [ ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT - ANDROID_HEIC_INFO_START ] =\n+ { \"maxJpegAppSegmentsCount\", TYPE_BYTE },\n+};\n+\n+static tag_info_t android_automotive[ANDROID_AUTOMOTIVE_END -\n+ ANDROID_AUTOMOTIVE_START] = {\n+ [ ANDROID_AUTOMOTIVE_LOCATION - ANDROID_AUTOMOTIVE_START ] =\n+ { \"location\", TYPE_BYTE },\n+};\n+\n+static tag_info_t android_automotive_lens[ANDROID_AUTOMOTIVE_LENS_END -\n+ ANDROID_AUTOMOTIVE_LENS_START] = {\n+ [ ANDROID_AUTOMOTIVE_LENS_FACING - ANDROID_AUTOMOTIVE_LENS_START ] =\n+ { \"facing\", TYPE_BYTE },\n+};\n+\n+static tag_info_t android_extension[ANDROID_EXTENSION_END -\n+ ANDROID_EXTENSION_START] = {\n+ [ ANDROID_EXTENSION_STRENGTH - ANDROID_EXTENSION_START ] =\n+ { \"strength\", TYPE_INT32 },\n+ [ ANDROID_EXTENSION_CURRENT_TYPE - ANDROID_EXTENSION_START ] =\n+ { \"currentType\", TYPE_INT32 },\n+ [ ANDROID_EXTENSION_NIGHT_MODE_INDICATOR - ANDROID_EXTENSION_START ] =\n+ { \"nightModeIndicator\", TYPE_INT32 },\n+};\n+\n+static tag_info_t android_jpegr[ANDROID_JPEGR_END -\n+ ANDROID_JPEGR_START] = {\n+ [ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS - ANDROID_JPEGR_START ] =\n+ { \"availableJpegRStreamConfigurations\",\n+ TYPE_INT32 },\n+ [ ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS - ANDROID_JPEGR_START ] =\n+ { \"availableJpegRMinFrameDurations\",\n+ TYPE_INT64 },\n+ [ ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS - ANDROID_JPEGR_START ] =\n+ { \"availableJpegRStallDurations\", TYPE_INT64 },\n+ [ ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION - ANDROID_JPEGR_START ] =\n+ { \"availableJpegRStreamConfigurationsMaximumResolution\",\n+ TYPE_INT32 },\n+ [ ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_JPEGR_START ] =\n+ { \"availableJpegRMinFrameDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+ [ ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS_MAXIMUM_RESOLUTION - ANDROID_JPEGR_START ] =\n+ { \"availableJpegRStallDurationsMaximumResolution\",\n+ TYPE_INT64 },\n+};\n+\n+static tag_info_t android_shared_session[ANDROID_SHARED_SESSION_END -\n+ ANDROID_SHARED_SESSION_START] = {\n+ [ ANDROID_SHARED_SESSION_COLOR_SPACE - ANDROID_SHARED_SESSION_START ] =\n+ { \"colorSpace\", TYPE_INT32 },\n+ [ ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS - ANDROID_SHARED_SESSION_START ] =\n+ { \"outputConfigurations\", TYPE_INT64 },\n+};\n+\n+static tag_info_t android_desktop_effects[ANDROID_DESKTOP_EFFECTS_END -\n+ ANDROID_DESKTOP_EFFECTS_START] = {\n+ [ ANDROID_DESKTOP_EFFECTS_CAPABILITIES - ANDROID_DESKTOP_EFFECTS_START ] =\n+ { \"capabilities\", TYPE_BYTE },\n+ [ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODES - ANDROID_DESKTOP_EFFECTS_START ] =\n+ { \"backgroundBlurModes\", TYPE_BYTE },\n+ [ ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE - ANDROID_DESKTOP_EFFECTS_START ] =\n+ { \"backgroundBlurMode\", TYPE_BYTE },\n+ [ ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE - ANDROID_DESKTOP_EFFECTS_START ] =\n+ { \"faceRetouchMode\", TYPE_BYTE },\n+ [ ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_STRENGTH - ANDROID_DESKTOP_EFFECTS_START ] =\n+ { \"faceRetouchStrength\", TYPE_BYTE },\n+ [ ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE - ANDROID_DESKTOP_EFFECTS_START ] =\n+ { \"portraitRelightMode\", TYPE_BYTE },\n+};\n+\n \n tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {\n android_color_correction,\n@@ -753,6 +1086,35 @@ tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {\n android_depth,\n android_logical_multi_camera,\n android_distortion_correction,\n+ android_heic,\n+ android_heic_info,\n+ android_automotive,\n+ android_automotive_lens,\n+ android_extension,\n+ android_jpegr,\n+ android_shared_session,\n+ android_desktop_effects,\n+};\n+\n+static int32_t tag_permission_needed[18] = {\n+ ANDROID_LENS_POSE_ROTATION,\n+ ANDROID_LENS_POSE_TRANSLATION,\n+ ANDROID_LENS_INTRINSIC_CALIBRATION,\n+ ANDROID_LENS_RADIAL_DISTORTION,\n+ ANDROID_LENS_POSE_REFERENCE,\n+ ANDROID_LENS_DISTORTION,\n+ ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION,\n+ ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION,\n+ ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,\n+ ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,\n+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1,\n+ ANDROID_SENSOR_REFERENCE_ILLUMINANT2,\n+ ANDROID_SENSOR_CALIBRATION_TRANSFORM1,\n+ ANDROID_SENSOR_CALIBRATION_TRANSFORM2,\n+ ANDROID_SENSOR_COLOR_TRANSFORM1,\n+ ANDROID_SENSOR_COLOR_TRANSFORM2,\n+ ANDROID_SENSOR_FORWARD_MATRIX1,\n+ ANDROID_SENSOR_FORWARD_MATRIX2,\n };\n \n int camera_metadata_enum_snprint(uint32_t tag,\n@@ -777,6 +1139,10 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"HIGH_QUALITY\";\n ret = 0;\n break;\n+ case ANDROID_COLOR_CORRECTION_MODE_CCT:\n+ msg = \"CCT\";\n+ ret = 0;\n+ break;\n default:\n msg = \"error: enum value out of range\";\n }\n@@ -810,6 +1176,18 @@ int camera_metadata_enum_snprint(uint32_t tag,\n case ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES: {\n break;\n }\n+ case ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_COLOR_TINT: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE_RANGE: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_AVAILABLE_MODES: {\n+ break;\n+ }\n \n case ANDROID_CONTROL_AE_ANTIBANDING_MODE: {\n switch (value) {\n@@ -878,6 +1256,10 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"ON_EXTERNAL_FLASH\";\n ret = 0;\n break;\n+ case ANDROID_CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY:\n+ msg = \"ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY\";\n+ ret = 0;\n+ break;\n default:\n msg = \"error: enum value out of range\";\n }\n@@ -1122,6 +1504,10 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"OFF_KEEP_STATE\";\n ret = 0;\n break;\n+ case ANDROID_CONTROL_MODE_USE_EXTENDED_SCENE_MODE:\n+ msg = \"USE_EXTENDED_SCENE_MODE\";\n+ ret = 0;\n+ break;\n default:\n msg = \"error: enum value out of range\";\n }\n@@ -1232,6 +1618,10 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"ON\";\n ret = 0;\n break;\n+ case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION:\n+ msg = \"PREVIEW_STABILIZATION\";\n+ ret = 0;\n+ break;\n default:\n msg = \"error: enum value out of range\";\n }\n@@ -1440,6 +1830,222 @@ int camera_metadata_enum_snprint(uint32_t tag,\n }\n break;\n }\n+ case ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_EXTENDED_SCENE_MODE: {\n+ switch (value) {\n+ case ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED:\n+ msg = \"DISABLED\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_STILL_CAPTURE:\n+ msg = \"BOKEH_STILL_CAPTURE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS:\n+ msg = \"BOKEH_CONTINUOUS\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START:\n+ msg = \"VENDOR_START\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_ZOOM_RATIO_RANGE: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_ZOOM_RATIO: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_REGIONS_SET: {\n+ switch (value) {\n+ case ANDROID_CONTROL_AF_REGIONS_SET_FALSE:\n+ msg = \"FALSE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AF_REGIONS_SET_TRUE:\n+ msg = \"TRUE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_REGIONS_SET: {\n+ switch (value) {\n+ case ANDROID_CONTROL_AE_REGIONS_SET_FALSE:\n+ msg = \"FALSE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AE_REGIONS_SET_TRUE:\n+ msg = \"TRUE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AWB_REGIONS_SET: {\n+ switch (value) {\n+ case ANDROID_CONTROL_AWB_REGIONS_SET_FALSE:\n+ msg = \"FALSE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AWB_REGIONS_SET_TRUE:\n+ msg = \"TRUE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_SETTINGS_OVERRIDE: {\n+ switch (value) {\n+ case ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF:\n+ msg = \"OFF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_SETTINGS_OVERRIDE_ZOOM:\n+ msg = \"ZOOM\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_SETTINGS_OVERRIDE_VENDOR_START:\n+ msg = \"VENDOR_START\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AUTOFRAMING: {\n+ switch (value) {\n+ case ANDROID_CONTROL_AUTOFRAMING_OFF:\n+ msg = \"OFF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AUTOFRAMING_ON:\n+ msg = \"ON\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AUTOFRAMING_AUTO:\n+ msg = \"AUTO\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AUTOFRAMING_AVAILABLE: {\n+ switch (value) {\n+ case ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_FALSE:\n+ msg = \"FALSE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_TRUE:\n+ msg = \"TRUE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AUTOFRAMING_STATE: {\n+ switch (value) {\n+ case ANDROID_CONTROL_AUTOFRAMING_STATE_INACTIVE:\n+ msg = \"INACTIVE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AUTOFRAMING_STATE_FRAMING:\n+ msg = \"FRAMING\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AUTOFRAMING_STATE_CONVERGED:\n+ msg = \"CONVERGED\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_LOW_LIGHT_BOOST_INFO_LUMINANCE_RANGE: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE: {\n+ switch (value) {\n+ case ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_INACTIVE:\n+ msg = \"INACTIVE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_ACTIVE:\n+ msg = \"ACTIVE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_ZOOM_METHOD: {\n+ switch (value) {\n+ case ANDROID_CONTROL_ZOOM_METHOD_AUTO:\n+ msg = \"AUTO\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_ZOOM_METHOD_ZOOM_RATIO:\n+ msg = \"ZOOM_RATIO\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_PRIORITY_MODE: {\n+ switch (value) {\n+ case ANDROID_CONTROL_AE_PRIORITY_MODE_OFF:\n+ msg = \"OFF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_SENSITIVITY_PRIORITY:\n+ msg = \"SENSOR_SENSITIVITY_PRIORITY\";\n+ ret = 0;\n+ break;\n+ case ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_EXPOSURE_TIME_PRIORITY:\n+ msg = \"SENSOR_EXPOSURE_TIME_PRIORITY\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES: {\n+ break;\n+ }\n \n case ANDROID_DEMOSAIC_MODE: {\n switch (value) {\n@@ -1545,6 +2151,21 @@ int camera_metadata_enum_snprint(uint32_t tag,\n }\n break;\n }\n+ case ANDROID_FLASH_STRENGTH_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL: {\n+ break;\n+ }\n \n case ANDROID_FLASH_INFO_AVAILABLE: {\n switch (value) {\n@@ -1564,6 +2185,12 @@ int camera_metadata_enum_snprint(uint32_t tag,\n case ANDROID_FLASH_INFO_CHARGE_DURATION: {\n break;\n }\n+ case ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL: {\n+ break;\n+ }\n \n case ANDROID_HOT_PIXEL_MODE: {\n switch (value) {\n@@ -1705,6 +2332,14 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"GYROSCOPE\";\n ret = 0;\n break;\n+ case ANDROID_LENS_POSE_REFERENCE_UNDEFINED:\n+ msg = \"UNDEFINED\";\n+ ret = 0;\n+ break;\n+ case ANDROID_LENS_POSE_REFERENCE_AUTOMOTIVE:\n+ msg = \"AUTOMOTIVE\";\n+ ret = 0;\n+ break;\n default:\n msg = \"error: enum value out of range\";\n }\n@@ -1713,6 +2348,12 @@ int camera_metadata_enum_snprint(uint32_t tag,\n case ANDROID_LENS_DISTORTION: {\n break;\n }\n+ case ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n \n case ANDROID_LENS_INFO_AVAILABLE_APERTURES: {\n break;\n@@ -1931,6 +2572,38 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"MONOCHROME\";\n ret = 0;\n break;\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA:\n+ msg = \"SECURE_IMAGE_DATA\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA:\n+ msg = \"SYSTEM_CAMERA\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING:\n+ msg = \"OFFLINE_PROCESSING\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR:\n+ msg = \"ULTRA_HIGH_RESOLUTION_SENSOR\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING:\n+ msg = \"REMOSAIC_REPROCESSING\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT:\n+ msg = \"DYNAMIC_RANGE_TEN_BIT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE:\n+ msg = \"STREAM_USE_CASE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_COLOR_SPACE_PROFILES:\n+ msg = \"COLOR_SPACE_PROFILES\";\n+ ret = 0;\n+ break;\n default:\n msg = \"error: enum value out of range\";\n }\n@@ -1951,6 +2624,146 @@ int camera_metadata_enum_snprint(uint32_t tag,\n case ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS: {\n break;\n }\n+ case ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP: {\n+ switch (value) {\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD:\n+ msg = \"STANDARD\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10:\n+ msg = \"HLG10\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10:\n+ msg = \"HDR10\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS:\n+ msg = \"HDR10_PLUS\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF:\n+ msg = \"DOLBY_VISION_10B_HDR_REF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO:\n+ msg = \"DOLBY_VISION_10B_HDR_REF_PO\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM:\n+ msg = \"DOLBY_VISION_10B_HDR_OEM\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO:\n+ msg = \"DOLBY_VISION_10B_HDR_OEM_PO\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF:\n+ msg = \"DOLBY_VISION_8B_HDR_REF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO:\n+ msg = \"DOLBY_VISION_8B_HDR_REF_PO\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM:\n+ msg = \"DOLBY_VISION_8B_HDR_OEM\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO:\n+ msg = \"DOLBY_VISION_8B_HDR_OEM_PO\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX:\n+ msg = \"MAX\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD_SMPTE_2094_50:\n+ msg = \"STANDARD_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10_SMPTE_2094_50:\n+ msg = \"HLG10_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_SMPTE_2094_50:\n+ msg = \"HDR10_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS_SMPTE_2094_50:\n+ msg = \"HDR10_PLUS_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50:\n+ msg = \"DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50:\n+ msg = \"DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50:\n+ msg = \"DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50:\n+ msg = \"DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50:\n+ msg = \"DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50:\n+ msg = \"DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50:\n+ msg = \"DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50:\n+ msg = \"DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX_312:\n+ msg = \"MAX_312\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP: {\n+ switch (value) {\n+ case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED:\n+ msg = \"UNSPECIFIED\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB:\n+ msg = \"SRGB\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3:\n+ msg = \"DISPLAY_P3\";\n+ ret = 0;\n+ break;\n+ case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_BT2020_HLG:\n+ msg = \"BT2020_HLG\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n \n case ANDROID_SCALER_CROP_REGION: {\n break;\n@@ -1985,6 +2798,22 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"BLOB\";\n ret = 0;\n break;\n+ case ANDROID_SCALER_AVAILABLE_FORMATS_RAW10:\n+ msg = \"RAW10\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_FORMATS_RAW12:\n+ msg = \"RAW12\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_FORMATS_RAW14:\n+ msg = \"RAW14\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_FORMATS_Y8:\n+ msg = \"Y8\";\n+ ret = 0;\n+ break;\n default:\n msg = \"error: enum value out of range\";\n }\n@@ -2050,6 +2879,207 @@ int camera_metadata_enum_snprint(uint32_t tag,\n }\n break;\n }\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS: {\n+ switch (value) {\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW:\n+ msg = \"PREVIEW\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD:\n+ msg = \"RECORD\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VIDEO_SNAPSHOT:\n+ msg = \"VIDEO_SNAPSHOT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT:\n+ msg = \"SNAPSHOT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_ZSL:\n+ msg = \"ZSL\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RAW:\n+ msg = \"RAW\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_LOW_LATENCY_SNAPSHOT:\n+ msg = \"LOW_LATENCY_SNAPSHOT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END:\n+ msg = \"PUBLIC_END\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_10BIT_OUTPUT:\n+ msg = \"10BIT_OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END_3_8:\n+ msg = \"PUBLIC_END_3_8\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VENDOR_START:\n+ msg = \"VENDOR_START\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES: {\n+ break;\n+ }\n+ case ANDROID_SCALER_ROTATE_AND_CROP: {\n+ switch (value) {\n+ case ANDROID_SCALER_ROTATE_AND_CROP_NONE:\n+ msg = \"NONE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_ROTATE_AND_CROP_90:\n+ msg = \"90\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_ROTATE_AND_CROP_180:\n+ msg = \"180\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_ROTATE_AND_CROP_270:\n+ msg = \"270\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_ROTATE_AND_CROP_AUTO:\n+ msg = \"AUTO\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_DEFAULT_SECURE_IMAGE_SIZE: {\n+ break;\n+ }\n+ case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS: {\n+ switch (value) {\n+ case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ switch (value) {\n+ case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED: {\n+ switch (value) {\n+ case ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_FALSE:\n+ msg = \"FALSE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_TRUE:\n+ msg = \"TRUE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_CROP_REGION_SET: {\n+ switch (value) {\n+ case ANDROID_SCALER_CROP_REGION_SET_FALSE:\n+ msg = \"FALSE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_CROP_REGION_SET_TRUE:\n+ msg = \"TRUE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES: {\n+ switch (value) {\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT:\n+ msg = \"DEFAULT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW:\n+ msg = \"PREVIEW\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE:\n+ msg = \"STILL_CAPTURE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD:\n+ msg = \"VIDEO_RECORD\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL:\n+ msg = \"PREVIEW_VIDEO_STILL\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL:\n+ msg = \"VIDEO_CALL\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW:\n+ msg = \"CROPPED_RAW\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START:\n+ msg = \"VENDOR_START\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_RAW_CROP_REGION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_CONCURRENT_MULTI_RESOLUTION_FORMATS: {\n+ break;\n+ }\n \n case ANDROID_SENSOR_EXPOSURE_TIME: {\n break;\n@@ -2225,6 +3255,10 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"PN9\";\n ret = 0;\n break;\n+ case ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK:\n+ msg = \"BLACK\";\n+ ret = 0;\n+ break;\n case ANDROID_SENSOR_TEST_PATTERN_MODE_CUSTOM1:\n msg = \"CUSTOM1\";\n ret = 0;\n@@ -2252,16 +3286,64 @@ int camera_metadata_enum_snprint(uint32_t tag,\n case ANDROID_SENSOR_OPAQUE_RAW_SIZE: {\n break;\n }\n-\n- case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE: {\n- break;\n- }\n- case ANDROID_SENSOR_INFO_SENSITIVITY_RANGE: {\n+ case ANDROID_SENSOR_OPAQUE_RAW_SIZE_MAXIMUM_RESOLUTION: {\n break;\n }\n- case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT: {\n+ case ANDROID_SENSOR_PIXEL_MODE: {\n switch (value) {\n- case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB:\n+ case ANDROID_SENSOR_PIXEL_MODE_DEFAULT:\n+ msg = \"DEFAULT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION:\n+ msg = \"MAXIMUM_RESOLUTION\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_RAW_BINNING_FACTOR_USED: {\n+ switch (value) {\n+ case ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_TRUE:\n+ msg = \"TRUE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_FALSE:\n+ msg = \"FALSE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_READOUT_TIMESTAMP: {\n+ switch (value) {\n+ case ANDROID_SENSOR_READOUT_TIMESTAMP_NOT_SUPPORTED:\n+ msg = \"NOT_SUPPORTED\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SENSOR_READOUT_TIMESTAMP_HARDWARE:\n+ msg = \"HARDWARE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_SENSITIVITY_RANGE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT: {\n+ switch (value) {\n+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB:\n msg = \"RGGB\";\n ret = 0;\n break;\n@@ -2281,6 +3363,14 @@ int camera_metadata_enum_snprint(uint32_t tag,\n msg = \"RGB\";\n ret = 0;\n break;\n+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO:\n+ msg = \"MONO\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR:\n+ msg = \"NIR\";\n+ ret = 0;\n+ break;\n default:\n msg = \"error: enum value out of range\";\n }\n@@ -2334,6 +3424,18 @@ int camera_metadata_enum_snprint(uint32_t tag,\n case ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE: {\n break;\n }\n+ case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_BINNING_FACTOR: {\n+ break;\n+ }\n \n case ANDROID_SHADING_MODE: {\n switch (value) {\n@@ -2516,6 +3618,12 @@ int camera_metadata_enum_snprint(uint32_t tag,\n case ANDROID_STATISTICS_OIS_Y_SHIFTS: {\n break;\n }\n+ case ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES: {\n+ break;\n+ }\n \n case ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES: {\n break;\n@@ -2663,6 +3771,69 @@ int camera_metadata_enum_snprint(uint32_t tag,\n case ANDROID_INFO_VERSION: {\n break;\n }\n+ case ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION: {\n+ switch (value) {\n+ case ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5:\n+ msg = \"HIDL_DEVICE_3_5\";\n+ ret = 0;\n+ break;\n+ case ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE:\n+ msg = \"SESSION_CONFIGURABLE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_INFO_DEVICE_STATE_ORIENTATIONS: {\n+ break;\n+ }\n+ case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION: {\n+ switch (value) {\n+ case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_UPSIDE_DOWN_CAKE:\n+ msg = \"UPSIDE_DOWN_CAKE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_VANILLA_ICE_CREAM:\n+ msg = \"VANILLA_ICE_CREAM\";\n+ ret = 0;\n+ break;\n+ case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_BAKLAVA:\n+ msg = \"BAKLAVA\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_INFO_DEVICE_ID: {\n+ break;\n+ }\n+ case ANDROID_INFO_DEVICE_TYPE: {\n+ switch (value) {\n+ case ANDROID_INFO_DEVICE_TYPE_BUILT_IN:\n+ msg = \"BUILT_IN\";\n+ ret = 0;\n+ break;\n+ case ANDROID_INFO_DEVICE_TYPE_EXTERNAL:\n+ msg = \"EXTERNAL\";\n+ ret = 0;\n+ break;\n+ case ANDROID_INFO_DEVICE_TYPE_VIRTUAL:\n+ msg = \"VIRTUAL\";\n+ ret = 0;\n+ break;\n+ case ANDROID_INFO_DEVICE_TYPE_UNKNOWN:\n+ msg = \"UNKNOWN\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n \n case ANDROID_BLACK_LEVEL_LOCK: {\n switch (value) {\n@@ -2757,6 +3928,72 @@ int camera_metadata_enum_snprint(uint32_t tag,\n }\n break;\n }\n+ case ANDROID_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS: {\n+ switch (value) {\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ switch (value) {\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ switch (value) {\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n \n case ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS: {\n break;\n@@ -2776,6 +4013,27 @@ int camera_metadata_enum_snprint(uint32_t tag,\n }\n break;\n }\n+ case ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID: {\n+ break;\n+ }\n+ case ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION: {\n+ break;\n+ }\n+ case ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS: {\n+ switch (value) {\n+ case ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_OFF:\n+ msg = \"OFF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_ON:\n+ msg = \"ON\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n \n case ANDROID_DISTORTION_CORRECTION_MODE: {\n switch (value) {\n@@ -2800,13 +4058,4211 @@ int camera_metadata_enum_snprint(uint32_t tag,\n break;\n }\n \n- }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS: {\n+ switch (value) {\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ switch (value) {\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS: {\n+ switch (value) {\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ switch (value) {\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n \n- strncpy(dst, msg, size - 1);\n- dst[size - 1] = '\\0';\n+ case ANDROID_HEIC_INFO_SUPPORTED: {\n+ switch (value) {\n+ case ANDROID_HEIC_INFO_SUPPORTED_FALSE:\n+ msg = \"FALSE\";\n+ ret = 0;\n+ break;\n+ case ANDROID_HEIC_INFO_SUPPORTED_TRUE:\n+ msg = \"TRUE\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT: {\n+ break;\n+ }\n+\n+ case ANDROID_AUTOMOTIVE_LOCATION: {\n+ switch (value) {\n+ case ANDROID_AUTOMOTIVE_LOCATION_INTERIOR:\n+ msg = \"INTERIOR\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_OTHER:\n+ msg = \"EXTERIOR_OTHER\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_FRONT:\n+ msg = \"EXTERIOR_FRONT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_REAR:\n+ msg = \"EXTERIOR_REAR\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_LEFT:\n+ msg = \"EXTERIOR_LEFT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_RIGHT:\n+ msg = \"EXTERIOR_RIGHT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_OTHER:\n+ msg = \"EXTRA_OTHER\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_FRONT:\n+ msg = \"EXTRA_FRONT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_REAR:\n+ msg = \"EXTRA_REAR\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_LEFT:\n+ msg = \"EXTRA_LEFT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LOCATION_EXTRA_RIGHT:\n+ msg = \"EXTRA_RIGHT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_AUTOMOTIVE_LENS_FACING: {\n+ switch (value) {\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_OTHER:\n+ msg = \"EXTERIOR_OTHER\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_FRONT:\n+ msg = \"EXTERIOR_FRONT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_REAR:\n+ msg = \"EXTERIOR_REAR\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_LEFT:\n+ msg = \"EXTERIOR_LEFT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_RIGHT:\n+ msg = \"EXTERIOR_RIGHT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_OTHER:\n+ msg = \"INTERIOR_OTHER\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_LEFT:\n+ msg = \"INTERIOR_SEAT_ROW_1_LEFT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_CENTER:\n+ msg = \"INTERIOR_SEAT_ROW_1_CENTER\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_RIGHT:\n+ msg = \"INTERIOR_SEAT_ROW_1_RIGHT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_LEFT:\n+ msg = \"INTERIOR_SEAT_ROW_2_LEFT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_CENTER:\n+ msg = \"INTERIOR_SEAT_ROW_2_CENTER\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_RIGHT:\n+ msg = \"INTERIOR_SEAT_ROW_2_RIGHT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_LEFT:\n+ msg = \"INTERIOR_SEAT_ROW_3_LEFT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_CENTER:\n+ msg = \"INTERIOR_SEAT_ROW_3_CENTER\";\n+ ret = 0;\n+ break;\n+ case ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_RIGHT:\n+ msg = \"INTERIOR_SEAT_ROW_3_RIGHT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_EXTENSION_STRENGTH: {\n+ break;\n+ }\n+ case ANDROID_EXTENSION_CURRENT_TYPE: {\n+ break;\n+ }\n+ case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR: {\n+ switch (value) {\n+ case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_UNKNOWN:\n+ msg = \"UNKNOWN\";\n+ ret = 0;\n+ break;\n+ case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_OFF:\n+ msg = \"OFF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_ON:\n+ msg = \"ON\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS: {\n+ switch (value) {\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ switch (value) {\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT:\n+ msg = \"OUTPUT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT:\n+ msg = \"INPUT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+\n+ case ANDROID_SHARED_SESSION_COLOR_SPACE: {\n+ switch (value) {\n+ case ANDROID_SHARED_SESSION_COLOR_SPACE_UNSPECIFIED:\n+ msg = \"UNSPECIFIED\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SHARED_SESSION_COLOR_SPACE_SRGB:\n+ msg = \"SRGB\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SHARED_SESSION_COLOR_SPACE_DISPLAY_P3:\n+ msg = \"DISPLAY_P3\";\n+ ret = 0;\n+ break;\n+ case ANDROID_SHARED_SESSION_COLOR_SPACE_BT2020_HLG:\n+ msg = \"BT2020_HLG\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS: {\n+ break;\n+ }\n+\n+ case ANDROID_DESKTOP_EFFECTS_CAPABILITIES: {\n+ switch (value) {\n+ case ANDROID_DESKTOP_EFFECTS_CAPABILITIES_BACKGROUND_BLUR:\n+ msg = \"BACKGROUND_BLUR\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DESKTOP_EFFECTS_CAPABILITIES_FACE_RETOUCH:\n+ msg = \"FACE_RETOUCH\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DESKTOP_EFFECTS_CAPABILITIES_PORTRAIT_RELIGHT:\n+ msg = \"PORTRAIT_RELIGHT\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODES: {\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE: {\n+ switch (value) {\n+ case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_OFF:\n+ msg = \"OFF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_LIGHT:\n+ msg = \"LIGHT\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_FULL:\n+ msg = \"FULL\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE: {\n+ switch (value) {\n+ case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_OFF:\n+ msg = \"OFF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_ON:\n+ msg = \"ON\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_STRENGTH: {\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE: {\n+ switch (value) {\n+ case ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_OFF:\n+ msg = \"OFF\";\n+ ret = 0;\n+ break;\n+ case ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_ON:\n+ msg = \"ON\";\n+ ret = 0;\n+ break;\n+ default:\n+ msg = \"error: enum value out of range\";\n+ }\n+ break;\n+ }\n+\n+ }\n+\n+ strncpy(dst, msg, size - 1);\n+ dst[size - 1] = '\\0';\n+\n+ return ret;\n+}\n+\n+int camera_metadata_enum_value(uint32_t tag,\n+ const char *name,\n+ size_t size,\n+ uint32_t *value) {\n+ if ((name == NULL) || (value == NULL)) {\n+ return -1;\n+ }\n+\n+ const char *enumName = NULL;\n+ int ret = -1;\n+\n+ switch(tag) {\n+ case ANDROID_COLOR_CORRECTION_MODE: {\n+ enumName = \"TRANSFORM_MATRIX\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_COLOR_CORRECTION_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CCT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_COLOR_CORRECTION_MODE_CCT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_TRANSFORM: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_GAINS: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_ABERRATION_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_COLOR_TINT: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_COLOR_TEMPERATURE_RANGE: {\n+ break;\n+ }\n+ case ANDROID_COLOR_CORRECTION_AVAILABLE_MODES: {\n+ break;\n+ }\n+\n+ case ANDROID_CONTROL_AE_ANTIBANDING_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"50HZ\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"60HZ\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"AUTO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_LOCK: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_LOCK_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_LOCK_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON_AUTO_FLASH\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON_ALWAYS_FLASH\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON_AUTO_FLASH_REDEYE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON_EXTERNAL_FLASH\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_MODE_ON_EXTERNAL_FLASH;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_REGIONS: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_TARGET_FPS_RANGE: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER: {\n+ enumName = \"IDLE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"START\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CANCEL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"AUTO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_MODE_AUTO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MACRO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_MODE_MACRO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CONTINUOUS_VIDEO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CONTINUOUS_PICTURE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EDOF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_MODE_EDOF;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_REGIONS: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_TRIGGER: {\n+ enumName = \"IDLE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_TRIGGER_IDLE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"START\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_TRIGGER_START;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CANCEL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_TRIGGER_CANCEL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AWB_LOCK: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_LOCK_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_LOCK_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AWB_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"AUTO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_AUTO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INCANDESCENT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_INCANDESCENT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FLUORESCENT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_FLUORESCENT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"WARM_FLUORESCENT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DAYLIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_DAYLIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CLOUDY_DAYLIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TWILIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_TWILIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SHADE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_MODE_SHADE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AWB_REGIONS: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_CAPTURE_INTENT: {\n+ enumName = \"CUSTOM\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PREVIEW\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"STILL_CAPTURE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VIDEO_RECORD\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VIDEO_SNAPSHOT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ZERO_SHUTTER_LAG\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MANUAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MOTION_TRACKING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_CAPTURE_INTENT_MOTION_TRACKING;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_EFFECT_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MONO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_MONO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"NEGATIVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_NEGATIVE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SOLARIZE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_SOLARIZE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SEPIA\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_SEPIA;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"POSTERIZE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_POSTERIZE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"WHITEBOARD\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BLACKBOARD\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"AQUA\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EFFECT_MODE_AQUA;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"AUTO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_MODE_AUTO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"USE_SCENE_MODE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_MODE_USE_SCENE_MODE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"OFF_KEEP_STATE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_MODE_OFF_KEEP_STATE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"USE_EXTENDED_SCENE_MODE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_MODE_USE_EXTENDED_SCENE_MODE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_SCENE_MODE: {\n+ enumName = \"DISABLED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_DISABLED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FACE_PRIORITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ACTION\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_ACTION;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PORTRAIT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_PORTRAIT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"LANDSCAPE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_LANDSCAPE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"NIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_NIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"NIGHT_PORTRAIT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"THEATRE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_THEATRE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BEACH\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_BEACH;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SNOW\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_SNOW;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SUNSET\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_SUNSET;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"STEADYPHOTO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FIREWORKS\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_FIREWORKS;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SPORTS\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_SPORTS;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PARTY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_PARTY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CANDLELIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BARCODE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_BARCODE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_SPEED_VIDEO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_HIGH_SPEED_VIDEO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HDR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_HDR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FACE_PRIORITY_LOW_LIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY_LOW_LIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DEVICE_CUSTOM_START\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_DEVICE_CUSTOM_START;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DEVICE_CUSTOM_END\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SCENE_MODE_DEVICE_CUSTOM_END;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PREVIEW_STABILIZATION\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_AVAILABLE_MODES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_COMPENSATION_RANGE: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_COMPENSATION_STEP: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_AVAILABLE_MODES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_EFFECTS: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_SCENE_MODES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AWB_AVAILABLE_MODES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_MAX_REGIONS: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_SCENE_MODE_OVERRIDES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_PRECAPTURE_ID: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_STATE: {\n+ enumName = \"INACTIVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_STATE_INACTIVE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SEARCHING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_STATE_SEARCHING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CONVERGED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_STATE_CONVERGED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"LOCKED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_STATE_LOCKED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FLASH_REQUIRED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PRECAPTURE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_STATE_PRECAPTURE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_STATE: {\n+ enumName = \"INACTIVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_STATE_INACTIVE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PASSIVE_SCAN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PASSIVE_FOCUSED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ACTIVE_SCAN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FOCUSED_LOCKED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"NOT_FOCUSED_LOCKED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PASSIVE_UNFOCUSED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_TRIGGER_ID: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AWB_STATE: {\n+ enumName = \"INACTIVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_STATE_INACTIVE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SEARCHING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_STATE_SEARCHING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CONVERGED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_STATE_CONVERGED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"LOCKED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_STATE_LOCKED;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_LOCK_AVAILABLE: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AWB_LOCK_AVAILABLE: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_MODES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_ENABLE_ZSL: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_ENABLE_ZSL_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_ENABLE_ZSL_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_SCENE_CHANGE: {\n+ enumName = \"NOT_DETECTED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_SCENE_CHANGE_NOT_DETECTED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DETECTED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_SCENE_CHANGE_DETECTED;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_EXTENDED_SCENE_MODE: {\n+ enumName = \"DISABLED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BOKEH_STILL_CAPTURE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_STILL_CAPTURE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BOKEH_CONTINUOUS\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VENDOR_START\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_ZOOM_RATIO_RANGE: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_ZOOM_RATIO: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AF_REGIONS_SET: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_REGIONS_SET_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AF_REGIONS_SET_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_REGIONS_SET: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_REGIONS_SET_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_REGIONS_SET_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AWB_REGIONS_SET: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_REGIONS_SET_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AWB_REGIONS_SET_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_SETTINGS_OVERRIDE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ZOOM\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SETTINGS_OVERRIDE_ZOOM;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VENDOR_START\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_SETTINGS_OVERRIDE_VENDOR_START;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_AUTOFRAMING: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AUTOFRAMING_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AUTOFRAMING_ON;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"AUTO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AUTOFRAMING_AUTO;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AUTOFRAMING_AVAILABLE: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AUTOFRAMING_STATE: {\n+ enumName = \"INACTIVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AUTOFRAMING_STATE_INACTIVE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FRAMING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AUTOFRAMING_STATE_FRAMING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CONVERGED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AUTOFRAMING_STATE_CONVERGED;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_LOW_LIGHT_BOOST_INFO_LUMINANCE_RANGE: {\n+ break;\n+ }\n+ case ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE: {\n+ enumName = \"INACTIVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_INACTIVE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ACTIVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_LOW_LIGHT_BOOST_STATE_ACTIVE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_ZOOM_METHOD: {\n+ enumName = \"AUTO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_ZOOM_METHOD_AUTO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ZOOM_RATIO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_ZOOM_METHOD_ZOOM_RATIO;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_PRIORITY_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_PRIORITY_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SENSOR_SENSITIVITY_PRIORITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_SENSITIVITY_PRIORITY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SENSOR_EXPOSURE_TIME_PRIORITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_EXPOSURE_TIME_PRIORITY;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES: {\n+ break;\n+ }\n+\n+ case ANDROID_DEMOSAIC_MODE: {\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEMOSAIC_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_EDGE_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_EDGE_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_EDGE_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_EDGE_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ZERO_SHUTTER_LAG\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_EDGE_MODE_ZERO_SHUTTER_LAG;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_EDGE_STRENGTH: {\n+ break;\n+ }\n+ case ANDROID_EDGE_AVAILABLE_EDGE_MODES: {\n+ break;\n+ }\n+\n+ case ANDROID_FLASH_FIRING_POWER: {\n+ break;\n+ }\n+ case ANDROID_FLASH_FIRING_TIME: {\n+ break;\n+ }\n+ case ANDROID_FLASH_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SINGLE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_MODE_SINGLE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TORCH\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_MODE_TORCH;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_FLASH_COLOR_TEMPERATURE: {\n+ break;\n+ }\n+ case ANDROID_FLASH_MAX_ENERGY: {\n+ break;\n+ }\n+ case ANDROID_FLASH_STATE: {\n+ enumName = \"UNAVAILABLE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_STATE_UNAVAILABLE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CHARGING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_STATE_CHARGING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"READY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_STATE_READY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FIRED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_STATE_FIRED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PARTIAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_STATE_PARTIAL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_FLASH_STRENGTH_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL: {\n+ break;\n+ }\n+\n+ case ANDROID_FLASH_INFO_AVAILABLE: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_INFO_AVAILABLE_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_FLASH_INFO_AVAILABLE_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_FLASH_INFO_CHARGE_DURATION: {\n+ break;\n+ }\n+ case ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL: {\n+ break;\n+ }\n+\n+ case ANDROID_HOT_PIXEL_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HOT_PIXEL_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HOT_PIXEL_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES: {\n+ break;\n+ }\n+\n+ case ANDROID_JPEG_GPS_COORDINATES: {\n+ break;\n+ }\n+ case ANDROID_JPEG_GPS_PROCESSING_METHOD: {\n+ break;\n+ }\n+ case ANDROID_JPEG_GPS_TIMESTAMP: {\n+ break;\n+ }\n+ case ANDROID_JPEG_ORIENTATION: {\n+ break;\n+ }\n+ case ANDROID_JPEG_QUALITY: {\n+ break;\n+ }\n+ case ANDROID_JPEG_THUMBNAIL_QUALITY: {\n+ break;\n+ }\n+ case ANDROID_JPEG_THUMBNAIL_SIZE: {\n+ break;\n+ }\n+ case ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES: {\n+ break;\n+ }\n+ case ANDROID_JPEG_MAX_SIZE: {\n+ break;\n+ }\n+ case ANDROID_JPEG_SIZE: {\n+ break;\n+ }\n+\n+ case ANDROID_LENS_APERTURE: {\n+ break;\n+ }\n+ case ANDROID_LENS_FILTER_DENSITY: {\n+ break;\n+ }\n+ case ANDROID_LENS_FOCAL_LENGTH: {\n+ break;\n+ }\n+ case ANDROID_LENS_FOCUS_DISTANCE: {\n+ break;\n+ }\n+ case ANDROID_LENS_OPTICAL_STABILIZATION_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_LENS_FACING: {\n+ enumName = \"FRONT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_FACING_FRONT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BACK\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_FACING_BACK;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERNAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_FACING_EXTERNAL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_LENS_POSE_ROTATION: {\n+ break;\n+ }\n+ case ANDROID_LENS_POSE_TRANSLATION: {\n+ break;\n+ }\n+ case ANDROID_LENS_FOCUS_RANGE: {\n+ break;\n+ }\n+ case ANDROID_LENS_STATE: {\n+ enumName = \"STATIONARY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_STATE_STATIONARY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MOVING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_STATE_MOVING;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_LENS_INTRINSIC_CALIBRATION: {\n+ break;\n+ }\n+ case ANDROID_LENS_RADIAL_DISTORTION: {\n+ break;\n+ }\n+ case ANDROID_LENS_POSE_REFERENCE: {\n+ enumName = \"PRIMARY_CAMERA\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_POSE_REFERENCE_PRIMARY_CAMERA;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"GYROSCOPE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_POSE_REFERENCE_GYROSCOPE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"UNDEFINED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_POSE_REFERENCE_UNDEFINED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"AUTOMOTIVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_POSE_REFERENCE_AUTOMOTIVE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_LENS_DISTORTION: {\n+ break;\n+ }\n+ case ANDROID_LENS_DISTORTION_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_LENS_INTRINSIC_CALIBRATION_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+\n+ case ANDROID_LENS_INFO_AVAILABLE_APERTURES: {\n+ break;\n+ }\n+ case ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES: {\n+ break;\n+ }\n+ case ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS: {\n+ break;\n+ }\n+ case ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION: {\n+ break;\n+ }\n+ case ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE: {\n+ break;\n+ }\n+ case ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE: {\n+ break;\n+ }\n+ case ANDROID_LENS_INFO_SHADING_MAP_SIZE: {\n+ break;\n+ }\n+ case ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION: {\n+ enumName = \"UNCALIBRATED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"APPROXIMATE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CALIBRATED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_NOISE_REDUCTION_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_NOISE_REDUCTION_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_NOISE_REDUCTION_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MINIMAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_NOISE_REDUCTION_MODE_MINIMAL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ZERO_SHUTTER_LAG\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_NOISE_REDUCTION_STRENGTH: {\n+ break;\n+ }\n+ case ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES: {\n+ break;\n+ }\n+\n+ case ANDROID_QUIRKS_METERING_CROP_REGION: {\n+ break;\n+ }\n+ case ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO: {\n+ break;\n+ }\n+ case ANDROID_QUIRKS_USE_ZSL_FORMAT: {\n+ break;\n+ }\n+ case ANDROID_QUIRKS_USE_PARTIAL_RESULT: {\n+ break;\n+ }\n+ case ANDROID_QUIRKS_PARTIAL_RESULT: {\n+ enumName = \"FINAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_QUIRKS_PARTIAL_RESULT_FINAL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PARTIAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_REQUEST_FRAME_COUNT: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_ID: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_INPUT_STREAMS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_METADATA_MODE: {\n+ enumName = \"NONE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_METADATA_MODE_NONE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FULL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_METADATA_MODE_FULL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_REQUEST_OUTPUT_STREAMS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_TYPE: {\n+ enumName = \"CAPTURE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_TYPE_CAPTURE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"REPROCESS\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_TYPE_REPROCESS;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_MAX_NUM_REPROCESS_STREAMS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_PIPELINE_DEPTH: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_PIPELINE_MAX_DEPTH: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_PARTIAL_RESULT_COUNT: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_CAPABILITIES: {\n+ enumName = \"BACKWARD_COMPATIBLE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MANUAL_SENSOR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MANUAL_POST_PROCESSING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"RAW\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PRIVATE_REPROCESSING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"READ_SENSOR_SETTINGS\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BURST_CAPTURE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"YUV_REPROCESSING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DEPTH_OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CONSTRAINED_HIGH_SPEED_VIDEO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MOTION_TRACKING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"LOGICAL_MULTI_CAMERA\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MONOCHROME\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SECURE_IMAGE_DATA\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SYSTEM_CAMERA\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"OFFLINE_PROCESSING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ULTRA_HIGH_RESOLUTION_SENSOR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"REMOSAIC_REPROCESSING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DYNAMIC_RANGE_TEN_BIT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"STREAM_USE_CASE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"COLOR_SPACE_PROFILES\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_COLOR_SPACE_PROFILES;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_RESULT_KEYS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_SESSION_KEYS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP: {\n+ enumName = \"STANDARD\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HLG10\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HDR10\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HDR10_PLUS\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_10B_HDR_REF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_10B_HDR_REF_PO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_10B_HDR_OEM\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_10B_HDR_OEM_PO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_8B_HDR_REF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_8B_HDR_REF_PO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_8B_HDR_OEM\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_8B_HDR_OEM_PO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MAX\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"STANDARD_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HLG10_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HDR10_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HDR10_PLUS_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HDR10_PLUS_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_REF_PO_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_10B_HDR_OEM_PO_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_REF_PO_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO_SMPTE_2094_50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MAX_312\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX_312;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE: {\n+ break;\n+ }\n+ case ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP: {\n+ enumName = \"UNSPECIFIED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SRGB\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DISPLAY_P3\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BT2020_HLG\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_BT2020_HLG;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_SCALER_CROP_REGION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_FORMATS: {\n+ enumName = \"RAW16\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW16;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"RAW_OPAQUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"YV12\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_YV12;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"YCrCb_420_SP\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_YCrCb_420_SP;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"IMPLEMENTATION_DEFINED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"YCbCr_420_888\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_YCbCr_420_888;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BLOB\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_BLOB;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"RAW10\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW10;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"RAW12\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW12;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"RAW14\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_RAW14;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"Y8\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_FORMATS_Y8;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_JPEG_SIZES: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_RAW_SIZES: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_SCALER_CROPPING_TYPE: {\n+ enumName = \"CENTER_ONLY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FREEFORM\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_CROPPING_TYPE_FREEFORM;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS: {\n+ enumName = \"PREVIEW\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"RECORD\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VIDEO_SNAPSHOT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VIDEO_SNAPSHOT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SNAPSHOT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ZSL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_ZSL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"RAW\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RAW;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"LOW_LATENCY_SNAPSHOT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_LOW_LATENCY_SNAPSHOT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PUBLIC_END\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"10BIT_OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_10BIT_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PUBLIC_END_3_8\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END_3_8;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VENDOR_START\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VENDOR_START;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES: {\n+ break;\n+ }\n+ case ANDROID_SCALER_ROTATE_AND_CROP: {\n+ enumName = \"NONE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_ROTATE_AND_CROP_NONE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"90\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_ROTATE_AND_CROP_90;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"180\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_ROTATE_AND_CROP_180;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"270\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_ROTATE_AND_CROP_270;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"AUTO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_ROTATE_AND_CROP_AUTO;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_DEFAULT_SECURE_IMAGE_SIZE: {\n+ break;\n+ }\n+ case ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_PHYSICAL_CAMERA_MULTI_RESOLUTION_STREAM_CONFIGURATIONS_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_CROP_REGION_SET: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_CROP_REGION_SET_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_CROP_REGION_SET_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES: {\n+ enumName = \"DEFAULT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PREVIEW\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"STILL_CAPTURE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VIDEO_RECORD\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PREVIEW_VIDEO_STILL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VIDEO_CALL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CROPPED_RAW\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VENDOR_START\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SCALER_RAW_CROP_REGION: {\n+ break;\n+ }\n+ case ANDROID_SCALER_CONCURRENT_MULTI_RESOLUTION_FORMATS: {\n+ break;\n+ }\n+\n+ case ANDROID_SENSOR_EXPOSURE_TIME: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_FRAME_DURATION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_SENSITIVITY: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1: {\n+ enumName = \"DAYLIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FLUORESCENT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TUNGSTEN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FLASH\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLASH;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FINE_WEATHER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CLOUDY_WEATHER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SHADE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_SHADE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DAYLIGHT_FLUORESCENT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DAY_WHITE_FLUORESCENT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"COOL_WHITE_FLUORESCENT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"WHITE_FLUORESCENT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"STANDARD_A\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"STANDARD_B\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_B;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"STANDARD_C\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_C;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"D55\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D55;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"D65\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D65;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"D75\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D75;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"D50\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D50;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ISO_STUDIO_TUNGSTEN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT2: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_CALIBRATION_TRANSFORM1: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_CALIBRATION_TRANSFORM2: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_COLOR_TRANSFORM1: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_COLOR_TRANSFORM2: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_FORWARD_MATRIX1: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_FORWARD_MATRIX2: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_BASE_GAIN_FACTOR: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_BLACK_LEVEL_PATTERN: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_ORIENTATION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_PROFILE_HUE_SAT_MAP_DIMENSIONS: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_TIMESTAMP: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_TEMPERATURE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_NEUTRAL_COLOR_POINT: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_NOISE_PROFILE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_PROFILE_HUE_SAT_MAP: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_PROFILE_TONE_CURVE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_GREEN_SPLIT: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_TEST_PATTERN_DATA: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_TEST_PATTERN_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SOLID_COLOR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"COLOR_BARS\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"COLOR_BARS_FADE_TO_GRAY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PN9\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_TEST_PATTERN_MODE_PN9;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BLACK\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CUSTOM1\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_TEST_PATTERN_MODE_CUSTOM1;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_ROLLING_SHUTTER_SKEW: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_OPTICAL_BLACK_REGIONS: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_DYNAMIC_BLACK_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_DYNAMIC_WHITE_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_OPAQUE_RAW_SIZE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_OPAQUE_RAW_SIZE_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_PIXEL_MODE: {\n+ enumName = \"DEFAULT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_PIXEL_MODE_DEFAULT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MAXIMUM_RESOLUTION\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_RAW_BINNING_FACTOR_USED: {\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_RAW_BINNING_FACTOR_USED_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_READOUT_TIMESTAMP: {\n+ enumName = \"NOT_SUPPORTED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_READOUT_TIMESTAMP_NOT_SUPPORTED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HARDWARE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_READOUT_TIMESTAMP_HARDWARE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_SENSITIVITY_RANGE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT: {\n+ enumName = \"RGGB\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"GRBG\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GRBG;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"GBRG\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BGGR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"RGB\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"MONO\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"NIR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_MAX_FRAME_DURATION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_PHYSICAL_SIZE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_WHITE_LEVEL: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE: {\n+ enumName = \"UNKNOWN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"REALTIME\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_LENS_SHADING_APPLIED: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_LENS_SHADING_APPLIED_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SENSOR_INFO_LENS_SHADING_APPLIED_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_SENSOR_INFO_BINNING_FACTOR: {\n+ break;\n+ }\n+\n+ case ANDROID_SHADING_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SHADING_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SHADING_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SHADING_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SHADING_STRENGTH: {\n+ break;\n+ }\n+ case ANDROID_SHADING_AVAILABLE_MODES: {\n+ break;\n+ }\n+\n+ case ANDROID_STATISTICS_FACE_DETECT_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SIMPLE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FULL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_FACE_DETECT_MODE_FULL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_STATISTICS_HISTOGRAM_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_HISTOGRAM_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_STATISTICS_SHARPNESS_MAP_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_SHARPNESS_MAP_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_STATISTICS_FACE_IDS: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_FACE_LANDMARKS: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_FACE_RECTANGLES: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_FACE_SCORES: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_HISTOGRAM: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_SHARPNESS_MAP: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_LENS_SHADING_CORRECTION_MAP: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_LENS_SHADING_MAP: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_PREDICTED_COLOR_GAINS: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_PREDICTED_COLOR_TRANSFORM: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_SCENE_FLICKER: {\n+ enumName = \"NONE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_SCENE_FLICKER_NONE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"50HZ\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_SCENE_FLICKER_50HZ;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"60HZ\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_SCENE_FLICKER_60HZ;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_STATISTICS_HOT_PIXEL_MAP: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_LENS_SHADING_MAP_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_STATISTICS_OIS_DATA_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_OIS_DATA_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_STATISTICS_OIS_DATA_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_STATISTICS_OIS_TIMESTAMPS: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_OIS_X_SHIFTS: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_OIS_Y_SHIFTS: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES: {\n+ break;\n+ }\n+\n+ case ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_INFO_MAX_FACE_COUNT: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES: {\n+ break;\n+ }\n+ case ANDROID_STATISTICS_INFO_AVAILABLE_OIS_DATA_MODES: {\n+ break;\n+ }\n+\n+ case ANDROID_TONEMAP_CURVE_BLUE: {\n+ break;\n+ }\n+ case ANDROID_TONEMAP_CURVE_GREEN: {\n+ break;\n+ }\n+ case ANDROID_TONEMAP_CURVE_RED: {\n+ break;\n+ }\n+ case ANDROID_TONEMAP_MODE: {\n+ enumName = \"CONTRAST_CURVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_TONEMAP_MODE_CONTRAST_CURVE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_TONEMAP_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_TONEMAP_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"GAMMA_VALUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_TONEMAP_MODE_GAMMA_VALUE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PRESET_CURVE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_TONEMAP_MODE_PRESET_CURVE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_TONEMAP_MAX_CURVE_POINTS: {\n+ break;\n+ }\n+ case ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES: {\n+ break;\n+ }\n+ case ANDROID_TONEMAP_GAMMA: {\n+ break;\n+ }\n+ case ANDROID_TONEMAP_PRESET_CURVE: {\n+ enumName = \"SRGB\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_TONEMAP_PRESET_CURVE_SRGB;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"REC709\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_TONEMAP_PRESET_CURVE_REC709;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_LED_TRANSMIT: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LED_TRANSMIT_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LED_TRANSMIT_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_LED_AVAILABLE_LEDS: {\n+ enumName = \"TRANSMIT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LED_AVAILABLE_LEDS_TRANSMIT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL: {\n+ enumName = \"LIMITED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FULL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"LEGACY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"3\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_3;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERNAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_INFO_VERSION: {\n+ break;\n+ }\n+ case ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION: {\n+ enumName = \"HIDL_DEVICE_3_5\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SESSION_CONFIGURABLE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_INFO_DEVICE_STATE_ORIENTATIONS: {\n+ break;\n+ }\n+ case ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION: {\n+ enumName = \"UPSIDE_DOWN_CAKE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_UPSIDE_DOWN_CAKE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VANILLA_ICE_CREAM\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_VANILLA_ICE_CREAM;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BAKLAVA\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_BAKLAVA;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_INFO_DEVICE_ID: {\n+ break;\n+ }\n+ case ANDROID_INFO_DEVICE_TYPE: {\n+ enumName = \"BUILT_IN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_DEVICE_TYPE_BUILT_IN;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERNAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_DEVICE_TYPE_EXTERNAL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"VIRTUAL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_DEVICE_TYPE_VIRTUAL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"UNKNOWN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_INFO_DEVICE_TYPE_UNKNOWN;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_BLACK_LEVEL_LOCK: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_BLACK_LEVEL_LOCK_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_BLACK_LEVEL_LOCK_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_SYNC_FRAME_NUMBER: {\n+ enumName = \"CONVERGING\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SYNC_FRAME_NUMBER_CONVERGING;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"UNKNOWN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SYNC_FRAME_NUMBER_UNKNOWN;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SYNC_MAX_LATENCY: {\n+ enumName = \"PER_FRAME_CONTROL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"UNKNOWN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR: {\n+ break;\n+ }\n+ case ANDROID_REPROCESS_MAX_CAPTURE_STALL: {\n+ break;\n+ }\n+\n+ case ANDROID_DEPTH_MAX_DEPTH_SAMPLES: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+\n+ case ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS: {\n+ break;\n+ }\n+ case ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE: {\n+ enumName = \"APPROXIMATE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_APPROXIMATE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"CALIBRATED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_CALIBRATED;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID: {\n+ break;\n+ }\n+ case ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION: {\n+ break;\n+ }\n+ case ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_LOGICAL_MULTI_CAMERA_ADDITIONAL_RESULTS_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_DISTORTION_CORRECTION_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DISTORTION_CORRECTION_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FAST\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DISTORTION_CORRECTION_MODE_FAST;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"HIGH_QUALITY\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DISTORTION_CORRECTION_MODE_HIGH_QUALITY;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DISTORTION_CORRECTION_AVAILABLE_MODES: {\n+ break;\n+ }\n+\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_HEIC_AVAILABLE_HEIC_ULTRA_HDR_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+\n+ case ANDROID_HEIC_INFO_SUPPORTED: {\n+ enumName = \"FALSE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_INFO_SUPPORTED_FALSE;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"TRUE\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_HEIC_INFO_SUPPORTED_TRUE;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT: {\n+ break;\n+ }\n+\n+ case ANDROID_AUTOMOTIVE_LOCATION: {\n+ enumName = \"INTERIOR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_INTERIOR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_OTHER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_OTHER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_FRONT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_FRONT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_REAR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_REAR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_LEFT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_LEFT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_RIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTERIOR_RIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTRA_OTHER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_OTHER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTRA_FRONT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_FRONT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTRA_REAR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_REAR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTRA_LEFT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_LEFT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTRA_RIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LOCATION_EXTRA_RIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_AUTOMOTIVE_LENS_FACING: {\n+ enumName = \"EXTERIOR_OTHER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_OTHER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_FRONT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_FRONT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_REAR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_REAR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_LEFT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_LEFT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"EXTERIOR_RIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_EXTERIOR_RIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_OTHER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_OTHER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_1_LEFT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_LEFT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_1_CENTER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_CENTER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_1_RIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_1_RIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_2_LEFT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_LEFT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_2_CENTER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_CENTER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_2_RIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_2_RIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_3_LEFT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_LEFT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_3_CENTER\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_CENTER;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INTERIOR_SEAT_ROW_3_RIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_AUTOMOTIVE_LENS_FACING_INTERIOR_SEAT_ROW_3_RIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_EXTENSION_STRENGTH: {\n+ break;\n+ }\n+ case ANDROID_EXTENSION_CURRENT_TYPE: {\n+ break;\n+ }\n+ case ANDROID_EXTENSION_NIGHT_MODE_INDICATOR: {\n+ enumName = \"UNKNOWN\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_UNKNOWN;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_EXTENSION_NIGHT_MODE_INDICATOR_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS: {\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION: {\n+ enumName = \"OUTPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_OUTPUT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"INPUT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION_INPUT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+ case ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS_MAXIMUM_RESOLUTION: {\n+ break;\n+ }\n+\n+ case ANDROID_SHARED_SESSION_COLOR_SPACE: {\n+ enumName = \"UNSPECIFIED\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SHARED_SESSION_COLOR_SPACE_UNSPECIFIED;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"SRGB\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SHARED_SESSION_COLOR_SPACE_SRGB;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"DISPLAY_P3\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SHARED_SESSION_COLOR_SPACE_DISPLAY_P3;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"BT2020_HLG\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_SHARED_SESSION_COLOR_SPACE_BT2020_HLG;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS: {\n+ break;\n+ }\n+\n+ case ANDROID_DESKTOP_EFFECTS_CAPABILITIES: {\n+ enumName = \"BACKGROUND_BLUR\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_CAPABILITIES_BACKGROUND_BLUR;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FACE_RETOUCH\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_CAPABILITIES_FACE_RETOUCH;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"PORTRAIT_RELIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_CAPABILITIES_PORTRAIT_RELIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODES: {\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"LIGHT\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_LIGHT;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"FULL\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_BACKGROUND_BLUR_MODE_FULL;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_FACE_RETOUCH_STRENGTH: {\n+ break;\n+ }\n+ case ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE: {\n+ enumName = \"OFF\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_OFF;\n+ ret = 0;\n+ break;\n+ }\n+ enumName = \"ON\";\n+ if (strncmp(name, enumName, size) == 0) {\n+ *value = ANDROID_DESKTOP_EFFECTS_PORTRAIT_RELIGHT_MODE_ON;\n+ ret = 0;\n+ break;\n+ }\n+ break;\n+ }\n+\n+ }\n \n return ret;\n }\n \n \n-#define CAMERA_METADATA_ENUM_STRING_MAX_SIZE 29\n+#define CAMERA_METADATA_ENUM_STRING_MAX_SIZE 42\n","prefixes":["RFC","v1","49/54"]}