blob: f6f053926bdc67e91c5897dd0eb847ebea82d58d [file] [log] [blame]
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001/*
2 * Copyright (C) 2020 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 */
Austin Borgerea931242021-12-13 23:10:41 +000016
Shuzhen Wangd4abdf72021-05-28 11:22:50 -070017#include <cutils/properties.h>
18
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -080019#include "SessionConfigurationUtils.h"
Colin Crossb8a9dbb2020-08-27 04:12:26 +000020#include "../api2/DepthCompositeStream.h"
21#include "../api2/HeicCompositeStream.h"
22#include "common/CameraDeviceBase.h"
23#include "../CameraService.h"
24#include "device3/Camera3Device.h"
25#include "device3/Camera3OutputStream.h"
26
Colin Crossb8a9dbb2020-08-27 04:12:26 +000027using android::camera3::OutputStreamInfo;
28using android::camera3::OutputStreamInfo;
29using android::hardware::camera2::ICameraDeviceUser;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -080030using android::hardware::camera::metadata::V3_6::CameraMetadataEnumAndroidSensorPixelMode;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -080031
32namespace android {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -080033namespace camera3 {
34
35void StreamConfiguration::getStreamConfigurations(
36 const CameraMetadata &staticInfo, int configuration,
37 std::unordered_map<int, std::vector<StreamConfiguration>> *scm) {
38 if (scm == nullptr) {
39 ALOGE("%s: StreamConfigurationMap nullptr", __FUNCTION__);
40 return;
41 }
42 const int STREAM_FORMAT_OFFSET = 0;
43 const int STREAM_WIDTH_OFFSET = 1;
44 const int STREAM_HEIGHT_OFFSET = 2;
45 const int STREAM_IS_INPUT_OFFSET = 3;
46
47 camera_metadata_ro_entry availableStreamConfigs = staticInfo.find(configuration);
48 for (size_t i = 0; i < availableStreamConfigs.count; i += 4) {
49 int32_t format = availableStreamConfigs.data.i32[i + STREAM_FORMAT_OFFSET];
50 int32_t width = availableStreamConfigs.data.i32[i + STREAM_WIDTH_OFFSET];
51 int32_t height = availableStreamConfigs.data.i32[i + STREAM_HEIGHT_OFFSET];
52 int32_t isInput = availableStreamConfigs.data.i32[i + STREAM_IS_INPUT_OFFSET];
53 StreamConfiguration sc = {format, width, height, isInput};
54 (*scm)[format].push_back(sc);
55 }
56}
57
58void StreamConfiguration::getStreamConfigurations(
59 const CameraMetadata &staticInfo, bool maxRes,
60 std::unordered_map<int, std::vector<StreamConfiguration>> *scm) {
61 int32_t scalerKey =
62 SessionConfigurationUtils::getAppropriateModeTag(
63 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxRes);
64
65 int32_t depthKey =
66 SessionConfigurationUtils::getAppropriateModeTag(
67 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, maxRes);
68
69 int32_t dynamicDepthKey =
70 SessionConfigurationUtils::getAppropriateModeTag(
71 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS);
72
73 int32_t heicKey =
74 SessionConfigurationUtils::getAppropriateModeTag(
75 ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS);
76
77 getStreamConfigurations(staticInfo, scalerKey, scm);
78 getStreamConfigurations(staticInfo, depthKey, scm);
79 getStreamConfigurations(staticInfo, dynamicDepthKey, scm);
80 getStreamConfigurations(staticInfo, heicKey, scm);
81}
82
Austin Borgerea931242021-12-13 23:10:41 +000083namespace SessionConfigurationUtils {
84
85int32_t PERF_CLASS_LEVEL =
86 property_get_int32("ro.odm.build.media_performance_class", 0);
87
88bool IS_PERF_CLASS = (PERF_CLASS_LEVEL == SDK_VERSION_S);
89
90camera3::Size getMaxJpegResolution(const CameraMetadata &metadata,
91 bool ultraHighResolution) {
92 int32_t maxJpegWidth = 0, maxJpegHeight = 0;
93 const int STREAM_CONFIGURATION_SIZE = 4;
94 const int STREAM_FORMAT_OFFSET = 0;
95 const int STREAM_WIDTH_OFFSET = 1;
96 const int STREAM_HEIGHT_OFFSET = 2;
97 const int STREAM_IS_INPUT_OFFSET = 3;
98
99 int32_t scalerSizesTag = ultraHighResolution ?
100 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_MAXIMUM_RESOLUTION :
101 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS;
102 camera_metadata_ro_entry_t availableStreamConfigs =
103 metadata.find(scalerSizesTag);
104 if (availableStreamConfigs.count == 0 ||
105 availableStreamConfigs.count % STREAM_CONFIGURATION_SIZE != 0) {
106 return camera3::Size(0, 0);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800107 }
Austin Borgerea931242021-12-13 23:10:41 +0000108
109 // Get max jpeg size (area-wise).
110 for (size_t i= 0; i < availableStreamConfigs.count; i+= STREAM_CONFIGURATION_SIZE) {
111 int32_t format = availableStreamConfigs.data.i32[i + STREAM_FORMAT_OFFSET];
112 int32_t width = availableStreamConfigs.data.i32[i + STREAM_WIDTH_OFFSET];
113 int32_t height = availableStreamConfigs.data.i32[i + STREAM_HEIGHT_OFFSET];
114 int32_t isInput = availableStreamConfigs.data.i32[i + STREAM_IS_INPUT_OFFSET];
115 if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT
116 && format == HAL_PIXEL_FORMAT_BLOB &&
117 (width * height > maxJpegWidth * maxJpegHeight)) {
118 maxJpegWidth = width;
119 maxJpegHeight = height;
120 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800121 }
Austin Borgerea931242021-12-13 23:10:41 +0000122
123 return camera3::Size(maxJpegWidth, maxJpegHeight);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800124}
125
Austin Borgerea931242021-12-13 23:10:41 +0000126size_t getUHRMaxJpegBufferSize(camera3::Size uhrMaxJpegSize,
127 camera3::Size defaultMaxJpegSize, size_t defaultMaxJpegBufferSize) {
128 return (uhrMaxJpegSize.width * uhrMaxJpegSize.height) /
129 (defaultMaxJpegSize.width * defaultMaxJpegSize.height) * defaultMaxJpegBufferSize;
130}
131
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800132StreamConfigurationPair
Austin Borgerea931242021-12-13 23:10:41 +0000133getStreamConfigurationPair(const CameraMetadata &staticInfo) {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800134 camera3::StreamConfigurationPair streamConfigurationPair;
135 camera3::StreamConfiguration::getStreamConfigurations(staticInfo, false,
136 &streamConfigurationPair.mDefaultStreamConfigurationMap);
137 camera3::StreamConfiguration::getStreamConfigurations(staticInfo, true,
138 &streamConfigurationPair.mMaximumResolutionStreamConfigurationMap);
139 return streamConfigurationPair;
140}
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800141
Austin Borgerea931242021-12-13 23:10:41 +0000142int64_t euclidDistSquare(int32_t x0, int32_t y0, int32_t x1, int32_t y1) {
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000143 int64_t d0 = x0 - x1;
144 int64_t d1 = y0 - y1;
145 return d0 * d0 + d1 * d1;
146}
147
Austin Borgerea931242021-12-13 23:10:41 +0000148bool roundBufferDimensionNearest(int32_t width, int32_t height,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800149 int32_t format, android_dataspace dataSpace,
150 const CameraMetadata& info, bool maxResolution, /*out*/int32_t* outWidth,
151 /*out*/int32_t* outHeight) {
152 const int32_t depthSizesTag =
153 getAppropriateModeTag(ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS,
154 maxResolution);
155 const int32_t scalerSizesTag =
156 getAppropriateModeTag(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
157 const int32_t heicSizesTag =
158 getAppropriateModeTag(ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS, maxResolution);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000159
160 camera_metadata_ro_entry streamConfigs =
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800161 (dataSpace == HAL_DATASPACE_DEPTH) ? info.find(depthSizesTag) :
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000162 (dataSpace == static_cast<android_dataspace>(HAL_DATASPACE_HEIF)) ?
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800163 info.find(heicSizesTag) :
164 info.find(scalerSizesTag);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000165
166 int32_t bestWidth = -1;
167 int32_t bestHeight = -1;
168
169 // Iterate through listed stream configurations and find the one with the smallest euclidean
170 // distance from the given dimensions for the given format.
171 for (size_t i = 0; i < streamConfigs.count; i += 4) {
172 int32_t fmt = streamConfigs.data.i32[i];
173 int32_t w = streamConfigs.data.i32[i + 1];
174 int32_t h = streamConfigs.data.i32[i + 2];
175
176 // Ignore input/output type for now
177 if (fmt == format) {
178 if (w == width && h == height) {
179 bestWidth = width;
180 bestHeight = height;
181 break;
182 } else if (w <= ROUNDING_WIDTH_CAP && (bestWidth == -1 ||
183 SessionConfigurationUtils::euclidDistSquare(w, h, width, height) <
184 SessionConfigurationUtils::euclidDistSquare(bestWidth, bestHeight, width,
185 height))) {
186 bestWidth = w;
187 bestHeight = h;
188 }
189 }
190 }
191
192 if (bestWidth == -1) {
193 // Return false if no configurations for this format were listed
194 return false;
195 }
196
197 // Set the outputs to the closet width/height
198 if (outWidth != NULL) {
199 *outWidth = bestWidth;
200 }
201 if (outHeight != NULL) {
202 *outHeight = bestHeight;
203 }
204
205 // Return true if at least one configuration for this format was listed
206 return true;
207}
208
Austin Borgerea931242021-12-13 23:10:41 +0000209bool isPublicFormat(int32_t format)
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000210{
211 switch(format) {
212 case HAL_PIXEL_FORMAT_RGBA_8888:
213 case HAL_PIXEL_FORMAT_RGBX_8888:
214 case HAL_PIXEL_FORMAT_RGB_888:
215 case HAL_PIXEL_FORMAT_RGB_565:
216 case HAL_PIXEL_FORMAT_BGRA_8888:
217 case HAL_PIXEL_FORMAT_YV12:
218 case HAL_PIXEL_FORMAT_Y8:
219 case HAL_PIXEL_FORMAT_Y16:
220 case HAL_PIXEL_FORMAT_RAW16:
221 case HAL_PIXEL_FORMAT_RAW10:
222 case HAL_PIXEL_FORMAT_RAW12:
223 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
224 case HAL_PIXEL_FORMAT_BLOB:
225 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
226 case HAL_PIXEL_FORMAT_YCbCr_420_888:
227 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
228 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
229 case HAL_PIXEL_FORMAT_YCbCr_422_I:
230 return true;
231 default:
232 return false;
233 }
234}
235
Austin Borgerea931242021-12-13 23:10:41 +0000236binder::Status createSurfaceFromGbp(
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000237 OutputStreamInfo& streamInfo, bool isStreamInfoValid,
238 sp<Surface>& surface, const sp<IGraphicBufferProducer>& gbp,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800239 const String8 &logicalCameraId, const CameraMetadata &physicalCameraMetadata,
240 const std::vector<int32_t> &sensorPixelModesUsed){
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000241 // bufferProducer must be non-null
242 if (gbp == nullptr) {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800243 String8 msg = String8::format("Camera %s: Surface is NULL", logicalCameraId.string());
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000244 ALOGW("%s: %s", __FUNCTION__, msg.string());
245 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
246 }
247 // HACK b/10949105
248 // Query consumer usage bits to set async operation mode for
249 // GLConsumer using controlledByApp parameter.
250 bool useAsync = false;
251 uint64_t consumerUsage = 0;
252 status_t err;
253 if ((err = gbp->getConsumerUsage(&consumerUsage)) != OK) {
254 String8 msg = String8::format("Camera %s: Failed to query Surface consumer usage: %s (%d)",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800255 logicalCameraId.string(), strerror(-err), err);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000256 ALOGE("%s: %s", __FUNCTION__, msg.string());
257 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
258 }
259 if (consumerUsage & GraphicBuffer::USAGE_HW_TEXTURE) {
260 ALOGW("%s: Camera %s with consumer usage flag: %" PRIu64 ": Forcing asynchronous mode for"
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800261 "stream", __FUNCTION__, logicalCameraId.string(), consumerUsage);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000262 useAsync = true;
263 }
264
265 uint64_t disallowedFlags = GraphicBuffer::USAGE_HW_VIDEO_ENCODER |
266 GRALLOC_USAGE_RENDERSCRIPT;
267 uint64_t allowedFlags = GraphicBuffer::USAGE_SW_READ_MASK |
268 GraphicBuffer::USAGE_HW_TEXTURE |
269 GraphicBuffer::USAGE_HW_COMPOSER;
270 bool flexibleConsumer = (consumerUsage & disallowedFlags) == 0 &&
271 (consumerUsage & allowedFlags) != 0;
272
273 surface = new Surface(gbp, useAsync);
274 ANativeWindow *anw = surface.get();
275
276 int width, height, format;
277 android_dataspace dataSpace;
278 if ((err = anw->query(anw, NATIVE_WINDOW_WIDTH, &width)) != OK) {
279 String8 msg = String8::format("Camera %s: Failed to query Surface width: %s (%d)",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800280 logicalCameraId.string(), strerror(-err), err);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000281 ALOGE("%s: %s", __FUNCTION__, msg.string());
282 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
283 }
284 if ((err = anw->query(anw, NATIVE_WINDOW_HEIGHT, &height)) != OK) {
285 String8 msg = String8::format("Camera %s: Failed to query Surface height: %s (%d)",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800286 logicalCameraId.string(), strerror(-err), err);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000287 ALOGE("%s: %s", __FUNCTION__, msg.string());
288 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
289 }
290 if ((err = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) {
291 String8 msg = String8::format("Camera %s: Failed to query Surface format: %s (%d)",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800292 logicalCameraId.string(), strerror(-err), err);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000293 ALOGE("%s: %s", __FUNCTION__, msg.string());
294 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
295 }
296 if ((err = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE,
297 reinterpret_cast<int*>(&dataSpace))) != OK) {
298 String8 msg = String8::format("Camera %s: Failed to query Surface dataspace: %s (%d)",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800299 logicalCameraId.string(), strerror(-err), err);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000300 ALOGE("%s: %s", __FUNCTION__, msg.string());
301 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
302 }
303
304 // FIXME: remove this override since the default format should be
305 // IMPLEMENTATION_DEFINED. b/9487482 & b/35317944
306 if ((format >= HAL_PIXEL_FORMAT_RGBA_8888 && format <= HAL_PIXEL_FORMAT_BGRA_8888) &&
307 ((consumerUsage & GRALLOC_USAGE_HW_MASK) &&
308 ((consumerUsage & GRALLOC_USAGE_SW_READ_MASK) == 0))) {
309 ALOGW("%s: Camera %s: Overriding format %#x to IMPLEMENTATION_DEFINED",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800310 __FUNCTION__, logicalCameraId.string(), format);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000311 format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
312 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800313 std::unordered_set<int32_t> overriddenSensorPixelModes;
314 if (checkAndOverrideSensorPixelModesUsed(sensorPixelModesUsed, format, width, height,
315 physicalCameraMetadata, flexibleConsumer, &overriddenSensorPixelModes) != OK) {
316 String8 msg = String8::format("Camera %s: sensor pixel modes for stream with "
317 "format %#x are not valid",logicalCameraId.string(), format);
318 ALOGE("%s: %s", __FUNCTION__, msg.string());
319 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
320 }
321 bool foundInMaxRes = false;
322 if (overriddenSensorPixelModes.find(ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION) !=
323 overriddenSensorPixelModes.end()) {
324 // we can use the default stream configuration map
325 foundInMaxRes = true;
326 }
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000327 // Round dimensions to the nearest dimensions available for this format
328 if (flexibleConsumer && isPublicFormat(format) &&
329 !SessionConfigurationUtils::roundBufferDimensionNearest(width, height,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800330 format, dataSpace, physicalCameraMetadata, foundInMaxRes, /*out*/&width,
331 /*out*/&height)) {
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000332 String8 msg = String8::format("Camera %s: No supported stream configurations with "
333 "format %#x defined, failed to create output stream",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800334 logicalCameraId.string(), format);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000335 ALOGE("%s: %s", __FUNCTION__, msg.string());
336 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
337 }
338
339 if (!isStreamInfoValid) {
340 streamInfo.width = width;
341 streamInfo.height = height;
342 streamInfo.format = format;
343 streamInfo.dataSpace = dataSpace;
344 streamInfo.consumerUsage = consumerUsage;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800345 streamInfo.sensorPixelModesUsed = overriddenSensorPixelModes;
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000346 return binder::Status::ok();
347 }
348 if (width != streamInfo.width) {
349 String8 msg = String8::format("Camera %s:Surface width doesn't match: %d vs %d",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800350 logicalCameraId.string(), width, streamInfo.width);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000351 ALOGE("%s: %s", __FUNCTION__, msg.string());
352 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
353 }
354 if (height != streamInfo.height) {
355 String8 msg = String8::format("Camera %s:Surface height doesn't match: %d vs %d",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800356 logicalCameraId.string(), height, streamInfo.height);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000357 ALOGE("%s: %s", __FUNCTION__, msg.string());
358 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
359 }
360 if (format != streamInfo.format) {
361 String8 msg = String8::format("Camera %s:Surface format doesn't match: %d vs %d",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800362 logicalCameraId.string(), format, streamInfo.format);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000363 ALOGE("%s: %s", __FUNCTION__, msg.string());
364 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
365 }
366 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
367 if (dataSpace != streamInfo.dataSpace) {
368 String8 msg = String8::format("Camera %s:Surface dataSpace doesn't match: %d vs %d",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800369 logicalCameraId.string(), dataSpace, streamInfo.dataSpace);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000370 ALOGE("%s: %s", __FUNCTION__, msg.string());
371 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
372 }
373 //At the native side, there isn't a way to check whether 2 surfaces come from the same
374 //surface class type. Use usage flag to approximate the comparison.
375 if (consumerUsage != streamInfo.consumerUsage) {
376 String8 msg = String8::format(
377 "Camera %s:Surface usage flag doesn't match %" PRIu64 " vs %" PRIu64 "",
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800378 logicalCameraId.string(), consumerUsage, streamInfo.consumerUsage);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000379 ALOGE("%s: %s", __FUNCTION__, msg.string());
380 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
381 }
382 }
383 return binder::Status::ok();
384}
385
Austin Borgerea931242021-12-13 23:10:41 +0000386void mapStreamInfo(const OutputStreamInfo &streamInfo,
Emilian Peevf4816702020-04-03 15:44:51 -0700387 camera3::camera_stream_rotation_t rotation, String8 physicalId,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800388 int32_t groupId, hardware::camera::device::V3_7::Stream *stream /*out*/) {
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000389 if (stream == nullptr) {
390 return;
391 }
392
Shuzhen Wang83bff122020-11-20 15:51:39 -0800393 stream->v3_4.v3_2.streamType = hardware::camera::device::V3_2::StreamType::OUTPUT;
394 stream->v3_4.v3_2.width = streamInfo.width;
395 stream->v3_4.v3_2.height = streamInfo.height;
396 stream->v3_4.v3_2.format = Camera3Device::mapToPixelFormat(streamInfo.format);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000397 auto u = streamInfo.consumerUsage;
398 camera3::Camera3OutputStream::applyZSLUsageQuirk(streamInfo.format, &u);
Shuzhen Wang83bff122020-11-20 15:51:39 -0800399 stream->v3_4.v3_2.usage = Camera3Device::mapToConsumerUsage(u);
400 stream->v3_4.v3_2.dataSpace = Camera3Device::mapToHidlDataspace(streamInfo.dataSpace);
401 stream->v3_4.v3_2.rotation = Camera3Device::mapToStreamRotation(rotation);
402 stream->v3_4.v3_2.id = -1; // Invalid stream id
403 stream->v3_4.physicalCameraId = std::string(physicalId.string());
404 stream->v3_4.bufferSize = 0;
405 stream->groupId = groupId;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800406 stream->sensorPixelModesUsed.resize(streamInfo.sensorPixelModesUsed.size());
407 size_t idx = 0;
408 for (auto mode : streamInfo.sensorPixelModesUsed) {
409 stream->sensorPixelModesUsed[idx++] =
410 static_cast<CameraMetadataEnumAndroidSensorPixelMode>(mode);
411 }
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000412}
413
Austin Borgerea931242021-12-13 23:10:41 +0000414binder::Status checkPhysicalCameraId(
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000415 const std::vector<std::string> &physicalCameraIds, const String8 &physicalCameraId,
416 const String8 &logicalCameraId) {
417 if (physicalCameraId.size() == 0) {
418 return binder::Status::ok();
419 }
420 if (std::find(physicalCameraIds.begin(), physicalCameraIds.end(),
421 physicalCameraId.string()) == physicalCameraIds.end()) {
422 String8 msg = String8::format("Camera %s: Camera doesn't support physicalCameraId %s.",
423 logicalCameraId.string(), physicalCameraId.string());
424 ALOGE("%s: %s", __FUNCTION__, msg.string());
425 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
426 }
427 return binder::Status::ok();
428}
429
Austin Borgerea931242021-12-13 23:10:41 +0000430binder::Status checkSurfaceType(size_t numBufferProducers,
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000431 bool deferredConsumer, int surfaceType) {
432 if (numBufferProducers > MAX_SURFACES_PER_STREAM) {
433 ALOGE("%s: GraphicBufferProducer count %zu for stream exceeds limit of %d",
434 __FUNCTION__, numBufferProducers, MAX_SURFACES_PER_STREAM);
435 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Surface count is too high");
436 } else if ((numBufferProducers == 0) && (!deferredConsumer)) {
437 ALOGE("%s: Number of consumers cannot be smaller than 1", __FUNCTION__);
438 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "No valid consumers.");
439 }
440
441 bool validSurfaceType = ((surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW) ||
442 (surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_TEXTURE));
443
444 if (deferredConsumer && !validSurfaceType) {
445 ALOGE("%s: Target surface has invalid surfaceType = %d.", __FUNCTION__, surfaceType);
446 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Target Surface is invalid");
447 }
448
449 return binder::Status::ok();
450}
451
Austin Borgerea931242021-12-13 23:10:41 +0000452binder::Status checkOperatingMode(int operatingMode,
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000453 const CameraMetadata &staticInfo, const String8 &cameraId) {
454 if (operatingMode < 0) {
455 String8 msg = String8::format(
456 "Camera %s: Invalid operating mode %d requested", cameraId.string(), operatingMode);
457 ALOGE("%s: %s", __FUNCTION__, msg.string());
458 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
459 msg.string());
460 }
461
462 bool isConstrainedHighSpeed = (operatingMode == ICameraDeviceUser::CONSTRAINED_HIGH_SPEED_MODE);
463 if (isConstrainedHighSpeed) {
464 camera_metadata_ro_entry_t entry = staticInfo.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
465 bool isConstrainedHighSpeedSupported = false;
466 for(size_t i = 0; i < entry.count; ++i) {
467 uint8_t capability = entry.data.u8[i];
468 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO) {
469 isConstrainedHighSpeedSupported = true;
470 break;
471 }
472 }
473 if (!isConstrainedHighSpeedSupported) {
474 String8 msg = String8::format(
475 "Camera %s: Try to create a constrained high speed configuration on a device"
476 " that doesn't support it.", cameraId.string());
477 ALOGE("%s: %s", __FUNCTION__, msg.string());
478 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
479 msg.string());
480 }
481 }
482
483 return binder::Status::ok();
484}
485
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800486binder::Status
Austin Borgerea931242021-12-13 23:10:41 +0000487convertToHALStreamCombination(
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800488 const SessionConfiguration& sessionConfiguration,
489 const String8 &logicalCameraId, const CameraMetadata &deviceInfo,
490 metadataGetter getMetadata, const std::vector<std::string> &physicalCameraIds,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700491 hardware::camera::device::V3_7::StreamConfiguration &streamConfiguration,
492 bool overrideForPerfClass, bool *earlyExit) {
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000493
494 auto operatingMode = sessionConfiguration.getOperatingMode();
495 binder::Status res = checkOperatingMode(operatingMode, deviceInfo, logicalCameraId);
496 if (!res.isOk()) {
497 return res;
498 }
499
500 if (earlyExit == nullptr) {
501 String8 msg("earlyExit nullptr");
502 ALOGE("%s: %s", __FUNCTION__, msg.string());
503 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
504 }
505 *earlyExit = false;
506 auto ret = Camera3Device::mapToStreamConfigurationMode(
Emilian Peevf4816702020-04-03 15:44:51 -0700507 static_cast<camera_stream_configuration_mode_t> (operatingMode),
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000508 /*out*/ &streamConfiguration.operationMode);
509 if (ret != OK) {
510 String8 msg = String8::format(
511 "Camera %s: Failed mapping operating mode %d requested: %s (%d)",
512 logicalCameraId.string(), operatingMode, strerror(-ret), ret);
513 ALOGE("%s: %s", __FUNCTION__, msg.string());
514 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
515 msg.string());
516 }
517
518 bool isInputValid = (sessionConfiguration.getInputWidth() > 0) &&
519 (sessionConfiguration.getInputHeight() > 0) &&
520 (sessionConfiguration.getInputFormat() > 0);
521 auto outputConfigs = sessionConfiguration.getOutputConfigurations();
522 size_t streamCount = outputConfigs.size();
523 streamCount = isInputValid ? streamCount + 1 : streamCount;
524 streamConfiguration.streams.resize(streamCount);
525 size_t streamIdx = 0;
526 if (isInputValid) {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800527 hardware::hidl_vec<CameraMetadataEnumAndroidSensorPixelMode> defaultSensorPixelModes;
528 defaultSensorPixelModes.resize(1);
529 defaultSensorPixelModes[0] =
530 static_cast<CameraMetadataEnumAndroidSensorPixelMode>(
531 ANDROID_SENSOR_PIXEL_MODE_DEFAULT);
Shuzhen Wang83bff122020-11-20 15:51:39 -0800532 streamConfiguration.streams[streamIdx++] = {{{/*streamId*/0,
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000533 hardware::camera::device::V3_2::StreamType::INPUT,
534 static_cast<uint32_t> (sessionConfiguration.getInputWidth()),
535 static_cast<uint32_t> (sessionConfiguration.getInputHeight()),
536 Camera3Device::mapToPixelFormat(sessionConfiguration.getInputFormat()),
537 /*usage*/ 0, HAL_DATASPACE_UNKNOWN,
538 hardware::camera::device::V3_2::StreamRotation::ROTATION_0},
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800539 /*physicalId*/ nullptr, /*bufferSize*/0}, /*groupId*/-1, defaultSensorPixelModes};
Shuzhen Wang83bff122020-11-20 15:51:39 -0800540 streamConfiguration.multiResolutionInputImage =
541 sessionConfiguration.inputIsMultiResolution();
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000542 }
543
544 for (const auto &it : outputConfigs) {
545 const std::vector<sp<IGraphicBufferProducer>>& bufferProducers =
546 it.getGraphicBufferProducers();
547 bool deferredConsumer = it.isDeferred();
548 String8 physicalCameraId = String8(it.getPhysicalCameraId());
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800549
550 std::vector<int32_t> sensorPixelModesUsed = it.getSensorPixelModesUsed();
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700551 const CameraMetadata &physicalDeviceInfo = getMetadata(physicalCameraId,
552 overrideForPerfClass);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800553 const CameraMetadata &metadataChosen =
554 physicalCameraId.size() > 0 ? physicalDeviceInfo : deviceInfo;
555
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000556 size_t numBufferProducers = bufferProducers.size();
557 bool isStreamInfoValid = false;
Shuzhen Wang83bff122020-11-20 15:51:39 -0800558 int32_t groupId = it.isMultiResolution() ? it.getSurfaceSetID() : -1;
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000559 OutputStreamInfo streamInfo;
560
561 res = checkSurfaceType(numBufferProducers, deferredConsumer, it.getSurfaceType());
562 if (!res.isOk()) {
563 return res;
564 }
565 res = checkPhysicalCameraId(physicalCameraIds, physicalCameraId,
566 logicalCameraId);
567 if (!res.isOk()) {
568 return res;
569 }
570
571 if (deferredConsumer) {
572 streamInfo.width = it.getWidth();
573 streamInfo.height = it.getHeight();
574 streamInfo.format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
575 streamInfo.dataSpace = android_dataspace_t::HAL_DATASPACE_UNKNOWN;
576 auto surfaceType = it.getSurfaceType();
577 streamInfo.consumerUsage = GraphicBuffer::USAGE_HW_TEXTURE;
578 if (surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW) {
579 streamInfo.consumerUsage |= GraphicBuffer::USAGE_HW_COMPOSER;
580 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800581 if (checkAndOverrideSensorPixelModesUsed(sensorPixelModesUsed,
582 streamInfo.format, streamInfo.width,
583 streamInfo.height, metadataChosen, false /*flexibleConsumer*/,
584 &streamInfo.sensorPixelModesUsed) != OK) {
585 ALOGE("%s: Deferred surface sensor pixel modes not valid",
586 __FUNCTION__);
587 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
588 "Deferred surface sensor pixel modes not valid");
589 }
Shuzhen Wang83bff122020-11-20 15:51:39 -0800590 mapStreamInfo(streamInfo, camera3::CAMERA_STREAM_ROTATION_0, physicalCameraId, groupId,
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000591 &streamConfiguration.streams[streamIdx++]);
592 isStreamInfoValid = true;
593
594 if (numBufferProducers == 0) {
595 continue;
596 }
597 }
598
599 for (auto& bufferProducer : bufferProducers) {
600 sp<Surface> surface;
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000601 res = createSurfaceFromGbp(streamInfo, isStreamInfoValid, surface, bufferProducer,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800602 logicalCameraId, metadataChosen, sensorPixelModesUsed);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000603
604 if (!res.isOk())
605 return res;
606
607 if (!isStreamInfoValid) {
608 bool isDepthCompositeStream =
609 camera3::DepthCompositeStream::isDepthCompositeStream(surface);
610 bool isHeicCompositeStream =
611 camera3::HeicCompositeStream::isHeicCompositeStream(surface);
612 if (isDepthCompositeStream || isHeicCompositeStream) {
613 // We need to take in to account that composite streams can have
614 // additional internal camera streams.
615 std::vector<OutputStreamInfo> compositeStreams;
616 if (isDepthCompositeStream) {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800617 // TODO: Take care of composite streams.
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000618 ret = camera3::DepthCompositeStream::getCompositeStreamInfo(streamInfo,
619 deviceInfo, &compositeStreams);
620 } else {
621 ret = camera3::HeicCompositeStream::getCompositeStreamInfo(streamInfo,
622 deviceInfo, &compositeStreams);
623 }
624 if (ret != OK) {
625 String8 msg = String8::format(
626 "Camera %s: Failed adding composite streams: %s (%d)",
627 logicalCameraId.string(), strerror(-ret), ret);
628 ALOGE("%s: %s", __FUNCTION__, msg.string());
629 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
630 }
631
632 if (compositeStreams.size() == 0) {
633 // No internal streams means composite stream not
634 // supported.
635 *earlyExit = true;
636 return binder::Status::ok();
637 } else if (compositeStreams.size() > 1) {
638 streamCount += compositeStreams.size() - 1;
639 streamConfiguration.streams.resize(streamCount);
640 }
641
642 for (const auto& compositeStream : compositeStreams) {
643 mapStreamInfo(compositeStream,
Emilian Peevf4816702020-04-03 15:44:51 -0700644 static_cast<camera_stream_rotation_t> (it.getRotation()),
Shuzhen Wang83bff122020-11-20 15:51:39 -0800645 physicalCameraId, groupId,
646 &streamConfiguration.streams[streamIdx++]);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000647 }
648 } else {
649 mapStreamInfo(streamInfo,
Emilian Peevf4816702020-04-03 15:44:51 -0700650 static_cast<camera_stream_rotation_t> (it.getRotation()),
Shuzhen Wang83bff122020-11-20 15:51:39 -0800651 physicalCameraId, groupId, &streamConfiguration.streams[streamIdx++]);
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000652 }
653 isStreamInfoValid = true;
654 }
655 }
656 }
657 return binder::Status::ok();
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800658}
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000659
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800660static bool inStreamConfigurationMap(int format, int width, int height,
661 const std::unordered_map<int, std::vector<camera3::StreamConfiguration>> &sm) {
662 auto scs = sm.find(format);
663 if (scs == sm.end()) {
664 return false;
665 }
666 for (auto &sc : scs->second) {
667 if (sc.width == width && sc.height == height && sc.isInput == 0) {
668 return true;
669 }
670 }
671 return false;
672}
673
674static std::unordered_set<int32_t> convertToSet(const std::vector<int32_t> &sensorPixelModesUsed) {
675 return std::unordered_set<int32_t>(sensorPixelModesUsed.begin(), sensorPixelModesUsed.end());
676}
677
Austin Borgerea931242021-12-13 23:10:41 +0000678status_t checkAndOverrideSensorPixelModesUsed(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800679 const std::vector<int32_t> &sensorPixelModesUsed, int format, int width, int height,
680 const CameraMetadata &staticInfo, bool flexibleConsumer,
681 std::unordered_set<int32_t> *overriddenSensorPixelModesUsed) {
Jayant Chowdhary84df28c2021-05-26 22:32:21 -0700682
683 const std::unordered_set<int32_t> &sensorPixelModesUsedSet =
684 convertToSet(sensorPixelModesUsed);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800685 if (!isUltraHighResolutionSensor(staticInfo)) {
Jayant Chowdhary84df28c2021-05-26 22:32:21 -0700686 if (sensorPixelModesUsedSet.find(ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION) !=
687 sensorPixelModesUsedSet.end()) {
688 // invalid value for non ultra high res sensors
689 return BAD_VALUE;
690 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800691 overriddenSensorPixelModesUsed->clear();
692 overriddenSensorPixelModesUsed->insert(ANDROID_SENSOR_PIXEL_MODE_DEFAULT);
693 return OK;
694 }
695
696 StreamConfigurationPair streamConfigurationPair = getStreamConfigurationPair(staticInfo);
Jayant Chowdhary84df28c2021-05-26 22:32:21 -0700697
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800698 bool isInDefaultStreamConfigurationMap =
699 inStreamConfigurationMap(format, width, height,
700 streamConfigurationPair.mDefaultStreamConfigurationMap);
701
702 bool isInMaximumResolutionStreamConfigurationMap =
703 inStreamConfigurationMap(format, width, height,
704 streamConfigurationPair.mMaximumResolutionStreamConfigurationMap);
705
706 // Case 1: The client has not changed the sensor mode defaults. In this case, we check if the
707 // size + format of the OutputConfiguration is found exclusively in 1.
708 // If yes, add that sensorPixelMode to overriddenSensorPixelModes.
709 // If no, add 'DEFAULT' to sensorPixelMode. This maintains backwards
710 // compatibility.
711 if (sensorPixelModesUsedSet.size() == 0) {
712 // Ambiguous case, default to only 'DEFAULT' mode.
713 if (isInDefaultStreamConfigurationMap && isInMaximumResolutionStreamConfigurationMap) {
714 overriddenSensorPixelModesUsed->insert(ANDROID_SENSOR_PIXEL_MODE_DEFAULT);
715 return OK;
716 }
717 // We don't allow flexible consumer for max resolution mode.
718 if (isInMaximumResolutionStreamConfigurationMap) {
719 overriddenSensorPixelModesUsed->insert(ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION);
720 return OK;
721 }
722 if (isInDefaultStreamConfigurationMap || (flexibleConsumer && width < ROUNDING_WIDTH_CAP)) {
723 overriddenSensorPixelModesUsed->insert(ANDROID_SENSOR_PIXEL_MODE_DEFAULT);
724 return OK;
725 }
726 return BAD_VALUE;
727 }
728
729 // Case2: The app has set sensorPixelModesUsed, we need to verify that they
730 // are valid / err out.
731 if (sensorPixelModesUsedSet.find(ANDROID_SENSOR_PIXEL_MODE_DEFAULT) !=
732 sensorPixelModesUsedSet.end() && !isInDefaultStreamConfigurationMap) {
733 return BAD_VALUE;
734 }
735
736 if (sensorPixelModesUsedSet.find(ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION) !=
737 sensorPixelModesUsedSet.end() && !isInMaximumResolutionStreamConfigurationMap) {
738 return BAD_VALUE;
739 }
740 *overriddenSensorPixelModesUsed = sensorPixelModesUsedSet;
741 return OK;
742}
743
Austin Borgerea931242021-12-13 23:10:41 +0000744bool convertHALStreamCombinationFromV37ToV34(
Shuzhen Wang83bff122020-11-20 15:51:39 -0800745 hardware::camera::device::V3_4::StreamConfiguration &streamConfigV34,
746 const hardware::camera::device::V3_7::StreamConfiguration &streamConfigV37) {
747 if (streamConfigV37.multiResolutionInputImage) {
748 // ICameraDevice older than 3.7 doesn't support multi-resolution input image.
749 return false;
750 }
751
752 streamConfigV34.streams.resize(streamConfigV37.streams.size());
753 for (size_t i = 0; i < streamConfigV37.streams.size(); i++) {
754 if (streamConfigV37.streams[i].groupId != -1) {
755 // ICameraDevice older than 3.7 doesn't support multi-resolution output
756 // image
757 return false;
758 }
759 streamConfigV34.streams[i] = streamConfigV37.streams[i].v3_4;
760 }
761 streamConfigV34.operationMode = streamConfigV37.operationMode;
762 streamConfigV34.sessionParams = streamConfigV37.sessionParams;
763
764 return true;
765}
766
Austin Borgerea931242021-12-13 23:10:41 +0000767bool targetPerfClassPrimaryCamera(
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700768 const std::set<std::string>& perfClassPrimaryCameraIds, const std::string& cameraId,
769 int targetSdkVersion) {
770 bool isPerfClassPrimaryCamera =
771 perfClassPrimaryCameraIds.find(cameraId) != perfClassPrimaryCameraIds.end();
772 return targetSdkVersion >= SDK_VERSION_S && isPerfClassPrimaryCamera;
773}
774
Austin Borgerea931242021-12-13 23:10:41 +0000775} // namespace SessionConfigurationUtils
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800776} // namespace camera3
777} // namespace android