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