/* * Copyright (C) 2018 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@3.5; import @3.2::StreamBuffer; import @3.4::StreamConfiguration; import @3.2::CameraBlobId; /** * If the result metadata cannot be produced for a physical camera device part of a logical * multi-camera, then HAL must invoke the notification callback and pass a message with ERROR_RESULT * code and errorStreamId that contains the stream id associated with that physical device. Such * callback must be made before the final processCaptureResult() call for the corresponding request. * The behavior during absent result metadata remains unchanged for a logical or a non-logical * camera device and the errorStreamId must be set to -1. */ /** * StreamConfiguration: * * Identical to @3.4::StreamConfiguration, except that it contains streamConfigCounter */ struct StreamConfiguration { @3.4::StreamConfiguration v3_4; /** * An incrementing counter used for HAL to keep track of the stream * configuration and the paired oneway signalStreamFlush call. When the * counter in signalStreamFlush call is less than the counter here, that * signalStreamFlush call is stale. */ uint32_t streamConfigCounter; }; enum StreamBufferRequestError : uint32_t { /** * Get buffer failed due to timeout waiting for an available buffer. This is * likely due to the client application holding too many buffers, or the * system is under memory pressure. * This is not a fatal error. HAL may try to request buffer for this stream * later. If HAL cannot get a buffer for certain capture request in time * due to this error, HAL can send an ERROR_REQUEST to camera service and * drop processing that request. */ NO_BUFFER_AVAILABLE = 1, /** * Get buffer failed due to HAL has reached its maxBuffer count. This is not * a fatal error. HAL may try to request buffer for this stream again after * it returns at least one buffer of that stream to camera service. */ MAX_BUFFER_EXCEEDED = 2, /** * Get buffer failed due to the stream is disconnected by client * application, has been removed, or not recognized by camera service. * This means application is no longer interested in this stream. * Requesting buffer for this stream must never succeed after this error is * returned. HAL must safely return all buffers of this stream after * getting this error. If HAL gets another capture request later targeting * a disconnected stream, HAL must send an ERROR_REQUEST to camera service * and drop processing that request. */ STREAM_DISCONNECTED = 3, /** * Get buffer failed for unknown reasons. This is a fatal error and HAL must * send ERROR_DEVICE to camera service and be ready to be closed. */ UNKNOWN_ERROR = 4 }; /** * Per-stream return value for requestStreamBuffers. * For each stream, either an StreamBufferRequestError error code, or all * requested buffers for this stream is returned, so buffers.size() must be * equal to BufferRequest::numBuffersRequested of corresponding stream. */ safe_union StreamBuffersVal { StreamBufferRequestError error; vec<@3.2::StreamBuffer> buffers; }; struct StreamBufferRet { int32_t streamId; StreamBuffersVal val; }; enum BufferRequestStatus : uint32_t { /** * Method call succeeded and all requested buffers are returned. */ OK = 0, /** * Method call failed for some streams. Check per stream status for each * returned StreamBufferRet. */ FAILED_PARTIAL = 1, /** * Method call failed for all streams and no buffers are returned at all. * Camera service is about to or is performing configureStreams. HAL must * wait until next configureStreams call is finished before requesting * buffers again. */ FAILED_CONFIGURING = 2, /** * Method call failed for all streams and no buffers are returned at all. * Failure due to bad BufferRequest input, eg: unknown streamId or repeated * streamId. */ FAILED_ILLEGAL_ARGUMENTS = 3, /** * Method call failed for all streams and no buffers are returned at all. * Failure due to unknown reason, or all streams has individual failing * reason. For the latter case, check per stream status for each returned * StreamBufferRet. */ FAILED_UNKNOWN = 4, }; struct BufferRequest { int32_t streamId; uint32_t numBuffersRequested; }; /** * CameraBlob: * * Identical to @3.2::CameraBlob, except that it also supports transport of JPEG * APP segments blob, which contains JPEG APP1 to APPn (Application Marker) * segments as specified in JEITA CP-3451. * * To capture a JPEG APP segments blob, a stream is created using the pixel format * HAL_PIXEL_FORMAT_BLOB and dataspace HAL_DATASPACE_JPEG_APP_SEGMENTS. The buffer * size for the stream is calculated by the framework, based on the static * metadata field android.heic.maxAppSegmentsCount, and is assigned to both * @3.2::Stream::width and @3.4::Stream::bufferSize. Camera framework sets * @3.2::Stream::height to 1. * * Similar to JPEG image, the JPEG APP segment images can be of variable size, * so the HAL needs to include the final size of all APP segments using this * structure inside the output stream buffer. The camera blob ID field must be * set to CameraBlobId::JPEG_APP_SEGMENTS. * * The transport header must be at the end of the JPEG APP segments output stream * buffer. That means the blobId must start at byte[buffer_size - * sizeof(CameraBlob)], where the buffer_size is the size of gralloc * buffer. The JPEG APP segments data itself starts at the beginning of the * buffer and must be blobSize bytes long. */ enum CameraBlobId : @3.2::CameraBlobId { JPEG_APP_SEGMENTS = 0x100, }; struct CameraBlob { CameraBlobId blobId; uint32_t blobSize; };