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