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