1 /*
2 * Copyright (C) 2012 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 #define LOG_TAG "Camera2Client"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 //#define LOG_NDEBUG 0
20
21 #include <sstream>
22
23 #include <inttypes.h>
24 #include <utils/Log.h>
25 #include <utils/Trace.h>
26
27 #include <android/hardware/camera2/ICameraDeviceCallbacks.h>
28 #include <camera/CameraUtils.h>
29 #include <camera/StringUtils.h>
30 #include <com_android_internal_camera_flags.h>
31 #include <com_android_window_flags.h>
32 #include <cutils/properties.h>
33 #include <gui/Surface.h>
34 #include <gui/view/Surface.h>
35
36 #include "api1/Camera2Client.h"
37
38 #include "api1/client2/StreamingProcessor.h"
39 #include "api1/client2/JpegProcessor.h"
40 #include "api1/client2/CaptureSequencer.h"
41 #include "api1/client2/CallbackProcessor.h"
42 #include "api1/client2/ZslProcessor.h"
43 #include "device3/RotateAndCropMapper.h"
44 #include "utils/CameraServiceProxyWrapper.h"
45
46 #define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
47 #define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
48
49 #ifndef FALLTHROUGH_INTENDED
50 #define FALLTHROUGH_INTENDED [[fallthrough]]
51 #endif
52
53 namespace android {
54 using namespace camera2;
55
56 namespace flags = com::android::internal::camera::flags;
57 namespace wm_flags = com::android::window::flags;
58
59 // Interface used by CameraService
60
Camera2Client(const sp<CameraService> & cameraService,const sp<hardware::ICameraClient> & cameraClient,std::shared_ptr<CameraServiceProxyWrapper> cameraServiceProxyWrapper,std::shared_ptr<AttributionAndPermissionUtils> attributionAndPermissionUtils,const AttributionSourceState & clientAttribution,int callingPid,const std::string & cameraDeviceId,int api1CameraId,int cameraFacing,int sensorOrientation,int servicePid,bool overrideForPerfClass,int rotationOverride,bool forceSlowJpegMode,bool sharedMode)61 Camera2Client::Camera2Client(
62 const sp<CameraService>& cameraService, const sp<hardware::ICameraClient>& cameraClient,
63 std::shared_ptr<CameraServiceProxyWrapper> cameraServiceProxyWrapper,
64 std::shared_ptr<AttributionAndPermissionUtils> attributionAndPermissionUtils,
65 const AttributionSourceState& clientAttribution, int callingPid,
66 const std::string& cameraDeviceId, int api1CameraId, int cameraFacing,
67 int sensorOrientation, int servicePid, bool overrideForPerfClass, int rotationOverride,
68 bool forceSlowJpegMode, bool sharedMode)
69 : Camera2ClientBase(cameraService, cameraClient, cameraServiceProxyWrapper,
70 attributionAndPermissionUtils, clientAttribution, callingPid,
71 false /*systemNativeClient - since no ndk for api1*/, cameraDeviceId,
72 api1CameraId, cameraFacing, sensorOrientation, servicePid,
73 overrideForPerfClass, rotationOverride, sharedMode,
74 /*legacyClient*/ true),
75 mParameters(api1CameraId, cameraFacing),
76 mInitialized(false),
77 mLatestRequestIds(kMaxRequestIds),
78 mLatestFailedRequestIds(kMaxRequestIds) {
79 ATRACE_CALL();
80
81 mRotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
82 mRotateAndCropIsSupported = false;
83 mRotateAndCropPreviewTransform = 0;
84
85 SharedParameters::Lock l(mParameters);
86 l.mParameters.state = Parameters::DISCONNECTED;
87 l.mParameters.isSlowJpegModeForced = forceSlowJpegMode;
88 }
89
initialize(sp<CameraProviderManager> manager,const std::string & monitorTags)90 status_t Camera2Client::initialize(sp<CameraProviderManager> manager,
91 const std::string& monitorTags) {
92 return initializeImpl(manager, monitorTags);
93 }
94
isZslEnabledInStillTemplate()95 bool Camera2Client::isZslEnabledInStillTemplate() {
96 bool zslEnabled = false;
97 CameraMetadata stillTemplate;
98 status_t res = mDevice->createDefaultRequest(
99 camera_request_template_t::CAMERA_TEMPLATE_STILL_CAPTURE, &stillTemplate);
100 if (res == OK) {
101 camera_metadata_entry_t enableZsl = stillTemplate.find(ANDROID_CONTROL_ENABLE_ZSL);
102 if (enableZsl.count == 1) {
103 zslEnabled = (enableZsl.data.u8[0] == ANDROID_CONTROL_ENABLE_ZSL_TRUE);
104 }
105 }
106
107 return zslEnabled;
108 }
109
110 template<typename TProviderPtr>
initializeImpl(TProviderPtr providerPtr,const std::string & monitorTags)111 status_t Camera2Client::initializeImpl(TProviderPtr providerPtr, const std::string& monitorTags)
112 {
113 ATRACE_CALL();
114 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
115 status_t res;
116
117 res = Camera2ClientBase::initialize(providerPtr, monitorTags);
118 if (res != OK) {
119 return res;
120 }
121
122 {
123 SharedParameters::Lock l(mParameters);
124
125 res = l.mParameters.initialize(mDevice.get());
126 if (res != OK) {
127 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
128 __FUNCTION__, mCameraId, strerror(-res), res);
129 return NO_INIT;
130 }
131
132 l.mParameters.isDeviceZslSupported = isZslEnabledInStillTemplate();
133 }
134
135 const CameraMetadata& staticInfo = mDevice->info();
136 mRotateAndCropIsSupported = camera3::RotateAndCropMapper::isNeeded(&staticInfo);
137 // The 'mRotateAndCropMode' value only accounts for the necessary adjustment
138 // when the display rotates. The sensor orientation still needs to be calculated
139 // and applied similar to the Camera2 path.
140 using hardware::BnCameraService::ROTATION_OVERRIDE_ROTATION_ONLY;
141 bool enableTransformInverseDisplay = true;
142 if (wm_flags::enable_camera_compat_for_desktop_windowing()) {
143 enableTransformInverseDisplay = (mRotationOverride != ROTATION_OVERRIDE_ROTATION_ONLY);
144 }
145 CameraUtils::getRotationTransform(staticInfo, OutputConfiguration::MIRROR_MODE_AUTO,
146 enableTransformInverseDisplay, &mRotateAndCropPreviewTransform);
147
148 mStreamingProcessor = new StreamingProcessor(this);
149
150 std::string threadName = std::string("C2-") + std::to_string(mCameraId);
151 mFrameProcessor = new FrameProcessor(mDevice, this);
152 res = mFrameProcessor->run((threadName + "-FrameProc").c_str());
153 if (res != OK) {
154 ALOGE("%s: Unable to start frame processor thread: %s (%d)",
155 __FUNCTION__, strerror(-res), res);
156 return res;
157 }
158
159 mCaptureSequencer = new CaptureSequencer(this);
160 res = mCaptureSequencer->run((threadName + "-CaptureSeq").c_str());
161 if (res != OK) {
162 ALOGE("%s: Unable to start capture sequencer thread: %s (%d)",
163 __FUNCTION__, strerror(-res), res);
164 return res;
165 }
166
167 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
168 res = mJpegProcessor->run((threadName + "-JpegProc").c_str());
169 if (res != OK) {
170 ALOGE("%s: Unable to start jpeg processor thread: %s (%d)",
171 __FUNCTION__, strerror(-res), res);
172 return res;
173 }
174
175 mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
176 res = mZslProcessor->run((threadName + "-ZslProc").c_str());
177 if (res != OK) {
178 ALOGE("%s: Unable to start zsl processor thread: %s (%d)",
179 __FUNCTION__, strerror(-res), res);
180 return res;
181 }
182
183 mCallbackProcessor = new CallbackProcessor(this);
184 res = mCallbackProcessor->run((threadName + "-CallbkProc").c_str());
185 if (res != OK) {
186 ALOGE("%s: Unable to start callback processor thread: %s (%d)",
187 __FUNCTION__, strerror(-res), res);
188 return res;
189 }
190
191 if (gLogLevel >= 1) {
192 SharedParameters::Lock l(mParameters);
193 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
194 mCameraId);
195 ALOGD("%s", l.mParameters.paramsFlattened.c_str());
196 }
197
198 mInitialized = true;
199 return OK;
200 }
201
~Camera2Client()202 Camera2Client::~Camera2Client() {
203 ATRACE_CALL();
204 ALOGV("~Camera2Client");
205
206 mDestructionStarted = true;
207
208 disconnect();
209
210 ALOGI("Camera %d: Closed", mCameraId);
211 }
212
dump(int fd,const Vector<String16> & args)213 status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
214 return BasicClient::dump(fd, args);
215 }
216
dumpClient(int fd,const Vector<String16> & args)217 status_t Camera2Client::dumpClient(int fd, const Vector<String16>& args) {
218 std::ostringstream result;
219 result << fmt::sprintf("Client2[%d] (%p) PID: %d, dump:\n", mCameraId,
220 (getRemoteCallback() != NULL ?
221 (void *) (IInterface::asBinder(getRemoteCallback()).get()) : NULL),
222 mCallingPid);
223 result << " State: ";
224 #define CASE_APPEND_ENUM(x) case x: result << #x "\n"; break;
225
226 const Parameters& p = mParameters.unsafeAccess();
227
228 result << Parameters::getStateName(p.state);
229
230 result << "\n Current parameters:\n";
231 result << fmt::sprintf(" Preview size: %d x %d\n",
232 p.previewWidth, p.previewHeight);
233 result << fmt::sprintf(" Preview FPS range: %d - %d\n",
234 p.previewFpsRange[0], p.previewFpsRange[1]);
235 result << fmt::sprintf(" Preview HAL pixel format: 0x%x\n",
236 p.previewFormat);
237 result << fmt::sprintf(" Preview transform: %x\n",
238 p.previewTransform);
239 result << fmt::sprintf(" Picture size: %d x %d\n",
240 p.pictureWidth, p.pictureHeight);
241 result << fmt::sprintf(" Jpeg thumbnail size: %d x %d\n",
242 p.jpegThumbSize[0], p.jpegThumbSize[1]);
243 result << fmt::sprintf(" Jpeg quality: %d, thumbnail quality: %d\n",
244 p.jpegQuality, p.jpegThumbQuality);
245 result << fmt::sprintf(" Jpeg rotation: %d\n", p.jpegRotation);
246 result << fmt::sprintf(" GPS tags %s\n",
247 p.gpsEnabled ? "enabled" : "disabled");
248 if (p.gpsEnabled) {
249 result << fmt::sprintf(" GPS lat x long x alt: %f x %f x %f\n",
250 p.gpsCoordinates[0], p.gpsCoordinates[1],
251 p.gpsCoordinates[2]);
252 result << fmt::sprintf(" GPS timestamp: %" PRId64 "\n",
253 p.gpsTimestamp);
254 result << fmt::sprintf(" GPS processing method: %s\n",
255 p.gpsProcessingMethod.c_str());
256 }
257
258 result << " White balance mode: ";
259 switch (p.wbMode) {
260 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
261 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
262 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
263 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
264 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
265 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
266 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
267 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
268 default: result << "UNKNOWN\n";
269 }
270
271 result << " Effect mode: ";
272 switch (p.effectMode) {
273 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
274 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
275 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
276 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
277 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
278 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
279 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
280 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
281 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
282 default: result << "UNKNOWN\n";
283 }
284
285 result << " Antibanding mode: ";
286 switch (p.antibandingMode) {
287 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
288 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
289 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
290 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
291 default: result << "UNKNOWN\n";
292 }
293
294 result << " Scene mode: ";
295 switch (p.sceneMode) {
296 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
297 result << "AUTO\n"; break;
298 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY)
299 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
300 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
301 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
302 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
303 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
304 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
305 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
306 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
307 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
308 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
309 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
310 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
311 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
312 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
313 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
314 default: result << "UNKNOWN\n";
315 }
316
317 result << " Flash mode: ";
318 switch (p.flashMode) {
319 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
320 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
321 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
322 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
323 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
324 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
325 default: result << "UNKNOWN\n";
326 }
327
328 result << " Focus mode: ";
329 switch (p.focusMode) {
330 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
331 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
332 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
333 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
334 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
335 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
336 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
337 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
338 default: result << "UNKNOWN\n";
339 }
340
341 result << " Focus state: ";
342 switch (p.focusState) {
343 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
344 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
345 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
346 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
347 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
348 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
349 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
350 default: result << "UNKNOWN\n";
351 }
352
353 result << " Focusing areas:\n";
354 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
355 result << fmt::sprintf(" [ (%d, %d, %d, %d), weight %d ]\n",
356 p.focusingAreas[i].left,
357 p.focusingAreas[i].top,
358 p.focusingAreas[i].right,
359 p.focusingAreas[i].bottom,
360 p.focusingAreas[i].weight);
361 }
362
363 result << fmt::sprintf(" Exposure compensation index: %d\n",
364 p.exposureCompensation);
365
366 result << fmt::sprintf(" AE lock %s, AWB lock %s\n",
367 p.autoExposureLock ? "enabled" : "disabled",
368 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
369
370 result << " Metering areas:\n";
371 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
372 result << fmt::sprintf(" [ (%d, %d, %d, %d), weight %d ]\n",
373 p.meteringAreas[i].left,
374 p.meteringAreas[i].top,
375 p.meteringAreas[i].right,
376 p.meteringAreas[i].bottom,
377 p.meteringAreas[i].weight);
378 }
379
380 result << fmt::sprintf(" Zoom index: %d\n", p.zoom);
381 result << fmt::sprintf(" Video size: %d x %d\n", p.videoWidth,
382 p.videoHeight);
383
384 result << fmt::sprintf(" Recording hint is %s\n",
385 p.recordingHint ? "set" : "not set");
386
387 result << fmt::sprintf(" Video stabilization is %s\n",
388 p.videoStabilization ? "enabled" : "disabled");
389
390 result << fmt::sprintf(" Selected still capture FPS range: %d - %d\n",
391 p.fastInfo.bestStillCaptureFpsRange[0],
392 p.fastInfo.bestStillCaptureFpsRange[1]);
393
394 result << fmt::sprintf(" Use zero shutter lag: %s\n",
395 p.useZeroShutterLag() ? "yes" : "no");
396
397 result << " Current streams:\n";
398 result << fmt::sprintf(" Preview stream ID: %d\n",
399 getPreviewStreamId());
400 result << fmt::sprintf(" Capture stream ID: %d\n",
401 getCaptureStreamId());
402 result << fmt::sprintf(" Recording stream ID: %d\n",
403 getRecordingStreamId());
404
405 result << " Quirks for this camera:\n";
406 bool haveQuirk = false;
407 if (p.quirks.triggerAfWithAuto) {
408 result << " triggerAfWithAuto\n";
409 haveQuirk = true;
410 }
411 if (p.quirks.useZslFormat) {
412 result << " useZslFormat\n";
413 haveQuirk = true;
414 }
415 if (p.quirks.meteringCropRegion) {
416 result << " meteringCropRegion\n";
417 haveQuirk = true;
418 }
419 if (p.quirks.partialResults) {
420 result << " usePartialResult\n";
421 haveQuirk = true;
422 }
423 if (!haveQuirk) {
424 result << " none\n";
425 }
426
427 std::string resultStr = result.str();
428
429 write(fd, resultStr.c_str(), resultStr.size());
430
431 mStreamingProcessor->dump(fd, args);
432
433 mCaptureSequencer->dump(fd, args);
434
435 mFrameProcessor->dump(fd, args);
436
437 mZslProcessor->dump(fd, args);
438
439 return dumpDevice(fd, args);
440 #undef CASE_APPEND_ENUM
441 }
442
443 // ICamera interface
444
disconnect()445 binder::Status Camera2Client::disconnect() {
446 ATRACE_CALL();
447 nsecs_t startTime = systemTime();
448 Mutex::Autolock icl(mBinderSerializationLock);
449
450 binder::Status res = binder::Status::ok();
451 // Allow both client and the cameraserver to disconnect at all times
452 int callingPid = getCallingPid();
453 if (callingPid != mCallingPid && callingPid != mServicePid) return res;
454
455 if (mDevice == 0) return res;
456
457 ALOGV("Camera %d: Shutting down", mCameraId);
458
459 /**
460 * disconnect() cannot call any methods that might need to promote a
461 * wp<Camera2Client>, since disconnect can be called from the destructor, at
462 * which point all such promotions will fail.
463 */
464
465 stopPreviewL();
466
467 {
468 SharedParameters::Lock l(mParameters);
469 if (l.mParameters.state == Parameters::DISCONNECTED) return res;
470 l.mParameters.state = Parameters::DISCONNECTED;
471 }
472
473 mFrameProcessor->requestExit();
474 mCaptureSequencer->requestExit();
475 mJpegProcessor->requestExit();
476 mZslProcessor->requestExit();
477 mCallbackProcessor->requestExit();
478
479 ALOGV("Camera %d: Waiting for threads", mCameraId);
480
481 {
482 // Don't wait with lock held, in case the other threads need to
483 // complete callbacks that re-enter Camera2Client
484 mBinderSerializationLock.unlock();
485
486 mFrameProcessor->join();
487 mCaptureSequencer->join();
488 mJpegProcessor->join();
489 mZslProcessor->join();
490 mCallbackProcessor->join();
491
492 mBinderSerializationLock.lock();
493 }
494
495 ALOGV("Camera %d: Deleting streams", mCameraId);
496
497 mStreamingProcessor->deletePreviewStream();
498 mStreamingProcessor->deleteRecordingStream();
499 mJpegProcessor->deleteStream();
500 mCallbackProcessor->deleteStream();
501 mZslProcessor->deleteStream();
502
503 ALOGV("Camera %d: Disconnecting device", mCameraId);
504
505 bool hasDeviceError = mDevice->hasDeviceError();
506 mDevice->disconnect();
507
508 if (flags::api1_release_binderlock_before_cameraservice_disconnect()) {
509 // CameraService::Client::disconnect calls CameraService which attempts to lock
510 // CameraService's mServiceLock. This might lead to a deadlock if the cameraservice is
511 // currently waiting to lock mSerializationLock on another thread.
512 mBinderSerializationLock.unlock();
513 CameraService::Client::disconnect();
514 mBinderSerializationLock.lock();
515 } else {
516 CameraService::Client::disconnect();
517 }
518
519 int32_t closeLatencyMs = ns2ms(systemTime() - startTime);
520 mCameraServiceProxyWrapper->logClose(mCameraIdStr, closeLatencyMs, hasDeviceError);
521
522 return res;
523 }
524
connect(const sp<hardware::ICameraClient> & client)525 status_t Camera2Client::connect(const sp<hardware::ICameraClient>& client) {
526 ATRACE_CALL();
527 ALOGV("%s: E", __FUNCTION__);
528 Mutex::Autolock icl(mBinderSerializationLock);
529
530 if (mCallingPid != 0 && getCallingPid() != mCallingPid) {
531 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
532 "current locked to pid %d", __FUNCTION__,
533 mCameraId, getCallingPid(), mCallingPid);
534 return BAD_VALUE;
535 }
536
537 mCallingPid = getCallingPid();
538
539 mRemoteCallback = client;
540 mSharedCameraCallbacks = client;
541
542 return OK;
543 }
544
lock()545 status_t Camera2Client::lock() {
546 ATRACE_CALL();
547 ALOGV("%s: E", __FUNCTION__);
548 Mutex::Autolock icl(mBinderSerializationLock);
549 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
550 __FUNCTION__, mCameraId, getCallingPid(), mCallingPid);
551
552 if (mCallingPid == 0) {
553 mCallingPid = getCallingPid();
554 return OK;
555 }
556
557 if (mCallingPid != getCallingPid()) {
558 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
559 __FUNCTION__, mCameraId, getCallingPid(), mCallingPid);
560 return EBUSY;
561 }
562
563 return OK;
564 }
565
unlock()566 status_t Camera2Client::unlock() {
567 ATRACE_CALL();
568 ALOGV("%s: E", __FUNCTION__);
569 Mutex::Autolock icl(mBinderSerializationLock);
570 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
571 __FUNCTION__, mCameraId, getCallingPid(), mCallingPid);
572
573 if (mCallingPid == getCallingPid()) {
574 SharedParameters::Lock l(mParameters);
575 if (l.mParameters.state == Parameters::RECORD ||
576 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
577 ALOGD("Not allowed to unlock camera during recording.");
578 return INVALID_OPERATION;
579 }
580 mCallingPid = 0;
581 mRemoteCallback.clear();
582 mSharedCameraCallbacks.clear();
583 return OK;
584 }
585
586 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
587 __FUNCTION__, mCameraId, getCallingPid(), mCallingPid);
588 return EBUSY;
589 }
590
setPreviewTarget(const sp<SurfaceType> & target)591 status_t Camera2Client::setPreviewTarget(const sp<SurfaceType>& target) {
592 ATRACE_CALL();
593 ALOGV("%s: E", __FUNCTION__);
594 Mutex::Autolock icl(mBinderSerializationLock);
595 status_t res;
596 if ((res = checkPid(__FUNCTION__)) != OK) return res;
597
598 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
599 sp<Surface> surface;
600 view::Surface viewSurface;
601 if (target != nullptr) {
602 // Using controlledByApp flag to ensure that the buffer queue remains in
603 // async mode for the old camera API, where many applications depend
604 // on that behavior.
605 surface = new Surface(target->getIGraphicBufferProducer(), true);
606 viewSurface = view::Surface::fromSurface(surface);
607 }
608 return setPreviewWindowL(viewSurface, surface);
609 #else
610 sp<IBinder> binder;
611 sp<Surface> window;
612 if (target != 0) {
613 binder = IInterface::asBinder(target);
614 // Using controlledByApp flag to ensure that the buffer queue remains in
615 // async mode for the old camera API, where many applications depend
616 // on that behavior.
617 window = new Surface(target, /*controlledByApp*/ true);
618 }
619 return setPreviewWindowL(binder, window);
620 #endif
621 }
622
623 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
setPreviewWindowL(const view::Surface & viewSurface,const sp<Surface> & window)624 status_t Camera2Client::setPreviewWindowL(const view::Surface& viewSurface,
625 const sp<Surface>& window) {
626 ATRACE_CALL();
627 status_t res;
628
629 uint64_t viewSurfaceID;
630 res = viewSurface.getUniqueId(&viewSurfaceID);
631 if (res != OK) {
632 ALOGE("%s: Camera %d: Could not getUniqueId.", __FUNCTION__, mCameraId);
633 return res;
634 }
635
636 if (viewSurfaceID == mPreviewViewSurfaceID) {
637 ALOGV("%s: Camera %d: New window is same as old window", __FUNCTION__, mCameraId);
638 return NO_ERROR;
639 }
640 #else
641 status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
642 const sp<Surface>& window) {
643 ATRACE_CALL();
644 status_t res;
645
646 if (binder == mPreviewSurface) {
647 ALOGV("%s: Camera %d: New window is same as old window",
648 __FUNCTION__, mCameraId);
649 return NO_ERROR;
650 }
651 #endif
652
653 Parameters::State state;
654 {
655 SharedParameters::Lock l(mParameters);
656 state = l.mParameters.state;
657 }
658 switch (state) {
659 case Parameters::DISCONNECTED:
660 case Parameters::RECORD:
661 case Parameters::STILL_CAPTURE:
662 case Parameters::VIDEO_SNAPSHOT:
663 ALOGE("%s: Camera %d: Cannot set preview display while in state %s", __FUNCTION__,
664 mCameraId, Parameters::getStateName(state));
665 return INVALID_OPERATION;
666 case Parameters::STOPPED:
667 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
668 // OK
669 break;
670 case Parameters::PREVIEW:
671 // Already running preview - need to stop and create a new stream
672 res = stopStream();
673 if (res != OK) {
674 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)", __FUNCTION__,
675 strerror(-res), res);
676 return res;
677 }
678 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
679 break;
680 }
681
682 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
683 mPreviewViewSurfaceID = viewSurfaceID;
684 #else
685 mPreviewSurface = binder;
686 #endif
687
688 res = mStreamingProcessor->setPreviewWindow(window);
689 if (res != OK) {
690 ALOGE("%s: Unable to set new preview window: %s (%d)", __FUNCTION__, strerror(-res), res);
691 return res;
692 }
693
694 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
695 SharedParameters::Lock l(mParameters);
696 l.mParameters.state = state;
697 return startPreviewL(l.mParameters, false);
698 }
699
700 return OK;
701 }
702
703 void Camera2Client::setPreviewCallbackFlag(int flag) {
704 ATRACE_CALL();
705 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
706 Mutex::Autolock icl(mBinderSerializationLock);
707
708 if ( checkPid(__FUNCTION__) != OK) return;
709
710 SharedParameters::Lock l(mParameters);
711 setPreviewCallbackFlagL(l.mParameters, flag);
712 }
713
714 void Camera2Client::setPreviewCallbackFlagL(Parameters ¶ms, int flag) {
715 status_t res = OK;
716
717 switch(params.state) {
718 case Parameters::STOPPED:
719 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
720 case Parameters::PREVIEW:
721 case Parameters::STILL_CAPTURE:
722 // OK
723 break;
724 default:
725 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
726 ALOGE("%s: Camera %d: Can't use preview callbacks "
727 "in state %d", __FUNCTION__, mCameraId, params.state);
728 return;
729 }
730 }
731
732 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
733 ALOGV("%s: setting oneshot", __FUNCTION__);
734 params.previewCallbackOneShot = true;
735 }
736 if (params.previewCallbackFlags != (uint32_t)flag) {
737
738 if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
739 // Disable any existing preview callback window when enabling
740 // preview callback flags
741 res = mCallbackProcessor->setCallbackWindow(NULL);
742 if (res != OK) {
743 ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
744 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
745 return;
746 }
747 params.previewCallbackSurface = false;
748 }
749
750 params.previewCallbackFlags = flag;
751
752 if (params.state == Parameters::PREVIEW) {
753 res = startPreviewL(params, true);
754 if (res != OK) {
755 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
756 __FUNCTION__, mCameraId,
757 Parameters::getStateName(params.state));
758 }
759 }
760 }
761 }
762
763 status_t Camera2Client::setPreviewCallbackTarget(const sp<SurfaceType>& target) {
764 ATRACE_CALL();
765 ALOGV("%s: E", __FUNCTION__);
766 Mutex::Autolock icl(mBinderSerializationLock);
767 status_t res;
768 if ((res = checkPid(__FUNCTION__)) != OK) return res;
769
770 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
771 sp<Surface> window = target;
772 #else
773 sp<Surface> window;
774 if (target != 0) {
775 window = new Surface(target);
776 }
777 #endif
778
779 res = mCallbackProcessor->setCallbackWindow(window);
780 if (res != OK) {
781 ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)", __FUNCTION__,
782 mCameraId, strerror(-res), res);
783 return res;
784 }
785
786 SharedParameters::Lock l(mParameters);
787
788 if (window != NULL) {
789 // Disable traditional callbacks when a valid callback target is given
790 l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
791 l.mParameters.previewCallbackOneShot = false;
792 l.mParameters.previewCallbackSurface = true;
793 } else {
794 // Disable callback target if given a NULL interface.
795 l.mParameters.previewCallbackSurface = false;
796 }
797
798 switch (l.mParameters.state) {
799 case Parameters::PREVIEW:
800 res = startPreviewL(l.mParameters, true);
801 break;
802 case Parameters::RECORD:
803 case Parameters::VIDEO_SNAPSHOT:
804 res = startRecordingL(l.mParameters, true);
805 break;
806 default:
807 break;
808 }
809 if (res != OK) {
810 ALOGE("%s: Camera %d: Unable to refresh request in state %s", __FUNCTION__, mCameraId,
811 Parameters::getStateName(l.mParameters.state));
812 }
813
814 return OK;
815 }
816
817 status_t Camera2Client::startPreview() {
818 ATRACE_CALL();
819 ALOGV("%s: E", __FUNCTION__);
820 Mutex::Autolock icl(mBinderSerializationLock);
821 status_t res;
822 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
823 SharedParameters::Lock l(mParameters);
824 return startPreviewL(l.mParameters, false);
825 }
826
827 status_t Camera2Client::startPreviewL(Parameters ¶ms, bool restart) {
828 ATRACE_CALL();
829 status_t res;
830
831 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
832
833 if (params.state == Parameters::DISCONNECTED) {
834 ALOGE("%s: Camera %d has been disconnected.", __FUNCTION__, mCameraId);
835 return INVALID_OPERATION;
836 }
837 if ( (params.state == Parameters::PREVIEW ||
838 params.state == Parameters::RECORD ||
839 params.state == Parameters::VIDEO_SNAPSHOT)
840 && !restart) {
841 // Succeed attempt to re-enter a streaming state
842 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
843 __FUNCTION__, mCameraId);
844 return OK;
845 }
846 if (params.state > Parameters::PREVIEW && !restart) {
847 ALOGE("%s: Can't start preview in state %s",
848 __FUNCTION__,
849 Parameters::getStateName(params.state));
850 return INVALID_OPERATION;
851 }
852
853 if (!mStreamingProcessor->haveValidPreviewWindow()) {
854 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
855 return OK;
856 }
857 params.state = Parameters::STOPPED;
858 int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();
859
860 res = mStreamingProcessor->updatePreviewStream(params);
861 if (res != OK) {
862 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
863 __FUNCTION__, mCameraId, strerror(-res), res);
864 return res;
865 }
866
867 bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;
868
869 // We could wait to create the JPEG output stream until first actual use
870 // (first takePicture call). However, this would substantially increase the
871 // first capture latency on HAL3 devices.
872 // So create it unconditionally at preview start. As a drawback,
873 // this increases gralloc memory consumption for applications that don't
874 // ever take a picture. Do not enter this mode when jpeg stream will slow
875 // down preview.
876 // TODO: Find a better compromise, though this likely would involve HAL
877 // changes.
878 int lastJpegStreamId = mJpegProcessor->getStreamId();
879 // If jpeg stream will slow down preview, make sure we remove it before starting preview
880 if (params.slowJpegMode) {
881 if (lastJpegStreamId != NO_STREAM) {
882 // Pause preview if we are streaming
883 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
884 if (activeRequestId != 0) {
885 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
886 if (res != OK) {
887 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
888 __FUNCTION__, mCameraId, strerror(-res), res);
889 }
890 res = mDevice->waitUntilDrained();
891 if (res != OK) {
892 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
893 __FUNCTION__, mCameraId, strerror(-res), res);
894 }
895 }
896
897 res = mJpegProcessor->deleteStream();
898
899 if (res != OK) {
900 ALOGE("%s: Camera %d: delete Jpeg stream failed: %s (%d)",
901 __FUNCTION__, mCameraId, strerror(-res), res);
902 }
903
904 if (activeRequestId != 0) {
905 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
906 if (res != OK) {
907 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
908 __FUNCTION__, mCameraId, strerror(-res), res);
909 }
910 }
911 }
912 } else {
913 res = updateProcessorStream(mJpegProcessor, params);
914 if (res != OK) {
915 ALOGE("%s: Camera %d: Can't pre-configure still image "
916 "stream: %s (%d)",
917 __FUNCTION__, mCameraId, strerror(-res), res);
918 return res;
919 }
920 }
921 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
922
923 Vector<int32_t> outputStreams;
924 bool callbacksEnabled = (params.previewCallbackFlags &
925 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
926 params.previewCallbackSurface;
927
928 if (callbacksEnabled) {
929 // Can't have recording stream hanging around when enabling callbacks,
930 // since it exceeds the max stream count on some devices.
931 if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
932 ALOGV("%s: Camera %d: Clearing out recording stream before "
933 "creating callback stream", __FUNCTION__, mCameraId);
934 res = mStreamingProcessor->stopStream();
935 if (res != OK) {
936 ALOGE("%s: Camera %d: Can't stop streaming to delete "
937 "recording stream", __FUNCTION__, mCameraId);
938 return res;
939 }
940 res = mStreamingProcessor->deleteRecordingStream();
941 if (res != OK) {
942 ALOGE("%s: Camera %d: Unable to delete recording stream before "
943 "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
944 strerror(-res), res);
945 return res;
946 }
947 }
948
949 res = mCallbackProcessor->updateStream(params);
950 if (res != OK) {
951 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
952 __FUNCTION__, mCameraId, strerror(-res), res);
953 return res;
954 }
955 outputStreams.push(getCallbackStreamId());
956 } else if (previewStreamChanged && mCallbackProcessor->getStreamId() != NO_STREAM) {
957 /**
958 * Delete the unused callback stream when preview stream is changed and
959 * preview is not enabled. Don't need stop preview stream as preview is in
960 * STOPPED state now.
961 */
962 ALOGV("%s: Camera %d: Delete unused preview callback stream.", __FUNCTION__, mCameraId);
963 res = mCallbackProcessor->deleteStream();
964 if (res != OK) {
965 ALOGE("%s: Camera %d: Unable to delete callback stream %s (%d)",
966 __FUNCTION__, mCameraId, strerror(-res), res);
967 return res;
968 }
969 }
970
971 if (params.useZeroShutterLag() &&
972 getRecordingStreamId() == NO_STREAM) {
973 res = updateProcessorStream(mZslProcessor, params);
974 if (res != OK) {
975 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
976 __FUNCTION__, mCameraId, strerror(-res), res);
977 return res;
978 }
979
980 if (jpegStreamChanged) {
981 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
982 __FUNCTION__, mCameraId);
983 mZslProcessor->clearZslQueue();
984 }
985 outputStreams.push(getZslStreamId());
986 } else {
987 mZslProcessor->deleteStream();
988 }
989
990 outputStreams.push(getPreviewStreamId());
991
992 if (params.isDeviceZslSupported) {
993 // If device ZSL is supported, resume preview buffers that may be paused
994 // during last takePicture().
995 mDevice->dropStreamBuffers(false, getPreviewStreamId());
996 }
997
998 if (!params.recordingHint) {
999 if (!restart) {
1000 res = mStreamingProcessor->updatePreviewRequest(params);
1001 if (res != OK) {
1002 ALOGE("%s: Camera %d: Can't set up preview request: "
1003 "%s (%d)", __FUNCTION__, mCameraId,
1004 strerror(-res), res);
1005 return res;
1006 }
1007 }
1008 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
1009 outputStreams);
1010 } else {
1011 if (!restart) {
1012 res = mStreamingProcessor->updateRecordingRequest(params);
1013 if (res != OK) {
1014 ALOGE("%s: Camera %d: Can't set up preview request with "
1015 "record hint: %s (%d)", __FUNCTION__, mCameraId,
1016 strerror(-res), res);
1017 return res;
1018 }
1019 }
1020 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1021 outputStreams);
1022 }
1023 if (res != OK) {
1024 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
1025 __FUNCTION__, mCameraId, strerror(-res), res);
1026 return res;
1027 }
1028
1029 mCallbackProcessor->unpauseCallback();
1030 params.state = Parameters::PREVIEW;
1031 return OK;
1032 }
1033
1034 void Camera2Client::stopPreview() {
1035 ATRACE_CALL();
1036 ALOGV("%s: E", __FUNCTION__);
1037 Mutex::Autolock icl(mBinderSerializationLock);
1038 status_t res;
1039 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1040 stopPreviewL();
1041 }
1042
1043 void Camera2Client::stopPreviewL() {
1044 ATRACE_CALL();
1045
1046 if (!mInitialized) {
1047 // If we haven't initialized yet, there's no stream to stop (b/379558387)
1048 return;
1049 }
1050
1051 status_t res;
1052 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
1053 Parameters::State state;
1054 {
1055 SharedParameters::Lock l(mParameters);
1056 state = l.mParameters.state;
1057 }
1058
1059 switch (state) {
1060 case Parameters::DISCONNECTED:
1061 // Nothing to do.
1062 break;
1063 case Parameters::STOPPED:
1064 case Parameters::VIDEO_SNAPSHOT:
1065 case Parameters::STILL_CAPTURE:
1066 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
1067 FALLTHROUGH_INTENDED;
1068 case Parameters::RECORD:
1069 case Parameters::PREVIEW:
1070 mCallbackProcessor->pauseCallback();
1071 syncWithDevice();
1072 // Due to flush a camera device sync is not a sufficient
1073 // guarantee that the current client parameters are
1074 // correctly applied. To resolve this wait for the current
1075 // request id to return in the results.
1076 waitUntilCurrentRequestIdLocked();
1077 res = stopStream();
1078 if (res != OK) {
1079 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
1080 __FUNCTION__, mCameraId, strerror(-res), res);
1081 }
1082
1083 // Flush all in-process captures and buffer in order to stop
1084 // preview faster.
1085 res = mDevice->flush();
1086 if (res != OK) {
1087 ALOGE("%s: Camera %d: Unable to flush pending requests: %s (%d)",
1088 __FUNCTION__, mCameraId, strerror(-res), res);
1089 }
1090
1091 res = mDevice->waitUntilDrained();
1092 if (res != OK) {
1093 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1094 __FUNCTION__, mCameraId, strerror(-res), res);
1095 }
1096 // Clean up recording stream
1097 res = mStreamingProcessor->deleteRecordingStream();
1098 if (res != OK) {
1099 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1100 "stop preview: %s (%d)",
1101 __FUNCTION__, mCameraId, strerror(-res), res);
1102 }
1103 FALLTHROUGH_INTENDED;
1104 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
1105 SharedParameters::Lock l(mParameters);
1106 l.mParameters.state = Parameters::STOPPED;
1107 commandStopFaceDetectionL(l.mParameters);
1108 break;
1109 }
1110 default:
1111 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
1112 state);
1113 }
1114 }
1115
1116 bool Camera2Client::previewEnabled() {
1117 ATRACE_CALL();
1118 Mutex::Autolock icl(mBinderSerializationLock);
1119 status_t res;
1120 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
1121
1122 SharedParameters::Lock l(mParameters);
1123 return l.mParameters.state == Parameters::PREVIEW;
1124 }
1125
1126 status_t Camera2Client::setVideoBufferMode(int32_t videoBufferMode) {
1127 ATRACE_CALL();
1128 Mutex::Autolock icl(mBinderSerializationLock);
1129 status_t res;
1130 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1131
1132 SharedParameters::Lock l(mParameters);
1133 switch (l.mParameters.state) {
1134 case Parameters::RECORD:
1135 case Parameters::VIDEO_SNAPSHOT:
1136 ALOGE("%s: Camera %d: Can't be called in state %s",
1137 __FUNCTION__, mCameraId,
1138 Parameters::getStateName(l.mParameters.state));
1139 return INVALID_OPERATION;
1140 default:
1141 // OK
1142 break;
1143 }
1144
1145 if (videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
1146 ALOGE("%s: %d: Only video buffer queue is supported", __FUNCTION__, __LINE__);
1147 return BAD_VALUE;
1148 }
1149
1150 l.mParameters.videoBufferMode = videoBufferMode;
1151
1152 return OK;
1153 }
1154
1155 status_t Camera2Client::startRecording() {
1156 ATRACE_CALL();
1157 ALOGV("%s: E", __FUNCTION__);
1158 Mutex::Autolock icl(mBinderSerializationLock);
1159 status_t res;
1160 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1161 SharedParameters::Lock l(mParameters);
1162
1163 return startRecordingL(l.mParameters, false);
1164 }
1165
1166 status_t Camera2Client::startRecordingL(Parameters ¶ms, bool restart) {
1167 status_t res = OK;
1168
1169 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
1170
1171 switch (params.state) {
1172 case Parameters::STOPPED:
1173 res = startPreviewL(params, false);
1174 if (res != OK) return res;
1175 // Make sure first preview request is submitted to the HAL device to avoid
1176 // two consecutive set of configure_streams being called into the HAL.
1177 // TODO: Refactor this to avoid initial preview configuration.
1178 syncWithDevice();
1179 break;
1180 case Parameters::PREVIEW:
1181 // Ready to go
1182 break;
1183 case Parameters::RECORD:
1184 case Parameters::VIDEO_SNAPSHOT:
1185 // OK to call this when recording is already on, just skip unless
1186 // we're looking to restart
1187 if (!restart) return OK;
1188 break;
1189 default:
1190 ALOGE("%s: Camera %d: Can't start recording in state %s",
1191 __FUNCTION__, mCameraId,
1192 Parameters::getStateName(params.state));
1193 return INVALID_OPERATION;
1194 };
1195
1196 if (params.videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
1197 ALOGE("%s: Camera %d: Recording only supported buffer queue mode, but "
1198 "mode %d is requested!", __FUNCTION__, mCameraId, params.videoBufferMode);
1199 return INVALID_OPERATION;
1200 }
1201
1202 if (!mStreamingProcessor->haveValidRecordingWindow()) {
1203 ALOGE("%s: No valid recording window", __FUNCTION__);
1204 return INVALID_OPERATION;
1205 }
1206
1207 if (!restart) {
1208 sCameraService->playSound(CameraService::SOUND_RECORDING_START);
1209 mStreamingProcessor->updateRecordingRequest(params);
1210 if (res != OK) {
1211 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1212 __FUNCTION__, mCameraId, strerror(-res), res);
1213 return res;
1214 }
1215 }
1216
1217 // Not all devices can support a preview callback stream and a recording
1218 // stream at the same time, so assume none of them can.
1219 if (mCallbackProcessor->getStreamId() != NO_STREAM) {
1220 ALOGV("%s: Camera %d: Clearing out callback stream before "
1221 "creating recording stream", __FUNCTION__, mCameraId);
1222 res = mStreamingProcessor->stopStream();
1223 if (res != OK) {
1224 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1225 __FUNCTION__, mCameraId);
1226 return res;
1227 }
1228 res = mCallbackProcessor->deleteStream();
1229 if (res != OK) {
1230 ALOGE("%s: Camera %d: Unable to delete callback stream before "
1231 "record: %s (%d)", __FUNCTION__, mCameraId,
1232 strerror(-res), res);
1233 return res;
1234 }
1235 }
1236
1237 // Clean up ZSL before transitioning into recording
1238 if (mZslProcessor->getStreamId() != NO_STREAM) {
1239 ALOGV("%s: Camera %d: Clearing out zsl stream before "
1240 "creating recording stream", __FUNCTION__, mCameraId);
1241 res = mStreamingProcessor->stopStream();
1242 if (res != OK) {
1243 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1244 __FUNCTION__, mCameraId);
1245 return res;
1246 }
1247 res = mDevice->waitUntilDrained();
1248 if (res != OK) {
1249 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1250 __FUNCTION__, mCameraId, strerror(-res), res);
1251 }
1252 res = mZslProcessor->clearZslQueue();
1253 if (res != OK) {
1254 ALOGE("%s: Camera %d: Can't clear zsl queue",
1255 __FUNCTION__, mCameraId);
1256 return res;
1257 }
1258 res = mZslProcessor->deleteStream();
1259 if (res != OK) {
1260 ALOGE("%s: Camera %d: Unable to delete zsl stream before "
1261 "record: %s (%d)", __FUNCTION__, mCameraId,
1262 strerror(-res), res);
1263 return res;
1264 }
1265 }
1266
1267 // Disable callbacks if they're enabled; can't record and use callbacks,
1268 // and we can't fail record start without stagefright asserting.
1269 params.previewCallbackFlags = 0;
1270
1271 // May need to reconfigure video snapshot JPEG sizes
1272 // during recording startup, so need a more complex sequence here to
1273 // ensure an early stream reconfiguration doesn't happen
1274 bool recordingStreamNeedsUpdate;
1275 res = mStreamingProcessor->recordingStreamNeedsUpdate(params, &recordingStreamNeedsUpdate);
1276 if (res != OK) {
1277 ALOGE("%s: Camera %d: Can't query recording stream",
1278 __FUNCTION__, mCameraId);
1279 return res;
1280 }
1281
1282 if (recordingStreamNeedsUpdate) {
1283 // Need to stop stream here so updateProcessorStream won't trigger configureStream
1284 // Right now camera device cannot handle configureStream failure gracefully
1285 // when device is streaming
1286 res = mStreamingProcessor->stopStream();
1287 if (res != OK) {
1288 ALOGE("%s: Camera %d: Can't stop streaming to update record "
1289 "stream", __FUNCTION__, mCameraId);
1290 return res;
1291 }
1292 res = mDevice->waitUntilDrained();
1293 if (res != OK) {
1294 ALOGE("%s: Camera %d: Waiting to stop streaming failed: "
1295 "%s (%d)", __FUNCTION__, mCameraId,
1296 strerror(-res), res);
1297 }
1298
1299 res = updateProcessorStream<
1300 StreamingProcessor,
1301 &StreamingProcessor::updateRecordingStream>(
1302 mStreamingProcessor,
1303 params);
1304 if (res != OK) {
1305 ALOGE("%s: Camera %d: Unable to update recording stream: "
1306 "%s (%d)", __FUNCTION__, mCameraId,
1307 strerror(-res), res);
1308 return res;
1309 }
1310 }
1311
1312 Vector<int32_t> outputStreams;
1313 outputStreams.push(getPreviewStreamId());
1314 outputStreams.push(getRecordingStreamId());
1315
1316 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1317 outputStreams);
1318
1319 // startStream might trigger a configureStream call and device might fail
1320 // configureStream due to jpeg size > video size. Try again with jpeg size overridden
1321 // to video size.
1322 if (res == BAD_VALUE) {
1323 overrideVideoSnapshotSize(params);
1324 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1325 outputStreams);
1326 }
1327
1328 if (res != OK) {
1329 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
1330 __FUNCTION__, mCameraId, strerror(-res), res);
1331 return res;
1332 }
1333
1334 if (params.state < Parameters::RECORD) {
1335 params.state = Parameters::RECORD;
1336 }
1337
1338 return OK;
1339 }
1340
1341 void Camera2Client::stopRecording() {
1342 ATRACE_CALL();
1343 ALOGV("%s: E", __FUNCTION__);
1344 Mutex::Autolock icl(mBinderSerializationLock);
1345 SharedParameters::Lock l(mParameters);
1346
1347 status_t res;
1348 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1349
1350 switch (l.mParameters.state) {
1351 case Parameters::RECORD:
1352 // OK to stop
1353 break;
1354 case Parameters::STOPPED:
1355 case Parameters::PREVIEW:
1356 case Parameters::STILL_CAPTURE:
1357 case Parameters::VIDEO_SNAPSHOT:
1358 default:
1359 ALOGE("%s: Camera %d: Can't stop recording in state %s",
1360 __FUNCTION__, mCameraId,
1361 Parameters::getStateName(l.mParameters.state));
1362 return;
1363 };
1364
1365 sCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
1366
1367 // Remove recording stream because the video target may be abandoned soon.
1368 res = stopStream();
1369 if (res != OK) {
1370 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
1371 __FUNCTION__, mCameraId, strerror(-res), res);
1372 }
1373
1374 res = mDevice->waitUntilDrained();
1375 if (res != OK) {
1376 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1377 __FUNCTION__, mCameraId, strerror(-res), res);
1378 }
1379 // Clean up recording stream
1380 res = mStreamingProcessor->deleteRecordingStream();
1381 if (res != OK) {
1382 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1383 "stop preview: %s (%d)",
1384 __FUNCTION__, mCameraId, strerror(-res), res);
1385 }
1386 l.mParameters.recoverOverriddenJpegSize();
1387
1388 // Restart preview
1389 res = startPreviewL(l.mParameters, true);
1390 if (res != OK) {
1391 ALOGE("%s: Camera %d: Unable to return to preview",
1392 __FUNCTION__, mCameraId);
1393 }
1394 }
1395
1396 bool Camera2Client::recordingEnabled() {
1397 ATRACE_CALL();
1398 Mutex::Autolock icl(mBinderSerializationLock);
1399
1400 if ( checkPid(__FUNCTION__) != OK) return false;
1401
1402 return recordingEnabledL();
1403 }
1404
1405 bool Camera2Client::recordingEnabledL() {
1406 ATRACE_CALL();
1407 SharedParameters::Lock l(mParameters);
1408
1409 return (l.mParameters.state == Parameters::RECORD
1410 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
1411 }
1412
1413 void Camera2Client::releaseRecordingFrame([[maybe_unused]] const sp<IMemory>& mem) {
1414 ATRACE_CALL();
1415 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1416 }
1417
1418 void Camera2Client::releaseRecordingFrameHandle([[maybe_unused]] native_handle_t *handle) {
1419 ATRACE_CALL();
1420 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1421 }
1422
1423 void Camera2Client::releaseRecordingFrameHandleBatch(
1424 [[maybe_unused]] const std::vector<native_handle_t*>& handles) {
1425 ATRACE_CALL();
1426 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1427 }
1428
1429 status_t Camera2Client::autoFocus() {
1430 ATRACE_CALL();
1431 Mutex::Autolock icl(mBinderSerializationLock);
1432 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1433 status_t res;
1434 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1435
1436 int triggerId;
1437 bool notifyImmediately = false;
1438 bool notifySuccess = false;
1439 {
1440 SharedParameters::Lock l(mParameters);
1441 if (l.mParameters.state < Parameters::PREVIEW) {
1442 ALOGE("%s: Camera %d: Call autoFocus when preview is inactive (state = %d).",
1443 __FUNCTION__, mCameraId, l.mParameters.state);
1444 return INVALID_OPERATION;
1445 }
1446
1447 /**
1448 * If the camera does not support auto-focus, it is a no-op and
1449 * onAutoFocus(boolean, Camera) callback will be called immediately
1450 * with a fake value of success set to true.
1451 *
1452 * Similarly, if focus mode is set to INFINITY, there's no reason to
1453 * bother the HAL.
1454 */
1455 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1456 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1457 notifyImmediately = true;
1458 notifySuccess = true;
1459 }
1460 /**
1461 * If we're in CAF mode, and AF has already been locked, just fire back
1462 * the callback right away; the HAL would not send a notification since
1463 * no state change would happen on a AF trigger.
1464 */
1465 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1466 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1467 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1468 notifyImmediately = true;
1469 notifySuccess = true;
1470 }
1471 /**
1472 * Send immediate notification back to client
1473 */
1474 if (notifyImmediately) {
1475 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1476 if (l.mRemoteCallback != 0) {
1477 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
1478 notifySuccess ? 1 : 0, 0);
1479 }
1480 return OK;
1481 }
1482 /**
1483 * Handle quirk mode for AF in scene modes
1484 */
1485 if (l.mParameters.quirks.triggerAfWithAuto &&
1486 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED &&
1487 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1488 !l.mParameters.focusingAreas[0].isEmpty()) {
1489 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1490 __FUNCTION__, l.mParameters.focusMode);
1491 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1492 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1493 updateRequests(l.mParameters);
1494 }
1495
1496 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1497 triggerId = l.mParameters.currentAfTriggerId;
1498 }
1499 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1500
1501 syncWithDevice();
1502
1503 mDevice->triggerAutofocus(triggerId);
1504
1505 return OK;
1506 }
1507
1508 status_t Camera2Client::cancelAutoFocus() {
1509 ATRACE_CALL();
1510 Mutex::Autolock icl(mBinderSerializationLock);
1511 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1512 status_t res;
1513 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1514
1515 int triggerId;
1516 {
1517 SharedParameters::Lock l(mParameters);
1518 if (l.mParameters.state == Parameters::DISCONNECTED) {
1519 ALOGE("%s: Camera %d has been disconnected.", __FUNCTION__, mCameraId);
1520 return INVALID_OPERATION;
1521 }
1522
1523 // Canceling does nothing in FIXED or INFINITY modes
1524 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1525 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1526 return OK;
1527 }
1528
1529 // An active AF trigger is canceled
1530 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1531 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1532 }
1533
1534 triggerId = ++l.mParameters.afTriggerCounter;
1535
1536 // When using triggerAfWithAuto quirk, may need to reset focus mode to
1537 // the real state at this point. No need to cancel explicitly if
1538 // changing the AF mode.
1539 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1540 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1541 l.mParameters.shadowFocusMode);
1542 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1543 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1544 updateRequests(l.mParameters);
1545
1546 return OK;
1547 }
1548 if (l.mParameters.allowZslMode) {
1549 mZslProcessor->clearZslQueue();
1550 }
1551 }
1552 syncWithDevice();
1553
1554 mDevice->triggerCancelAutofocus(triggerId);
1555
1556 return OK;
1557 }
1558
1559 status_t Camera2Client::takePicture(int /*msgType*/) {
1560 ATRACE_CALL();
1561 Mutex::Autolock icl(mBinderSerializationLock);
1562 status_t res;
1563 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1564
1565 int takePictureCounter;
1566 bool shouldSyncWithDevice = true;
1567 {
1568 SharedParameters::Lock l(mParameters);
1569 switch (l.mParameters.state) {
1570 case Parameters::DISCONNECTED:
1571 case Parameters::STOPPED:
1572 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1573 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
1574 __FUNCTION__, mCameraId);
1575 return INVALID_OPERATION;
1576 case Parameters::PREVIEW:
1577 // Good to go for takePicture
1578 res = commandStopFaceDetectionL(l.mParameters);
1579 if (res != OK) {
1580 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1581 __FUNCTION__, mCameraId);
1582 return res;
1583 }
1584 l.mParameters.state = Parameters::STILL_CAPTURE;
1585
1586 // Remove recording stream to prevent video snapshot jpeg logic kicking in
1587 if (l.mParameters.isJpegSizeOverridden() &&
1588 mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
1589 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1590 if (res != OK) {
1591 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1592 __FUNCTION__, mCameraId, strerror(-res), res);
1593 }
1594 res = mDevice->waitUntilDrained();
1595 if (res != OK) {
1596 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1597 __FUNCTION__, mCameraId, strerror(-res), res);
1598 }
1599 // Clean up recording stream
1600 res = mStreamingProcessor->deleteRecordingStream();
1601 if (res != OK) {
1602 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1603 "stop preview: %s (%d)",
1604 __FUNCTION__, mCameraId, strerror(-res), res);
1605 }
1606 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1607 if (res != OK) {
1608 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1609 __FUNCTION__, mCameraId, strerror(-res), res);
1610 }
1611 l.mParameters.recoverOverriddenJpegSize();
1612 }
1613 break;
1614 case Parameters::RECORD:
1615 // Good to go for video snapshot
1616 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1617 break;
1618 case Parameters::STILL_CAPTURE:
1619 case Parameters::VIDEO_SNAPSHOT:
1620 ALOGE("%s: Camera %d: Already taking a picture",
1621 __FUNCTION__, mCameraId);
1622 return INVALID_OPERATION;
1623 }
1624
1625 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
1626 int lastJpegStreamId = mJpegProcessor->getStreamId();
1627 // slowJpegMode will create jpeg stream in CaptureSequencer before capturing
1628 if (!l.mParameters.slowJpegMode) {
1629 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1630 }
1631
1632 // If video snapshot fail to configureStream, try override video snapshot size to
1633 // video size
1634 if (res == BAD_VALUE && l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
1635 overrideVideoSnapshotSize(l.mParameters);
1636 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1637 }
1638 if (res != OK) {
1639 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1640 __FUNCTION__, mCameraId, strerror(-res), res);
1641 return res;
1642 }
1643 takePictureCounter = ++l.mParameters.takePictureCounter;
1644
1645 // Clear ZSL buffer queue when Jpeg size is changed.
1646 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
1647 if (l.mParameters.allowZslMode && jpegStreamChanged) {
1648 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
1649 __FUNCTION__, mCameraId);
1650 mZslProcessor->clearZslQueue();
1651 }
1652
1653 // We should always sync with the device in case flash is turned on,
1654 // the camera device suggests that flash is needed (AE state FLASH_REQUIRED)
1655 // or we are in some other AE state different from CONVERGED that may need
1656 // precapture trigger.
1657 if (l.mParameters.flashMode != Parameters::FLASH_MODE_ON &&
1658 (l.mParameters.aeState == ANDROID_CONTROL_AE_STATE_CONVERGED)) {
1659 shouldSyncWithDevice = false;
1660 }
1661 }
1662
1663 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1664
1665 // Make sure HAL has correct settings in case precapture trigger is needed.
1666 if (shouldSyncWithDevice) {
1667 syncWithDevice();
1668 }
1669
1670 res = mCaptureSequencer->startCapture();
1671 if (res != OK) {
1672 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
1673 __FUNCTION__, mCameraId, strerror(-res), res);
1674 }
1675
1676 return res;
1677 }
1678
1679 status_t Camera2Client::setParameters(const String8& params) {
1680 ATRACE_CALL();
1681 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1682 Mutex::Autolock icl(mBinderSerializationLock);
1683 status_t res;
1684 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1685
1686 SharedParameters::Lock l(mParameters);
1687
1688 Parameters::focusMode_t focusModeBefore = l.mParameters.focusMode;
1689 res = l.mParameters.set(params);
1690 if (res != OK) return res;
1691 Parameters::focusMode_t focusModeAfter = l.mParameters.focusMode;
1692
1693 if (l.mParameters.allowZslMode && focusModeAfter != focusModeBefore) {
1694 mZslProcessor->clearZslQueue();
1695 }
1696
1697 res = updateRequests(l.mParameters);
1698
1699 return res;
1700 }
1701
1702 String8 Camera2Client::getParameters() const {
1703 ATRACE_CALL();
1704 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1705 Mutex::Autolock icl(mBinderSerializationLock);
1706 // The camera service can unconditionally get the parameters at all times
1707 if (getCallingPid() != mServicePid && checkPid(__FUNCTION__) != OK) return String8();
1708
1709 SharedParameters::ReadLock l(mParameters);
1710
1711 return l.mParameters.get();
1712 }
1713
1714 status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1715 ATRACE_CALL();
1716 Mutex::Autolock icl(mBinderSerializationLock);
1717 status_t res;
1718 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1719
1720 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1721 cmd, arg1, arg2);
1722
1723 switch (cmd) {
1724 case CAMERA_CMD_START_SMOOTH_ZOOM:
1725 return commandStartSmoothZoomL();
1726 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1727 return commandStopSmoothZoomL();
1728 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1729 return commandSetDisplayOrientationL(arg1);
1730 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1731 return commandEnableShutterSoundL(arg1 == 1);
1732 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1733 return commandPlayRecordingSoundL();
1734 case CAMERA_CMD_START_FACE_DETECTION:
1735 return commandStartFaceDetectionL(arg1);
1736 case CAMERA_CMD_STOP_FACE_DETECTION: {
1737 SharedParameters::Lock l(mParameters);
1738 return commandStopFaceDetectionL(l.mParameters);
1739 }
1740 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1741 return commandEnableFocusMoveMsgL(arg1 == 1);
1742 case CAMERA_CMD_PING:
1743 return commandPingL();
1744 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1745 case CAMERA_CMD_SET_VIDEO_FORMAT:
1746 ALOGE("%s: command %d (arguments %d, %d) is not supported.",
1747 __FUNCTION__, cmd, arg1, arg2);
1748 return BAD_VALUE;
1749 default:
1750 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1751 __FUNCTION__, cmd, arg1, arg2);
1752 return BAD_VALUE;
1753 }
1754 }
1755
1756 status_t Camera2Client::commandStartSmoothZoomL() {
1757 ALOGE("%s: Unimplemented!", __FUNCTION__);
1758 return OK;
1759 }
1760
1761 status_t Camera2Client::commandStopSmoothZoomL() {
1762 ALOGE("%s: Unimplemented!", __FUNCTION__);
1763 return OK;
1764 }
1765
1766 status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1767 int transform = Parameters::degToTransform(degrees,
1768 mCameraFacing == CAMERA_FACING_FRONT);
1769 if (transform == -1) {
1770 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1771 __FUNCTION__, mCameraId, degrees);
1772 return BAD_VALUE;
1773 }
1774 {
1775 Mutex::Autolock icl(mRotateAndCropLock);
1776 if (mRotateAndCropMode != ANDROID_SCALER_ROTATE_AND_CROP_NONE) {
1777 ALOGI("%s: Rotate and crop set to: %d, skipping display orientation!", __FUNCTION__,
1778 mRotateAndCropMode);
1779 transform = mRotateAndCropPreviewTransform;
1780 }
1781 }
1782 SharedParameters::Lock l(mParameters);
1783 if (transform != l.mParameters.previewTransform &&
1784 getPreviewStreamId() != NO_STREAM) {
1785 mDevice->setStreamTransform(getPreviewStreamId(), transform);
1786 }
1787 l.mParameters.previewTransform = transform;
1788 return OK;
1789 }
1790
1791 status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1792 SharedParameters::Lock l(mParameters);
1793 if (enable) {
1794 l.mParameters.playShutterSound = true;
1795 return OK;
1796 }
1797
1798 l.mParameters.playShutterSound = false;
1799 return OK;
1800 }
1801
1802 status_t Camera2Client::commandPlayRecordingSoundL() {
1803 sCameraService->playSound(CameraService::SOUND_RECORDING_START);
1804 return OK;
1805 }
1806
1807 status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
1808 ALOGV("%s: Camera %d: Starting face detection",
1809 __FUNCTION__, mCameraId);
1810 status_t res;
1811 SharedParameters::Lock l(mParameters);
1812 switch (l.mParameters.state) {
1813 case Parameters::DISCONNECTED:
1814 case Parameters::STOPPED:
1815 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1816 case Parameters::STILL_CAPTURE:
1817 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1818 __FUNCTION__, mCameraId);
1819 return INVALID_OPERATION;
1820 case Parameters::PREVIEW:
1821 case Parameters::RECORD:
1822 case Parameters::VIDEO_SNAPSHOT:
1823 // Good to go for starting face detect
1824 break;
1825 }
1826 // Ignoring type
1827 if (l.mParameters.fastInfo.bestFaceDetectMode ==
1828 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
1829 ALOGE("%s: Camera %d: Face detection not supported",
1830 __FUNCTION__, mCameraId);
1831 return BAD_VALUE;
1832 }
1833 if (l.mParameters.enableFaceDetect) return OK;
1834
1835 l.mParameters.enableFaceDetect = true;
1836
1837 res = updateRequests(l.mParameters);
1838
1839 return res;
1840 }
1841
1842 status_t Camera2Client::commandStopFaceDetectionL(Parameters ¶ms) {
1843 status_t res = OK;
1844 ALOGV("%s: Camera %d: Stopping face detection",
1845 __FUNCTION__, mCameraId);
1846
1847 if (!params.enableFaceDetect) return OK;
1848
1849 params.enableFaceDetect = false;
1850
1851 if (params.state == Parameters::PREVIEW
1852 || params.state == Parameters::RECORD
1853 || params.state == Parameters::VIDEO_SNAPSHOT) {
1854 res = updateRequests(params);
1855 }
1856
1857 return res;
1858 }
1859
1860 status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1861 SharedParameters::Lock l(mParameters);
1862 l.mParameters.enableFocusMoveMessages = enable;
1863
1864 return OK;
1865 }
1866
1867 status_t Camera2Client::commandPingL() {
1868 // Always ping back if access is proper and device is alive
1869 SharedParameters::Lock l(mParameters);
1870 if (l.mParameters.state != Parameters::DISCONNECTED) {
1871 return OK;
1872 } else {
1873 return NO_INIT;
1874 }
1875 }
1876
1877 void Camera2Client::notifyError(int32_t errorCode,
1878 const CaptureResultExtras& resultExtras) {
1879 int32_t err = CAMERA_ERROR_UNKNOWN;
1880 switch(errorCode) {
1881 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED:
1882 err = CAMERA_ERROR_RELEASED;
1883 break;
1884 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE:
1885 err = CAMERA_ERROR_UNKNOWN;
1886 break;
1887 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE:
1888 err = CAMERA_ERROR_SERVER_DIED;
1889 break;
1890 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST:
1891 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT:
1892 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER:
1893 ALOGW("%s: Received recoverable error %d from HAL - ignoring, requestId %" PRId32,
1894 __FUNCTION__, errorCode, resultExtras.requestId);
1895
1896 if ((hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST == errorCode) ||
1897 (hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT == errorCode)) {
1898 Mutex::Autolock al(mLatestRequestMutex);
1899
1900 mLatestFailedRequestIds.add(resultExtras.requestId);
1901 mLatestRequestSignal.signal();
1902 }
1903 mCaptureSequencer->notifyError(errorCode, resultExtras);
1904 return;
1905 default:
1906 err = CAMERA_ERROR_UNKNOWN;
1907 break;
1908 }
1909
1910 ALOGE("%s: Error condition %d reported by HAL, requestId %" PRId32, __FUNCTION__, errorCode,
1911 resultExtras.requestId);
1912
1913 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1914 if (l.mRemoteCallback != nullptr) {
1915 l.mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, err, 0);
1916 }
1917 }
1918
1919
1920 /** Device-related methods */
1921 void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1922 ALOGV("%s: Autofocus state now %d, last trigger %d",
1923 __FUNCTION__, newState, triggerId);
1924 bool sendCompletedMessage = false;
1925 bool sendMovingMessage = false;
1926
1927 bool success = false;
1928 bool afInMotion = false;
1929 {
1930 SharedParameters::Lock l(mParameters);
1931 // Trace end of AF state
1932 char tmp[32];
1933 if (l.mParameters.afStateCounter > 0) {
1934 camera_metadata_enum_snprint(
1935 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1936 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1937 }
1938
1939 // Update state
1940 l.mParameters.focusState = newState;
1941 l.mParameters.afStateCounter++;
1942
1943 // Trace start of AF state
1944
1945 camera_metadata_enum_snprint(
1946 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1947 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1948
1949 switch (l.mParameters.focusMode) {
1950 case Parameters::FOCUS_MODE_AUTO:
1951 case Parameters::FOCUS_MODE_MACRO:
1952 // Don't send notifications upstream if they're not for the current AF
1953 // trigger. For example, if cancel was called in between, or if we
1954 // already sent a notification about this AF call.
1955 if (triggerId != l.mParameters.currentAfTriggerId) break;
1956 switch (newState) {
1957 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1958 success = true;
1959 FALLTHROUGH_INTENDED;
1960 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1961 sendCompletedMessage = true;
1962 l.mParameters.currentAfTriggerId = -1;
1963 break;
1964 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1965 // Just starting focusing, ignore
1966 break;
1967 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1968 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1969 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1970 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
1971 default:
1972 // Unexpected in AUTO/MACRO mode
1973 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1974 __FUNCTION__, newState);
1975 break;
1976 }
1977 break;
1978 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1979 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1980 switch (newState) {
1981 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1982 success = true;
1983 FALLTHROUGH_INTENDED;
1984 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1985 // Don't send notifications upstream if they're not for
1986 // the current AF trigger. For example, if cancel was
1987 // called in between, or if we already sent a
1988 // notification about this AF call.
1989 // Send both a 'AF done' callback and a 'AF move' callback
1990 if (triggerId != l.mParameters.currentAfTriggerId) break;
1991 sendCompletedMessage = true;
1992 afInMotion = false;
1993 if (l.mParameters.enableFocusMoveMessages &&
1994 l.mParameters.afInMotion) {
1995 sendMovingMessage = true;
1996 }
1997 l.mParameters.currentAfTriggerId = -1;
1998 break;
1999 case ANDROID_CONTROL_AF_STATE_INACTIVE:
2000 // Cancel was called, or we switched state; care if
2001 // currently moving
2002 afInMotion = false;
2003 if (l.mParameters.enableFocusMoveMessages &&
2004 l.mParameters.afInMotion) {
2005 sendMovingMessage = true;
2006 }
2007 break;
2008 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
2009 // Start passive scan, inform upstream
2010 afInMotion = true;
2011 FALLTHROUGH_INTENDED;
2012 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
2013 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
2014 // Stop passive scan, inform upstream
2015 if (l.mParameters.enableFocusMoveMessages) {
2016 sendMovingMessage = true;
2017 }
2018 break;
2019 }
2020 l.mParameters.afInMotion = afInMotion;
2021 break;
2022 case Parameters::FOCUS_MODE_EDOF:
2023 case Parameters::FOCUS_MODE_INFINITY:
2024 case Parameters::FOCUS_MODE_FIXED:
2025 default:
2026 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
2027 ALOGE("%s: Unexpected AF state change %d "
2028 "(ID %d) in focus mode %d",
2029 __FUNCTION__, newState, triggerId,
2030 l.mParameters.focusMode);
2031 }
2032 }
2033 }
2034 if (sendMovingMessage) {
2035 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
2036 if (l.mRemoteCallback != 0) {
2037 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
2038 afInMotion ? 1 : 0, 0);
2039 }
2040 }
2041 if (sendCompletedMessage) {
2042 ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
2043 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
2044 if (l.mRemoteCallback != 0) {
2045 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
2046 success ? 1 : 0, 0);
2047 }
2048 }
2049 }
2050
2051 void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
2052 ALOGV("%s: Autoexposure state now %d, last trigger %d",
2053 __FUNCTION__, newState, triggerId);
2054 {
2055 SharedParameters::Lock l(mParameters);
2056 // Update state
2057 l.mParameters.aeState = newState;
2058 }
2059 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
2060 }
2061
2062 void Camera2Client::notifyShutter(const CaptureResultExtras& resultExtras,
2063 nsecs_t timestamp) {
2064 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64,
2065 __FUNCTION__, resultExtras.requestId, timestamp);
2066 mCaptureSequencer->notifyShutter(resultExtras, timestamp);
2067
2068 Camera2ClientBase::notifyShutter(resultExtras, timestamp);
2069 }
2070
2071 camera2::SharedParameters& Camera2Client::getParameters() {
2072 return mParameters;
2073 }
2074
2075 int Camera2Client::getPreviewStreamId() const {
2076 return mStreamingProcessor->getPreviewStreamId();
2077 }
2078
2079 int Camera2Client::getCaptureStreamId() const {
2080 return mJpegProcessor->getStreamId();
2081 }
2082
2083 int Camera2Client::getCallbackStreamId() const {
2084 return mCallbackProcessor->getStreamId();
2085 }
2086
2087 int Camera2Client::getRecordingStreamId() const {
2088 return mStreamingProcessor->getRecordingStreamId();
2089 }
2090
2091 int Camera2Client::getZslStreamId() const {
2092 return mZslProcessor->getStreamId();
2093 }
2094
2095 status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
2096 const wp<camera2::FrameProcessor::FilteredListener>& listener, bool sendPartials) {
2097 return mFrameProcessor->registerListener(minId, maxId, listener, sendPartials);
2098 }
2099
2100 status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
2101 const wp<camera2::FrameProcessor::FilteredListener>& listener) {
2102 return mFrameProcessor->removeListener(minId, maxId, listener);
2103 }
2104
2105 status_t Camera2Client::stopStream() {
2106 return mStreamingProcessor->stopStream();
2107 }
2108
2109 status_t Camera2Client::createJpegStreamL(Parameters ¶ms) {
2110 status_t res = OK;
2111 int lastJpegStreamId = mJpegProcessor->getStreamId();
2112 if (lastJpegStreamId != NO_STREAM) {
2113 return INVALID_OPERATION;
2114 }
2115
2116 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2117 if (res != OK) {
2118 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2119 __FUNCTION__, mCameraId, strerror(-res), res);
2120 return res;
2121 }
2122
2123 res = mDevice->flush();
2124 if (res != OK) {
2125 ALOGE("%s: Camera %d: Unable flush device: %s (%d)",
2126 __FUNCTION__, mCameraId, strerror(-res), res);
2127 return res;
2128 }
2129
2130 // Ideally we don't need this, but current camera device
2131 // status tracking mechanism demands it.
2132 res = mDevice->waitUntilDrained();
2133 if (res != OK) {
2134 ALOGE("%s: Camera %d: Waiting device drain failed: %s (%d)",
2135 __FUNCTION__, mCameraId, strerror(-res), res);
2136 }
2137
2138 res = updateProcessorStream(mJpegProcessor, params);
2139 return res;
2140 }
2141
2142 const int32_t Camera2Client::kPreviewRequestIdStart;
2143 const int32_t Camera2Client::kPreviewRequestIdEnd;
2144 const int32_t Camera2Client::kRecordingRequestIdStart;
2145 const int32_t Camera2Client::kRecordingRequestIdEnd;
2146 const int32_t Camera2Client::kCaptureRequestIdStart;
2147 const int32_t Camera2Client::kCaptureRequestIdEnd;
2148
2149 /** Utility methods */
2150
2151 status_t Camera2Client::updateRequests(Parameters ¶ms) {
2152 status_t res;
2153
2154 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
2155
2156 res = mStreamingProcessor->incrementStreamingIds();
2157 if (res != OK) {
2158 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
2159 __FUNCTION__, mCameraId, strerror(-res), res);
2160 return res;
2161 }
2162
2163 res = mStreamingProcessor->updatePreviewRequest(params);
2164 if (res != OK) {
2165 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
2166 __FUNCTION__, mCameraId, strerror(-res), res);
2167 return res;
2168 }
2169 res = mStreamingProcessor->updateRecordingRequest(params);
2170 if (res != OK) {
2171 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
2172 __FUNCTION__, mCameraId, strerror(-res), res);
2173 return res;
2174 }
2175
2176 if (params.state == Parameters::PREVIEW) {
2177 res = startPreviewL(params, true);
2178 if (res != OK) {
2179 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
2180 __FUNCTION__, mCameraId, strerror(-res), res);
2181 return res;
2182 }
2183 } else if (params.state == Parameters::RECORD ||
2184 params.state == Parameters::VIDEO_SNAPSHOT) {
2185 res = startRecordingL(params, true);
2186 if (res != OK) {
2187 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
2188 __FUNCTION__, mCameraId, strerror(-res), res);
2189 return res;
2190 }
2191 }
2192 return res;
2193 }
2194
2195
2196 size_t Camera2Client::calculateBufferSize(int width, int height,
2197 int format, int stride) {
2198 switch (format) {
2199 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
2200 return width * height * 2;
2201 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
2202 return width * height * 3 / 2;
2203 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
2204 return width * height * 2;
2205 case HAL_PIXEL_FORMAT_YV12: { // YV12
2206 size_t ySize = stride * height;
2207 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
2208 size_t uvSize = uvStride * height / 2;
2209 return ySize + uvSize * 2;
2210 }
2211 case HAL_PIXEL_FORMAT_RGB_565:
2212 return width * height * 2;
2213 case HAL_PIXEL_FORMAT_RGBA_8888:
2214 return width * height * 4;
2215 case HAL_PIXEL_FORMAT_RAW16:
2216 return width * height * 2;
2217 default:
2218 ALOGE("%s: Unknown preview format: %x",
2219 __FUNCTION__, format);
2220 return 0;
2221 }
2222 }
2223
2224 status_t Camera2Client::syncWithDevice() {
2225 ATRACE_CALL();
2226 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
2227 status_t res;
2228
2229 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
2230 if (activeRequestId == 0) return OK;
2231
2232 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
2233 if (res == TIMED_OUT) {
2234 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
2235 __FUNCTION__, mCameraId);
2236 } else if (res != OK) {
2237 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
2238 __FUNCTION__, mCameraId);
2239 }
2240 return res;
2241 }
2242
2243 template <typename ProcessorT>
2244 status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2245 camera2::Parameters params) {
2246 // No default template arguments until C++11, so we need this overload
2247 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
2248 processor, params);
2249 }
2250
2251 template <typename ProcessorT,
2252 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
2253 status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2254 Parameters params) {
2255 status_t res;
2256
2257 // Get raw pointer since sp<T> doesn't have operator->*
2258 ProcessorT *processorPtr = processor.get();
2259 res = (processorPtr->*updateStreamF)(params);
2260
2261 /**
2262 * Can't update the stream if it's busy?
2263 *
2264 * Then we need to stop the device (by temporarily clearing the request
2265 * queue) and then try again. Resume streaming once we're done.
2266 */
2267 if (res == -EBUSY) {
2268 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
2269 mCameraId);
2270 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2271 if (res != OK) {
2272 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2273 __FUNCTION__, mCameraId, strerror(-res), res);
2274 }
2275
2276 res = mDevice->waitUntilDrained();
2277 if (res != OK) {
2278 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
2279 __FUNCTION__, mCameraId, strerror(-res), res);
2280 }
2281
2282 res = (processorPtr->*updateStreamF)(params);
2283 if (res != OK) {
2284 ALOGE("%s: Camera %d: Failed to update processing stream "
2285 " despite having halted streaming first: %s (%d)",
2286 __FUNCTION__, mCameraId, strerror(-res), res);
2287 }
2288
2289 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
2290 if (res != OK) {
2291 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
2292 __FUNCTION__, mCameraId, strerror(-res), res);
2293 }
2294 }
2295
2296 return res;
2297 }
2298
2299 status_t Camera2Client::overrideVideoSnapshotSize(Parameters ¶ms) {
2300 ALOGV("%s: Camera %d: configure still size to video size before recording"
2301 , __FUNCTION__, mCameraId);
2302 params.overrideJpegSizeByVideoSize();
2303 status_t res = updateProcessorStream(mJpegProcessor, params);
2304 if (res != OK) {
2305 ALOGE("%s: Camera %d: Can't override video snapshot size to video size: %s (%d)",
2306 __FUNCTION__, mCameraId, strerror(-res), res);
2307 }
2308 return res;
2309 }
2310
2311 status_t Camera2Client::setVideoTarget(const sp<SurfaceType>& target) {
2312 ATRACE_CALL();
2313 ALOGV("%s: E", __FUNCTION__);
2314 Mutex::Autolock icl(mBinderSerializationLock);
2315 status_t res;
2316 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
2317
2318 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
2319 uint64_t videoSurfaceID;
2320 res = target->getUniqueId(&videoSurfaceID);
2321 if (res != OK) {
2322 ALOGE("%s: Camera %d: Could not getUniqueId in setVideoTarget.", __FUNCTION__, mCameraId);
2323 return res;
2324 }
2325 if (videoSurfaceID == mVideoSurfaceID) {
2326 ALOGE("%s: Camera %d: New video window is same as old video window", __FUNCTION__,
2327 mCameraId);
2328 return NO_ERROR;
2329 }
2330 #else
2331 sp<IBinder> binder = IInterface::asBinder(target);
2332 if (binder == mVideoSurface) {
2333 ALOGV("%s: Camera %d: New video window is same as old video window",
2334 __FUNCTION__, mCameraId);
2335 return NO_ERROR;
2336 }
2337 #endif
2338
2339 sp<Surface> window;
2340 int format;
2341 android_dataspace dataSpace;
2342
2343 if (target != nullptr) {
2344 // Using controlledByApp flag to ensure that the buffer queue remains in
2345 // async mode for the old camera API, where many applications depend
2346 // on that behavior.
2347 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
2348 window = new Surface(target->getIGraphicBufferProducer(), /*controlledByApp*/ true);
2349 #else
2350 window = new Surface(target, /*controlledByApp*/ true);
2351 #endif
2352
2353 ANativeWindow *anw = window.get();
2354
2355 if ((res = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) {
2356 ALOGE("%s: Failed to query Surface format", __FUNCTION__);
2357 return res;
2358 }
2359
2360 if ((res = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE,
2361 reinterpret_cast<int*>(&dataSpace))) != OK) {
2362 ALOGE("%s: Failed to query Surface dataSpace", __FUNCTION__);
2363 return res;
2364 }
2365 }
2366
2367 Parameters::State state;
2368 {
2369 SharedParameters::Lock l(mParameters);
2370 state = l.mParameters.state;
2371 }
2372
2373 switch (state) {
2374 case Parameters::STOPPED:
2375 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
2376 case Parameters::PREVIEW:
2377 // OK
2378 break;
2379 case Parameters::DISCONNECTED:
2380 case Parameters::RECORD:
2381 case Parameters::STILL_CAPTURE:
2382 case Parameters::VIDEO_SNAPSHOT:
2383 default:
2384 ALOGE("%s: Camera %d: Cannot set video target while in state %s",
2385 __FUNCTION__, mCameraId,
2386 Parameters::getStateName(state));
2387 return INVALID_OPERATION;
2388 }
2389
2390 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
2391 mVideoSurfaceID = videoSurfaceID;
2392 #else
2393 mVideoSurface = binder;
2394 #endif
2395 res = mStreamingProcessor->setRecordingWindow(window);
2396 if (res != OK) {
2397 ALOGE("%s: Unable to set new recording window: %s (%d)",
2398 __FUNCTION__, strerror(-res), res);
2399 return res;
2400 }
2401
2402 {
2403 SharedParameters::Lock l(mParameters);
2404 l.mParameters.videoFormat = format;
2405 l.mParameters.videoDataSpace = dataSpace;
2406 }
2407
2408 return OK;
2409 }
2410
2411 status_t Camera2Client::setAudioRestriction(int /*mode*/) {
2412 // Empty implementation. setAudioRestriction is hidden interface and not
2413 // supported by android.hardware.Camera API
2414 return INVALID_OPERATION;
2415 }
2416
2417 int32_t Camera2Client::getGlobalAudioRestriction() {
2418 // Empty implementation. getAudioRestriction is hidden interface and not
2419 // supported by android.hardware.Camera API
2420 return INVALID_OPERATION;
2421 }
2422
2423 status_t Camera2Client::setCameraServiceWatchdog(bool enabled) {
2424 return mDevice->setCameraServiceWatchdog(enabled);
2425 }
2426
2427 status_t Camera2Client::setRotateAndCropOverride(uint8_t rotateAndCrop, bool fromHal) {
2428 if (rotateAndCrop > ANDROID_SCALER_ROTATE_AND_CROP_AUTO) return BAD_VALUE;
2429
2430 {
2431 Mutex::Autolock icl(mRotateAndCropLock);
2432 if (mRotateAndCropIsSupported) {
2433 mRotateAndCropMode = rotateAndCrop;
2434 } else {
2435 mRotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
2436 return OK;
2437 }
2438 }
2439
2440 return mDevice->setRotateAndCropAutoBehavior(
2441 static_cast<camera_metadata_enum_android_scaler_rotate_and_crop_t>(rotateAndCrop), fromHal);
2442 }
2443
2444 status_t Camera2Client::setAutoframingOverride(uint8_t autoframingValue) {
2445 if (autoframingValue > ANDROID_CONTROL_AUTOFRAMING_AUTO) return BAD_VALUE;
2446
2447 return mDevice->setAutoframingAutoBehavior(
2448 static_cast<camera_metadata_enum_android_control_autoframing_t>(autoframingValue));
2449 }
2450
2451 bool Camera2Client::supportsCameraMute() {
2452 return mDevice->supportsCameraMute();
2453 }
2454
2455 status_t Camera2Client::setCameraMute(bool enabled) {
2456 return mDevice->setCameraMute(enabled);
2457 }
2458
2459 void Camera2Client::setStreamUseCaseOverrides(
2460 const std::vector<int64_t>& useCaseOverrides) {
2461 mDevice->setStreamUseCaseOverrides(useCaseOverrides);
2462 }
2463
2464 void Camera2Client::clearStreamUseCaseOverrides() {
2465 mDevice->clearStreamUseCaseOverrides();
2466 }
2467
2468 bool Camera2Client::supportsZoomOverride() {
2469 return mDevice->supportsZoomOverride();
2470 }
2471
2472 status_t Camera2Client::setZoomOverride(int zoomOverride) {
2473 return mDevice->setZoomOverride(zoomOverride);
2474 }
2475
2476 status_t Camera2Client::waitUntilCurrentRequestIdLocked() {
2477 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
2478 if (activeRequestId != 0) {
2479 auto res = waitUntilRequestIdApplied(activeRequestId,
2480 mDevice->getExpectedInFlightDuration());
2481 if (res == TIMED_OUT) {
2482 ALOGE("%s: Camera %d: Timed out waiting for current request id to return in results!",
2483 __FUNCTION__, mCameraId);
2484 return res;
2485 } else if (res != OK) {
2486 ALOGE("%s: Camera %d: Error while waiting for current request id to return in results!",
2487 __FUNCTION__, mCameraId);
2488 return res;
2489 }
2490 }
2491
2492 return OK;
2493 }
2494
2495 status_t Camera2Client::waitUntilRequestIdApplied(int32_t requestId, nsecs_t timeout) {
2496 Mutex::Autolock l(mLatestRequestMutex);
2497 while ((std::find(mLatestRequestIds.begin(), mLatestRequestIds.end(), requestId) ==
2498 mLatestRequestIds.end()) &&
2499 (std::find(mLatestFailedRequestIds.begin(), mLatestFailedRequestIds.end(), requestId) ==
2500 mLatestFailedRequestIds.end())) {
2501 nsecs_t startTime = systemTime();
2502
2503 auto res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout);
2504 if (res != OK) return res;
2505
2506 timeout -= (systemTime() - startTime);
2507 }
2508
2509 return (std::find(mLatestRequestIds.begin(), mLatestRequestIds.end(), requestId) !=
2510 mLatestRequestIds.end()) ? OK : DEAD_OBJECT;
2511 }
2512
2513 void Camera2Client::notifyRequestId(int32_t requestId) {
2514 Mutex::Autolock al(mLatestRequestMutex);
2515
2516 mLatestRequestIds.add(requestId);
2517 mLatestRequestSignal.signal();
2518 }
2519
2520 const char* Camera2Client::kAutofocusLabel = "autofocus";
2521 const char* Camera2Client::kTakepictureLabel = "take_picture";
2522
2523 } // namespace android
2524