blob: 948b59f370516ca7b30e01db737d2b49381c9ce8 [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>
25#include <gui/SurfaceTextureClient.h>
26#include <gui/Surface.h>
James Paintere5382062012-09-05 18:02:32 -070027#include "camera2/Parameters.h"
James Painter10894e52012-09-07 16:36:50 -070028#include "Camera2Client.h"
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070029
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070030#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
31#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
32
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070033namespace android {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070034using namespace camera2;
35
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070036static int getCallingPid() {
37 return IPCThreadState::self()->getCallingPid();
38}
39
40static int getCallingUid() {
41 return IPCThreadState::self()->getCallingUid();
42}
43
44// Interface used by CameraService
45
46Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
47 const sp<ICameraClient>& cameraClient,
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070048 int cameraId,
49 int cameraFacing,
Igor Murashkinecf17e82012-10-02 16:05:11 -070050 int clientPid,
51 int servicePid):
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070052 Client(cameraService, cameraClient,
Igor Murashkinecf17e82012-10-02 16:05:11 -070053 cameraId, cameraFacing, clientPid, servicePid),
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -070054 mSharedCameraClient(cameraClient),
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070055 mParameters(cameraId, cameraFacing)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070056{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070057 ATRACE_CALL();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070058 ALOGI("Camera %d: Opened", cameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070059
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070060 mDevice = new Camera2Device(cameraId);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070061
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070062 SharedParameters::Lock l(mParameters);
63 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070064}
65
Eino-Ville Talvala3a609142012-07-31 14:36:26 -070066status_t Camera2Client::checkPid(const char* checkLocation) const {
67 int callingPid = getCallingPid();
Igor Murashkinecf17e82012-10-02 16:05:11 -070068 if (callingPid == mClientPid || callingPid == mServicePid) return NO_ERROR;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -070069
70 ALOGE("%s: attempt to use a locked camera from a different process"
Igor Murashkinecf17e82012-10-02 16:05:11 -070071 " (old pid %d, new pid %d, servicePid %d)", checkLocation, mClientPid, callingPid, mServicePid);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -070072 return PERMISSION_DENIED;
73}
74
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070075status_t Camera2Client::initialize(camera_module_t *module)
76{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070077 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070078 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070079 status_t res;
80
81 res = mDevice->initialize(module);
82 if (res != OK) {
83 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
84 __FUNCTION__, mCameraId, strerror(-res), res);
85 return NO_INIT;
86 }
87
Eino-Ville Talvala174181e2012-08-03 13:53:39 -070088 res = mDevice->setNotifyCallback(this);
89
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070090 SharedParameters::Lock l(mParameters);
91
92 res = l.mParameters.initialize(&(mDevice->info()));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070093 if (res != OK) {
94 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
95 __FUNCTION__, mCameraId, strerror(-res), res);
96 return NO_INIT;
97 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070098
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070099 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700100
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700101 mStreamingProcessor = new StreamingProcessor(this);
102
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700103 mFrameProcessor = new FrameProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700104 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700105 mCameraId);
106 mFrameProcessor->run(threadName.string());
107
108 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700109 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700110 mCameraId);
111 mCaptureSequencer->run(threadName.string());
112
113 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700114 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700115 mCameraId);
116 mJpegProcessor->run(threadName.string());
117
118 mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700119 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700120 mCameraId);
121 mZslProcessor->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700122
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700123 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700124 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700125 mCameraId);
126 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700127
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700128 if (gLogLevel >= 1) {
129 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
130 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700131 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700132 }
133
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700134 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700135}
136
137Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700138 ATRACE_CALL();
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700139
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700140 mDestructionStarted = true;
141
Igor Murashkinecf17e82012-10-02 16:05:11 -0700142 Parameters::State state;
143 // warning:
144 // holding on to locks more than necessary may be hazardous to your health
145 {
146 SharedParameters::Lock l(mParameters);
147 state = l.mParameters.state;
148 }
149
150 if (state != Parameters::DISCONNECTED) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700151 // Rewrite mClientPid to allow shutdown by CameraService
152 mClientPid = getCallingPid();
153 disconnect();
154 }
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700155
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700156 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700157}
158
159status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700160 String8 result;
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700161 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n",
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700162 mCameraId,
163 getCameraClient()->asBinder().get(),
164 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700165 result.append(" State: ");
166#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
167
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700168 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700169
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700170 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700171
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700172 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700173 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700174 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700175 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700176 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700177 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700178 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700179 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700180 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700181 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700182 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700183 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700184 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700185 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700186 p.jpegQuality, p.jpegThumbQuality);
187 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700188 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700189 p.gpsEnabled ? "enabled" : "disabled");
190 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700191 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700192 p.gpsCoordinates[0], p.gpsCoordinates[1],
193 p.gpsCoordinates[2]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700194 result.appendFormat(" GPS timestamp: %lld\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700195 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700196 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700197 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700198 }
199
200 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700201 switch (p.wbMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700202 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO)
203 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT)
204 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT)
205 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT)
206 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT)
207 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT)
208 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT)
209 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE)
210 default: result.append("UNKNOWN\n");
211 }
212
213 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700214 switch (p.effectMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700215 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF)
216 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO)
217 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE)
218 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE)
219 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA)
220 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE)
221 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD)
223 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA)
224 default: result.append("UNKNOWN\n");
225 }
226
227 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700228 switch (p.antibandingMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700229 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO)
230 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF)
231 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ)
232 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ)
233 default: result.append("UNKNOWN\n");
234 }
235
236 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700237 switch (p.sceneMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700238 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
239 result.append("AUTO\n"); break;
240 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
241 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
242 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
243 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
244 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
245 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
246 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
247 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
248 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
249 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
250 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
251 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
252 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
255 default: result.append("UNKNOWN\n");
256 }
257
258 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700259 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700260 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
261 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
262 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
263 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
264 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
265 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
266 default: result.append("UNKNOWN\n");
267 }
268
269 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700270 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700271 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
272 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
273 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
274 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
275 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
276 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
277 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
278 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
279 default: result.append("UNKNOWN\n");
280 }
281
282 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700283 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700284 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700285 p.focusingAreas[i].left,
286 p.focusingAreas[i].top,
287 p.focusingAreas[i].right,
288 p.focusingAreas[i].bottom,
289 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700290 }
291
292 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700293 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700294
295 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700296 p.autoExposureLock ? "enabled" : "disabled",
297 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700298
299 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700300 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700301 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700302 p.meteringAreas[i].left,
303 p.meteringAreas[i].top,
304 p.meteringAreas[i].right,
305 p.meteringAreas[i].bottom,
306 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700307 }
308
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700309 result.appendFormat(" Zoom index: %d\n", p.zoom);
310 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
311 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700312
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700313 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700314 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700315
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700316 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700317 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700318
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700319 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700320 result.appendFormat(" Preview stream ID: %d\n",
321 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700322 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700323 getCaptureStreamId());
324 result.appendFormat(" Recording stream ID: %d\n",
325 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700326
327 result.append(" Quirks for this camera:\n");
328 bool haveQuirk = false;
329 if (p.quirks.triggerAfWithAuto) {
330 result.appendFormat(" triggerAfWithAuto\n");
331 haveQuirk = true;
332 }
333 if (p.quirks.useZslFormat) {
334 result.appendFormat(" useZslFormat\n");
335 haveQuirk = true;
336 }
337 if (!haveQuirk) {
338 result.appendFormat(" none\n");
339 }
340
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700341 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700342
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700343 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700344
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700345 mCaptureSequencer->dump(fd, args);
346
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700347 mFrameProcessor->dump(fd, args);
348
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700349 mZslProcessor->dump(fd, args);
350
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700351 result = " Device dump:\n";
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700352 write(fd, result.string(), result.size());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700353
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700354 status_t res = mDevice->dump(fd, args);
355 if (res != OK) {
356 result = String8::format(" Error dumping device: %s (%d)",
357 strerror(-res), res);
358 write(fd, result.string(), result.size());
359 }
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700360
361#undef CASE_APPEND_ENUM
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700362 return NO_ERROR;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700363}
364
365// ICamera interface
366
367void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700368 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700369 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700370 status_t res;
371 if ( (res = checkPid(__FUNCTION__) ) != OK) 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 Talvala36cdfb12012-08-02 17:34:15 -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);
381 l.mParameters.state = Parameters::DISCONNECTED;
382 }
383
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700384 mStreamingProcessor->deletePreviewStream();
385 mStreamingProcessor->deleteRecordingStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700386 mJpegProcessor->deleteStream();
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700387 mCallbackProcessor->deleteStream();
Eino-Ville Talvalacf70d342012-09-05 19:02:43 -0700388 mZslProcessor->deleteStream();
389
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700390 mFrameProcessor->requestExit();
391 mCaptureSequencer->requestExit();
392 mJpegProcessor->requestExit();
393 mZslProcessor->requestExit();
394 mCallbackProcessor->requestExit();
395
396 ALOGV("Camera %d: Waiting for threads", mCameraId);
397
398 mFrameProcessor->join();
399 mCaptureSequencer->join();
400 mJpegProcessor->join();
401 mZslProcessor->join();
402 mCallbackProcessor->join();
403
404 ALOGV("Camera %d: Disconnecting device", mCameraId);
405
406 mDevice->disconnect();
407
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700408 mDevice.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700409
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700410 CameraService::Client::disconnect();
411}
412
413status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700414 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700415 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700416 Mutex::Autolock icl(mICameraLock);
417
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700418 if (mClientPid != 0 && getCallingPid() != mClientPid) {
419 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
420 "current locked to pid %d", __FUNCTION__,
421 mCameraId, getCallingPid(), mClientPid);
422 return BAD_VALUE;
423 }
424
425 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700426
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700427 mCameraClient = client;
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -0700428 mSharedCameraClient = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700429
430 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700431}
432
433status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700434 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700435 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700436 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700437 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
438 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700439
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700440 if (mClientPid == 0) {
441 mClientPid = getCallingPid();
442 return OK;
443 }
444
445 if (mClientPid != getCallingPid()) {
446 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
447 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
448 return EBUSY;
449 }
450
451 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700452}
453
454status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700455 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700456 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700457 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700458 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
459 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700460
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700461 // TODO: Check for uninterruptable conditions
462
463 if (mClientPid == getCallingPid()) {
464 mClientPid = 0;
465 mCameraClient.clear();
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -0700466 mSharedCameraClient.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700467 return OK;
468 }
469
470 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
471 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
472 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700473}
474
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700475status_t Camera2Client::setPreviewDisplay(
476 const sp<Surface>& surface) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700477 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700478 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700479 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700480 status_t res;
481 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700482
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700483 sp<IBinder> binder;
484 sp<ANativeWindow> window;
485 if (surface != 0) {
486 binder = surface->asBinder();
487 window = surface;
488 }
489
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700490 return setPreviewWindowL(binder,window);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700491}
492
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700493status_t Camera2Client::setPreviewTexture(
494 const sp<ISurfaceTexture>& surfaceTexture) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700495 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700496 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700497 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700498 status_t res;
499 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700500
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700501 sp<IBinder> binder;
502 sp<ANativeWindow> window;
503 if (surfaceTexture != 0) {
504 binder = surfaceTexture->asBinder();
505 window = new SurfaceTextureClient(surfaceTexture);
506 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700507 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700508}
509
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700510status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700511 sp<ANativeWindow> window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700512 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700513 status_t res;
514
515 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700516 ALOGV("%s: Camera %d: New window is same as old window",
517 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700518 return NO_ERROR;
519 }
520
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700521 SharedParameters::Lock l(mParameters);
522 switch (l.mParameters.state) {
523 case Parameters::DISCONNECTED:
524 case Parameters::RECORD:
525 case Parameters::STILL_CAPTURE:
526 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700527 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700528 __FUNCTION__, mCameraId,
529 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700530 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700531 case Parameters::STOPPED:
532 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700533 // OK
534 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700535 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700536 // Already running preview - need to stop and create a new stream
537 // TODO: Optimize this so that we don't wait for old stream to drain
538 // before spinning up new stream
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700539 mDevice->clearStreamingRequest();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700540 l.mParameters.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700541 break;
542 }
543
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700544 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700545 res = mStreamingProcessor->setPreviewWindow(window);
546 if (res != OK) {
547 ALOGE("%s: Unable to set new preview window: %s (%d)",
548 __FUNCTION__, strerror(-res), res);
549 return res;
550 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700551
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700552 if (l.mParameters.state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
553 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700554 }
555
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700556 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700557}
558
559void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700560 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700561 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700562 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700563 status_t res;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700564 if ( checkPid(__FUNCTION__) != OK) return;
565
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700566 SharedParameters::Lock l(mParameters);
567 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700568}
569
570void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
571 status_t res = OK;
572 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
573 ALOGV("%s: setting oneshot", __FUNCTION__);
574 params.previewCallbackOneShot = true;
575 }
576 if (params.previewCallbackFlags != (uint32_t)flag) {
577 params.previewCallbackFlags = flag;
578 switch(params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700579 case Parameters::PREVIEW:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700580 res = startPreviewL(params, true);
581 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700582 case Parameters::RECORD:
583 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700584 res = startRecordingL(params, true);
585 break;
586 default:
587 break;
588 }
589 if (res != OK) {
590 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700591 __FUNCTION__, mCameraId,
592 Parameters::getStateName(params.state));
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700593 }
594 }
595
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700596}
597
598status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700599 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700600 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700601 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700602 status_t res;
603 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700604 SharedParameters::Lock l(mParameters);
605 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700606}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700607
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700608status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700609 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700610 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700611
612 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
613
Alex Ray77449ad2012-09-26 15:52:50 -0700614 if (params.state == Parameters::PREVIEW && !restart) {
615 // Succeed attempt to re-enter preview state
616 ALOGI("%s: Not starting preview; already in preview state.",
617 __FUNCTION__);
618 return OK;
619 }
620 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700621 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700622 __FUNCTION__,
623 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700624 return INVALID_OPERATION;
625 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700626
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700627 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700628 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700629 return OK;
630 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700631 params.state = Parameters::STOPPED;
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700632
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700633 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700634 if (res != OK) {
635 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
636 __FUNCTION__, mCameraId, strerror(-res), res);
637 return res;
638 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700639
640 Vector<uint8_t> outputStreams;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700641 bool callbacksEnabled = params.previewCallbackFlags &
642 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
643 if (callbacksEnabled) {
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700644 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700645 if (res != OK) {
646 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
647 __FUNCTION__, mCameraId, strerror(-res), res);
648 return res;
649 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700650 outputStreams.push(getCallbackStreamId());
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700651 }
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700652 if (params.zslMode && !params.recordingHint) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700653 res = mZslProcessor->updateStream(params);
654 if (res != OK) {
655 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
656 __FUNCTION__, mCameraId, strerror(-res), res);
657 return res;
658 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700659 outputStreams.push(getZslStreamId());
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700660 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700661
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700662 outputStreams.push(getPreviewStreamId());
663
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700664 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700665 if (!restart) {
666 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700667 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700668 ALOGE("%s: Camera %d: Can't set up preview request: "
669 "%s (%d)", __FUNCTION__, mCameraId,
670 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700671 return res;
672 }
673 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700674 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
675 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700676 } else {
677 // With recording hint set, we're going to be operating under the
678 // assumption that the user will record video. To optimize recording
679 // startup time, create the necessary output streams for recording and
680 // video snapshot now if they don't already exist.
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700681 res = mJpegProcessor->updateStream(params);
682 if (res != OK) {
683 ALOGE("%s: Camera %d: Can't pre-configure still image "
684 "stream: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700685 __FUNCTION__, mCameraId, strerror(-res), res);
686 return res;
687 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700688
689 if (!restart) {
690 res = mStreamingProcessor->updateRecordingRequest(params);
691 if (res != OK) {
692 ALOGE("%s: Camera %d: Can't set up preview request with "
693 "record hint: %s (%d)", __FUNCTION__, mCameraId,
694 strerror(-res), res);
695 return res;
696 }
697 }
698 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
699 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700700 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700701 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700702 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700703 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700704 return res;
705 }
706
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700707 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700708 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700709}
710
711void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700712 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700713 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700714 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700715 status_t res;
716 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700717 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700718}
719
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700720void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700721 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700722 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700723 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700724 SharedParameters::Lock l(mParameters);
725 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700726 }
727
728 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700729 case Parameters::DISCONNECTED:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700730 ALOGE("%s: Camera %d: Call before initialized",
731 __FUNCTION__, mCameraId);
732 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700733 case Parameters::STOPPED:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700734 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700735 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700736 ALOGE("%s: Camera %d: Cannot stop preview during still capture.",
737 __FUNCTION__, mCameraId);
738 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700739 case Parameters::RECORD:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700740 // no break - identical to preview
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700741 case Parameters::PREVIEW:
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700742 mStreamingProcessor->stopStream();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700743 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700744 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
745 SharedParameters::Lock l(mParameters);
746 l.mParameters.state = Parameters::STOPPED;
747 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700748 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700749 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700750 default:
751 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700752 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700753 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700754}
755
756bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700757 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700758 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700759 status_t res;
760 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
761
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700762 SharedParameters::Lock l(mParameters);
763 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700764}
765
766status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700767 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700768 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700769 status_t res;
770 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
771
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700772 SharedParameters::Lock l(mParameters);
773 switch (l.mParameters.state) {
774 case Parameters::RECORD:
775 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700776 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700777 __FUNCTION__, mCameraId,
778 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700779 return INVALID_OPERATION;
780 default:
781 // OK
782 break;
783 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700784
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700785 l.mParameters.storeMetadataInBuffers = enabled;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700786
787 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700788}
789
790status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700791 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700792 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700793 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700794 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700795 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700796 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700797
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700798 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700799}
800
801status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
802 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700803
804 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
805
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700806 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700807 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700808 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700809 if (res != OK) return res;
810 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700811 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700812 // Ready to go
813 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700814 case Parameters::RECORD:
815 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700816 // OK to call this when recording is already on, just skip unless
817 // we're looking to restart
818 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700819 break;
820 default:
821 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700822 __FUNCTION__, mCameraId,
823 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700824 return INVALID_OPERATION;
825 };
826
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700827 if (!params.storeMetadataInBuffers) {
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700828 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
829 "non-metadata recording mode requested!", __FUNCTION__,
830 mCameraId);
831 return INVALID_OPERATION;
832 }
833
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700834 if (!restart) {
835 mCameraService->playSound(CameraService::SOUND_RECORDING);
836 mStreamingProcessor->updateRecordingRequest(params);
837 if (res != OK) {
838 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
839 __FUNCTION__, mCameraId, strerror(-res), res);
840 return res;
841 }
842 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -0700843
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700844 res = mStreamingProcessor->updateRecordingStream(params);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700845 if (res != OK) {
846 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
847 __FUNCTION__, mCameraId, strerror(-res), res);
848 return res;
849 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700850
851 Vector<uint8_t> outputStreams;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700852 bool callbacksEnabled = params.previewCallbackFlags &
853 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
854 if (callbacksEnabled) {
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700855 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700856 if (res != OK) {
857 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
858 __FUNCTION__, mCameraId, strerror(-res), res);
859 return res;
860 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700861 outputStreams.push(getCallbackStreamId());
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700862 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700863 outputStreams.push(getPreviewStreamId());
864 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700865
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700866 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
867 outputStreams);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700868 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700869 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700870 __FUNCTION__, mCameraId, strerror(-res), res);
871 return res;
872 }
873
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700874 if (params.state < Parameters::RECORD) {
875 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700876 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700877
878 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700879}
880
881void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700882 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700883 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700884 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700885 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700886
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700887 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700888 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
889
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700890 switch (l.mParameters.state) {
891 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700892 // OK to stop
893 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700894 case Parameters::STOPPED:
895 case Parameters::PREVIEW:
896 case Parameters::STILL_CAPTURE:
897 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700898 default:
899 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700900 __FUNCTION__, mCameraId,
901 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700902 return;
903 };
904
Eino-Ville Talvala609acc02012-09-06 18:26:58 -0700905 mCameraService->playSound(CameraService::SOUND_RECORDING);
906
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700907 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700908 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700909 ALOGE("%s: Camera %d: Unable to return to preview",
910 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700911 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700912}
913
914bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700915 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700916 Mutex::Autolock icl(mICameraLock);
James Dong8da4cd72012-08-04 19:58:07 -0700917
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700918 if ( checkPid(__FUNCTION__) != OK) return false;
919
James Dong8da4cd72012-08-04 19:58:07 -0700920 return recordingEnabledL();
921}
922
923bool Camera2Client::recordingEnabledL() {
924 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700925 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -0700926
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700927 return (l.mParameters.state == Parameters::RECORD
928 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700929}
930
931void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700932 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700933 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700934 if ( checkPid(__FUNCTION__) != OK) return;
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -0700935
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700936 mStreamingProcessor->releaseRecordingFrame(mem);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700937}
938
939status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700940 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700941 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700942 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700943 status_t res;
944 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
945
Eino-Ville Talvala174181e2012-08-03 13:53:39 -0700946 int triggerId;
947 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700948 SharedParameters::Lock l(mParameters);
949 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
950 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -0700951 }
952
953 mDevice->triggerAutofocus(triggerId);
954
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700955 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700956}
957
958status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700959 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700960 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700961 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700962 status_t res;
963 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
964
Eino-Ville Talvala174181e2012-08-03 13:53:39 -0700965 int triggerId;
966 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700967 SharedParameters::Lock l(mParameters);
968 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -0700969 }
970
971 mDevice->triggerCancelAutofocus(triggerId);
972
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700973 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700974}
975
976status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700977 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700978 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700979 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700980 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700981
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700982 SharedParameters::Lock l(mParameters);
983 switch (l.mParameters.state) {
984 case Parameters::DISCONNECTED:
985 case Parameters::STOPPED:
986 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700987 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
988 __FUNCTION__, mCameraId);
989 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700990 case Parameters::PREVIEW:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700991 // Good to go for takePicture
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700992 res = commandStopFaceDetectionL(l.mParameters);
993 if (res != OK) {
994 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
995 __FUNCTION__, mCameraId);
996 return res;
997 }
998 l.mParameters.state = Parameters::STILL_CAPTURE;
999 break;
1000 case Parameters::RECORD:
1001 // Good to go for video snapshot
1002 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001003 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001004 case Parameters::STILL_CAPTURE:
1005 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001006 ALOGE("%s: Camera %d: Already taking a picture",
1007 __FUNCTION__, mCameraId);
1008 return INVALID_OPERATION;
1009 }
1010
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001011 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001012
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001013 res = mJpegProcessor->updateStream(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001014 if (res != OK) {
1015 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1016 __FUNCTION__, mCameraId, strerror(-res), res);
1017 return res;
1018 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001019
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001020 res = mCaptureSequencer->startCapture();
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001021 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001022 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001023 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001024 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001025
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001026 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001027}
1028
1029status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001030 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001031 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001032 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001033 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001034 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1035
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001036 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001037
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001038 res = l.mParameters.set(params);
1039 if (res != OK) return res;
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001040
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001041 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001042
1043 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001044}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001045
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001046String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001047 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001048 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001049 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001050 if ( checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001051
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001052 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001053
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001054 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001055}
1056
1057status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001058 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001059 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001060 status_t res;
1061 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001062
1063 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1064 cmd, arg1, arg2);
1065
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001066 switch (cmd) {
1067 case CAMERA_CMD_START_SMOOTH_ZOOM:
1068 return commandStartSmoothZoomL();
1069 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1070 return commandStopSmoothZoomL();
1071 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1072 return commandSetDisplayOrientationL(arg1);
1073 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1074 return commandEnableShutterSoundL(arg1 == 1);
1075 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1076 return commandPlayRecordingSoundL();
1077 case CAMERA_CMD_START_FACE_DETECTION:
1078 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001079 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001080 SharedParameters::Lock l(mParameters);
1081 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001082 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001083 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1084 return commandEnableFocusMoveMsgL(arg1 == 1);
1085 case CAMERA_CMD_PING:
1086 return commandPingL();
1087 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1088 return commandSetVideoBufferCountL(arg1);
1089 default:
1090 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1091 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001092 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001093 }
1094}
James Dong983cf232012-08-01 16:39:55 -07001095
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001096status_t Camera2Client::commandStartSmoothZoomL() {
1097 ALOGE("%s: Unimplemented!", __FUNCTION__);
1098 return OK;
1099}
James Dong983cf232012-08-01 16:39:55 -07001100
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001101status_t Camera2Client::commandStopSmoothZoomL() {
1102 ALOGE("%s: Unimplemented!", __FUNCTION__);
1103 return OK;
1104}
James Dong983cf232012-08-01 16:39:55 -07001105
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001106status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001107 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001108 mCameraFacing == CAMERA_FACING_FRONT);
1109 if (transform == -1) {
1110 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1111 __FUNCTION__, mCameraId, degrees);
1112 return BAD_VALUE;
1113 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001114 SharedParameters::Lock l(mParameters);
1115 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001116 getPreviewStreamId() != NO_STREAM) {
1117 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001118 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001119 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001120 return OK;
1121}
1122
1123status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001124 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001125 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001126 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001127 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001128 }
1129
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001130 // Disabling shutter sound may not be allowed. In that case only
1131 // allow the mediaserver process to disable the sound.
1132 char value[PROPERTY_VALUE_MAX];
1133 property_get("ro.camera.sound.forced", value, "0");
1134 if (strncmp(value, "0", 2) != 0) {
1135 // Disabling shutter sound is not allowed. Deny if the current
1136 // process is not mediaserver.
1137 if (getCallingPid() != getpid()) {
1138 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1139 getCallingPid());
1140 return PERMISSION_DENIED;
1141 }
1142 }
1143
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001144 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001145 return OK;
1146}
1147
1148status_t Camera2Client::commandPlayRecordingSoundL() {
1149 mCameraService->playSound(CameraService::SOUND_RECORDING);
1150 return OK;
1151}
1152
1153status_t Camera2Client::commandStartFaceDetectionL(int type) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001154 ALOGV("%s: Camera %d: Starting face detection",
1155 __FUNCTION__, mCameraId);
1156 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001157 SharedParameters::Lock l(mParameters);
1158 switch (l.mParameters.state) {
1159 case Parameters::DISCONNECTED:
1160 case Parameters::STOPPED:
1161 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1162 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001163 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1164 __FUNCTION__, mCameraId);
1165 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001166 case Parameters::PREVIEW:
1167 case Parameters::RECORD:
1168 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001169 // Good to go for starting face detect
1170 break;
1171 }
1172 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001173 if (l.mParameters.fastInfo.bestFaceDetectMode ==
1174 ANDROID_STATS_FACE_DETECTION_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001175 ALOGE("%s: Camera %d: Face detection not supported",
1176 __FUNCTION__, mCameraId);
1177 return INVALID_OPERATION;
1178 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001179 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001180
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001181 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001182
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001183 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001184
1185 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001186}
1187
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001188status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001189 status_t res = OK;
1190 ALOGV("%s: Camera %d: Stopping face detection",
1191 __FUNCTION__, mCameraId);
1192
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001193 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001194
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001195 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001196
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001197 if (params.state == Parameters::PREVIEW
1198 || params.state == Parameters::RECORD
1199 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001200 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001201 }
1202
1203 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001204}
1205
1206status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001207 SharedParameters::Lock l(mParameters);
1208 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001209
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001210 return OK;
1211}
1212
1213status_t Camera2Client::commandPingL() {
1214 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001215 SharedParameters::Lock l(mParameters);
1216 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001217 return OK;
1218 } else {
1219 return NO_INIT;
1220 }
1221}
1222
1223status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
James Dong8da4cd72012-08-04 19:58:07 -07001224 if (recordingEnabledL()) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001225 ALOGE("%s: Camera %d: Error setting video buffer count after "
1226 "recording was started", __FUNCTION__, mCameraId);
1227 return INVALID_OPERATION;
1228 }
1229
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001230 return mStreamingProcessor->setRecordingBufferCount(count);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001231}
1232
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001233/** Device-related methods */
1234
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001235void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1236 ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1237}
1238
1239void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1240 ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1241 frameNumber, timestamp);
1242}
1243
1244void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1245 ALOGV("%s: Autofocus state now %d, last trigger %d",
1246 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001247 bool sendCompletedMessage = false;
1248 bool sendMovingMessage = false;
1249
1250 bool success = false;
1251 bool afInMotion = false;
1252 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001253 SharedParameters::Lock l(mParameters);
1254 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001255 case Parameters::FOCUS_MODE_AUTO:
1256 case Parameters::FOCUS_MODE_MACRO:
1257 // Don't send notifications upstream if they're not for the current AF
1258 // trigger. For example, if cancel was called in between, or if we
1259 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001260 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001261 switch (newState) {
1262 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1263 success = true;
1264 // no break
1265 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1266 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001267 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001268 break;
1269 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1270 // Just starting focusing, ignore
1271 break;
1272 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1273 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1274 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1275 default:
1276 // Unexpected in AUTO/MACRO mode
1277 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1278 __FUNCTION__, newState);
1279 break;
1280 }
1281 break;
1282 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1283 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1284 switch (newState) {
1285 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1286 success = true;
1287 // no break
1288 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1289 // Don't send notifications upstream if they're not for
1290 // the current AF trigger. For example, if cancel was
1291 // called in between, or if we already sent a
1292 // notification about this AF call.
1293 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001294 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001295 sendCompletedMessage = true;
1296 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001297 if (l.mParameters.enableFocusMoveMessages &&
1298 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001299 sendMovingMessage = true;
1300 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001301 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001302 break;
1303 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1304 // Cancel was called, or we switched state; care if
1305 // currently moving
1306 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001307 if (l.mParameters.enableFocusMoveMessages &&
1308 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001309 sendMovingMessage = true;
1310 }
1311 break;
1312 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1313 // Start passive scan, inform upstream
1314 afInMotion = true;
1315 // no break
1316 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1317 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001318 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001319 sendMovingMessage = true;
1320 }
1321 break;
1322 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001323 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001324 break;
1325 case Parameters::FOCUS_MODE_EDOF:
1326 case Parameters::FOCUS_MODE_INFINITY:
1327 case Parameters::FOCUS_MODE_FIXED:
1328 default:
1329 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001330 ALOGE("%s: Unexpected AF state change %d "
1331 "(ID %d) in focus mode %d",
1332 __FUNCTION__, newState, triggerId,
1333 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001334 }
1335 }
1336 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001337 if (sendMovingMessage) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001338 SharedCameraClient::Lock l(mSharedCameraClient);
1339 if (l.mCameraClient != 0) {
1340 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001341 afInMotion ? 1 : 0, 0);
1342 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001343 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001344 if (sendCompletedMessage) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001345 SharedCameraClient::Lock l(mSharedCameraClient);
1346 if (l.mCameraClient != 0) {
1347 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1348 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001349 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001350 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001351}
1352
1353void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1354 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1355 __FUNCTION__, newState, triggerId);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001356 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001357}
1358
1359void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1360 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1361 __FUNCTION__, newState, triggerId);
1362}
1363
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001364int Camera2Client::getCameraId() const {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001365 return mCameraId;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001366}
1367
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001368const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1369 return mDevice;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001370}
1371
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001372const sp<CameraService>& Camera2Client::getCameraService() {
1373 return mCameraService;
1374}
1375
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001376camera2::SharedParameters& Camera2Client::getParameters() {
1377 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001378}
1379
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001380int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001381 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001382}
1383
1384int Camera2Client::getCaptureStreamId() const {
1385 return mJpegProcessor->getStreamId();
1386}
1387
1388int Camera2Client::getCallbackStreamId() const {
1389 return mCallbackProcessor->getStreamId();
1390}
1391
1392int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001393 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001394}
1395
1396int Camera2Client::getZslStreamId() const {
1397 return mZslProcessor->getStreamId();
1398}
1399
1400status_t Camera2Client::registerFrameListener(int32_t id,
1401 wp<camera2::FrameProcessor::FilteredListener> listener) {
1402 return mFrameProcessor->registerListener(id, listener);
1403}
1404
1405status_t Camera2Client::removeFrameListener(int32_t id) {
1406 return mFrameProcessor->removeListener(id);
1407}
1408
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001409Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1410 mCameraClient(client.mCameraClient),
1411 mSharedClient(client) {
1412 mSharedClient.mCameraClientLock.lock();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001413}
1414
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001415Camera2Client::SharedCameraClient::Lock::~Lock() {
1416 mSharedClient.mCameraClientLock.unlock();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001417}
1418
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -07001419Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1420 mCameraClient(client) {
1421}
1422
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001423Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1424 const sp<ICameraClient>&client) {
1425 Mutex::Autolock l(mCameraClientLock);
1426 mCameraClient = client;
1427 return *this;
1428}
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -07001429
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001430void Camera2Client::SharedCameraClient::clear() {
1431 Mutex::Autolock l(mCameraClientLock);
1432 mCameraClient.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001433}
1434
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001435const int32_t Camera2Client::kPreviewRequestId;
1436const int32_t Camera2Client::kRecordRequestId;
1437const int32_t Camera2Client::kFirstCaptureRequestId;
1438
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001439/** Utility methods */
1440
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001441status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001442 status_t res;
1443
Igor Murashkin22d58d32012-10-02 19:07:14 -07001444 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1445
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001446 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001447 if (res != OK) {
1448 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1449 __FUNCTION__, mCameraId, strerror(-res), res);
1450 return res;
1451 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001452 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001453 if (res != OK) {
1454 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1455 __FUNCTION__, mCameraId, strerror(-res), res);
1456 return res;
1457 }
1458
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001459 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001460 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001461 if (res != OK) {
1462 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1463 __FUNCTION__, mCameraId, strerror(-res), res);
1464 return res;
1465 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001466 } else if (params.state == Parameters::RECORD ||
1467 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001468 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001469 if (res != OK) {
1470 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1471 __FUNCTION__, mCameraId, strerror(-res), res);
1472 return res;
1473 }
1474 }
1475 return res;
1476}
1477
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001478
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001479size_t Camera2Client::calculateBufferSize(int width, int height,
1480 int format, int stride) {
1481 switch (format) {
1482 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1483 return width * height * 2;
1484 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1485 return width * height * 3 / 2;
1486 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1487 return width * height * 2;
1488 case HAL_PIXEL_FORMAT_YV12: { // YV12
1489 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07001490 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001491 size_t uvSize = uvStride * height / 2;
1492 return ySize + uvSize * 2;
1493 }
1494 case HAL_PIXEL_FORMAT_RGB_565:
1495 return width * height * 2;
1496 case HAL_PIXEL_FORMAT_RGBA_8888:
1497 return width * height * 4;
1498 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1499 return width * height * 2;
1500 default:
1501 ALOGE("%s: Unknown preview format: %x",
1502 __FUNCTION__, format);
1503 return 0;
1504 }
1505}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001506
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001507} // namespace android