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 "Camera2"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 //#define LOG_NDEBUG 0
20
21 #include <utils/Log.h>
22 #include <utils/Trace.h>
23
24 #include <cutils/properties.h>
25 #include <gui/Surface.h>
26 #include "camera2/Parameters.h"
27 #include "Camera2Client.h"
28 #include "Camera2Device.h"
29 #include "Camera3Device.h"
30
31 #include "camera2/ZslProcessor.h"
32 #include "camera2/ZslProcessor3.h"
33
34 #define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
35 #define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
36
37 namespace android {
38 using namespace camera2;
39
getCallingPid()40 static int getCallingPid() {
41 return IPCThreadState::self()->getCallingPid();
42 }
43
44 // Interface used by CameraService
45
Camera2Client(const sp<CameraService> & cameraService,const sp<ICameraClient> & cameraClient,const String16 & clientPackageName,int cameraId,int cameraFacing,int clientPid,uid_t clientUid,int servicePid,int deviceVersion)46 Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
47 const sp<ICameraClient>& cameraClient,
48 const String16& clientPackageName,
49 int cameraId,
50 int cameraFacing,
51 int clientPid,
52 uid_t clientUid,
53 int servicePid,
54 int deviceVersion):
55 Camera2ClientBase(cameraService, cameraClient, clientPackageName,
56 cameraId, cameraFacing, clientPid, clientUid, servicePid),
57 mParameters(cameraId, cameraFacing),
58 mDeviceVersion(deviceVersion)
59 {
60 ATRACE_CALL();
61 ALOGI("Camera %d: Opened", cameraId);
62
63 switch (mDeviceVersion) {
64 case CAMERA_DEVICE_API_VERSION_2_0:
65 mDevice = new Camera2Device(cameraId);
66 break;
67 case CAMERA_DEVICE_API_VERSION_3_0:
68 mDevice = new Camera3Device(cameraId);
69 break;
70 default:
71 ALOGE("Camera %d: Unknown HAL device version %d",
72 cameraId, mDeviceVersion);
73 mDevice = NULL;
74 break;
75 }
76
77
78 SharedParameters::Lock l(mParameters);
79 l.mParameters.state = Parameters::DISCONNECTED;
80 }
81
initialize(camera_module_t * module)82 status_t Camera2Client::initialize(camera_module_t *module)
83 {
84 ATRACE_CALL();
85 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
86 status_t res;
87
88 res = Camera2ClientBase::initialize(module);
89 if (res != OK) {
90 return res;
91 }
92
93 SharedParameters::Lock l(mParameters);
94
95 res = l.mParameters.initialize(&(mDevice->info()));
96 if (res != OK) {
97 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
98 __FUNCTION__, mCameraId, strerror(-res), res);
99 return NO_INIT;
100 }
101
102 String8 threadName;
103
104 mStreamingProcessor = new StreamingProcessor(this);
105 threadName = String8::format("C2-%d-StreamProc",
106 mCameraId);
107 mStreamingProcessor->run(threadName.string());
108
109 mFrameProcessor = new FrameProcessor(mDevice, this);
110 threadName = String8::format("C2-%d-FrameProc",
111 mCameraId);
112 mFrameProcessor->run(threadName.string());
113
114 mCaptureSequencer = new CaptureSequencer(this);
115 threadName = String8::format("C2-%d-CaptureSeq",
116 mCameraId);
117 mCaptureSequencer->run(threadName.string());
118
119 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
120 threadName = String8::format("C2-%d-JpegProc",
121 mCameraId);
122 mJpegProcessor->run(threadName.string());
123
124 switch (mDeviceVersion) {
125 case CAMERA_DEVICE_API_VERSION_2_0: {
126 sp<ZslProcessor> zslProc =
127 new ZslProcessor(this, mCaptureSequencer);
128 mZslProcessor = zslProc;
129 mZslProcessorThread = zslProc;
130 break;
131 }
132 case CAMERA_DEVICE_API_VERSION_3_0:{
133 sp<ZslProcessor3> zslProc =
134 new ZslProcessor3(this, mCaptureSequencer);
135 mZslProcessor = zslProc;
136 mZslProcessorThread = zslProc;
137 break;
138 }
139 default:
140 break;
141 }
142 threadName = String8::format("C2-%d-ZslProc",
143 mCameraId);
144 mZslProcessorThread->run(threadName.string());
145
146 mCallbackProcessor = new CallbackProcessor(this);
147 threadName = String8::format("C2-%d-CallbkProc",
148 mCameraId);
149 mCallbackProcessor->run(threadName.string());
150
151 if (gLogLevel >= 1) {
152 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
153 mCameraId);
154 ALOGD("%s", l.mParameters.paramsFlattened.string());
155 }
156
157 return OK;
158 }
159
~Camera2Client()160 Camera2Client::~Camera2Client() {
161 ATRACE_CALL();
162 ALOGV("~Camera2Client");
163
164 mDestructionStarted = true;
165
166 disconnect();
167
168 ALOGI("Camera %d: Closed", mCameraId);
169 }
170
dump(int fd,const Vector<String16> & args)171 status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
172 String8 result;
173 result.appendFormat("Client2[%d] (%p) Client: %s PID: %d, dump:\n",
174 mCameraId,
175 getRemoteCallback()->asBinder().get(),
176 String8(mClientPackageName).string(),
177 mClientPid);
178 result.append(" State: ");
179 #define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
180
181 const Parameters& p = mParameters.unsafeAccess();
182
183 result.append(Parameters::getStateName(p.state));
184
185 result.append("\n Current parameters:\n");
186 result.appendFormat(" Preview size: %d x %d\n",
187 p.previewWidth, p.previewHeight);
188 result.appendFormat(" Preview FPS range: %d - %d\n",
189 p.previewFpsRange[0], p.previewFpsRange[1]);
190 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
191 p.previewFormat);
192 result.appendFormat(" Preview transform: %x\n",
193 p.previewTransform);
194 result.appendFormat(" Picture size: %d x %d\n",
195 p.pictureWidth, p.pictureHeight);
196 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
197 p.jpegThumbSize[0], p.jpegThumbSize[1]);
198 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
199 p.jpegQuality, p.jpegThumbQuality);
200 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
201 result.appendFormat(" GPS tags %s\n",
202 p.gpsEnabled ? "enabled" : "disabled");
203 if (p.gpsEnabled) {
204 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
205 p.gpsCoordinates[0], p.gpsCoordinates[1],
206 p.gpsCoordinates[2]);
207 result.appendFormat(" GPS timestamp: %lld\n",
208 p.gpsTimestamp);
209 result.appendFormat(" GPS processing method: %s\n",
210 p.gpsProcessingMethod.string());
211 }
212
213 result.append(" White balance mode: ");
214 switch (p.wbMode) {
215 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
216 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
217 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
218 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
219 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
220 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
221 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
223 default: result.append("UNKNOWN\n");
224 }
225
226 result.append(" Effect mode: ");
227 switch (p.effectMode) {
228 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
229 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
230 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
231 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
232 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
233 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
234 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
235 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
236 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
237 default: result.append("UNKNOWN\n");
238 }
239
240 result.append(" Antibanding mode: ");
241 switch (p.antibandingMode) {
242 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
243 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
244 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
245 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
246 default: result.append("UNKNOWN\n");
247 }
248
249 result.append(" Scene mode: ");
250 switch (p.sceneMode) {
251 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
252 result.append("AUTO\n"); break;
253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
255 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
258 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
259 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
260 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
261 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
262 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
263 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
264 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
265 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
266 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
267 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
268 default: result.append("UNKNOWN\n");
269 }
270
271 result.append(" Flash mode: ");
272 switch (p.flashMode) {
273 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
274 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
275 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
276 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
277 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
278 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
279 default: result.append("UNKNOWN\n");
280 }
281
282 result.append(" Focus mode: ");
283 switch (p.focusMode) {
284 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
285 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
286 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
287 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
288 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
289 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
290 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
291 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
292 default: result.append("UNKNOWN\n");
293 }
294
295 result.append(" Focus state: ");
296 switch (p.focusState) {
297 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
298 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
299 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
300 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
301 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
302 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
303 default: result.append("UNKNOWN\n");
304 }
305
306 result.append(" Focusing areas:\n");
307 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
308 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
309 p.focusingAreas[i].left,
310 p.focusingAreas[i].top,
311 p.focusingAreas[i].right,
312 p.focusingAreas[i].bottom,
313 p.focusingAreas[i].weight);
314 }
315
316 result.appendFormat(" Exposure compensation index: %d\n",
317 p.exposureCompensation);
318
319 result.appendFormat(" AE lock %s, AWB lock %s\n",
320 p.autoExposureLock ? "enabled" : "disabled",
321 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
322
323 result.appendFormat(" Metering areas:\n");
324 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
325 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
326 p.meteringAreas[i].left,
327 p.meteringAreas[i].top,
328 p.meteringAreas[i].right,
329 p.meteringAreas[i].bottom,
330 p.meteringAreas[i].weight);
331 }
332
333 result.appendFormat(" Zoom index: %d\n", p.zoom);
334 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
335 p.videoHeight);
336
337 result.appendFormat(" Recording hint is %s\n",
338 p.recordingHint ? "set" : "not set");
339
340 result.appendFormat(" Video stabilization is %s\n",
341 p.videoStabilization ? "enabled" : "disabled");
342
343 result.append(" Current streams:\n");
344 result.appendFormat(" Preview stream ID: %d\n",
345 getPreviewStreamId());
346 result.appendFormat(" Capture stream ID: %d\n",
347 getCaptureStreamId());
348 result.appendFormat(" Recording stream ID: %d\n",
349 getRecordingStreamId());
350
351 result.append(" Quirks for this camera:\n");
352 bool haveQuirk = false;
353 if (p.quirks.triggerAfWithAuto) {
354 result.appendFormat(" triggerAfWithAuto\n");
355 haveQuirk = true;
356 }
357 if (p.quirks.useZslFormat) {
358 result.appendFormat(" useZslFormat\n");
359 haveQuirk = true;
360 }
361 if (p.quirks.meteringCropRegion) {
362 result.appendFormat(" meteringCropRegion\n");
363 haveQuirk = true;
364 }
365 if (!haveQuirk) {
366 result.appendFormat(" none\n");
367 }
368
369 write(fd, result.string(), result.size());
370
371 mStreamingProcessor->dump(fd, args);
372
373 mCaptureSequencer->dump(fd, args);
374
375 mFrameProcessor->dump(fd, args);
376
377 mZslProcessor->dump(fd, args);
378
379 return dumpDevice(fd, args);
380 #undef CASE_APPEND_ENUM
381 }
382
383 // ICamera interface
384
disconnect()385 void Camera2Client::disconnect() {
386 ATRACE_CALL();
387 Mutex::Autolock icl(mBinderSerializationLock);
388
389 // Allow both client and the media server to disconnect at all times
390 int callingPid = getCallingPid();
391 if (callingPid != mClientPid && callingPid != mServicePid) return;
392
393 if (mDevice == 0) return;
394
395 ALOGV("Camera %d: Shutting down", mCameraId);
396
397 /**
398 * disconnect() cannot call any methods that might need to promote a
399 * wp<Camera2Client>, since disconnect can be called from the destructor, at
400 * which point all such promotions will fail.
401 */
402
403 stopPreviewL();
404
405 {
406 SharedParameters::Lock l(mParameters);
407 if (l.mParameters.state == Parameters::DISCONNECTED) return;
408 l.mParameters.state = Parameters::DISCONNECTED;
409 }
410
411 mStreamingProcessor->deletePreviewStream();
412 mStreamingProcessor->deleteRecordingStream();
413 mJpegProcessor->deleteStream();
414 mCallbackProcessor->deleteStream();
415 mZslProcessor->deleteStream();
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 mStreamingProcessor->join();
427 mFrameProcessor->join();
428 mCaptureSequencer->join();
429 mJpegProcessor->join();
430 mZslProcessorThread->join();
431 mCallbackProcessor->join();
432
433 ALOGV("Camera %d: Disconnecting device", mCameraId);
434
435 mDevice->disconnect();
436
437 mDevice.clear();
438
439 CameraService::Client::disconnect();
440 }
441
connect(const sp<ICameraClient> & client)442 status_t Camera2Client::connect(const sp<ICameraClient>& client) {
443 ATRACE_CALL();
444 ALOGV("%s: E", __FUNCTION__);
445 Mutex::Autolock icl(mBinderSerializationLock);
446
447 if (mClientPid != 0 && getCallingPid() != mClientPid) {
448 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
449 "current locked to pid %d", __FUNCTION__,
450 mCameraId, getCallingPid(), mClientPid);
451 return BAD_VALUE;
452 }
453
454 mClientPid = getCallingPid();
455
456 mRemoteCallback = client;
457 mSharedCameraCallbacks = client;
458
459 return OK;
460 }
461
lock()462 status_t Camera2Client::lock() {
463 ATRACE_CALL();
464 ALOGV("%s: E", __FUNCTION__);
465 Mutex::Autolock icl(mBinderSerializationLock);
466 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
467 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
468
469 if (mClientPid == 0) {
470 mClientPid = getCallingPid();
471 return OK;
472 }
473
474 if (mClientPid != getCallingPid()) {
475 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
476 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
477 return EBUSY;
478 }
479
480 return OK;
481 }
482
unlock()483 status_t Camera2Client::unlock() {
484 ATRACE_CALL();
485 ALOGV("%s: E", __FUNCTION__);
486 Mutex::Autolock icl(mBinderSerializationLock);
487 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
488 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
489
490 if (mClientPid == getCallingPid()) {
491 SharedParameters::Lock l(mParameters);
492 if (l.mParameters.state == Parameters::RECORD ||
493 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
494 ALOGD("Not allowed to unlock camera during recording.");
495 return INVALID_OPERATION;
496 }
497 mClientPid = 0;
498 mRemoteCallback.clear();
499 mSharedCameraCallbacks.clear();
500 return OK;
501 }
502
503 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
504 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
505 return EBUSY;
506 }
507
setPreviewDisplay(const sp<Surface> & surface)508 status_t Camera2Client::setPreviewDisplay(
509 const sp<Surface>& surface) {
510 ATRACE_CALL();
511 ALOGV("%s: E", __FUNCTION__);
512 Mutex::Autolock icl(mBinderSerializationLock);
513 status_t res;
514 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
515
516 sp<IBinder> binder;
517 sp<ANativeWindow> window;
518 if (surface != 0) {
519 binder = surface->getIGraphicBufferProducer()->asBinder();
520 window = surface;
521 }
522
523 return setPreviewWindowL(binder,window);
524 }
525
setPreviewTexture(const sp<IGraphicBufferProducer> & bufferProducer)526 status_t Camera2Client::setPreviewTexture(
527 const sp<IGraphicBufferProducer>& bufferProducer) {
528 ATRACE_CALL();
529 ALOGV("%s: E", __FUNCTION__);
530 Mutex::Autolock icl(mBinderSerializationLock);
531 status_t res;
532 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
533
534 sp<IBinder> binder;
535 sp<ANativeWindow> window;
536 if (bufferProducer != 0) {
537 binder = bufferProducer->asBinder();
538 window = new Surface(bufferProducer);
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 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
615 ALOGV("%s: setting oneshot", __FUNCTION__);
616 params.previewCallbackOneShot = true;
617 }
618 if (params.previewCallbackFlags != (uint32_t)flag) {
619 params.previewCallbackFlags = flag;
620 switch(params.state) {
621 case Parameters::PREVIEW:
622 res = startPreviewL(params, true);
623 break;
624 case Parameters::RECORD:
625 case Parameters::VIDEO_SNAPSHOT:
626 res = startRecordingL(params, true);
627 break;
628 default:
629 break;
630 }
631 if (res != OK) {
632 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
633 __FUNCTION__, mCameraId,
634 Parameters::getStateName(params.state));
635 }
636 }
637
638 }
639
startPreview()640 status_t Camera2Client::startPreview() {
641 ATRACE_CALL();
642 ALOGV("%s: E", __FUNCTION__);
643 Mutex::Autolock icl(mBinderSerializationLock);
644 status_t res;
645 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
646 SharedParameters::Lock l(mParameters);
647 return startPreviewL(l.mParameters, false);
648 }
649
startPreviewL(Parameters & params,bool restart)650 status_t Camera2Client::startPreviewL(Parameters ¶ms, bool restart) {
651 ATRACE_CALL();
652 status_t res;
653
654 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
655
656 if ( (params.state == Parameters::PREVIEW ||
657 params.state == Parameters::RECORD ||
658 params.state == Parameters::VIDEO_SNAPSHOT)
659 && !restart) {
660 // Succeed attempt to re-enter a streaming state
661 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
662 __FUNCTION__, mCameraId);
663 return OK;
664 }
665 if (params.state > Parameters::PREVIEW && !restart) {
666 ALOGE("%s: Can't start preview in state %s",
667 __FUNCTION__,
668 Parameters::getStateName(params.state));
669 return INVALID_OPERATION;
670 }
671
672 if (!mStreamingProcessor->haveValidPreviewWindow()) {
673 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
674 return OK;
675 }
676 params.state = Parameters::STOPPED;
677
678 res = mStreamingProcessor->updatePreviewStream(params);
679 if (res != OK) {
680 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
681 __FUNCTION__, mCameraId, strerror(-res), res);
682 return res;
683 }
684
685 Vector<uint8_t> outputStreams;
686 bool callbacksEnabled = params.previewCallbackFlags &
687 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
688 if (callbacksEnabled) {
689 res = mCallbackProcessor->updateStream(params);
690 if (res != OK) {
691 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
692 __FUNCTION__, mCameraId, strerror(-res), res);
693 return res;
694 }
695 outputStreams.push(getCallbackStreamId());
696 }
697 if (params.zslMode && !params.recordingHint) {
698 res = updateProcessorStream(mZslProcessor, params);
699 if (res != OK) {
700 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
701 __FUNCTION__, mCameraId, strerror(-res), res);
702 return res;
703 }
704 outputStreams.push(getZslStreamId());
705 }
706
707 outputStreams.push(getPreviewStreamId());
708
709 if (!params.recordingHint) {
710 if (!restart) {
711 res = mStreamingProcessor->updatePreviewRequest(params);
712 if (res != OK) {
713 ALOGE("%s: Camera %d: Can't set up preview request: "
714 "%s (%d)", __FUNCTION__, mCameraId,
715 strerror(-res), res);
716 return res;
717 }
718 }
719 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
720 outputStreams);
721 } else {
722 // With recording hint set, we're going to be operating under the
723 // assumption that the user will record video. To optimize recording
724 // startup time, create the necessary output streams for recording and
725 // video snapshot now if they don't already exist.
726 res = updateProcessorStream(mJpegProcessor, params);
727 if (res != OK) {
728 ALOGE("%s: Camera %d: Can't pre-configure still image "
729 "stream: %s (%d)",
730 __FUNCTION__, mCameraId, strerror(-res), res);
731 return res;
732 }
733
734 if (!restart) {
735 res = mStreamingProcessor->updateRecordingRequest(params);
736 if (res != OK) {
737 ALOGE("%s: Camera %d: Can't set up preview request with "
738 "record hint: %s (%d)", __FUNCTION__, mCameraId,
739 strerror(-res), res);
740 return res;
741 }
742 }
743 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
744 outputStreams);
745 }
746 if (res != OK) {
747 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
748 __FUNCTION__, mCameraId, strerror(-res), res);
749 return res;
750 }
751
752 params.state = Parameters::PREVIEW;
753 return OK;
754 }
755
stopPreview()756 void Camera2Client::stopPreview() {
757 ATRACE_CALL();
758 ALOGV("%s: E", __FUNCTION__);
759 Mutex::Autolock icl(mBinderSerializationLock);
760 status_t res;
761 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
762 stopPreviewL();
763 }
764
stopPreviewL()765 void Camera2Client::stopPreviewL() {
766 ATRACE_CALL();
767 status_t res;
768 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
769 Parameters::State state;
770 {
771 SharedParameters::Lock l(mParameters);
772 state = l.mParameters.state;
773 }
774
775 switch (state) {
776 case Parameters::DISCONNECTED:
777 // Nothing to do.
778 break;
779 case Parameters::STOPPED:
780 case Parameters::VIDEO_SNAPSHOT:
781 case Parameters::STILL_CAPTURE:
782 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
783 // no break
784 case Parameters::RECORD:
785 case Parameters::PREVIEW:
786 res = stopStream();
787 if (res != OK) {
788 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
789 __FUNCTION__, mCameraId, strerror(-res), res);
790 }
791 res = mDevice->waitUntilDrained();
792 if (res != OK) {
793 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
794 __FUNCTION__, mCameraId, strerror(-res), res);
795 }
796 // no break
797 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
798 SharedParameters::Lock l(mParameters);
799 l.mParameters.state = Parameters::STOPPED;
800 commandStopFaceDetectionL(l.mParameters);
801 break;
802 }
803 default:
804 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
805 state);
806 }
807 }
808
previewEnabled()809 bool Camera2Client::previewEnabled() {
810 ATRACE_CALL();
811 Mutex::Autolock icl(mBinderSerializationLock);
812 status_t res;
813 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
814
815 SharedParameters::Lock l(mParameters);
816 return l.mParameters.state == Parameters::PREVIEW;
817 }
818
storeMetaDataInBuffers(bool enabled)819 status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
820 ATRACE_CALL();
821 Mutex::Autolock icl(mBinderSerializationLock);
822 status_t res;
823 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
824
825 SharedParameters::Lock l(mParameters);
826 switch (l.mParameters.state) {
827 case Parameters::RECORD:
828 case Parameters::VIDEO_SNAPSHOT:
829 ALOGE("%s: Camera %d: Can't be called in state %s",
830 __FUNCTION__, mCameraId,
831 Parameters::getStateName(l.mParameters.state));
832 return INVALID_OPERATION;
833 default:
834 // OK
835 break;
836 }
837
838 l.mParameters.storeMetadataInBuffers = enabled;
839
840 return OK;
841 }
842
startRecording()843 status_t Camera2Client::startRecording() {
844 ATRACE_CALL();
845 ALOGV("%s: E", __FUNCTION__);
846 Mutex::Autolock icl(mBinderSerializationLock);
847 status_t res;
848 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
849 SharedParameters::Lock l(mParameters);
850
851 return startRecordingL(l.mParameters, false);
852 }
853
startRecordingL(Parameters & params,bool restart)854 status_t Camera2Client::startRecordingL(Parameters ¶ms, bool restart) {
855 status_t res;
856
857 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
858
859 switch (params.state) {
860 case Parameters::STOPPED:
861 res = startPreviewL(params, false);
862 if (res != OK) return res;
863 break;
864 case Parameters::PREVIEW:
865 // Ready to go
866 break;
867 case Parameters::RECORD:
868 case Parameters::VIDEO_SNAPSHOT:
869 // OK to call this when recording is already on, just skip unless
870 // we're looking to restart
871 if (!restart) return OK;
872 break;
873 default:
874 ALOGE("%s: Camera %d: Can't start recording in state %s",
875 __FUNCTION__, mCameraId,
876 Parameters::getStateName(params.state));
877 return INVALID_OPERATION;
878 };
879
880 if (!params.storeMetadataInBuffers) {
881 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
882 "non-metadata recording mode requested!", __FUNCTION__,
883 mCameraId);
884 return INVALID_OPERATION;
885 }
886
887 if (!restart) {
888 mCameraService->playSound(CameraService::SOUND_RECORDING);
889 mStreamingProcessor->updateRecordingRequest(params);
890 if (res != OK) {
891 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
892 __FUNCTION__, mCameraId, strerror(-res), res);
893 return res;
894 }
895 }
896
897 res = updateProcessorStream<
898 StreamingProcessor,
899 &StreamingProcessor::updateRecordingStream>(mStreamingProcessor,
900 params);
901 if (res != OK) {
902 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
903 __FUNCTION__, mCameraId, strerror(-res), res);
904 return res;
905 }
906
907 Vector<uint8_t> outputStreams;
908 bool callbacksEnabled = params.previewCallbackFlags &
909 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
910 if (callbacksEnabled) {
911 res = mCallbackProcessor->updateStream(params);
912 if (res != OK) {
913 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
914 __FUNCTION__, mCameraId, strerror(-res), res);
915 return res;
916 }
917 outputStreams.push(getCallbackStreamId());
918 }
919 outputStreams.push(getPreviewStreamId());
920 outputStreams.push(getRecordingStreamId());
921
922 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
923 outputStreams);
924 if (res != OK) {
925 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
926 __FUNCTION__, mCameraId, strerror(-res), res);
927 return res;
928 }
929
930 if (params.state < Parameters::RECORD) {
931 params.state = Parameters::RECORD;
932 }
933
934 return OK;
935 }
936
stopRecording()937 void Camera2Client::stopRecording() {
938 ATRACE_CALL();
939 ALOGV("%s: E", __FUNCTION__);
940 Mutex::Autolock icl(mBinderSerializationLock);
941 SharedParameters::Lock l(mParameters);
942
943 status_t res;
944 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
945
946 switch (l.mParameters.state) {
947 case Parameters::RECORD:
948 // OK to stop
949 break;
950 case Parameters::STOPPED:
951 case Parameters::PREVIEW:
952 case Parameters::STILL_CAPTURE:
953 case Parameters::VIDEO_SNAPSHOT:
954 default:
955 ALOGE("%s: Camera %d: Can't stop recording in state %s",
956 __FUNCTION__, mCameraId,
957 Parameters::getStateName(l.mParameters.state));
958 return;
959 };
960
961 mCameraService->playSound(CameraService::SOUND_RECORDING);
962
963 res = startPreviewL(l.mParameters, true);
964 if (res != OK) {
965 ALOGE("%s: Camera %d: Unable to return to preview",
966 __FUNCTION__, mCameraId);
967 }
968 }
969
recordingEnabled()970 bool Camera2Client::recordingEnabled() {
971 ATRACE_CALL();
972 Mutex::Autolock icl(mBinderSerializationLock);
973
974 if ( checkPid(__FUNCTION__) != OK) return false;
975
976 return recordingEnabledL();
977 }
978
recordingEnabledL()979 bool Camera2Client::recordingEnabledL() {
980 ATRACE_CALL();
981 SharedParameters::Lock l(mParameters);
982
983 return (l.mParameters.state == Parameters::RECORD
984 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
985 }
986
releaseRecordingFrame(const sp<IMemory> & mem)987 void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
988 ATRACE_CALL();
989 Mutex::Autolock icl(mBinderSerializationLock);
990 if ( checkPid(__FUNCTION__) != OK) return;
991
992 mStreamingProcessor->releaseRecordingFrame(mem);
993 }
994
autoFocus()995 status_t Camera2Client::autoFocus() {
996 ATRACE_CALL();
997 Mutex::Autolock icl(mBinderSerializationLock);
998 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
999 status_t res;
1000 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1001
1002 int triggerId;
1003 bool notifyImmediately = false;
1004 bool notifySuccess = false;
1005 {
1006 SharedParameters::Lock l(mParameters);
1007 if (l.mParameters.state < Parameters::PREVIEW) {
1008 return INVALID_OPERATION;
1009 }
1010
1011 /**
1012 * If the camera does not support auto-focus, it is a no-op and
1013 * onAutoFocus(boolean, Camera) callback will be called immediately
1014 * with a fake value of success set to true.
1015 *
1016 * Similarly, if focus mode is set to INFINITY, there's no reason to
1017 * bother the HAL.
1018 */
1019 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1020 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1021 notifyImmediately = true;
1022 notifySuccess = true;
1023 }
1024 /**
1025 * If we're in CAF mode, and AF has already been locked, just fire back
1026 * the callback right away; the HAL would not send a notification since
1027 * no state change would happen on a AF trigger.
1028 */
1029 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1030 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1031 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1032 notifyImmediately = true;
1033 notifySuccess = true;
1034 }
1035 /**
1036 * Send immediate notification back to client
1037 */
1038 if (notifyImmediately) {
1039 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1040 if (l.mRemoteCallback != 0) {
1041 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
1042 notifySuccess ? 1 : 0, 0);
1043 }
1044 return OK;
1045 }
1046 /**
1047 * Handle quirk mode for AF in scene modes
1048 */
1049 if (l.mParameters.quirks.triggerAfWithAuto &&
1050 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED &&
1051 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1052 !l.mParameters.focusingAreas[0].isEmpty()) {
1053 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1054 __FUNCTION__, l.mParameters.focusMode);
1055 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1056 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1057 updateRequests(l.mParameters);
1058 }
1059
1060 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1061 triggerId = l.mParameters.currentAfTriggerId;
1062 }
1063 syncWithDevice();
1064
1065 mDevice->triggerAutofocus(triggerId);
1066
1067 return OK;
1068 }
1069
cancelAutoFocus()1070 status_t Camera2Client::cancelAutoFocus() {
1071 ATRACE_CALL();
1072 Mutex::Autolock icl(mBinderSerializationLock);
1073 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1074 status_t res;
1075 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1076
1077 int triggerId;
1078 {
1079 SharedParameters::Lock l(mParameters);
1080 // Canceling does nothing in FIXED or INFINITY modes
1081 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1082 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1083 return OK;
1084 }
1085 triggerId = ++l.mParameters.afTriggerCounter;
1086
1087 // When using triggerAfWithAuto quirk, may need to reset focus mode to
1088 // the real state at this point. No need to cancel explicitly if
1089 // changing the AF mode.
1090 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1091 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1092 l.mParameters.shadowFocusMode);
1093 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1094 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1095 updateRequests(l.mParameters);
1096
1097 return OK;
1098 }
1099 }
1100 syncWithDevice();
1101
1102 mDevice->triggerCancelAutofocus(triggerId);
1103
1104 return OK;
1105 }
1106
takePicture(int msgType)1107 status_t Camera2Client::takePicture(int msgType) {
1108 ATRACE_CALL();
1109 Mutex::Autolock icl(mBinderSerializationLock);
1110 status_t res;
1111 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1112
1113 {
1114 SharedParameters::Lock l(mParameters);
1115 switch (l.mParameters.state) {
1116 case Parameters::DISCONNECTED:
1117 case Parameters::STOPPED:
1118 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1119 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
1120 __FUNCTION__, mCameraId);
1121 return INVALID_OPERATION;
1122 case Parameters::PREVIEW:
1123 // Good to go for takePicture
1124 res = commandStopFaceDetectionL(l.mParameters);
1125 if (res != OK) {
1126 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1127 __FUNCTION__, mCameraId);
1128 return res;
1129 }
1130 l.mParameters.state = Parameters::STILL_CAPTURE;
1131 break;
1132 case Parameters::RECORD:
1133 // Good to go for video snapshot
1134 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1135 break;
1136 case Parameters::STILL_CAPTURE:
1137 case Parameters::VIDEO_SNAPSHOT:
1138 ALOGE("%s: Camera %d: Already taking a picture",
1139 __FUNCTION__, mCameraId);
1140 return INVALID_OPERATION;
1141 }
1142
1143 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
1144
1145 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1146 if (res != OK) {
1147 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1148 __FUNCTION__, mCameraId, strerror(-res), res);
1149 return res;
1150 }
1151 }
1152
1153 // Need HAL to have correct settings before (possibly) triggering precapture
1154 syncWithDevice();
1155
1156 res = mCaptureSequencer->startCapture(msgType);
1157 if (res != OK) {
1158 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
1159 __FUNCTION__, mCameraId, strerror(-res), res);
1160 }
1161
1162 return res;
1163 }
1164
setParameters(const String8 & params)1165 status_t Camera2Client::setParameters(const String8& params) {
1166 ATRACE_CALL();
1167 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1168 Mutex::Autolock icl(mBinderSerializationLock);
1169 status_t res;
1170 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1171
1172 SharedParameters::Lock l(mParameters);
1173
1174 res = l.mParameters.set(params);
1175 if (res != OK) return res;
1176
1177 res = updateRequests(l.mParameters);
1178
1179 return res;
1180 }
1181
getParameters() const1182 String8 Camera2Client::getParameters() const {
1183 ATRACE_CALL();
1184 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1185 Mutex::Autolock icl(mBinderSerializationLock);
1186 if ( checkPid(__FUNCTION__) != OK) return String8();
1187
1188 SharedParameters::ReadLock l(mParameters);
1189
1190 return l.mParameters.get();
1191 }
1192
sendCommand(int32_t cmd,int32_t arg1,int32_t arg2)1193 status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1194 ATRACE_CALL();
1195 Mutex::Autolock icl(mBinderSerializationLock);
1196 status_t res;
1197 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1198
1199 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1200 cmd, arg1, arg2);
1201
1202 switch (cmd) {
1203 case CAMERA_CMD_START_SMOOTH_ZOOM:
1204 return commandStartSmoothZoomL();
1205 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1206 return commandStopSmoothZoomL();
1207 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1208 return commandSetDisplayOrientationL(arg1);
1209 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1210 return commandEnableShutterSoundL(arg1 == 1);
1211 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1212 return commandPlayRecordingSoundL();
1213 case CAMERA_CMD_START_FACE_DETECTION:
1214 return commandStartFaceDetectionL(arg1);
1215 case CAMERA_CMD_STOP_FACE_DETECTION: {
1216 SharedParameters::Lock l(mParameters);
1217 return commandStopFaceDetectionL(l.mParameters);
1218 }
1219 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1220 return commandEnableFocusMoveMsgL(arg1 == 1);
1221 case CAMERA_CMD_PING:
1222 return commandPingL();
1223 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1224 return commandSetVideoBufferCountL(arg1);
1225 default:
1226 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1227 __FUNCTION__, cmd, arg1, arg2);
1228 return BAD_VALUE;
1229 }
1230 }
1231
commandStartSmoothZoomL()1232 status_t Camera2Client::commandStartSmoothZoomL() {
1233 ALOGE("%s: Unimplemented!", __FUNCTION__);
1234 return OK;
1235 }
1236
commandStopSmoothZoomL()1237 status_t Camera2Client::commandStopSmoothZoomL() {
1238 ALOGE("%s: Unimplemented!", __FUNCTION__);
1239 return OK;
1240 }
1241
commandSetDisplayOrientationL(int degrees)1242 status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1243 int transform = Parameters::degToTransform(degrees,
1244 mCameraFacing == CAMERA_FACING_FRONT);
1245 if (transform == -1) {
1246 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1247 __FUNCTION__, mCameraId, degrees);
1248 return BAD_VALUE;
1249 }
1250 SharedParameters::Lock l(mParameters);
1251 if (transform != l.mParameters.previewTransform &&
1252 getPreviewStreamId() != NO_STREAM) {
1253 mDevice->setStreamTransform(getPreviewStreamId(), transform);
1254 }
1255 l.mParameters.previewTransform = transform;
1256 return OK;
1257 }
1258
commandEnableShutterSoundL(bool enable)1259 status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1260 SharedParameters::Lock l(mParameters);
1261 if (enable) {
1262 l.mParameters.playShutterSound = true;
1263 return OK;
1264 }
1265
1266 // Disabling shutter sound may not be allowed. In that case only
1267 // allow the mediaserver process to disable the sound.
1268 char value[PROPERTY_VALUE_MAX];
1269 property_get("ro.camera.sound.forced", value, "0");
1270 if (strncmp(value, "0", 2) != 0) {
1271 // Disabling shutter sound is not allowed. Deny if the current
1272 // process is not mediaserver.
1273 if (getCallingPid() != getpid()) {
1274 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1275 getCallingPid());
1276 return PERMISSION_DENIED;
1277 }
1278 }
1279
1280 l.mParameters.playShutterSound = false;
1281 return OK;
1282 }
1283
commandPlayRecordingSoundL()1284 status_t Camera2Client::commandPlayRecordingSoundL() {
1285 mCameraService->playSound(CameraService::SOUND_RECORDING);
1286 return OK;
1287 }
1288
commandStartFaceDetectionL(int)1289 status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
1290 ALOGV("%s: Camera %d: Starting face detection",
1291 __FUNCTION__, mCameraId);
1292 status_t res;
1293 SharedParameters::Lock l(mParameters);
1294 switch (l.mParameters.state) {
1295 case Parameters::DISCONNECTED:
1296 case Parameters::STOPPED:
1297 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1298 case Parameters::STILL_CAPTURE:
1299 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1300 __FUNCTION__, mCameraId);
1301 return INVALID_OPERATION;
1302 case Parameters::PREVIEW:
1303 case Parameters::RECORD:
1304 case Parameters::VIDEO_SNAPSHOT:
1305 // Good to go for starting face detect
1306 break;
1307 }
1308 // Ignoring type
1309 if (l.mParameters.fastInfo.bestFaceDetectMode ==
1310 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
1311 ALOGE("%s: Camera %d: Face detection not supported",
1312 __FUNCTION__, mCameraId);
1313 return BAD_VALUE;
1314 }
1315 if (l.mParameters.enableFaceDetect) return OK;
1316
1317 l.mParameters.enableFaceDetect = true;
1318
1319 res = updateRequests(l.mParameters);
1320
1321 return res;
1322 }
1323
commandStopFaceDetectionL(Parameters & params)1324 status_t Camera2Client::commandStopFaceDetectionL(Parameters ¶ms) {
1325 status_t res = OK;
1326 ALOGV("%s: Camera %d: Stopping face detection",
1327 __FUNCTION__, mCameraId);
1328
1329 if (!params.enableFaceDetect) return OK;
1330
1331 params.enableFaceDetect = false;
1332
1333 if (params.state == Parameters::PREVIEW
1334 || params.state == Parameters::RECORD
1335 || params.state == Parameters::VIDEO_SNAPSHOT) {
1336 res = updateRequests(params);
1337 }
1338
1339 return res;
1340 }
1341
commandEnableFocusMoveMsgL(bool enable)1342 status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1343 SharedParameters::Lock l(mParameters);
1344 l.mParameters.enableFocusMoveMessages = enable;
1345
1346 return OK;
1347 }
1348
commandPingL()1349 status_t Camera2Client::commandPingL() {
1350 // Always ping back if access is proper and device is alive
1351 SharedParameters::Lock l(mParameters);
1352 if (l.mParameters.state != Parameters::DISCONNECTED) {
1353 return OK;
1354 } else {
1355 return NO_INIT;
1356 }
1357 }
1358
commandSetVideoBufferCountL(size_t count)1359 status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1360 if (recordingEnabledL()) {
1361 ALOGE("%s: Camera %d: Error setting video buffer count after "
1362 "recording was started", __FUNCTION__, mCameraId);
1363 return INVALID_OPERATION;
1364 }
1365
1366 return mStreamingProcessor->setRecordingBufferCount(count);
1367 }
1368
1369 /** Device-related methods */
notifyAutoFocus(uint8_t newState,int triggerId)1370 void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1371 ALOGV("%s: Autofocus state now %d, last trigger %d",
1372 __FUNCTION__, newState, triggerId);
1373 bool sendCompletedMessage = false;
1374 bool sendMovingMessage = false;
1375
1376 bool success = false;
1377 bool afInMotion = false;
1378 {
1379 SharedParameters::Lock l(mParameters);
1380 l.mParameters.focusState = newState;
1381 switch (l.mParameters.focusMode) {
1382 case Parameters::FOCUS_MODE_AUTO:
1383 case Parameters::FOCUS_MODE_MACRO:
1384 // Don't send notifications upstream if they're not for the current AF
1385 // trigger. For example, if cancel was called in between, or if we
1386 // already sent a notification about this AF call.
1387 if (triggerId != l.mParameters.currentAfTriggerId) break;
1388 switch (newState) {
1389 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1390 success = true;
1391 // no break
1392 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1393 sendCompletedMessage = true;
1394 l.mParameters.currentAfTriggerId = -1;
1395 break;
1396 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1397 // Just starting focusing, ignore
1398 break;
1399 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1400 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1401 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1402 default:
1403 // Unexpected in AUTO/MACRO mode
1404 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1405 __FUNCTION__, newState);
1406 break;
1407 }
1408 break;
1409 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1410 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1411 switch (newState) {
1412 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1413 success = true;
1414 // no break
1415 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1416 // Don't send notifications upstream if they're not for
1417 // the current AF trigger. For example, if cancel was
1418 // called in between, or if we already sent a
1419 // notification about this AF call.
1420 // Send both a 'AF done' callback and a 'AF move' callback
1421 if (triggerId != l.mParameters.currentAfTriggerId) break;
1422 sendCompletedMessage = true;
1423 afInMotion = false;
1424 if (l.mParameters.enableFocusMoveMessages &&
1425 l.mParameters.afInMotion) {
1426 sendMovingMessage = true;
1427 }
1428 l.mParameters.currentAfTriggerId = -1;
1429 break;
1430 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1431 // Cancel was called, or we switched state; care if
1432 // currently moving
1433 afInMotion = false;
1434 if (l.mParameters.enableFocusMoveMessages &&
1435 l.mParameters.afInMotion) {
1436 sendMovingMessage = true;
1437 }
1438 break;
1439 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1440 // Start passive scan, inform upstream
1441 afInMotion = true;
1442 // no break
1443 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1444 // Stop passive scan, inform upstream
1445 if (l.mParameters.enableFocusMoveMessages) {
1446 sendMovingMessage = true;
1447 }
1448 break;
1449 }
1450 l.mParameters.afInMotion = afInMotion;
1451 break;
1452 case Parameters::FOCUS_MODE_EDOF:
1453 case Parameters::FOCUS_MODE_INFINITY:
1454 case Parameters::FOCUS_MODE_FIXED:
1455 default:
1456 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
1457 ALOGE("%s: Unexpected AF state change %d "
1458 "(ID %d) in focus mode %d",
1459 __FUNCTION__, newState, triggerId,
1460 l.mParameters.focusMode);
1461 }
1462 }
1463 }
1464 if (sendMovingMessage) {
1465 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1466 if (l.mRemoteCallback != 0) {
1467 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
1468 afInMotion ? 1 : 0, 0);
1469 }
1470 }
1471 if (sendCompletedMessage) {
1472 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1473 if (l.mRemoteCallback != 0) {
1474 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
1475 success ? 1 : 0, 0);
1476 }
1477 }
1478 }
1479
notifyAutoExposure(uint8_t newState,int triggerId)1480 void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1481 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1482 __FUNCTION__, newState, triggerId);
1483 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
1484 }
1485
getParameters()1486 camera2::SharedParameters& Camera2Client::getParameters() {
1487 return mParameters;
1488 }
1489
getPreviewStreamId() const1490 int Camera2Client::getPreviewStreamId() const {
1491 return mStreamingProcessor->getPreviewStreamId();
1492 }
1493
getCaptureStreamId() const1494 int Camera2Client::getCaptureStreamId() const {
1495 return mJpegProcessor->getStreamId();
1496 }
1497
getCallbackStreamId() const1498 int Camera2Client::getCallbackStreamId() const {
1499 return mCallbackProcessor->getStreamId();
1500 }
1501
getRecordingStreamId() const1502 int Camera2Client::getRecordingStreamId() const {
1503 return mStreamingProcessor->getRecordingStreamId();
1504 }
1505
getZslStreamId() const1506 int Camera2Client::getZslStreamId() const {
1507 return mZslProcessor->getStreamId();
1508 }
1509
registerFrameListener(int32_t minId,int32_t maxId,wp<camera2::FrameProcessor::FilteredListener> listener)1510 status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
1511 wp<camera2::FrameProcessor::FilteredListener> listener) {
1512 return mFrameProcessor->registerListener(minId, maxId, listener);
1513 }
1514
removeFrameListener(int32_t minId,int32_t maxId,wp<camera2::FrameProcessor::FilteredListener> listener)1515 status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1516 wp<camera2::FrameProcessor::FilteredListener> listener) {
1517 return mFrameProcessor->removeListener(minId, maxId, listener);
1518 }
1519
stopStream()1520 status_t Camera2Client::stopStream() {
1521 return mStreamingProcessor->stopStream();
1522 }
1523
1524 const int32_t Camera2Client::kPreviewRequestIdStart;
1525 const int32_t Camera2Client::kPreviewRequestIdEnd;
1526 const int32_t Camera2Client::kRecordingRequestIdStart;
1527 const int32_t Camera2Client::kRecordingRequestIdEnd;
1528 const int32_t Camera2Client::kCaptureRequestIdStart;
1529 const int32_t Camera2Client::kCaptureRequestIdEnd;
1530
1531 /** Utility methods */
1532
updateRequests(Parameters & params)1533 status_t Camera2Client::updateRequests(Parameters ¶ms) {
1534 status_t res;
1535
1536 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1537
1538 res = mStreamingProcessor->incrementStreamingIds();
1539 if (res != OK) {
1540 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1541 __FUNCTION__, mCameraId, strerror(-res), res);
1542 return res;
1543 }
1544
1545 res = mStreamingProcessor->updatePreviewRequest(params);
1546 if (res != OK) {
1547 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1548 __FUNCTION__, mCameraId, strerror(-res), res);
1549 return res;
1550 }
1551 res = mStreamingProcessor->updateRecordingRequest(params);
1552 if (res != OK) {
1553 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1554 __FUNCTION__, mCameraId, strerror(-res), res);
1555 return res;
1556 }
1557
1558 if (params.state == Parameters::PREVIEW) {
1559 res = startPreviewL(params, true);
1560 if (res != OK) {
1561 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1562 __FUNCTION__, mCameraId, strerror(-res), res);
1563 return res;
1564 }
1565 } else if (params.state == Parameters::RECORD ||
1566 params.state == Parameters::VIDEO_SNAPSHOT) {
1567 res = startRecordingL(params, true);
1568 if (res != OK) {
1569 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1570 __FUNCTION__, mCameraId, strerror(-res), res);
1571 return res;
1572 }
1573 }
1574 return res;
1575 }
1576
1577
calculateBufferSize(int width,int height,int format,int stride)1578 size_t Camera2Client::calculateBufferSize(int width, int height,
1579 int format, int stride) {
1580 switch (format) {
1581 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1582 return width * height * 2;
1583 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1584 return width * height * 3 / 2;
1585 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1586 return width * height * 2;
1587 case HAL_PIXEL_FORMAT_YV12: { // YV12
1588 size_t ySize = stride * height;
1589 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
1590 size_t uvSize = uvStride * height / 2;
1591 return ySize + uvSize * 2;
1592 }
1593 case HAL_PIXEL_FORMAT_RGB_565:
1594 return width * height * 2;
1595 case HAL_PIXEL_FORMAT_RGBA_8888:
1596 return width * height * 4;
1597 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1598 return width * height * 2;
1599 default:
1600 ALOGE("%s: Unknown preview format: %x",
1601 __FUNCTION__, format);
1602 return 0;
1603 }
1604 }
1605
syncWithDevice()1606 status_t Camera2Client::syncWithDevice() {
1607 ATRACE_CALL();
1608 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
1609 status_t res;
1610
1611 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
1612 if (activeRequestId == 0) return OK;
1613
1614 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
1615 if (res == TIMED_OUT) {
1616 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
1617 __FUNCTION__, mCameraId);
1618 } else if (res != OK) {
1619 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
1620 __FUNCTION__, mCameraId);
1621 }
1622 return res;
1623 }
1624
1625 template <typename ProcessorT>
updateProcessorStream(sp<ProcessorT> processor,camera2::Parameters params)1626 status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1627 camera2::Parameters params) {
1628 // No default template arguments until C++11, so we need this overload
1629 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
1630 processor, params);
1631 }
1632
1633 template <typename ProcessorT,
1634 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
updateProcessorStream(sp<ProcessorT> processor,Parameters params)1635 status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1636 Parameters params) {
1637 status_t res;
1638
1639 // Get raw pointer since sp<T> doesn't have operator->*
1640 ProcessorT *processorPtr = processor.get();
1641 res = (processorPtr->*updateStreamF)(params);
1642
1643 /**
1644 * Can't update the stream if it's busy?
1645 *
1646 * Then we need to stop the device (by temporarily clearing the request
1647 * queue) and then try again. Resume streaming once we're done.
1648 */
1649 if (res == -EBUSY) {
1650 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1651 if (res != OK) {
1652 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1653 __FUNCTION__, mCameraId, strerror(-res), res);
1654 }
1655
1656 res = mDevice->waitUntilDrained();
1657 if (res != OK) {
1658 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1659 __FUNCTION__, mCameraId, strerror(-res), res);
1660 }
1661
1662 res = (processorPtr->*updateStreamF)(params);
1663 if (res != OK) {
1664 ALOGE("%s: Camera %d: Failed to update processing stream "
1665 " despite having halted streaming first: %s (%d)",
1666 __FUNCTION__, mCameraId, strerror(-res), res);
1667 }
1668
1669 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1670 if (res != OK) {
1671 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1672 __FUNCTION__, mCameraId, strerror(-res), res);
1673 }
1674 }
1675
1676 return res;
1677 }
1678
1679 } // namespace android
1680