blob: 90355be0e7f68e35707652c53f9b345550dbeb86 [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
17#define LOG_TAG "Camera2Client"
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070018#define ATRACE_TAG ATRACE_TAG_CAMERA
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070019//#define LOG_NDEBUG 0
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070020
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>
Eino-Ville Talvala78822d72012-07-18 17:52:18 -070027#include <media/hardware/MetadataBufferType.h>
James Paintere5382062012-09-05 18:02:32 -070028#include "camera2/Parameters.h"
James Painter10894e52012-09-07 16:36:50 -070029#include "Camera2Client.h"
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070030
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070031#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
32#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
33
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070034namespace android {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070035using namespace camera2;
36
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070037static int getCallingPid() {
38 return IPCThreadState::self()->getCallingPid();
39}
40
41static int getCallingUid() {
42 return IPCThreadState::self()->getCallingUid();
43}
44
45// Interface used by CameraService
46
47Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
48 const sp<ICameraClient>& cameraClient,
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070049 int cameraId,
50 int cameraFacing,
51 int clientPid):
52 Client(cameraService, cameraClient,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070053 cameraId, cameraFacing, clientPid),
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -070054 mSharedCameraClient(cameraClient),
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070055 mParameters(cameraId, cameraFacing),
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -070056 mPreviewStreamId(NO_STREAM),
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -070057 mRecordingStreamId(NO_STREAM),
James Dong983cf232012-08-01 16:39:55 -070058 mRecordingHeapCount(kDefaultRecordingHeapCount)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070059{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070060 ATRACE_CALL();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070061 ALOGI("Camera %d: Opened", cameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070062
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070063 mDevice = new Camera2Device(cameraId);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070064
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070065 SharedParameters::Lock l(mParameters);
66 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070067
68 char value[PROPERTY_VALUE_MAX];
69 property_get("camera.zsl_mode", value, "0");
70 if (!strcmp(value,"1")) {
71 ALOGI("Camera %d: Enabling ZSL mode", cameraId);
72 l.mParameters.zslMode = true;
73 } else {
74 l.mParameters.zslMode = false;
75 }
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070076}
77
Eino-Ville Talvala3a609142012-07-31 14:36:26 -070078status_t Camera2Client::checkPid(const char* checkLocation) const {
79 int callingPid = getCallingPid();
80 if (callingPid == mClientPid) return NO_ERROR;
81
82 ALOGE("%s: attempt to use a locked camera from a different process"
83 " (old pid %d, new pid %d)", checkLocation, mClientPid, callingPid);
84 return PERMISSION_DENIED;
85}
86
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070087status_t Camera2Client::initialize(camera_module_t *module)
88{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070089 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070090 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070091 status_t res;
92
93 res = mDevice->initialize(module);
94 if (res != OK) {
95 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
96 __FUNCTION__, mCameraId, strerror(-res), res);
97 return NO_INIT;
98 }
99
Eino-Ville Talvala174181e2012-08-03 13:53:39 -0700100 res = mDevice->setNotifyCallback(this);
101
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700102 SharedParameters::Lock l(mParameters);
103
104 res = l.mParameters.initialize(&(mDevice->info()));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700105 if (res != OK) {
106 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
107 __FUNCTION__, mCameraId, strerror(-res), res);
108 return NO_INIT;
109 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -0700110
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700111 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700112
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700113 mFrameProcessor = new FrameProcessor(this);
114 threadName = String8::format("Camera2Client[%d]::FrameProcessor",
115 mCameraId);
116 mFrameProcessor->run(threadName.string());
117
118 mCaptureSequencer = new CaptureSequencer(this);
119 threadName = String8::format("Camera2Client[%d]::CaptureSequencer",
120 mCameraId);
121 mCaptureSequencer->run(threadName.string());
122
123 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
124 threadName = String8::format("Camera2Client[%d]::JpegProcessor",
125 mCameraId);
126 mJpegProcessor->run(threadName.string());
127
128 mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
129 threadName = String8::format("Camera2Client[%d]::ZslProcessor",
130 mCameraId);
131 mZslProcessor->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700132
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700133 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700134 threadName = String8::format("Camera2Client[%d]::CallbackProcessor",
135 mCameraId);
136 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700137
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700138 if (gLogLevel >= 1) {
139 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
140 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700141 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700142 }
143
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700144 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700145}
146
147Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700148 ATRACE_CALL();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700149 ALOGV("Camera %d: Shutting down", mCameraId);
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700150
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700151 mDestructionStarted = true;
152
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700153 // Rewrite mClientPid to allow shutdown by CameraService
154 mClientPid = getCallingPid();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700155 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700156
157 mFrameProcessor->requestExit();
Eino-Ville Talvalacf70d342012-09-05 19:02:43 -0700158 mCaptureSequencer->requestExit();
159 mJpegProcessor->requestExit();
160 mZslProcessor->requestExit();
161 mCallbackProcessor->requestExit();
162
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700163 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700164}
165
166status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700167 String8 result;
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700168 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n",
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700169 mCameraId,
170 getCameraClient()->asBinder().get(),
171 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700172 result.append(" State: ");
173#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
174
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700175 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700176
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700177 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700178
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700179 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700180 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700181 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700182 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700183 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700184 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700185 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700186 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700187 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700188 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700189 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700190 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700191 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700192 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700193 p.jpegQuality, p.jpegThumbQuality);
194 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700195 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700196 p.gpsEnabled ? "enabled" : "disabled");
197 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700198 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700199 p.gpsCoordinates[0], p.gpsCoordinates[1],
200 p.gpsCoordinates[2]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700201 result.appendFormat(" GPS timestamp: %lld\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700202 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700203 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700204 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700205 }
206
207 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700208 switch (p.wbMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700209 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO)
210 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT)
211 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT)
212 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT)
213 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT)
214 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT)
215 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT)
216 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE)
217 default: result.append("UNKNOWN\n");
218 }
219
220 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700221 switch (p.effectMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700222 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF)
223 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO)
224 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE)
225 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE)
226 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA)
227 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE)
228 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD)
229 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD)
230 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA)
231 default: result.append("UNKNOWN\n");
232 }
233
234 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700235 switch (p.antibandingMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700236 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO)
237 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF)
238 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ)
239 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ)
240 default: result.append("UNKNOWN\n");
241 }
242
243 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700244 switch (p.sceneMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700245 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
246 result.append("AUTO\n"); break;
247 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
248 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
249 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
250 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
251 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
252 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
255 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
258 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
259 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
260 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
261 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
262 default: result.append("UNKNOWN\n");
263 }
264
265 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700266 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700267 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
268 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
269 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
270 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
271 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
272 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
273 default: result.append("UNKNOWN\n");
274 }
275
276 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700277 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700278 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
279 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
280 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
281 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
282 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
283 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
284 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
285 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
286 default: result.append("UNKNOWN\n");
287 }
288
289 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700290 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700291 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700292 p.focusingAreas[i].left,
293 p.focusingAreas[i].top,
294 p.focusingAreas[i].right,
295 p.focusingAreas[i].bottom,
296 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700297 }
298
299 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700300 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700301
302 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700303 p.autoExposureLock ? "enabled" : "disabled",
304 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700305
306 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700307 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700308 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700309 p.meteringAreas[i].left,
310 p.meteringAreas[i].top,
311 p.meteringAreas[i].right,
312 p.meteringAreas[i].bottom,
313 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700314 }
315
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700316 result.appendFormat(" Zoom index: %d\n", p.zoom);
317 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
318 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700319
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700320 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700321 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700322
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700323 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700324 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700325
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700326 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700327 result.appendFormat(" Preview stream ID: %d\n",
328 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700329 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700330 getCaptureStreamId());
331 result.appendFormat(" Recording stream ID: %d\n",
332 getRecordingStreamId());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700333
334 result.append(" Current requests:\n");
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700335 if (mPreviewRequest.entryCount() != 0) {
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700336 result.append(" Preview request:\n");
337 write(fd, result.string(), result.size());
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700338 mPreviewRequest.dump(fd, 2, 6);
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700339 } else {
340 result.append(" Preview request: undefined\n");
341 write(fd, result.string(), result.size());
342 }
343
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700344 if (mRecordingRequest.entryCount() != 0) {
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700345 result = " Recording request:\n";
346 write(fd, result.string(), result.size());
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700347 mRecordingRequest.dump(fd, 2, 6);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700348 } else {
349 result = " Recording request: undefined\n";
350 write(fd, result.string(), result.size());
351 }
352
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700353 mCaptureSequencer->dump(fd, args);
354
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700355 mFrameProcessor->dump(fd, args);
356
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700357 result = " Device dump:\n";
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700358 write(fd, result.string(), result.size());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700359
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700360 status_t res = mDevice->dump(fd, args);
361 if (res != OK) {
362 result = String8::format(" Error dumping device: %s (%d)",
363 strerror(-res), res);
364 write(fd, result.string(), result.size());
365 }
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700366
367#undef CASE_APPEND_ENUM
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700368 return NO_ERROR;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700369}
370
371// ICamera interface
372
373void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700374 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700375 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700376 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700377 status_t res;
378 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700379
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700380 if (mDevice == 0) return;
381
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700382 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700383
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700384 if (mPreviewStreamId != NO_STREAM) {
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700385 mDevice->deleteStream(mPreviewStreamId);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700386 mPreviewStreamId = NO_STREAM;
387 }
388
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700389 mJpegProcessor->deleteStream();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700390
Eino-Ville Talvala898a9a92012-07-20 11:05:20 -0700391 if (mRecordingStreamId != NO_STREAM) {
392 mDevice->deleteStream(mRecordingStreamId);
393 mRecordingStreamId = NO_STREAM;
394 }
395
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700396 mCallbackProcessor->deleteStream();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700397
Eino-Ville Talvalacf70d342012-09-05 19:02:43 -0700398 mZslProcessor->deleteStream();
399
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700400 mDevice.clear();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700401 SharedParameters::Lock l(mParameters);
402 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700403
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700404 CameraService::Client::disconnect();
405}
406
407status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700408 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700409 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700410 Mutex::Autolock icl(mICameraLock);
411
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700412 if (mClientPid != 0 && getCallingPid() != mClientPid) {
413 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
414 "current locked to pid %d", __FUNCTION__,
415 mCameraId, getCallingPid(), mClientPid);
416 return BAD_VALUE;
417 }
418
419 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700420
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700421 mCameraClient = client;
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -0700422 mSharedCameraClient = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700423
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700424 SharedParameters::Lock l(mParameters);
425 l.mParameters.state = Parameters::STOPPED;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700426
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700427 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700428}
429
430status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700431 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700432 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700433 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700434 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
435 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700436
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700437 if (mClientPid == 0) {
438 mClientPid = getCallingPid();
439 return OK;
440 }
441
442 if (mClientPid != getCallingPid()) {
443 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
444 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
445 return EBUSY;
446 }
447
448 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700449}
450
451status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700452 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700453 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700454 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700455 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
456 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700457
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700458 // TODO: Check for uninterruptable conditions
459
460 if (mClientPid == getCallingPid()) {
461 mClientPid = 0;
462 mCameraClient.clear();
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -0700463 mSharedCameraClient.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700464 return OK;
465 }
466
467 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
468 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
469 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700470}
471
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700472status_t Camera2Client::setPreviewDisplay(
473 const sp<Surface>& surface) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700474 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700475 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700476 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700477 status_t res;
478 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700479
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700480 sp<IBinder> binder;
481 sp<ANativeWindow> window;
482 if (surface != 0) {
483 binder = surface->asBinder();
484 window = surface;
485 }
486
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700487 return setPreviewWindowL(binder,window);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700488}
489
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700490status_t Camera2Client::setPreviewTexture(
491 const sp<ISurfaceTexture>& surfaceTexture) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700492 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700493 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700494 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700495 status_t res;
496 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700497
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700498 sp<IBinder> binder;
499 sp<ANativeWindow> window;
500 if (surfaceTexture != 0) {
501 binder = surfaceTexture->asBinder();
502 window = new SurfaceTextureClient(surfaceTexture);
503 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700504 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700505}
506
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700507status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700508 sp<ANativeWindow> window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700509 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700510 status_t res;
511
512 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700513 ALOGV("%s: Camera %d: New window is same as old window",
514 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700515 return NO_ERROR;
516 }
517
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700518 SharedParameters::Lock l(mParameters);
519 switch (l.mParameters.state) {
520 case Parameters::DISCONNECTED:
521 case Parameters::RECORD:
522 case Parameters::STILL_CAPTURE:
523 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700524 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700525 __FUNCTION__, mCameraId,
526 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700527 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700528 case Parameters::STOPPED:
529 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700530 // OK
531 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700532 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700533 // Already running preview - need to stop and create a new stream
534 // TODO: Optimize this so that we don't wait for old stream to drain
535 // before spinning up new stream
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700536 mDevice->clearStreamingRequest();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700537 l.mParameters.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700538 break;
539 }
540
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700541 if (mPreviewStreamId != NO_STREAM) {
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700542 res = mDevice->waitUntilDrained();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700543 if (res != OK) {
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700544 ALOGE("%s: Error waiting for preview to drain: %s (%d)",
545 __FUNCTION__, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700546 return res;
547 }
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700548 res = mDevice->deleteStream(mPreviewStreamId);
549 if (res != OK) {
550 ALOGE("%s: Unable to delete old preview stream: %s (%d)",
551 __FUNCTION__, strerror(-res), res);
552 return res;
553 }
554 mPreviewStreamId = NO_STREAM;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700555 }
556
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700557 mPreviewSurface = binder;
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700558 mPreviewWindow = window;
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700559
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700560 if (l.mParameters.state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
561 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700562 }
563
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700564 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700565}
566
567void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700568 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700569 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700570 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700571 status_t res;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700572 if ( checkPid(__FUNCTION__) != OK) return;
573
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700574 SharedParameters::Lock l(mParameters);
575 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700576}
577
578void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
579 status_t res = OK;
580 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
581 ALOGV("%s: setting oneshot", __FUNCTION__);
582 params.previewCallbackOneShot = true;
583 }
584 if (params.previewCallbackFlags != (uint32_t)flag) {
585 params.previewCallbackFlags = flag;
586 switch(params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700587 case Parameters::PREVIEW:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700588 res = startPreviewL(params, true);
589 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700590 case Parameters::RECORD:
591 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700592 res = startRecordingL(params, true);
593 break;
594 default:
595 break;
596 }
597 if (res != OK) {
598 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700599 __FUNCTION__, mCameraId,
600 Parameters::getStateName(params.state));
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700601 }
602 }
603
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700604}
605
606status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700607 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700608 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700609 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700610 status_t res;
611 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700612 SharedParameters::Lock l(mParameters);
613 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700614}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700615
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700616status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700617 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700618 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700619 if (params.state >= Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700620 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700621 __FUNCTION__,
622 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700623 return INVALID_OPERATION;
624 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700625
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700626 if (mPreviewWindow == 0) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700627 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700628 return OK;
629 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700630 params.state = Parameters::STOPPED;
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700631
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700632 res = updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700633 if (res != OK) {
634 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
635 __FUNCTION__, mCameraId, strerror(-res), res);
636 return res;
637 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700638 bool callbacksEnabled = params.previewCallbackFlags &
639 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
640 if (callbacksEnabled) {
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700641 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700642 if (res != OK) {
643 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
644 __FUNCTION__, mCameraId, strerror(-res), res);
645 return res;
646 }
647 }
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700648 if (params.zslMode && !params.recordingHint) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700649 res = mZslProcessor->updateStream(params);
650 if (res != OK) {
651 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
652 __FUNCTION__, mCameraId, strerror(-res), res);
653 return res;
654 }
655 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700656
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700657 CameraMetadata *request;
658 if (!params.recordingHint) {
659 if (mPreviewRequest.entryCount() == 0) {
660 res = updatePreviewRequest(params);
661 if (res != OK) {
662 ALOGE("%s: Camera %d: Unable to create preview request: %s (%d)",
663 __FUNCTION__, mCameraId, strerror(-res), res);
664 return res;
665 }
666 }
667 request = &mPreviewRequest;
668 } else {
669 // With recording hint set, we're going to be operating under the
670 // assumption that the user will record video. To optimize recording
671 // startup time, create the necessary output streams for recording and
672 // video snapshot now if they don't already exist.
673 if (mRecordingRequest.entryCount() == 0) {
674 res = updateRecordingRequest(params);
675 if (res != OK) {
676 ALOGE("%s: Camera %d: Unable to create recording preview "
677 "request: %s (%d)",
678 __FUNCTION__, mCameraId, strerror(-res), res);
679 return res;
680 }
681 }
682 request = &mRecordingRequest;
683
684 res = updateRecordingStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700685 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700686 ALOGE("%s: Camera %d: Unable to pre-configure recording "
687 "stream: %s (%d)",
688 __FUNCTION__, mCameraId, strerror(-res), res);
689 return res;
690 }
691
692 res = mJpegProcessor->updateStream(params);
693 if (res != OK) {
694 ALOGE("%s: Camera %d: Can't pre-configure still image "
695 "stream: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700696 __FUNCTION__, mCameraId, strerror(-res), res);
697 return res;
698 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700699 }
700
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700701 Vector<uint8_t> outputStreams;
702 outputStreams.push(getPreviewStreamId());
703
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700704 if (callbacksEnabled) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700705 outputStreams.push(getCallbackStreamId());
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700706 }
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700707 if (params.zslMode && !params.recordingHint) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700708 outputStreams.push(getZslStreamId());
709 }
710
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700711 res = request->update(
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700712 ANDROID_REQUEST_OUTPUT_STREAMS,
713 outputStreams);
714
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700715 if (res != OK) {
716 ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
717 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700718 return res;
719 }
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700720 res = request->sort();
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700721 if (res != OK) {
722 ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)",
723 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700724 return res;
725 }
726
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700727 res = mDevice->setStreamingRequest(*request);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700728 if (res != OK) {
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700729 ALOGE("%s: Camera %d: Unable to set preview request to start preview: "
730 "%s (%d)",
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700731 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700732 return res;
733 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700734 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700735
736 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700737}
738
739void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700740 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700741 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700742 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700743 status_t res;
744 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700745 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700746}
747
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700748void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700749 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700750 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700751 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700752 SharedParameters::Lock l(mParameters);
753 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700754 }
755
756 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700757 case Parameters::DISCONNECTED:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700758 ALOGE("%s: Camera %d: Call before initialized",
759 __FUNCTION__, mCameraId);
760 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700761 case Parameters::STOPPED:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700762 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700763 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700764 ALOGE("%s: Camera %d: Cannot stop preview during still capture.",
765 __FUNCTION__, mCameraId);
766 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700767 case Parameters::RECORD:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700768 // no break - identical to preview
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700769 case Parameters::PREVIEW:
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700770 mDevice->clearStreamingRequest();
Eino-Ville Talvala22671062012-07-20 18:30:37 -0700771 mDevice->waitUntilDrained();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700772 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700773 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
774 SharedParameters::Lock l(mParameters);
775 l.mParameters.state = Parameters::STOPPED;
776 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700777 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700778 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700779 default:
780 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700781 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700782 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700783}
784
785bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700786 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700787 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700788 status_t res;
789 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
790
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700791 SharedParameters::Lock l(mParameters);
792 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700793}
794
795status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700796 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700797 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700798 status_t res;
799 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
800
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700801 SharedParameters::Lock l(mParameters);
802 switch (l.mParameters.state) {
803 case Parameters::RECORD:
804 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700805 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700806 __FUNCTION__, mCameraId,
807 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700808 return INVALID_OPERATION;
809 default:
810 // OK
811 break;
812 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700813
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700814 l.mParameters.storeMetadataInBuffers = enabled;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700815
816 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700817}
818
819status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700820 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700821 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700822 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700823 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700824 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700825 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700826
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700827 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700828}
829
830status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
831 status_t res;
832 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700833 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700834 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700835 if (res != OK) return res;
836 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700837 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700838 // Ready to go
839 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700840 case Parameters::RECORD:
841 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700842 // OK to call this when recording is already on, just skip unless
843 // we're looking to restart
844 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700845 break;
846 default:
847 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700848 __FUNCTION__, mCameraId,
849 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700850 return INVALID_OPERATION;
851 };
852
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700853 if (!params.storeMetadataInBuffers) {
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700854 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
855 "non-metadata recording mode requested!", __FUNCTION__,
856 mCameraId);
857 return INVALID_OPERATION;
858 }
859
Eino-Ville Talvala609acc02012-09-06 18:26:58 -0700860 mCameraService->playSound(CameraService::SOUND_RECORDING);
861
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700862 res = updateRecordingStream(params);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700863 if (res != OK) {
864 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
865 __FUNCTION__, mCameraId, strerror(-res), res);
866 return res;
867 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700868 bool callbacksEnabled = params.previewCallbackFlags &
869 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
870 if (callbacksEnabled) {
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700871 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700872 if (res != OK) {
873 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
874 __FUNCTION__, mCameraId, strerror(-res), res);
875 return res;
876 }
877 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700878
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700879 if (mRecordingRequest.entryCount() == 0) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700880 res = updateRecordingRequest(params);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700881 if (res != OK) {
882 ALOGE("%s: Camera %d: Unable to create recording request: %s (%d)",
883 __FUNCTION__, mCameraId, strerror(-res), res);
884 return res;
885 }
886 }
887
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700888 if (callbacksEnabled) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700889 uint8_t outputStreams[3] ={
890 getPreviewStreamId(),
891 getRecordingStreamId(),
892 getCallbackStreamId()
893 };
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700894 res = mRecordingRequest.update(
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700895 ANDROID_REQUEST_OUTPUT_STREAMS,
896 outputStreams, 3);
897 } else {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700898 uint8_t outputStreams[2] = {
899 getPreviewStreamId(),
900 getRecordingStreamId()
901 };
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700902 res = mRecordingRequest.update(
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700903 ANDROID_REQUEST_OUTPUT_STREAMS,
904 outputStreams, 2);
905 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700906 if (res != OK) {
907 ALOGE("%s: Camera %d: Unable to set up recording request: %s (%d)",
908 __FUNCTION__, mCameraId, strerror(-res), res);
909 return res;
910 }
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -0700911 res = mRecordingRequest.sort();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700912 if (res != OK) {
913 ALOGE("%s: Camera %d: Error sorting recording request: %s (%d)",
914 __FUNCTION__, mCameraId, strerror(-res), res);
915 return res;
916 }
917
918 res = mDevice->setStreamingRequest(mRecordingRequest);
919 if (res != OK) {
920 ALOGE("%s: Camera %d: Unable to set recording request to start "
921 "recording: %s (%d)", __FUNCTION__, mCameraId,
922 strerror(-res), res);
923 return res;
924 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700925 if (params.state < Parameters::RECORD) {
926 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700927 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700928
929 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700930}
931
932void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700933 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700934 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700935 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700936 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700937
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700938 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700939 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
940
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700941 switch (l.mParameters.state) {
942 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700943 // OK to stop
944 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700945 case Parameters::STOPPED:
946 case Parameters::PREVIEW:
947 case Parameters::STILL_CAPTURE:
948 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700949 default:
950 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700951 __FUNCTION__, mCameraId,
952 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700953 return;
954 };
955
Eino-Ville Talvala609acc02012-09-06 18:26:58 -0700956 mCameraService->playSound(CameraService::SOUND_RECORDING);
957
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700958 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700959 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700960 ALOGE("%s: Camera %d: Unable to return to preview",
961 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700962 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700963}
964
965bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700966 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700967 Mutex::Autolock icl(mICameraLock);
James Dong8da4cd72012-08-04 19:58:07 -0700968
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700969 if ( checkPid(__FUNCTION__) != OK) return false;
970
James Dong8da4cd72012-08-04 19:58:07 -0700971 return recordingEnabledL();
972}
973
974bool Camera2Client::recordingEnabledL() {
975 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700976 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -0700977
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700978 return (l.mParameters.state == Parameters::RECORD
979 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700980}
981
982void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700983 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700984 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700985 status_t res;
986 if ( checkPid(__FUNCTION__) != OK) return;
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -0700987
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700988 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -0700989
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700990 // Make sure this is for the current heap
991 ssize_t offset;
992 size_t size;
993 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
994 if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) {
995 ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release "
996 "(got %x, expected %x)", __FUNCTION__, mCameraId,
997 heap->getHeapID(), mRecordingHeap->mHeap->getHeapID());
998 return;
999 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001000 uint8_t *data = (uint8_t*)heap->getBase() + offset;
1001 uint32_t type = *(uint32_t*)data;
1002 if (type != kMetadataBufferTypeGrallocSource) {
1003 ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)",
1004 __FUNCTION__, mCameraId, type, kMetadataBufferTypeGrallocSource);
1005 return;
1006 }
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001007
1008 // Release the buffer back to the recording queue
1009
1010 buffer_handle_t imgHandle = *(buffer_handle_t*)(data + 4);
1011
1012 size_t itemIndex;
1013 for (itemIndex = 0; itemIndex < mRecordingBuffers.size(); itemIndex++) {
1014 const BufferItemConsumer::BufferItem item = mRecordingBuffers[itemIndex];
1015 if (item.mBuf != BufferItemConsumer::INVALID_BUFFER_SLOT &&
1016 item.mGraphicBuffer->handle == imgHandle) {
1017 break;
1018 }
1019 }
1020 if (itemIndex == mRecordingBuffers.size()) {
1021 ALOGE("%s: Camera %d: Can't find buffer_handle_t %p in list of "
1022 "outstanding buffers", __FUNCTION__, mCameraId, imgHandle);
1023 return;
1024 }
1025
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001026 ALOGV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, mCameraId,
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001027 imgHandle);
1028
1029 res = mRecordingConsumer->releaseBuffer(mRecordingBuffers[itemIndex]);
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001030 if (res != OK) {
1031 ALOGE("%s: Camera %d: Unable to free recording frame (buffer_handle_t: %p):"
1032 "%s (%d)",
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001033 __FUNCTION__, mCameraId, imgHandle, strerror(-res), res);
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001034 return;
1035 }
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001036 mRecordingBuffers.replaceAt(itemIndex);
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001037
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001038 mRecordingHeapFree++;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001039}
1040
1041status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001042 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001043 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001044 status_t res;
1045 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1046
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001047 int triggerId;
1048 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001049 SharedParameters::Lock l(mParameters);
1050 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1051 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001052 }
1053
1054 mDevice->triggerAutofocus(triggerId);
1055
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001056 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001057}
1058
1059status_t Camera2Client::cancelAutoFocus() {
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 Talvala3a609142012-07-31 14:36:26 -07001062 status_t res;
1063 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1064
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001065 int triggerId;
1066 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001067 SharedParameters::Lock l(mParameters);
1068 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001069 }
1070
1071 mDevice->triggerCancelAutofocus(triggerId);
1072
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001073 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001074}
1075
1076status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001077 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001078 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001079 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001080 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001081
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001082 SharedParameters::Lock l(mParameters);
1083 switch (l.mParameters.state) {
1084 case Parameters::DISCONNECTED:
1085 case Parameters::STOPPED:
1086 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001087 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
1088 __FUNCTION__, mCameraId);
1089 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001090 case Parameters::PREVIEW:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001091 // Good to go for takePicture
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001092 res = commandStopFaceDetectionL(l.mParameters);
1093 if (res != OK) {
1094 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1095 __FUNCTION__, mCameraId);
1096 return res;
1097 }
1098 l.mParameters.state = Parameters::STILL_CAPTURE;
1099 break;
1100 case Parameters::RECORD:
1101 // Good to go for video snapshot
1102 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001103 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001104 case Parameters::STILL_CAPTURE:
1105 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001106 ALOGE("%s: Camera %d: Already taking a picture",
1107 __FUNCTION__, mCameraId);
1108 return INVALID_OPERATION;
1109 }
1110
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001111 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001112
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001113 res = mJpegProcessor->updateStream(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001114 if (res != OK) {
1115 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1116 __FUNCTION__, mCameraId, strerror(-res), res);
1117 return res;
1118 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001119
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001120 res = mCaptureSequencer->startCapture();
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001121 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001122 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001123 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001124 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001125
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001126 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001127}
1128
1129status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001130 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001131 ALOGV("%s: E", __FUNCTION__);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001132 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001133 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001134 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1135
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001136 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001137
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001138 res = l.mParameters.set(params);
1139 if (res != OK) return res;
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001140
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001141 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001142
1143 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001144}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001145
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001146String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001147 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001148 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001149 if ( checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001150
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001151 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001152
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001153 // TODO: Deal with focus distances
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001154 return l.mParameters.paramsFlattened;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001155}
1156
1157status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001158 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001159 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001160 status_t res;
1161 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001162
1163 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1164 cmd, arg1, arg2);
1165
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001166 switch (cmd) {
1167 case CAMERA_CMD_START_SMOOTH_ZOOM:
1168 return commandStartSmoothZoomL();
1169 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1170 return commandStopSmoothZoomL();
1171 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1172 return commandSetDisplayOrientationL(arg1);
1173 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1174 return commandEnableShutterSoundL(arg1 == 1);
1175 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1176 return commandPlayRecordingSoundL();
1177 case CAMERA_CMD_START_FACE_DETECTION:
1178 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001179 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001180 SharedParameters::Lock l(mParameters);
1181 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001182 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001183 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1184 return commandEnableFocusMoveMsgL(arg1 == 1);
1185 case CAMERA_CMD_PING:
1186 return commandPingL();
1187 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1188 return commandSetVideoBufferCountL(arg1);
1189 default:
1190 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1191 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001192 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001193 }
1194}
James Dong983cf232012-08-01 16:39:55 -07001195
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001196status_t Camera2Client::commandStartSmoothZoomL() {
1197 ALOGE("%s: Unimplemented!", __FUNCTION__);
1198 return OK;
1199}
James Dong983cf232012-08-01 16:39:55 -07001200
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001201status_t Camera2Client::commandStopSmoothZoomL() {
1202 ALOGE("%s: Unimplemented!", __FUNCTION__);
1203 return OK;
1204}
James Dong983cf232012-08-01 16:39:55 -07001205
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001206status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001207 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001208 mCameraFacing == CAMERA_FACING_FRONT);
1209 if (transform == -1) {
1210 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1211 __FUNCTION__, mCameraId, degrees);
1212 return BAD_VALUE;
1213 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001214 SharedParameters::Lock l(mParameters);
1215 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001216 mPreviewStreamId != NO_STREAM) {
1217 mDevice->setStreamTransform(mPreviewStreamId, transform);
1218 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001219 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001220 return OK;
1221}
1222
1223status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001224 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001225 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001226 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001227 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001228 }
1229
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001230 // Disabling shutter sound may not be allowed. In that case only
1231 // allow the mediaserver process to disable the sound.
1232 char value[PROPERTY_VALUE_MAX];
1233 property_get("ro.camera.sound.forced", value, "0");
1234 if (strncmp(value, "0", 2) != 0) {
1235 // Disabling shutter sound is not allowed. Deny if the current
1236 // process is not mediaserver.
1237 if (getCallingPid() != getpid()) {
1238 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1239 getCallingPid());
1240 return PERMISSION_DENIED;
1241 }
1242 }
1243
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001244 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001245 return OK;
1246}
1247
1248status_t Camera2Client::commandPlayRecordingSoundL() {
1249 mCameraService->playSound(CameraService::SOUND_RECORDING);
1250 return OK;
1251}
1252
1253status_t Camera2Client::commandStartFaceDetectionL(int type) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001254 ALOGV("%s: Camera %d: Starting face detection",
1255 __FUNCTION__, mCameraId);
1256 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001257 SharedParameters::Lock l(mParameters);
1258 switch (l.mParameters.state) {
1259 case Parameters::DISCONNECTED:
1260 case Parameters::STOPPED:
1261 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1262 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001263 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1264 __FUNCTION__, mCameraId);
1265 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001266 case Parameters::PREVIEW:
1267 case Parameters::RECORD:
1268 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001269 // Good to go for starting face detect
1270 break;
1271 }
1272 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001273 if (l.mParameters.fastInfo.bestFaceDetectMode ==
1274 ANDROID_STATS_FACE_DETECTION_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001275 ALOGE("%s: Camera %d: Face detection not supported",
1276 __FUNCTION__, mCameraId);
1277 return INVALID_OPERATION;
1278 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001279 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001280
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001281 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001282
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001283 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001284
1285 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001286}
1287
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001288status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001289 status_t res = OK;
1290 ALOGV("%s: Camera %d: Stopping face detection",
1291 __FUNCTION__, mCameraId);
1292
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001293 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001294
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001295 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001296
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001297 if (params.state == Parameters::PREVIEW
1298 || params.state == Parameters::RECORD
1299 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001300 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001301 }
1302
1303 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001304}
1305
1306status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001307 SharedParameters::Lock l(mParameters);
1308 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001309
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001310 return OK;
1311}
1312
1313status_t Camera2Client::commandPingL() {
1314 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001315 SharedParameters::Lock l(mParameters);
1316 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001317 return OK;
1318 } else {
1319 return NO_INIT;
1320 }
1321}
1322
1323status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
James Dong8da4cd72012-08-04 19:58:07 -07001324 if (recordingEnabledL()) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001325 ALOGE("%s: Camera %d: Error setting video buffer count after "
1326 "recording was started", __FUNCTION__, mCameraId);
1327 return INVALID_OPERATION;
1328 }
1329
1330 // 32 is the current upper limit on the video buffer count for BufferQueue
1331 if (count > 32) {
1332 ALOGE("%s: Camera %d: Error setting %d as video buffer count value",
1333 __FUNCTION__, mCameraId, count);
1334 return BAD_VALUE;
1335 }
1336
1337 // Need to reallocate memory for heap
1338 if (mRecordingHeapCount != count) {
1339 if (mRecordingHeap != 0) {
1340 mRecordingHeap.clear();
1341 mRecordingHeap = NULL;
1342 }
1343 mRecordingHeapCount = count;
1344 }
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001345
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001346 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001347}
1348
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001349/** Device-related methods */
1350
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001351void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1352 ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1353}
1354
1355void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1356 ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1357 frameNumber, timestamp);
1358}
1359
1360void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1361 ALOGV("%s: Autofocus state now %d, last trigger %d",
1362 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001363 bool sendCompletedMessage = false;
1364 bool sendMovingMessage = false;
1365
1366 bool success = false;
1367 bool afInMotion = false;
1368 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001369 SharedParameters::Lock l(mParameters);
1370 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001371 case Parameters::FOCUS_MODE_AUTO:
1372 case Parameters::FOCUS_MODE_MACRO:
1373 // Don't send notifications upstream if they're not for the current AF
1374 // trigger. For example, if cancel was called in between, or if we
1375 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001376 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001377 switch (newState) {
1378 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1379 success = true;
1380 // no break
1381 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1382 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001383 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001384 break;
1385 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1386 // Just starting focusing, ignore
1387 break;
1388 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1389 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1390 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1391 default:
1392 // Unexpected in AUTO/MACRO mode
1393 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1394 __FUNCTION__, newState);
1395 break;
1396 }
1397 break;
1398 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1399 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1400 switch (newState) {
1401 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1402 success = true;
1403 // no break
1404 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1405 // Don't send notifications upstream if they're not for
1406 // the current AF trigger. For example, if cancel was
1407 // called in between, or if we already sent a
1408 // notification about this AF call.
1409 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001410 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001411 sendCompletedMessage = true;
1412 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001413 if (l.mParameters.enableFocusMoveMessages &&
1414 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001415 sendMovingMessage = true;
1416 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001417 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001418 break;
1419 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1420 // Cancel was called, or we switched state; care if
1421 // currently moving
1422 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001423 if (l.mParameters.enableFocusMoveMessages &&
1424 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001425 sendMovingMessage = true;
1426 }
1427 break;
1428 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1429 // Start passive scan, inform upstream
1430 afInMotion = true;
1431 // no break
1432 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1433 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001434 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001435 sendMovingMessage = true;
1436 }
1437 break;
1438 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001439 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001440 break;
1441 case Parameters::FOCUS_MODE_EDOF:
1442 case Parameters::FOCUS_MODE_INFINITY:
1443 case Parameters::FOCUS_MODE_FIXED:
1444 default:
1445 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001446 ALOGE("%s: Unexpected AF state change %d "
1447 "(ID %d) in focus mode %d",
1448 __FUNCTION__, newState, triggerId,
1449 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001450 }
1451 }
1452 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001453 if (sendMovingMessage) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001454 SharedCameraClient::Lock l(mSharedCameraClient);
1455 if (l.mCameraClient != 0) {
1456 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001457 afInMotion ? 1 : 0, 0);
1458 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001459 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001460 if (sendCompletedMessage) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001461 SharedCameraClient::Lock l(mSharedCameraClient);
1462 if (l.mCameraClient != 0) {
1463 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1464 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001465 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001466 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001467}
1468
1469void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1470 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1471 __FUNCTION__, newState, triggerId);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001472 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001473}
1474
1475void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1476 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1477 __FUNCTION__, newState, triggerId);
1478}
1479
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001480int Camera2Client::getCameraId() const {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001481 return mCameraId;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001482}
1483
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001484const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1485 return mDevice;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001486}
1487
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001488const sp<CameraService>& Camera2Client::getCameraService() {
1489 return mCameraService;
1490}
1491
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001492camera2::SharedParameters& Camera2Client::getParameters() {
1493 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001494}
1495
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001496int Camera2Client::getPreviewStreamId() const {
1497 return mPreviewStreamId;
1498}
1499
1500int Camera2Client::getCaptureStreamId() const {
1501 return mJpegProcessor->getStreamId();
1502}
1503
1504int Camera2Client::getCallbackStreamId() const {
1505 return mCallbackProcessor->getStreamId();
1506}
1507
1508int Camera2Client::getRecordingStreamId() const {
1509 return mRecordingStreamId;
1510}
1511
1512int Camera2Client::getZslStreamId() const {
1513 return mZslProcessor->getStreamId();
1514}
1515
1516status_t Camera2Client::registerFrameListener(int32_t id,
1517 wp<camera2::FrameProcessor::FilteredListener> listener) {
1518 return mFrameProcessor->registerListener(id, listener);
1519}
1520
1521status_t Camera2Client::removeFrameListener(int32_t id) {
1522 return mFrameProcessor->removeListener(id);
1523}
1524
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001525Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1526 mCameraClient(client.mCameraClient),
1527 mSharedClient(client) {
1528 mSharedClient.mCameraClientLock.lock();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001529}
1530
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001531Camera2Client::SharedCameraClient::Lock::~Lock() {
1532 mSharedClient.mCameraClientLock.unlock();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001533}
1534
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -07001535Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1536 mCameraClient(client) {
1537}
1538
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001539Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1540 const sp<ICameraClient>&client) {
1541 Mutex::Autolock l(mCameraClientLock);
1542 mCameraClient = client;
1543 return *this;
1544}
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -07001545
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001546void Camera2Client::SharedCameraClient::clear() {
1547 Mutex::Autolock l(mCameraClientLock);
1548 mCameraClient.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001549}
1550
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001551const int32_t Camera2Client::kPreviewRequestId;
1552const int32_t Camera2Client::kRecordRequestId;
1553const int32_t Camera2Client::kFirstCaptureRequestId;
1554
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001555void Camera2Client::onRecordingFrameAvailable() {
1556 ATRACE_CALL();
1557 status_t res;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001558 sp<Camera2Heap> recordingHeap;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001559 size_t heapIdx = 0;
1560 nsecs_t timestamp;
1561 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001562 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001563
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001564 BufferItemConsumer::BufferItem imgBuffer;
1565 res = mRecordingConsumer->acquireBuffer(&imgBuffer);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001566 if (res != OK) {
1567 ALOGE("%s: Camera %d: Error receiving recording buffer: %s (%d)",
1568 __FUNCTION__, mCameraId, strerror(-res), res);
1569 return;
1570 }
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001571 timestamp = imgBuffer.mTimestamp;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001572
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001573 mRecordingFrameCount++;
1574 ALOGV("OnRecordingFrame: Frame %d", mRecordingFrameCount);
1575
1576 // TODO: Signal errors here upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001577 if (l.mParameters.state != Parameters::RECORD &&
1578 l.mParameters.state != Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001579 ALOGV("%s: Camera %d: Discarding recording image buffers received after "
1580 "recording done",
1581 __FUNCTION__, mCameraId);
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001582 mRecordingConsumer->releaseBuffer(imgBuffer);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001583 return;
1584 }
Eino-Ville Talvala898a9a92012-07-20 11:05:20 -07001585
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001586 if (mRecordingHeap == 0) {
1587 const size_t bufferSize = 4 + sizeof(buffer_handle_t);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001588 ALOGV("%s: Camera %d: Creating recording heap with %d buffers of "
1589 "size %d bytes", __FUNCTION__, mCameraId,
James Dong983cf232012-08-01 16:39:55 -07001590 mRecordingHeapCount, bufferSize);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001591
James Dong983cf232012-08-01 16:39:55 -07001592 mRecordingHeap = new Camera2Heap(bufferSize, mRecordingHeapCount,
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001593 "Camera2Client::RecordingHeap");
1594 if (mRecordingHeap->mHeap->getSize() == 0) {
1595 ALOGE("%s: Camera %d: Unable to allocate memory for recording",
1596 __FUNCTION__, mCameraId);
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001597 mRecordingConsumer->releaseBuffer(imgBuffer);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001598 return;
1599 }
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001600 for (size_t i = 0; i < mRecordingBuffers.size(); i++) {
1601 if (mRecordingBuffers[i].mBuf !=
1602 BufferItemConsumer::INVALID_BUFFER_SLOT) {
1603 ALOGE("%s: Camera %d: Non-empty recording buffers list!",
1604 __FUNCTION__, mCameraId);
1605 }
1606 }
1607 mRecordingBuffers.clear();
1608 mRecordingBuffers.setCapacity(mRecordingHeapCount);
1609 mRecordingBuffers.insertAt(0, mRecordingHeapCount);
1610
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001611 mRecordingHeapHead = 0;
James Dong983cf232012-08-01 16:39:55 -07001612 mRecordingHeapFree = mRecordingHeapCount;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001613 }
1614
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001615 if ( mRecordingHeapFree == 0) {
1616 ALOGE("%s: Camera %d: No free recording buffers, dropping frame",
1617 __FUNCTION__, mCameraId);
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001618 mRecordingConsumer->releaseBuffer(imgBuffer);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001619 return;
1620 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001621
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001622 heapIdx = mRecordingHeapHead;
James Dong983cf232012-08-01 16:39:55 -07001623 mRecordingHeapHead = (mRecordingHeapHead + 1) % mRecordingHeapCount;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001624 mRecordingHeapFree--;
1625
1626 ALOGV("%s: Camera %d: Timestamp %lld",
1627 __FUNCTION__, mCameraId, timestamp);
1628
1629 ssize_t offset;
1630 size_t size;
1631 sp<IMemoryHeap> heap =
1632 mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset,
1633 &size);
1634
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001635 uint8_t *data = (uint8_t*)heap->getBase() + offset;
1636 uint32_t type = kMetadataBufferTypeGrallocSource;
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001637 *((uint32_t*)data) = type;
1638 *((buffer_handle_t*)(data + 4)) = imgBuffer.mGraphicBuffer->handle;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001639 ALOGV("%s: Camera %d: Sending out buffer_handle_t %p",
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001640 __FUNCTION__, mCameraId, imgBuffer.mGraphicBuffer->handle);
1641 mRecordingBuffers.replaceAt(imgBuffer, heapIdx);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001642 recordingHeap = mRecordingHeap;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001643 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001644
1645 // Call outside locked parameters to allow re-entrancy from notification
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001646 SharedCameraClient::Lock l(mSharedCameraClient);
1647 if (l.mCameraClient != 0) {
1648 l.mCameraClient->dataCallbackTimestamp(timestamp,
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001649 CAMERA_MSG_VIDEO_FRAME,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001650 recordingHeap->mBuffers[heapIdx]);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001651 }
1652}
1653
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001654/** Utility methods */
1655
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001656status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001657 status_t res;
1658
1659 res = updatePreviewRequest(params);
1660 if (res != OK) {
1661 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1662 __FUNCTION__, mCameraId, strerror(-res), res);
1663 return res;
1664 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001665 res = updateRecordingRequest(params);
1666 if (res != OK) {
1667 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1668 __FUNCTION__, mCameraId, strerror(-res), res);
1669 return res;
1670 }
1671
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001672 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001673 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001674 if (res != OK) {
1675 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1676 __FUNCTION__, mCameraId, strerror(-res), res);
1677 return res;
1678 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001679 } else if (params.state == Parameters::RECORD ||
1680 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001681 res = mDevice->setStreamingRequest(mRecordingRequest);
1682 if (res != OK) {
1683 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1684 __FUNCTION__, mCameraId, strerror(-res), res);
1685 return res;
1686 }
1687 }
1688 return res;
1689}
1690
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001691status_t Camera2Client::updatePreviewStream(const Parameters &params) {
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001692 ATRACE_CALL();
1693 status_t res;
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001694
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001695 if (mPreviewStreamId != NO_STREAM) {
1696 // Check if stream parameters have to change
1697 uint32_t currentWidth, currentHeight;
1698 res = mDevice->getStreamInfo(mPreviewStreamId,
1699 &currentWidth, &currentHeight, 0);
1700 if (res != OK) {
1701 ALOGE("%s: Camera %d: Error querying preview stream info: "
1702 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1703 return res;
1704 }
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001705 if (currentWidth != (uint32_t)params.previewWidth ||
1706 currentHeight != (uint32_t)params.previewHeight) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001707 ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d",
1708 __FUNCTION__, mCameraId, currentWidth, currentHeight,
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001709 params.previewWidth, params.previewHeight);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001710 res = mDevice->waitUntilDrained();
1711 if (res != OK) {
1712 ALOGE("%s: Camera %d: Error waiting for preview to drain: "
1713 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1714 return res;
1715 }
1716 res = mDevice->deleteStream(mPreviewStreamId);
1717 if (res != OK) {
1718 ALOGE("%s: Camera %d: Unable to delete old output stream "
1719 "for preview: %s (%d)", __FUNCTION__, mCameraId,
1720 strerror(-res), res);
1721 return res;
1722 }
1723 mPreviewStreamId = NO_STREAM;
1724 }
1725 }
1726
1727 if (mPreviewStreamId == NO_STREAM) {
1728 res = mDevice->createStream(mPreviewWindow,
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001729 params.previewWidth, params.previewHeight,
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001730 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0,
1731 &mPreviewStreamId);
1732 if (res != OK) {
1733 ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)",
1734 __FUNCTION__, mCameraId, strerror(-res), res);
1735 return res;
1736 }
1737 }
1738
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001739 res = mDevice->setStreamTransform(mPreviewStreamId,
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001740 params.previewTransform);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001741 if (res != OK) {
1742 ALOGE("%s: Camera %d: Unable to set preview stream transform: "
1743 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1744 return res;
1745 }
1746
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001747 return OK;
1748}
1749
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001750status_t Camera2Client::updatePreviewRequest(const Parameters &params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001751 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001752 status_t res;
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -07001753 if (mPreviewRequest.entryCount() == 0) {
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001754 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
1755 &mPreviewRequest);
1756 if (res != OK) {
1757 ALOGE("%s: Camera %d: Unable to create default preview request: "
1758 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1759 return res;
1760 }
1761 }
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001762
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001763 res = params.updateRequest(&mPreviewRequest);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001764 if (res != OK) {
1765 ALOGE("%s: Camera %d: Unable to update common entries of preview "
1766 "request: %s (%d)", __FUNCTION__, mCameraId,
1767 strerror(-res), res);
1768 return res;
1769 }
1770
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001771 res = mPreviewRequest.update(ANDROID_REQUEST_ID,
1772 &kPreviewRequestId, 1);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001773
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001774 return OK;
1775}
1776
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001777status_t Camera2Client::updateRecordingRequest(const Parameters &params) {
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001778 ATRACE_CALL();
1779 status_t res;
Eino-Ville Talvalacab96a42012-08-24 11:29:22 -07001780 if (mRecordingRequest.entryCount() == 0) {
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001781 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD,
1782 &mRecordingRequest);
1783 if (res != OK) {
1784 ALOGE("%s: Camera %d: Unable to create default recording request:"
1785 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1786 return res;
1787 }
1788 }
1789
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001790 res = params.updateRequest(&mRecordingRequest);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001791 if (res != OK) {
1792 ALOGE("%s: Camera %d: Unable to update common entries of recording "
1793 "request: %s (%d)", __FUNCTION__, mCameraId,
1794 strerror(-res), res);
1795 return res;
1796 }
1797
1798 return OK;
1799}
1800
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001801status_t Camera2Client::updateRecordingStream(const Parameters &params) {
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001802 status_t res;
1803
1804 if (mRecordingConsumer == 0) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001805 // Create CPU buffer queue endpoint. We need one more buffer here so that we can
1806 // always acquire and free a buffer when the heap is full; otherwise the consumer
1807 // will have buffers in flight we'll never clear out.
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001808 mRecordingConsumer = new BufferItemConsumer(
1809 GRALLOC_USAGE_HW_VIDEO_ENCODER,
1810 mRecordingHeapCount + 1,
1811 true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001812 mRecordingConsumer->setFrameAvailableListener(new RecordingWaiter(this));
1813 mRecordingConsumer->setName(String8("Camera2Client::RecordingConsumer"));
1814 mRecordingWindow = new SurfaceTextureClient(
1815 mRecordingConsumer->getProducerInterface());
1816 // Allocate memory later, since we don't know buffer size until receipt
1817 }
1818
1819 if (mRecordingStreamId != NO_STREAM) {
1820 // Check if stream parameters have to change
1821 uint32_t currentWidth, currentHeight;
1822 res = mDevice->getStreamInfo(mRecordingStreamId,
1823 &currentWidth, &currentHeight, 0);
1824 if (res != OK) {
1825 ALOGE("%s: Camera %d: Error querying recording output stream info: "
1826 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1827 return res;
1828 }
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001829 if (currentWidth != (uint32_t)params.videoWidth ||
1830 currentHeight != (uint32_t)params.videoHeight) {
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001831 // TODO: Should wait to be sure previous recording has finished
1832 res = mDevice->deleteStream(mRecordingStreamId);
1833 if (res != OK) {
1834 ALOGE("%s: Camera %d: Unable to delete old output stream "
1835 "for recording: %s (%d)", __FUNCTION__, mCameraId,
1836 strerror(-res), res);
1837 return res;
1838 }
1839 mRecordingStreamId = NO_STREAM;
1840 }
1841 }
1842
1843 if (mRecordingStreamId == NO_STREAM) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001844 mRecordingFrameCount = 0;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001845 res = mDevice->createStream(mRecordingWindow,
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -07001846 params.videoWidth, params.videoHeight,
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001847 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001848 if (res != OK) {
1849 ALOGE("%s: Camera %d: Can't create output stream for recording: "
1850 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1851 return res;
1852 }
1853 }
1854
1855 return OK;
1856}
1857
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001858size_t Camera2Client::calculateBufferSize(int width, int height,
1859 int format, int stride) {
1860 switch (format) {
1861 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1862 return width * height * 2;
1863 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1864 return width * height * 3 / 2;
1865 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1866 return width * height * 2;
1867 case HAL_PIXEL_FORMAT_YV12: { // YV12
1868 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07001869 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001870 size_t uvSize = uvStride * height / 2;
1871 return ySize + uvSize * 2;
1872 }
1873 case HAL_PIXEL_FORMAT_RGB_565:
1874 return width * height * 2;
1875 case HAL_PIXEL_FORMAT_RGBA_8888:
1876 return width * height * 4;
1877 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1878 return width * height * 2;
1879 default:
1880 ALOGE("%s: Unknown preview format: %x",
1881 __FUNCTION__, format);
1882 return 0;
1883 }
1884}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001885
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001886} // namespace android