blob: 335e999d776ef3cd44565354e16620711ac9ec19 [file] [log] [blame]
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001/*
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
Zhijun Hecc27e112013-10-03 16:12:43 -070017#define LOG_TAG "Camera2Client"
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070018#define ATRACE_TAG ATRACE_TAG_CAMERA
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070019//#define LOG_NDEBUG 0
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070020
Kévin PETIT377b2ec2014-02-03 12:35:36 +000021#include <inttypes.h>
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070022#include <utils/Log.h>
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070023#include <utils/Trace.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070024
25#include <cutils/properties.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070026#include <gui/Surface.h>
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080027#include <android/hardware/camera2/ICameraDeviceCallbacks.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070028
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070029#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"
Igor Murashkinae500e52013-04-22 14:03:54 -070036
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070037#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
38#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
39
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070040namespace android {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070041using namespace camera2;
42
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070043static int getCallingPid() {
44 return IPCThreadState::self()->getCallingPid();
45}
46
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070047// Interface used by CameraService
48
49Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080050 const sp<hardware::ICameraClient>& cameraClient,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080051 const String16& clientPackageName,
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070052 int cameraId,
53 int cameraFacing,
Igor Murashkinecf17e82012-10-02 16:05:11 -070054 int clientPid,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080055 uid_t clientUid,
Igor Murashkina858ea02014-08-19 14:53:08 -070056 int servicePid,
57 bool legacyMode):
Igor Murashkin44cfcf02013-03-01 16:22:28 -080058 Camera2ClientBase(cameraService, cameraClient, clientPackageName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080059 String8::format("%d", cameraId), cameraFacing,
60 clientPid, clientUid, servicePid),
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070061 mParameters(cameraId, cameraFacing)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070062{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070063 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070064
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070065 SharedParameters::Lock l(mParameters);
66 l.mParameters.state = Parameters::DISCONNECTED;
Igor Murashkina858ea02014-08-19 14:53:08 -070067
68 mLegacyMode = legacyMode;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070069}
70
Yin-Chia Yehdce65c82017-01-06 15:03:53 -080071status_t Camera2Client::initialize(CameraModule *module) {
72 return initializeImpl(module);
73}
74
75status_t Camera2Client::initialize(sp<CameraProviderManager> manager) {
76 return initializeImpl(manager);
77}
78
79template<typename TProviderPtr>
80status_t Camera2Client::initializeImpl(TProviderPtr providerPtr)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070081{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070082 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070083 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070084 status_t res;
85
Yin-Chia Yehdce65c82017-01-06 15:03:53 -080086 res = Camera2ClientBase::initialize(providerPtr);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080087 if (res != OK) {
88 return res;
89 }
90
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070091 {
92 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070093
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070094 res = l.mParameters.initialize(&(mDevice->info()), mDeviceVersion);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070095 if (res != OK) {
96 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
97 __FUNCTION__, mCameraId, strerror(-res), res);
98 return NO_INIT;
99 }
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700100 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -0700101
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700102 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700103
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700104 mStreamingProcessor = new StreamingProcessor(this);
Eino-Ville Talvala254446a2013-06-04 16:34:35 -0700105 threadName = String8::format("C2-%d-StreamProc",
106 mCameraId);
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700107
Igor Murashkince124da2013-03-04 14:53:08 -0800108 mFrameProcessor = new FrameProcessor(mDevice, this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700109 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700110 mCameraId);
111 mFrameProcessor->run(threadName.string());
112
113 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700114 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700115 mCameraId);
116 mCaptureSequencer->run(threadName.string());
117
118 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700119 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700120 mCameraId);
121 mJpegProcessor->run(threadName.string());
122
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800123 mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
124
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700125 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700126 mCameraId);
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800127 mZslProcessor->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700128
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700129 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700130 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700131 mCameraId);
132 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700133
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700134 if (gLogLevel >= 1) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700135 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700136 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
137 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700138 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700139 }
140
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700141 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700142}
143
144Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700145 ATRACE_CALL();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700146 ALOGV("~Camera2Client");
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700147
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700148 mDestructionStarted = true;
149
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700150 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700151
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700152 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700153}
154
155status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800156 return BasicClient::dump(fd, args);
157}
158
159status_t Camera2Client::dumpClient(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700160 String8 result;
Ruben Brunkcc776712015-02-17 20:18:47 -0800161 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n", mCameraId,
Eino-Ville Talvalae992e752014-11-07 16:17:48 -0800162 (getRemoteCallback() != NULL ?
Marco Nelissenf8880202014-11-14 07:58:25 -0800163 (IInterface::asBinder(getRemoteCallback()).get()) : NULL),
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700164 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700165 result.append(" State: ");
166#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
167
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700168 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700169
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700170 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700171
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700172 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700173 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700174 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700175 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700176 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700177 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700178 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700179 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700180 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700181 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700182 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700183 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700184 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700185 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700186 p.jpegQuality, p.jpegThumbQuality);
187 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700188 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700189 p.gpsEnabled ? "enabled" : "disabled");
190 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700191 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700192 p.gpsCoordinates[0], p.gpsCoordinates[1],
193 p.gpsCoordinates[2]);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000194 result.appendFormat(" GPS timestamp: %" PRId64 "\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700195 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700196 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700197 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700198 }
199
200 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700201 switch (p.wbMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800202 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
203 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
204 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
205 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
206 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
207 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
208 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
209 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700210 default: result.append("UNKNOWN\n");
211 }
212
213 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700214 switch (p.effectMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800215 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
216 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
217 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
218 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
219 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
220 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
221 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
223 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700224 default: result.append("UNKNOWN\n");
225 }
226
227 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700228 switch (p.antibandingMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800229 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
230 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
231 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
232 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700233 default: result.append("UNKNOWN\n");
234 }
235
236 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700237 switch (p.sceneMode) {
Ruben Brunkc69b91c2014-01-17 17:12:10 -0800238 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700239 result.append("AUTO\n"); break;
240 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
241 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
242 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
243 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
244 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
245 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
246 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
247 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
248 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
249 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
250 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
251 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
252 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
255 default: result.append("UNKNOWN\n");
256 }
257
258 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700259 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700260 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
261 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
262 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
263 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
264 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
265 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
266 default: result.append("UNKNOWN\n");
267 }
268
269 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700270 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700271 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
272 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
273 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
274 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
275 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
276 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
277 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
278 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
279 default: result.append("UNKNOWN\n");
280 }
281
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700282 result.append(" Focus state: ");
283 switch (p.focusState) {
284 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
285 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
286 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -0700287 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700288 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
289 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
290 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
291 default: result.append("UNKNOWN\n");
292 }
293
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700294 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700295 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700296 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700297 p.focusingAreas[i].left,
298 p.focusingAreas[i].top,
299 p.focusingAreas[i].right,
300 p.focusingAreas[i].bottom,
301 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700302 }
303
304 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700305 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700306
307 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700308 p.autoExposureLock ? "enabled" : "disabled",
309 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700310
311 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700312 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700313 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700314 p.meteringAreas[i].left,
315 p.meteringAreas[i].top,
316 p.meteringAreas[i].right,
317 p.meteringAreas[i].bottom,
318 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700319 }
320
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700321 result.appendFormat(" Zoom index: %d\n", p.zoom);
322 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
323 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700324
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700325 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700326 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700327
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700328 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700329 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700330
Eino-Ville Talvala0181fde2013-09-20 10:12:32 -0700331 result.appendFormat(" Selected still capture FPS range: %d - %d\n",
332 p.fastInfo.bestStillCaptureFpsRange[0],
333 p.fastInfo.bestStillCaptureFpsRange[1]);
334
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -0700335 result.appendFormat(" Use zero shutter lag: %s\n",
336 p.useZeroShutterLag() ? "yes" : "no");
337
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700338 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700339 result.appendFormat(" Preview stream ID: %d\n",
340 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700341 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700342 getCaptureStreamId());
343 result.appendFormat(" Recording stream ID: %d\n",
344 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700345
346 result.append(" Quirks for this camera:\n");
347 bool haveQuirk = false;
348 if (p.quirks.triggerAfWithAuto) {
349 result.appendFormat(" triggerAfWithAuto\n");
350 haveQuirk = true;
351 }
352 if (p.quirks.useZslFormat) {
353 result.appendFormat(" useZslFormat\n");
354 haveQuirk = true;
355 }
Igor Murashkin7373cbe2012-09-28 15:30:03 -0700356 if (p.quirks.meteringCropRegion) {
357 result.appendFormat(" meteringCropRegion\n");
358 haveQuirk = true;
359 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700360 if (p.quirks.partialResults) {
361 result.appendFormat(" usePartialResult\n");
362 haveQuirk = true;
363 }
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700364 if (!haveQuirk) {
365 result.appendFormat(" none\n");
366 }
367
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700368 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700369
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700370 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700371
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700372 mCaptureSequencer->dump(fd, args);
373
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700374 mFrameProcessor->dump(fd, args);
375
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700376 mZslProcessor->dump(fd, args);
377
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800378 return dumpDevice(fd, args);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700379#undef CASE_APPEND_ENUM
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700380}
381
382// ICamera interface
383
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800384binder::Status Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700385 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800386 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700387
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800388 binder::Status res = binder::Status::ok();
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800389 // Allow both client and the cameraserver to disconnect at all times
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700390 int callingPid = getCallingPid();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800391 if (callingPid != mClientPid && callingPid != mServicePid) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700392
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800393 if (mDevice == 0) return res;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700394
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700395 ALOGV("Camera %d: Shutting down", mCameraId);
396
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700397 /**
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
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700403 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700404
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700405 {
406 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800407 if (l.mParameters.state == Parameters::DISCONNECTED) return res;
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700408 l.mParameters.state = Parameters::DISCONNECTED;
409 }
410
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700411 mFrameProcessor->requestExit();
412 mCaptureSequencer->requestExit();
413 mJpegProcessor->requestExit();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800414 mZslProcessor->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700415 mCallbackProcessor->requestExit();
416
417 ALOGV("Camera %d: Waiting for threads", mCameraId);
418
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700419 {
420 // Don't wait with lock held, in case the other threads need to
421 // complete callbacks that re-enter Camera2Client
422 mBinderSerializationLock.unlock();
423
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700424 mFrameProcessor->join();
425 mCaptureSequencer->join();
426 mJpegProcessor->join();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800427 mZslProcessor->join();
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700428 mCallbackProcessor->join();
429
430 mBinderSerializationLock.lock();
431 }
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700432
Ruben Brunkdfe71552013-12-05 11:00:37 -0800433 ALOGV("Camera %d: Deleting streams", mCameraId);
434
435 mStreamingProcessor->deletePreviewStream();
436 mStreamingProcessor->deleteRecordingStream();
437 mJpegProcessor->deleteStream();
438 mCallbackProcessor->deleteStream();
439 mZslProcessor->deleteStream();
440
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700441 ALOGV("Camera %d: Disconnecting device", mCameraId);
442
443 mDevice->disconnect();
444
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700445 mDevice.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700446
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700447 CameraService::Client::disconnect();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800448
449 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700450}
451
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800452status_t Camera2Client::connect(const sp<hardware::ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700453 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700454 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800455 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700456
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700457 if (mClientPid != 0 && getCallingPid() != mClientPid) {
458 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
459 "current locked to pid %d", __FUNCTION__,
460 mCameraId, getCallingPid(), mClientPid);
461 return BAD_VALUE;
462 }
463
464 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700465
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800466 mRemoteCallback = client;
467 mSharedCameraCallbacks = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700468
469 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700470}
471
472status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700473 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700474 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800475 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700476 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
477 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700478
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700479 if (mClientPid == 0) {
480 mClientPid = getCallingPid();
481 return OK;
482 }
483
484 if (mClientPid != getCallingPid()) {
485 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
486 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
487 return EBUSY;
488 }
489
490 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700491}
492
493status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700494 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700495 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800496 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700497 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
498 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700499
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700500 if (mClientPid == getCallingPid()) {
Eino-Ville Talvala907e5652012-10-10 15:28:53 -0700501 SharedParameters::Lock l(mParameters);
502 if (l.mParameters.state == Parameters::RECORD ||
503 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
504 ALOGD("Not allowed to unlock camera during recording.");
505 return INVALID_OPERATION;
506 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700507 mClientPid = 0;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800508 mRemoteCallback.clear();
509 mSharedCameraCallbacks.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700510 return OK;
511 }
512
513 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
514 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
515 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700516}
517
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700518status_t Camera2Client::setPreviewTarget(
Andy McFadden8ba01022012-12-18 09:46:54 -0800519 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700520 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700521 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800522 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700523 status_t res;
524 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700525
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700526 sp<IBinder> binder;
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700527 sp<Surface> window;
Andy McFadden8ba01022012-12-18 09:46:54 -0800528 if (bufferProducer != 0) {
Marco Nelissenf8880202014-11-14 07:58:25 -0800529 binder = IInterface::asBinder(bufferProducer);
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700530 // Using controlledByApp flag to ensure that the buffer queue remains in
531 // async mode for the old camera API, where many applications depend
532 // on that behavior.
533 window = new Surface(bufferProducer, /*controlledByApp*/ true);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700534 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700535 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700536}
537
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700538status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700539 const sp<Surface>& window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700540 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700541 status_t res;
542
543 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700544 ALOGV("%s: Camera %d: New window is same as old window",
545 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700546 return NO_ERROR;
547 }
548
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700549 Parameters::State state;
550 {
551 SharedParameters::Lock l(mParameters);
552 state = l.mParameters.state;
553 }
554 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700555 case Parameters::DISCONNECTED:
556 case Parameters::RECORD:
557 case Parameters::STILL_CAPTURE:
558 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700559 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700560 __FUNCTION__, mCameraId,
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700561 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700562 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700563 case Parameters::STOPPED:
564 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700565 // OK
566 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700567 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700568 // Already running preview - need to stop and create a new stream
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700569 res = stopStream();
570 if (res != OK) {
571 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
572 __FUNCTION__, strerror(-res), res);
573 return res;
574 }
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700575 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700576 break;
577 }
578
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700579 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700580 res = mStreamingProcessor->setPreviewWindow(window);
581 if (res != OK) {
582 ALOGE("%s: Unable to set new preview window: %s (%d)",
583 __FUNCTION__, strerror(-res), res);
584 return res;
585 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700586
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700587 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
588 SharedParameters::Lock l(mParameters);
589 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700590 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700591 }
592
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700593 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700594}
595
596void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700597 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700598 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800599 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinddf3c502012-10-12 16:56:11 -0700600
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700601 if ( checkPid(__FUNCTION__) != OK) return;
602
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700603 SharedParameters::Lock l(mParameters);
604 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700605}
606
607void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
608 status_t res = OK;
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700609
610 switch(params.state) {
611 case Parameters::STOPPED:
612 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
613 case Parameters::PREVIEW:
Zhijun Hea2520db2013-07-08 16:12:32 -0700614 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700615 // OK
616 break;
617 default:
618 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
619 ALOGE("%s: Camera %d: Can't use preview callbacks "
620 "in state %d", __FUNCTION__, mCameraId, params.state);
621 return;
622 }
623 }
624
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700625 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
626 ALOGV("%s: setting oneshot", __FUNCTION__);
627 params.previewCallbackOneShot = true;
628 }
629 if (params.previewCallbackFlags != (uint32_t)flag) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700630
Zhijun He527748a2013-09-15 21:06:10 -0700631 if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700632 // Disable any existing preview callback window when enabling
633 // preview callback flags
634 res = mCallbackProcessor->setCallbackWindow(NULL);
635 if (res != OK) {
636 ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
637 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
638 return;
639 }
640 params.previewCallbackSurface = false;
641 }
642
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700643 params.previewCallbackFlags = flag;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700644
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700645 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700646 res = startPreviewL(params, true);
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700647 if (res != OK) {
648 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
649 __FUNCTION__, mCameraId,
650 Parameters::getStateName(params.state));
651 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700652 }
653 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700654}
655
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700656status_t Camera2Client::setPreviewCallbackTarget(
657 const sp<IGraphicBufferProducer>& callbackProducer) {
658 ATRACE_CALL();
659 ALOGV("%s: E", __FUNCTION__);
660 Mutex::Autolock icl(mBinderSerializationLock);
661 status_t res;
662 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
663
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700664 sp<Surface> window;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700665 if (callbackProducer != 0) {
666 window = new Surface(callbackProducer);
667 }
668
669 res = mCallbackProcessor->setCallbackWindow(window);
670 if (res != OK) {
671 ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
672 __FUNCTION__, mCameraId, strerror(-res), res);
673 return res;
674 }
675
676 SharedParameters::Lock l(mParameters);
677
678 if (window != NULL) {
679 // Disable traditional callbacks when a valid callback target is given
680 l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
681 l.mParameters.previewCallbackOneShot = false;
682 l.mParameters.previewCallbackSurface = true;
683 } else {
684 // Disable callback target if given a NULL interface.
685 l.mParameters.previewCallbackSurface = false;
686 }
687
688 switch(l.mParameters.state) {
689 case Parameters::PREVIEW:
690 res = startPreviewL(l.mParameters, true);
691 break;
692 case Parameters::RECORD:
693 case Parameters::VIDEO_SNAPSHOT:
694 res = startRecordingL(l.mParameters, true);
695 break;
696 default:
697 break;
698 }
699 if (res != OK) {
700 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
701 __FUNCTION__, mCameraId,
702 Parameters::getStateName(l.mParameters.state));
703 }
704
705 return OK;
706}
707
708
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700709status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700710 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700711 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800712 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700713 status_t res;
714 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700715 SharedParameters::Lock l(mParameters);
716 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700717}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700718
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700719status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700720 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700721 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700722
723 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
724
Eino-Ville Talvalaa14be592012-10-10 17:17:01 -0700725 if ( (params.state == Parameters::PREVIEW ||
726 params.state == Parameters::RECORD ||
727 params.state == Parameters::VIDEO_SNAPSHOT)
728 && !restart) {
729 // Succeed attempt to re-enter a streaming state
730 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
731 __FUNCTION__, mCameraId);
Alex Ray77449ad2012-09-26 15:52:50 -0700732 return OK;
733 }
734 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700735 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700736 __FUNCTION__,
737 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700738 return INVALID_OPERATION;
739 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700740
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700741 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700742 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700743 return OK;
744 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700745 params.state = Parameters::STOPPED;
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800746 int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700747
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700748 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700749 if (res != OK) {
750 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
751 __FUNCTION__, mCameraId, strerror(-res), res);
752 return res;
753 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700754
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800755 bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;
756
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700757 // We could wait to create the JPEG output stream until first actual use
758 // (first takePicture call). However, this would substantially increase the
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800759 // first capture latency on HAL3 devices.
760 // So create it unconditionally at preview start. As a drawback,
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700761 // this increases gralloc memory consumption for applications that don't
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800762 // ever take a picture. Do not enter this mode when jpeg stream will slow
763 // down preview.
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700764 // TODO: Find a better compromise, though this likely would involve HAL
765 // changes.
Zhijun Hee2d83752014-06-23 10:22:37 -0700766 int lastJpegStreamId = mJpegProcessor->getStreamId();
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800767 // If jpeg stream will slow down preview, make sure we remove it before starting preview
768 if (params.slowJpegMode) {
769 mJpegProcessor->deleteStream();
770 } else {
771 res = updateProcessorStream(mJpegProcessor, params);
772 if (res != OK) {
773 ALOGE("%s: Camera %d: Can't pre-configure still image "
774 "stream: %s (%d)",
775 __FUNCTION__, mCameraId, strerror(-res), res);
776 return res;
777 }
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700778 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700779 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700780
Zhijun Hed1d64672013-09-06 15:00:01 -0700781 Vector<int32_t> outputStreams;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700782 bool callbacksEnabled = (params.previewCallbackFlags &
783 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
784 params.previewCallbackSurface;
785
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700786 if (callbacksEnabled) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700787 // Can't have recording stream hanging around when enabling callbacks,
788 // since it exceeds the max stream count on some devices.
789 if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
790 ALOGV("%s: Camera %d: Clearing out recording stream before "
791 "creating callback stream", __FUNCTION__, mCameraId);
792 res = mStreamingProcessor->stopStream();
793 if (res != OK) {
794 ALOGE("%s: Camera %d: Can't stop streaming to delete "
795 "recording stream", __FUNCTION__, mCameraId);
796 return res;
797 }
798 res = mStreamingProcessor->deleteRecordingStream();
799 if (res != OK) {
800 ALOGE("%s: Camera %d: Unable to delete recording stream before "
801 "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
802 strerror(-res), res);
803 return res;
804 }
805 }
806
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700807 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700808 if (res != OK) {
809 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
810 __FUNCTION__, mCameraId, strerror(-res), res);
811 return res;
812 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700813 outputStreams.push(getCallbackStreamId());
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800814 } else if (previewStreamChanged && mCallbackProcessor->getStreamId() != NO_STREAM) {
815 /**
816 * Delete the unused callback stream when preview stream is changed and
817 * preview is not enabled. Don't need stop preview stream as preview is in
818 * STOPPED state now.
819 */
820 ALOGV("%s: Camera %d: Delete unused preview callback stream.", __FUNCTION__, mCameraId);
821 res = mCallbackProcessor->deleteStream();
822 if (res != OK) {
823 ALOGE("%s: Camera %d: Unable to delete callback stream %s (%d)",
824 __FUNCTION__, mCameraId, strerror(-res), res);
825 return res;
826 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700827 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700828
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -0700829 if (params.useZeroShutterLag() &&
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700830 getRecordingStreamId() == NO_STREAM) {
Igor Murashkindca254a2013-05-13 14:53:44 -0700831 res = updateProcessorStream(mZslProcessor, params);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700832 if (res != OK) {
833 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
834 __FUNCTION__, mCameraId, strerror(-res), res);
835 return res;
836 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700837
838 if (jpegStreamChanged) {
839 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
840 __FUNCTION__, mCameraId);
841 mZslProcessor->clearZslQueue();
842 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700843 outputStreams.push(getZslStreamId());
Zhijun He66107622013-11-01 11:05:56 -0700844 } else {
845 mZslProcessor->deleteStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700846 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700847
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700848 outputStreams.push(getPreviewStreamId());
849
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700850 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700851 if (!restart) {
852 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700853 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700854 ALOGE("%s: Camera %d: Can't set up preview request: "
855 "%s (%d)", __FUNCTION__, mCameraId,
856 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700857 return res;
858 }
859 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700860 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
861 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700862 } else {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700863 if (!restart) {
864 res = mStreamingProcessor->updateRecordingRequest(params);
865 if (res != OK) {
866 ALOGE("%s: Camera %d: Can't set up preview request with "
867 "record hint: %s (%d)", __FUNCTION__, mCameraId,
868 strerror(-res), res);
869 return res;
870 }
871 }
872 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
873 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700874 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700875 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700876 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700877 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700878 return res;
879 }
880
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700881 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700882 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700883}
884
885void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700886 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700887 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800888 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700889 status_t res;
890 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700891 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700892}
893
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700894void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700895 ATRACE_CALL();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700896 status_t res;
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700897 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700898 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700899 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700900 SharedParameters::Lock l(mParameters);
901 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700902 }
903
904 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700905 case Parameters::DISCONNECTED:
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800906 // Nothing to do.
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700907 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700908 case Parameters::STOPPED:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700909 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700910 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700911 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
912 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700913 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700914 case Parameters::PREVIEW:
Ruben Brunka27c4aa2013-09-04 18:18:26 -0700915 syncWithDevice();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700916 res = stopStream();
917 if (res != OK) {
918 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
919 __FUNCTION__, mCameraId, strerror(-res), res);
920 }
Ruchit Sharma2cec0df2014-08-20 16:02:08 -0400921
922 // Flush all in-process captures and buffer in order to stop
923 // preview faster.
924 res = mDevice->flush();
925 if (res != OK) {
926 ALOGE("%s: Camera %d: Unable to flush pending requests: %s (%d)",
927 __FUNCTION__, mCameraId, strerror(-res), res);
928 }
929
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700930 res = mDevice->waitUntilDrained();
931 if (res != OK) {
932 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
933 __FUNCTION__, mCameraId, strerror(-res), res);
934 }
Yin-Chia Yeh28d03272014-07-17 16:05:23 -0700935 // Clean up recording stream
936 res = mStreamingProcessor->deleteRecordingStream();
937 if (res != OK) {
938 ALOGE("%s: Camera %d: Unable to delete recording stream before "
939 "stop preview: %s (%d)",
940 __FUNCTION__, mCameraId, strerror(-res), res);
941 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700942 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700943 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
944 SharedParameters::Lock l(mParameters);
945 l.mParameters.state = Parameters::STOPPED;
946 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700947 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700948 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700949 default:
950 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700951 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700952 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700953}
954
955bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700956 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800957 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700958 status_t res;
959 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
960
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700961 SharedParameters::Lock l(mParameters);
962 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700963}
964
Chien-Yu Chen8cca0752015-11-13 15:28:48 -0800965status_t Camera2Client::setVideoBufferMode(int32_t videoBufferMode) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700966 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800967 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700968 status_t res;
969 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
970
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700971 SharedParameters::Lock l(mParameters);
972 switch (l.mParameters.state) {
973 case Parameters::RECORD:
974 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700975 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700976 __FUNCTION__, mCameraId,
977 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700978 return INVALID_OPERATION;
979 default:
980 // OK
981 break;
982 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700983
Chien-Yu Chen8cca0752015-11-13 15:28:48 -0800984 if (videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
985 ALOGE("%s: %d: Only video buffer queue is supported", __FUNCTION__, __LINE__);
986 return BAD_VALUE;
987 }
988
989 l.mParameters.videoBufferMode = videoBufferMode;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700990
991 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700992}
993
994status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700995 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700996 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800997 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700998 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700999 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001000 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001001
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001002 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001003}
1004
1005status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
Yunlian Jiang7fd5bdb2016-11-22 15:16:25 -08001006 status_t res = OK;
Igor Murashkin22d58d32012-10-02 19:07:14 -07001007
1008 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
1009
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001010 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001011 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001012 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001013 if (res != OK) return res;
Zhijun He96ff5c42014-10-13 22:20:37 -07001014 // Make sure first preview request is submitted to the HAL device to avoid
1015 // two consecutive set of configure_streams being called into the HAL.
1016 // TODO: Refactor this to avoid initial preview configuration.
1017 syncWithDevice();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001018 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001019 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001020 // Ready to go
1021 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001022 case Parameters::RECORD:
1023 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001024 // OK to call this when recording is already on, just skip unless
1025 // we're looking to restart
1026 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001027 break;
1028 default:
1029 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001030 __FUNCTION__, mCameraId,
1031 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001032 return INVALID_OPERATION;
1033 };
1034
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001035 if (params.videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
1036 ALOGE("%s: Camera %d: Recording only supported buffer queue mode, but "
1037 "mode %d is requested!", __FUNCTION__, mCameraId, params.videoBufferMode);
1038 return INVALID_OPERATION;
1039 }
1040
1041 if (!mStreamingProcessor->haveValidRecordingWindow()) {
1042 ALOGE("%s: No valid recording window", __FUNCTION__);
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001043 return INVALID_OPERATION;
1044 }
1045
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001046 if (!restart) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001047 sCameraService->playSound(CameraService::SOUND_RECORDING_START);
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001048 mStreamingProcessor->updateRecordingRequest(params);
1049 if (res != OK) {
1050 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1051 __FUNCTION__, mCameraId, strerror(-res), res);
1052 return res;
1053 }
1054 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001055
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001056 // Not all devices can support a preview callback stream and a recording
1057 // stream at the same time, so assume none of them can.
1058 if (mCallbackProcessor->getStreamId() != NO_STREAM) {
1059 ALOGV("%s: Camera %d: Clearing out callback stream before "
1060 "creating recording stream", __FUNCTION__, mCameraId);
1061 res = mStreamingProcessor->stopStream();
1062 if (res != OK) {
1063 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1064 __FUNCTION__, mCameraId);
1065 return res;
1066 }
1067 res = mCallbackProcessor->deleteStream();
1068 if (res != OK) {
1069 ALOGE("%s: Camera %d: Unable to delete callback stream before "
1070 "record: %s (%d)", __FUNCTION__, mCameraId,
1071 strerror(-res), res);
1072 return res;
1073 }
1074 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001075
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001076 // Clean up ZSL before transitioning into recording
1077 if (mZslProcessor->getStreamId() != NO_STREAM) {
1078 ALOGV("%s: Camera %d: Clearing out zsl stream before "
1079 "creating recording stream", __FUNCTION__, mCameraId);
1080 res = mStreamingProcessor->stopStream();
1081 if (res != OK) {
1082 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1083 __FUNCTION__, mCameraId);
1084 return res;
1085 }
1086 res = mDevice->waitUntilDrained();
1087 if (res != OK) {
1088 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1089 __FUNCTION__, mCameraId, strerror(-res), res);
1090 }
1091 res = mZslProcessor->clearZslQueue();
1092 if (res != OK) {
1093 ALOGE("%s: Camera %d: Can't clear zsl queue",
1094 __FUNCTION__, mCameraId);
1095 return res;
1096 }
1097 res = mZslProcessor->deleteStream();
1098 if (res != OK) {
1099 ALOGE("%s: Camera %d: Unable to delete zsl stream before "
1100 "record: %s (%d)", __FUNCTION__, mCameraId,
1101 strerror(-res), res);
1102 return res;
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001103 }
1104 }
1105
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001106 // Disable callbacks if they're enabled; can't record and use callbacks,
1107 // and we can't fail record start without stagefright asserting.
1108 params.previewCallbackFlags = 0;
1109
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001110 // May need to reconfigure video snapshot JPEG sizes
1111 // during recording startup, so need a more complex sequence here to
1112 // ensure an early stream reconfiguration doesn't happen
1113 bool recordingStreamNeedsUpdate;
1114 res = mStreamingProcessor->recordingStreamNeedsUpdate(params, &recordingStreamNeedsUpdate);
1115 if (res != OK) {
1116 ALOGE("%s: Camera %d: Can't query recording stream",
1117 __FUNCTION__, mCameraId);
1118 return res;
1119 }
1120
1121 if (recordingStreamNeedsUpdate) {
1122 // Need to stop stream here so updateProcessorStream won't trigger configureStream
1123 // Right now camera device cannot handle configureStream failure gracefully
1124 // when device is streaming
1125 res = mStreamingProcessor->stopStream();
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001126 if (res != OK) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001127 ALOGE("%s: Camera %d: Can't stop streaming to update record "
1128 "stream", __FUNCTION__, mCameraId);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001129 return res;
1130 }
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001131 res = mDevice->waitUntilDrained();
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001132 if (res != OK) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001133 ALOGE("%s: Camera %d: Waiting to stop streaming failed: "
1134 "%s (%d)", __FUNCTION__, mCameraId,
1135 strerror(-res), res);
1136 }
1137
1138 res = updateProcessorStream<
1139 StreamingProcessor,
1140 &StreamingProcessor::updateRecordingStream>(
1141 mStreamingProcessor,
1142 params);
1143 if (res != OK) {
1144 ALOGE("%s: Camera %d: Unable to update recording stream: "
1145 "%s (%d)", __FUNCTION__, mCameraId,
1146 strerror(-res), res);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001147 return res;
1148 }
1149 }
1150
Zhijun Hed1d64672013-09-06 15:00:01 -07001151 Vector<int32_t> outputStreams;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001152 outputStreams.push(getPreviewStreamId());
1153 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001154
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001155 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1156 outputStreams);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001157
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001158 // startStream might trigger a configureStream call and device might fail
1159 // configureStream due to jpeg size > video size. Try again with jpeg size overridden
1160 // to video size.
1161 if (res == BAD_VALUE) {
1162 overrideVideoSnapshotSize(params);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001163 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1164 outputStreams);
1165 }
1166
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001167 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001168 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001169 __FUNCTION__, mCameraId, strerror(-res), res);
1170 return res;
1171 }
1172
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001173 if (params.state < Parameters::RECORD) {
1174 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001175 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001176
1177 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001178}
1179
1180void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001181 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001182 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001183 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001184 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001185
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001186 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001187 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1188
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001189 switch (l.mParameters.state) {
1190 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001191 // OK to stop
1192 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001193 case Parameters::STOPPED:
1194 case Parameters::PREVIEW:
1195 case Parameters::STILL_CAPTURE:
1196 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001197 default:
1198 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001199 __FUNCTION__, mCameraId,
1200 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001201 return;
1202 };
1203
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001204 sCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001205
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001206 // Remove recording stream because the video target may be abandoned soon.
1207 res = stopStream();
1208 if (res != OK) {
1209 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
1210 __FUNCTION__, mCameraId, strerror(-res), res);
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001211 }
1212
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001213 res = mDevice->waitUntilDrained();
1214 if (res != OK) {
1215 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1216 __FUNCTION__, mCameraId, strerror(-res), res);
1217 }
1218 // Clean up recording stream
1219 res = mStreamingProcessor->deleteRecordingStream();
1220 if (res != OK) {
1221 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1222 "stop preview: %s (%d)",
1223 __FUNCTION__, mCameraId, strerror(-res), res);
1224 }
1225 l.mParameters.recoverOverriddenJpegSize();
1226
1227 // Restart preview
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001228 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001229 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001230 ALOGE("%s: Camera %d: Unable to return to preview",
1231 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001232 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001233}
1234
1235bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001236 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001237 Mutex::Autolock icl(mBinderSerializationLock);
James Dong8da4cd72012-08-04 19:58:07 -07001238
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001239 if ( checkPid(__FUNCTION__) != OK) return false;
1240
James Dong8da4cd72012-08-04 19:58:07 -07001241 return recordingEnabledL();
1242}
1243
1244bool Camera2Client::recordingEnabledL() {
1245 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001246 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -07001247
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001248 return (l.mParameters.state == Parameters::RECORD
1249 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001250}
1251
1252void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Chien-Yu Chen98a668f2015-12-18 14:10:33 -08001253 (void)mem;
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001254 ATRACE_CALL();
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001255 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001256}
1257
Chien-Yu Chen2d13b1d2016-04-28 12:11:20 -07001258void Camera2Client::releaseRecordingFrameHandle(native_handle_t *handle) {
1259 (void)handle;
1260 ATRACE_CALL();
1261 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1262}
1263
Yin-Chia Yehb5df5472017-03-20 19:32:19 -07001264void Camera2Client::releaseRecordingFrameHandleBatch(
1265 const std::vector<native_handle_t*>& handles) {
1266 (void)handles;
1267 ATRACE_CALL();
1268 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1269}
1270
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001271status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001272 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001273 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001274 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001275 status_t res;
1276 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1277
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001278 int triggerId;
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001279 bool notifyImmediately = false;
1280 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001281 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001282 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001283 if (l.mParameters.state < Parameters::PREVIEW) {
Zhijun Hef79f8ca2014-09-22 23:52:54 -07001284 ALOGE("%s: Camera %d: Call autoFocus when preview is inactive (state = %d).",
1285 __FUNCTION__, mCameraId, l.mParameters.state);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001286 return INVALID_OPERATION;
1287 }
1288
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001289 /**
1290 * If the camera does not support auto-focus, it is a no-op and
1291 * onAutoFocus(boolean, Camera) callback will be called immediately
1292 * with a fake value of success set to true.
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001293 *
1294 * Similarly, if focus mode is set to INFINITY, there's no reason to
1295 * bother the HAL.
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001296 */
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001297 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1298 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001299 notifyImmediately = true;
1300 notifySuccess = true;
1301 }
1302 /**
1303 * If we're in CAF mode, and AF has already been locked, just fire back
1304 * the callback right away; the HAL would not send a notification since
1305 * no state change would happen on a AF trigger.
1306 */
1307 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1308 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1309 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1310 notifyImmediately = true;
1311 notifySuccess = true;
1312 }
1313 /**
1314 * Send immediate notification back to client
1315 */
1316 if (notifyImmediately) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001317 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1318 if (l.mRemoteCallback != 0) {
1319 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001320 notifySuccess ? 1 : 0, 0);
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001321 }
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001322 return OK;
1323 }
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001324 /**
1325 * Handle quirk mode for AF in scene modes
1326 */
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001327 if (l.mParameters.quirks.triggerAfWithAuto &&
Ruben Brunkc69b91c2014-01-17 17:12:10 -08001328 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED &&
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001329 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1330 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001331 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1332 __FUNCTION__, l.mParameters.focusMode);
1333 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1334 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1335 updateRequests(l.mParameters);
1336 }
1337
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001338 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1339 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001340 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001341 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1342
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001343 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001344
1345 mDevice->triggerAutofocus(triggerId);
1346
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001347 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001348}
1349
1350status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001351 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001352 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001353 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001354 status_t res;
1355 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1356
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001357 int triggerId;
1358 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001359 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001360 // Canceling does nothing in FIXED or INFINITY modes
1361 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1362 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1363 return OK;
1364 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001365
1366 // An active AF trigger is canceled
1367 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1368 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1369 }
1370
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001371 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001372
1373 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001374 // the real state at this point. No need to cancel explicitly if
1375 // changing the AF mode.
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001376 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1377 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1378 l.mParameters.shadowFocusMode);
1379 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1380 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1381 updateRequests(l.mParameters);
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001382
1383 return OK;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001384 }
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001385 if (l.mParameters.allowZslMode) {
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001386 mZslProcessor->clearZslQueue();
1387 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001388 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001389 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001390
1391 mDevice->triggerCancelAutofocus(triggerId);
1392
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001393 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001394}
1395
Ben Murdochff823702012-11-28 13:58:29 +00001396status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001397 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001398 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001399 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001400 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001401
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001402 int takePictureCounter;
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001403 {
1404 SharedParameters::Lock l(mParameters);
1405 switch (l.mParameters.state) {
1406 case Parameters::DISCONNECTED:
1407 case Parameters::STOPPED:
1408 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1409 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001410 __FUNCTION__, mCameraId);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001411 return INVALID_OPERATION;
1412 case Parameters::PREVIEW:
1413 // Good to go for takePicture
1414 res = commandStopFaceDetectionL(l.mParameters);
1415 if (res != OK) {
1416 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1417 __FUNCTION__, mCameraId);
1418 return res;
1419 }
1420 l.mParameters.state = Parameters::STILL_CAPTURE;
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001421
1422 // Remove recording stream to prevent video snapshot jpeg logic kicking in
1423 if (l.mParameters.isJpegSizeOverridden() &&
1424 mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
1425 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1426 if (res != OK) {
1427 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1428 __FUNCTION__, mCameraId, strerror(-res), res);
1429 }
1430 res = mDevice->waitUntilDrained();
1431 if (res != OK) {
1432 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1433 __FUNCTION__, mCameraId, strerror(-res), res);
1434 }
1435 // Clean up recording stream
1436 res = mStreamingProcessor->deleteRecordingStream();
1437 if (res != OK) {
1438 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1439 "stop preview: %s (%d)",
1440 __FUNCTION__, mCameraId, strerror(-res), res);
1441 }
1442 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1443 if (res != OK) {
1444 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1445 __FUNCTION__, mCameraId, strerror(-res), res);
1446 }
1447 l.mParameters.recoverOverriddenJpegSize();
1448 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001449 break;
1450 case Parameters::RECORD:
1451 // Good to go for video snapshot
1452 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1453 break;
1454 case Parameters::STILL_CAPTURE:
1455 case Parameters::VIDEO_SNAPSHOT:
1456 ALOGE("%s: Camera %d: Already taking a picture",
1457 __FUNCTION__, mCameraId);
1458 return INVALID_OPERATION;
1459 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001460
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001461 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Zhijun Hee2d83752014-06-23 10:22:37 -07001462 int lastJpegStreamId = mJpegProcessor->getStreamId();
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -08001463 // slowJpegMode will create jpeg stream in CaptureSequencer before capturing
1464 if (!l.mParameters.slowJpegMode) {
1465 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1466 }
1467
Yin-Chia Yehd3c5b082014-09-15 14:50:06 -07001468 // If video snapshot fail to configureStream, try override video snapshot size to
1469 // video size
1470 if (res == BAD_VALUE && l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
1471 overrideVideoSnapshotSize(l.mParameters);
1472 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1473 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001474 if (res != OK) {
1475 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1476 __FUNCTION__, mCameraId, strerror(-res), res);
1477 return res;
1478 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001479 takePictureCounter = ++l.mParameters.takePictureCounter;
Zhijun Hee2d83752014-06-23 10:22:37 -07001480
1481 // Clear ZSL buffer queue when Jpeg size is changed.
1482 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001483 if (l.mParameters.allowZslMode && jpegStreamChanged) {
Zhijun Hee2d83752014-06-23 10:22:37 -07001484 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
1485 __FUNCTION__, mCameraId);
1486 mZslProcessor->clearZslQueue();
1487 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001488 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001489
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001490 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1491
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001492 // Need HAL to have correct settings before (possibly) triggering precapture
1493 syncWithDevice();
1494
Igor Murashkinaa9e3e02012-11-26 10:50:55 -08001495 res = mCaptureSequencer->startCapture(msgType);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001496 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001497 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001498 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001499 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001500
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001501 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001502}
1503
1504status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001505 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001506 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001507 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001508 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001509 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1510
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001511 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001512
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001513 Parameters::focusMode_t focusModeBefore = l.mParameters.focusMode;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001514 res = l.mParameters.set(params);
1515 if (res != OK) return res;
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001516 Parameters::focusMode_t focusModeAfter = l.mParameters.focusMode;
1517
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001518 if (l.mParameters.allowZslMode && focusModeAfter != focusModeBefore) {
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001519 mZslProcessor->clearZslQueue();
1520 }
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001521
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001522 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001523
1524 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001525}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001526
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001527String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001528 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001529 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001530 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinebe865b2014-08-07 17:07:28 -07001531 // The camera service can unconditionally get the parameters at all times
1532 if (getCallingPid() != mServicePid && checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001533
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001534 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001535
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001536 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001537}
1538
1539status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001540 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001541 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001542 status_t res;
1543 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001544
1545 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1546 cmd, arg1, arg2);
1547
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001548 switch (cmd) {
1549 case CAMERA_CMD_START_SMOOTH_ZOOM:
1550 return commandStartSmoothZoomL();
1551 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1552 return commandStopSmoothZoomL();
1553 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1554 return commandSetDisplayOrientationL(arg1);
1555 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1556 return commandEnableShutterSoundL(arg1 == 1);
1557 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1558 return commandPlayRecordingSoundL();
1559 case CAMERA_CMD_START_FACE_DETECTION:
1560 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001561 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001562 SharedParameters::Lock l(mParameters);
1563 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001564 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001565 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1566 return commandEnableFocusMoveMsgL(arg1 == 1);
1567 case CAMERA_CMD_PING:
1568 return commandPingL();
1569 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
Eino-Ville Talvalad46a6b92015-05-14 17:26:24 -07001570 case CAMERA_CMD_SET_VIDEO_FORMAT:
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001571 ALOGE("%s: command %d (arguments %d, %d) is not supported.",
1572 __FUNCTION__, cmd, arg1, arg2);
1573 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001574 default:
1575 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1576 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001577 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001578 }
1579}
James Dong983cf232012-08-01 16:39:55 -07001580
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001581status_t Camera2Client::commandStartSmoothZoomL() {
1582 ALOGE("%s: Unimplemented!", __FUNCTION__);
1583 return OK;
1584}
James Dong983cf232012-08-01 16:39:55 -07001585
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001586status_t Camera2Client::commandStopSmoothZoomL() {
1587 ALOGE("%s: Unimplemented!", __FUNCTION__);
1588 return OK;
1589}
James Dong983cf232012-08-01 16:39:55 -07001590
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001591status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001592 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001593 mCameraFacing == CAMERA_FACING_FRONT);
1594 if (transform == -1) {
1595 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1596 __FUNCTION__, mCameraId, degrees);
1597 return BAD_VALUE;
1598 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001599 SharedParameters::Lock l(mParameters);
1600 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001601 getPreviewStreamId() != NO_STREAM) {
1602 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001603 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001604 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001605 return OK;
1606}
1607
1608status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001609 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001610 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001611 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001612 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001613 }
1614
Igor Murashkina858ea02014-08-19 14:53:08 -07001615 // the camera2 api legacy mode can unconditionally disable the shutter sound
1616 if (mLegacyMode) {
1617 ALOGV("%s: Disable shutter sound in legacy mode", __FUNCTION__);
1618 l.mParameters.playShutterSound = false;
1619 return OK;
1620 }
1621
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001622 // Disabling shutter sound may not be allowed. In that case only
1623 // allow the mediaserver process to disable the sound.
1624 char value[PROPERTY_VALUE_MAX];
1625 property_get("ro.camera.sound.forced", value, "0");
1626 if (strncmp(value, "0", 2) != 0) {
1627 // Disabling shutter sound is not allowed. Deny if the current
1628 // process is not mediaserver.
1629 if (getCallingPid() != getpid()) {
1630 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1631 getCallingPid());
1632 return PERMISSION_DENIED;
1633 }
1634 }
1635
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001636 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001637 return OK;
1638}
1639
1640status_t Camera2Client::commandPlayRecordingSoundL() {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001641 sCameraService->playSound(CameraService::SOUND_RECORDING_START);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001642 return OK;
1643}
1644
Igor Murashkinddf3c502012-10-12 16:56:11 -07001645status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001646 ALOGV("%s: Camera %d: Starting face detection",
1647 __FUNCTION__, mCameraId);
1648 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001649 SharedParameters::Lock l(mParameters);
1650 switch (l.mParameters.state) {
1651 case Parameters::DISCONNECTED:
1652 case Parameters::STOPPED:
1653 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1654 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001655 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1656 __FUNCTION__, mCameraId);
1657 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001658 case Parameters::PREVIEW:
1659 case Parameters::RECORD:
1660 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001661 // Good to go for starting face detect
1662 break;
1663 }
1664 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001665 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkind32b99b2012-11-27 16:25:46 -08001666 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001667 ALOGE("%s: Camera %d: Face detection not supported",
1668 __FUNCTION__, mCameraId);
Ziv Hendelcaf3a9c2013-03-21 03:25:32 +02001669 return BAD_VALUE;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001670 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001671 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001672
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001673 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001674
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001675 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001676
1677 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001678}
1679
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001680status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001681 status_t res = OK;
1682 ALOGV("%s: Camera %d: Stopping face detection",
1683 __FUNCTION__, mCameraId);
1684
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001685 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001686
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001687 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001688
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001689 if (params.state == Parameters::PREVIEW
1690 || params.state == Parameters::RECORD
1691 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001692 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001693 }
1694
1695 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001696}
1697
1698status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001699 SharedParameters::Lock l(mParameters);
1700 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001701
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001702 return OK;
1703}
1704
1705status_t Camera2Client::commandPingL() {
1706 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001707 SharedParameters::Lock l(mParameters);
1708 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001709 return OK;
1710 } else {
1711 return NO_INIT;
1712 }
1713}
1714
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001715void Camera2Client::notifyError(int32_t errorCode,
Ruben Brunka485dfe2015-04-14 13:43:47 -07001716 const CaptureResultExtras& resultExtras) {
1717 int32_t err = CAMERA_ERROR_UNKNOWN;
1718 switch(errorCode) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001719 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001720 err = CAMERA_ERROR_RELEASED;
1721 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001722 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001723 err = CAMERA_ERROR_UNKNOWN;
1724 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001725 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001726 err = CAMERA_ERROR_SERVER_DIED;
1727 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001728 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST:
1729 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT:
1730 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001731 ALOGW("%s: Received recoverable error %d from HAL - ignoring, requestId %" PRId32,
1732 __FUNCTION__, errorCode, resultExtras.requestId);
1733 return;
1734 default:
1735 err = CAMERA_ERROR_UNKNOWN;
1736 break;
1737 }
1738
1739 ALOGE("%s: Error condition %d reported by HAL, requestId %" PRId32, __FUNCTION__, errorCode,
1740 resultExtras.requestId);
1741
1742 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1743 if (l.mRemoteCallback != nullptr) {
1744 l.mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, err, 0);
1745 }
1746}
1747
1748
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001749/** Device-related methods */
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001750void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1751 ALOGV("%s: Autofocus state now %d, last trigger %d",
1752 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001753 bool sendCompletedMessage = false;
1754 bool sendMovingMessage = false;
1755
1756 bool success = false;
1757 bool afInMotion = false;
1758 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001759 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001760 // Trace end of AF state
1761 char tmp[32];
1762 if (l.mParameters.afStateCounter > 0) {
1763 camera_metadata_enum_snprint(
1764 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1765 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1766 }
1767
1768 // Update state
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001769 l.mParameters.focusState = newState;
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001770 l.mParameters.afStateCounter++;
1771
1772 // Trace start of AF state
1773
1774 camera_metadata_enum_snprint(
1775 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1776 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1777
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001778 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001779 case Parameters::FOCUS_MODE_AUTO:
1780 case Parameters::FOCUS_MODE_MACRO:
1781 // Don't send notifications upstream if they're not for the current AF
1782 // trigger. For example, if cancel was called in between, or if we
1783 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001784 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001785 switch (newState) {
1786 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1787 success = true;
1788 // no break
1789 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1790 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001791 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001792 break;
1793 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1794 // Just starting focusing, ignore
1795 break;
1796 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1797 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1798 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001799 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001800 default:
1801 // Unexpected in AUTO/MACRO mode
1802 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1803 __FUNCTION__, newState);
1804 break;
1805 }
1806 break;
1807 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1808 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1809 switch (newState) {
1810 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1811 success = true;
1812 // no break
1813 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1814 // Don't send notifications upstream if they're not for
1815 // the current AF trigger. For example, if cancel was
1816 // called in between, or if we already sent a
1817 // notification about this AF call.
1818 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001819 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001820 sendCompletedMessage = true;
1821 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001822 if (l.mParameters.enableFocusMoveMessages &&
1823 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001824 sendMovingMessage = true;
1825 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001826 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001827 break;
1828 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1829 // Cancel was called, or we switched state; care if
1830 // currently moving
1831 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001832 if (l.mParameters.enableFocusMoveMessages &&
1833 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001834 sendMovingMessage = true;
1835 }
1836 break;
1837 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1838 // Start passive scan, inform upstream
1839 afInMotion = true;
1840 // no break
1841 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001842 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001843 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001844 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001845 sendMovingMessage = true;
1846 }
1847 break;
1848 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001849 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001850 break;
1851 case Parameters::FOCUS_MODE_EDOF:
1852 case Parameters::FOCUS_MODE_INFINITY:
1853 case Parameters::FOCUS_MODE_FIXED:
1854 default:
1855 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001856 ALOGE("%s: Unexpected AF state change %d "
1857 "(ID %d) in focus mode %d",
1858 __FUNCTION__, newState, triggerId,
1859 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001860 }
1861 }
1862 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001863 if (sendMovingMessage) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001864 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1865 if (l.mRemoteCallback != 0) {
1866 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001867 afInMotion ? 1 : 0, 0);
1868 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001869 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001870 if (sendCompletedMessage) {
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001871 ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001872 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1873 if (l.mRemoteCallback != 0) {
1874 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001875 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001876 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001877 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001878}
1879
1880void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1881 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1882 __FUNCTION__, newState, triggerId);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001883 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001884}
1885
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001886void Camera2Client::notifyShutter(const CaptureResultExtras& resultExtras,
1887 nsecs_t timestamp) {
1888 (void)resultExtras;
1889 (void)timestamp;
1890
1891 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64,
1892 __FUNCTION__, resultExtras.requestId, timestamp);
1893 mCaptureSequencer->notifyShutter(resultExtras, timestamp);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07001894
1895 Camera2ClientBase::notifyShutter(resultExtras, timestamp);
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001896}
1897
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001898camera2::SharedParameters& Camera2Client::getParameters() {
1899 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001900}
1901
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001902int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001903 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001904}
1905
1906int Camera2Client::getCaptureStreamId() const {
1907 return mJpegProcessor->getStreamId();
1908}
1909
1910int Camera2Client::getCallbackStreamId() const {
1911 return mCallbackProcessor->getStreamId();
1912}
1913
1914int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001915 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001916}
1917
1918int Camera2Client::getZslStreamId() const {
1919 return mZslProcessor->getStreamId();
1920}
1921
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001922status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -07001923 const wp<camera2::FrameProcessor::FilteredListener>& listener, bool sendPartials) {
Zhijun He25a0aef2014-06-25 11:40:02 -07001924 return mFrameProcessor->registerListener(minId, maxId, listener, sendPartials);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001925}
1926
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001927status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -07001928 const wp<camera2::FrameProcessor::FilteredListener>& listener) {
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001929 return mFrameProcessor->removeListener(minId, maxId, listener);
1930}
1931
1932status_t Camera2Client::stopStream() {
1933 return mStreamingProcessor->stopStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001934}
1935
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -08001936status_t Camera2Client::createJpegStreamL(Parameters &params) {
1937 status_t res = OK;
1938 int lastJpegStreamId = mJpegProcessor->getStreamId();
1939 if (lastJpegStreamId != NO_STREAM) {
1940 return INVALID_OPERATION;
1941 }
1942
1943 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1944 if (res != OK) {
1945 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1946 __FUNCTION__, mCameraId, strerror(-res), res);
1947 return res;
1948 }
1949
1950 res = mDevice->flush();
1951 if (res != OK) {
1952 ALOGE("%s: Camera %d: Unable flush device: %s (%d)",
1953 __FUNCTION__, mCameraId, strerror(-res), res);
1954 return res;
1955 }
1956
1957 // Ideally we don't need this, but current camera device
1958 // status tracking mechanism demands it.
1959 res = mDevice->waitUntilDrained();
1960 if (res != OK) {
1961 ALOGE("%s: Camera %d: Waiting device drain failed: %s (%d)",
1962 __FUNCTION__, mCameraId, strerror(-res), res);
1963 }
1964
1965 res = updateProcessorStream(mJpegProcessor, params);
1966 return res;
1967}
1968
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001969const int32_t Camera2Client::kPreviewRequestIdStart;
1970const int32_t Camera2Client::kPreviewRequestIdEnd;
1971const int32_t Camera2Client::kRecordingRequestIdStart;
1972const int32_t Camera2Client::kRecordingRequestIdEnd;
1973const int32_t Camera2Client::kCaptureRequestIdStart;
1974const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001975
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001976/** Utility methods */
1977
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001978status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001979 status_t res;
1980
Igor Murashkin22d58d32012-10-02 19:07:14 -07001981 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1982
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001983 res = mStreamingProcessor->incrementStreamingIds();
1984 if (res != OK) {
1985 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1986 __FUNCTION__, mCameraId, strerror(-res), res);
1987 return res;
1988 }
1989
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001990 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001991 if (res != OK) {
1992 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1993 __FUNCTION__, mCameraId, strerror(-res), res);
1994 return res;
1995 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001996 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001997 if (res != OK) {
1998 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1999 __FUNCTION__, mCameraId, strerror(-res), res);
2000 return res;
2001 }
2002
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07002003 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07002004 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002005 if (res != OK) {
2006 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
2007 __FUNCTION__, mCameraId, strerror(-res), res);
2008 return res;
2009 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07002010 } else if (params.state == Parameters::RECORD ||
2011 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07002012 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002013 if (res != OK) {
2014 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
2015 __FUNCTION__, mCameraId, strerror(-res), res);
2016 return res;
2017 }
2018 }
2019 return res;
2020}
2021
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07002022
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002023size_t Camera2Client::calculateBufferSize(int width, int height,
2024 int format, int stride) {
2025 switch (format) {
2026 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
2027 return width * height * 2;
2028 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
2029 return width * height * 3 / 2;
2030 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
2031 return width * height * 2;
2032 case HAL_PIXEL_FORMAT_YV12: { // YV12
2033 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07002034 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002035 size_t uvSize = uvStride * height / 2;
2036 return ySize + uvSize * 2;
2037 }
2038 case HAL_PIXEL_FORMAT_RGB_565:
2039 return width * height * 2;
2040 case HAL_PIXEL_FORMAT_RGBA_8888:
2041 return width * height * 4;
Eino-Ville Talvalaa97dfeb2015-02-19 16:26:13 -08002042 case HAL_PIXEL_FORMAT_RAW16:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002043 return width * height * 2;
2044 default:
2045 ALOGE("%s: Unknown preview format: %x",
2046 __FUNCTION__, format);
2047 return 0;
2048 }
2049}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002050
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002051status_t Camera2Client::syncWithDevice() {
2052 ATRACE_CALL();
Eino-Ville Talvala43b7ac62012-10-23 09:09:01 -07002053 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002054 status_t res;
2055
2056 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
2057 if (activeRequestId == 0) return OK;
2058
2059 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
2060 if (res == TIMED_OUT) {
2061 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
2062 __FUNCTION__, mCameraId);
2063 } else if (res != OK) {
2064 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
2065 __FUNCTION__, mCameraId);
2066 }
2067 return res;
2068}
2069
Igor Murashkindca254a2013-05-13 14:53:44 -07002070template <typename ProcessorT>
2071status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2072 camera2::Parameters params) {
Igor Murashkin82db9e62013-05-21 11:38:49 -07002073 // No default template arguments until C++11, so we need this overload
2074 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
2075 processor, params);
2076}
2077
2078template <typename ProcessorT,
2079 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
2080status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2081 Parameters params) {
Igor Murashkindca254a2013-05-13 14:53:44 -07002082 status_t res;
2083
Igor Murashkin82db9e62013-05-21 11:38:49 -07002084 // Get raw pointer since sp<T> doesn't have operator->*
2085 ProcessorT *processorPtr = processor.get();
2086 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002087
2088 /**
2089 * Can't update the stream if it's busy?
2090 *
2091 * Then we need to stop the device (by temporarily clearing the request
2092 * queue) and then try again. Resume streaming once we're done.
2093 */
2094 if (res == -EBUSY) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07002095 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
2096 mCameraId);
Igor Murashkindca254a2013-05-13 14:53:44 -07002097 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2098 if (res != OK) {
2099 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2100 __FUNCTION__, mCameraId, strerror(-res), res);
2101 }
2102
2103 res = mDevice->waitUntilDrained();
2104 if (res != OK) {
2105 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
2106 __FUNCTION__, mCameraId, strerror(-res), res);
2107 }
2108
Igor Murashkin82db9e62013-05-21 11:38:49 -07002109 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002110 if (res != OK) {
2111 ALOGE("%s: Camera %d: Failed to update processing stream "
2112 " despite having halted streaming first: %s (%d)",
2113 __FUNCTION__, mCameraId, strerror(-res), res);
2114 }
2115
2116 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
2117 if (res != OK) {
2118 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
2119 __FUNCTION__, mCameraId, strerror(-res), res);
2120 }
2121 }
2122
2123 return res;
2124}
Igor Murashkin44cfcf02013-03-01 16:22:28 -08002125
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07002126status_t Camera2Client::overrideVideoSnapshotSize(Parameters &params) {
2127 ALOGV("%s: Camera %d: configure still size to video size before recording"
2128 , __FUNCTION__, mCameraId);
2129 params.overrideJpegSizeByVideoSize();
2130 status_t res = updateProcessorStream(mJpegProcessor, params);
2131 if (res != OK) {
2132 ALOGE("%s: Camera %d: Can't override video snapshot size to video size: %s (%d)",
2133 __FUNCTION__, mCameraId, strerror(-res), res);
2134 }
2135 return res;
2136}
2137
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08002138status_t Camera2Client::setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer) {
2139 ATRACE_CALL();
2140 ALOGV("%s: E", __FUNCTION__);
2141 Mutex::Autolock icl(mBinderSerializationLock);
2142 status_t res;
2143 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
2144
2145 sp<IBinder> binder = IInterface::asBinder(bufferProducer);
2146 if (binder == mVideoSurface) {
2147 ALOGV("%s: Camera %d: New video window is same as old video window",
2148 __FUNCTION__, mCameraId);
2149 return NO_ERROR;
2150 }
2151
2152 sp<Surface> window;
2153 int format;
2154 android_dataspace dataSpace;
2155
2156 if (bufferProducer != nullptr) {
2157 // Using controlledByApp flag to ensure that the buffer queue remains in
2158 // async mode for the old camera API, where many applications depend
2159 // on that behavior.
2160 window = new Surface(bufferProducer, /*controlledByApp*/ true);
2161
2162 ANativeWindow *anw = window.get();
2163
2164 if ((res = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) {
2165 ALOGE("%s: Failed to query Surface format", __FUNCTION__);
2166 return res;
2167 }
2168
2169 if ((res = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE,
2170 reinterpret_cast<int*>(&dataSpace))) != OK) {
2171 ALOGE("%s: Failed to query Surface dataSpace", __FUNCTION__);
2172 return res;
2173 }
2174 }
2175
2176 Parameters::State state;
2177 {
2178 SharedParameters::Lock l(mParameters);
2179 state = l.mParameters.state;
2180 }
2181
2182 switch (state) {
2183 case Parameters::STOPPED:
2184 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
2185 case Parameters::PREVIEW:
2186 // OK
2187 break;
2188 case Parameters::DISCONNECTED:
2189 case Parameters::RECORD:
2190 case Parameters::STILL_CAPTURE:
2191 case Parameters::VIDEO_SNAPSHOT:
2192 default:
2193 ALOGE("%s: Camera %d: Cannot set video target while in state %s",
2194 __FUNCTION__, mCameraId,
2195 Parameters::getStateName(state));
2196 return INVALID_OPERATION;
2197 }
2198
2199 mVideoSurface = binder;
2200 res = mStreamingProcessor->setRecordingWindow(window);
2201 if (res != OK) {
2202 ALOGE("%s: Unable to set new recording window: %s (%d)",
2203 __FUNCTION__, strerror(-res), res);
2204 return res;
2205 }
2206
2207 {
2208 SharedParameters::Lock l(mParameters);
2209 l.mParameters.videoFormat = format;
2210 l.mParameters.videoDataSpace = dataSpace;
2211 }
2212
2213 return OK;
2214}
2215
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07002216const char* Camera2Client::kAutofocusLabel = "autofocus";
2217const char* Camera2Client::kTakepictureLabel = "take_picture";
2218
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07002219} // namespace android