blob: 5fdec34e7a37cdb4837a67fd85faf423f46da285 [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
Eino-Ville Talvala852c3812012-09-24 09:46:53 -070017#define LOG_TAG "Camera2"
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
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070021#include <utils/Log.h>
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070022#include <utils/Trace.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070023
24#include <cutils/properties.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070025#include <gui/Surface.h>
James Painterc3dbf1a2012-09-05 18:02:32 -070026#include "camera2/Parameters.h"
James Painterfe140e82012-09-07 16:36:50 -070027#include "Camera2Client.h"
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080028#include "Camera2Device.h"
29#include "Camera3Device.h"
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070030
Igor Murashkin2fba5842013-04-22 14:03:54 -070031#include "camera2/ZslProcessor.h"
32#include "camera2/ZslProcessor3.h"
33
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070034#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
35#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
36
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070037namespace android {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070038using namespace camera2;
39
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070040static int getCallingPid() {
41 return IPCThreadState::self()->getCallingPid();
42}
43
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070044// Interface used by CameraService
45
46Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
47 const sp<ICameraClient>& cameraClient,
Eino-Ville Talvala48af7e82013-02-19 10:40:14 -080048 const String16& clientPackageName,
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070049 int cameraId,
50 int cameraFacing,
Igor Murashkin8dcdb952012-10-02 16:05:11 -070051 int clientPid,
Eino-Ville Talvala48af7e82013-02-19 10:40:14 -080052 uid_t clientUid,
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080053 int servicePid,
54 int deviceVersion):
Igor Murashkina2e203b2013-03-01 16:22:28 -080055 Camera2ClientBase(cameraService, cameraClient, clientPackageName,
Eino-Ville Talvala48af7e82013-02-19 10:40:14 -080056 cameraId, cameraFacing, clientPid, clientUid, servicePid),
Igor Murashkin2fba5842013-04-22 14:03:54 -070057 mParameters(cameraId, cameraFacing),
58 mDeviceVersion(deviceVersion)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070059{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070060 ATRACE_CALL();
Eino-Ville Talvala69230df2012-08-29 17:37:16 -070061 ALOGI("Camera %d: Opened", cameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070062
Igor Murashkin2fba5842013-04-22 14:03:54 -070063 switch (mDeviceVersion) {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080064 case CAMERA_DEVICE_API_VERSION_2_0:
65 mDevice = new Camera2Device(cameraId);
66 break;
67 case CAMERA_DEVICE_API_VERSION_3_0:
68 mDevice = new Camera3Device(cameraId);
69 break;
70 default:
71 ALOGE("Camera %d: Unknown HAL device version %d",
Igor Murashkin2fba5842013-04-22 14:03:54 -070072 cameraId, mDeviceVersion);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080073 mDevice = NULL;
74 break;
75 }
76
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070077
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070078 SharedParameters::Lock l(mParameters);
79 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070080}
81
82status_t Camera2Client::initialize(camera_module_t *module)
83{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070084 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070085 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070086 status_t res;
87
Igor Murashkin9ab909b2013-03-04 17:25:57 -080088 res = Camera2ClientBase::initialize(module);
Eino-Ville Talvala48af7e82013-02-19 10:40:14 -080089 if (res != OK) {
90 return res;
91 }
92
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070093 SharedParameters::Lock l(mParameters);
94
95 res = l.mParameters.initialize(&(mDevice->info()));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070096 if (res != OK) {
97 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
98 __FUNCTION__, mCameraId, strerror(-res), res);
99 return NO_INIT;
100 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -0700101
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700102 String8 threadName;
Eino-Ville Talvala177bd342012-08-28 01:25:43 -0700103
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700104 mStreamingProcessor = new StreamingProcessor(this);
105
Igor Murashkin71381052013-03-04 14:53:08 -0800106 mFrameProcessor = new FrameProcessor(mDevice, this);
Eino-Ville Talvala852c3812012-09-24 09:46:53 -0700107 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700108 mCameraId);
109 mFrameProcessor->run(threadName.string());
110
111 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala852c3812012-09-24 09:46:53 -0700112 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700113 mCameraId);
114 mCaptureSequencer->run(threadName.string());
115
116 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala852c3812012-09-24 09:46:53 -0700117 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700118 mCameraId);
119 mJpegProcessor->run(threadName.string());
120
Igor Murashkin2fba5842013-04-22 14:03:54 -0700121 switch (mDeviceVersion) {
122 case CAMERA_DEVICE_API_VERSION_2_0: {
123 sp<ZslProcessor> zslProc =
124 new ZslProcessor(this, mCaptureSequencer);
125 mZslProcessor = zslProc;
126 mZslProcessorThread = zslProc;
127 break;
128 }
129 case CAMERA_DEVICE_API_VERSION_3_0:{
130 sp<ZslProcessor3> zslProc =
131 new ZslProcessor3(this, mCaptureSequencer);
132 mZslProcessor = zslProc;
133 mZslProcessorThread = zslProc;
134 break;
135 }
136 default:
137 break;
138 }
Eino-Ville Talvala852c3812012-09-24 09:46:53 -0700139 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700140 mCameraId);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700141 mZslProcessorThread->run(threadName.string());
Eino-Ville Talvala177bd342012-08-28 01:25:43 -0700142
Eino-Ville Talvala28639182012-08-28 11:34:14 -0700143 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala852c3812012-09-24 09:46:53 -0700144 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700145 mCameraId);
146 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvala28639182012-08-28 11:34:14 -0700147
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700148 if (gLogLevel >= 1) {
149 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
150 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700151 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700152 }
153
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700154 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700155}
156
157Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700158 ATRACE_CALL();
Eino-Ville Talvala02f84572013-04-23 15:16:57 -0700159 ALOGV("~Camera2Client");
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700160
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700161 mDestructionStarted = true;
162
Eino-Ville Talvala61704882012-10-09 22:16:58 -0700163 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700164
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700165 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700166}
167
168status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700169 String8 result;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700170 result.appendFormat("Client2[%d] (%p) Client: %s PID: %d, dump:\n",
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700171 mCameraId,
Igor Murashkina2e203b2013-03-01 16:22:28 -0800172 getRemoteCallback()->asBinder().get(),
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700173 String8(mClientPackageName).string(),
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700174 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700175 result.append(" State: ");
176#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
177
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700178 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700179
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700180 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700181
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700182 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700183 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700184 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700185 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700186 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700187 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700188 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700189 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700190 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700191 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700192 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700193 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700194 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700195 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700196 p.jpegQuality, p.jpegThumbQuality);
197 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700198 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700199 p.gpsEnabled ? "enabled" : "disabled");
200 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700201 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700202 p.gpsCoordinates[0], p.gpsCoordinates[1],
203 p.gpsCoordinates[2]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700204 result.appendFormat(" GPS timestamp: %lld\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700205 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700206 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700207 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700208 }
209
210 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700211 switch (p.wbMode) {
Igor Murashkin2d2b40b2012-11-27 16:25:46 -0800212 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
213 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
214 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
215 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
216 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
217 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
218 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
219 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700220 default: result.append("UNKNOWN\n");
221 }
222
223 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700224 switch (p.effectMode) {
Igor Murashkin2d2b40b2012-11-27 16:25:46 -0800225 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
226 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
227 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
228 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
229 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
230 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
231 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
232 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
233 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700234 default: result.append("UNKNOWN\n");
235 }
236
237 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700238 switch (p.antibandingMode) {
Igor Murashkin2d2b40b2012-11-27 16:25:46 -0800239 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
240 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
241 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
242 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700243 default: result.append("UNKNOWN\n");
244 }
245
246 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700247 switch (p.sceneMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700248 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
249 result.append("AUTO\n"); break;
250 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
251 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
252 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
255 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
258 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
259 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
260 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
261 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
262 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
263 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
264 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
265 default: result.append("UNKNOWN\n");
266 }
267
268 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700269 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700270 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
271 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
272 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
273 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
274 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
275 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
276 default: result.append("UNKNOWN\n");
277 }
278
279 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700280 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700281 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
282 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
283 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
284 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
285 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
286 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
287 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
288 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
289 default: result.append("UNKNOWN\n");
290 }
291
Eino-Ville Talvalaf1a6e0d2012-10-16 10:17:30 -0700292 result.append(" Focus state: ");
293 switch (p.focusState) {
294 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
295 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
296 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
297 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
298 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
299 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
300 default: result.append("UNKNOWN\n");
301 }
302
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700303 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700304 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700305 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700306 p.focusingAreas[i].left,
307 p.focusingAreas[i].top,
308 p.focusingAreas[i].right,
309 p.focusingAreas[i].bottom,
310 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700311 }
312
313 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700314 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700315
316 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700317 p.autoExposureLock ? "enabled" : "disabled",
318 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700319
320 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700321 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700322 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700323 p.meteringAreas[i].left,
324 p.meteringAreas[i].top,
325 p.meteringAreas[i].right,
326 p.meteringAreas[i].bottom,
327 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700328 }
329
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700330 result.appendFormat(" Zoom index: %d\n", p.zoom);
331 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
332 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700333
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700334 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700335 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700336
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700337 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700338 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700339
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700340 result.append(" Current streams:\n");
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700341 result.appendFormat(" Preview stream ID: %d\n",
342 getPreviewStreamId());
Eino-Ville Talvala177bd342012-08-28 01:25:43 -0700343 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700344 getCaptureStreamId());
345 result.appendFormat(" Recording stream ID: %d\n",
346 getRecordingStreamId());
Eino-Ville Talvala596cb972012-10-02 18:14:49 -0700347
348 result.append(" Quirks for this camera:\n");
349 bool haveQuirk = false;
350 if (p.quirks.triggerAfWithAuto) {
351 result.appendFormat(" triggerAfWithAuto\n");
352 haveQuirk = true;
353 }
354 if (p.quirks.useZslFormat) {
355 result.appendFormat(" useZslFormat\n");
356 haveQuirk = true;
357 }
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700358 if (p.quirks.meteringCropRegion) {
359 result.appendFormat(" meteringCropRegion\n");
360 haveQuirk = true;
361 }
Eino-Ville Talvala596cb972012-10-02 18:14:49 -0700362 if (!haveQuirk) {
363 result.appendFormat(" none\n");
364 }
365
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700366 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700367
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700368 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700369
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700370 mCaptureSequencer->dump(fd, args);
371
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700372 mFrameProcessor->dump(fd, args);
373
Eino-Ville Talvala22745492012-09-17 17:55:07 -0700374 mZslProcessor->dump(fd, args);
375
Igor Murashkina2e203b2013-03-01 16:22:28 -0800376 return dumpDevice(fd, args);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700377#undef CASE_APPEND_ENUM
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700378}
379
380// ICamera interface
381
382void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700383 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -0800384 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala61704882012-10-09 22:16:58 -0700385
386 // Allow both client and the media server to disconnect at all times
387 int callingPid = getCallingPid();
388 if (callingPid != mClientPid && callingPid != mServicePid) return;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700389
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700390 if (mDevice == 0) return;
391
Eino-Ville Talvala7adb52f2012-09-20 14:44:20 -0700392 ALOGV("Camera %d: Shutting down", mCameraId);
393
Eino-Ville Talvala02f84572013-04-23 15:16:57 -0700394 /**
395 * disconnect() cannot call any methods that might need to promote a
396 * wp<Camera2Client>, since disconnect can be called from the destructor, at
397 * which point all such promotions will fail.
398 */
399
Eino-Ville Talvalae0493842012-10-05 12:03:10 -0700400 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700401
Eino-Ville Talvala7adb52f2012-09-20 14:44:20 -0700402 {
403 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala61704882012-10-09 22:16:58 -0700404 if (l.mParameters.state == Parameters::DISCONNECTED) return;
Eino-Ville Talvala7adb52f2012-09-20 14:44:20 -0700405 l.mParameters.state = Parameters::DISCONNECTED;
406 }
407
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700408 mStreamingProcessor->deletePreviewStream();
409 mStreamingProcessor->deleteRecordingStream();
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700410 mJpegProcessor->deleteStream();
Eino-Ville Talvala28639182012-08-28 11:34:14 -0700411 mCallbackProcessor->deleteStream();
Eino-Ville Talvala7d8b92b2012-09-05 19:02:43 -0700412 mZslProcessor->deleteStream();
413
Eino-Ville Talvala7adb52f2012-09-20 14:44:20 -0700414 mFrameProcessor->requestExit();
415 mCaptureSequencer->requestExit();
416 mJpegProcessor->requestExit();
Igor Murashkin2fba5842013-04-22 14:03:54 -0700417 mZslProcessorThread->requestExit();
Eino-Ville Talvala7adb52f2012-09-20 14:44:20 -0700418 mCallbackProcessor->requestExit();
419
420 ALOGV("Camera %d: Waiting for threads", mCameraId);
421
422 mFrameProcessor->join();
423 mCaptureSequencer->join();
424 mJpegProcessor->join();
Igor Murashkin2fba5842013-04-22 14:03:54 -0700425 mZslProcessorThread->join();
Eino-Ville Talvala7adb52f2012-09-20 14:44:20 -0700426 mCallbackProcessor->join();
427
428 ALOGV("Camera %d: Disconnecting device", mCameraId);
429
430 mDevice->disconnect();
431
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700432 mDevice.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700433
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700434 CameraService::Client::disconnect();
435}
436
437status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700438 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700439 ALOGV("%s: E", __FUNCTION__);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800440 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700441
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700442 if (mClientPid != 0 && getCallingPid() != mClientPid) {
443 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
444 "current locked to pid %d", __FUNCTION__,
445 mCameraId, getCallingPid(), mClientPid);
446 return BAD_VALUE;
447 }
448
449 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700450
Igor Murashkina2e203b2013-03-01 16:22:28 -0800451 mRemoteCallback = client;
452 mSharedCameraCallbacks = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700453
454 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700455}
456
457status_t Camera2Client::lock() {
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 Murashkina2e203b2013-03-01 16:22:28 -0800460 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700461 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
462 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700463
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700464 if (mClientPid == 0) {
465 mClientPid = getCallingPid();
466 return OK;
467 }
468
469 if (mClientPid != getCallingPid()) {
470 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
471 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
472 return EBUSY;
473 }
474
475 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700476}
477
478status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700479 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700480 ALOGV("%s: E", __FUNCTION__);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800481 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700482 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
483 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700484
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700485 if (mClientPid == getCallingPid()) {
Eino-Ville Talvalacfee40e2012-10-10 15:28:53 -0700486 SharedParameters::Lock l(mParameters);
487 if (l.mParameters.state == Parameters::RECORD ||
488 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
489 ALOGD("Not allowed to unlock camera during recording.");
490 return INVALID_OPERATION;
491 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700492 mClientPid = 0;
Igor Murashkina2e203b2013-03-01 16:22:28 -0800493 mRemoteCallback.clear();
494 mSharedCameraCallbacks.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700495 return OK;
496 }
497
498 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
499 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
500 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700501}
502
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700503status_t Camera2Client::setPreviewDisplay(
504 const sp<Surface>& surface) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700505 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700506 ALOGV("%s: E", __FUNCTION__);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800507 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700508 status_t res;
509 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700510
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700511 sp<IBinder> binder;
512 sp<ANativeWindow> window;
513 if (surface != 0) {
Mathias Agopiana6843662013-02-19 18:25:33 -0800514 binder = surface->getIGraphicBufferProducer()->asBinder();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700515 window = surface;
516 }
517
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700518 return setPreviewWindowL(binder,window);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700519}
520
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700521status_t Camera2Client::setPreviewTexture(
Andy McFadden484566c2012-12-18 09:46:54 -0800522 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700523 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700524 ALOGV("%s: E", __FUNCTION__);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800525 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700526 status_t res;
527 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700528
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700529 sp<IBinder> binder;
530 sp<ANativeWindow> window;
Andy McFadden484566c2012-12-18 09:46:54 -0800531 if (bufferProducer != 0) {
532 binder = bufferProducer->asBinder();
Mathias Agopianb1e7cd12013-02-14 17:11:27 -0800533 window = new Surface(bufferProducer);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700534 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700535 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700536}
537
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700538status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700539 sp<ANativeWindow> window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700540 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700541 status_t res;
542
543 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700544 ALOGV("%s: Camera %d: New window is same as old window",
545 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700546 return NO_ERROR;
547 }
548
Eino-Ville Talvalac0fdb982012-10-17 16:32:34 -0700549 Parameters::State state;
550 {
551 SharedParameters::Lock l(mParameters);
552 state = l.mParameters.state;
553 }
554 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700555 case Parameters::DISCONNECTED:
556 case Parameters::RECORD:
557 case Parameters::STILL_CAPTURE:
558 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700559 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700560 __FUNCTION__, mCameraId,
Eino-Ville Talvalac0fdb982012-10-17 16:32:34 -0700561 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700562 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700563 case Parameters::STOPPED:
564 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700565 // OK
566 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700567 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700568 // Already running preview - need to stop and create a new stream
Eino-Ville Talvala02f84572013-04-23 15:16:57 -0700569 res = stopStream();
570 if (res != OK) {
571 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
572 __FUNCTION__, strerror(-res), res);
573 return res;
574 }
Eino-Ville Talvalac0fdb982012-10-17 16:32:34 -0700575 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700576 break;
577 }
578
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700579 mPreviewSurface = binder;
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700580 res = mStreamingProcessor->setPreviewWindow(window);
581 if (res != OK) {
582 ALOGE("%s: Unable to set new preview window: %s (%d)",
583 __FUNCTION__, strerror(-res), res);
584 return res;
585 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700586
Eino-Ville Talvalac0fdb982012-10-17 16:32:34 -0700587 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
588 SharedParameters::Lock l(mParameters);
589 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700590 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700591 }
592
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700593 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700594}
595
596void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700597 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700598 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800599 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinebe3f692012-10-12 16:56:11 -0700600
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700601 if ( checkPid(__FUNCTION__) != OK) return;
602
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700603 SharedParameters::Lock l(mParameters);
604 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700605}
606
607void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
608 status_t res = OK;
609 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
610 ALOGV("%s: setting oneshot", __FUNCTION__);
611 params.previewCallbackOneShot = true;
612 }
613 if (params.previewCallbackFlags != (uint32_t)flag) {
614 params.previewCallbackFlags = flag;
615 switch(params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700616 case Parameters::PREVIEW:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700617 res = startPreviewL(params, true);
618 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700619 case Parameters::RECORD:
620 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700621 res = startRecordingL(params, true);
622 break;
623 default:
624 break;
625 }
626 if (res != OK) {
627 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700628 __FUNCTION__, mCameraId,
629 Parameters::getStateName(params.state));
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700630 }
631 }
632
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700633}
634
635status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700636 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700637 ALOGV("%s: E", __FUNCTION__);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800638 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700639 status_t res;
640 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700641 SharedParameters::Lock l(mParameters);
642 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700643}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700644
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700645status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700646 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700647 status_t res;
Igor Murashkin0cb290b2012-10-02 19:07:14 -0700648
649 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
650
Eino-Ville Talvala411ddcc2012-10-10 17:17:01 -0700651 if ( (params.state == Parameters::PREVIEW ||
652 params.state == Parameters::RECORD ||
653 params.state == Parameters::VIDEO_SNAPSHOT)
654 && !restart) {
655 // Succeed attempt to re-enter a streaming state
656 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
657 __FUNCTION__, mCameraId);
Alex Ray71d64542012-09-26 15:52:50 -0700658 return OK;
659 }
660 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700661 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700662 __FUNCTION__,
663 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700664 return INVALID_OPERATION;
665 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700666
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700667 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700668 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700669 return OK;
670 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700671 params.state = Parameters::STOPPED;
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700672
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700673 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700674 if (res != OK) {
675 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
676 __FUNCTION__, mCameraId, strerror(-res), res);
677 return res;
678 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700679
680 Vector<uint8_t> outputStreams;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700681 bool callbacksEnabled = params.previewCallbackFlags &
682 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
683 if (callbacksEnabled) {
Eino-Ville Talvala28639182012-08-28 11:34:14 -0700684 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700685 if (res != OK) {
686 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
687 __FUNCTION__, mCameraId, strerror(-res), res);
688 return res;
689 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700690 outputStreams.push(getCallbackStreamId());
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700691 }
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -0700692 if (params.zslMode && !params.recordingHint) {
Igor Murashkin52827132013-05-13 14:53:44 -0700693 res = updateProcessorStream(mZslProcessor, params);
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700694 if (res != OK) {
695 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
696 __FUNCTION__, mCameraId, strerror(-res), res);
697 return res;
698 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700699 outputStreams.push(getZslStreamId());
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700700 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700701
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700702 outputStreams.push(getPreviewStreamId());
703
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -0700704 if (!params.recordingHint) {
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700705 if (!restart) {
706 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -0700707 if (res != OK) {
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700708 ALOGE("%s: Camera %d: Can't set up preview request: "
709 "%s (%d)", __FUNCTION__, mCameraId,
710 strerror(-res), res);
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -0700711 return res;
712 }
713 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700714 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
715 outputStreams);
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -0700716 } else {
717 // With recording hint set, we're going to be operating under the
718 // assumption that the user will record video. To optimize recording
719 // startup time, create the necessary output streams for recording and
720 // video snapshot now if they don't already exist.
Igor Murashkin52827132013-05-13 14:53:44 -0700721 res = updateProcessorStream(mJpegProcessor, params);
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -0700722 if (res != OK) {
723 ALOGE("%s: Camera %d: Can't pre-configure still image "
724 "stream: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700725 __FUNCTION__, mCameraId, strerror(-res), res);
726 return res;
727 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700728
729 if (!restart) {
730 res = mStreamingProcessor->updateRecordingRequest(params);
731 if (res != OK) {
732 ALOGE("%s: Camera %d: Can't set up preview request with "
733 "record hint: %s (%d)", __FUNCTION__, mCameraId,
734 strerror(-res), res);
735 return res;
736 }
737 }
738 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
739 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700740 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700741 if (res != OK) {
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700742 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700743 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700744 return res;
745 }
746
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700747 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700748 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700749}
750
751void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700752 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700753 ALOGV("%s: E", __FUNCTION__);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800754 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700755 status_t res;
756 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700757 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700758}
759
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700760void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700761 ATRACE_CALL();
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -0700762 status_t res;
Eino-Ville Talvalae0493842012-10-05 12:03:10 -0700763 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700764 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700765 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700766 SharedParameters::Lock l(mParameters);
767 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700768 }
769
770 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700771 case Parameters::DISCONNECTED:
Eino-Ville Talvala48af7e82013-02-19 10:40:14 -0800772 // Nothing to do.
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700773 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700774 case Parameters::STOPPED:
Eino-Ville Talvalae0493842012-10-05 12:03:10 -0700775 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700776 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalae0493842012-10-05 12:03:10 -0700777 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
778 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700779 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700780 case Parameters::PREVIEW:
Eino-Ville Talvala02f84572013-04-23 15:16:57 -0700781 res = stopStream();
782 if (res != OK) {
783 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
784 __FUNCTION__, mCameraId, strerror(-res), res);
785 }
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -0700786 res = mDevice->waitUntilDrained();
787 if (res != OK) {
788 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
789 __FUNCTION__, mCameraId, strerror(-res), res);
790 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700791 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700792 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
793 SharedParameters::Lock l(mParameters);
794 l.mParameters.state = Parameters::STOPPED;
795 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700796 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700797 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700798 default:
799 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700800 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700801 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700802}
803
804bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700805 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -0800806 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700807 status_t res;
808 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
809
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700810 SharedParameters::Lock l(mParameters);
811 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700812}
813
814status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700815 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -0800816 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700817 status_t res;
818 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
819
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700820 SharedParameters::Lock l(mParameters);
821 switch (l.mParameters.state) {
822 case Parameters::RECORD:
823 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700824 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700825 __FUNCTION__, mCameraId,
826 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700827 return INVALID_OPERATION;
828 default:
829 // OK
830 break;
831 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700832
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700833 l.mParameters.storeMetadataInBuffers = enabled;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700834
835 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700836}
837
838status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700839 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700840 ALOGV("%s: E", __FUNCTION__);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800841 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700842 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700843 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700844 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700845
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700846 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700847}
848
849status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
850 status_t res;
Igor Murashkin0cb290b2012-10-02 19:07:14 -0700851
852 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
853
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700854 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700855 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700856 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700857 if (res != OK) return res;
858 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700859 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700860 // Ready to go
861 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700862 case Parameters::RECORD:
863 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700864 // OK to call this when recording is already on, just skip unless
865 // we're looking to restart
866 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700867 break;
868 default:
869 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700870 __FUNCTION__, mCameraId,
871 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700872 return INVALID_OPERATION;
873 };
874
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700875 if (!params.storeMetadataInBuffers) {
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700876 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
877 "non-metadata recording mode requested!", __FUNCTION__,
878 mCameraId);
879 return INVALID_OPERATION;
880 }
881
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700882 if (!restart) {
883 mCameraService->playSound(CameraService::SOUND_RECORDING);
884 mStreamingProcessor->updateRecordingRequest(params);
885 if (res != OK) {
886 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
887 __FUNCTION__, mCameraId, strerror(-res), res);
888 return res;
889 }
890 }
Eino-Ville Talvala33578832012-09-06 18:26:58 -0700891
Igor Murashkin82db9e62013-05-21 11:38:49 -0700892 res = updateProcessorStream<
893 StreamingProcessor,
894 &StreamingProcessor::updateRecordingStream>(mStreamingProcessor,
895 params);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700896 if (res != OK) {
897 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
898 __FUNCTION__, mCameraId, strerror(-res), res);
899 return res;
900 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700901
902 Vector<uint8_t> outputStreams;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700903 bool callbacksEnabled = params.previewCallbackFlags &
904 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
905 if (callbacksEnabled) {
Eino-Ville Talvala28639182012-08-28 11:34:14 -0700906 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700907 if (res != OK) {
908 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
909 __FUNCTION__, mCameraId, strerror(-res), res);
910 return res;
911 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700912 outputStreams.push(getCallbackStreamId());
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700913 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700914 outputStreams.push(getPreviewStreamId());
915 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700916
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700917 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
918 outputStreams);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700919 if (res != OK) {
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700920 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700921 __FUNCTION__, mCameraId, strerror(-res), res);
922 return res;
923 }
924
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700925 if (params.state < Parameters::RECORD) {
926 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700927 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700928
929 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700930}
931
932void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700933 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700934 ALOGV("%s: E", __FUNCTION__);
Igor Murashkina2e203b2013-03-01 16:22:28 -0800935 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700936 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700937
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700938 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700939 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
940
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700941 switch (l.mParameters.state) {
942 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700943 // OK to stop
944 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700945 case Parameters::STOPPED:
946 case Parameters::PREVIEW:
947 case Parameters::STILL_CAPTURE:
948 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700949 default:
950 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700951 __FUNCTION__, mCameraId,
952 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700953 return;
954 };
955
Eino-Ville Talvala33578832012-09-06 18:26:58 -0700956 mCameraService->playSound(CameraService::SOUND_RECORDING);
957
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -0700958 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700959 if (res != OK) {
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -0700960 ALOGE("%s: Camera %d: Unable to return to preview",
961 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700962 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700963}
964
965bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700966 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -0800967 Mutex::Autolock icl(mBinderSerializationLock);
James Dong8da4cd72012-08-04 19:58:07 -0700968
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700969 if ( checkPid(__FUNCTION__) != OK) return false;
970
James Dong8da4cd72012-08-04 19:58:07 -0700971 return recordingEnabledL();
972}
973
974bool Camera2Client::recordingEnabledL() {
975 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700976 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -0700977
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700978 return (l.mParameters.state == Parameters::RECORD
979 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700980}
981
982void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700983 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -0800984 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700985 if ( checkPid(__FUNCTION__) != OK) return;
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -0700986
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -0700987 mStreamingProcessor->releaseRecordingFrame(mem);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700988}
989
990status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700991 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -0800992 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700993 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700994 status_t res;
995 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
996
Eino-Ville Talvala174181e2012-08-03 13:53:39 -0700997 int triggerId;
Eino-Ville Talvalaf1a6e0d2012-10-16 10:17:30 -0700998 bool notifyImmediately = false;
999 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001000 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001001 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001002 if (l.mParameters.state < Parameters::PREVIEW) {
1003 return INVALID_OPERATION;
1004 }
1005
Igor Murashkin5b44bee2012-10-08 18:05:12 -07001006 /**
1007 * If the camera does not support auto-focus, it is a no-op and
1008 * onAutoFocus(boolean, Camera) callback will be called immediately
1009 * with a fake value of success set to true.
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001010 *
1011 * Similarly, if focus mode is set to INFINITY, there's no reason to
1012 * bother the HAL.
Igor Murashkin5b44bee2012-10-08 18:05:12 -07001013 */
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001014 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1015 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
Eino-Ville Talvalaf1a6e0d2012-10-16 10:17:30 -07001016 notifyImmediately = true;
1017 notifySuccess = true;
1018 }
1019 /**
1020 * If we're in CAF mode, and AF has already been locked, just fire back
1021 * the callback right away; the HAL would not send a notification since
1022 * no state change would happen on a AF trigger.
1023 */
1024 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1025 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1026 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1027 notifyImmediately = true;
1028 notifySuccess = true;
1029 }
1030 /**
1031 * Send immediate notification back to client
1032 */
1033 if (notifyImmediately) {
Igor Murashkina2e203b2013-03-01 16:22:28 -08001034 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1035 if (l.mRemoteCallback != 0) {
1036 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaf1a6e0d2012-10-16 10:17:30 -07001037 notifySuccess ? 1 : 0, 0);
Igor Murashkin5b44bee2012-10-08 18:05:12 -07001038 }
Igor Murashkin5b44bee2012-10-08 18:05:12 -07001039 return OK;
1040 }
Eino-Ville Talvalaf1a6e0d2012-10-16 10:17:30 -07001041 /**
1042 * Handle quirk mode for AF in scene modes
1043 */
Eino-Ville Talvala4c843702012-10-04 00:56:40 -07001044 if (l.mParameters.quirks.triggerAfWithAuto &&
1045 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED &&
Eino-Ville Talvala65dc3fc2012-10-16 12:58:21 -07001046 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1047 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala4c843702012-10-04 00:56:40 -07001048 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1049 __FUNCTION__, l.mParameters.focusMode);
1050 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1051 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1052 updateRequests(l.mParameters);
1053 }
1054
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001055 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1056 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001057 }
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001058 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001059
1060 mDevice->triggerAutofocus(triggerId);
1061
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001062 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001063}
1064
1065status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001066 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -08001067 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -07001068 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001069 status_t res;
1070 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1071
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001072 int triggerId;
1073 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001074 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001075 // Canceling does nothing in FIXED or INFINITY modes
1076 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1077 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1078 return OK;
1079 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001080 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala4c843702012-10-04 00:56:40 -07001081
1082 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvala65dc3fc2012-10-16 12:58:21 -07001083 // the real state at this point. No need to cancel explicitly if
1084 // changing the AF mode.
Eino-Ville Talvala4c843702012-10-04 00:56:40 -07001085 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1086 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1087 l.mParameters.shadowFocusMode);
1088 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1089 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1090 updateRequests(l.mParameters);
Eino-Ville Talvala65dc3fc2012-10-16 12:58:21 -07001091
1092 return OK;
Eino-Ville Talvala4c843702012-10-04 00:56:40 -07001093 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001094 }
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001095 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001096
1097 mDevice->triggerCancelAutofocus(triggerId);
1098
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001099 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001100}
1101
Ben Murdoch72421522012-11-28 13:58:29 +00001102status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001103 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -08001104 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001105 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001106 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001107
Eino-Ville Talvala1d838ce2012-10-24 17:30:30 -07001108 {
1109 SharedParameters::Lock l(mParameters);
1110 switch (l.mParameters.state) {
1111 case Parameters::DISCONNECTED:
1112 case Parameters::STOPPED:
1113 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1114 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001115 __FUNCTION__, mCameraId);
Eino-Ville Talvala1d838ce2012-10-24 17:30:30 -07001116 return INVALID_OPERATION;
1117 case Parameters::PREVIEW:
1118 // Good to go for takePicture
1119 res = commandStopFaceDetectionL(l.mParameters);
1120 if (res != OK) {
1121 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1122 __FUNCTION__, mCameraId);
1123 return res;
1124 }
1125 l.mParameters.state = Parameters::STILL_CAPTURE;
1126 break;
1127 case Parameters::RECORD:
1128 // Good to go for video snapshot
1129 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1130 break;
1131 case Parameters::STILL_CAPTURE:
1132 case Parameters::VIDEO_SNAPSHOT:
1133 ALOGE("%s: Camera %d: Already taking a picture",
1134 __FUNCTION__, mCameraId);
1135 return INVALID_OPERATION;
1136 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001137
Eino-Ville Talvala1d838ce2012-10-24 17:30:30 -07001138 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001139
Igor Murashkin52827132013-05-13 14:53:44 -07001140 res = updateProcessorStream(mJpegProcessor, l.mParameters);
Eino-Ville Talvala1d838ce2012-10-24 17:30:30 -07001141 if (res != OK) {
1142 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1143 __FUNCTION__, mCameraId, strerror(-res), res);
1144 return res;
1145 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001146 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001147
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001148 // Need HAL to have correct settings before (possibly) triggering precapture
1149 syncWithDevice();
1150
Igor Murashkin786a8da2012-11-26 10:50:55 -08001151 res = mCaptureSequencer->startCapture(msgType);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001152 if (res != OK) {
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001153 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001154 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001155 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001156
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001157 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001158}
1159
1160status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001161 ATRACE_CALL();
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -07001162 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkina2e203b2013-03-01 16:22:28 -08001163 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001164 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001165 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1166
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001167 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001168
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001169 res = l.mParameters.set(params);
1170 if (res != OK) return res;
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001171
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001172 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001173
1174 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001175}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001176
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001177String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001178 ATRACE_CALL();
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -07001179 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkina2e203b2013-03-01 16:22:28 -08001180 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001181 if ( checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001182
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001183 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001184
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -07001185 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001186}
1187
1188status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001189 ATRACE_CALL();
Igor Murashkina2e203b2013-03-01 16:22:28 -08001190 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001191 status_t res;
1192 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001193
1194 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1195 cmd, arg1, arg2);
1196
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001197 switch (cmd) {
1198 case CAMERA_CMD_START_SMOOTH_ZOOM:
1199 return commandStartSmoothZoomL();
1200 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1201 return commandStopSmoothZoomL();
1202 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1203 return commandSetDisplayOrientationL(arg1);
1204 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1205 return commandEnableShutterSoundL(arg1 == 1);
1206 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1207 return commandPlayRecordingSoundL();
1208 case CAMERA_CMD_START_FACE_DETECTION:
1209 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001210 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001211 SharedParameters::Lock l(mParameters);
1212 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001213 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001214 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1215 return commandEnableFocusMoveMsgL(arg1 == 1);
1216 case CAMERA_CMD_PING:
1217 return commandPingL();
1218 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1219 return commandSetVideoBufferCountL(arg1);
1220 default:
1221 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1222 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001223 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001224 }
1225}
James Dong983cf232012-08-01 16:39:55 -07001226
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001227status_t Camera2Client::commandStartSmoothZoomL() {
1228 ALOGE("%s: Unimplemented!", __FUNCTION__);
1229 return OK;
1230}
James Dong983cf232012-08-01 16:39:55 -07001231
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001232status_t Camera2Client::commandStopSmoothZoomL() {
1233 ALOGE("%s: Unimplemented!", __FUNCTION__);
1234 return OK;
1235}
James Dong983cf232012-08-01 16:39:55 -07001236
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001237status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001238 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001239 mCameraFacing == CAMERA_FACING_FRONT);
1240 if (transform == -1) {
1241 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1242 __FUNCTION__, mCameraId, degrees);
1243 return BAD_VALUE;
1244 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001245 SharedParameters::Lock l(mParameters);
1246 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -07001247 getPreviewStreamId() != NO_STREAM) {
1248 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001249 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001250 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001251 return OK;
1252}
1253
1254status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001255 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001256 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001257 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001258 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001259 }
1260
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001261 // Disabling shutter sound may not be allowed. In that case only
1262 // allow the mediaserver process to disable the sound.
1263 char value[PROPERTY_VALUE_MAX];
1264 property_get("ro.camera.sound.forced", value, "0");
1265 if (strncmp(value, "0", 2) != 0) {
1266 // Disabling shutter sound is not allowed. Deny if the current
1267 // process is not mediaserver.
1268 if (getCallingPid() != getpid()) {
1269 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1270 getCallingPid());
1271 return PERMISSION_DENIED;
1272 }
1273 }
1274
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001275 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001276 return OK;
1277}
1278
1279status_t Camera2Client::commandPlayRecordingSoundL() {
1280 mCameraService->playSound(CameraService::SOUND_RECORDING);
1281 return OK;
1282}
1283
Igor Murashkinebe3f692012-10-12 16:56:11 -07001284status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001285 ALOGV("%s: Camera %d: Starting face detection",
1286 __FUNCTION__, mCameraId);
1287 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001288 SharedParameters::Lock l(mParameters);
1289 switch (l.mParameters.state) {
1290 case Parameters::DISCONNECTED:
1291 case Parameters::STOPPED:
1292 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1293 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001294 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1295 __FUNCTION__, mCameraId);
1296 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001297 case Parameters::PREVIEW:
1298 case Parameters::RECORD:
1299 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001300 // Good to go for starting face detect
1301 break;
1302 }
1303 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001304 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkin2d2b40b2012-11-27 16:25:46 -08001305 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001306 ALOGE("%s: Camera %d: Face detection not supported",
1307 __FUNCTION__, mCameraId);
Ziv Hendelea49f4b2013-03-21 03:25:32 +02001308 return BAD_VALUE;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001309 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001310 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001311
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001312 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001313
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001314 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001315
1316 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001317}
1318
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001319status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001320 status_t res = OK;
1321 ALOGV("%s: Camera %d: Stopping face detection",
1322 __FUNCTION__, mCameraId);
1323
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001324 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001325
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001326 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001327
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001328 if (params.state == Parameters::PREVIEW
1329 || params.state == Parameters::RECORD
1330 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001331 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001332 }
1333
1334 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001335}
1336
1337status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001338 SharedParameters::Lock l(mParameters);
1339 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001340
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001341 return OK;
1342}
1343
1344status_t Camera2Client::commandPingL() {
1345 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001346 SharedParameters::Lock l(mParameters);
1347 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001348 return OK;
1349 } else {
1350 return NO_INIT;
1351 }
1352}
1353
1354status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
James Dong8da4cd72012-08-04 19:58:07 -07001355 if (recordingEnabledL()) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001356 ALOGE("%s: Camera %d: Error setting video buffer count after "
1357 "recording was started", __FUNCTION__, mCameraId);
1358 return INVALID_OPERATION;
1359 }
1360
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -07001361 return mStreamingProcessor->setRecordingBufferCount(count);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001362}
1363
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001364/** Device-related methods */
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001365void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1366 ALOGV("%s: Autofocus state now %d, last trigger %d",
1367 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001368 bool sendCompletedMessage = false;
1369 bool sendMovingMessage = false;
1370
1371 bool success = false;
1372 bool afInMotion = false;
1373 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001374 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalaf1a6e0d2012-10-16 10:17:30 -07001375 l.mParameters.focusState = newState;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001376 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001377 case Parameters::FOCUS_MODE_AUTO:
1378 case Parameters::FOCUS_MODE_MACRO:
1379 // Don't send notifications upstream if they're not for the current AF
1380 // trigger. For example, if cancel was called in between, or if we
1381 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001382 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001383 switch (newState) {
1384 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1385 success = true;
1386 // no break
1387 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1388 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001389 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001390 break;
1391 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1392 // Just starting focusing, ignore
1393 break;
1394 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1395 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1396 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1397 default:
1398 // Unexpected in AUTO/MACRO mode
1399 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1400 __FUNCTION__, newState);
1401 break;
1402 }
1403 break;
1404 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1405 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1406 switch (newState) {
1407 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1408 success = true;
1409 // no break
1410 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1411 // Don't send notifications upstream if they're not for
1412 // the current AF trigger. For example, if cancel was
1413 // called in between, or if we already sent a
1414 // notification about this AF call.
1415 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001416 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001417 sendCompletedMessage = true;
1418 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001419 if (l.mParameters.enableFocusMoveMessages &&
1420 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001421 sendMovingMessage = true;
1422 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001423 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001424 break;
1425 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1426 // Cancel was called, or we switched state; care if
1427 // currently moving
1428 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001429 if (l.mParameters.enableFocusMoveMessages &&
1430 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001431 sendMovingMessage = true;
1432 }
1433 break;
1434 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1435 // Start passive scan, inform upstream
1436 afInMotion = true;
1437 // no break
1438 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1439 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001440 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001441 sendMovingMessage = true;
1442 }
1443 break;
1444 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001445 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001446 break;
1447 case Parameters::FOCUS_MODE_EDOF:
1448 case Parameters::FOCUS_MODE_INFINITY:
1449 case Parameters::FOCUS_MODE_FIXED:
1450 default:
1451 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001452 ALOGE("%s: Unexpected AF state change %d "
1453 "(ID %d) in focus mode %d",
1454 __FUNCTION__, newState, triggerId,
1455 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001456 }
1457 }
1458 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001459 if (sendMovingMessage) {
Igor Murashkina2e203b2013-03-01 16:22:28 -08001460 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1461 if (l.mRemoteCallback != 0) {
1462 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001463 afInMotion ? 1 : 0, 0);
1464 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001465 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001466 if (sendCompletedMessage) {
Igor Murashkina2e203b2013-03-01 16:22:28 -08001467 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1468 if (l.mRemoteCallback != 0) {
1469 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001470 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001471 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001472 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001473}
1474
1475void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1476 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1477 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001478 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001479}
1480
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001481camera2::SharedParameters& Camera2Client::getParameters() {
1482 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001483}
1484
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001485int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -07001486 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001487}
1488
1489int Camera2Client::getCaptureStreamId() const {
1490 return mJpegProcessor->getStreamId();
1491}
1492
1493int Camera2Client::getCallbackStreamId() const {
1494 return mCallbackProcessor->getStreamId();
1495}
1496
1497int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -07001498 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001499}
1500
1501int Camera2Client::getZslStreamId() const {
1502 return mZslProcessor->getStreamId();
1503}
1504
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001505status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001506 wp<camera2::FrameProcessor::FilteredListener> listener) {
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001507 return mFrameProcessor->registerListener(minId, maxId, listener);
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001508}
1509
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001510status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1511 wp<camera2::FrameProcessor::FilteredListener> listener) {
1512 return mFrameProcessor->removeListener(minId, maxId, listener);
1513}
1514
1515status_t Camera2Client::stopStream() {
1516 return mStreamingProcessor->stopStream();
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001517}
1518
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001519const int32_t Camera2Client::kPreviewRequestIdStart;
1520const int32_t Camera2Client::kPreviewRequestIdEnd;
1521const int32_t Camera2Client::kRecordingRequestIdStart;
1522const int32_t Camera2Client::kRecordingRequestIdEnd;
1523const int32_t Camera2Client::kCaptureRequestIdStart;
1524const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -07001525
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001526/** Utility methods */
1527
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -07001528status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001529 status_t res;
1530
Igor Murashkin0cb290b2012-10-02 19:07:14 -07001531 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1532
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001533 res = mStreamingProcessor->incrementStreamingIds();
1534 if (res != OK) {
1535 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1536 __FUNCTION__, mCameraId, strerror(-res), res);
1537 return res;
1538 }
1539
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -07001540 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001541 if (res != OK) {
1542 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1543 __FUNCTION__, mCameraId, strerror(-res), res);
1544 return res;
1545 }
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -07001546 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001547 if (res != OK) {
1548 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1549 __FUNCTION__, mCameraId, strerror(-res), res);
1550 return res;
1551 }
1552
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001553 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvalaf98cbbe2012-08-29 18:06:32 -07001554 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001555 if (res != OK) {
1556 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1557 __FUNCTION__, mCameraId, strerror(-res), res);
1558 return res;
1559 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001560 } else if (params.state == Parameters::RECORD ||
1561 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala43cbdc52012-09-26 10:45:47 -07001562 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001563 if (res != OK) {
1564 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1565 __FUNCTION__, mCameraId, strerror(-res), res);
1566 return res;
1567 }
1568 }
1569 return res;
1570}
1571
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001572
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001573size_t Camera2Client::calculateBufferSize(int width, int height,
1574 int format, int stride) {
1575 switch (format) {
1576 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1577 return width * height * 2;
1578 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1579 return width * height * 3 / 2;
1580 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1581 return width * height * 2;
1582 case HAL_PIXEL_FORMAT_YV12: { // YV12
1583 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07001584 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001585 size_t uvSize = uvStride * height / 2;
1586 return ySize + uvSize * 2;
1587 }
1588 case HAL_PIXEL_FORMAT_RGB_565:
1589 return width * height * 2;
1590 case HAL_PIXEL_FORMAT_RGBA_8888:
1591 return width * height * 4;
1592 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1593 return width * height * 2;
1594 default:
1595 ALOGE("%s: Unknown preview format: %x",
1596 __FUNCTION__, format);
1597 return 0;
1598 }
1599}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001600
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001601status_t Camera2Client::syncWithDevice() {
1602 ATRACE_CALL();
Eino-Ville Talvalab66e9d62012-10-23 09:09:01 -07001603 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4c9eb712012-10-02 13:30:28 -07001604 status_t res;
1605
1606 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
1607 if (activeRequestId == 0) return OK;
1608
1609 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
1610 if (res == TIMED_OUT) {
1611 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
1612 __FUNCTION__, mCameraId);
1613 } else if (res != OK) {
1614 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
1615 __FUNCTION__, mCameraId);
1616 }
1617 return res;
1618}
1619
Igor Murashkin52827132013-05-13 14:53:44 -07001620template <typename ProcessorT>
1621status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1622 camera2::Parameters params) {
Igor Murashkin82db9e62013-05-21 11:38:49 -07001623 // No default template arguments until C++11, so we need this overload
1624 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
1625 processor, params);
1626}
1627
1628template <typename ProcessorT,
1629 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
1630status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1631 Parameters params) {
Igor Murashkin52827132013-05-13 14:53:44 -07001632 status_t res;
1633
Igor Murashkin82db9e62013-05-21 11:38:49 -07001634 // Get raw pointer since sp<T> doesn't have operator->*
1635 ProcessorT *processorPtr = processor.get();
1636 res = (processorPtr->*updateStreamF)(params);
Igor Murashkin52827132013-05-13 14:53:44 -07001637
1638 /**
1639 * Can't update the stream if it's busy?
1640 *
1641 * Then we need to stop the device (by temporarily clearing the request
1642 * queue) and then try again. Resume streaming once we're done.
1643 */
1644 if (res == -EBUSY) {
1645 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1646 if (res != OK) {
1647 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1648 __FUNCTION__, mCameraId, strerror(-res), res);
1649 }
1650
1651 res = mDevice->waitUntilDrained();
1652 if (res != OK) {
1653 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1654 __FUNCTION__, mCameraId, strerror(-res), res);
1655 }
1656
Igor Murashkin82db9e62013-05-21 11:38:49 -07001657 res = (processorPtr->*updateStreamF)(params);
Igor Murashkin52827132013-05-13 14:53:44 -07001658 if (res != OK) {
1659 ALOGE("%s: Camera %d: Failed to update processing stream "
1660 " despite having halted streaming first: %s (%d)",
1661 __FUNCTION__, mCameraId, strerror(-res), res);
1662 }
1663
1664 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1665 if (res != OK) {
1666 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1667 __FUNCTION__, mCameraId, strerror(-res), res);
1668 }
1669 }
1670
1671 return res;
1672}
Igor Murashkina2e203b2013-03-01 16:22:28 -08001673
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001674} // namespace android