blob: 6e7824e8f525e224cb745e0a186485e275289120 [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 Talvala61ab9f92012-05-17 10:30:54 -070027
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070028#include "api1/Camera2Client.h"
29
30#include "api1/client2/StreamingProcessor.h"
31#include "api1/client2/JpegProcessor.h"
32#include "api1/client2/CaptureSequencer.h"
33#include "api1/client2/CallbackProcessor.h"
34#include "api1/client2/ZslProcessor.h"
35#include "api1/client2/ZslProcessor3.h"
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,
50 const sp<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 Talvalaceb388d2013-02-19 10:40:14 -080059 cameraId, cameraFacing, clientPid, clientUid, servicePid),
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070060 mParameters(cameraId, cameraFacing)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070061{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070062 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070063
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070064 SharedParameters::Lock l(mParameters);
65 l.mParameters.state = Parameters::DISCONNECTED;
Igor Murashkina858ea02014-08-19 14:53:08 -070066
67 mLegacyMode = legacyMode;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070068}
69
70status_t Camera2Client::initialize(camera_module_t *module)
71{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070072 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070073 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070074 status_t res;
75
Igor Murashkine6800ce2013-03-04 17:25:57 -080076 res = Camera2ClientBase::initialize(module);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080077 if (res != OK) {
78 return res;
79 }
80
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070081 {
82 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070083
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070084 res = l.mParameters.initialize(&(mDevice->info()), mDeviceVersion);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070085 if (res != OK) {
86 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
87 __FUNCTION__, mCameraId, strerror(-res), res);
88 return NO_INIT;
89 }
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070090 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070091
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070092 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -070093
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070094 mStreamingProcessor = new StreamingProcessor(this);
Eino-Ville Talvala254446a2013-06-04 16:34:35 -070095 threadName = String8::format("C2-%d-StreamProc",
96 mCameraId);
97 mStreamingProcessor->run(threadName.string());
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070098
Igor Murashkince124da2013-03-04 14:53:08 -080099 mFrameProcessor = new FrameProcessor(mDevice, this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700100 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700101 mCameraId);
102 mFrameProcessor->run(threadName.string());
103
104 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700105 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700106 mCameraId);
107 mCaptureSequencer->run(threadName.string());
108
109 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700110 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700111 mCameraId);
112 mJpegProcessor->run(threadName.string());
113
Igor Murashkinae500e52013-04-22 14:03:54 -0700114 switch (mDeviceVersion) {
115 case CAMERA_DEVICE_API_VERSION_2_0: {
116 sp<ZslProcessor> zslProc =
117 new ZslProcessor(this, mCaptureSequencer);
118 mZslProcessor = zslProc;
119 mZslProcessorThread = zslProc;
120 break;
121 }
Zhijun He95dd5ba2014-03-26 18:18:00 -0700122 case CAMERA_DEVICE_API_VERSION_3_0:
123 case CAMERA_DEVICE_API_VERSION_3_1:
124 case CAMERA_DEVICE_API_VERSION_3_2: {
Igor Murashkinae500e52013-04-22 14:03:54 -0700125 sp<ZslProcessor3> zslProc =
126 new ZslProcessor3(this, mCaptureSequencer);
127 mZslProcessor = zslProc;
128 mZslProcessorThread = zslProc;
129 break;
130 }
131 default:
132 break;
133 }
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700134 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700135 mCameraId);
Igor Murashkinae500e52013-04-22 14:03:54 -0700136 mZslProcessorThread->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700137
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700138 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700139 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700140 mCameraId);
141 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700142
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700143 if (gLogLevel >= 1) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700144 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700145 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
146 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700147 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700148 }
149
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700150 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700151}
152
153Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700154 ATRACE_CALL();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700155 ALOGV("~Camera2Client");
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700156
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700157 mDestructionStarted = true;
158
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700159 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700160
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700161 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700162}
163
164status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700165 String8 result;
Eino-Ville Talvalad0158c32013-03-11 14:13:50 -0700166 result.appendFormat("Client2[%d] (%p) Client: %s PID: %d, dump:\n",
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700167 mCameraId,
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800168 getRemoteCallback()->asBinder().get(),
Eino-Ville Talvalad0158c32013-03-11 14:13:50 -0700169 String8(mClientPackageName).string(),
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700170 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700171 result.append(" State: ");
172#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
173
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700174 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700175
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700176 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700177
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700178 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700179 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700180 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700181 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700182 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700183 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700184 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700185 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700186 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700187 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700188 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700189 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700190 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700191 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700192 p.jpegQuality, p.jpegThumbQuality);
193 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700194 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700195 p.gpsEnabled ? "enabled" : "disabled");
196 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700197 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700198 p.gpsCoordinates[0], p.gpsCoordinates[1],
199 p.gpsCoordinates[2]);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000200 result.appendFormat(" GPS timestamp: %" PRId64 "\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700201 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700202 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700203 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700204 }
205
206 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700207 switch (p.wbMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800208 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
209 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
210 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
211 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
212 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
213 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
214 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
215 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700216 default: result.append("UNKNOWN\n");
217 }
218
219 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700220 switch (p.effectMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800221 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
223 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
224 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
225 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
226 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
227 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
228 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
229 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700230 default: result.append("UNKNOWN\n");
231 }
232
233 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700234 switch (p.antibandingMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800235 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
236 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
237 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
238 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700239 default: result.append("UNKNOWN\n");
240 }
241
242 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700243 switch (p.sceneMode) {
Ruben Brunkc69b91c2014-01-17 17:12:10 -0800244 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700245 result.append("AUTO\n"); break;
246 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
247 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
248 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
249 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
250 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
251 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
252 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
255 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
258 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
259 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
260 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
261 default: result.append("UNKNOWN\n");
262 }
263
264 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700265 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700266 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
267 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
268 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
269 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
270 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
271 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
272 default: result.append("UNKNOWN\n");
273 }
274
275 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700276 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700277 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
278 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
279 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
280 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
281 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
282 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
283 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
284 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
285 default: result.append("UNKNOWN\n");
286 }
287
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700288 result.append(" Focus state: ");
289 switch (p.focusState) {
290 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
291 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
292 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -0700293 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700294 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
295 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
296 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
297 default: result.append("UNKNOWN\n");
298 }
299
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700300 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700301 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700302 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700303 p.focusingAreas[i].left,
304 p.focusingAreas[i].top,
305 p.focusingAreas[i].right,
306 p.focusingAreas[i].bottom,
307 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700308 }
309
310 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700311 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700312
313 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700314 p.autoExposureLock ? "enabled" : "disabled",
315 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700316
317 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700318 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700319 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700320 p.meteringAreas[i].left,
321 p.meteringAreas[i].top,
322 p.meteringAreas[i].right,
323 p.meteringAreas[i].bottom,
324 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700325 }
326
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700327 result.appendFormat(" Zoom index: %d\n", p.zoom);
328 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
329 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700330
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700331 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700332 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700333
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700334 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700335 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700336
Eino-Ville Talvala0181fde2013-09-20 10:12:32 -0700337 result.appendFormat(" Selected still capture FPS range: %d - %d\n",
338 p.fastInfo.bestStillCaptureFpsRange[0],
339 p.fastInfo.bestStillCaptureFpsRange[1]);
340
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700341 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700342 result.appendFormat(" Preview stream ID: %d\n",
343 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700344 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700345 getCaptureStreamId());
346 result.appendFormat(" Recording stream ID: %d\n",
347 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700348
349 result.append(" Quirks for this camera:\n");
350 bool haveQuirk = false;
351 if (p.quirks.triggerAfWithAuto) {
352 result.appendFormat(" triggerAfWithAuto\n");
353 haveQuirk = true;
354 }
355 if (p.quirks.useZslFormat) {
356 result.appendFormat(" useZslFormat\n");
357 haveQuirk = true;
358 }
Igor Murashkin7373cbe2012-09-28 15:30:03 -0700359 if (p.quirks.meteringCropRegion) {
360 result.appendFormat(" meteringCropRegion\n");
361 haveQuirk = true;
362 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700363 if (p.quirks.partialResults) {
364 result.appendFormat(" usePartialResult\n");
365 haveQuirk = true;
366 }
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700367 if (!haveQuirk) {
368 result.appendFormat(" none\n");
369 }
370
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700371 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700372
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700373 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700374
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700375 mCaptureSequencer->dump(fd, args);
376
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700377 mFrameProcessor->dump(fd, args);
378
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700379 mZslProcessor->dump(fd, args);
380
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800381 return dumpDevice(fd, args);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700382#undef CASE_APPEND_ENUM
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700383}
384
385// ICamera interface
386
387void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700388 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800389 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700390
391 // Allow both client and the media server to disconnect at all times
392 int callingPid = getCallingPid();
393 if (callingPid != mClientPid && callingPid != mServicePid) return;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700394
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700395 if (mDevice == 0) return;
396
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700397 ALOGV("Camera %d: Shutting down", mCameraId);
398
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700399 /**
400 * disconnect() cannot call any methods that might need to promote a
401 * wp<Camera2Client>, since disconnect can be called from the destructor, at
402 * which point all such promotions will fail.
403 */
404
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700405 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700406
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700407 {
408 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700409 if (l.mParameters.state == Parameters::DISCONNECTED) return;
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700410 l.mParameters.state = Parameters::DISCONNECTED;
411 }
412
Eino-Ville Talvala254446a2013-06-04 16:34:35 -0700413 mStreamingProcessor->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700414 mFrameProcessor->requestExit();
415 mCaptureSequencer->requestExit();
416 mJpegProcessor->requestExit();
Igor Murashkinae500e52013-04-22 14:03:54 -0700417 mZslProcessorThread->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700418 mCallbackProcessor->requestExit();
419
420 ALOGV("Camera %d: Waiting for threads", mCameraId);
421
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700422 {
423 // Don't wait with lock held, in case the other threads need to
424 // complete callbacks that re-enter Camera2Client
425 mBinderSerializationLock.unlock();
426
427 mStreamingProcessor->join();
428 mFrameProcessor->join();
429 mCaptureSequencer->join();
430 mJpegProcessor->join();
431 mZslProcessorThread->join();
432 mCallbackProcessor->join();
433
434 mBinderSerializationLock.lock();
435 }
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700436
Ruben Brunkdfe71552013-12-05 11:00:37 -0800437 ALOGV("Camera %d: Deleting streams", mCameraId);
438
439 mStreamingProcessor->deletePreviewStream();
440 mStreamingProcessor->deleteRecordingStream();
441 mJpegProcessor->deleteStream();
442 mCallbackProcessor->deleteStream();
443 mZslProcessor->deleteStream();
444
Ruben Brunk6551e1e2014-09-09 16:20:53 -0700445 // Remove all ZSL stream state before disconnect; needed to work around b/15408128.
446 mZslProcessor->disconnect();
447
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700448 ALOGV("Camera %d: Disconnecting device", mCameraId);
449
450 mDevice->disconnect();
451
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700452 mDevice.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700453
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700454 CameraService::Client::disconnect();
455}
456
457status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700458 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700459 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800460 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700461
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700462 if (mClientPid != 0 && getCallingPid() != mClientPid) {
463 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
464 "current locked to pid %d", __FUNCTION__,
465 mCameraId, getCallingPid(), mClientPid);
466 return BAD_VALUE;
467 }
468
469 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700470
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800471 mRemoteCallback = client;
472 mSharedCameraCallbacks = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700473
474 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700475}
476
477status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700478 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700479 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800480 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700481 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
482 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700483
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700484 if (mClientPid == 0) {
485 mClientPid = getCallingPid();
486 return OK;
487 }
488
489 if (mClientPid != getCallingPid()) {
490 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
491 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
492 return EBUSY;
493 }
494
495 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700496}
497
498status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700499 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700500 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800501 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700502 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
503 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700504
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700505 if (mClientPid == getCallingPid()) {
Eino-Ville Talvala907e5652012-10-10 15:28:53 -0700506 SharedParameters::Lock l(mParameters);
507 if (l.mParameters.state == Parameters::RECORD ||
508 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
509 ALOGD("Not allowed to unlock camera during recording.");
510 return INVALID_OPERATION;
511 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700512 mClientPid = 0;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800513 mRemoteCallback.clear();
514 mSharedCameraCallbacks.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700515 return OK;
516 }
517
518 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
519 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
520 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700521}
522
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700523status_t Camera2Client::setPreviewTarget(
Andy McFadden8ba01022012-12-18 09:46:54 -0800524 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700525 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700526 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800527 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700528 status_t res;
529 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700530
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700531 sp<IBinder> binder;
532 sp<ANativeWindow> window;
Andy McFadden8ba01022012-12-18 09:46:54 -0800533 if (bufferProducer != 0) {
534 binder = bufferProducer->asBinder();
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700535 // Using controlledByApp flag to ensure that the buffer queue remains in
536 // async mode for the old camera API, where many applications depend
537 // on that behavior.
538 window = new Surface(bufferProducer, /*controlledByApp*/ true);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700539 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700540 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700541}
542
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700543status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700544 sp<ANativeWindow> window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700545 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700546 status_t res;
547
548 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700549 ALOGV("%s: Camera %d: New window is same as old window",
550 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700551 return NO_ERROR;
552 }
553
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700554 Parameters::State state;
555 {
556 SharedParameters::Lock l(mParameters);
557 state = l.mParameters.state;
558 }
559 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700560 case Parameters::DISCONNECTED:
561 case Parameters::RECORD:
562 case Parameters::STILL_CAPTURE:
563 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700564 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700565 __FUNCTION__, mCameraId,
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700566 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700567 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700568 case Parameters::STOPPED:
569 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700570 // OK
571 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700572 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700573 // Already running preview - need to stop and create a new stream
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700574 res = stopStream();
575 if (res != OK) {
576 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
577 __FUNCTION__, strerror(-res), res);
578 return res;
579 }
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700580 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700581 break;
582 }
583
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700584 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700585 res = mStreamingProcessor->setPreviewWindow(window);
586 if (res != OK) {
587 ALOGE("%s: Unable to set new preview window: %s (%d)",
588 __FUNCTION__, strerror(-res), res);
589 return res;
590 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700591
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700592 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
593 SharedParameters::Lock l(mParameters);
594 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700595 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700596 }
597
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700598 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700599}
600
601void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700602 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700603 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800604 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinddf3c502012-10-12 16:56:11 -0700605
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700606 if ( checkPid(__FUNCTION__) != OK) return;
607
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700608 SharedParameters::Lock l(mParameters);
609 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700610}
611
612void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
613 status_t res = OK;
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700614
615 switch(params.state) {
616 case Parameters::STOPPED:
617 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
618 case Parameters::PREVIEW:
Zhijun Hea2520db2013-07-08 16:12:32 -0700619 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700620 // OK
621 break;
622 default:
623 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
624 ALOGE("%s: Camera %d: Can't use preview callbacks "
625 "in state %d", __FUNCTION__, mCameraId, params.state);
626 return;
627 }
628 }
629
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700630 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
631 ALOGV("%s: setting oneshot", __FUNCTION__);
632 params.previewCallbackOneShot = true;
633 }
634 if (params.previewCallbackFlags != (uint32_t)flag) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700635
Zhijun He527748a2013-09-15 21:06:10 -0700636 if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700637 // Disable any existing preview callback window when enabling
638 // preview callback flags
639 res = mCallbackProcessor->setCallbackWindow(NULL);
640 if (res != OK) {
641 ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
642 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
643 return;
644 }
645 params.previewCallbackSurface = false;
646 }
647
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700648 params.previewCallbackFlags = flag;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700649
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700650 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700651 res = startPreviewL(params, true);
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700652 if (res != OK) {
653 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
654 __FUNCTION__, mCameraId,
655 Parameters::getStateName(params.state));
656 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700657 }
658 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700659}
660
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700661status_t Camera2Client::setPreviewCallbackTarget(
662 const sp<IGraphicBufferProducer>& callbackProducer) {
663 ATRACE_CALL();
664 ALOGV("%s: E", __FUNCTION__);
665 Mutex::Autolock icl(mBinderSerializationLock);
666 status_t res;
667 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
668
669 sp<ANativeWindow> window;
670 if (callbackProducer != 0) {
671 window = new Surface(callbackProducer);
672 }
673
674 res = mCallbackProcessor->setCallbackWindow(window);
675 if (res != OK) {
676 ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
677 __FUNCTION__, mCameraId, strerror(-res), res);
678 return res;
679 }
680
681 SharedParameters::Lock l(mParameters);
682
683 if (window != NULL) {
684 // Disable traditional callbacks when a valid callback target is given
685 l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
686 l.mParameters.previewCallbackOneShot = false;
687 l.mParameters.previewCallbackSurface = true;
688 } else {
689 // Disable callback target if given a NULL interface.
690 l.mParameters.previewCallbackSurface = false;
691 }
692
693 switch(l.mParameters.state) {
694 case Parameters::PREVIEW:
695 res = startPreviewL(l.mParameters, true);
696 break;
697 case Parameters::RECORD:
698 case Parameters::VIDEO_SNAPSHOT:
699 res = startRecordingL(l.mParameters, true);
700 break;
701 default:
702 break;
703 }
704 if (res != OK) {
705 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
706 __FUNCTION__, mCameraId,
707 Parameters::getStateName(l.mParameters.state));
708 }
709
710 return OK;
711}
712
713
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700714status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700715 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700716 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800717 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700718 status_t res;
719 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700720 SharedParameters::Lock l(mParameters);
721 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700722}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700723
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700724status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700725 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700726 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700727
728 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
729
Eino-Ville Talvalaa14be592012-10-10 17:17:01 -0700730 if ( (params.state == Parameters::PREVIEW ||
731 params.state == Parameters::RECORD ||
732 params.state == Parameters::VIDEO_SNAPSHOT)
733 && !restart) {
734 // Succeed attempt to re-enter a streaming state
735 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
736 __FUNCTION__, mCameraId);
Alex Ray77449ad2012-09-26 15:52:50 -0700737 return OK;
738 }
739 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700740 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700741 __FUNCTION__,
742 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700743 return INVALID_OPERATION;
744 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700745
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700746 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700747 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700748 return OK;
749 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700750 params.state = Parameters::STOPPED;
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800751 int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700752
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700753 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700754 if (res != OK) {
755 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
756 __FUNCTION__, mCameraId, strerror(-res), res);
757 return res;
758 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700759
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800760 bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;
761
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700762 // We could wait to create the JPEG output stream until first actual use
763 // (first takePicture call). However, this would substantially increase the
764 // first capture latency on HAL3 devices, and potentially on some HAL2
765 // devices. So create it unconditionally at preview start. As a drawback,
766 // this increases gralloc memory consumption for applications that don't
767 // ever take a picture.
768 // TODO: Find a better compromise, though this likely would involve HAL
769 // changes.
Zhijun Hee2d83752014-06-23 10:22:37 -0700770 int lastJpegStreamId = mJpegProcessor->getStreamId();
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700771 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 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700778 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700779
Zhijun Hed1d64672013-09-06 15:00:01 -0700780 Vector<int32_t> outputStreams;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700781 bool callbacksEnabled = (params.previewCallbackFlags &
782 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
783 params.previewCallbackSurface;
784
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700785 if (callbacksEnabled) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700786 // Can't have recording stream hanging around when enabling callbacks,
787 // since it exceeds the max stream count on some devices.
788 if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
789 ALOGV("%s: Camera %d: Clearing out recording stream before "
790 "creating callback stream", __FUNCTION__, mCameraId);
791 res = mStreamingProcessor->stopStream();
792 if (res != OK) {
793 ALOGE("%s: Camera %d: Can't stop streaming to delete "
794 "recording stream", __FUNCTION__, mCameraId);
795 return res;
796 }
797 res = mStreamingProcessor->deleteRecordingStream();
798 if (res != OK) {
799 ALOGE("%s: Camera %d: Unable to delete recording stream before "
800 "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
801 strerror(-res), res);
802 return res;
803 }
804 }
805
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700806 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700807 if (res != OK) {
808 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
809 __FUNCTION__, mCameraId, strerror(-res), res);
810 return res;
811 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700812 outputStreams.push(getCallbackStreamId());
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800813 } else if (previewStreamChanged && mCallbackProcessor->getStreamId() != NO_STREAM) {
814 /**
815 * Delete the unused callback stream when preview stream is changed and
816 * preview is not enabled. Don't need stop preview stream as preview is in
817 * STOPPED state now.
818 */
819 ALOGV("%s: Camera %d: Delete unused preview callback stream.", __FUNCTION__, mCameraId);
820 res = mCallbackProcessor->deleteStream();
821 if (res != OK) {
822 ALOGE("%s: Camera %d: Unable to delete callback stream %s (%d)",
823 __FUNCTION__, mCameraId, strerror(-res), res);
824 return res;
825 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700826 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700827
828 if (params.zslMode && !params.recordingHint &&
829 getRecordingStreamId() == NO_STREAM) {
Igor Murashkindca254a2013-05-13 14:53:44 -0700830 res = updateProcessorStream(mZslProcessor, params);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700831 if (res != OK) {
832 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
833 __FUNCTION__, mCameraId, strerror(-res), res);
834 return res;
835 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700836
837 if (jpegStreamChanged) {
838 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
839 __FUNCTION__, mCameraId);
840 mZslProcessor->clearZslQueue();
841 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700842 outputStreams.push(getZslStreamId());
Zhijun He66107622013-11-01 11:05:56 -0700843 } else {
844 mZslProcessor->deleteStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700845 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700846
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700847 outputStreams.push(getPreviewStreamId());
848
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700849 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700850 if (!restart) {
851 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700852 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700853 ALOGE("%s: Camera %d: Can't set up preview request: "
854 "%s (%d)", __FUNCTION__, mCameraId,
855 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700856 return res;
857 }
858 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700859 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
860 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700861 } else {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700862 if (!restart) {
863 res = mStreamingProcessor->updateRecordingRequest(params);
864 if (res != OK) {
865 ALOGE("%s: Camera %d: Can't set up preview request with "
866 "record hint: %s (%d)", __FUNCTION__, mCameraId,
867 strerror(-res), res);
868 return res;
869 }
870 }
871 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
872 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700873 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700874 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700875 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700876 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700877 return res;
878 }
879
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700880 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700881 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700882}
883
884void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700885 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700886 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800887 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700888 status_t res;
889 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700890 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700891}
892
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700893void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700894 ATRACE_CALL();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700895 status_t res;
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700896 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700897 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700898 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700899 SharedParameters::Lock l(mParameters);
900 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700901 }
902
903 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700904 case Parameters::DISCONNECTED:
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800905 // Nothing to do.
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700906 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700907 case Parameters::STOPPED:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700908 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700909 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700910 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
911 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700912 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700913 case Parameters::PREVIEW:
Ruben Brunka27c4aa2013-09-04 18:18:26 -0700914 syncWithDevice();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700915 res = stopStream();
916 if (res != OK) {
917 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
918 __FUNCTION__, mCameraId, strerror(-res), res);
919 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700920 res = mDevice->waitUntilDrained();
921 if (res != OK) {
922 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
923 __FUNCTION__, mCameraId, strerror(-res), res);
924 }
Yin-Chia Yeh28d03272014-07-17 16:05:23 -0700925 // Clean up recording stream
926 res = mStreamingProcessor->deleteRecordingStream();
927 if (res != OK) {
928 ALOGE("%s: Camera %d: Unable to delete recording stream before "
929 "stop preview: %s (%d)",
930 __FUNCTION__, mCameraId, strerror(-res), res);
931 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700932 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700933 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
934 SharedParameters::Lock l(mParameters);
935 l.mParameters.state = Parameters::STOPPED;
936 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700937 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700938 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700939 default:
940 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700941 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700942 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700943}
944
945bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700946 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800947 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700948 status_t res;
949 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
950
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700951 SharedParameters::Lock l(mParameters);
952 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700953}
954
955status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
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 res;
960
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700961 SharedParameters::Lock l(mParameters);
962 switch (l.mParameters.state) {
963 case Parameters::RECORD:
964 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700965 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700966 __FUNCTION__, mCameraId,
967 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700968 return INVALID_OPERATION;
969 default:
970 // OK
971 break;
972 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700973
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700974 l.mParameters.storeMetadataInBuffers = enabled;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700975
976 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700977}
978
979status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700980 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700981 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800982 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700983 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700984 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700985 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700986
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700987 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700988}
989
990status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
991 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700992
993 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
994
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700995 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700996 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700997 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700998 if (res != OK) return res;
Zhijun He96ff5c42014-10-13 22:20:37 -0700999 // Make sure first preview request is submitted to the HAL device to avoid
1000 // two consecutive set of configure_streams being called into the HAL.
1001 // TODO: Refactor this to avoid initial preview configuration.
1002 syncWithDevice();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001003 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001004 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001005 // Ready to go
1006 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001007 case Parameters::RECORD:
1008 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001009 // OK to call this when recording is already on, just skip unless
1010 // we're looking to restart
1011 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001012 break;
1013 default:
1014 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001015 __FUNCTION__, mCameraId,
1016 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001017 return INVALID_OPERATION;
1018 };
1019
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001020 if (!params.storeMetadataInBuffers) {
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001021 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
1022 "non-metadata recording mode requested!", __FUNCTION__,
1023 mCameraId);
1024 return INVALID_OPERATION;
1025 }
1026
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001027 if (!restart) {
1028 mCameraService->playSound(CameraService::SOUND_RECORDING);
1029 mStreamingProcessor->updateRecordingRequest(params);
1030 if (res != OK) {
1031 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1032 __FUNCTION__, mCameraId, strerror(-res), res);
1033 return res;
1034 }
1035 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001036
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001037 // Not all devices can support a preview callback stream and a recording
1038 // stream at the same time, so assume none of them can.
1039 if (mCallbackProcessor->getStreamId() != NO_STREAM) {
1040 ALOGV("%s: Camera %d: Clearing out callback stream before "
1041 "creating recording stream", __FUNCTION__, mCameraId);
1042 res = mStreamingProcessor->stopStream();
1043 if (res != OK) {
1044 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1045 __FUNCTION__, mCameraId);
1046 return res;
1047 }
1048 res = mCallbackProcessor->deleteStream();
1049 if (res != OK) {
1050 ALOGE("%s: Camera %d: Unable to delete callback stream before "
1051 "record: %s (%d)", __FUNCTION__, mCameraId,
1052 strerror(-res), res);
1053 return res;
1054 }
1055 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001056
Eino-Ville Talvaladc2e6dd2014-09-26 13:09:54 -07001057 // On current HALs, clean up ZSL before transitioning into recording
1058 if (mDeviceVersion != CAMERA_DEVICE_API_VERSION_2_0) {
1059 if (mZslProcessor->getStreamId() != NO_STREAM) {
1060 ALOGV("%s: Camera %d: Clearing out zsl stream before "
1061 "creating recording stream", __FUNCTION__, mCameraId);
1062 res = mStreamingProcessor->stopStream();
1063 if (res != OK) {
1064 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1065 __FUNCTION__, mCameraId);
1066 return res;
1067 }
1068 res = mDevice->waitUntilDrained();
1069 if (res != OK) {
1070 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1071 __FUNCTION__, mCameraId, strerror(-res), res);
1072 }
1073 res = mZslProcessor->clearZslQueue();
1074 if (res != OK) {
1075 ALOGE("%s: Camera %d: Can't clear zsl queue",
1076 __FUNCTION__, mCameraId);
1077 return res;
1078 }
1079 res = mZslProcessor->deleteStream();
1080 if (res != OK) {
1081 ALOGE("%s: Camera %d: Unable to delete zsl stream before "
1082 "record: %s (%d)", __FUNCTION__, mCameraId,
1083 strerror(-res), res);
1084 return res;
1085 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001086 }
1087 }
1088
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001089 // Disable callbacks if they're enabled; can't record and use callbacks,
1090 // and we can't fail record start without stagefright asserting.
1091 params.previewCallbackFlags = 0;
1092
Eino-Ville Talvaladc2e6dd2014-09-26 13:09:54 -07001093 if (mDeviceVersion != CAMERA_DEVICE_API_VERSION_2_0) {
1094 // For newer devices, may need to reconfigure video snapshot JPEG sizes
1095 // during recording startup, so need a more complex sequence here to
1096 // ensure an early stream reconfiguration doesn't happen
1097 bool recordingStreamNeedsUpdate;
1098 res = mStreamingProcessor->recordingStreamNeedsUpdate(params, &recordingStreamNeedsUpdate);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001099 if (res != OK) {
Eino-Ville Talvaladc2e6dd2014-09-26 13:09:54 -07001100 ALOGE("%s: Camera %d: Can't query recording stream",
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001101 __FUNCTION__, mCameraId);
1102 return res;
1103 }
Eino-Ville Talvaladc2e6dd2014-09-26 13:09:54 -07001104
1105 if (recordingStreamNeedsUpdate) {
1106 // Need to stop stream here so updateProcessorStream won't trigger configureStream
1107 // Right now camera device cannot handle configureStream failure gracefully
1108 // when device is streaming
1109 res = mStreamingProcessor->stopStream();
1110 if (res != OK) {
1111 ALOGE("%s: Camera %d: Can't stop streaming to update record "
1112 "stream", __FUNCTION__, mCameraId);
1113 return res;
1114 }
1115 res = mDevice->waitUntilDrained();
1116 if (res != OK) {
1117 ALOGE("%s: Camera %d: Waiting to stop streaming failed: "
1118 "%s (%d)", __FUNCTION__, mCameraId,
1119 strerror(-res), res);
1120 }
1121
1122 res = updateProcessorStream<
1123 StreamingProcessor,
1124 &StreamingProcessor::updateRecordingStream>(
1125 mStreamingProcessor,
1126 params);
1127 if (res != OK) {
1128 ALOGE("%s: Camera %d: Unable to update recording stream: "
1129 "%s (%d)", __FUNCTION__, mCameraId,
1130 strerror(-res), res);
1131 return res;
1132 }
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001133 }
Eino-Ville Talvaladc2e6dd2014-09-26 13:09:54 -07001134 } else {
1135 // Maintain call sequencing for HALv2 devices.
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001136 res = updateProcessorStream<
1137 StreamingProcessor,
1138 &StreamingProcessor::updateRecordingStream>(mStreamingProcessor,
Eino-Ville Talvaladc2e6dd2014-09-26 13:09:54 -07001139 params);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001140 if (res != OK) {
1141 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
1142 __FUNCTION__, mCameraId, strerror(-res), res);
1143 return res;
1144 }
1145 }
1146
Zhijun Hed1d64672013-09-06 15:00:01 -07001147 Vector<int32_t> outputStreams;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001148 outputStreams.push(getPreviewStreamId());
1149 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001150
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001151 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1152 outputStreams);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001153
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001154 // startStream might trigger a configureStream call and device might fail
1155 // configureStream due to jpeg size > video size. Try again with jpeg size overridden
1156 // to video size.
1157 if (res == BAD_VALUE) {
1158 overrideVideoSnapshotSize(params);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001159 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1160 outputStreams);
1161 }
1162
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001163 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001164 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001165 __FUNCTION__, mCameraId, strerror(-res), res);
1166 return res;
1167 }
1168
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001169 if (params.state < Parameters::RECORD) {
1170 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001171 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001172
1173 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001174}
1175
1176void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001177 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001178 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001179 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001180 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001181
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001182 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001183 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1184
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001185 switch (l.mParameters.state) {
1186 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001187 // OK to stop
1188 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001189 case Parameters::STOPPED:
1190 case Parameters::PREVIEW:
1191 case Parameters::STILL_CAPTURE:
1192 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001193 default:
1194 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001195 __FUNCTION__, mCameraId,
1196 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001197 return;
1198 };
1199
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001200 mCameraService->playSound(CameraService::SOUND_RECORDING);
1201
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001202 // Remove recording stream to prevent it from slowing down takePicture later
1203 if (!l.mParameters.recordingHint && l.mParameters.isJpegSizeOverridden()) {
1204 res = stopStream();
1205 if (res != OK) {
1206 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
1207 __FUNCTION__, mCameraId, strerror(-res), res);
1208 }
1209 res = mDevice->waitUntilDrained();
1210 if (res != OK) {
1211 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1212 __FUNCTION__, mCameraId, strerror(-res), res);
1213 }
1214 // Clean up recording stream
1215 res = mStreamingProcessor->deleteRecordingStream();
1216 if (res != OK) {
1217 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1218 "stop preview: %s (%d)",
1219 __FUNCTION__, mCameraId, strerror(-res), res);
1220 }
1221 l.mParameters.recoverOverriddenJpegSize();
1222 }
1223
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001224 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001225 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001226 ALOGE("%s: Camera %d: Unable to return to preview",
1227 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001228 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001229}
1230
1231bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001232 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001233 Mutex::Autolock icl(mBinderSerializationLock);
James Dong8da4cd72012-08-04 19:58:07 -07001234
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001235 if ( checkPid(__FUNCTION__) != OK) return false;
1236
James Dong8da4cd72012-08-04 19:58:07 -07001237 return recordingEnabledL();
1238}
1239
1240bool Camera2Client::recordingEnabledL() {
1241 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001242 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -07001243
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001244 return (l.mParameters.state == Parameters::RECORD
1245 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001246}
1247
1248void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001249 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001250 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001251 if ( checkPid(__FUNCTION__) != OK) return;
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001252
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001253 mStreamingProcessor->releaseRecordingFrame(mem);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001254}
1255
1256status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001257 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001258 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001259 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001260 status_t res;
1261 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1262
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001263 int triggerId;
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001264 bool notifyImmediately = false;
1265 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001266 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001267 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001268 if (l.mParameters.state < Parameters::PREVIEW) {
Zhijun Hef79f8ca2014-09-22 23:52:54 -07001269 ALOGE("%s: Camera %d: Call autoFocus when preview is inactive (state = %d).",
1270 __FUNCTION__, mCameraId, l.mParameters.state);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001271 return INVALID_OPERATION;
1272 }
1273
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001274 /**
1275 * If the camera does not support auto-focus, it is a no-op and
1276 * onAutoFocus(boolean, Camera) callback will be called immediately
1277 * with a fake value of success set to true.
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001278 *
1279 * Similarly, if focus mode is set to INFINITY, there's no reason to
1280 * bother the HAL.
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001281 */
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001282 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1283 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001284 notifyImmediately = true;
1285 notifySuccess = true;
1286 }
1287 /**
1288 * If we're in CAF mode, and AF has already been locked, just fire back
1289 * the callback right away; the HAL would not send a notification since
1290 * no state change would happen on a AF trigger.
1291 */
1292 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1293 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1294 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1295 notifyImmediately = true;
1296 notifySuccess = true;
1297 }
1298 /**
1299 * Send immediate notification back to client
1300 */
1301 if (notifyImmediately) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001302 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1303 if (l.mRemoteCallback != 0) {
1304 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001305 notifySuccess ? 1 : 0, 0);
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001306 }
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001307 return OK;
1308 }
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001309 /**
1310 * Handle quirk mode for AF in scene modes
1311 */
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001312 if (l.mParameters.quirks.triggerAfWithAuto &&
Ruben Brunkc69b91c2014-01-17 17:12:10 -08001313 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED &&
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001314 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1315 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001316 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1317 __FUNCTION__, l.mParameters.focusMode);
1318 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1319 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1320 updateRequests(l.mParameters);
1321 }
1322
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001323 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1324 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001325 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001326 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1327
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001328 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001329
1330 mDevice->triggerAutofocus(triggerId);
1331
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001332 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001333}
1334
1335status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001336 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001337 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001338 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001339 status_t res;
1340 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1341
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001342 int triggerId;
1343 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001344 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001345 // Canceling does nothing in FIXED or INFINITY modes
1346 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1347 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1348 return OK;
1349 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001350
1351 // An active AF trigger is canceled
1352 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1353 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1354 }
1355
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001356 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001357
1358 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001359 // the real state at this point. No need to cancel explicitly if
1360 // changing the AF mode.
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001361 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1362 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1363 l.mParameters.shadowFocusMode);
1364 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1365 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1366 updateRequests(l.mParameters);
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001367
1368 return OK;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001369 }
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001370 if (l.mParameters.zslMode) {
1371 mZslProcessor->clearZslQueue();
1372 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001373 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001374 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001375
1376 mDevice->triggerCancelAutofocus(triggerId);
1377
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001378 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001379}
1380
Ben Murdochff823702012-11-28 13:58:29 +00001381status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001382 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001383 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001384 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001385 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001386
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001387 int takePictureCounter;
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001388 {
1389 SharedParameters::Lock l(mParameters);
1390 switch (l.mParameters.state) {
1391 case Parameters::DISCONNECTED:
1392 case Parameters::STOPPED:
1393 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1394 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001395 __FUNCTION__, mCameraId);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001396 return INVALID_OPERATION;
1397 case Parameters::PREVIEW:
1398 // Good to go for takePicture
1399 res = commandStopFaceDetectionL(l.mParameters);
1400 if (res != OK) {
1401 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1402 __FUNCTION__, mCameraId);
1403 return res;
1404 }
1405 l.mParameters.state = Parameters::STILL_CAPTURE;
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001406
1407 // Remove recording stream to prevent video snapshot jpeg logic kicking in
1408 if (l.mParameters.isJpegSizeOverridden() &&
1409 mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
1410 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1411 if (res != OK) {
1412 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1413 __FUNCTION__, mCameraId, strerror(-res), res);
1414 }
1415 res = mDevice->waitUntilDrained();
1416 if (res != OK) {
1417 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1418 __FUNCTION__, mCameraId, strerror(-res), res);
1419 }
1420 // Clean up recording stream
1421 res = mStreamingProcessor->deleteRecordingStream();
1422 if (res != OK) {
1423 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1424 "stop preview: %s (%d)",
1425 __FUNCTION__, mCameraId, strerror(-res), res);
1426 }
1427 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1428 if (res != OK) {
1429 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1430 __FUNCTION__, mCameraId, strerror(-res), res);
1431 }
1432 l.mParameters.recoverOverriddenJpegSize();
1433 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001434 break;
1435 case Parameters::RECORD:
1436 // Good to go for video snapshot
1437 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1438 break;
1439 case Parameters::STILL_CAPTURE:
1440 case Parameters::VIDEO_SNAPSHOT:
1441 ALOGE("%s: Camera %d: Already taking a picture",
1442 __FUNCTION__, mCameraId);
1443 return INVALID_OPERATION;
1444 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001445
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001446 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001447
Zhijun Hee2d83752014-06-23 10:22:37 -07001448 int lastJpegStreamId = mJpegProcessor->getStreamId();
Igor Murashkindca254a2013-05-13 14:53:44 -07001449 res = updateProcessorStream(mJpegProcessor, l.mParameters);
Yin-Chia Yehd3c5b082014-09-15 14:50:06 -07001450 // If video snapshot fail to configureStream, try override video snapshot size to
1451 // video size
1452 if (res == BAD_VALUE && l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
1453 overrideVideoSnapshotSize(l.mParameters);
1454 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1455 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001456 if (res != OK) {
1457 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1458 __FUNCTION__, mCameraId, strerror(-res), res);
1459 return res;
1460 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001461 takePictureCounter = ++l.mParameters.takePictureCounter;
Zhijun Hee2d83752014-06-23 10:22:37 -07001462
1463 // Clear ZSL buffer queue when Jpeg size is changed.
1464 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
1465 if (l.mParameters.zslMode && jpegStreamChanged) {
1466 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
1467 __FUNCTION__, mCameraId);
1468 mZslProcessor->clearZslQueue();
1469 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001470 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001471
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001472 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1473
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001474 // Need HAL to have correct settings before (possibly) triggering precapture
1475 syncWithDevice();
1476
Igor Murashkinaa9e3e02012-11-26 10:50:55 -08001477 res = mCaptureSequencer->startCapture(msgType);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001478 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001479 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001480 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001481 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001482
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001483 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001484}
1485
1486status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001487 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001488 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001489 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001490 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001491 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1492
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001493 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001494
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001495 Parameters::focusMode_t focusModeBefore = l.mParameters.focusMode;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001496 res = l.mParameters.set(params);
1497 if (res != OK) return res;
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001498 Parameters::focusMode_t focusModeAfter = l.mParameters.focusMode;
1499
1500 if (l.mParameters.zslMode && focusModeAfter != focusModeBefore) {
1501 mZslProcessor->clearZslQueue();
1502 }
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001503
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001504 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001505
1506 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001507}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001508
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001509String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001510 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001511 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001512 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinebe865b2014-08-07 17:07:28 -07001513 // The camera service can unconditionally get the parameters at all times
1514 if (getCallingPid() != mServicePid && checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001515
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001516 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001517
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001518 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001519}
1520
1521status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001522 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001523 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001524 status_t res;
1525 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001526
1527 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1528 cmd, arg1, arg2);
1529
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001530 switch (cmd) {
1531 case CAMERA_CMD_START_SMOOTH_ZOOM:
1532 return commandStartSmoothZoomL();
1533 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1534 return commandStopSmoothZoomL();
1535 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1536 return commandSetDisplayOrientationL(arg1);
1537 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1538 return commandEnableShutterSoundL(arg1 == 1);
1539 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1540 return commandPlayRecordingSoundL();
1541 case CAMERA_CMD_START_FACE_DETECTION:
1542 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001543 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001544 SharedParameters::Lock l(mParameters);
1545 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001546 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001547 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1548 return commandEnableFocusMoveMsgL(arg1 == 1);
1549 case CAMERA_CMD_PING:
1550 return commandPingL();
1551 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1552 return commandSetVideoBufferCountL(arg1);
1553 default:
1554 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1555 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001556 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001557 }
1558}
James Dong983cf232012-08-01 16:39:55 -07001559
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001560status_t Camera2Client::commandStartSmoothZoomL() {
1561 ALOGE("%s: Unimplemented!", __FUNCTION__);
1562 return OK;
1563}
James Dong983cf232012-08-01 16:39:55 -07001564
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001565status_t Camera2Client::commandStopSmoothZoomL() {
1566 ALOGE("%s: Unimplemented!", __FUNCTION__);
1567 return OK;
1568}
James Dong983cf232012-08-01 16:39:55 -07001569
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001570status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001571 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001572 mCameraFacing == CAMERA_FACING_FRONT);
1573 if (transform == -1) {
1574 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1575 __FUNCTION__, mCameraId, degrees);
1576 return BAD_VALUE;
1577 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001578 SharedParameters::Lock l(mParameters);
1579 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001580 getPreviewStreamId() != NO_STREAM) {
1581 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001582 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001583 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001584 return OK;
1585}
1586
1587status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001588 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001589 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001590 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001591 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001592 }
1593
Igor Murashkina858ea02014-08-19 14:53:08 -07001594 // the camera2 api legacy mode can unconditionally disable the shutter sound
1595 if (mLegacyMode) {
1596 ALOGV("%s: Disable shutter sound in legacy mode", __FUNCTION__);
1597 l.mParameters.playShutterSound = false;
1598 return OK;
1599 }
1600
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001601 // Disabling shutter sound may not be allowed. In that case only
1602 // allow the mediaserver process to disable the sound.
1603 char value[PROPERTY_VALUE_MAX];
1604 property_get("ro.camera.sound.forced", value, "0");
1605 if (strncmp(value, "0", 2) != 0) {
1606 // Disabling shutter sound is not allowed. Deny if the current
1607 // process is not mediaserver.
1608 if (getCallingPid() != getpid()) {
1609 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1610 getCallingPid());
1611 return PERMISSION_DENIED;
1612 }
1613 }
1614
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001615 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001616 return OK;
1617}
1618
1619status_t Camera2Client::commandPlayRecordingSoundL() {
1620 mCameraService->playSound(CameraService::SOUND_RECORDING);
1621 return OK;
1622}
1623
Igor Murashkinddf3c502012-10-12 16:56:11 -07001624status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001625 ALOGV("%s: Camera %d: Starting face detection",
1626 __FUNCTION__, mCameraId);
1627 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001628 SharedParameters::Lock l(mParameters);
1629 switch (l.mParameters.state) {
1630 case Parameters::DISCONNECTED:
1631 case Parameters::STOPPED:
1632 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1633 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001634 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1635 __FUNCTION__, mCameraId);
1636 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001637 case Parameters::PREVIEW:
1638 case Parameters::RECORD:
1639 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001640 // Good to go for starting face detect
1641 break;
1642 }
1643 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001644 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkind32b99b2012-11-27 16:25:46 -08001645 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001646 ALOGE("%s: Camera %d: Face detection not supported",
1647 __FUNCTION__, mCameraId);
Ziv Hendelcaf3a9c2013-03-21 03:25:32 +02001648 return BAD_VALUE;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001649 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001650 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001651
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001652 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001653
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001654 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001655
1656 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001657}
1658
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001659status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001660 status_t res = OK;
1661 ALOGV("%s: Camera %d: Stopping face detection",
1662 __FUNCTION__, mCameraId);
1663
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001664 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001665
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001666 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001667
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001668 if (params.state == Parameters::PREVIEW
1669 || params.state == Parameters::RECORD
1670 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001671 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001672 }
1673
1674 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001675}
1676
1677status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001678 SharedParameters::Lock l(mParameters);
1679 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001680
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001681 return OK;
1682}
1683
1684status_t Camera2Client::commandPingL() {
1685 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001686 SharedParameters::Lock l(mParameters);
1687 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001688 return OK;
1689 } else {
1690 return NO_INIT;
1691 }
1692}
1693
1694status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
James Dong8da4cd72012-08-04 19:58:07 -07001695 if (recordingEnabledL()) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001696 ALOGE("%s: Camera %d: Error setting video buffer count after "
1697 "recording was started", __FUNCTION__, mCameraId);
1698 return INVALID_OPERATION;
1699 }
1700
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001701 return mStreamingProcessor->setRecordingBufferCount(count);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001702}
1703
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001704/** Device-related methods */
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001705void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1706 ALOGV("%s: Autofocus state now %d, last trigger %d",
1707 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001708 bool sendCompletedMessage = false;
1709 bool sendMovingMessage = false;
1710
1711 bool success = false;
1712 bool afInMotion = false;
1713 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001714 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001715 // Trace end of AF state
1716 char tmp[32];
1717 if (l.mParameters.afStateCounter > 0) {
1718 camera_metadata_enum_snprint(
1719 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1720 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1721 }
1722
1723 // Update state
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001724 l.mParameters.focusState = newState;
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001725 l.mParameters.afStateCounter++;
1726
1727 // Trace start of AF state
1728
1729 camera_metadata_enum_snprint(
1730 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1731 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1732
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001733 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001734 case Parameters::FOCUS_MODE_AUTO:
1735 case Parameters::FOCUS_MODE_MACRO:
1736 // Don't send notifications upstream if they're not for the current AF
1737 // trigger. For example, if cancel was called in between, or if we
1738 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001739 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001740 switch (newState) {
1741 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1742 success = true;
1743 // no break
1744 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1745 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001746 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001747 break;
1748 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1749 // Just starting focusing, ignore
1750 break;
1751 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1752 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1753 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001754 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001755 default:
1756 // Unexpected in AUTO/MACRO mode
1757 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1758 __FUNCTION__, newState);
1759 break;
1760 }
1761 break;
1762 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1763 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1764 switch (newState) {
1765 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1766 success = true;
1767 // no break
1768 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1769 // Don't send notifications upstream if they're not for
1770 // the current AF trigger. For example, if cancel was
1771 // called in between, or if we already sent a
1772 // notification about this AF call.
1773 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001774 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001775 sendCompletedMessage = true;
1776 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001777 if (l.mParameters.enableFocusMoveMessages &&
1778 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001779 sendMovingMessage = true;
1780 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001781 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001782 break;
1783 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1784 // Cancel was called, or we switched state; care if
1785 // currently moving
1786 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001787 if (l.mParameters.enableFocusMoveMessages &&
1788 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001789 sendMovingMessage = true;
1790 }
1791 break;
1792 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1793 // Start passive scan, inform upstream
1794 afInMotion = true;
1795 // no break
1796 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001797 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001798 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001799 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001800 sendMovingMessage = true;
1801 }
1802 break;
1803 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001804 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001805 break;
1806 case Parameters::FOCUS_MODE_EDOF:
1807 case Parameters::FOCUS_MODE_INFINITY:
1808 case Parameters::FOCUS_MODE_FIXED:
1809 default:
1810 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001811 ALOGE("%s: Unexpected AF state change %d "
1812 "(ID %d) in focus mode %d",
1813 __FUNCTION__, newState, triggerId,
1814 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001815 }
1816 }
1817 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001818 if (sendMovingMessage) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001819 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1820 if (l.mRemoteCallback != 0) {
1821 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001822 afInMotion ? 1 : 0, 0);
1823 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001824 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001825 if (sendCompletedMessage) {
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001826 ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001827 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1828 if (l.mRemoteCallback != 0) {
1829 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001830 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001831 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001832 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001833}
1834
1835void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1836 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1837 __FUNCTION__, newState, triggerId);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001838 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001839}
1840
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001841camera2::SharedParameters& Camera2Client::getParameters() {
1842 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001843}
1844
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001845int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001846 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001847}
1848
1849int Camera2Client::getCaptureStreamId() const {
1850 return mJpegProcessor->getStreamId();
1851}
1852
1853int Camera2Client::getCallbackStreamId() const {
1854 return mCallbackProcessor->getStreamId();
1855}
1856
1857int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001858 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001859}
1860
1861int Camera2Client::getZslStreamId() const {
1862 return mZslProcessor->getStreamId();
1863}
1864
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001865status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Zhijun He25a0aef2014-06-25 11:40:02 -07001866 wp<camera2::FrameProcessor::FilteredListener> listener, bool sendPartials) {
1867 return mFrameProcessor->registerListener(minId, maxId, listener, sendPartials);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001868}
1869
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001870status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1871 wp<camera2::FrameProcessor::FilteredListener> listener) {
1872 return mFrameProcessor->removeListener(minId, maxId, listener);
1873}
1874
1875status_t Camera2Client::stopStream() {
1876 return mStreamingProcessor->stopStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001877}
1878
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001879const int32_t Camera2Client::kPreviewRequestIdStart;
1880const int32_t Camera2Client::kPreviewRequestIdEnd;
1881const int32_t Camera2Client::kRecordingRequestIdStart;
1882const int32_t Camera2Client::kRecordingRequestIdEnd;
1883const int32_t Camera2Client::kCaptureRequestIdStart;
1884const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001885
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001886/** Utility methods */
1887
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001888status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001889 status_t res;
1890
Igor Murashkin22d58d32012-10-02 19:07:14 -07001891 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1892
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001893 res = mStreamingProcessor->incrementStreamingIds();
1894 if (res != OK) {
1895 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1896 __FUNCTION__, mCameraId, strerror(-res), res);
1897 return res;
1898 }
1899
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001900 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001901 if (res != OK) {
1902 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1903 __FUNCTION__, mCameraId, strerror(-res), res);
1904 return res;
1905 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001906 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001907 if (res != OK) {
1908 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1909 __FUNCTION__, mCameraId, strerror(-res), res);
1910 return res;
1911 }
1912
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001913 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001914 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001915 if (res != OK) {
1916 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1917 __FUNCTION__, mCameraId, strerror(-res), res);
1918 return res;
1919 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001920 } else if (params.state == Parameters::RECORD ||
1921 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001922 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001923 if (res != OK) {
1924 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1925 __FUNCTION__, mCameraId, strerror(-res), res);
1926 return res;
1927 }
1928 }
1929 return res;
1930}
1931
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001932
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001933size_t Camera2Client::calculateBufferSize(int width, int height,
1934 int format, int stride) {
1935 switch (format) {
1936 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1937 return width * height * 2;
1938 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1939 return width * height * 3 / 2;
1940 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1941 return width * height * 2;
1942 case HAL_PIXEL_FORMAT_YV12: { // YV12
1943 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07001944 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001945 size_t uvSize = uvStride * height / 2;
1946 return ySize + uvSize * 2;
1947 }
1948 case HAL_PIXEL_FORMAT_RGB_565:
1949 return width * height * 2;
1950 case HAL_PIXEL_FORMAT_RGBA_8888:
1951 return width * height * 4;
1952 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1953 return width * height * 2;
1954 default:
1955 ALOGE("%s: Unknown preview format: %x",
1956 __FUNCTION__, format);
1957 return 0;
1958 }
1959}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001960
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001961status_t Camera2Client::syncWithDevice() {
1962 ATRACE_CALL();
Eino-Ville Talvala43b7ac62012-10-23 09:09:01 -07001963 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001964 status_t res;
1965
1966 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
1967 if (activeRequestId == 0) return OK;
1968
1969 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
1970 if (res == TIMED_OUT) {
1971 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
1972 __FUNCTION__, mCameraId);
1973 } else if (res != OK) {
1974 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
1975 __FUNCTION__, mCameraId);
1976 }
1977 return res;
1978}
1979
Igor Murashkindca254a2013-05-13 14:53:44 -07001980template <typename ProcessorT>
1981status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1982 camera2::Parameters params) {
Igor Murashkin82db9e62013-05-21 11:38:49 -07001983 // No default template arguments until C++11, so we need this overload
1984 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
1985 processor, params);
1986}
1987
1988template <typename ProcessorT,
1989 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
1990status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1991 Parameters params) {
Igor Murashkindca254a2013-05-13 14:53:44 -07001992 status_t res;
1993
Igor Murashkin82db9e62013-05-21 11:38:49 -07001994 // Get raw pointer since sp<T> doesn't have operator->*
1995 ProcessorT *processorPtr = processor.get();
1996 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07001997
1998 /**
1999 * Can't update the stream if it's busy?
2000 *
2001 * Then we need to stop the device (by temporarily clearing the request
2002 * queue) and then try again. Resume streaming once we're done.
2003 */
2004 if (res == -EBUSY) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07002005 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
2006 mCameraId);
Igor Murashkindca254a2013-05-13 14:53:44 -07002007 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2008 if (res != OK) {
2009 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2010 __FUNCTION__, mCameraId, strerror(-res), res);
2011 }
2012
2013 res = mDevice->waitUntilDrained();
2014 if (res != OK) {
2015 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
2016 __FUNCTION__, mCameraId, strerror(-res), res);
2017 }
2018
Igor Murashkin82db9e62013-05-21 11:38:49 -07002019 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002020 if (res != OK) {
2021 ALOGE("%s: Camera %d: Failed to update processing stream "
2022 " despite having halted streaming first: %s (%d)",
2023 __FUNCTION__, mCameraId, strerror(-res), res);
2024 }
2025
2026 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
2027 if (res != OK) {
2028 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
2029 __FUNCTION__, mCameraId, strerror(-res), res);
2030 }
2031 }
2032
2033 return res;
2034}
Igor Murashkin44cfcf02013-03-01 16:22:28 -08002035
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07002036status_t Camera2Client::overrideVideoSnapshotSize(Parameters &params) {
2037 ALOGV("%s: Camera %d: configure still size to video size before recording"
2038 , __FUNCTION__, mCameraId);
2039 params.overrideJpegSizeByVideoSize();
2040 status_t res = updateProcessorStream(mJpegProcessor, params);
2041 if (res != OK) {
2042 ALOGE("%s: Camera %d: Can't override video snapshot size to video size: %s (%d)",
2043 __FUNCTION__, mCameraId, strerror(-res), res);
2044 }
2045 return res;
2046}
2047
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07002048const char* Camera2Client::kAutofocusLabel = "autofocus";
2049const char* Camera2Client::kTakepictureLabel = "take_picture";
2050
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07002051} // namespace android