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