| /* |
| * Copyright (C) 2016 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. |
| */ |
| |
| package android.hardware.camera.device@1.0; |
| |
| enum CameraFacing : uint32_t { |
| /** The facing of the camera is opposite to that of the screen. */ |
| BACK = 0, |
| /** The facing of the camera is the same as that of the screen. */ |
| FRONT = 1, |
| /** |
| * The facing of the camera is not fixed relative to the screen. |
| * The cameras with this facing are external cameras, e.g. USB cameras. |
| */ |
| EXTERNAL = 2 |
| }; |
| |
| /** |
| * Basic information about a camera device, always accessible via |
| * ICameraDevice::getCameraInfo(). |
| */ |
| struct CameraInfo { |
| /** |
| * The direction that this device faces. |
| */ |
| CameraFacing facing; |
| |
| /** |
| * The orientation of the camera image. The value is the angle that the |
| * camera image needs to be rotated clockwise so it shows correctly on the |
| * display in its natural orientation. It must be 0, 90, 180, or 270. |
| * |
| * For example, suppose a device has a naturally tall screen. The |
| * back-facing camera sensor is mounted in landscape. You are looking at the |
| * screen. If the top side of the camera sensor is aligned with the right |
| * edge of the screen in natural orientation, the value must be 90. If the |
| * top side of a front-facing camera sensor is aligned with the right of the |
| * screen, the value must be 270. |
| * |
| * An external camera device must leave this set to 0. |
| * |
| */ |
| uint32_t orientation; |
| |
| }; |
| |
| /** |
| * Message types for ICameraDevice@1.0::enableMsgType()/disableMsgType() |
| * |
| * A set of bit masks for specifying how the received preview frames are |
| * handled before the previewCallback() call. |
| * |
| * The least significant 3 bits of an "int" value are used for this purpose: |
| * |
| * ..... 0 0 0 |
| * ^ ^ ^ |
| * | | |---------> determine whether the callback is enabled or not |
| * | |-----------> determine whether the callback is one-shot or not |
| * |-------------> determine whether the frame is copied out or not |
| * |
| * WARNING: When a frame is sent directly without copying, it is the frame |
| * receiver's responsiblity to make sure that the frame data won't get |
| * corrupted by subsequent preview frames filled by the camera. This flag is |
| * recommended only when copying out data brings significant performance price |
| * and the handling/processing of the received frame data is always faster than |
| * the preview frame rate so that data corruption won't occur. |
| * |
| * For instance, |
| * 1. 0x00 disables the callback. In this case, copy out and one shot bits |
| * are ignored. |
| * 2. 0x01 enables a callback without copying out the received frames. A |
| * typical use case is the Camcorder application to avoid making costly |
| * frame copies. |
| * 3. 0x05 is enabling a callback with frame copied out repeatedly. A typical |
| * use case is the Camera application. |
| * 4. 0x07 is enabling a callback with frame copied out only once. A typical |
| * use case is the Barcode scanner application. |
| */ |
| enum FrameCallbackFlag : uint32_t { |
| ENABLE_MASK = 0x01, |
| ONE_SHOT_MASK = 0x02, |
| COPY_OUT_MASK = 0x04, |
| /** Typical use cases */ |
| NOOP = 0x00, |
| CAMCORDER = 0x01, |
| CAMERA = 0x05, |
| BARCODE_SCANNER = 0x07 |
| }; |
| |
| typedef bitfield<FrameCallbackFlag> FrameCallbackFlags; |
| |
| /** |
| * Subset of commands in /system/core/include/system/camera.h relevant for |
| * ICameraDevice@1.0::sendCommand() |
| */ |
| enum CommandType : uint32_t { |
| START_SMOOTH_ZOOM = 1, |
| STOP_SMOOTH_ZOOM = 2, |
| |
| /** |
| * Start the face detection. This must be called only after preview is |
| * started. The camera must notify the listener of CAMERA_MSG_FACE and the |
| * detected faces in the preview frame. The detected faces may be the same |
| * as the previous ones. Apps must call CAMERA_CMD_STOP_FACE_DETECTION to |
| * stop the face detection. This method is supported if CameraParameters |
| * KEY_MAX_NUM_HW_DETECTED_FACES or KEY_MAX_NUM_SW_DETECTED_FACES is bigger |
| * than 0. Hardware and software face detection must not be running at the |
| * same time. If the face detection has started, apps must not send this |
| * again. |
| * |
| * In hardware face detection mode, CameraParameters KEY_WHITE_BALANCE, |
| * KEY_FOCUS_AREAS and KEY_METERING_AREAS have no effect. |
| * |
| * arg1 is the face detection type. It can be CAMERA_FACE_DETECTION_HW or |
| * CAMERA_FACE_DETECTION_SW. If the type of face detection requested is not |
| * supported, the HAL must return BAD_VALUE. |
| */ |
| START_FACE_DETECTION = 6, |
| |
| /** |
| * Stop the face detection. |
| */ |
| STOP_FACE_DETECTION = 7, |
| |
| /** |
| * Enable/disable focus move callback (CAMERA_MSG_FOCUS_MOVE). Passing |
| * arg1 = 0 must disable, while passing arg1 = 1 must enable the callback. |
| */ |
| ENABLE_FOCUS_MOVE_MSG = 8, |
| |
| /** |
| * Configure an explicit format to use for video recording metadata mode. |
| * This can be used to switch the format from the |
| * default IMPLEMENTATION_DEFINED gralloc format to some other |
| * device-supported format, and the default dataspace from the BT_709 color |
| * space to some other device-supported dataspace. arg1 is the HAL pixel |
| * format, and arg2 is the HAL dataSpace. This command returns |
| * INVALID_OPERATION error if it is sent after video recording is started, |
| * or the command is not supported at all. |
| * |
| * If the gralloc format is set to a format other than |
| * IMPLEMENTATION_DEFINED, then HALv3 devices must use gralloc usage flags |
| * of SW_READ_OFTEN. |
| */ |
| SET_VIDEO_FORMAT = 11 |
| }; |
| |
| /** |
| * Message types for ICameraDevice1Callback::notifyCallback() |
| */ |
| enum NotifyCallbackMsg : uint32_t { |
| ERROR = 0x0001, |
| SHUTTER = 0x0002, |
| FOCUS = 0x0004, |
| ZOOM = 0x0008, |
| // Notify on autofocus start and stop. This is useful in continuous |
| // autofocus - FOCUS_MODE_CONTINUOUS_VIDEO and FOCUS_MODE_CONTINUOUS_PICTURE. |
| FOCUS_MOVE = 0x0800 |
| }; |
| |
| /** |
| * Message types for ICameraDevice1Callback::dataCallback() and |
| * ICameraDevice1Callback::dataCallbackTimestamp() |
| */ |
| enum DataCallbackMsg : uint32_t { |
| PREVIEW_FRAME = 0x0010, |
| VIDEO_FRAME = 0x0020, |
| POSTVIEW_FRAME = 0x0040, |
| RAW_IMAGE = 0x0080, |
| COMPRESSED_IMAGE = 0x0100, |
| RAW_IMAGE_NOTIFY = 0x0200, |
| // Preview frame metadata. This can be combined with |
| // CAMERA_MSG_PREVIEW_FRAME in dataCallback. For example, the apps can |
| // request FRAME and METADATA. Or the apps can request only FRAME or only |
| // METADATA. |
| PREVIEW_METADATA = 0x0400 |
| }; |
| |
| /** |
| * Information for a single detected face. |
| */ |
| struct CameraFace { |
| /** |
| * Bounds of the face [left, top, right, bottom]. (-1000, -1000) represents |
| * the top-left of the camera field of view, and (1000, 1000) represents the |
| * bottom-right of the field of view. The width and height cannot be 0 or |
| * negative. This is supported by both hardware and software face detection. |
| * |
| * The direction is relative to the sensor orientation, that is, what the |
| * sensor sees. The direction is not affected by the rotation or mirroring |
| * of CAMERA_CMD_SET_DISPLAY_ORIENTATION. |
| */ |
| int32_t[4] rect; |
| |
| /** |
| * The confidence level of the face. The range is 1 to 100. 100 is the |
| * highest confidence. This is supported by both hardware and software |
| * face detection. |
| */ |
| int32_t score; |
| |
| /** |
| * An unique id per face while the face is visible to the tracker. If |
| * the face leaves the field-of-view and comes back, it will get a new |
| * id. If the value is 0, id is not supported. |
| */ |
| int32_t id; |
| |
| /** |
| * The coordinates of the center of the left eye. The range is -1000 to |
| * 1000. -2000, -2000 if this is not supported. |
| */ |
| int32_t[2] leftEye; |
| |
| /** |
| * The coordinates of the center of the right eye. The range is -1000 to |
| * 1000. -2000, -2000 if this is not supported. |
| */ |
| int32_t[2] rightEye; |
| |
| /** |
| * The coordinates of the center of the mouth. The range is -1000 to 1000. |
| * -2000, -2000 if this is not supported. |
| */ |
| int32_t[2] mouth; |
| |
| }; |
| |
| /** |
| * The metadata of the frame data, such as face detection result. |
| */ |
| struct CameraFrameMetadata { |
| /** |
| * A vector of the detected faces. |
| */ |
| vec<CameraFace> faces; |
| }; |
| |
| /** |
| * A simple integer handle to use to reference a particular memory buffer |
| * between the HAL and the framework. |
| */ |
| typedef uint32_t MemoryId; |
| |
| /* |
| * Struct containing arguments of ICameraDeviceCallback::handleCallbackTimestamp. |
| * Used to send a batch of messages in ICameraDeviceCallback::handleCallbackTimestampBatch. |
| */ |
| struct HandleTimestampMessage { |
| // The handle of image buffer data. |
| handle frameData; |
| |
| // A memory handle to the buffer containing the data |
| MemoryId data; |
| |
| // The offset into the memory handle where the buffer starts. |
| uint32_t bufferIndex; |
| |
| // The time this buffer was captured by the camera, in nanoseconds |
| int64_t timestamp; |
| }; |
| |
| /* |
| * Struct containing arguments of ICameraDevice::releaseRecordingFrameHandle. |
| * Used by camera framework to send a batch of recording frames back to camera HAL. |
| */ |
| struct VideoFrameMessage { |
| // The handle of image buffer data. |
| handle frameData; |
| |
| // A memory handle to the buffer containing the data |
| MemoryId data; |
| |
| // The offset into the memory handle where the buffer starts. |
| uint32_t bufferIndex; |
| }; |