blob: b9feaf8ea8470587fed13f9614b8a5f64d2a9916 [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 Talvala4bb81182012-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 Paintere5382062012-09-05 18:02:32 -070026#include "camera2/Parameters.h"
James Painter10894e52012-09-07 16:36:50 -070027#include "Camera2Client.h"
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070028
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070029#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
30#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
31
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070032namespace android {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070033using namespace camera2;
34
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070035static int getCallingPid() {
36 return IPCThreadState::self()->getCallingPid();
37}
38
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070039// Interface used by CameraService
40
41Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
42 const sp<ICameraClient>& cameraClient,
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070043 int cameraId,
44 int cameraFacing,
Igor Murashkinecf17e82012-10-02 16:05:11 -070045 int clientPid,
46 int servicePid):
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070047 Client(cameraService, cameraClient,
Igor Murashkinecf17e82012-10-02 16:05:11 -070048 cameraId, cameraFacing, clientPid, servicePid),
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -070049 mSharedCameraClient(cameraClient),
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070050 mParameters(cameraId, cameraFacing)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070051{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070052 ATRACE_CALL();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070053 ALOGI("Camera %d: Opened", cameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070054
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070055 mDevice = new Camera2Device(cameraId);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070056
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070057 SharedParameters::Lock l(mParameters);
58 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070059}
60
Eino-Ville Talvala3a609142012-07-31 14:36:26 -070061status_t Camera2Client::checkPid(const char* checkLocation) const {
62 int callingPid = getCallingPid();
Eino-Ville Talvalac0379202012-10-09 22:16:58 -070063 if (callingPid == mClientPid) return NO_ERROR;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -070064
65 ALOGE("%s: attempt to use a locked camera from a different process"
Eino-Ville Talvalac0379202012-10-09 22:16:58 -070066 " (old pid %d, new pid %d)", checkLocation, mClientPid, callingPid);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -070067 return PERMISSION_DENIED;
68}
69
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070070status_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
76 res = mDevice->initialize(module);
77 if (res != OK) {
78 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
79 __FUNCTION__, mCameraId, strerror(-res), res);
80 return NO_INIT;
81 }
82
Eino-Ville Talvala174181e2012-08-03 13:53:39 -070083 res = mDevice->setNotifyCallback(this);
84
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070085 SharedParameters::Lock l(mParameters);
86
87 res = l.mParameters.initialize(&(mDevice->info()));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070088 if (res != OK) {
89 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
90 __FUNCTION__, mCameraId, strerror(-res), res);
91 return NO_INIT;
92 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070093
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070094 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -070095
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070096 mStreamingProcessor = new StreamingProcessor(this);
97
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070098 mFrameProcessor = new FrameProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -070099 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700100 mCameraId);
101 mFrameProcessor->run(threadName.string());
102
103 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700104 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700105 mCameraId);
106 mCaptureSequencer->run(threadName.string());
107
108 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700109 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700110 mCameraId);
111 mJpegProcessor->run(threadName.string());
112
113 mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700114 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700115 mCameraId);
116 mZslProcessor->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700117
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700118 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700119 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700120 mCameraId);
121 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700122
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700123 if (gLogLevel >= 1) {
124 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
125 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700126 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700127 }
128
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700129 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700130}
131
132Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700133 ATRACE_CALL();
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700134
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700135 mDestructionStarted = true;
136
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700137 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700138
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700139 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700140}
141
142status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700143 String8 result;
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700144 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n",
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700145 mCameraId,
146 getCameraClient()->asBinder().get(),
147 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700148 result.append(" State: ");
149#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
150
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700151 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700152
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700153 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700154
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700155 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700156 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700157 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700158 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700159 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700160 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700161 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700162 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700163 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700164 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700165 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700166 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700167 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700168 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700169 p.jpegQuality, p.jpegThumbQuality);
170 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700171 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700172 p.gpsEnabled ? "enabled" : "disabled");
173 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700174 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700175 p.gpsCoordinates[0], p.gpsCoordinates[1],
176 p.gpsCoordinates[2]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700177 result.appendFormat(" GPS timestamp: %lld\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700178 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700179 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700180 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700181 }
182
183 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700184 switch (p.wbMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800185 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
186 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
187 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
188 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
189 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
190 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
191 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
192 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700193 default: result.append("UNKNOWN\n");
194 }
195
196 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700197 switch (p.effectMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800198 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
199 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
200 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
201 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
202 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
203 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
204 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
205 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
206 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700207 default: result.append("UNKNOWN\n");
208 }
209
210 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700211 switch (p.antibandingMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800212 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
213 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
214 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
215 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700216 default: result.append("UNKNOWN\n");
217 }
218
219 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700220 switch (p.sceneMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700221 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
222 result.append("AUTO\n"); break;
223 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
224 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
225 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
226 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
227 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
228 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
229 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
230 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
231 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
232 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
233 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
234 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
235 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
236 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
237 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
238 default: result.append("UNKNOWN\n");
239 }
240
241 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700242 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700243 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
244 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
245 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
246 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
247 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
248 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
249 default: result.append("UNKNOWN\n");
250 }
251
252 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700253 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700254 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
255 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
256 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
257 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
258 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
259 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
260 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
261 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
262 default: result.append("UNKNOWN\n");
263 }
264
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700265 result.append(" Focus state: ");
266 switch (p.focusState) {
267 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
268 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
269 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
270 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
271 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
272 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
273 default: result.append("UNKNOWN\n");
274 }
275
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700276 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700277 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700278 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700279 p.focusingAreas[i].left,
280 p.focusingAreas[i].top,
281 p.focusingAreas[i].right,
282 p.focusingAreas[i].bottom,
283 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700284 }
285
286 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700287 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700288
289 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700290 p.autoExposureLock ? "enabled" : "disabled",
291 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700292
293 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700294 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700295 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700296 p.meteringAreas[i].left,
297 p.meteringAreas[i].top,
298 p.meteringAreas[i].right,
299 p.meteringAreas[i].bottom,
300 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700301 }
302
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700303 result.appendFormat(" Zoom index: %d\n", p.zoom);
304 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
305 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700306
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700307 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700308 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700309
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700310 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700311 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700312
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700313 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700314 result.appendFormat(" Preview stream ID: %d\n",
315 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700316 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700317 getCaptureStreamId());
318 result.appendFormat(" Recording stream ID: %d\n",
319 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700320
321 result.append(" Quirks for this camera:\n");
322 bool haveQuirk = false;
323 if (p.quirks.triggerAfWithAuto) {
324 result.appendFormat(" triggerAfWithAuto\n");
325 haveQuirk = true;
326 }
327 if (p.quirks.useZslFormat) {
328 result.appendFormat(" useZslFormat\n");
329 haveQuirk = true;
330 }
Igor Murashkin7373cbe2012-09-28 15:30:03 -0700331 if (p.quirks.meteringCropRegion) {
332 result.appendFormat(" meteringCropRegion\n");
333 haveQuirk = true;
334 }
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700335 if (!haveQuirk) {
336 result.appendFormat(" none\n");
337 }
338
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700339 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700340
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700341 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700342
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700343 mCaptureSequencer->dump(fd, args);
344
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700345 mFrameProcessor->dump(fd, args);
346
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700347 mZslProcessor->dump(fd, args);
348
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700349 result = " Device dump:\n";
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700350 write(fd, result.string(), result.size());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700351
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700352 status_t res = mDevice->dump(fd, args);
353 if (res != OK) {
354 result = String8::format(" Error dumping device: %s (%d)",
355 strerror(-res), res);
356 write(fd, result.string(), result.size());
357 }
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700358
359#undef CASE_APPEND_ENUM
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700360 return NO_ERROR;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700361}
362
363// ICamera interface
364
365void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700366 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700367 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700368
369 // Allow both client and the media server to disconnect at all times
370 int callingPid = getCallingPid();
371 if (callingPid != mClientPid && callingPid != mServicePid) return;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700372
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700373 if (mDevice == 0) return;
374
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700375 ALOGV("Camera %d: Shutting down", mCameraId);
376
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700377 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700378
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700379 {
380 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700381 if (l.mParameters.state == Parameters::DISCONNECTED) return;
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700382 l.mParameters.state = Parameters::DISCONNECTED;
383 }
384
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700385 mStreamingProcessor->deletePreviewStream();
386 mStreamingProcessor->deleteRecordingStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700387 mJpegProcessor->deleteStream();
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700388 mCallbackProcessor->deleteStream();
Eino-Ville Talvalacf70d342012-09-05 19:02:43 -0700389 mZslProcessor->deleteStream();
390
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700391 mFrameProcessor->requestExit();
392 mCaptureSequencer->requestExit();
393 mJpegProcessor->requestExit();
394 mZslProcessor->requestExit();
395 mCallbackProcessor->requestExit();
396
397 ALOGV("Camera %d: Waiting for threads", mCameraId);
398
399 mFrameProcessor->join();
400 mCaptureSequencer->join();
401 mJpegProcessor->join();
402 mZslProcessor->join();
403 mCallbackProcessor->join();
404
405 ALOGV("Camera %d: Disconnecting device", mCameraId);
406
407 mDevice->disconnect();
408
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700409 mDevice.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700410
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700411 CameraService::Client::disconnect();
412}
413
414status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700415 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700416 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700417 Mutex::Autolock icl(mICameraLock);
418
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700419 if (mClientPid != 0 && getCallingPid() != mClientPid) {
420 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
421 "current locked to pid %d", __FUNCTION__,
422 mCameraId, getCallingPid(), mClientPid);
423 return BAD_VALUE;
424 }
425
426 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700427
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700428 mCameraClient = client;
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -0700429 mSharedCameraClient = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700430
431 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700432}
433
434status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700435 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700436 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700437 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700438 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
439 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700440
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700441 if (mClientPid == 0) {
442 mClientPid = getCallingPid();
443 return OK;
444 }
445
446 if (mClientPid != getCallingPid()) {
447 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
448 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
449 return EBUSY;
450 }
451
452 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700453}
454
455status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700456 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700457 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700458 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700459 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
460 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700461
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700462 if (mClientPid == getCallingPid()) {
Eino-Ville Talvala907e5652012-10-10 15:28:53 -0700463 SharedParameters::Lock l(mParameters);
464 if (l.mParameters.state == Parameters::RECORD ||
465 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
466 ALOGD("Not allowed to unlock camera during recording.");
467 return INVALID_OPERATION;
468 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700469 mClientPid = 0;
470 mCameraClient.clear();
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -0700471 mSharedCameraClient.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700472 return OK;
473 }
474
475 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
476 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
477 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700478}
479
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700480status_t Camera2Client::setPreviewDisplay(
481 const sp<Surface>& surface) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700482 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700483 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700484 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700485 status_t res;
486 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700487
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700488 sp<IBinder> binder;
489 sp<ANativeWindow> window;
490 if (surface != 0) {
Mathias Agopian1a2952a2013-02-14 17:11:27 -0800491 binder = surface->getISurfaceTexture()->asBinder();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700492 window = surface;
493 }
494
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700495 return setPreviewWindowL(binder,window);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700496}
497
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700498status_t Camera2Client::setPreviewTexture(
Andy McFadden8ba01022012-12-18 09:46:54 -0800499 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700500 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700501 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700502 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700503 status_t res;
504 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700505
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700506 sp<IBinder> binder;
507 sp<ANativeWindow> window;
Andy McFadden8ba01022012-12-18 09:46:54 -0800508 if (bufferProducer != 0) {
509 binder = bufferProducer->asBinder();
Mathias Agopian1a2952a2013-02-14 17:11:27 -0800510 window = new Surface(bufferProducer);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700511 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700512 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700513}
514
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700515status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700516 sp<ANativeWindow> window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700517 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700518 status_t res;
519
520 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700521 ALOGV("%s: Camera %d: New window is same as old window",
522 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700523 return NO_ERROR;
524 }
525
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700526 Parameters::State state;
527 {
528 SharedParameters::Lock l(mParameters);
529 state = l.mParameters.state;
530 }
531 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700532 case Parameters::DISCONNECTED:
533 case Parameters::RECORD:
534 case Parameters::STILL_CAPTURE:
535 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700536 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700537 __FUNCTION__, mCameraId,
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700538 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700539 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700540 case Parameters::STOPPED:
541 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700542 // OK
543 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700544 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700545 // Already running preview - need to stop and create a new stream
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700546 mStreamingProcessor->stopStream();
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700547 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700548 break;
549 }
550
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700551 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700552 res = mStreamingProcessor->setPreviewWindow(window);
553 if (res != OK) {
554 ALOGE("%s: Unable to set new preview window: %s (%d)",
555 __FUNCTION__, strerror(-res), res);
556 return res;
557 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700558
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700559 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
560 SharedParameters::Lock l(mParameters);
561 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700562 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700563 }
564
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700565 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700566}
567
568void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700569 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700570 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700571 Mutex::Autolock icl(mICameraLock);
Igor Murashkinddf3c502012-10-12 16:56:11 -0700572
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700573 if ( checkPid(__FUNCTION__) != OK) return;
574
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700575 SharedParameters::Lock l(mParameters);
576 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700577}
578
579void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
580 status_t res = OK;
581 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
582 ALOGV("%s: setting oneshot", __FUNCTION__);
583 params.previewCallbackOneShot = true;
584 }
585 if (params.previewCallbackFlags != (uint32_t)flag) {
586 params.previewCallbackFlags = flag;
587 switch(params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700588 case Parameters::PREVIEW:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700589 res = startPreviewL(params, true);
590 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700591 case Parameters::RECORD:
592 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700593 res = startRecordingL(params, true);
594 break;
595 default:
596 break;
597 }
598 if (res != OK) {
599 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700600 __FUNCTION__, mCameraId,
601 Parameters::getStateName(params.state));
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700602 }
603 }
604
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700605}
606
607status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700608 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700609 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700610 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700611 status_t res;
612 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700613 SharedParameters::Lock l(mParameters);
614 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700615}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700616
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700617status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700618 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700619 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700620
621 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
622
Eino-Ville Talvalaa14be592012-10-10 17:17:01 -0700623 if ( (params.state == Parameters::PREVIEW ||
624 params.state == Parameters::RECORD ||
625 params.state == Parameters::VIDEO_SNAPSHOT)
626 && !restart) {
627 // Succeed attempt to re-enter a streaming state
628 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
629 __FUNCTION__, mCameraId);
Alex Ray77449ad2012-09-26 15:52:50 -0700630 return OK;
631 }
632 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700633 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700634 __FUNCTION__,
635 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700636 return INVALID_OPERATION;
637 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700638
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700639 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700640 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700641 return OK;
642 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700643 params.state = Parameters::STOPPED;
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700644
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700645 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700646 if (res != OK) {
647 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
648 __FUNCTION__, mCameraId, strerror(-res), res);
649 return res;
650 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700651
652 Vector<uint8_t> outputStreams;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700653 bool callbacksEnabled = params.previewCallbackFlags &
654 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
655 if (callbacksEnabled) {
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700656 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700657 if (res != OK) {
658 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
659 __FUNCTION__, mCameraId, strerror(-res), res);
660 return res;
661 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700662 outputStreams.push(getCallbackStreamId());
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700663 }
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700664 if (params.zslMode && !params.recordingHint) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700665 res = mZslProcessor->updateStream(params);
666 if (res != OK) {
667 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
668 __FUNCTION__, mCameraId, strerror(-res), res);
669 return res;
670 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700671 outputStreams.push(getZslStreamId());
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700672 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700673
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700674 outputStreams.push(getPreviewStreamId());
675
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700676 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700677 if (!restart) {
678 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700679 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700680 ALOGE("%s: Camera %d: Can't set up preview request: "
681 "%s (%d)", __FUNCTION__, mCameraId,
682 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700683 return res;
684 }
685 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700686 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
687 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700688 } else {
689 // With recording hint set, we're going to be operating under the
690 // assumption that the user will record video. To optimize recording
691 // startup time, create the necessary output streams for recording and
692 // video snapshot now if they don't already exist.
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700693 res = mJpegProcessor->updateStream(params);
694 if (res != OK) {
695 ALOGE("%s: Camera %d: Can't pre-configure still image "
696 "stream: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700697 __FUNCTION__, mCameraId, strerror(-res), res);
698 return res;
699 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700700
701 if (!restart) {
702 res = mStreamingProcessor->updateRecordingRequest(params);
703 if (res != OK) {
704 ALOGE("%s: Camera %d: Can't set up preview request with "
705 "record hint: %s (%d)", __FUNCTION__, mCameraId,
706 strerror(-res), res);
707 return res;
708 }
709 }
710 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
711 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700712 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700713 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700714 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700715 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700716 return res;
717 }
718
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700719 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700720 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700721}
722
723void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700724 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700725 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700726 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700727 status_t res;
728 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700729 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700730}
731
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700732void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700733 ATRACE_CALL();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700734 status_t res;
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700735 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700736 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700737 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700738 SharedParameters::Lock l(mParameters);
739 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700740 }
741
742 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700743 case Parameters::DISCONNECTED:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700744 ALOGE("%s: Camera %d: Call before initialized",
745 __FUNCTION__, mCameraId);
746 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700747 case Parameters::STOPPED:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700748 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700749 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700750 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
751 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700752 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700753 case Parameters::PREVIEW:
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700754 mStreamingProcessor->stopStream();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700755 res = mDevice->waitUntilDrained();
756 if (res != OK) {
757 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
758 __FUNCTION__, mCameraId, strerror(-res), res);
759 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700760 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700761 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
762 SharedParameters::Lock l(mParameters);
763 l.mParameters.state = Parameters::STOPPED;
764 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700765 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700766 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700767 default:
768 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700769 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700770 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700771}
772
773bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700774 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700775 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700776 status_t res;
777 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
778
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700779 SharedParameters::Lock l(mParameters);
780 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700781}
782
783status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700784 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700785 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700786 status_t res;
787 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
788
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700789 SharedParameters::Lock l(mParameters);
790 switch (l.mParameters.state) {
791 case Parameters::RECORD:
792 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700793 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700794 __FUNCTION__, mCameraId,
795 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700796 return INVALID_OPERATION;
797 default:
798 // OK
799 break;
800 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700801
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700802 l.mParameters.storeMetadataInBuffers = enabled;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700803
804 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700805}
806
807status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700808 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700809 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700810 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700811 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700812 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700813 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700814
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700815 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700816}
817
818status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
819 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700820
821 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
822
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700823 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700824 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700825 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700826 if (res != OK) return res;
827 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700828 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700829 // Ready to go
830 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700831 case Parameters::RECORD:
832 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700833 // OK to call this when recording is already on, just skip unless
834 // we're looking to restart
835 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700836 break;
837 default:
838 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700839 __FUNCTION__, mCameraId,
840 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700841 return INVALID_OPERATION;
842 };
843
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700844 if (!params.storeMetadataInBuffers) {
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700845 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
846 "non-metadata recording mode requested!", __FUNCTION__,
847 mCameraId);
848 return INVALID_OPERATION;
849 }
850
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700851 if (!restart) {
852 mCameraService->playSound(CameraService::SOUND_RECORDING);
853 mStreamingProcessor->updateRecordingRequest(params);
854 if (res != OK) {
855 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
856 __FUNCTION__, mCameraId, strerror(-res), res);
857 return res;
858 }
859 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -0700860
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700861 res = mStreamingProcessor->updateRecordingStream(params);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700862 if (res != OK) {
863 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
864 __FUNCTION__, mCameraId, strerror(-res), res);
865 return res;
866 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700867
868 Vector<uint8_t> outputStreams;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700869 bool callbacksEnabled = params.previewCallbackFlags &
870 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
871 if (callbacksEnabled) {
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700872 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700873 if (res != OK) {
874 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
875 __FUNCTION__, mCameraId, strerror(-res), res);
876 return res;
877 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700878 outputStreams.push(getCallbackStreamId());
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700879 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700880 outputStreams.push(getPreviewStreamId());
881 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700882
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700883 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
884 outputStreams);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700885 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700886 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700887 __FUNCTION__, mCameraId, strerror(-res), res);
888 return res;
889 }
890
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700891 if (params.state < Parameters::RECORD) {
892 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700893 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700894
895 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700896}
897
898void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700899 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700900 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700901 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700902 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700903
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700904 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700905 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
906
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700907 switch (l.mParameters.state) {
908 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700909 // OK to stop
910 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700911 case Parameters::STOPPED:
912 case Parameters::PREVIEW:
913 case Parameters::STILL_CAPTURE:
914 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700915 default:
916 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700917 __FUNCTION__, mCameraId,
918 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700919 return;
920 };
921
Eino-Ville Talvala609acc02012-09-06 18:26:58 -0700922 mCameraService->playSound(CameraService::SOUND_RECORDING);
923
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700924 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700925 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700926 ALOGE("%s: Camera %d: Unable to return to preview",
927 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700928 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700929}
930
931bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700932 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700933 Mutex::Autolock icl(mICameraLock);
James Dong8da4cd72012-08-04 19:58:07 -0700934
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700935 if ( checkPid(__FUNCTION__) != OK) return false;
936
James Dong8da4cd72012-08-04 19:58:07 -0700937 return recordingEnabledL();
938}
939
940bool Camera2Client::recordingEnabledL() {
941 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700942 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -0700943
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700944 return (l.mParameters.state == Parameters::RECORD
945 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700946}
947
948void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700949 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700950 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700951 if ( checkPid(__FUNCTION__) != OK) return;
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -0700952
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700953 mStreamingProcessor->releaseRecordingFrame(mem);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700954}
955
956status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700957 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700958 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700959 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700960 status_t res;
961 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
962
Eino-Ville Talvala174181e2012-08-03 13:53:39 -0700963 int triggerId;
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700964 bool notifyImmediately = false;
965 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -0700966 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700967 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700968 if (l.mParameters.state < Parameters::PREVIEW) {
969 return INVALID_OPERATION;
970 }
971
Igor Murashkin5f0714e2012-10-08 18:05:12 -0700972 /**
973 * If the camera does not support auto-focus, it is a no-op and
974 * onAutoFocus(boolean, Camera) callback will be called immediately
975 * with a fake value of success set to true.
976 */
977 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED) {
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700978 notifyImmediately = true;
979 notifySuccess = true;
980 }
981 /**
982 * If we're in CAF mode, and AF has already been locked, just fire back
983 * the callback right away; the HAL would not send a notification since
984 * no state change would happen on a AF trigger.
985 */
986 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
987 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
988 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
989 notifyImmediately = true;
990 notifySuccess = true;
991 }
992 /**
993 * Send immediate notification back to client
994 */
995 if (notifyImmediately) {
Igor Murashkin5f0714e2012-10-08 18:05:12 -0700996 SharedCameraClient::Lock l(mSharedCameraClient);
997 if (l.mCameraClient != 0) {
998 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700999 notifySuccess ? 1 : 0, 0);
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001000 }
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001001 return OK;
1002 }
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001003 /**
1004 * Handle quirk mode for AF in scene modes
1005 */
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001006 if (l.mParameters.quirks.triggerAfWithAuto &&
1007 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED &&
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001008 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1009 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001010 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1011 __FUNCTION__, l.mParameters.focusMode);
1012 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1013 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1014 updateRequests(l.mParameters);
1015 }
1016
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001017 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1018 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001019 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001020 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001021
1022 mDevice->triggerAutofocus(triggerId);
1023
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001024 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001025}
1026
1027status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001028 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001029 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001030 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001031 status_t res;
1032 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1033
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001034 int triggerId;
1035 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001036 SharedParameters::Lock l(mParameters);
1037 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001038
1039 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001040 // the real state at this point. No need to cancel explicitly if
1041 // changing the AF mode.
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001042 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1043 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1044 l.mParameters.shadowFocusMode);
1045 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1046 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1047 updateRequests(l.mParameters);
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001048
1049 return OK;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001050 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001051 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001052 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001053
1054 mDevice->triggerCancelAutofocus(triggerId);
1055
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001056 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001057}
1058
Ben Murdochff823702012-11-28 13:58:29 +00001059status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001060 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001061 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001062 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001063 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001064
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001065 {
1066 SharedParameters::Lock l(mParameters);
1067 switch (l.mParameters.state) {
1068 case Parameters::DISCONNECTED:
1069 case Parameters::STOPPED:
1070 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1071 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001072 __FUNCTION__, mCameraId);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001073 return INVALID_OPERATION;
1074 case Parameters::PREVIEW:
1075 // Good to go for takePicture
1076 res = commandStopFaceDetectionL(l.mParameters);
1077 if (res != OK) {
1078 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1079 __FUNCTION__, mCameraId);
1080 return res;
1081 }
1082 l.mParameters.state = Parameters::STILL_CAPTURE;
1083 break;
1084 case Parameters::RECORD:
1085 // Good to go for video snapshot
1086 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1087 break;
1088 case Parameters::STILL_CAPTURE:
1089 case Parameters::VIDEO_SNAPSHOT:
1090 ALOGE("%s: Camera %d: Already taking a picture",
1091 __FUNCTION__, mCameraId);
1092 return INVALID_OPERATION;
1093 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001094
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001095 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001096
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001097 res = mJpegProcessor->updateStream(l.mParameters);
1098 if (res != OK) {
1099 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1100 __FUNCTION__, mCameraId, strerror(-res), res);
1101 return res;
1102 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001103 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001104
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001105 // Need HAL to have correct settings before (possibly) triggering precapture
1106 syncWithDevice();
1107
Igor Murashkinaa9e3e02012-11-26 10:50:55 -08001108 res = mCaptureSequencer->startCapture(msgType);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001109 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001110 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001111 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001112 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001113
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001114 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001115}
1116
1117status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001118 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001119 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001120 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001121 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001122 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1123
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001124 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001125
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001126 res = l.mParameters.set(params);
1127 if (res != OK) return res;
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001128
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001129 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001130
1131 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001132}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001133
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001134String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001135 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001136 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001137 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001138 if ( checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001139
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001140 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001141
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001142 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001143}
1144
1145status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001146 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001147 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001148 status_t res;
1149 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001150
1151 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1152 cmd, arg1, arg2);
1153
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001154 switch (cmd) {
1155 case CAMERA_CMD_START_SMOOTH_ZOOM:
1156 return commandStartSmoothZoomL();
1157 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1158 return commandStopSmoothZoomL();
1159 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1160 return commandSetDisplayOrientationL(arg1);
1161 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1162 return commandEnableShutterSoundL(arg1 == 1);
1163 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1164 return commandPlayRecordingSoundL();
1165 case CAMERA_CMD_START_FACE_DETECTION:
1166 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001167 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001168 SharedParameters::Lock l(mParameters);
1169 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001170 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001171 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1172 return commandEnableFocusMoveMsgL(arg1 == 1);
1173 case CAMERA_CMD_PING:
1174 return commandPingL();
1175 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1176 return commandSetVideoBufferCountL(arg1);
1177 default:
1178 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1179 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001180 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001181 }
1182}
James Dong983cf232012-08-01 16:39:55 -07001183
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001184status_t Camera2Client::commandStartSmoothZoomL() {
1185 ALOGE("%s: Unimplemented!", __FUNCTION__);
1186 return OK;
1187}
James Dong983cf232012-08-01 16:39:55 -07001188
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001189status_t Camera2Client::commandStopSmoothZoomL() {
1190 ALOGE("%s: Unimplemented!", __FUNCTION__);
1191 return OK;
1192}
James Dong983cf232012-08-01 16:39:55 -07001193
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001194status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001195 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001196 mCameraFacing == CAMERA_FACING_FRONT);
1197 if (transform == -1) {
1198 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1199 __FUNCTION__, mCameraId, degrees);
1200 return BAD_VALUE;
1201 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001202 SharedParameters::Lock l(mParameters);
1203 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001204 getPreviewStreamId() != NO_STREAM) {
1205 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001206 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001207 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001208 return OK;
1209}
1210
1211status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001212 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001213 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001214 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001215 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001216 }
1217
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001218 // Disabling shutter sound may not be allowed. In that case only
1219 // allow the mediaserver process to disable the sound.
1220 char value[PROPERTY_VALUE_MAX];
1221 property_get("ro.camera.sound.forced", value, "0");
1222 if (strncmp(value, "0", 2) != 0) {
1223 // Disabling shutter sound is not allowed. Deny if the current
1224 // process is not mediaserver.
1225 if (getCallingPid() != getpid()) {
1226 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1227 getCallingPid());
1228 return PERMISSION_DENIED;
1229 }
1230 }
1231
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001232 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001233 return OK;
1234}
1235
1236status_t Camera2Client::commandPlayRecordingSoundL() {
1237 mCameraService->playSound(CameraService::SOUND_RECORDING);
1238 return OK;
1239}
1240
Igor Murashkinddf3c502012-10-12 16:56:11 -07001241status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001242 ALOGV("%s: Camera %d: Starting face detection",
1243 __FUNCTION__, mCameraId);
1244 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001245 SharedParameters::Lock l(mParameters);
1246 switch (l.mParameters.state) {
1247 case Parameters::DISCONNECTED:
1248 case Parameters::STOPPED:
1249 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1250 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001251 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1252 __FUNCTION__, mCameraId);
1253 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001254 case Parameters::PREVIEW:
1255 case Parameters::RECORD:
1256 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001257 // Good to go for starting face detect
1258 break;
1259 }
1260 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001261 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkind32b99b2012-11-27 16:25:46 -08001262 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001263 ALOGE("%s: Camera %d: Face detection not supported",
1264 __FUNCTION__, mCameraId);
1265 return INVALID_OPERATION;
1266 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001267 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001268
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001269 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001270
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001271 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001272
1273 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001274}
1275
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001276status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001277 status_t res = OK;
1278 ALOGV("%s: Camera %d: Stopping face detection",
1279 __FUNCTION__, mCameraId);
1280
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001281 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001282
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001283 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001284
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001285 if (params.state == Parameters::PREVIEW
1286 || params.state == Parameters::RECORD
1287 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001288 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001289 }
1290
1291 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001292}
1293
1294status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001295 SharedParameters::Lock l(mParameters);
1296 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001297
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001298 return OK;
1299}
1300
1301status_t Camera2Client::commandPingL() {
1302 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001303 SharedParameters::Lock l(mParameters);
1304 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001305 return OK;
1306 } else {
1307 return NO_INIT;
1308 }
1309}
1310
1311status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
James Dong8da4cd72012-08-04 19:58:07 -07001312 if (recordingEnabledL()) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001313 ALOGE("%s: Camera %d: Error setting video buffer count after "
1314 "recording was started", __FUNCTION__, mCameraId);
1315 return INVALID_OPERATION;
1316 }
1317
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001318 return mStreamingProcessor->setRecordingBufferCount(count);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001319}
1320
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001321/** Device-related methods */
1322
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001323void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1324 ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1325}
1326
1327void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
Igor Murashkinddf3c502012-10-12 16:56:11 -07001328 (void)frameNumber;
1329 (void)timestamp;
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001330 ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1331 frameNumber, timestamp);
1332}
1333
1334void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1335 ALOGV("%s: Autofocus state now %d, last trigger %d",
1336 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001337 bool sendCompletedMessage = false;
1338 bool sendMovingMessage = false;
1339
1340 bool success = false;
1341 bool afInMotion = false;
1342 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001343 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001344 l.mParameters.focusState = newState;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001345 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001346 case Parameters::FOCUS_MODE_AUTO:
1347 case Parameters::FOCUS_MODE_MACRO:
1348 // Don't send notifications upstream if they're not for the current AF
1349 // trigger. For example, if cancel was called in between, or if we
1350 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001351 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001352 switch (newState) {
1353 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1354 success = true;
1355 // no break
1356 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1357 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001358 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001359 break;
1360 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1361 // Just starting focusing, ignore
1362 break;
1363 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1364 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1365 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1366 default:
1367 // Unexpected in AUTO/MACRO mode
1368 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1369 __FUNCTION__, newState);
1370 break;
1371 }
1372 break;
1373 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1374 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1375 switch (newState) {
1376 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1377 success = true;
1378 // no break
1379 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1380 // Don't send notifications upstream if they're not for
1381 // the current AF trigger. For example, if cancel was
1382 // called in between, or if we already sent a
1383 // notification about this AF call.
1384 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001385 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001386 sendCompletedMessage = true;
1387 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001388 if (l.mParameters.enableFocusMoveMessages &&
1389 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001390 sendMovingMessage = true;
1391 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001392 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001393 break;
1394 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1395 // Cancel was called, or we switched state; care if
1396 // currently moving
1397 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001398 if (l.mParameters.enableFocusMoveMessages &&
1399 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001400 sendMovingMessage = true;
1401 }
1402 break;
1403 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1404 // Start passive scan, inform upstream
1405 afInMotion = true;
1406 // no break
1407 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1408 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001409 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001410 sendMovingMessage = true;
1411 }
1412 break;
1413 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001414 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001415 break;
1416 case Parameters::FOCUS_MODE_EDOF:
1417 case Parameters::FOCUS_MODE_INFINITY:
1418 case Parameters::FOCUS_MODE_FIXED:
1419 default:
1420 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001421 ALOGE("%s: Unexpected AF state change %d "
1422 "(ID %d) in focus mode %d",
1423 __FUNCTION__, newState, triggerId,
1424 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001425 }
1426 }
1427 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001428 if (sendMovingMessage) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001429 SharedCameraClient::Lock l(mSharedCameraClient);
1430 if (l.mCameraClient != 0) {
1431 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001432 afInMotion ? 1 : 0, 0);
1433 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001434 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001435 if (sendCompletedMessage) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001436 SharedCameraClient::Lock l(mSharedCameraClient);
1437 if (l.mCameraClient != 0) {
1438 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1439 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001440 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001441 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001442}
1443
1444void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1445 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1446 __FUNCTION__, newState, triggerId);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001447 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001448}
1449
1450void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
Igor Murashkinddf3c502012-10-12 16:56:11 -07001451 (void)newState;
1452 (void)triggerId;
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001453 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1454 __FUNCTION__, newState, triggerId);
1455}
1456
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001457int Camera2Client::getCameraId() const {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001458 return mCameraId;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001459}
1460
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001461const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1462 return mDevice;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001463}
1464
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001465const sp<CameraService>& Camera2Client::getCameraService() {
1466 return mCameraService;
1467}
1468
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001469camera2::SharedParameters& Camera2Client::getParameters() {
1470 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001471}
1472
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001473int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001474 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001475}
1476
1477int Camera2Client::getCaptureStreamId() const {
1478 return mJpegProcessor->getStreamId();
1479}
1480
1481int Camera2Client::getCallbackStreamId() const {
1482 return mCallbackProcessor->getStreamId();
1483}
1484
1485int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001486 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001487}
1488
1489int Camera2Client::getZslStreamId() const {
1490 return mZslProcessor->getStreamId();
1491}
1492
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001493status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001494 wp<camera2::FrameProcessor::FilteredListener> listener) {
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001495 return mFrameProcessor->registerListener(minId, maxId, listener);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001496}
1497
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001498status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1499 wp<camera2::FrameProcessor::FilteredListener> listener) {
1500 return mFrameProcessor->removeListener(minId, maxId, listener);
1501}
1502
1503status_t Camera2Client::stopStream() {
1504 return mStreamingProcessor->stopStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001505}
1506
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001507Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1508 mCameraClient(client.mCameraClient),
1509 mSharedClient(client) {
1510 mSharedClient.mCameraClientLock.lock();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001511}
1512
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001513Camera2Client::SharedCameraClient::Lock::~Lock() {
1514 mSharedClient.mCameraClientLock.unlock();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001515}
1516
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -07001517Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1518 mCameraClient(client) {
1519}
1520
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001521Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1522 const sp<ICameraClient>&client) {
1523 Mutex::Autolock l(mCameraClientLock);
1524 mCameraClient = client;
1525 return *this;
1526}
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -07001527
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001528void Camera2Client::SharedCameraClient::clear() {
1529 Mutex::Autolock l(mCameraClientLock);
1530 mCameraClient.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001531}
1532
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001533const int32_t Camera2Client::kPreviewRequestIdStart;
1534const int32_t Camera2Client::kPreviewRequestIdEnd;
1535const int32_t Camera2Client::kRecordingRequestIdStart;
1536const int32_t Camera2Client::kRecordingRequestIdEnd;
1537const int32_t Camera2Client::kCaptureRequestIdStart;
1538const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001539
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001540/** Utility methods */
1541
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001542status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001543 status_t res;
1544
Igor Murashkin22d58d32012-10-02 19:07:14 -07001545 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1546
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001547 res = mStreamingProcessor->incrementStreamingIds();
1548 if (res != OK) {
1549 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1550 __FUNCTION__, mCameraId, strerror(-res), res);
1551 return res;
1552 }
1553
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001554 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001555 if (res != OK) {
1556 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1557 __FUNCTION__, mCameraId, strerror(-res), res);
1558 return res;
1559 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001560 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001561 if (res != OK) {
1562 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1563 __FUNCTION__, mCameraId, strerror(-res), res);
1564 return res;
1565 }
1566
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001567 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001568 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001569 if (res != OK) {
1570 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1571 __FUNCTION__, mCameraId, strerror(-res), res);
1572 return res;
1573 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001574 } else if (params.state == Parameters::RECORD ||
1575 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001576 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001577 if (res != OK) {
1578 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1579 __FUNCTION__, mCameraId, strerror(-res), res);
1580 return res;
1581 }
1582 }
1583 return res;
1584}
1585
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001586
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001587size_t Camera2Client::calculateBufferSize(int width, int height,
1588 int format, int stride) {
1589 switch (format) {
1590 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1591 return width * height * 2;
1592 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1593 return width * height * 3 / 2;
1594 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1595 return width * height * 2;
1596 case HAL_PIXEL_FORMAT_YV12: { // YV12
1597 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07001598 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001599 size_t uvSize = uvStride * height / 2;
1600 return ySize + uvSize * 2;
1601 }
1602 case HAL_PIXEL_FORMAT_RGB_565:
1603 return width * height * 2;
1604 case HAL_PIXEL_FORMAT_RGBA_8888:
1605 return width * height * 4;
1606 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1607 return width * height * 2;
1608 default:
1609 ALOGE("%s: Unknown preview format: %x",
1610 __FUNCTION__, format);
1611 return 0;
1612 }
1613}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001614
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001615status_t Camera2Client::syncWithDevice() {
1616 ATRACE_CALL();
Eino-Ville Talvala43b7ac62012-10-23 09:09:01 -07001617 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001618 status_t res;
1619
1620 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
1621 if (activeRequestId == 0) return OK;
1622
1623 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
1624 if (res == TIMED_OUT) {
1625 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
1626 __FUNCTION__, mCameraId);
1627 } else if (res != OK) {
1628 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
1629 __FUNCTION__, mCameraId);
1630 }
1631 return res;
1632}
1633
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001634} // namespace android