2012-11-28 03:06:06 +01:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2013 The Android Open Source Project
|
|
|
|
|
*
|
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
|
*
|
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
*
|
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
|
* limitations under the License.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef ANDROID_INCLUDE_CAMERA3_H
|
|
|
|
|
#define ANDROID_INCLUDE_CAMERA3_H
|
|
|
|
|
|
2013-02-15 21:09:48 +01:00
|
|
|
#include <system/camera_metadata.h>
|
2012-11-28 03:06:06 +01:00
|
|
|
#include "camera_common.h"
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Camera device HAL 3.0 [ CAMERA_DEVICE_API_VERSION_3_0 ]
|
|
|
|
|
*
|
|
|
|
|
* EXPERIMENTAL.
|
|
|
|
|
*
|
|
|
|
|
* Supports the android.hardware.Camera API.
|
|
|
|
|
*
|
|
|
|
|
* Camera devices that support this version of the HAL must return
|
|
|
|
|
* CAMERA_DEVICE_API_VERSION_3_0 in camera_device_t.common.version and in
|
|
|
|
|
* camera_info_t.device_version (from camera_module_t.get_camera_info).
|
|
|
|
|
*
|
|
|
|
|
* Camera modules that may contain version 3.0 devices must implement at least
|
|
|
|
|
* version 2.0 of the camera module interface (as defined by
|
|
|
|
|
* camera_module_t.common.module_api_version).
|
|
|
|
|
*
|
|
|
|
|
* See camera_common.h for more versioning details.
|
|
|
|
|
*
|
2013-03-17 00:53:28 +01:00
|
|
|
* Documentation index:
|
|
|
|
|
* S1. Version history
|
|
|
|
|
* S2. Startup and operation sequencing
|
|
|
|
|
* S3. Operational modes
|
|
|
|
|
* S4. 3A modes and state machines
|
|
|
|
|
* S5. Error management
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* S1. Version history:
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
|
|
|
|
* 1.0: Initial Android camera HAL (Android 4.0) [camera.h]:
|
|
|
|
|
*
|
|
|
|
|
* - Converted from C++ CameraHardwareInterface abstraction layer.
|
|
|
|
|
*
|
|
|
|
|
* - Supports android.hardware.Camera API.
|
|
|
|
|
*
|
|
|
|
|
* 2.0: Initial release of expanded-capability HAL (Android 4.2) [camera2.h]:
|
|
|
|
|
*
|
|
|
|
|
* - Sufficient for implementing existing android.hardware.Camera API.
|
|
|
|
|
*
|
|
|
|
|
* - Allows for ZSL queue in camera service layer
|
|
|
|
|
*
|
|
|
|
|
* - Not tested for any new features such manual capture control, Bayer RAW
|
|
|
|
|
* capture, reprocessing of RAW data.
|
|
|
|
|
*
|
|
|
|
|
* 3.0: First revision of expanded-capability HAL:
|
|
|
|
|
*
|
|
|
|
|
* - Major version change since the ABI is completely different. No change to
|
|
|
|
|
* the required hardware capabilities or operational model from 2.0.
|
|
|
|
|
*
|
|
|
|
|
* - Reworked input request and stream queue interfaces: Framework calls into
|
|
|
|
|
* HAL with next request and stream buffers already dequeued. Sync framework
|
|
|
|
|
* support is included, necessary for efficient implementations.
|
|
|
|
|
*
|
|
|
|
|
* - Moved triggers into requests, most notifications into results.
|
|
|
|
|
*
|
|
|
|
|
* - Consolidated all callbacks into framework into one structure, and all
|
|
|
|
|
* setup methods into a single initialize() call.
|
|
|
|
|
*
|
|
|
|
|
* - Made stream configuration into a single call to simplify stream
|
|
|
|
|
* management. Bidirectional streams replace STREAM_FROM_STREAM construct.
|
|
|
|
|
*
|
|
|
|
|
* - Limited mode semantics for older/limited hardware devices.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2013-03-17 00:53:28 +01:00
|
|
|
* S2. Startup and general expected operation sequence:
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
|
|
|
|
* 1. Framework calls camera_module_t->common.open(), which returns a
|
|
|
|
|
* hardware_device_t structure.
|
|
|
|
|
*
|
|
|
|
|
* 2. Framework inspects the hardware_device_t->version field, and instantiates
|
|
|
|
|
* the appropriate handler for that version of the camera hardware device. In
|
|
|
|
|
* case the version is CAMERA_DEVICE_API_VERSION_3_0, the device is cast to
|
|
|
|
|
* a camera3_device_t.
|
|
|
|
|
*
|
|
|
|
|
* 3. Framework calls camera3_device_t->ops->initialize() with the framework
|
|
|
|
|
* callback function pointers. This will only be called this one time after
|
|
|
|
|
* open(), before any other functions in the ops structure are called.
|
|
|
|
|
*
|
|
|
|
|
* 4. The framework calls camera3_device_t->ops->configure_streams() with a list
|
|
|
|
|
* of input/output streams to the HAL device.
|
|
|
|
|
*
|
|
|
|
|
* 5. The framework allocates gralloc buffers and calls
|
|
|
|
|
* camera3_device_t->ops->register_stream_buffers() for at least one of the
|
|
|
|
|
* output streams listed in configure_streams. The same stream is registered
|
|
|
|
|
* only once.
|
|
|
|
|
*
|
|
|
|
|
* 5. The framework requests default settings for some number of use cases with
|
|
|
|
|
* calls to camera3_device_t->ops->construct_default_request_settings(). This
|
|
|
|
|
* may occur any time after step 3.
|
|
|
|
|
*
|
|
|
|
|
* 7. The framework constructs and sends the first capture request to the HAL,
|
|
|
|
|
* with settings based on one of the sets of default settings, and with at
|
|
|
|
|
* least one output stream, which has been registered earlier by the
|
|
|
|
|
* framework. This is sent to the HAL with
|
|
|
|
|
* camera3_device_t->ops->process_capture_request(). The HAL must block the
|
|
|
|
|
* return of this call until it is ready for the next request to be sent.
|
|
|
|
|
*
|
|
|
|
|
* 8. The framework continues to submit requests, and possibly call
|
|
|
|
|
* register_stream_buffers() for not-yet-registered streams, and call
|
|
|
|
|
* construct_default_request_settings to get default settings buffers for
|
|
|
|
|
* other use cases.
|
|
|
|
|
*
|
|
|
|
|
* 9. When the capture of a request begins (sensor starts exposing for the
|
|
|
|
|
* capture), the HAL calls camera3_callback_ops_t->notify() with the SHUTTER
|
|
|
|
|
* event, including the frame number and the timestamp for start of exposure.
|
|
|
|
|
*
|
|
|
|
|
* 10. After some pipeline delay, the HAL begins to return completed captures to
|
|
|
|
|
* the framework with camera3_callback_ops_t->process_capture_result(). These
|
|
|
|
|
* are returned in the same order as the requests were submitted. Multiple
|
|
|
|
|
* requests can be in flight at once, depending on the pipeline depth of the
|
|
|
|
|
* camera HAL device.
|
|
|
|
|
*
|
|
|
|
|
* 11. After some time, the framework may stop submitting new requests, wait for
|
|
|
|
|
* the existing captures to complete (all buffers filled, all results
|
|
|
|
|
* returned), and then call configure_streams() again. This resets the camera
|
|
|
|
|
* hardware and pipeline for a new set of input/output streams. Some streams
|
|
|
|
|
* may be reused from the previous configuration; if these streams' buffers
|
|
|
|
|
* had already been registered with the HAL, they will not be registered
|
|
|
|
|
* again. The framework then continues from step 7, if at least one
|
|
|
|
|
* registered output stream remains (otherwise, step 5 is required first).
|
|
|
|
|
*
|
|
|
|
|
* 12. Alternatively, the framework may call camera3_device_t->common->close()
|
2013-03-06 22:23:31 +01:00
|
|
|
* to end the camera session. This may be called at any time when no other
|
|
|
|
|
* calls from the framework are active, although the call may block until all
|
|
|
|
|
* in-flight captures have completed (all results returned, all buffers
|
|
|
|
|
* filled). After the close call returns, no more calls to the
|
|
|
|
|
* camera3_callback_ops_t functions are allowed from the HAL. Once the
|
|
|
|
|
* close() call is underway, the framework may not call any other HAL device
|
|
|
|
|
* functions.
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
|
|
|
|
* 13. In case of an error or other asynchronous event, the HAL must call
|
|
|
|
|
* camera3_callback_ops_t->notify() with the appropriate error/event
|
|
|
|
|
* message. After returning from a fatal device-wide error notification, the
|
|
|
|
|
* HAL should act as if close() had been called on it. However, the HAL must
|
|
|
|
|
* either cancel or complete all outstanding captures before calling
|
|
|
|
|
* notify(), so that once notify() is called with a fatal error, the
|
|
|
|
|
* framework will not receive further callbacks from the device. Methods
|
|
|
|
|
* besides close() should return -ENODEV or NULL after the notify() method
|
|
|
|
|
* returns from a fatal error message.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2013-03-17 00:53:28 +01:00
|
|
|
* S3. Operational modes:
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
|
|
|
|
* The camera 3 HAL device can implement one of two possible operational modes;
|
|
|
|
|
* limited and full. Full support is expected from new higher-end
|
|
|
|
|
* devices. Limited mode has hardware requirements roughly in line with those
|
|
|
|
|
* for a camera HAL device v1 implementation, and is expected from older or
|
|
|
|
|
* inexpensive devices. Full is a strict superset of limited, and they share the
|
|
|
|
|
* same essential operational flow, as documented above.
|
|
|
|
|
*
|
|
|
|
|
* The HAL must indicate its level of support with the
|
|
|
|
|
* android.info.supportedHardwareLevel static metadata entry, with 0 indicating
|
|
|
|
|
* limited mode, and 1 indicating full mode support.
|
|
|
|
|
*
|
|
|
|
|
* Roughly speaking, limited-mode devices do not allow for application control
|
|
|
|
|
* of capture settings (3A control only), high-rate capture of high-resolution
|
2013-03-17 00:53:28 +01:00
|
|
|
* images, raw sensor readout, or support for YUV output streams above maximum
|
2012-11-28 03:06:06 +01:00
|
|
|
* recording resolution (JPEG only for large images).
|
|
|
|
|
*
|
|
|
|
|
* ** Details of limited mode behavior:
|
|
|
|
|
*
|
|
|
|
|
* - Limited-mode devices do not need to implement accurate synchronization
|
|
|
|
|
* between capture request settings and the actual image data
|
|
|
|
|
* captured. Instead, changes to settings may take effect some time in the
|
|
|
|
|
* future, and possibly not for the same output frame for each settings
|
|
|
|
|
* entry. Rapid changes in settings may result in some settings never being
|
|
|
|
|
* used for a capture. However, captures that include high-resolution output
|
|
|
|
|
* buffers ( > 1080p ) have to use the settings as specified (but see below
|
|
|
|
|
* for processing rate).
|
|
|
|
|
*
|
|
|
|
|
* - Limited-mode devices do not need to support most of the
|
|
|
|
|
* settings/result/static info metadata. Full-mode devices must support all
|
|
|
|
|
* metadata fields listed in TODO. Specifically, only the following settings
|
|
|
|
|
* are expected to be consumed or produced by a limited-mode HAL device:
|
|
|
|
|
*
|
|
|
|
|
* android.control.aeAntibandingMode (controls)
|
|
|
|
|
* android.control.aeExposureCompensation (controls)
|
|
|
|
|
* android.control.aeLock (controls)
|
|
|
|
|
* android.control.aeMode (controls)
|
|
|
|
|
* [OFF means ON_FLASH_TORCH - TODO]
|
|
|
|
|
* android.control.aeRegions (controls)
|
|
|
|
|
* android.control.aeTargetFpsRange (controls)
|
|
|
|
|
* android.control.afMode (controls)
|
|
|
|
|
* [OFF means infinity focus]
|
|
|
|
|
* android.control.afRegions (controls)
|
|
|
|
|
* android.control.awbLock (controls)
|
|
|
|
|
* android.control.awbMode (controls)
|
|
|
|
|
* [OFF not supported]
|
|
|
|
|
* android.control.awbRegions (controls)
|
|
|
|
|
* android.control.captureIntent (controls)
|
|
|
|
|
* android.control.effectMode (controls)
|
|
|
|
|
* android.control.mode (controls)
|
|
|
|
|
* [OFF not supported]
|
|
|
|
|
* android.control.sceneMode (controls)
|
|
|
|
|
* android.control.videoStabilizationMode (controls)
|
|
|
|
|
* android.control.aeAvailableAntibandingModes (static)
|
|
|
|
|
* android.control.aeAvailableModes (static)
|
|
|
|
|
* android.control.aeAvailableTargetFpsRanges (static)
|
|
|
|
|
* android.control.aeCompensationRange (static)
|
|
|
|
|
* android.control.aeCompensationStep (static)
|
|
|
|
|
* android.control.afAvailableModes (static)
|
|
|
|
|
* android.control.availableEffects (static)
|
|
|
|
|
* android.control.availableSceneModes (static)
|
|
|
|
|
* android.control.availableVideoStabilizationModes (static)
|
|
|
|
|
* android.control.awbAvailableModes (static)
|
|
|
|
|
* android.control.maxRegions (static)
|
|
|
|
|
* android.control.sceneModeOverrides (static)
|
|
|
|
|
* android.control.aeRegions (dynamic)
|
|
|
|
|
* android.control.aeState (dynamic)
|
|
|
|
|
* android.control.afMode (dynamic)
|
|
|
|
|
* android.control.afRegions (dynamic)
|
|
|
|
|
* android.control.afState (dynamic)
|
|
|
|
|
* android.control.awbMode (dynamic)
|
|
|
|
|
* android.control.awbRegions (dynamic)
|
|
|
|
|
* android.control.awbState (dynamic)
|
|
|
|
|
* android.control.mode (dynamic)
|
|
|
|
|
*
|
|
|
|
|
* android.flash.info.available (static)
|
|
|
|
|
*
|
|
|
|
|
* android.info.supportedHardwareLevel (static)
|
|
|
|
|
*
|
|
|
|
|
* android.jpeg.gpsCoordinates (controls)
|
|
|
|
|
* android.jpeg.gpsProcessingMethod (controls)
|
|
|
|
|
* android.jpeg.gpsTimestamp (controls)
|
|
|
|
|
* android.jpeg.orientation (controls)
|
|
|
|
|
* android.jpeg.quality (controls)
|
|
|
|
|
* android.jpeg.thumbnailQuality (controls)
|
|
|
|
|
* android.jpeg.thumbnailSize (controls)
|
|
|
|
|
* android.jpeg.availableThumbnailSizes (static)
|
|
|
|
|
* android.jpeg.maxSize (static)
|
|
|
|
|
* android.jpeg.gpsCoordinates (dynamic)
|
|
|
|
|
* android.jpeg.gpsProcessingMethod (dynamic)
|
|
|
|
|
* android.jpeg.gpsTimestamp (dynamic)
|
|
|
|
|
* android.jpeg.orientation (dynamic)
|
|
|
|
|
* android.jpeg.quality (dynamic)
|
|
|
|
|
* android.jpeg.size (dynamic)
|
|
|
|
|
* android.jpeg.thumbnailQuality (dynamic)
|
|
|
|
|
* android.jpeg.thumbnailSize (dynamic)
|
|
|
|
|
*
|
|
|
|
|
* android.lens.info.minimumFocusDistance (static)
|
|
|
|
|
*
|
|
|
|
|
* android.request.id (controls)
|
|
|
|
|
* android.request.id (dynamic)
|
|
|
|
|
*
|
|
|
|
|
* android.scaler.cropRegion (controls)
|
|
|
|
|
* [ignores (x,y), assumes center-zoom]
|
|
|
|
|
* android.scaler.availableFormats (static)
|
|
|
|
|
* [RAW not supported]
|
|
|
|
|
* android.scaler.availableJpegMinDurations (static)
|
|
|
|
|
* android.scaler.availableJpegSizes (static)
|
|
|
|
|
* android.scaler.availableMaxDigitalZoom (static)
|
|
|
|
|
* android.scaler.availableProcessedMinDurations (static)
|
|
|
|
|
* android.scaler.availableProcessedSizes (static)
|
|
|
|
|
* [full resolution not supported]
|
|
|
|
|
* android.scaler.maxDigitalZoom (static)
|
|
|
|
|
* android.scaler.cropRegion (dynamic)
|
|
|
|
|
*
|
|
|
|
|
* android.sensor.orientation (static)
|
|
|
|
|
* android.sensor.timestamp (dynamic)
|
|
|
|
|
*
|
|
|
|
|
* android.statistics.faceDetectMode (controls)
|
|
|
|
|
* android.statistics.info.availableFaceDetectModes (static)
|
|
|
|
|
* android.statistics.faceDetectMode (dynamic)
|
|
|
|
|
* android.statistics.faceIds (dynamic)
|
|
|
|
|
* android.statistics.faceLandmarks (dynamic)
|
|
|
|
|
* android.statistics.faceRectangles (dynamic)
|
|
|
|
|
* android.statistics.faceScores (dynamic)
|
|
|
|
|
*
|
|
|
|
|
* - Captures in limited mode that include high-resolution (> 1080p) output
|
|
|
|
|
* buffers may block in process_capture_request() until all the output buffers
|
|
|
|
|
* have been filled. A full-mode HAL device must process sequences of
|
|
|
|
|
* high-resolution requests at the rate indicated in the static metadata for
|
|
|
|
|
* that pixel format. The HAL must still call process_capture_result() to
|
|
|
|
|
* provide the output; the framework must simply be prepared for
|
|
|
|
|
* process_capture_request() to block until after process_capture_result() for
|
|
|
|
|
* that request completes for high-resolution captures for limited-mode
|
|
|
|
|
* devices.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2013-03-17 00:53:28 +01:00
|
|
|
* S4. 3A modes and state machines:
|
|
|
|
|
*
|
|
|
|
|
* While the actual 3A algorithms are up to the HAL implementation, a high-level
|
|
|
|
|
* state machine description is defined by the HAL interface, to allow the HAL
|
|
|
|
|
* device and the framework to communicate about the current state of 3A, and to
|
|
|
|
|
* trigger 3A events.
|
|
|
|
|
*
|
|
|
|
|
* When the device is opened, all the individual 3A states must be
|
|
|
|
|
* STATE_INACTIVE. Stream configuration does not reset 3A. For example, locked
|
|
|
|
|
* focus must be maintained across the configure() call.
|
|
|
|
|
*
|
|
|
|
|
* Triggering a 3A action involves simply setting the relevant trigger entry in
|
|
|
|
|
* the settings for the next request to indicate start of trigger. For example,
|
|
|
|
|
* the trigger for starting an autofocus scan is setting the entry
|
|
|
|
|
* ANDROID_CONTROL_AF_TRIGGER to ANDROID_CONTROL_AF_TRIGGER_START for one
|
|
|
|
|
* request, and cancelling an autofocus scan is triggered by setting
|
|
|
|
|
* ANDROID_CONTROL_AF_TRIGGER to ANDROID_CONTRL_AF_TRIGGER_CANCEL. Otherwise,
|
|
|
|
|
* the entry will not exist, or be set to ANDROID_CONTROL_AF_TRIGGER_IDLE. Each
|
|
|
|
|
* request with a trigger entry set to a non-IDLE value will be treated as an
|
|
|
|
|
* independent triggering event.
|
|
|
|
|
*
|
|
|
|
|
* At the top level, 3A is controlled by the ANDROID_CONTROL_MODE setting, which
|
|
|
|
|
* selects between no 3A (ANDROID_CONTROL_MODE_OFF), normal AUTO mode
|
|
|
|
|
* (ANDROID_CONTROL_MODE_AUTO), and using the scene mode setting
|
|
|
|
|
* (ANDROID_CONTROL_USE_SCENE_MODE).
|
|
|
|
|
*
|
|
|
|
|
* - In OFF mode, each of the individual AE/AF/AWB modes are effectively OFF,
|
|
|
|
|
* and none of the capture controls may be overridden by the 3A routines.
|
|
|
|
|
*
|
|
|
|
|
* - In AUTO mode, Auto-focus, auto-exposure, and auto-whitebalance all run
|
|
|
|
|
* their own independent algorithms, and have their own mode, state, and
|
|
|
|
|
* trigger metadata entries, as listed in the next section.
|
|
|
|
|
*
|
|
|
|
|
* - In USE_SCENE_MODE, the value of the ANDROID_CONTROL_SCENE_MODE entry must
|
|
|
|
|
* be used to determine the behavior of 3A routines. In SCENE_MODEs other than
|
|
|
|
|
* FACE_PRIORITY, the HAL must override the values of
|
|
|
|
|
* ANDROId_CONTROL_AE/AWB/AF_MODE to be the mode it prefers for the selected
|
|
|
|
|
* SCENE_MODE. For example, the HAL may prefer SCENE_MODE_NIGHT to use
|
|
|
|
|
* CONTINUOUS_FOCUS AF mode. Any user selection of AE/AWB/AF_MODE when scene
|
|
|
|
|
* must be ignored for these scene modes.
|
|
|
|
|
*
|
|
|
|
|
* - For SCENE_MODE_FACE_PRIORITY, the AE/AWB/AF_MODE controls work as in
|
|
|
|
|
* ANDROID_CONTROL_MODE_AUTO, but the 3A routines must bias toward metering
|
|
|
|
|
* and focusing on any detected faces in the scene.
|
|
|
|
|
*
|
|
|
|
|
* S4.1. Auto-focus settings and result entries:
|
|
|
|
|
*
|
|
|
|
|
* Main metadata entries:
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AF_MODE: Control for selecting the current autofocus
|
|
|
|
|
* mode. Set by the framework in the request settings.
|
|
|
|
|
*
|
|
|
|
|
* AF_MODE_OFF: AF is disabled; the framework/app directly controls lens
|
|
|
|
|
* position.
|
|
|
|
|
*
|
|
|
|
|
* AF_MODE_AUTO: Single-sweep autofocus. No lens movement unless AF is
|
|
|
|
|
* triggered.
|
|
|
|
|
*
|
|
|
|
|
* AF_MODE_MACRO: Single-sweep up-close autofocus. No lens movement unless
|
|
|
|
|
* AF is triggered.
|
|
|
|
|
*
|
|
|
|
|
* AF_MODE_CONTINUOUS_VIDEO: Smooth continuous focusing, for recording
|
|
|
|
|
* video. Triggering immediately locks focus in current
|
|
|
|
|
* position. Canceling resumes cotinuous focusing.
|
|
|
|
|
*
|
|
|
|
|
* AF_MODE_CONTINUOUS_PICTURE: Fast continuous focusing, for
|
|
|
|
|
* zero-shutter-lag still capture. Triggering locks focus once currently
|
|
|
|
|
* active sweep concludes. Canceling resumes continuous focusing.
|
|
|
|
|
*
|
|
|
|
|
* AF_MODE_EDOF: Advanced extended depth of field focusing. There is no
|
|
|
|
|
* autofocus scan, so triggering one or canceling one has no effect.
|
|
|
|
|
* Images are focused automatically by the HAL.
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AF_STATE: Dynamic metadata describing the current AF
|
|
|
|
|
* algorithm state, reported by the HAL in the result metadata.
|
|
|
|
|
*
|
|
|
|
|
* AF_STATE_INACTIVE: No focusing has been done, or algorithm was
|
|
|
|
|
* reset. Lens is not moving. Always the state for MODE_OFF or MODE_EDOF.
|
|
|
|
|
* When the device is opened, it must start in this state.
|
|
|
|
|
*
|
|
|
|
|
* AF_STATE_PASSIVE_SCAN: A continuous focus algorithm is currently scanning
|
|
|
|
|
* for good focus. The lens is moving.
|
|
|
|
|
*
|
|
|
|
|
* AF_STATE_PASSIVE_FOCUSED: A continuous focus algorithm believes it is
|
|
|
|
|
* well focused. The lens is not moving. The HAL may spontaneously leave
|
|
|
|
|
* this state.
|
|
|
|
|
*
|
|
|
|
|
* AF_STATE_ACTIVE_SCAN: A scan triggered by the user is underway.
|
|
|
|
|
*
|
|
|
|
|
* AF_STATE_FOCUSED_LOCKED: The AF algorithm believes it is focused. The
|
|
|
|
|
* lens is not moving.
|
|
|
|
|
*
|
|
|
|
|
* AF_STATE_NOT_FOCUSED_LOCKED: The AF algorithm has been unable to
|
|
|
|
|
* focus. The lens is not moving.
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AF_TRIGGER: Control for starting an autofocus scan, the
|
|
|
|
|
* meaning of which is mode- and state- dependent. Set by the framework in
|
|
|
|
|
* the request settings.
|
|
|
|
|
*
|
|
|
|
|
* AF_TRIGGER_IDLE: No current trigger.
|
|
|
|
|
*
|
|
|
|
|
* AF_TRIGGER_START: Trigger start of AF scan. Effect is mode and state
|
|
|
|
|
* dependent.
|
|
|
|
|
*
|
|
|
|
|
* AF_TRIGGER_CANCEL: Cancel current AF scan if any, and reset algorithm to
|
|
|
|
|
* default.
|
|
|
|
|
*
|
|
|
|
|
* Additional metadata entries:
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AF_REGIONS: Control for selecting the regions of the FOV
|
|
|
|
|
* that should be used to determine good focus. This applies to all AF
|
|
|
|
|
* modes that scan for focus. Set by the framework in the request
|
|
|
|
|
* settings.
|
|
|
|
|
*
|
|
|
|
|
* S4.2. Auto-exposure settings and result entries:
|
|
|
|
|
*
|
|
|
|
|
* Main metadata entries:
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AE_MODE: Control for selecting the current auto-exposure
|
|
|
|
|
* mode. Set by the framework in the request settings.
|
|
|
|
|
*
|
|
|
|
|
* AE_MODE_OFF: Autoexposure is disabled; the user controls exposure, gain,
|
|
|
|
|
* frame duration, and flash.
|
|
|
|
|
*
|
|
|
|
|
* AE_MODE_ON: Standard autoexposure, with flash control disabled. User may
|
|
|
|
|
* set flash to fire or to torch mode.
|
|
|
|
|
*
|
|
|
|
|
* AE_MODE_ON_AUTO_FLASH: Standard autoexposure, with flash on at HAL's
|
|
|
|
|
* discretion for precapture and still capture. User control of flash
|
|
|
|
|
* disabled.
|
|
|
|
|
*
|
|
|
|
|
* AE_MODE_ON_ALWAYS_FLASH: Standard autoexposure, with flash always fired
|
|
|
|
|
* for capture, and at HAL's discretion for precapture.. User control of
|
|
|
|
|
* flash disabled.
|
|
|
|
|
*
|
|
|
|
|
* AE_MODE_ON_AUTO_FLASH_REDEYE: Standard autoexposure, with flash on at
|
|
|
|
|
* HAL's discretion for precapture and still capture. Use a flash burst
|
|
|
|
|
* at end of precapture sequence to reduce redeye in the final
|
|
|
|
|
* picture. User control of flash disabled.
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AE_STATE: Dynamic metadata describing the current AE
|
|
|
|
|
* algorithm state, reported by the HAL in the result metadata.
|
|
|
|
|
*
|
|
|
|
|
* AE_STATE_INACTIVE: Initial AE state after mode switch. When the device is
|
|
|
|
|
* opened, it must start in this state.
|
|
|
|
|
*
|
|
|
|
|
* AE_STATE_SEARCHING: AE is not converged to a good value, and is adjusting
|
|
|
|
|
* exposure parameters.
|
|
|
|
|
*
|
|
|
|
|
* AE_STATE_CONVERGED: AE has found good exposure values for the current
|
|
|
|
|
* scene, and the exposure parameters are not changing. HAL may
|
|
|
|
|
* spontaneously leave this state to search for better solution.
|
|
|
|
|
*
|
|
|
|
|
* AE_STATE_LOCKED: AE has been locked with the AE_LOCK control. Exposure
|
|
|
|
|
* values are not changing.
|
|
|
|
|
*
|
|
|
|
|
* AE_STATE_FLASH_REQUIRED: The HAL has converged exposure, but believes
|
|
|
|
|
* flash is required for a sufficiently bright picture. Used for
|
|
|
|
|
* determining if a zero-shutter-lag frame can be used.
|
|
|
|
|
*
|
|
|
|
|
* AE_STATE_PRECAPTURE: The HAL is in the middle of a precapture
|
|
|
|
|
* sequence. Depending on AE mode, this mode may involve firing the
|
|
|
|
|
* flash for metering, or a burst of flash pulses for redeye reduction.
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER: Control for starting a metering
|
|
|
|
|
* sequence before capturing a high-quality image. Set by the framework in
|
|
|
|
|
* the request settings.
|
|
|
|
|
*
|
|
|
|
|
* PRECAPTURE_TRIGGER_IDLE: No current trigger.
|
|
|
|
|
*
|
|
|
|
|
* PRECAPTURE_TRIGGER_START: Start a precapture sequence. The HAL should
|
|
|
|
|
* use the subsequent requests to measure good exposure/white balance
|
|
|
|
|
* for an upcoming high-resolution capture.
|
|
|
|
|
*
|
|
|
|
|
* Additional metadata entries:
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AE_LOCK: Control for locking AE controls to their current
|
|
|
|
|
* values
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION: Control for adjusting AE
|
|
|
|
|
* algorithm target brightness point.
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AE_TARGET_FPS_RANGE: Control for selecting the target frame
|
|
|
|
|
* rate range for the AE algorithm. The AE routine cannot change the frame
|
|
|
|
|
* rate to be outside these bounds.
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AE_REGIONS: Control for selecting the regions of the FOV
|
|
|
|
|
* that should be used to determine good exposure levels. This applies to
|
|
|
|
|
* all AE modes besides OFF.
|
|
|
|
|
*
|
|
|
|
|
* S4.3. Auto-whitebalance settings and result entries:
|
|
|
|
|
*
|
|
|
|
|
* Main metadata entries:
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AWB_MODE: Control for selecting the current white-balance
|
|
|
|
|
* mode.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_OFF: Auto-whitebalance is disabled. User controls color matrix.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_AUTO: Automatic white balance is enabled; 3A controls color
|
|
|
|
|
* transform, possibly using more complex transforms than a simple
|
|
|
|
|
* matrix.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_INCANDESCENT: Fixed white balance settings good for indoor
|
|
|
|
|
* incandescent (tungsten) lighting, roughly 2700K.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_FLUORESCENT: Fixed white balance settings good for fluorescent
|
|
|
|
|
* lighting, roughly 5000K.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_WARM_FLUORESCENT: Fixed white balance settings good for
|
|
|
|
|
* fluorescent lighting, roughly 3000K.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_DAYLIGHT: Fixed white balance settings good for daylight,
|
|
|
|
|
* roughly 5500K.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_CLOUDY_DAYLIGHT: Fixed white balance settings good for clouded
|
|
|
|
|
* daylight, roughly 6500K.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_TWILIGHT: Fixed white balance settings good for
|
|
|
|
|
* near-sunset/sunrise, roughly 15000K.
|
|
|
|
|
*
|
|
|
|
|
* AWB_MODE_SHADE: Fixed white balance settings good for areas indirectly
|
|
|
|
|
* lit by the sun, roughly 7500K.
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AWB_STATE: Dynamic metadata describing the current AWB
|
|
|
|
|
* algorithm state, reported by the HAL in the result metadata.
|
|
|
|
|
*
|
|
|
|
|
* AWB_STATE_INACTIVE: Initial AWB state after mode switch. When the device
|
|
|
|
|
* is opened, it must start in this state.
|
|
|
|
|
*
|
|
|
|
|
* AWB_STATE_SEARCHING: AWB is not converged to a good value, and is
|
|
|
|
|
* changing color adjustment parameters.
|
|
|
|
|
*
|
|
|
|
|
* AWB_STATE_CONVERGED: AWB has found good color adjustment values for the
|
|
|
|
|
* current scene, and the parameters are not changing. HAL may
|
|
|
|
|
* spontaneously leave this state to search for better solution.
|
|
|
|
|
*
|
|
|
|
|
* AWB_STATE_LOCKED: AWB has been locked with the AWB_LOCK control. Color
|
|
|
|
|
* adjustment values are not changing.
|
|
|
|
|
*
|
|
|
|
|
* Additional metadata entries:
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AWB_LOCK: Control for locking AWB color adjustments to
|
|
|
|
|
* their current values.
|
|
|
|
|
*
|
|
|
|
|
* ANDROID_CONTROL_AWB_REGIONS: Control for selecting the regions of the FOV
|
|
|
|
|
* that should be used to determine good color balance. This applies only
|
|
|
|
|
* to auto-WB mode.
|
|
|
|
|
*
|
|
|
|
|
* S4.4. General state machine transition notes
|
|
|
|
|
*
|
|
|
|
|
* Switching between AF, AE, or AWB modes always resets the algorithm's state
|
|
|
|
|
* to INACTIVE. Similarly, switching between CONTROL_MODE or
|
|
|
|
|
* CONTROL_SCENE_MODE if CONTROL_MODE == USE_SCENE_MODE resets all the
|
|
|
|
|
* algorithm states to INACTIVE.
|
|
|
|
|
*
|
|
|
|
|
* The tables below are per-mode.
|
|
|
|
|
*
|
|
|
|
|
* S4.5. AF state machines
|
|
|
|
|
*
|
|
|
|
|
* mode = AF_MODE_OFF or AF_MODE_EDOF
|
|
|
|
|
*| state | trans. cause | new state | notes |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | | | AF is disabled |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*
|
|
|
|
|
* mode = AF_MODE_AUTO or AF_MODE_MACRO
|
|
|
|
|
*| state | trans. cause | new state | notes |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | AF_TRIGGER | ACTIVE_SCAN | Start AF sweep |
|
|
|
|
|
*| | | | Lens now moving |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| ACTIVE_SCAN | AF sweep done | FOCUSED_LOCKED | If AF successful |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| ACTIVE_SCAN | AF sweep done | NOT_FOCUSED_LOCKED | If AF successful |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| ACTIVE_SCAN | AF_CANCEL | INACTIVE | Cancel/reset AF |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| FOCUSED_LOCKED | AF_CANCEL | INACTIVE | Cancel/reset AF |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| FOCUSED_LOCKED | AF_TRIGGER | ACTIVE_SCAN | Start new sweep |
|
|
|
|
|
*| | | | Lens now moving |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| NOT_FOCUSED_LOCKED | AF_CANCEL | INACTIVE | Cancel/reset AF |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| NOT_FOCUSED_LOCKED | AF_TRIGGER | ACTIVE_SCAN | Start new sweep |
|
|
|
|
|
*| | | | Lens now moving |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| All states | mode change | INACTIVE | |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*
|
|
|
|
|
* mode = AF_MODE_CONTINUOUS_VIDEO
|
|
|
|
|
*| state | trans. cause | new state | notes |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | HAL initiates | PASSIVE_SCAN | Start AF scan |
|
|
|
|
|
*| | new scan | | Lens now moving |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | AF_TRIGGER | NOT_FOCUSED_LOCKED | AF state query |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_SCAN | HAL completes | PASSIVE_FOCUSED | End AF scan |
|
|
|
|
|
*| | current scan | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_SCAN | AF_TRIGGER | FOCUSED_LOCKED | Immediate trans. |
|
|
|
|
|
*| | | | if focus is good |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_SCAN | AF_TRIGGER | NOT_FOCUSED_LOCKED | Immediate trans. |
|
|
|
|
|
*| | | | if focus is bad |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_SCAN | AF_CANCEL | INACTIVE | Reset lens |
|
|
|
|
|
*| | | | position |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_FOCUSED | HAL initiates | PASSIVE_SCAN | Start AF scan |
|
|
|
|
|
*| | new scan | | Lens now moving |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_FOCUSED | AF_TRIGGER | FOCUSED_LOCKED | Immediate trans. |
|
|
|
|
|
*| | | | if focus is good |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_FOCUSED | AF_TRIGGER | NOT_FOCUSED_LOCKED | Immediate trans. |
|
|
|
|
|
*| | | | if focus is bad |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| FOCUSED_LOCKED | AF_TRIGGER | FOCUSED_LOCKED | No effect |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| FOCUSED_LOCKED | AF_CANCEL | INACTIVE | Restart AF scan |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| NOT_FOCUSED_LOCKED | AF_TRIGGER | NOT_FOCUSED_LOCKED | No effect |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| NOT_FOCUSED_LOCKED | AF_CANCEL | INACTIVE | Restart AF scan |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*
|
|
|
|
|
* mode = AF_MODE_CONTINUOUS_PICTURE
|
|
|
|
|
*| state | trans. cause | new state | notes |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | HAL initiates | PASSIVE_SCAN | Start AF scan |
|
|
|
|
|
*| | new scan | | Lens now moving |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | AF_TRIGGER | NOT_FOCUSED_LOCKED | AF state query |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_SCAN | HAL completes | PASSIVE_FOCUSED | End AF scan |
|
|
|
|
|
*| | current scan | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_SCAN | AF_TRIGGER | FOCUSED_LOCKED | Eventual trans. |
|
|
|
|
|
*| | | | once focus good |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_SCAN | AF_TRIGGER | NOT_FOCUSED_LOCKED | Eventual trans. |
|
|
|
|
|
*| | | | if cannot focus |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_SCAN | AF_CANCEL | INACTIVE | Reset lens |
|
|
|
|
|
*| | | | position |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_FOCUSED | HAL initiates | PASSIVE_SCAN | Start AF scan |
|
|
|
|
|
*| | new scan | | Lens now moving |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_FOCUSED | AF_TRIGGER | FOCUSED_LOCKED | Immediate trans. |
|
|
|
|
|
*| | | | if focus is good |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PASSIVE_FOCUSED | AF_TRIGGER | NOT_FOCUSED_LOCKED | Immediate trans. |
|
|
|
|
|
*| | | | if focus is bad |
|
|
|
|
|
*| | | | Lens now locked |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| FOCUSED_LOCKED | AF_TRIGGER | FOCUSED_LOCKED | No effect |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| FOCUSED_LOCKED | AF_CANCEL | INACTIVE | Restart AF scan |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| NOT_FOCUSED_LOCKED | AF_TRIGGER | NOT_FOCUSED_LOCKED | No effect |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| NOT_FOCUSED_LOCKED | AF_CANCEL | INACTIVE | Restart AF scan |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*
|
|
|
|
|
* S4.6. AE and AWB state machines
|
|
|
|
|
*
|
|
|
|
|
* The AE and AWB state machines are mostly identical. AE has additional
|
|
|
|
|
* FLASH_REQUIRED and PRECAPTURE states. So rows below that refer to those two
|
|
|
|
|
* states should be ignored for the AWB state machine.
|
|
|
|
|
*
|
|
|
|
|
* mode = AE_MODE_OFF / AWB mode not AUTO
|
|
|
|
|
*| state | trans. cause | new state | notes |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | | | AE/AWB disabled |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*
|
|
|
|
|
* mode = AE_MODE_ON_* / AWB_MODE_AUTO
|
|
|
|
|
*| state | trans. cause | new state | notes |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | HAL initiates | SEARCHING | |
|
|
|
|
|
*| | AE/AWB scan | | |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| INACTIVE | AE/AWB_LOCK | LOCKED | values locked |
|
|
|
|
|
*| | on | | |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| SEARCHING | HAL finishes | CONVERGED | good values, not |
|
|
|
|
|
*| | AE/AWB scan | | changing |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| SEARCHING | HAL finishes | FLASH_REQUIRED | converged but too|
|
|
|
|
|
*| | AE scan | | dark w/o flash |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| SEARCHING | AE/AWB_LOCK | LOCKED | values locked |
|
|
|
|
|
*| | on | | |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| CONVERGED | HAL initiates | SEARCHING | values locked |
|
|
|
|
|
*| | AE/AWB scan | | |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| CONVERGED | AE/AWB_LOCK | LOCKED | values locked |
|
|
|
|
|
*| | on | | |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| LOCKED | AE/AWB_LOCK | SEARCHING | values not good |
|
|
|
|
|
*| | off | | after unlock |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| LOCKED | AE/AWB_LOCK | CONVERGED | values good |
|
|
|
|
|
*| | off | | after unlock |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| LOCKED | AE_LOCK | FLASH_REQUIRED | exposure good, |
|
|
|
|
|
*| | off | | but too dark |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| All AE states | PRECAPTURE_ | PRECAPTURE | Start precapture |
|
|
|
|
|
*| | START | | sequence |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PRECAPTURE | Sequence done.| CONVERGED | Ready for high- |
|
|
|
|
|
*| | AE_LOCK off | | quality capture |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*| PRECAPTURE | Sequence done.| LOCKED | Ready for high- |
|
|
|
|
|
*| | AE_LOCK on | | quality capture |
|
|
|
|
|
*+--------------------+---------------+--------------------+------------------+
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* S5. Error management:
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
|
|
|
|
* Camera HAL device ops functions that have a return value will all return
|
|
|
|
|
* -ENODEV / NULL in case of a serious error. This means the device cannot
|
|
|
|
|
* continue operation, and must be closed by the framework. Once this error is
|
2013-02-15 22:47:24 +01:00
|
|
|
* returned by some method, or if notify() is called with ERROR_DEVICE, only
|
|
|
|
|
* the close() method can be called successfully. All other methods will return
|
|
|
|
|
* -ENODEV / NULL.
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
2013-03-17 00:53:28 +01:00
|
|
|
* If a device op is called in the wrong sequence, for example if the framework
|
|
|
|
|
* calls configure_streams() is called before initialize(), the device must
|
|
|
|
|
* return -ENOSYS from the call, and do nothing.
|
|
|
|
|
*
|
2012-11-28 03:06:06 +01:00
|
|
|
* Transient errors in image capture must be reported through notify() as follows:
|
|
|
|
|
*
|
|
|
|
|
* - The failure of an entire capture to occur must be reported by the HAL by
|
|
|
|
|
* calling notify() with ERROR_REQUEST. Individual errors for the result
|
|
|
|
|
* metadata or the output buffers must not be reported in this case.
|
|
|
|
|
*
|
|
|
|
|
* - If the metadata for a capture cannot be produced, but some image buffers
|
|
|
|
|
* were filled, the HAL must call notify() with ERROR_RESULT.
|
|
|
|
|
*
|
|
|
|
|
* - If an output image buffer could not be filled, but either the metadata was
|
|
|
|
|
* produced or some other buffers were filled, the HAL must call notify() with
|
|
|
|
|
* ERROR_BUFFER for each failed buffer.
|
|
|
|
|
*
|
|
|
|
|
* In each of these transient failure cases, the HAL must still call
|
|
|
|
|
* process_capture_result, with valid output buffer_handle_t. If the result
|
|
|
|
|
* metadata could not be produced, it should be NULL. If some buffers could not
|
|
|
|
|
* be filled, their sync fences must be set to the error state.
|
|
|
|
|
*
|
2013-03-17 00:53:28 +01:00
|
|
|
* Invalid input arguments result in -EINVAL from the appropriate methods. In
|
|
|
|
|
* that case, the framework must act as if that call had never been made.
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
__BEGIN_DECLS
|
|
|
|
|
|
|
|
|
|
struct camera3_device;
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
*
|
|
|
|
|
* Camera3 stream and stream buffer definitions.
|
|
|
|
|
*
|
|
|
|
|
* These structs and enums define the handles and contents of the input and
|
|
|
|
|
* output streams connecting the HAL to various framework and application buffer
|
|
|
|
|
* consumers. Each stream is backed by a gralloc buffer queue.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_stream_type_t:
|
|
|
|
|
*
|
|
|
|
|
* The type of the camera stream, which defines whether the camera HAL device is
|
|
|
|
|
* the producer or the consumer for that stream, and how the buffers of the
|
|
|
|
|
* stream relate to the other streams.
|
|
|
|
|
*/
|
|
|
|
|
typedef enum camera3_stream_type {
|
|
|
|
|
/**
|
|
|
|
|
* This stream is an output stream; the camera HAL device will be
|
|
|
|
|
* responsible for filling buffers from this stream with newly captured or
|
|
|
|
|
* reprocessed image data.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_STREAM_OUTPUT = 0,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* This stream is an input stream; the camera HAL device will be responsible
|
|
|
|
|
* for reading buffers from this stream and sending them through the camera
|
|
|
|
|
* processing pipeline, as if the buffer was a newly captured image from the
|
|
|
|
|
* imager.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_STREAM_INPUT = 1,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* This stream can be used for input and output. Typically, the stream is
|
|
|
|
|
* used as an output stream, but occasionally one already-filled buffer may
|
|
|
|
|
* be sent back to the HAL device for reprocessing.
|
|
|
|
|
*
|
|
|
|
|
* This kind of stream is meant generally for zero-shutter-lag features,
|
|
|
|
|
* where copying the captured image from the output buffer to the
|
|
|
|
|
* reprocessing input buffer would be expensive. The stream will be used by
|
|
|
|
|
* the framework as follows:
|
|
|
|
|
*
|
|
|
|
|
* 1. The framework includes a buffer from this stream as output buffer in a
|
|
|
|
|
* request as normal.
|
|
|
|
|
*
|
|
|
|
|
* 2. Once the HAL device returns a filled output buffer to the framework,
|
|
|
|
|
* the framework may do one of two things with the filled buffer:
|
|
|
|
|
*
|
|
|
|
|
* 2. a. The framework uses the filled data, and returns the now-used buffer
|
|
|
|
|
* to the stream queue for reuse. This behavior exactly matches the
|
|
|
|
|
* OUTPUT type of stream.
|
|
|
|
|
*
|
|
|
|
|
* 2. b. The framework wants to reprocess the filled data, and uses the
|
|
|
|
|
* buffer as an input buffer for a request. Once the HAL device has
|
|
|
|
|
* used the reprocessing buffer, it then returns it to the
|
|
|
|
|
* framework. The framework then returns the now-used buffer to the
|
|
|
|
|
* stream queue for reuse.
|
|
|
|
|
*
|
|
|
|
|
* 3. The HAL device will be given the buffer again as an output buffer for
|
|
|
|
|
* a request at some future point.
|
|
|
|
|
*
|
|
|
|
|
* Note that the HAL will always be reprocessing data it produced.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_STREAM_BIDIRECTIONAL = 2,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Total number of framework-defined stream types
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_NUM_STREAM_TYPES
|
|
|
|
|
|
|
|
|
|
} camera3_stream_type_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_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 additionally by the
|
|
|
|
|
* HAL with the gralloc usage flags and the maximum in-flight buffer count.
|
|
|
|
|
*
|
|
|
|
|
* The stream structures are owned by the framework, but pointers to a
|
|
|
|
|
* camera3_stream passed into the HAL by configure_streams() are valid until the
|
|
|
|
|
* end of the first subsequent configure_streams() call that _does not_ include
|
|
|
|
|
* that camera3_stream as an argument, or until the end of the close() call.
|
|
|
|
|
*
|
|
|
|
|
* All camera3_stream framework-controlled members are immutable once the
|
|
|
|
|
* camera3_stream is passed into configure_streams(). The HAL may only change
|
|
|
|
|
* the HAL-controlled parameters during a configure_streams() call, except for
|
|
|
|
|
* the contents of the private pointer.
|
|
|
|
|
*
|
|
|
|
|
* If a configure_streams() call returns a non-fatal error, all active streams
|
|
|
|
|
* remain valid as if configure_streams() had not been called.
|
|
|
|
|
*
|
|
|
|
|
* The endpoint of the stream is not visible to the camera HAL device.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_stream {
|
|
|
|
|
|
|
|
|
|
/*****
|
|
|
|
|
* Set by framework before configure_streams()
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* 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.
|
|
|
|
|
*
|
|
|
|
|
* The camera HAL device must inspect the buffers handed to it in the
|
|
|
|
|
* subsequent register_stream_buffers() call to obtain the
|
|
|
|
|
* implementation-specific format details, if necessary.
|
|
|
|
|
*/
|
|
|
|
|
int format;
|
|
|
|
|
|
|
|
|
|
/*****
|
|
|
|
|
* Set by HAL during configure_streams().
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
|
|
|
|
uint32_t usage;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The maximum number of buffers the HAL device may need to have dequeued at
|
|
|
|
|
* the same time. The HAL device may not have more buffers in-flight from
|
|
|
|
|
* this stream than this value.
|
|
|
|
|
*/
|
|
|
|
|
uint32_t max_buffers;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* A handle to HAL-private information for the stream. Will not be inspected
|
|
|
|
|
* by the framework code.
|
|
|
|
|
*/
|
|
|
|
|
void *priv;
|
|
|
|
|
|
|
|
|
|
} camera3_stream_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_stream_configuration_t:
|
|
|
|
|
*
|
|
|
|
|
* A structure of stream definitions, used by configure_streams(). This
|
|
|
|
|
* structure defines all the output streams and the reprocessing input
|
|
|
|
|
* stream for the current camera use case.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_stream_configuration {
|
|
|
|
|
/**
|
|
|
|
|
* The total number of streams requested 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;
|
|
|
|
|
|
|
|
|
|
/**
|
2013-03-06 22:21:11 +01:00
|
|
|
* An array of camera stream pointers, defining the input/output
|
|
|
|
|
* configuration for the camera HAL device.
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
|
|
|
|
* At most one input-capable stream may be defined (INPUT or BIDIRECTIONAL)
|
|
|
|
|
* in a single configuration.
|
|
|
|
|
*
|
|
|
|
|
* At least one output-capable stream must be defined (OUTPUT or
|
|
|
|
|
* BIDIRECTIONAL).
|
|
|
|
|
*/
|
2013-03-06 22:21:11 +01:00
|
|
|
camera3_stream_t **streams;
|
2012-11-28 03:06:06 +01:00
|
|
|
|
|
|
|
|
} camera3_stream_configuration_t;
|
|
|
|
|
|
2013-03-06 22:23:31 +01:00
|
|
|
/**
|
|
|
|
|
* camera3_buffer_status_t:
|
|
|
|
|
*
|
|
|
|
|
* The current status of a single stream buffer.
|
|
|
|
|
*/
|
|
|
|
|
typedef enum camera3_buffer_status {
|
|
|
|
|
/**
|
|
|
|
|
* The buffer is in a normal state, and can be used after waiting on its
|
|
|
|
|
* sync fence.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_BUFFER_STATUS_OK = 0,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The buffer does not contain valid data, and the data in it should not be
|
|
|
|
|
* used. The sync fence must still be waited on before reusing the buffer.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_BUFFER_STATUS_ERROR = 1
|
|
|
|
|
|
|
|
|
|
} camera3_buffer_status_t;
|
|
|
|
|
|
2012-11-28 03:06:06 +01:00
|
|
|
/**
|
|
|
|
|
* camera3_stream_buffer_t:
|
|
|
|
|
*
|
|
|
|
|
* A single buffer from a camera3 stream. It includes a handle to its parent
|
|
|
|
|
* stream, the handle to the gralloc buffer itself, and sync fences
|
|
|
|
|
*
|
|
|
|
|
* The buffer does not specify whether it is to be used for input or output;
|
|
|
|
|
* that is determined by its parent stream type and how the buffer is passed to
|
|
|
|
|
* the HAL device.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_stream_buffer {
|
|
|
|
|
/**
|
|
|
|
|
* The handle of the stream this buffer is associated with
|
|
|
|
|
*/
|
|
|
|
|
camera3_stream_t *stream;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The native handle to the buffer
|
|
|
|
|
*/
|
|
|
|
|
buffer_handle_t *buffer;
|
|
|
|
|
|
2013-03-06 22:23:31 +01:00
|
|
|
/**
|
|
|
|
|
* Current state of the buffer, one of the camera3_buffer_status_t
|
|
|
|
|
* values. The framework will not pass buffers to the HAL that are in an
|
|
|
|
|
* error state. In case a buffer could not be filled by the HAL, it must
|
|
|
|
|
* have its status set to CAMERA3_BUFFER_STATUS_ERROR when returned to the
|
|
|
|
|
* framework with process_capture_result().
|
|
|
|
|
*/
|
|
|
|
|
int status;
|
|
|
|
|
|
2012-11-28 03:06:06 +01:00
|
|
|
/**
|
|
|
|
|
* The acquire sync fence for this buffer. The HAL must wait on this fence
|
|
|
|
|
* fd before attempting to read from or write to this buffer.
|
|
|
|
|
*
|
|
|
|
|
* The framework may be set to -1 to indicate that no waiting is necessary
|
2013-03-06 22:23:31 +01:00
|
|
|
* for this buffer.
|
|
|
|
|
*
|
|
|
|
|
* When the HAL returns an output buffer to the framework with
|
|
|
|
|
* process_capture_result(), the acquire_fence must be set to -1. If the HAL
|
|
|
|
|
* never waits on the acquire_fence due to an error in filling a buffer,
|
|
|
|
|
* when calling process_capture_result() the HAL must set the release_fence
|
|
|
|
|
* of the buffer to be the acquire_fence passed to it by the framework. This
|
|
|
|
|
* will allow the framework to wait on the fence before reusing the buffer.
|
|
|
|
|
*
|
|
|
|
|
* For input buffers, the HAL must not change the acquire_fence field during
|
|
|
|
|
* the process_capture_request() call.
|
2012-11-28 03:06:06 +01:00
|
|
|
*/
|
|
|
|
|
int acquire_fence;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The release sync fence for this buffer. The HAL must set this fence when
|
|
|
|
|
* returning buffers to the framework, or write -1 to indicate that no
|
|
|
|
|
* waiting is required for this buffer.
|
|
|
|
|
*
|
|
|
|
|
* For the input buffer, the release fence must be set by the
|
|
|
|
|
* process_capture_request() call. For the output buffers, the fences must
|
|
|
|
|
* be set in the output_buffers array passed to process_capture_result().
|
2013-03-06 22:23:31 +01:00
|
|
|
*
|
2012-11-28 03:06:06 +01:00
|
|
|
*/
|
|
|
|
|
int release_fence;
|
|
|
|
|
|
|
|
|
|
} camera3_stream_buffer_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_stream_buffer_set_t:
|
|
|
|
|
*
|
|
|
|
|
* The complete set of gralloc buffers for a stream. This structure is given to
|
|
|
|
|
* register_stream_buffers() to allow the camera HAL device to register/map/etc
|
|
|
|
|
* newly allocated stream buffers.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_stream_buffer_set {
|
|
|
|
|
/**
|
|
|
|
|
* The stream handle for the stream these buffers belong to
|
|
|
|
|
*/
|
|
|
|
|
camera3_stream_t *stream;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The number of buffers in this stream. It is guaranteed to be at least
|
|
|
|
|
* stream->max_buffers.
|
|
|
|
|
*/
|
|
|
|
|
uint32_t num_buffers;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The array of gralloc buffer handles for this stream. If the stream format
|
|
|
|
|
* is set to HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, the camera HAL device
|
|
|
|
|
* should inspect the passed-in buffers to determine any platform-private
|
|
|
|
|
* pixel format information.
|
|
|
|
|
*/
|
2013-03-06 22:21:11 +01:00
|
|
|
buffer_handle_t **buffers;
|
2012-11-28 03:06:06 +01:00
|
|
|
|
|
|
|
|
} camera3_stream_buffer_set_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_jpeg_blob:
|
|
|
|
|
*
|
|
|
|
|
* Transport header for compressed JPEG buffers in output streams.
|
|
|
|
|
*
|
|
|
|
|
* To capture JPEG images, a stream is created using the pixel format
|
|
|
|
|
* HAL_PIXEL_FORMAT_BLOB, and the static metadata field android.jpeg.maxSize is
|
|
|
|
|
* used as the buffer size. 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.
|
|
|
|
|
*
|
|
|
|
|
* Transport header should be at the end of the JPEG output stream buffer. That
|
|
|
|
|
* means the jpeg_blob_id must start at byte[android.jpeg.maxSize -
|
|
|
|
|
* sizeof(camera3_jpeg_blob)]. 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.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_jpeg_blob {
|
|
|
|
|
uint16_t jpeg_blob_id;
|
|
|
|
|
uint32_t jpeg_size;
|
|
|
|
|
} camera3_jpeg_blob_t;
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
CAMERA3_JPEG_BLOB_ID = 0x00FF
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
*
|
|
|
|
|
* Message definitions for the HAL notify() callback.
|
|
|
|
|
*
|
|
|
|
|
* These definitions are used for the HAL notify callback, to signal
|
|
|
|
|
* asynchronous events from the HAL device to the Android framework.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_msg_type:
|
|
|
|
|
*
|
|
|
|
|
* Indicates the type of message sent, which specifies which member of the
|
|
|
|
|
* message union is valid.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
typedef enum camera3_msg_type {
|
|
|
|
|
/**
|
|
|
|
|
* An error has occurred. camera3_notify_msg.message.error contains the
|
|
|
|
|
* error information.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_MSG_ERROR = 1,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The exposure of a given request has
|
|
|
|
|
* begun. camera3_notify_msg.message.shutter contains the information
|
|
|
|
|
* the capture.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_MSG_SHUTTER = 2,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Number of framework message types
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_NUM_MESSAGES
|
|
|
|
|
|
|
|
|
|
} camera3_msg_type_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Defined error codes for CAMERA_MSG_ERROR
|
|
|
|
|
*/
|
|
|
|
|
typedef enum camera3_error_msg_code {
|
|
|
|
|
/**
|
|
|
|
|
* A serious failure occured. No further frames or buffer streams will
|
|
|
|
|
* be produced by the device. Device should be treated as closed. The
|
|
|
|
|
* client must reopen the device to use it again. The frame_number field
|
|
|
|
|
* is unused.
|
|
|
|
|
*/
|
2013-02-15 22:47:24 +01:00
|
|
|
CAMERA3_MSG_ERROR_DEVICE = 1,
|
2012-11-28 03:06:06 +01:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* An error has occurred in processing a request. No output (metadata or
|
|
|
|
|
* buffers) will be produced for this request. The frame_number field
|
|
|
|
|
* specifies which request has been dropped. Subsequent requests are
|
|
|
|
|
* unaffected, and the device remains operational.
|
|
|
|
|
*/
|
2013-02-15 22:47:24 +01:00
|
|
|
CAMERA3_MSG_ERROR_REQUEST = 2,
|
2012-11-28 03:06:06 +01:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* An error has occurred in producing an output result metadata buffer
|
|
|
|
|
* for a request, but output stream buffers for it will still be
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2013-02-15 22:47:24 +01:00
|
|
|
CAMERA3_MSG_ERROR_RESULT = 3,
|
2012-11-28 03:06:06 +01:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* An error has occurred in placing an output buffer into a stream for a
|
|
|
|
|
* request. The frame metadata and other buffers may still be
|
|
|
|
|
* available. Subsequent requests are unaffected, and the device remains
|
|
|
|
|
* operational. The frame_number field specifies the request for which the
|
|
|
|
|
* buffer was dropped, and error_stream contains a pointer to the stream
|
|
|
|
|
* that dropped the frame.u
|
|
|
|
|
*/
|
2013-02-15 22:47:24 +01:00
|
|
|
CAMERA3_MSG_ERROR_BUFFER = 4,
|
2012-11-28 03:06:06 +01:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Number of error types
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_MSG_NUM_ERRORS
|
|
|
|
|
|
|
|
|
|
} camera3_error_msg_code_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_error_msg_t:
|
|
|
|
|
*
|
|
|
|
|
* Message contents for CAMERA3_MSG_ERROR
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_error_msg {
|
|
|
|
|
/**
|
|
|
|
|
* Frame number of the request the error applies to. 0 if the frame number
|
|
|
|
|
* isn't applicable to the error.
|
|
|
|
|
*/
|
|
|
|
|
uint32_t frame_number;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Pointer to the stream that had a failure. NULL if the stream isn't
|
|
|
|
|
* applicable to the error.
|
|
|
|
|
*/
|
|
|
|
|
camera3_stream_t *error_stream;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The code for this error; one of the CAMERA_MSG_ERROR enum values.
|
|
|
|
|
*/
|
|
|
|
|
int error_code;
|
|
|
|
|
|
|
|
|
|
} camera3_error_msg_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_shutter_msg_t:
|
|
|
|
|
*
|
|
|
|
|
* Message contents for CAMERA3_MSG_SHUTTER
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_shutter_msg {
|
|
|
|
|
/**
|
|
|
|
|
* Frame number of the request that has begun exposure
|
|
|
|
|
*/
|
|
|
|
|
uint32_t frame_number;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Timestamp for the start of capture. This must match the capture result
|
|
|
|
|
* metadata's sensor exposure start timestamp.
|
|
|
|
|
*/
|
|
|
|
|
uint64_t timestamp;
|
|
|
|
|
|
|
|
|
|
} camera3_shutter_msg_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_notify_msg_t:
|
|
|
|
|
*
|
|
|
|
|
* The message structure sent to camera3_callback_ops_t.notify()
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_notify_msg {
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The message type. One of camera3_notify_msg_type, or a private extension.
|
|
|
|
|
*/
|
|
|
|
|
int type;
|
|
|
|
|
|
|
|
|
|
union {
|
|
|
|
|
/**
|
|
|
|
|
* Error message contents. Valid if type is CAMERA3_MSG_ERROR
|
|
|
|
|
*/
|
|
|
|
|
camera3_error_msg_t error;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Shutter message contents. Valid if type is CAMERA3_MSG_SHUTTER
|
|
|
|
|
*/
|
|
|
|
|
camera3_shutter_msg_t shutter;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Generic message contents. Used to ensure a minimum size for custom
|
|
|
|
|
* message types.
|
|
|
|
|
*/
|
|
|
|
|
uint8_t generic[32];
|
|
|
|
|
} message;
|
|
|
|
|
|
|
|
|
|
} camera3_notify_msg_t;
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
*
|
|
|
|
|
* Capture request/result definitions for the HAL process_capture_request()
|
|
|
|
|
* method, and the process_capture_result() callback.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_request_template_t:
|
|
|
|
|
*
|
|
|
|
|
* Available template types for
|
|
|
|
|
* camera3_device_ops.construct_default_request_settings()
|
|
|
|
|
*/
|
|
|
|
|
typedef enum camera3_request_template {
|
|
|
|
|
/**
|
|
|
|
|
* Standard camera preview operation with 3A on auto.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_TEMPLATE_PREVIEW = 1,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Standard camera high-quality still capture with 3A and flash on auto.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_TEMPLATE_STILL_CAPTURE = 2,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Standard video recording plus preview with 3A on auto, torch off.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_TEMPLATE_VIDEO_RECORD = 3,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* High-quality still capture while recording video. Application will
|
|
|
|
|
* include preview, video record, and full-resolution YUV or JPEG streams in
|
|
|
|
|
* request. Must not cause stuttering on video stream. 3A on auto.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_TEMPLATE_VIDEO_SNAPSHOT = 4,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Zero-shutter-lag mode. Application will request preview and
|
|
|
|
|
* full-resolution data for each frame, and reprocess it to JPEG when a
|
|
|
|
|
* still image is requested by user. Settings should provide highest-quality
|
|
|
|
|
* full-resolution images without compromising preview frame rate. 3A on
|
|
|
|
|
* auto.
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG = 5,
|
|
|
|
|
|
|
|
|
|
/* Total number of templates */
|
|
|
|
|
CAMERA3_TEMPLATE_COUNT,
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* First value for vendor-defined request templates
|
|
|
|
|
*/
|
|
|
|
|
CAMERA3_VENDOR_TEMPLATE_START = 0x40000000
|
|
|
|
|
|
|
|
|
|
} camera3_request_template_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_capture_request_t:
|
|
|
|
|
*
|
|
|
|
|
* A single request for image capture/buffer reprocessing, sent to the Camera
|
|
|
|
|
* HAL device by the framework in process_capture_request().
|
|
|
|
|
*
|
|
|
|
|
* The request contains the settings to be used for this capture, and the set of
|
|
|
|
|
* output buffers to write the resulting image data in. It may optionally
|
|
|
|
|
* contain an input buffer, in which case the request is for reprocessing that
|
|
|
|
|
* input buffer instead of capturing a new image with the camera sensor. The
|
|
|
|
|
* capture is identified by the frame_number.
|
|
|
|
|
*
|
|
|
|
|
* In response, the camera HAL device must send a camera3_capture_result
|
|
|
|
|
* structure asynchronously to the framework, using the process_capture_result()
|
|
|
|
|
* callback.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_capture_request {
|
|
|
|
|
/**
|
|
|
|
|
* The frame number is an incrementing integer set by the framework to
|
|
|
|
|
* uniquely identify this capture. It needs to be returned in the result
|
|
|
|
|
* call, and is also used to identify the request in asynchronous
|
|
|
|
|
* notifications sent to camera3_callback_ops_t.notify().
|
|
|
|
|
*/
|
|
|
|
|
uint32_t frame_number;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The settings buffer contains the capture and processing parameters for
|
|
|
|
|
* the request. As a special case, a NULL settings buffer indicates that the
|
|
|
|
|
* settings are identical to the most-recently submitted capture request. A
|
|
|
|
|
* NULL buffer cannot be used as the first submitted request after a
|
|
|
|
|
* configure_streams() call.
|
|
|
|
|
*/
|
|
|
|
|
const camera_metadata_t *settings;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The input stream buffer to use for this request, if any.
|
|
|
|
|
*
|
|
|
|
|
* If input_buffer is NULL, then the request is for a new capture from the
|
|
|
|
|
* imager. If input_buffer is valid, the request is for reprocessing the
|
|
|
|
|
* image contained in input_buffer.
|
|
|
|
|
*
|
|
|
|
|
* In the latter case, the HAL must set the release_fence of the
|
|
|
|
|
* input_buffer to a valid sync fence, or to -1 if the HAL does not support
|
|
|
|
|
* sync, before process_capture_request() returns.
|
|
|
|
|
*
|
|
|
|
|
* The HAL is required to wait on the acquire sync fence of the input buffer
|
|
|
|
|
* before accessing it.
|
|
|
|
|
*
|
|
|
|
|
* Any input buffer included here will have been registered with the HAL
|
|
|
|
|
* through register_stream_buffers() before its inclusion in a request.
|
|
|
|
|
*/
|
|
|
|
|
camera3_stream_buffer_t *input_buffer;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The number of output buffers for this capture request. Must be at least
|
|
|
|
|
* 1.
|
|
|
|
|
*/
|
|
|
|
|
uint32_t num_output_buffers;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* An array of num_output_buffers stream buffers, to be filled with image
|
|
|
|
|
* data from this capture/reprocess. The HAL must wait on the acquire fences
|
|
|
|
|
* of each stream buffer before writing to them. All the buffers included
|
|
|
|
|
* here will have been registered with the HAL through
|
|
|
|
|
* register_stream_buffers() before their inclusion in a request.
|
|
|
|
|
*
|
|
|
|
|
* The HAL takes ownership of the actual buffer_handle_t entries in
|
|
|
|
|
* output_buffers; the framework does not access them until they are
|
|
|
|
|
* returned in a camera3_capture_result_t.
|
|
|
|
|
*/
|
|
|
|
|
const camera3_stream_buffer_t *output_buffers;
|
|
|
|
|
|
|
|
|
|
} camera3_capture_request_t;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* camera3_capture_result_t:
|
|
|
|
|
*
|
|
|
|
|
* The result of a single capture/reprocess by the camera HAL device. This is
|
|
|
|
|
* sent to the framework asynchronously with process_capture_result(), in
|
|
|
|
|
* response to a single capture request sent to the HAL with
|
|
|
|
|
* process_capture_request().
|
|
|
|
|
*
|
|
|
|
|
* The result structure contains the output metadata from this capture, and the
|
|
|
|
|
* set of output buffers that have been/will be filled for this capture. Each
|
|
|
|
|
* output buffer may come with a release sync fence that the framework will wait
|
|
|
|
|
* on before reading, in case the buffer has not yet been filled by the HAL.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_capture_result {
|
|
|
|
|
/**
|
|
|
|
|
* The frame number is an incrementing integer set by the framework in the
|
|
|
|
|
* submitted request to uniquely identify this capture. It is also used to
|
|
|
|
|
* identify the request in asynchronous notifications sent to
|
|
|
|
|
* camera3_callback_ops_t.notify().
|
|
|
|
|
*/
|
|
|
|
|
uint32_t frame_number;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The result metadata for this capture. This contains information about the
|
|
|
|
|
* final capture parameters, the state of the capture and post-processing
|
|
|
|
|
* hardware, the state of the 3A algorithms, if enabled, and the output of
|
|
|
|
|
* any enabled statistics units.
|
|
|
|
|
*/
|
|
|
|
|
const camera_metadata_t *result;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The number of output buffers used for this capture. Must equal the
|
|
|
|
|
* matching capture request's count.
|
|
|
|
|
*/
|
|
|
|
|
uint32_t num_output_buffers;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The handles for the output stream buffers for this capture. They may not
|
|
|
|
|
* yet be filled at the time the HAL calls process_capture_result(); the
|
|
|
|
|
* framework will wait on the release sync fences provided by the HAL before
|
|
|
|
|
* reading the buffers.
|
|
|
|
|
*
|
|
|
|
|
* The HAL must set the stream buffer's release sync fence to a valid sync
|
|
|
|
|
* fd, or to -1 if the buffer has already been filled.
|
2013-03-06 22:23:31 +01:00
|
|
|
*
|
|
|
|
|
* If the HAL encounters an error while processing the buffer, and the
|
|
|
|
|
* buffer is not filled, the buffer's status field must be set to
|
|
|
|
|
* CAMERA3_BUFFER_STATUS_ERROR. If the HAL did not wait on the acquire fence
|
|
|
|
|
* before encountering the error, the acquire fence should be copied into
|
|
|
|
|
* the release fence, to allow the framework to wait on the fence before
|
|
|
|
|
* reusing the buffer.
|
|
|
|
|
*
|
|
|
|
|
* The acquire fence must be set to -1 for all output buffers.
|
|
|
|
|
*
|
2012-11-28 03:06:06 +01:00
|
|
|
*/
|
|
|
|
|
const camera3_stream_buffer_t *output_buffers;
|
|
|
|
|
|
|
|
|
|
} camera3_capture_result_t;
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
*
|
|
|
|
|
* Callback methods for the HAL to call into the framework.
|
|
|
|
|
*
|
|
|
|
|
* These methods are used to return metadata and image buffers for a completed
|
|
|
|
|
* or failed captures, and to notify the framework of asynchronous events such
|
|
|
|
|
* as errors.
|
|
|
|
|
*
|
|
|
|
|
* The framework will not call back into the HAL from within these callbacks,
|
|
|
|
|
* and these calls will not block for extended periods.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_callback_ops {
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* process_capture_result:
|
|
|
|
|
*
|
|
|
|
|
* Send a completed capture result metadata buffer to the framework, along
|
|
|
|
|
* with the possibly completed output stream buffers.
|
|
|
|
|
*
|
|
|
|
|
* Captures must be processed in-order, so that the Nth request submitted
|
|
|
|
|
* will match with the Nth result returned. Only one call to
|
|
|
|
|
* process_capture_request() should be made at a time to ensure correct
|
|
|
|
|
* ordering.
|
|
|
|
|
*
|
|
|
|
|
* The HAL retains ownership of result structure, which only needs to be
|
|
|
|
|
* valid to access during this call. The framework will copy whatever it
|
|
|
|
|
* needs before this call returns.
|
|
|
|
|
*
|
|
|
|
|
* The output buffers do not need to be filled yet; the framework will wait
|
|
|
|
|
* on the stream buffer release sync fence before reading the buffer
|
|
|
|
|
* data. Therefore, this method must be called by the HAL as soon as the
|
|
|
|
|
* result metadata is available, even if some or all of the output buffers
|
|
|
|
|
* are still in processing. The HAL must include valid release sync fences
|
|
|
|
|
* into each output_buffers stream buffer entry, or -1 if it does not
|
|
|
|
|
* support streams or if that stream buffer is already filled.
|
|
|
|
|
*
|
|
|
|
|
* If the result buffer cannot be constructed for a request, the HAL should
|
|
|
|
|
* return a NULL buffer here, but still provide the output buffers and their
|
|
|
|
|
* sync fences. In addition, notify() must be called with an ERROR_RESULT
|
|
|
|
|
* message.
|
|
|
|
|
*
|
2013-03-06 22:23:31 +01:00
|
|
|
* If an output buffer cannot be filled, its status field must be set to
|
|
|
|
|
* STATUS_ERROR. In addition, notify() must be called with a ERROR_BUFFER
|
|
|
|
|
* message.
|
2012-11-28 03:06:06 +01:00
|
|
|
*
|
|
|
|
|
* If the entire capture has failed, then this method still needs to be
|
2013-03-06 22:23:31 +01:00
|
|
|
* called to return the output buffers to the framework. All the buffer
|
|
|
|
|
* statuses should be STATUS_ERROR, and the result metadata should be
|
|
|
|
|
* NULL. In addition, notify() must be called with a ERROR_REQUEST
|
2012-11-28 03:06:06 +01:00
|
|
|
* message. In this case, individual ERROR_RESULT/ERROR_BUFFER messages
|
|
|
|
|
* should not be sent.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
void (*process_capture_result)(const struct camera3_callback_ops *,
|
|
|
|
|
const camera3_capture_result_t *result);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* notify:
|
|
|
|
|
*
|
|
|
|
|
* Asynchronous notification callback from the HAL, fired for various
|
|
|
|
|
* reasons. Only for information independent of frame capture, or that
|
|
|
|
|
* require specific timing. The ownership of the message structure remains
|
|
|
|
|
* with the HAL, and the msg only needs to be valid for the duration of this
|
|
|
|
|
* call.
|
|
|
|
|
*
|
|
|
|
|
* Multiple threads may call notify() simultaneously.
|
|
|
|
|
*/
|
|
|
|
|
void (*notify)(const struct camera3_callback_ops *,
|
|
|
|
|
const camera3_notify_msg_t *msg);
|
|
|
|
|
|
|
|
|
|
} camera3_callback_ops_t;
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
*
|
|
|
|
|
* Camera device operations
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_device_ops {
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* initialize:
|
|
|
|
|
*
|
|
|
|
|
* One-time initialization to pass framework callback function pointers to
|
|
|
|
|
* the HAL. Will be called once after a successful open() call, before any
|
|
|
|
|
* other functions are called on the camera3_device_ops structure.
|
|
|
|
|
*
|
|
|
|
|
* Return values:
|
|
|
|
|
*
|
|
|
|
|
* 0: On successful initialization
|
|
|
|
|
*
|
|
|
|
|
* -ENODEV: If initialization fails. Only close() can be called successfully
|
|
|
|
|
* by the framework after this.
|
|
|
|
|
*/
|
|
|
|
|
int (*initialize)(const struct camera3_device *,
|
|
|
|
|
const camera3_callback_ops_t *callback_ops);
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
* Stream management
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* configure_streams:
|
|
|
|
|
*
|
|
|
|
|
* Reset the HAL camera device processing pipeline and set up new input and
|
|
|
|
|
* output streams. This call replaces any existing stream configuration with
|
|
|
|
|
* the streams defined in the stream_list. This method will be called at
|
|
|
|
|
* least once after initialize() before a request is submitted with
|
|
|
|
|
* process_capture_request().
|
|
|
|
|
*
|
|
|
|
|
* The stream_list must contain at least one output-capable stream, and may
|
|
|
|
|
* not contain more than one input-capable stream.
|
|
|
|
|
*
|
|
|
|
|
* The stream_list may contain streams that are also in the currently-active
|
|
|
|
|
* set of streams (from the previous call to configure_stream()). These
|
|
|
|
|
* streams will already have valid values for usage, max_buffers, and the
|
|
|
|
|
* private pointer. If such a stream has already had its buffers registered,
|
|
|
|
|
* register_stream_buffers() will not be called again for the stream, and
|
|
|
|
|
* buffers from the stream can be immediately included in input requests.
|
|
|
|
|
*
|
|
|
|
|
* If the HAL needs to change the stream configuration for an existing
|
|
|
|
|
* stream due to the new configuration, it may rewrite the values of usage
|
|
|
|
|
* and/or max_buffers during the configure call. The framework will detect
|
|
|
|
|
* such a change, and will then reallocate the stream buffers, and call
|
|
|
|
|
* register_stream_buffers() again before using buffers from that stream in
|
|
|
|
|
* a request.
|
|
|
|
|
*
|
|
|
|
|
* If a currently-active stream is not included in stream_list, the HAL may
|
|
|
|
|
* safely remove any references to that stream. It will not be reused in a
|
|
|
|
|
* later configure() call by the framework, and all the gralloc buffers for
|
|
|
|
|
* it will be freed after the configure_streams() call returns.
|
|
|
|
|
*
|
|
|
|
|
* The stream_list structure is owned by the framework, and may not be
|
|
|
|
|
* accessed once this call completes. The address of an individual
|
|
|
|
|
* camera3_stream_t structure will remain valid for access by the HAL until
|
|
|
|
|
* the end of the first configure_stream() call which no longer includes
|
|
|
|
|
* that camera3_stream_t in the stream_list argument. The HAL may not change
|
|
|
|
|
* values in the stream structure outside of the private pointer, except for
|
|
|
|
|
* the usage and max_buffers members during the configure_streams() call
|
|
|
|
|
* itself.
|
|
|
|
|
*
|
|
|
|
|
* If the stream is new, the usage, max_buffer, and private pointer fields
|
|
|
|
|
* of the stream structure will all be set to 0. The HAL device must set
|
|
|
|
|
* these fields before the configure_streams() call returns. These fields
|
|
|
|
|
* are then used by the framework and the platform gralloc module to
|
|
|
|
|
* allocate the gralloc buffers for each stream.
|
|
|
|
|
*
|
|
|
|
|
* Before such a new stream can have its buffers included in a capture
|
|
|
|
|
* request, the framework will call register_stream_buffers() with that
|
|
|
|
|
* stream. However, the framework is not required to register buffers for
|
|
|
|
|
* _all_ streams before submitting a request. This allows for quick startup
|
|
|
|
|
* of (for example) a preview stream, with allocation for other streams
|
|
|
|
|
* happening later or concurrently.
|
|
|
|
|
*
|
|
|
|
|
* Preconditions:
|
|
|
|
|
*
|
|
|
|
|
* The framework will only call this method when no captures are being
|
|
|
|
|
* processed. That is, all results have been returned to the framework, and
|
|
|
|
|
* all in-flight input and output buffers have been returned and their
|
|
|
|
|
* release sync fences have been signaled by the HAL. The framework will not
|
|
|
|
|
* submit new requests for capture while the configure_streams() call is
|
|
|
|
|
* underway.
|
|
|
|
|
*
|
|
|
|
|
* Postconditions:
|
|
|
|
|
*
|
|
|
|
|
* The HAL device must configure itself to provide maximum possible output
|
|
|
|
|
* frame rate given the sizes and formats of the output streams, as
|
|
|
|
|
* documented in the camera device's static metadata.
|
|
|
|
|
*
|
|
|
|
|
* Performance expectations:
|
|
|
|
|
*
|
|
|
|
|
* This call is expected to be heavyweight and possibly take several hundred
|
|
|
|
|
* milliseconds to complete, since it may require resetting and
|
|
|
|
|
* reconfiguring the image sensor and the camera processing pipeline.
|
|
|
|
|
* Nevertheless, the HAL device should attempt to minimize the
|
|
|
|
|
* reconfiguration delay to minimize the user-visible pauses during
|
|
|
|
|
* application operational mode changes (such as switching from still
|
|
|
|
|
* capture to video recording).
|
|
|
|
|
*
|
|
|
|
|
* Return values:
|
|
|
|
|
*
|
|
|
|
|
* 0: On successful stream configuration
|
|
|
|
|
*
|
|
|
|
|
* -EINVAL: If the requested stream configuration is invalid. Some examples
|
|
|
|
|
* of invalid stream configurations include:
|
|
|
|
|
*
|
|
|
|
|
* - Including more than 1 input-capable stream (INPUT or
|
|
|
|
|
* BIDIRECTIONAL)
|
|
|
|
|
*
|
|
|
|
|
* - Not including any output-capable streams (OUTPUT or
|
|
|
|
|
* BIDIRECTIONAL)
|
|
|
|
|
*
|
|
|
|
|
* - Including streams with unsupported formats, or an unsupported
|
|
|
|
|
* size for that format.
|
|
|
|
|
*
|
|
|
|
|
* - Including too many output streams of a certain format.
|
|
|
|
|
*
|
2013-02-15 21:09:48 +01:00
|
|
|
* Note that the framework submitting an invalid stream
|
|
|
|
|
* configuration is not normal operation, since stream
|
|
|
|
|
* configurations are checked before configure. An invalid
|
|
|
|
|
* configuration means that a bug exists in the framework code, or
|
|
|
|
|
* there is a mismatch between the HAL's static metadata and the
|
|
|
|
|
* requirements on streams.
|
|
|
|
|
*
|
2012-11-28 03:06:06 +01:00
|
|
|
* -ENODEV: If there has been a fatal error and the device is no longer
|
|
|
|
|
* operational. Only close() can be called successfully by the
|
|
|
|
|
* framework after this error is returned.
|
|
|
|
|
*/
|
|
|
|
|
int (*configure_streams)(const struct camera3_device *,
|
|
|
|
|
camera3_stream_configuration_t *stream_list);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* register_stream_buffers:
|
|
|
|
|
*
|
|
|
|
|
* Register buffers for a given stream with the HAL device. This method is
|
|
|
|
|
* called by the framework after a new stream is defined by
|
|
|
|
|
* configure_streams, and before buffers from that stream are included in a
|
|
|
|
|
* capture request. If the same stream is listed in a subsequent
|
|
|
|
|
* configure_streams() call, register_stream_buffers will _not_ be called
|
|
|
|
|
* again for that stream.
|
|
|
|
|
*
|
|
|
|
|
* The framework does not need to register buffers for all configured
|
|
|
|
|
* streams before it submits the first capture request. This allows quick
|
|
|
|
|
* startup for preview (or similar use cases) while other streams are still
|
|
|
|
|
* being allocated.
|
|
|
|
|
*
|
|
|
|
|
* This method is intended to allow the HAL device to map or otherwise
|
|
|
|
|
* prepare the buffers for later use. The buffers passed in will already be
|
|
|
|
|
* locked for use. At the end of the call, all the buffers must be ready to
|
|
|
|
|
* be returned to the stream. The buffer_set argument is only valid for the
|
|
|
|
|
* duration of this call.
|
|
|
|
|
*
|
|
|
|
|
* If the stream format was set to HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
|
|
|
|
|
* the camera HAL should inspect the passed-in buffers here to determine any
|
|
|
|
|
* platform-private pixel format information.
|
|
|
|
|
*
|
|
|
|
|
* Return values:
|
|
|
|
|
*
|
|
|
|
|
* 0: On successful registration of the new stream buffers
|
|
|
|
|
*
|
|
|
|
|
* -EINVAL: If the stream_buffer_set does not refer to a valid active
|
|
|
|
|
* stream, or if the buffers array is invalid.
|
|
|
|
|
*
|
|
|
|
|
* -ENOMEM: If there was a failure in registering the buffers. The framework
|
|
|
|
|
* must consider all the stream buffers to be unregistered, and can
|
|
|
|
|
* try to register again later.
|
|
|
|
|
*
|
|
|
|
|
* -ENODEV: If there is a fatal error, and the device is no longer
|
|
|
|
|
* operational. Only close() can be called successfully by the
|
|
|
|
|
* framework after this error is returned.
|
|
|
|
|
*/
|
|
|
|
|
int (*register_stream_buffers)(const struct camera3_device *,
|
|
|
|
|
const camera3_stream_buffer_set_t *buffer_set);
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
* Request creation and submission
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* construct_default_request_settings:
|
|
|
|
|
*
|
|
|
|
|
* Create capture settings for standard camera use cases.
|
|
|
|
|
*
|
|
|
|
|
* The device must return a settings buffer that is configured to meet the
|
|
|
|
|
* requested use case, which must be one of the CAMERA3_TEMPLATE_*
|
|
|
|
|
* enums. All request control fields must be included.
|
|
|
|
|
*
|
|
|
|
|
* The HAL retains ownership of this structure, but the pointer to the
|
|
|
|
|
* structure must be valid until the device is closed. The framework and the
|
|
|
|
|
* HAL may not modify the buffer once it is returned by this call. The same
|
|
|
|
|
* buffer may be returned for subsequent calls for the same template, or for
|
|
|
|
|
* other templates.
|
|
|
|
|
*
|
|
|
|
|
* Return values:
|
|
|
|
|
*
|
|
|
|
|
* Valid metadata: On successful creation of a default settings
|
|
|
|
|
* buffer.
|
|
|
|
|
*
|
|
|
|
|
* NULL: In case of a fatal error. After this is returned, only
|
2013-03-17 00:53:28 +01:00
|
|
|
* the close() method can be called successfully by the
|
2012-11-28 03:06:06 +01:00
|
|
|
* framework.
|
|
|
|
|
*/
|
|
|
|
|
const camera_metadata_t* (*construct_default_request_settings)(
|
|
|
|
|
const struct camera3_device *,
|
|
|
|
|
int type);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* process_capture_request:
|
|
|
|
|
*
|
|
|
|
|
* Send a new capture request to the HAL. The HAL should not return from
|
|
|
|
|
* this call until it is ready to accept the next request to process. Only
|
|
|
|
|
* one call to process_capture_request() will be made at a time by the
|
|
|
|
|
* framework, and the calls will all be from the same thread. The next call
|
|
|
|
|
* to process_capture_request() will be made as soon as a new request and
|
|
|
|
|
* its associated buffers are available. In a normal preview scenario, this
|
|
|
|
|
* means the function will be called again by the framework almost
|
|
|
|
|
* instantly.
|
|
|
|
|
*
|
|
|
|
|
* The actual request processing is asynchronous, with the results of
|
|
|
|
|
* capture being returned by the HAL through the process_capture_result()
|
|
|
|
|
* call. This call requires the result metadata to be available, but output
|
|
|
|
|
* buffers may simply provide sync fences to wait on. Multiple requests are
|
|
|
|
|
* expected to be in flight at once, to maintain full output frame rate.
|
|
|
|
|
*
|
|
|
|
|
* The framework retains ownership of the request structure. It is only
|
|
|
|
|
* guaranteed to be valid during this call. The HAL device must make copies
|
|
|
|
|
* of the information it needs to retain for the capture processing.
|
|
|
|
|
*
|
|
|
|
|
* The HAL must write the file descriptor for the input buffer's release
|
|
|
|
|
* sync fence into input_buffer->release_fence, if input_buffer is not
|
|
|
|
|
* NULL. If the HAL returns -1 for the input buffer release sync fence, the
|
|
|
|
|
* framework is free to immediately reuse the input buffer. Otherwise, the
|
|
|
|
|
* framework will wait on the sync fence before refilling and reusing the
|
|
|
|
|
* input buffer.
|
|
|
|
|
*
|
|
|
|
|
* Return values:
|
|
|
|
|
*
|
|
|
|
|
* 0: On a successful start to processing the capture request
|
|
|
|
|
*
|
|
|
|
|
* -EINVAL: If the input is malformed (the settings are NULL when not
|
|
|
|
|
* allowed, there are 0 output buffers, etc) and capture processing
|
|
|
|
|
* cannot start. Failures during request processing should be
|
|
|
|
|
* handled by calling camera3_callback_ops_t.notify().
|
|
|
|
|
*
|
|
|
|
|
* -ENODEV: If the camera device has encountered a serious error. After this
|
|
|
|
|
* error is returned, only the close() method can be successfully
|
|
|
|
|
* called by the framework.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
int (*process_capture_request)(const struct camera3_device *,
|
|
|
|
|
camera3_capture_request_t *request);
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
* Miscellaneous methods
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* get_metadata_vendor_tag_ops:
|
|
|
|
|
*
|
2013-03-17 00:53:28 +01:00
|
|
|
* Get methods to query for vendor extension metadata tag information. The
|
2012-11-28 03:06:06 +01:00
|
|
|
* HAL should fill in all the vendor tag operation methods, or leave ops
|
|
|
|
|
* unchanged if no vendor tags are defined.
|
|
|
|
|
*
|
|
|
|
|
* The definition of vendor_tag_query_ops_t can be found in
|
|
|
|
|
* system/media/camera/include/system/camera_metadata.h.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
void (*get_metadata_vendor_tag_ops)(const struct camera3_device*,
|
|
|
|
|
vendor_tag_query_ops_t* ops);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* dump:
|
|
|
|
|
*
|
|
|
|
|
* Print out debugging state for the camera device. This will be called by
|
|
|
|
|
* the framework when the camera service is asked for a debug dump, which
|
|
|
|
|
* happens when using the dumpsys tool, or when capturing a bugreport.
|
|
|
|
|
*
|
|
|
|
|
* The passed-in file descriptor can be used to write debugging text using
|
|
|
|
|
* dprintf() or write(). The text should be in ASCII encoding only.
|
|
|
|
|
*/
|
|
|
|
|
void (*dump)(const struct camera3_device *, int fd);
|
|
|
|
|
|
|
|
|
|
} camera3_device_ops_t;
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
|
*
|
|
|
|
|
* Camera device definition
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
typedef struct camera3_device {
|
|
|
|
|
/**
|
|
|
|
|
* common.version must equal CAMERA_DEVICE_API_VERSION_3_0 to identify this
|
|
|
|
|
* device as implementing version 3.0 of the camera device HAL.
|
|
|
|
|
*/
|
|
|
|
|
hw_device_t common;
|
|
|
|
|
camera3_device_ops_t *ops;
|
|
|
|
|
void *priv;
|
|
|
|
|
} camera3_device_t;
|
|
|
|
|
|
|
|
|
|
__END_DECLS
|
|
|
|
|
|
|
|
|
|
#endif /* #ifdef ANDROID_INCLUDE_CAMERA3_H */
|
