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