1 /* 2 * Copyright (C) 2019 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_SERVERS_CAMERA3_INFLIGHT_REQUEST_H 18 #define ANDROID_SERVERS_CAMERA3_INFLIGHT_REQUEST_H 19 20 #include <set> 21 22 #include <camera/CaptureResult.h> 23 #include <camera/CameraMetadata.h> 24 #include <utils/String8.h> 25 #include <utils/Timers.h> 26 27 #include "common/CameraDeviceBase.h" 28 29 namespace android { 30 31 namespace camera3 { 32 33 typedef struct camera_stream_configuration { 34 uint32_t num_streams; 35 camera_stream_t **streams; 36 uint32_t operation_mode; 37 bool input_is_multi_resolution; 38 } camera_stream_configuration_t; 39 40 typedef struct camera_capture_request { 41 uint32_t frame_number; 42 const camera_metadata_t *settings; 43 camera_stream_buffer_t *input_buffer; 44 uint32_t num_output_buffers; 45 const camera_stream_buffer_t *output_buffers; 46 uint32_t num_physcam_settings; 47 const char **physcam_id; 48 const camera_metadata_t **physcam_settings; 49 int32_t input_width; 50 int32_t input_height; 51 } camera_capture_request_t; 52 53 typedef struct camera_capture_result { 54 uint32_t frame_number; 55 const camera_metadata_t *result; 56 uint32_t num_output_buffers; 57 const camera_stream_buffer_t *output_buffers; 58 const camera_stream_buffer_t *input_buffer; 59 uint32_t partial_result; 60 uint32_t num_physcam_metadata; 61 const char **physcam_ids; 62 const camera_metadata_t **physcam_metadata; 63 } camera_capture_result_t; 64 65 typedef struct camera_shutter_msg { 66 uint32_t frame_number; 67 uint64_t timestamp; 68 bool readout_timestamp_valid; 69 uint64_t readout_timestamp; 70 } camera_shutter_msg_t; 71 72 typedef struct camera_error_msg { 73 uint32_t frame_number; 74 camera_stream_t *error_stream; 75 int error_code; 76 } camera_error_msg_t; 77 78 typedef enum camera_error_msg_code { 79 CAMERA_MSG_ERROR_DEVICE = 1, 80 CAMERA_MSG_ERROR_REQUEST = 2, 81 CAMERA_MSG_ERROR_RESULT = 3, 82 CAMERA_MSG_ERROR_BUFFER = 4, 83 CAMERA_MSG_NUM_ERRORS 84 } camera_error_msg_code_t; 85 86 typedef struct camera_notify_msg { 87 int type; 88 89 union { 90 camera_error_msg_t error; 91 camera_shutter_msg_t shutter; 92 } message; 93 } camera_notify_msg_t; 94 95 typedef enum { 96 // Cache the buffers with STATUS_ERROR within InFlightRequest 97 ERROR_BUF_CACHE, 98 // Return the buffers with STATUS_ERROR to the buffer queue 99 ERROR_BUF_RETURN, 100 // Return the buffers with STATUS_ERROR to the buffer queue, and call 101 // notify(ERROR_BUFFER) as well 102 ERROR_BUF_RETURN_NOTIFY 103 } ERROR_BUF_STRATEGY; 104 105 struct InFlightRequest { 106 // Set by notify() SHUTTER call. 107 nsecs_t shutterTimestamp; 108 // Set by process_capture_result(). 109 nsecs_t sensorTimestamp; 110 int requestStatus; 111 // Set by process_capture_result call with valid metadata 112 bool haveResultMetadata; 113 // Decremented by calls to process_capture_result with valid output 114 // and input buffers 115 int numBuffersLeft; 116 117 // The inflight request is considered complete if all buffers are returned 118 119 CaptureResultExtras resultExtras; 120 // If this request has any input buffer 121 bool hasInputBuffer; 122 123 // The last metadata that framework receives from HAL and 124 // not yet send out because the shutter event hasn't arrived. 125 // It's added by process_capture_result and sent when framework 126 // receives the shutter event. 127 CameraMetadata pendingMetadata; 128 129 // The metadata of the partial results that framework receives from HAL so far 130 // and has sent out. 131 CameraMetadata collectedPartialResult; 132 133 // Buffers are added by process_capture_result when output buffers 134 // return from HAL but framework has not yet received the shutter 135 // event. They will be returned to the streams when framework receives 136 // the shutter event. 137 Vector<camera_stream_buffer_t> pendingOutputBuffers; 138 139 // Whether this inflight request's shutter and result callback are to be 140 // called. The policy is that if the request is the last one in the constrained 141 // high speed recording request list, this flag will be true. If the request list 142 // is not for constrained high speed recording, this flag will also be true. 143 bool hasCallback; 144 145 // Minimum expected frame duration for this request 146 // For manual captures, equal to the max of requested exposure time and frame duration 147 // For auto-exposure modes, equal to 1/(higher end of target FPS range) 148 nsecs_t minExpectedDuration; 149 150 // Maximum expected frame duration for this request. 151 // For manual captures, equal to the max of requested exposure time and frame duration 152 // For auto-exposure modes, equal to 1/(lower end of target FPS range) 153 nsecs_t maxExpectedDuration; 154 155 // Whether the FPS range is fixed, aka, minFps == maxFps 156 bool isFixedFps; 157 158 // Whether the result metadata for this request is to be skipped. The 159 // result metadata should be skipped in the case of 160 // REQUEST/RESULT error. 161 bool skipResultMetadata; 162 163 // Whether the buffers with STATUS_ERROR should be cached as pending buffers, 164 // returned to the buffer queue, or returned to the buffer queue and notify with ERROR_BUFFER. 165 ERROR_BUF_STRATEGY errorBufStrategy; 166 167 // The physical camera ids being requested. 168 // For request on a physical camera stream, the inside set contains one Id 169 // For request on a stream group containing physical camera streams, the 170 // inside set contains all stream Ids in the group. 171 std::set<std::set<String8>> physicalCameraIds; 172 173 // Map of physicalCameraId <-> Metadata 174 std::vector<PhysicalCaptureResultInfo> physicalMetadatas; 175 176 // Indicates a still capture request. 177 bool stillCapture; 178 179 // Indicates a ZSL capture request 180 bool zslCapture; 181 182 // Indicates that ROTATE_AND_CROP was set to AUTO 183 bool rotateAndCropAuto; 184 185 // Requested camera ids (both logical and physical) with zoomRatio != 1.0f 186 std::set<std::string> cameraIdsWithZoom; 187 188 // Time of capture request (from systemTime) in Ns 189 nsecs_t requestTimeNs; 190 191 // What shared surfaces an output should go to 192 SurfaceMap outputSurfaces; 193 194 // Current output transformation 195 int32_t transform; 196 197 static const nsecs_t kDefaultMinExpectedDuration = 33333333; // 33 ms 198 static const nsecs_t kDefaultMaxExpectedDuration = 100000000; // 100 ms 199 200 // Default constructor needed by KeyedVector InFlightRequestInFlightRequest201 InFlightRequest() : 202 shutterTimestamp(0), 203 sensorTimestamp(0), 204 requestStatus(OK), 205 haveResultMetadata(false), 206 numBuffersLeft(0), 207 hasInputBuffer(false), 208 hasCallback(true), 209 minExpectedDuration(kDefaultMinExpectedDuration), 210 maxExpectedDuration(kDefaultMaxExpectedDuration), 211 isFixedFps(false), 212 skipResultMetadata(false), 213 errorBufStrategy(ERROR_BUF_CACHE), 214 stillCapture(false), 215 zslCapture(false), 216 rotateAndCropAuto(false), 217 requestTimeNs(0), 218 transform(-1) { 219 } 220 221 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput, 222 bool hasAppCallback, nsecs_t minDuration, nsecs_t maxDuration, bool fixedFps, 223 const std::set<std::set<String8>>& physicalCameraIdSet, bool isStillCapture, 224 bool isZslCapture, bool rotateAndCropAuto, const std::set<std::string>& idsWithZoom, 225 nsecs_t requestNs, const SurfaceMap& outSurfaces = SurfaceMap{}) : 226 shutterTimestamp(0), 227 sensorTimestamp(0), 228 requestStatus(OK), 229 haveResultMetadata(false), 230 numBuffersLeft(numBuffers), 231 resultExtras(extras), 232 hasInputBuffer(hasInput), 233 hasCallback(hasAppCallback), 234 minExpectedDuration(minDuration), 235 maxExpectedDuration(maxDuration), 236 isFixedFps(fixedFps), 237 skipResultMetadata(false), 238 errorBufStrategy(ERROR_BUF_CACHE), 239 physicalCameraIds(physicalCameraIdSet), 240 stillCapture(isStillCapture), 241 zslCapture(isZslCapture), 242 rotateAndCropAuto(rotateAndCropAuto), 243 cameraIdsWithZoom(idsWithZoom), 244 requestTimeNs(requestNs), 245 outputSurfaces(outSurfaces), 246 transform(-1) { 247 } 248 }; 249 250 // Map from frame number to the in-flight request state 251 typedef KeyedVector<uint32_t, InFlightRequest> InFlightRequestMap; 252 253 } // namespace camera3 254 255 } // namespace android 256 257 #endif 258