1 /*
2 **
3 ** Copyright 2008, The Android Open Source Project
4 ** Copyright 2010, Samsung Electronics Co. LTD
5 **
6 ** Licensed under the Apache License, Version 2.0 (the "License");
7 ** you may not use this file except in compliance with the License.
8 ** You may obtain a copy of the License at
9 **
10 ** http://www.apache.org/licenses/LICENSE-2.0
11 **
12 ** Unless required by applicable law or agreed to in writing, software
13 ** distributed under the License is distributed on an "AS IS" BASIS,
14 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 ** See the License for the specific language governing permissions and
16 ** limitations under the License.
17 */
18
19 //#define LOG_NDEBUG 0
20 #define LOG_TAG "CameraHardwareSec"
21 #include <utils/Log.h>
22
23 #include "SecCameraHWInterface.h"
24 #include <utils/threads.h>
25 #include <fcntl.h>
26 #include <sys/mman.h>
27 #include <camera/Camera.h>
28 #include <MetadataBufferType.h>
29
30 #define VIDEO_COMMENT_MARKER_H 0xFFBE
31 #define VIDEO_COMMENT_MARKER_L 0xFFBF
32 #define VIDEO_COMMENT_MARKER_LENGTH 4
33 #define JPEG_EOI_MARKER 0xFFD9
34 #define HIBYTE(x) (((x) >> 8) & 0xFF)
35 #define LOBYTE(x) ((x) & 0xFF)
36
37 #define BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR "0.10,1.20,Infinity"
38 #define BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR "0.10,0.20,Infinity"
39 #define BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR "0.10,1.20,Infinity"
40 #define FRONT_CAMERA_FOCUS_DISTANCES_STR "0.20,0.25,Infinity"
41
42 // FIXME:
43 // -- The actual preview color is set to YV12. The preview frames
44 // returned via preview callback must be generated by color
45 // conversion if the requested preview color format for the
46 // preview frames is _not_ YV12. The reason that YV12 is used
47 // for actual preview is because that is the only color format
48 // supported by gralloc. Matching the preview cor format with
49 // gralloc color format improves performance since no color
50 // conversion is needed for preview.
51 //
52 // -- we only support two preview color formats that client
53 // applications can set: NV21 and YUV420/YV12.
54
55 namespace android {
56
57 struct addrs {
58 uint32_t type; // make sure that this is 4 byte.
59 unsigned int addr_y;
60 unsigned int addr_cbcr;
61 unsigned int buf_index;
62 unsigned int reserved;
63 };
64
65 struct addrs_cap {
66 unsigned int addr_y;
67 unsigned int width;
68 unsigned int height;
69 };
70
71 static const int INITIAL_SKIP_FRAME = 3;
72 static const int EFFECT_SKIP_FRAME = 1;
73
74 gralloc_module_t const* CameraHardwareSec::mGrallocHal;
75
CameraHardwareSec(int cameraId,camera_device_t * dev)76 CameraHardwareSec::CameraHardwareSec(int cameraId, camera_device_t *dev)
77 :
78 mCaptureInProgress(false),
79 mParameters(),
80 mCameraSensorName(NULL),
81 mSkipFrame(0),
82 mNotifyCb(0),
83 mDataCb(0),
84 mDataCbTimestamp(0),
85 mCallbackCookie(0),
86 mMsgEnabled(0),
87 mRecordRunning(false),
88 mPostViewWidth(0),
89 mPostViewHeight(0),
90 mPostViewSize(0),
91 mHalDevice(dev)
92 {
93 ALOGV("%s :", __func__);
94 int ret = 0;
95
96 mPreviewWindow = NULL;
97 mSecCamera = SecCamera::createInstance();
98
99 mRawHeap = NULL;
100 mPreviewHeap = NULL;
101 mRecordHeap = NULL;
102
103 if (!mGrallocHal) {
104 ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&mGrallocHal);
105 if (ret)
106 ALOGE("ERR(%s):Fail on loading gralloc HAL", __func__);
107 }
108
109 ret = mSecCamera->initCamera(cameraId);
110 if (ret < 0) {
111 ALOGE("ERR(%s):Fail on mSecCamera init", __func__);
112 }
113
114 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
115 ALOGV("mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
116 mPostViewWidth,mPostViewHeight,mPostViewSize);
117
118 initDefaultParameters(cameraId);
119
120 mExitAutoFocusThread = false;
121 mExitPreviewThread = false;
122 /* whether the PreviewThread is active in preview or stopped. we
123 * create the thread but it is initially in stopped state.
124 */
125 mPreviewRunning = false;
126 mPreviewStartDeferred = false;
127 mPreviewThread = new PreviewThread(this);
128 mAutoFocusThread = new AutoFocusThread(this);
129 mPictureThread = new PictureThread(this);
130 }
131
getCameraId() const132 int CameraHardwareSec::getCameraId() const
133 {
134 return mSecCamera->getCameraId();
135 }
136
initDefaultParameters(int cameraId)137 void CameraHardwareSec::initDefaultParameters(int cameraId)
138 {
139 if (mSecCamera == NULL) {
140 ALOGE("ERR(%s):mSecCamera object is NULL", __func__);
141 return;
142 }
143
144 CameraParameters p;
145 CameraParameters ip;
146
147 mCameraSensorName = mSecCamera->getCameraSensorName();
148 ALOGV("CameraSensorName: %s", mCameraSensorName);
149
150 int preview_max_width = 0;
151 int preview_max_height = 0;
152 int snapshot_max_width = 0;
153 int snapshot_max_height = 0;
154
155 if (cameraId == SecCamera::CAMERA_ID_BACK) {
156 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
157 "720x480,640x480,352x288,176x144");
158 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
159 "2560x1920,2048x1536,1600x1200,1280x960,640x480");
160 } else {
161 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
162 "640x480,320x240,176x144");
163 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
164 "640x480");
165 }
166
167 p.getSupportedPreviewSizes(mSupportedPreviewSizes);
168
169 // If these fail, then we are using an invalid cameraId and we'll leave the
170 // sizes at zero to catch the error.
171 if (mSecCamera->getPreviewMaxSize(&preview_max_width,
172 &preview_max_height) < 0)
173 ALOGE("getPreviewMaxSize fail (%d / %d) \n",
174 preview_max_width, preview_max_height);
175 if (mSecCamera->getSnapshotMaxSize(&snapshot_max_width,
176 &snapshot_max_height) < 0)
177 ALOGE("getSnapshotMaxSize fail (%d / %d) \n",
178 snapshot_max_width, snapshot_max_height);
179 String8 previewColorString;
180 previewColorString = CameraParameters::PIXEL_FORMAT_YUV420SP;
181 previewColorString.append(",");
182 previewColorString.append(CameraParameters::PIXEL_FORMAT_YUV420P);
183 p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP);
184 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, previewColorString.string());
185 p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, CameraParameters::PIXEL_FORMAT_YUV420P);
186 p.setPreviewSize(preview_max_width, preview_max_height);
187
188 p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
189 p.setPictureSize(snapshot_max_width, snapshot_max_height);
190 p.set(CameraParameters::KEY_JPEG_QUALITY, "100"); // maximum quality
191 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
192 CameraParameters::PIXEL_FORMAT_JPEG);
193
194 String8 parameterString;
195
196 if (cameraId == SecCamera::CAMERA_ID_BACK) {
197 parameterString = CameraParameters::FOCUS_MODE_AUTO;
198 parameterString.append(",");
199 parameterString.append(CameraParameters::FOCUS_MODE_INFINITY);
200 parameterString.append(",");
201 parameterString.append(CameraParameters::FOCUS_MODE_MACRO);
202 p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
203 parameterString.string());
204 p.set(CameraParameters::KEY_FOCUS_MODE,
205 CameraParameters::FOCUS_MODE_AUTO);
206 p.set(CameraParameters::KEY_FOCUS_DISTANCES,
207 BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
208 p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
209 "320x240,0x0");
210 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "320");
211 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "240");
212 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "30");
213 p.setPreviewFrameRate(30);
214 } else {
215 parameterString = CameraParameters::FOCUS_MODE_FIXED;
216 p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
217 parameterString.string());
218 p.set(CameraParameters::KEY_FOCUS_MODE,
219 CameraParameters::FOCUS_MODE_FIXED);
220 p.set(CameraParameters::KEY_FOCUS_DISTANCES,
221 FRONT_CAMERA_FOCUS_DISTANCES_STR);
222 p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
223 "160x120,0x0");
224 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160");
225 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120");
226 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "15");
227 p.setPreviewFrameRate(15);
228 }
229
230 parameterString = CameraParameters::EFFECT_NONE;
231 parameterString.append(",");
232 parameterString.append(CameraParameters::EFFECT_MONO);
233 parameterString.append(",");
234 parameterString.append(CameraParameters::EFFECT_NEGATIVE);
235 parameterString.append(",");
236 parameterString.append(CameraParameters::EFFECT_SEPIA);
237 p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, parameterString.string());
238
239 if (cameraId == SecCamera::CAMERA_ID_BACK) {
240 parameterString = CameraParameters::FLASH_MODE_ON;
241 parameterString.append(",");
242 parameterString.append(CameraParameters::FLASH_MODE_OFF);
243 parameterString.append(",");
244 parameterString.append(CameraParameters::FLASH_MODE_AUTO);
245 parameterString.append(",");
246 parameterString.append(CameraParameters::FLASH_MODE_TORCH);
247 p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
248 parameterString.string());
249 p.set(CameraParameters::KEY_FLASH_MODE,
250 CameraParameters::FLASH_MODE_OFF);
251
252 parameterString = CameraParameters::SCENE_MODE_AUTO;
253 parameterString.append(",");
254 parameterString.append(CameraParameters::SCENE_MODE_PORTRAIT);
255 parameterString.append(",");
256 parameterString.append(CameraParameters::SCENE_MODE_LANDSCAPE);
257 parameterString.append(",");
258 parameterString.append(CameraParameters::SCENE_MODE_NIGHT);
259 parameterString.append(",");
260 parameterString.append(CameraParameters::SCENE_MODE_BEACH);
261 parameterString.append(",");
262 parameterString.append(CameraParameters::SCENE_MODE_SNOW);
263 parameterString.append(",");
264 parameterString.append(CameraParameters::SCENE_MODE_SUNSET);
265 parameterString.append(",");
266 parameterString.append(CameraParameters::SCENE_MODE_FIREWORKS);
267 parameterString.append(",");
268 parameterString.append(CameraParameters::SCENE_MODE_SPORTS);
269 parameterString.append(",");
270 parameterString.append(CameraParameters::SCENE_MODE_PARTY);
271 parameterString.append(",");
272 parameterString.append(CameraParameters::SCENE_MODE_CANDLELIGHT);
273 p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
274 parameterString.string());
275 p.set(CameraParameters::KEY_SCENE_MODE,
276 CameraParameters::SCENE_MODE_AUTO);
277
278 /* we have two ranges, 4-30fps for night mode and
279 * 15-30fps for all others
280 */
281 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
282 p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000");
283
284 p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.43");
285 } else {
286 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(7500,30000)");
287 p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "7500,30000");
288
289 p.set(CameraParameters::KEY_FOCAL_LENGTH, "0.9");
290 }
291
292 parameterString = CameraParameters::WHITE_BALANCE_AUTO;
293 parameterString.append(",");
294 parameterString.append(CameraParameters::WHITE_BALANCE_INCANDESCENT);
295 parameterString.append(",");
296 parameterString.append(CameraParameters::WHITE_BALANCE_FLUORESCENT);
297 parameterString.append(",");
298 parameterString.append(CameraParameters::WHITE_BALANCE_DAYLIGHT);
299 parameterString.append(",");
300 parameterString.append(CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT);
301 p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
302 parameterString.string());
303
304 ip.set("sharpness-min", 0);
305 ip.set("sharpness-max", 4);
306 ip.set("saturation-min", 0);
307 ip.set("saturation-max", 4);
308 ip.set("contrast-min", 0);
309 ip.set("contrast-max", 4);
310
311 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100");
312
313 p.set(CameraParameters::KEY_ROTATION, 0);
314 p.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO);
315
316 p.set(CameraParameters::KEY_EFFECT, CameraParameters::EFFECT_NONE);
317
318 ip.set("sharpness", SHARPNESS_DEFAULT);
319 ip.set("contrast", CONTRAST_DEFAULT);
320 ip.set("saturation", SATURATION_DEFAULT);
321 ip.set("iso", "auto");
322 ip.set("metering", "center");
323
324 ip.set("wdr", 0);
325 ip.set("chk_dataline", 0);
326 if (cameraId == SecCamera::CAMERA_ID_FRONT) {
327 ip.set("vtmode", 0);
328 ip.set("blur", 0);
329 }
330
331 p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "51.2");
332 p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "39.4");
333
334 p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0");
335 p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "4");
336 p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-4");
337 p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5");
338
339 mParameters = p;
340 mInternalParameters = ip;
341
342 /* make sure mSecCamera has all the settings we do. applications
343 * aren't required to call setParameters themselves (only if they
344 * want to change something.
345 */
346 setParameters(p);
347 mSecCamera->setISO(ISO_AUTO);
348 mSecCamera->setMetering(METERING_CENTER);
349 mSecCamera->setContrast(CONTRAST_DEFAULT);
350 mSecCamera->setSharpness(SHARPNESS_DEFAULT);
351 mSecCamera->setSaturation(SATURATION_DEFAULT);
352 if (cameraId == SecCamera::CAMERA_ID_BACK)
353 mSecCamera->setFrameRate(30);
354 else
355 mSecCamera->setFrameRate(15);
356 }
357
~CameraHardwareSec()358 CameraHardwareSec::~CameraHardwareSec()
359 {
360 ALOGV("%s", __func__);
361 mSecCamera->DeinitCamera();
362 }
363
setPreviewWindow(preview_stream_ops * w)364 status_t CameraHardwareSec::setPreviewWindow(preview_stream_ops *w)
365 {
366 int min_bufs;
367
368 mPreviewWindow = w;
369 ALOGV("%s: mPreviewWindow %p", __func__, mPreviewWindow);
370
371 if (!w) {
372 ALOGE("preview window is NULL!");
373 return OK;
374 }
375
376 mPreviewLock.lock();
377
378 if (mPreviewRunning && !mPreviewStartDeferred) {
379 ALOGI("stop preview (window change)");
380 stopPreviewInternal();
381 }
382
383 if (w->get_min_undequeued_buffer_count(w, &min_bufs)) {
384 ALOGE("%s: could not retrieve min undequeued buffer count", __func__);
385 return INVALID_OPERATION;
386 }
387
388 if (min_bufs >= kBufferCount) {
389 ALOGE("%s: min undequeued buffer count %d is too high (expecting at most %d)", __func__,
390 min_bufs, kBufferCount - 1);
391 }
392
393 ALOGV("%s: setting buffer count to %d", __func__, kBufferCount);
394 if (w->set_buffer_count(w, kBufferCount)) {
395 ALOGE("%s: could not set buffer count", __func__);
396 return INVALID_OPERATION;
397 }
398
399 int preview_width;
400 int preview_height;
401 mParameters.getPreviewSize(&preview_width, &preview_height);
402 int hal_pixel_format = HAL_PIXEL_FORMAT_YV12;
403
404 const char *str_preview_format = mParameters.getPreviewFormat();
405 ALOGV("%s: preview format %s", __func__, str_preview_format);
406
407 if (w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN)) {
408 ALOGE("%s: could not set usage on gralloc buffer", __func__);
409 return INVALID_OPERATION;
410 }
411
412 if (w->set_buffers_geometry(w,
413 preview_width, preview_height,
414 hal_pixel_format)) {
415 ALOGE("%s: could not set buffers geometry to %s",
416 __func__, str_preview_format);
417 return INVALID_OPERATION;
418 }
419
420 if (mPreviewRunning && mPreviewStartDeferred) {
421 ALOGV("start/resume preview");
422 status_t ret = startPreviewInternal();
423 if (ret == OK) {
424 mPreviewStartDeferred = false;
425 mPreviewCondition.signal();
426 }
427 }
428 mPreviewLock.unlock();
429
430 return OK;
431 }
432
setCallbacks(camera_notify_callback notify_cb,camera_data_callback data_cb,camera_data_timestamp_callback data_cb_timestamp,camera_request_memory get_memory,void * user)433 void CameraHardwareSec::setCallbacks(camera_notify_callback notify_cb,
434 camera_data_callback data_cb,
435 camera_data_timestamp_callback data_cb_timestamp,
436 camera_request_memory get_memory,
437 void *user)
438 {
439 mNotifyCb = notify_cb;
440 mDataCb = data_cb;
441 mDataCbTimestamp = data_cb_timestamp;
442 mGetMemoryCb = get_memory;
443 mCallbackCookie = user;
444 }
445
enableMsgType(int32_t msgType)446 void CameraHardwareSec::enableMsgType(int32_t msgType)
447 {
448 ALOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
449 __func__, msgType, mMsgEnabled);
450 mMsgEnabled |= msgType;
451
452 ALOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
453 }
454
disableMsgType(int32_t msgType)455 void CameraHardwareSec::disableMsgType(int32_t msgType)
456 {
457 ALOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
458 __func__, msgType, mMsgEnabled);
459 mMsgEnabled &= ~msgType;
460 ALOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
461 }
462
msgTypeEnabled(int32_t msgType)463 bool CameraHardwareSec::msgTypeEnabled(int32_t msgType)
464 {
465 return (mMsgEnabled & msgType);
466 }
467
468 // ---------------------------------------------------------------------------
setSkipFrame(int frame)469 void CameraHardwareSec::setSkipFrame(int frame)
470 {
471 Mutex::Autolock lock(mSkipFrameLock);
472 if (frame < mSkipFrame)
473 return;
474
475 mSkipFrame = frame;
476 }
477
previewThreadWrapper()478 int CameraHardwareSec::previewThreadWrapper()
479 {
480 ALOGI("%s: starting", __func__);
481 while (1) {
482 mPreviewLock.lock();
483 while (!mPreviewRunning) {
484 ALOGI("%s: calling mSecCamera->stopPreview() and waiting", __func__);
485 mSecCamera->stopPreview();
486 /* signal that we're stopping */
487 mPreviewStoppedCondition.signal();
488 mPreviewCondition.wait(mPreviewLock);
489 ALOGI("%s: return from wait", __func__);
490 }
491 mPreviewLock.unlock();
492
493 if (mExitPreviewThread) {
494 ALOGI("%s: exiting", __func__);
495 mSecCamera->stopPreview();
496 return 0;
497 }
498 previewThread();
499 }
500 }
501
previewThread()502 int CameraHardwareSec::previewThread()
503 {
504 int index;
505 nsecs_t timestamp;
506 unsigned int phyYAddr;
507 unsigned int phyCAddr;
508 struct addrs *addrs;
509
510 index = mSecCamera->getPreview();
511 if (index < 0) {
512 ALOGE("ERR(%s):Fail on SecCamera->getPreview()", __func__);
513 return UNKNOWN_ERROR;
514 }
515
516 // ALOGV("%s: index %d", __func__, index);
517
518 mSkipFrameLock.lock();
519 if (mSkipFrame > 0) {
520 mSkipFrame--;
521 mSkipFrameLock.unlock();
522 ALOGV("%s: index %d skipping frame", __func__, index);
523 return NO_ERROR;
524 }
525 mSkipFrameLock.unlock();
526
527 timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
528
529 phyYAddr = mSecCamera->getPhyAddrY(index);
530 phyCAddr = mSecCamera->getPhyAddrC(index);
531
532 if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) {
533 ALOGE("ERR(%s):Fail on SecCamera getPhyAddr Y addr = %0x C addr = %0x",
534 __func__, phyYAddr, phyCAddr);
535 return UNKNOWN_ERROR;
536 }
537
538 int width, height, frame_size, offset;
539
540 mSecCamera->getPreviewSize(&width, &height, &frame_size);
541
542 offset = frame_size * index;
543
544 if (mPreviewWindow && mGrallocHal) {
545 buffer_handle_t *buf_handle;
546 int stride;
547 if (0 != mPreviewWindow->dequeue_buffer(mPreviewWindow, &buf_handle, &stride)) {
548 ALOGE("Could not dequeue gralloc buffer!\n");
549 goto callbacks;
550 }
551
552 void *vaddr;
553 if (!mGrallocHal->lock(mGrallocHal,
554 *buf_handle,
555 GRALLOC_USAGE_SW_WRITE_OFTEN,
556 0, 0, width, height, &vaddr)) {
557 char *frame = ((char *)mPreviewHeap->data) + offset;
558
559 // the code below assumes YUV, not RGB
560 {
561 int h;
562 char *src = frame;
563 char *ptr = (char *)vaddr;
564
565 // Copy the Y plane, while observing the stride
566 for (h = 0; h < height; h++) {
567 memcpy(ptr, src, width);
568 ptr += stride;
569 src += width;
570 }
571
572 {
573 // U
574 char *v = ptr;
575 ptr += stride * height / 4;
576 for (h = 0; h < height / 2; h++) {
577 memcpy(ptr, src, width / 2);
578 ptr += stride / 2;
579 src += width / 2;
580 }
581 // V
582 ptr = v;
583 for (h = 0; h < height / 2; h++) {
584 memcpy(ptr, src, width / 2);
585 ptr += stride / 2;
586 src += width / 2;
587 }
588 }
589 }
590
591 mGrallocHal->unlock(mGrallocHal, *buf_handle);
592 }
593 else
594 ALOGE("%s: could not obtain gralloc buffer", __func__);
595
596 if (0 != mPreviewWindow->enqueue_buffer(mPreviewWindow, buf_handle)) {
597 ALOGE("Could not enqueue gralloc buffer!\n");
598 goto callbacks;
599 }
600 }
601
602 callbacks:
603 // Notify the client of a new frame.
604 if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
605 const char * preview_format = mParameters.getPreviewFormat();
606 if (!strcmp(preview_format, CameraParameters::PIXEL_FORMAT_YUV420SP)) {
607 // Color conversion from YUV420 to NV21
608 char *vu = ((char *)mPreviewHeap->data) + offset + width * height;
609 const int uv_size = (width * height) >> 1;
610 char saved_uv[uv_size];
611 memcpy(saved_uv, vu, uv_size);
612 char *u = saved_uv;
613 char *v = u + (uv_size >> 1);
614
615 int h = 0;
616 while (h < width * height / 4) {
617 *vu++ = *v++;
618 *vu++ = *u++;
619 ++h;
620 }
621 }
622 mDataCb(CAMERA_MSG_PREVIEW_FRAME, mPreviewHeap, index, NULL, mCallbackCookie);
623 }
624
625 Mutex::Autolock lock(mRecordLock);
626 if (mRecordRunning == true) {
627 index = mSecCamera->getRecordFrame();
628 if (index < 0) {
629 ALOGE("ERR(%s):Fail on SecCamera->getRecord()", __func__);
630 return UNKNOWN_ERROR;
631 }
632
633 phyYAddr = mSecCamera->getRecPhyAddrY(index);
634 phyCAddr = mSecCamera->getRecPhyAddrC(index);
635
636 if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) {
637 ALOGE("ERR(%s):Fail on SecCamera getRectPhyAddr Y addr = %0x C addr = %0x", __func__,
638 phyYAddr, phyCAddr);
639 return UNKNOWN_ERROR;
640 }
641
642 addrs = (struct addrs *)mRecordHeap->data;
643
644 addrs[index].type = kMetadataBufferTypeCameraSource;
645 addrs[index].addr_y = phyYAddr;
646 addrs[index].addr_cbcr = phyCAddr;
647 addrs[index].buf_index = index;
648
649 // Notify the client of a new frame.
650 if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) {
651 mDataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME,
652 mRecordHeap, index, mCallbackCookie);
653 } else {
654 mSecCamera->releaseRecordFrame(index);
655 }
656 }
657
658 return NO_ERROR;
659 }
660
startPreview()661 status_t CameraHardwareSec::startPreview()
662 {
663 int ret = 0; //s1 [Apply factory standard]
664
665 ALOGV("%s :", __func__);
666
667 if (waitCaptureCompletion() != NO_ERROR) {
668 return TIMED_OUT;
669 }
670
671 mPreviewLock.lock();
672 if (mPreviewRunning) {
673 // already running
674 ALOGE("%s : preview thread already running", __func__);
675 mPreviewLock.unlock();
676 return INVALID_OPERATION;
677 }
678
679 mPreviewRunning = true;
680 mPreviewStartDeferred = false;
681
682 if (!mPreviewWindow) {
683 ALOGI("%s : deferring", __func__);
684 mPreviewStartDeferred = true;
685 mPreviewLock.unlock();
686 return NO_ERROR;
687 }
688
689 ret = startPreviewInternal();
690 if (ret == OK)
691 mPreviewCondition.signal();
692
693 mPreviewLock.unlock();
694 return ret;
695 }
696
startPreviewInternal()697 status_t CameraHardwareSec::startPreviewInternal()
698 {
699 ALOGV("%s", __func__);
700
701 int ret = mSecCamera->startPreview();
702 ALOGV("%s : mSecCamera->startPreview() returned %d", __func__, ret);
703
704 if (ret < 0) {
705 ALOGE("ERR(%s):Fail on mSecCamera->startPreview()", __func__);
706 return UNKNOWN_ERROR;
707 }
708
709 setSkipFrame(INITIAL_SKIP_FRAME);
710
711 int width, height, frame_size;
712
713 mSecCamera->getPreviewSize(&width, &height, &frame_size);
714
715 ALOGD("mPreviewHeap(fd(%d), size(%d), width(%d), height(%d))",
716 mSecCamera->getCameraFd(), frame_size, width, height);
717 if (mPreviewHeap) {
718 mPreviewHeap->release(mPreviewHeap);
719 mPreviewHeap = 0;
720 }
721
722 mPreviewHeap = mGetMemoryCb((int)mSecCamera->getCameraFd(),
723 frame_size,
724 kBufferCount,
725 0); // no cookie
726
727 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
728 ALOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
729 mPostViewWidth,mPostViewHeight,mPostViewSize);
730
731 return NO_ERROR;
732 }
733
stopPreviewInternal()734 void CameraHardwareSec::stopPreviewInternal()
735 {
736 ALOGV("%s :", __func__);
737
738 /* request that the preview thread stop. */
739 if (mPreviewRunning) {
740 mPreviewRunning = false;
741 if (!mPreviewStartDeferred) {
742 mPreviewCondition.signal();
743 /* wait until preview thread is stopped */
744 mPreviewStoppedCondition.wait(mPreviewLock);
745 }
746 else
747 ALOGV("%s : preview running but deferred, doing nothing", __func__);
748 } else
749 ALOGI("%s : preview not running, doing nothing", __func__);
750 }
751
stopPreview()752 void CameraHardwareSec::stopPreview()
753 {
754 ALOGV("%s :", __func__);
755
756 /* request that the preview thread stop. */
757 mPreviewLock.lock();
758 stopPreviewInternal();
759 mPreviewLock.unlock();
760 }
761
previewEnabled()762 bool CameraHardwareSec::previewEnabled()
763 {
764 Mutex::Autolock lock(mPreviewLock);
765 ALOGV("%s : %d", __func__, mPreviewRunning);
766 return mPreviewRunning;
767 }
768
769 // ---------------------------------------------------------------------------
770
startRecording()771 status_t CameraHardwareSec::startRecording()
772 {
773 ALOGV("%s :", __func__);
774
775 Mutex::Autolock lock(mRecordLock);
776
777 if (mRecordHeap) {
778 mRecordHeap->release(mRecordHeap);
779 mRecordHeap = 0;
780 }
781 mRecordHeap = mGetMemoryCb(-1, sizeof(struct addrs), kBufferCount, NULL);
782 if (!mRecordHeap) {
783 ALOGE("ERR(%s): Record heap creation fail", __func__);
784 return UNKNOWN_ERROR;
785 }
786
787 if (mRecordRunning == false) {
788 if (mSecCamera->startRecord() < 0) {
789 ALOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__);
790 return UNKNOWN_ERROR;
791 }
792 mRecordRunning = true;
793 }
794 return NO_ERROR;
795 }
796
stopRecording()797 void CameraHardwareSec::stopRecording()
798 {
799 ALOGV("%s :", __func__);
800
801 Mutex::Autolock lock(mRecordLock);
802
803 if (mRecordRunning == true) {
804 if (mSecCamera->stopRecord() < 0) {
805 ALOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__);
806 return;
807 }
808 mRecordRunning = false;
809 }
810 }
811
recordingEnabled()812 bool CameraHardwareSec::recordingEnabled()
813 {
814 ALOGV("%s :", __func__);
815
816 return mRecordRunning;
817 }
818
releaseRecordingFrame(const void * opaque)819 void CameraHardwareSec::releaseRecordingFrame(const void *opaque)
820 {
821 struct addrs *addrs = (struct addrs *)opaque;
822 mSecCamera->releaseRecordFrame(addrs->buf_index);
823 }
824
825 // ---------------------------------------------------------------------------
826
autoFocusThread()827 int CameraHardwareSec::autoFocusThread()
828 {
829 int count =0;
830 int af_status =0 ;
831
832 ALOGV("%s : starting", __func__);
833
834 /* block until we're told to start. we don't want to use
835 * a restartable thread and requestExitAndWait() in cancelAutoFocus()
836 * because it would cause deadlock between our callbacks and the
837 * caller of cancelAutoFocus() which both want to grab the same lock
838 * in CameraServices layer.
839 */
840 mFocusLock.lock();
841 /* check early exit request */
842 if (mExitAutoFocusThread) {
843 mFocusLock.unlock();
844 ALOGV("%s : exiting on request0", __func__);
845 return NO_ERROR;
846 }
847 mFocusCondition.wait(mFocusLock);
848 /* check early exit request */
849 if (mExitAutoFocusThread) {
850 mFocusLock.unlock();
851 ALOGV("%s : exiting on request1", __func__);
852 return NO_ERROR;
853 }
854 mFocusLock.unlock();
855
856 ALOGV("%s : calling setAutoFocus", __func__);
857 if (mSecCamera->setAutofocus() < 0) {
858 ALOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__);
859 return UNKNOWN_ERROR;
860 }
861
862 af_status = mSecCamera->getAutoFocusResult();
863
864 if (af_status == 0x01) {
865 ALOGV("%s : AF Success!!", __func__);
866 if (mMsgEnabled & CAMERA_MSG_FOCUS)
867 mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
868 } else if (af_status == 0x02) {
869 ALOGV("%s : AF Cancelled !!", __func__);
870 if (mMsgEnabled & CAMERA_MSG_FOCUS) {
871 /* CAMERA_MSG_FOCUS only takes a bool. true for
872 * finished and false for failure. cancel is still
873 * considered a true result.
874 */
875 mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
876 }
877 } else {
878 ALOGV("%s : AF Fail !!", __func__);
879 ALOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
880 if (mMsgEnabled & CAMERA_MSG_FOCUS)
881 mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
882 }
883
884 ALOGV("%s : exiting with no error", __func__);
885 return NO_ERROR;
886 }
887
autoFocus()888 status_t CameraHardwareSec::autoFocus()
889 {
890 ALOGV("%s :", __func__);
891 /* signal autoFocusThread to run once */
892 mFocusCondition.signal();
893 return NO_ERROR;
894 }
895
896 /* 2009.10.14 by icarus for added interface */
cancelAutoFocus()897 status_t CameraHardwareSec::cancelAutoFocus()
898 {
899 ALOGV("%s :", __func__);
900
901 // If preview is not running, cancel autofocus can still be called.
902 // Since the camera subsystem is completely reset on preview start,
903 // cancel AF is a no-op.
904 if (!mPreviewRunning) return NO_ERROR;
905
906 // cancelAutoFocus should be allowed after preview is started. But if
907 // the preview is deferred, cancelAutoFocus will fail. Ignore it if that is
908 // the case.
909 if (mPreviewRunning && mPreviewStartDeferred) return NO_ERROR;
910
911 if (mSecCamera->cancelAutofocus() < 0) {
912 ALOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__);
913 return UNKNOWN_ERROR;
914 }
915
916 return NO_ERROR;
917 }
918
save_jpeg(unsigned char * real_jpeg,int jpeg_size)919 int CameraHardwareSec::save_jpeg( unsigned char *real_jpeg, int jpeg_size)
920 {
921 FILE *yuv_fp = NULL;
922 char filename[100], *buffer = NULL;
923
924 /* file create/open, note to "wb" */
925 yuv_fp = fopen("/data/camera_dump.jpeg", "wb");
926 if (yuv_fp == NULL) {
927 ALOGE("Save jpeg file open error");
928 return -1;
929 }
930
931 ALOGV("[BestIQ] real_jpeg size ========> %d\n", jpeg_size);
932 buffer = (char *) malloc(jpeg_size);
933 if (buffer == NULL) {
934 ALOGE("Save YUV] buffer alloc failed");
935 if (yuv_fp)
936 fclose(yuv_fp);
937
938 return -1;
939 }
940
941 memcpy(buffer, real_jpeg, jpeg_size);
942
943 fflush(stdout);
944
945 fwrite(buffer, 1, jpeg_size, yuv_fp);
946
947 fflush(yuv_fp);
948
949 if (yuv_fp)
950 fclose(yuv_fp);
951 if (buffer)
952 free(buffer);
953
954 return 0;
955 }
956
save_postview(const char * fname,uint8_t * buf,uint32_t size)957 void CameraHardwareSec::save_postview(const char *fname, uint8_t *buf, uint32_t size)
958 {
959 int nw;
960 int cnt = 0;
961 uint32_t written = 0;
962
963 ALOGD("opening file [%s]\n", fname);
964 int fd = open(fname, O_RDWR | O_CREAT);
965 if (fd < 0) {
966 ALOGE("failed to create file [%s]: %s", fname, strerror(errno));
967 return;
968 }
969
970 ALOGD("writing %d bytes to file [%s]\n", size, fname);
971 while (written < size) {
972 nw = ::write(fd, buf + written, size - written);
973 if (nw < 0) {
974 ALOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno));
975 break;
976 }
977 written += nw;
978 cnt++;
979 }
980 ALOGD("done writing %d bytes to file [%s] in %d passes\n",size, fname, cnt);
981 ::close(fd);
982 }
983
scaleDownYuv422(char * srcBuf,uint32_t srcWidth,uint32_t srcHeight,char * dstBuf,uint32_t dstWidth,uint32_t dstHeight)984 bool CameraHardwareSec::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHeight,
985 char *dstBuf, uint32_t dstWidth, uint32_t dstHeight)
986 {
987 int32_t step_x, step_y;
988 int32_t iXsrc, iXdst;
989 int32_t x, y, src_y_start_pos, dst_pos, src_pos;
990
991 if (dstWidth % 2 != 0 || dstHeight % 2 != 0){
992 ALOGE("scale_down_yuv422: invalid width, height for scaling");
993 return false;
994 }
995
996 step_x = srcWidth / dstWidth;
997 step_y = srcHeight / dstHeight;
998
999 dst_pos = 0;
1000 for (uint32_t y = 0; y < dstHeight; y++) {
1001 src_y_start_pos = (y * step_y * (srcWidth * 2));
1002
1003 for (uint32_t x = 0; x < dstWidth; x += 2) {
1004 src_pos = src_y_start_pos + (x * (step_x * 2));
1005
1006 dstBuf[dst_pos++] = srcBuf[src_pos ];
1007 dstBuf[dst_pos++] = srcBuf[src_pos + 1];
1008 dstBuf[dst_pos++] = srcBuf[src_pos + 2];
1009 dstBuf[dst_pos++] = srcBuf[src_pos + 3];
1010 }
1011 }
1012
1013 return true;
1014 }
1015
YUY2toNV21(void * srcBuf,void * dstBuf,uint32_t srcWidth,uint32_t srcHeight)1016 bool CameraHardwareSec::YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight)
1017 {
1018 int32_t x, y, src_y_start_pos, dst_cbcr_pos, dst_pos, src_pos;
1019 unsigned char *srcBufPointer = (unsigned char *)srcBuf;
1020 unsigned char *dstBufPointer = (unsigned char *)dstBuf;
1021
1022 dst_pos = 0;
1023 dst_cbcr_pos = srcWidth*srcHeight;
1024 for (uint32_t y = 0; y < srcHeight; y++) {
1025 src_y_start_pos = (y * (srcWidth * 2));
1026
1027 for (uint32_t x = 0; x < (srcWidth * 2); x += 2) {
1028 src_pos = src_y_start_pos + x;
1029
1030 dstBufPointer[dst_pos++] = srcBufPointer[src_pos];
1031 }
1032 }
1033 for (uint32_t y = 0; y < srcHeight; y += 2) {
1034 src_y_start_pos = (y * (srcWidth * 2));
1035
1036 for (uint32_t x = 0; x < (srcWidth * 2); x += 4) {
1037 src_pos = src_y_start_pos + x;
1038
1039 dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 3];
1040 dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 1];
1041 }
1042 }
1043
1044 return true;
1045 }
1046
pictureThread()1047 int CameraHardwareSec::pictureThread()
1048 {
1049 ALOGV("%s :", __func__);
1050
1051 int jpeg_size = 0;
1052 int ret = NO_ERROR;
1053 unsigned char *jpeg_data = NULL;
1054 int postview_offset = 0;
1055 unsigned char *postview_data = NULL;
1056
1057 unsigned char *addr = NULL;
1058 int mPostViewWidth, mPostViewHeight, mPostViewSize;
1059 int mThumbWidth, mThumbHeight, mThumbSize;
1060 int cap_width, cap_height, cap_frame_size;
1061 int JpegImageSize, JpegExifSize;
1062 bool isLSISensor = false;
1063
1064 unsigned int output_size = 0;
1065
1066 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
1067 mSecCamera->getThumbnailConfig(&mThumbWidth, &mThumbHeight, &mThumbSize);
1068 int postviewHeapSize = mPostViewSize;
1069 mSecCamera->getSnapshotSize(&cap_width, &cap_height, &cap_frame_size);
1070 int mJpegHeapSize;
1071 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK)
1072 mJpegHeapSize = cap_frame_size * SecCamera::getJpegRatio();
1073 else
1074 mJpegHeapSize = cap_frame_size;
1075
1076 LOG_TIME_DEFINE(0)
1077 LOG_TIME_START(0)
1078 // sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, mPostViewSize + 8);
1079
1080 struct addrs_cap *addrs = (struct addrs_cap *)mRawHeap->data;
1081
1082 addrs[0].width = mPostViewWidth;
1083 addrs[0].height = mPostViewHeight;
1084 ALOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight);
1085
1086 camera_memory_t *JpegHeap = mGetMemoryCb(-1, mJpegHeapSize, 1, 0);
1087 sp<MemoryHeapBase> PostviewHeap = new MemoryHeapBase(mPostViewSize);
1088 sp<MemoryHeapBase> ThumbnailHeap = new MemoryHeapBase(mThumbSize);
1089
1090 LOG_TIME_DEFINE(1)
1091 LOG_TIME_START(1)
1092
1093 int picture_size, picture_width, picture_height;
1094 mSecCamera->getSnapshotSize(&picture_width, &picture_height, &picture_size);
1095 int picture_format = mSecCamera->getSnapshotPixelFormat();
1096
1097 unsigned int phyAddr;
1098
1099 // Modified the shutter sound timing for Jpeg capture
1100 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK)
1101 mSecCamera->setSnapshotCmd();
1102 if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
1103 mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
1104 }
1105
1106 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){
1107 jpeg_data = mSecCamera->getJpeg(&jpeg_size, &phyAddr);
1108 if (jpeg_data == NULL) {
1109 ALOGE("ERR(%s):Fail on SecCamera->getSnapshot()", __func__);
1110 ret = UNKNOWN_ERROR;
1111 goto out;
1112 }
1113 } else {
1114 if (mSecCamera->getSnapshotAndJpeg((unsigned char*)PostviewHeap->base(),
1115 (unsigned char*)JpegHeap->data, &output_size) < 0) {
1116 ret = UNKNOWN_ERROR;
1117 goto out;
1118 }
1119 ALOGI("snapshotandjpeg done\n");
1120 }
1121
1122 LOG_TIME_END(1)
1123 LOG_CAMERA("getSnapshotAndJpeg interval: %lu us", LOG_TIME(1));
1124
1125 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) {
1126 isLSISensor = !strncmp((const char*)mCameraSensorName, "S5K4ECGX", 8);
1127 if(isLSISensor) {
1128 ALOGI("== Camera Sensor Detect %s - Samsung LSI SOC 5M ==\n", mCameraSensorName);
1129 // LSI 5M SOC
1130 if (!SplitFrame(jpeg_data, SecCamera::getInterleaveDataSize(),
1131 SecCamera::getJpegLineLength(),
1132 mPostViewWidth * 2, mPostViewWidth,
1133 JpegHeap->data, &JpegImageSize,
1134 PostviewHeap->base(), &mPostViewSize)) {
1135 ret = UNKNOWN_ERROR;
1136 goto out;
1137 }
1138 } else {
1139 ALOGI("== Camera Sensor Detect %s Sony SOC 5M ==\n", mCameraSensorName);
1140 decodeInterleaveData(jpeg_data,
1141 SecCamera::getInterleaveDataSize(),
1142 mPostViewWidth, mPostViewHeight,
1143 &JpegImageSize, JpegHeap->data, PostviewHeap->base());
1144 }
1145 } else {
1146 JpegImageSize = static_cast<int>(output_size);
1147 }
1148 scaleDownYuv422((char *)PostviewHeap->base(), mPostViewWidth, mPostViewHeight,
1149 (char *)ThumbnailHeap->base(), mThumbWidth, mThumbHeight);
1150
1151 memcpy(mRawHeap->data, PostviewHeap->base(), postviewHeapSize);
1152
1153 if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
1154 mDataCb(CAMERA_MSG_RAW_IMAGE, mRawHeap, 0, NULL, mCallbackCookie);
1155 } else if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY) {
1156 mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
1157 }
1158
1159 if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
1160 camera_memory_t *ExifHeap =
1161 mGetMemoryCb(-1, EXIF_FILE_SIZE + JPG_STREAM_BUF_SIZE, 1, 0);
1162 JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->data,
1163 (unsigned char *)ThumbnailHeap->base());
1164
1165 ALOGV("JpegExifSize=%d", JpegExifSize);
1166
1167 if (JpegExifSize < 0) {
1168 ret = UNKNOWN_ERROR;
1169 ExifHeap->release(ExifHeap);
1170 goto out;
1171 }
1172
1173 camera_memory_t *mem = mGetMemoryCb(-1, JpegImageSize + JpegExifSize, 1, 0);
1174 uint8_t *ptr = (uint8_t *) mem->data;
1175 memcpy(ptr, JpegHeap->data, 2); ptr += 2;
1176 memcpy(ptr, ExifHeap->data, JpegExifSize); ptr += JpegExifSize;
1177 memcpy(ptr, (uint8_t *) JpegHeap->data + 2, JpegImageSize - 2);
1178 mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, 0, NULL, mCallbackCookie);
1179 mem->release(mem);
1180 ExifHeap->release(ExifHeap);
1181 }
1182
1183 LOG_TIME_END(0)
1184 LOG_CAMERA("pictureThread interval: %lu us", LOG_TIME(0));
1185
1186 ALOGV("%s : pictureThread end", __func__);
1187
1188 out:
1189 JpegHeap->release(JpegHeap);
1190 mSecCamera->endSnapshot();
1191 mCaptureLock.lock();
1192 mCaptureInProgress = false;
1193 mCaptureCondition.broadcast();
1194 mCaptureLock.unlock();
1195
1196 return ret;
1197 }
1198
waitCaptureCompletion()1199 status_t CameraHardwareSec::waitCaptureCompletion() {
1200 // 5 seconds timeout
1201 nsecs_t endTime = 5000000000LL + systemTime(SYSTEM_TIME_MONOTONIC);
1202 Mutex::Autolock lock(mCaptureLock);
1203 while (mCaptureInProgress) {
1204 nsecs_t remainingTime = endTime - systemTime(SYSTEM_TIME_MONOTONIC);
1205 if (remainingTime <= 0) {
1206 ALOGE("Timed out waiting picture thread.");
1207 return TIMED_OUT;
1208 }
1209 ALOGD("Waiting for picture thread to complete.");
1210 mCaptureCondition.waitRelative(mCaptureLock, remainingTime);
1211 }
1212 return NO_ERROR;
1213 }
1214
takePicture()1215 status_t CameraHardwareSec::takePicture()
1216 {
1217 ALOGV("%s :", __func__);
1218
1219 stopPreview();
1220
1221 if (!mRawHeap) {
1222 int rawHeapSize = mPostViewSize;
1223 ALOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize);
1224 mRawHeap = mGetMemoryCb(-1, rawHeapSize, 1, 0);
1225 if (!mRawHeap) {
1226 ALOGE("ERR(%s): Raw heap creation fail", __func__);
1227 }
1228 }
1229
1230 if (waitCaptureCompletion() != NO_ERROR) {
1231 return TIMED_OUT;
1232 }
1233
1234 if (mPictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
1235 ALOGE("%s : couldn't run picture thread", __func__);
1236 return INVALID_OPERATION;
1237 }
1238 mCaptureLock.lock();
1239 mCaptureInProgress = true;
1240 mCaptureLock.unlock();
1241
1242 return NO_ERROR;
1243 }
1244
cancelPicture()1245 status_t CameraHardwareSec::cancelPicture()
1246 {
1247 ALOGV("%s", __func__);
1248
1249 if (mPictureThread.get()) {
1250 ALOGV("%s: waiting for picture thread to exit", __func__);
1251 mPictureThread->requestExitAndWait();
1252 ALOGV("%s: picture thread has exited", __func__);
1253 }
1254
1255 return NO_ERROR;
1256 }
1257
CheckVideoStartMarker(unsigned char * pBuf)1258 bool CameraHardwareSec::CheckVideoStartMarker(unsigned char *pBuf)
1259 {
1260 if (!pBuf) {
1261 ALOGE("CheckVideoStartMarker() => pBuf is NULL\n");
1262 return false;
1263 }
1264
1265 if (HIBYTE(VIDEO_COMMENT_MARKER_H) == * pBuf && LOBYTE(VIDEO_COMMENT_MARKER_H) == *(pBuf + 1) &&
1266 HIBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 2) && LOBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 3))
1267 return true;
1268
1269 return false;
1270 }
1271
CheckEOIMarker(unsigned char * pBuf)1272 bool CameraHardwareSec::CheckEOIMarker(unsigned char *pBuf)
1273 {
1274 if (!pBuf) {
1275 ALOGE("CheckEOIMarker() => pBuf is NULL\n");
1276 return false;
1277 }
1278
1279 // EOI marker [FF D9]
1280 if (HIBYTE(JPEG_EOI_MARKER) == *pBuf && LOBYTE(JPEG_EOI_MARKER) == *(pBuf + 1))
1281 return true;
1282
1283 return false;
1284 }
1285
FindEOIMarkerInJPEG(unsigned char * pBuf,int dwBufSize,int * pnJPEGsize)1286 bool CameraHardwareSec::FindEOIMarkerInJPEG(unsigned char *pBuf, int dwBufSize, int *pnJPEGsize)
1287 {
1288 if (NULL == pBuf || 0 >= dwBufSize) {
1289 ALOGE("FindEOIMarkerInJPEG() => There is no contents.");
1290 return false;
1291 }
1292
1293 unsigned char *pBufEnd = pBuf + dwBufSize;
1294
1295 while (pBuf < pBufEnd) {
1296 if (CheckEOIMarker(pBuf++))
1297 return true;
1298
1299 (*pnJPEGsize)++;
1300 }
1301
1302 return false;
1303 }
1304
SplitFrame(unsigned char * pFrame,int dwSize,int dwJPEGLineLength,int dwVideoLineLength,int dwVideoHeight,void * pJPEG,int * pdwJPEGSize,void * pVideo,int * pdwVideoSize)1305 bool CameraHardwareSec::SplitFrame(unsigned char *pFrame, int dwSize,
1306 int dwJPEGLineLength, int dwVideoLineLength, int dwVideoHeight,
1307 void *pJPEG, int *pdwJPEGSize,
1308 void *pVideo, int *pdwVideoSize)
1309 {
1310 ALOGV("===========SplitFrame Start==============");
1311
1312 if (NULL == pFrame || 0 >= dwSize) {
1313 ALOGE("There is no contents (pFrame=%p, dwSize=%d", pFrame, dwSize);
1314 return false;
1315 }
1316
1317 if (0 == dwJPEGLineLength || 0 == dwVideoLineLength) {
1318 ALOGE("There in no input information for decoding interleaved jpeg");
1319 return false;
1320 }
1321
1322 unsigned char *pSrc = pFrame;
1323 unsigned char *pSrcEnd = pFrame + dwSize;
1324
1325 unsigned char *pJ = (unsigned char *)pJPEG;
1326 int dwJSize = 0;
1327 unsigned char *pV = (unsigned char *)pVideo;
1328 int dwVSize = 0;
1329
1330 bool bRet = false;
1331 bool isFinishJpeg = false;
1332
1333 while (pSrc < pSrcEnd) {
1334 // Check video start marker
1335 if (CheckVideoStartMarker(pSrc)) {
1336 int copyLength;
1337
1338 if (pSrc + dwVideoLineLength <= pSrcEnd)
1339 copyLength = dwVideoLineLength;
1340 else
1341 copyLength = pSrcEnd - pSrc - VIDEO_COMMENT_MARKER_LENGTH;
1342
1343 // Copy video data
1344 if (pV) {
1345 memcpy(pV, pSrc + VIDEO_COMMENT_MARKER_LENGTH, copyLength);
1346 pV += copyLength;
1347 dwVSize += copyLength;
1348 }
1349
1350 pSrc += copyLength + VIDEO_COMMENT_MARKER_LENGTH;
1351 } else {
1352 // Copy pure JPEG data
1353 int size = 0;
1354 int dwCopyBufLen = dwJPEGLineLength <= pSrcEnd-pSrc ? dwJPEGLineLength : pSrcEnd - pSrc;
1355
1356 if (FindEOIMarkerInJPEG((unsigned char *)pSrc, dwCopyBufLen, &size)) {
1357 isFinishJpeg = true;
1358 size += 2; // to count EOF marker size
1359 } else {
1360 if ((dwCopyBufLen == 1) && (pJPEG < pJ)) {
1361 unsigned char checkBuf[2] = { *(pJ - 1), *pSrc };
1362
1363 if (CheckEOIMarker(checkBuf))
1364 isFinishJpeg = true;
1365 }
1366 size = dwCopyBufLen;
1367 }
1368
1369 memcpy(pJ, pSrc, size);
1370
1371 dwJSize += size;
1372
1373 pJ += dwCopyBufLen;
1374 pSrc += dwCopyBufLen;
1375 }
1376 if (isFinishJpeg)
1377 break;
1378 }
1379
1380 if (isFinishJpeg) {
1381 bRet = true;
1382 if(pdwJPEGSize)
1383 *pdwJPEGSize = dwJSize;
1384 if(pdwVideoSize)
1385 *pdwVideoSize = dwVSize;
1386 } else {
1387 ALOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI");
1388 bRet = false;
1389 if(pdwJPEGSize)
1390 *pdwJPEGSize = 0;
1391 if(pdwVideoSize)
1392 *pdwVideoSize = 0;
1393 }
1394 ALOGV("===========SplitFrame end==============");
1395
1396 return bRet;
1397 }
1398
decodeInterleaveData(unsigned char * pInterleaveData,int interleaveDataSize,int yuvWidth,int yuvHeight,int * pJpegSize,void * pJpegData,void * pYuvData)1399 int CameraHardwareSec::decodeInterleaveData(unsigned char *pInterleaveData,
1400 int interleaveDataSize,
1401 int yuvWidth,
1402 int yuvHeight,
1403 int *pJpegSize,
1404 void *pJpegData,
1405 void *pYuvData)
1406 {
1407 if (pInterleaveData == NULL)
1408 return false;
1409
1410 bool ret = true;
1411 unsigned int *interleave_ptr = (unsigned int *)pInterleaveData;
1412 unsigned char *jpeg_ptr = (unsigned char *)pJpegData;
1413 unsigned char *yuv_ptr = (unsigned char *)pYuvData;
1414 unsigned char *p;
1415 int jpeg_size = 0;
1416 int yuv_size = 0;
1417
1418 int i = 0;
1419
1420 ALOGV("decodeInterleaveData Start~~~");
1421 while (i < interleaveDataSize) {
1422 if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) ||
1423 (*interleave_ptr == 0xFF02FFFF)) {
1424 // Padding Data
1425 // ALOGE("%d(%x) padding data\n", i, *interleave_ptr);
1426 interleave_ptr++;
1427 i += 4;
1428 }
1429 else if ((*interleave_ptr & 0xFFFF) == 0x05FF) {
1430 // Start-code of YUV Data
1431 // ALOGE("%d(%x) yuv data\n", i, *interleave_ptr);
1432 p = (unsigned char *)interleave_ptr;
1433 p += 2;
1434 i += 2;
1435
1436 // Extract YUV Data
1437 if (pYuvData != NULL) {
1438 memcpy(yuv_ptr, p, yuvWidth * 2);
1439 yuv_ptr += yuvWidth * 2;
1440 yuv_size += yuvWidth * 2;
1441 }
1442 p += yuvWidth * 2;
1443 i += yuvWidth * 2;
1444
1445 // Check End-code of YUV Data
1446 if ((*p == 0xFF) && (*(p + 1) == 0x06)) {
1447 interleave_ptr = (unsigned int *)(p + 2);
1448 i += 2;
1449 } else {
1450 ret = false;
1451 break;
1452 }
1453 } else {
1454 // Extract JPEG Data
1455 // ALOGE("%d(%x) jpg data, jpeg_size = %d bytes\n", i, *interleave_ptr, jpeg_size);
1456 if (pJpegData != NULL) {
1457 memcpy(jpeg_ptr, interleave_ptr, 4);
1458 jpeg_ptr += 4;
1459 jpeg_size += 4;
1460 }
1461 interleave_ptr++;
1462 i += 4;
1463 }
1464 }
1465 if (ret) {
1466 if (pJpegData != NULL) {
1467 // Remove Padding after EOI
1468 for (i = 0; i < 3; i++) {
1469 if (*(--jpeg_ptr) != 0xFF) {
1470 break;
1471 }
1472 jpeg_size--;
1473 }
1474 *pJpegSize = jpeg_size;
1475
1476 }
1477 // Check YUV Data Size
1478 if (pYuvData != NULL) {
1479 if (yuv_size != (yuvWidth * yuvHeight * 2)) {
1480 ret = false;
1481 }
1482 }
1483 }
1484 ALOGV("decodeInterleaveData End~~~");
1485 return ret;
1486 }
1487
dump(int fd) const1488 status_t CameraHardwareSec::dump(int fd) const
1489 {
1490 const size_t SIZE = 256;
1491 char buffer[SIZE];
1492 String8 result;
1493 const Vector<String16> args;
1494
1495 if (mSecCamera != 0) {
1496 mSecCamera->dump(fd);
1497 mParameters.dump(fd, args);
1498 mInternalParameters.dump(fd, args);
1499 snprintf(buffer, 255, " preview running(%s)\n", mPreviewRunning?"true": "false");
1500 result.append(buffer);
1501 } else {
1502 result.append("No camera client yet.\n");
1503 }
1504 write(fd, result.string(), result.size());
1505 return NO_ERROR;
1506 }
1507
isSupportedPreviewSize(const int width,const int height) const1508 bool CameraHardwareSec::isSupportedPreviewSize(const int width,
1509 const int height) const
1510 {
1511 unsigned int i;
1512
1513 for (i = 0; i < mSupportedPreviewSizes.size(); i++) {
1514 if (mSupportedPreviewSizes[i].width == width &&
1515 mSupportedPreviewSizes[i].height == height)
1516 return true;
1517 }
1518
1519 return false;
1520 }
1521
isSupportedParameter(const char * const parm,const char * const supported_parm) const1522 bool CameraHardwareSec::isSupportedParameter(const char * const parm,
1523 const char * const supported_parm) const
1524 {
1525 const char *pStart;
1526 const char *pEnd;
1527
1528 if (!parm || !supported_parm)
1529 return false;
1530
1531 pStart = supported_parm;
1532
1533 while (true) {
1534 pEnd = strchr(pStart, ',');
1535 if (!pEnd) {
1536 if (!strcmp(parm, pStart))
1537 return true;
1538 else
1539 return false;
1540 }
1541 if (!strncmp(parm, pStart, pEnd - pStart)) {
1542 return true;
1543 }
1544 pStart = pEnd + 1;
1545 }
1546 /* NOTREACHED */
1547 }
1548
setParameters(const CameraParameters & params)1549 status_t CameraHardwareSec::setParameters(const CameraParameters& params)
1550 {
1551 ALOGV("%s :", __func__);
1552
1553 status_t ret = NO_ERROR;
1554
1555 /* if someone calls us while picture thread is running, it could screw
1556 * up the sensor quite a bit so return error.
1557 */
1558 if (waitCaptureCompletion() != NO_ERROR) {
1559 return TIMED_OUT;
1560 }
1561
1562 // preview size
1563 int new_preview_width = 0;
1564 int new_preview_height = 0;
1565 params.getPreviewSize(&new_preview_width, &new_preview_height);
1566 const char *new_str_preview_format = params.getPreviewFormat();
1567 ALOGV("%s : new_preview_width x new_preview_height = %dx%d, format = %s",
1568 __func__, new_preview_width, new_preview_height, new_str_preview_format);
1569
1570 if (strcmp(new_str_preview_format, CameraParameters::PIXEL_FORMAT_YUV420SP) &&
1571 strcmp(new_str_preview_format, CameraParameters::PIXEL_FORMAT_YUV420P)) {
1572 ALOGE("Unsupported preview color format: %s", new_str_preview_format);
1573 return BAD_VALUE;
1574 }
1575
1576 if (0 < new_preview_width && 0 < new_preview_height &&
1577 new_str_preview_format != NULL &&
1578 isSupportedPreviewSize(new_preview_width, new_preview_height)) {
1579 int new_preview_format = V4L2_PIX_FMT_YUV420;
1580
1581 int current_preview_width, current_preview_height, current_frame_size;
1582 mSecCamera->getPreviewSize(¤t_preview_width,
1583 ¤t_preview_height,
1584 ¤t_frame_size);
1585 int current_pixel_format = mSecCamera->getPreviewPixelFormat();
1586
1587 if (current_preview_width != new_preview_width ||
1588 current_preview_height != new_preview_height ||
1589 current_pixel_format != new_preview_format) {
1590 if (mSecCamera->setPreviewSize(new_preview_width, new_preview_height,
1591 new_preview_format) < 0) {
1592 ALOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))",
1593 __func__, new_preview_width, new_preview_height, new_preview_format);
1594 ret = UNKNOWN_ERROR;
1595 } else {
1596 if (mPreviewWindow) {
1597 if (mPreviewRunning && !mPreviewStartDeferred) {
1598 ALOGE("ERR(%s): preview is running, cannot change size and format!",
1599 __func__);
1600 ret = INVALID_OPERATION;
1601 }
1602
1603 ALOGV("%s: mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow);
1604 ALOGV("%s: mPreviewWindow->set_buffers_geometry (%p)", __func__,
1605 mPreviewWindow->set_buffers_geometry);
1606 mPreviewWindow->set_buffers_geometry(mPreviewWindow,
1607 new_preview_width, new_preview_height,
1608 new_preview_format);
1609 ALOGV("%s: DONE mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow);
1610 }
1611
1612 mParameters.setPreviewSize(new_preview_width, new_preview_height);
1613 mParameters.setPreviewFormat(new_str_preview_format);
1614 }
1615 }
1616 else ALOGV("%s: preview size and format has not changed", __func__);
1617 } else {
1618 ALOGE("%s: Invalid preview size(%dx%d)",
1619 __func__, new_preview_width, new_preview_height);
1620
1621 ret = INVALID_OPERATION;
1622 }
1623
1624 int new_picture_width = 0;
1625 int new_picture_height = 0;
1626
1627 params.getPictureSize(&new_picture_width, &new_picture_height);
1628 ALOGV("%s : new_picture_width x new_picture_height = %dx%d", __func__, new_picture_width, new_picture_height);
1629 if (0 < new_picture_width && 0 < new_picture_height) {
1630 ALOGV("%s: setSnapshotSize", __func__);
1631 if (mSecCamera->setSnapshotSize(new_picture_width, new_picture_height) < 0) {
1632 ALOGE("ERR(%s):Fail on mSecCamera->setSnapshotSize(width(%d), height(%d))",
1633 __func__, new_picture_width, new_picture_height);
1634 ret = UNKNOWN_ERROR;
1635 } else {
1636 mParameters.setPictureSize(new_picture_width, new_picture_height);
1637 }
1638 }
1639
1640 // picture format
1641 const char *new_str_picture_format = params.getPictureFormat();
1642 ALOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format);
1643 if (new_str_picture_format != NULL) {
1644 int new_picture_format = 0;
1645
1646 if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGB565))
1647 new_picture_format = V4L2_PIX_FMT_RGB565;
1648 else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGBA8888))
1649 new_picture_format = V4L2_PIX_FMT_RGB32;
1650 else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_YUV420SP))
1651 new_picture_format = V4L2_PIX_FMT_NV21;
1652 else if (!strcmp(new_str_picture_format, "yuv420sp_custom"))
1653 new_picture_format = V4L2_PIX_FMT_NV12T;
1654 else if (!strcmp(new_str_picture_format, "yuv420p"))
1655 new_picture_format = V4L2_PIX_FMT_YUV420;
1656 else if (!strcmp(new_str_picture_format, "yuv422i"))
1657 new_picture_format = V4L2_PIX_FMT_YUYV;
1658 else if (!strcmp(new_str_picture_format, "uyv422i_custom")) //Zero copy UYVY format
1659 new_picture_format = V4L2_PIX_FMT_UYVY;
1660 else if (!strcmp(new_str_picture_format, "uyv422i")) //Non-zero copy UYVY format
1661 new_picture_format = V4L2_PIX_FMT_UYVY;
1662 else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_JPEG))
1663 new_picture_format = V4L2_PIX_FMT_YUYV;
1664 else if (!strcmp(new_str_picture_format, "yuv422p"))
1665 new_picture_format = V4L2_PIX_FMT_YUV422P;
1666 else
1667 new_picture_format = V4L2_PIX_FMT_NV21; //for 3rd party
1668
1669 if (mSecCamera->setSnapshotPixelFormat(new_picture_format) < 0) {
1670 ALOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format);
1671 ret = UNKNOWN_ERROR;
1672 } else {
1673 mParameters.setPictureFormat(new_str_picture_format);
1674 }
1675 }
1676
1677 //JPEG image quality
1678 int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
1679 ALOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
1680 /* we ignore bad values */
1681 if (new_jpeg_quality >=1 && new_jpeg_quality <= 100) {
1682 if (mSecCamera->setJpegQuality(new_jpeg_quality) < 0) {
1683 ALOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality);
1684 ret = UNKNOWN_ERROR;
1685 } else {
1686 mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality);
1687 }
1688 }
1689
1690 // JPEG thumbnail size
1691 int new_jpeg_thumbnail_width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1692 int new_jpeg_thumbnail_height= params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1693 if (0 <= new_jpeg_thumbnail_width && 0 <= new_jpeg_thumbnail_height) {
1694 if (mSecCamera->setJpegThumbnailSize(new_jpeg_thumbnail_width, new_jpeg_thumbnail_height) < 0) {
1695 ALOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height);
1696 ret = UNKNOWN_ERROR;
1697 } else {
1698 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, new_jpeg_thumbnail_width);
1699 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, new_jpeg_thumbnail_height);
1700 }
1701 }
1702
1703 // frame rate
1704 int new_frame_rate = params.getPreviewFrameRate();
1705 /* ignore any fps request, we're determine fps automatically based
1706 * on scene mode. don't return an error because it causes CTS failure.
1707 */
1708 if (new_frame_rate != mParameters.getPreviewFrameRate()) {
1709 ALOGW("WARN(%s): request for preview frame %d not allowed, != %d\n",
1710 __func__, new_frame_rate, mParameters.getPreviewFrameRate());
1711 }
1712
1713 // rotation
1714 int new_rotation = params.getInt(CameraParameters::KEY_ROTATION);
1715 ALOGV("%s : new_rotation %d", __func__, new_rotation);
1716 if (0 <= new_rotation) {
1717 ALOGV("%s : set orientation:%d\n", __func__, new_rotation);
1718 if (mSecCamera->setExifOrientationInfo(new_rotation) < 0) {
1719 ALOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation);
1720 ret = UNKNOWN_ERROR;
1721 } else {
1722 mParameters.set(CameraParameters::KEY_ROTATION, new_rotation);
1723 }
1724 }
1725
1726 // brightness
1727 int new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1728 int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
1729 int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
1730 ALOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation);
1731 if ((min_exposure_compensation <= new_exposure_compensation) &&
1732 (max_exposure_compensation >= new_exposure_compensation)) {
1733 if (mSecCamera->setBrightness(new_exposure_compensation) < 0) {
1734 ALOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_exposure_compensation);
1735 ret = UNKNOWN_ERROR;
1736 } else {
1737 mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, new_exposure_compensation);
1738 }
1739 }
1740
1741 // whitebalance
1742 const char *new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE);
1743 ALOGV("%s : new_white_str %s", __func__, new_white_str);
1744 if (new_white_str != NULL) {
1745 int new_white = -1;
1746
1747 if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO))
1748 new_white = WHITE_BALANCE_AUTO;
1749 else if (!strcmp(new_white_str,
1750 CameraParameters::WHITE_BALANCE_DAYLIGHT))
1751 new_white = WHITE_BALANCE_SUNNY;
1752 else if (!strcmp(new_white_str,
1753 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT))
1754 new_white = WHITE_BALANCE_CLOUDY;
1755 else if (!strcmp(new_white_str,
1756 CameraParameters::WHITE_BALANCE_FLUORESCENT))
1757 new_white = WHITE_BALANCE_FLUORESCENT;
1758 else if (!strcmp(new_white_str,
1759 CameraParameters::WHITE_BALANCE_INCANDESCENT))
1760 new_white = WHITE_BALANCE_TUNGSTEN;
1761 else {
1762 ALOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent
1763 ret = UNKNOWN_ERROR;
1764 }
1765
1766 if (0 <= new_white) {
1767 if (mSecCamera->setWhiteBalance(new_white) < 0) {
1768 ALOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white);
1769 ret = UNKNOWN_ERROR;
1770 } else {
1771 mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str);
1772 }
1773 }
1774 }
1775
1776 // scene mode
1777 const char *new_scene_mode_str = params.get(CameraParameters::KEY_SCENE_MODE);
1778 const char *current_scene_mode_str = mParameters.get(CameraParameters::KEY_SCENE_MODE);
1779
1780 // fps range
1781 int new_min_fps = 0;
1782 int new_max_fps = 0;
1783 int current_min_fps, current_max_fps;
1784 params.getPreviewFpsRange(&new_min_fps, &new_max_fps);
1785 mParameters.getPreviewFpsRange(¤t_min_fps, ¤t_max_fps);
1786 /* our fps range is determined by the sensor, reject any request
1787 * that isn't exactly what we're already at.
1788 * but the check is performed when requesting only changing fps range
1789 */
1790 if (new_scene_mode_str && current_scene_mode_str) {
1791 if (!strcmp(new_scene_mode_str, current_scene_mode_str)) {
1792 if ((new_min_fps != current_min_fps) || (new_max_fps != current_max_fps)) {
1793 ALOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed",
1794 __func__, new_min_fps, new_max_fps);
1795 ALOGE("%s : current_min_fps = %d, current_max_fps = %d",
1796 __func__, current_min_fps, current_max_fps);
1797 ret = UNKNOWN_ERROR;
1798 }
1799 }
1800 } else {
1801 /* Check basic validation if scene mode is different */
1802 if ((new_min_fps > new_max_fps) ||
1803 (new_min_fps < 0) || (new_max_fps < 0))
1804 ret = UNKNOWN_ERROR;
1805 }
1806
1807 const char *new_focus_mode_str = params.get(CameraParameters::KEY_FOCUS_MODE);
1808
1809 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) {
1810 int new_scene_mode = -1;
1811
1812 const char *new_flash_mode_str = params.get(CameraParameters::KEY_FLASH_MODE);
1813
1814 // fps range is (15000,30000) by default.
1815 mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
1816 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1817 "15000,30000");
1818
1819 if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) {
1820 new_scene_mode = SCENE_MODE_NONE;
1821 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "on,off,auto,torch");
1822 } else {
1823 // defaults for non-auto scene modes
1824 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) {
1825 new_focus_mode_str = CameraParameters::FOCUS_MODE_AUTO;
1826 }
1827 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
1828
1829 if (!strcmp(new_scene_mode_str,
1830 CameraParameters::SCENE_MODE_PORTRAIT)) {
1831 new_scene_mode = SCENE_MODE_PORTRAIT;
1832 new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO;
1833 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "auto");
1834 } else if (!strcmp(new_scene_mode_str,
1835 CameraParameters::SCENE_MODE_LANDSCAPE)) {
1836 new_scene_mode = SCENE_MODE_LANDSCAPE;
1837 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
1838 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off");
1839 } else if (!strcmp(new_scene_mode_str,
1840 CameraParameters::SCENE_MODE_SPORTS)) {
1841 new_scene_mode = SCENE_MODE_SPORTS;
1842 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
1843 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off");
1844 } else if (!strcmp(new_scene_mode_str,
1845 CameraParameters::SCENE_MODE_PARTY)) {
1846 new_scene_mode = SCENE_MODE_PARTY_INDOOR;
1847 new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO;
1848 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "auto");
1849 } else if ((!strcmp(new_scene_mode_str,
1850 CameraParameters::SCENE_MODE_BEACH)) ||
1851 (!strcmp(new_scene_mode_str,
1852 CameraParameters::SCENE_MODE_SNOW))) {
1853 new_scene_mode = SCENE_MODE_BEACH_SNOW;
1854 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
1855 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off");
1856 } else if (!strcmp(new_scene_mode_str,
1857 CameraParameters::SCENE_MODE_SUNSET)) {
1858 new_scene_mode = SCENE_MODE_SUNSET;
1859 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
1860 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off");
1861 } else if (!strcmp(new_scene_mode_str,
1862 CameraParameters::SCENE_MODE_NIGHT)) {
1863 new_scene_mode = SCENE_MODE_NIGHTSHOT;
1864 mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(4000,30000)");
1865 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1866 "4000,30000");
1867 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
1868 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off");
1869 } else if (!strcmp(new_scene_mode_str,
1870 CameraParameters::SCENE_MODE_FIREWORKS)) {
1871 new_scene_mode = SCENE_MODE_FIREWORKS;
1872 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
1873 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off");
1874 } else if (!strcmp(new_scene_mode_str,
1875 CameraParameters::SCENE_MODE_CANDLELIGHT)) {
1876 new_scene_mode = SCENE_MODE_CANDLE_LIGHT;
1877 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
1878 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off");
1879 } else {
1880 ALOGE("%s::unmatched scene_mode(%s)",
1881 __func__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto
1882 ret = UNKNOWN_ERROR;
1883 }
1884 }
1885
1886 // focus mode
1887 if (new_focus_mode_str != NULL) {
1888 int new_focus_mode = -1;
1889
1890 if (!strcmp(new_focus_mode_str,
1891 CameraParameters::FOCUS_MODE_AUTO)) {
1892 new_focus_mode = FOCUS_MODE_AUTO;
1893 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
1894 BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
1895 }
1896 else if (!strcmp(new_focus_mode_str,
1897 CameraParameters::FOCUS_MODE_MACRO)) {
1898 new_focus_mode = FOCUS_MODE_MACRO;
1899 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
1900 BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR);
1901 }
1902 else if (!strcmp(new_focus_mode_str,
1903 CameraParameters::FOCUS_MODE_INFINITY)) {
1904 new_focus_mode = FOCUS_MODE_INFINITY;
1905 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
1906 BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR);
1907 }
1908 else {
1909 ALOGE("%s::unmatched focus_mode(%s)", __func__, new_focus_mode_str);
1910 ret = UNKNOWN_ERROR;
1911 }
1912
1913 if (0 <= new_focus_mode) {
1914 if (mSecCamera->setFocusMode(new_focus_mode) < 0) {
1915 ALOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode);
1916 ret = UNKNOWN_ERROR;
1917 } else {
1918 mParameters.set(CameraParameters::KEY_FOCUS_MODE, new_focus_mode_str);
1919 }
1920 }
1921 }
1922
1923 // flash..
1924 if (new_flash_mode_str != NULL) {
1925 int new_flash_mode = -1;
1926
1927 if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_OFF))
1928 new_flash_mode = FLASH_MODE_OFF;
1929 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_AUTO))
1930 new_flash_mode = FLASH_MODE_AUTO;
1931 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_ON))
1932 new_flash_mode = FLASH_MODE_ON;
1933 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_TORCH))
1934 new_flash_mode = FLASH_MODE_TORCH;
1935 else {
1936 ALOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye
1937 ret = UNKNOWN_ERROR;
1938 }
1939 if (0 <= new_flash_mode) {
1940 if (mSecCamera->setFlashMode(new_flash_mode) < 0) {
1941 ALOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode);
1942 ret = UNKNOWN_ERROR;
1943 } else {
1944 mParameters.set(CameraParameters::KEY_FLASH_MODE, new_flash_mode_str);
1945 }
1946 }
1947 }
1948
1949 // scene..
1950 if (0 <= new_scene_mode) {
1951 if (mSecCamera->setSceneMode(new_scene_mode) < 0) {
1952 ALOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode);
1953 ret = UNKNOWN_ERROR;
1954 } else {
1955 mParameters.set(CameraParameters::KEY_SCENE_MODE, new_scene_mode_str);
1956 }
1957 }
1958 } else {
1959 if (!isSupportedParameter(new_focus_mode_str,
1960 mParameters.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES))) {
1961 ALOGE("%s: Unsupported focus mode: %s", __func__, new_focus_mode_str);
1962 ret = UNKNOWN_ERROR;
1963 }
1964 }
1965
1966 // ---------------------------------------------------------------------------
1967
1968 // image effect
1969 const char *new_image_effect_str = params.get(CameraParameters::KEY_EFFECT);
1970 if (new_image_effect_str != NULL) {
1971
1972 int new_image_effect = -1;
1973
1974 if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NONE))
1975 new_image_effect = IMAGE_EFFECT_NONE;
1976 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_MONO))
1977 new_image_effect = IMAGE_EFFECT_BNW;
1978 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_SEPIA))
1979 new_image_effect = IMAGE_EFFECT_SEPIA;
1980 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_AQUA))
1981 new_image_effect = IMAGE_EFFECT_AQUA;
1982 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NEGATIVE))
1983 new_image_effect = IMAGE_EFFECT_NEGATIVE;
1984 else {
1985 //posterize, whiteboard, blackboard, solarize
1986 ALOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str);
1987 ret = UNKNOWN_ERROR;
1988 }
1989
1990 if (new_image_effect >= 0) {
1991 if (mSecCamera->setImageEffect(new_image_effect) < 0) {
1992 ALOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect);
1993 ret = UNKNOWN_ERROR;
1994 } else {
1995 const char *old_image_effect_str = mParameters.get(CameraParameters::KEY_EFFECT);
1996
1997 if (old_image_effect_str) {
1998 if (strcmp(old_image_effect_str, new_image_effect_str)) {
1999 setSkipFrame(EFFECT_SKIP_FRAME);
2000 }
2001 }
2002
2003 mParameters.set(CameraParameters::KEY_EFFECT, new_image_effect_str);
2004 }
2005 }
2006 }
2007
2008 //vt mode
2009 int new_vtmode = mInternalParameters.getInt("vtmode");
2010 if (0 <= new_vtmode) {
2011 if (mSecCamera->setVTmode(new_vtmode) < 0) {
2012 ALOGE("ERR(%s):Fail on mSecCamera->setVTMode(%d)", __func__, new_vtmode);
2013 ret = UNKNOWN_ERROR;
2014 }
2015 }
2016
2017 //contrast
2018 int new_contrast = mInternalParameters.getInt("contrast");
2019
2020 if (0 <= new_contrast) {
2021 if (mSecCamera->setContrast(new_contrast) < 0) {
2022 ALOGE("ERR(%s):Fail on mSecCamera->setContrast(%d)", __func__, new_contrast);
2023 ret = UNKNOWN_ERROR;
2024 }
2025 }
2026
2027 //WDR
2028 int new_wdr = mInternalParameters.getInt("wdr");
2029
2030 if (0 <= new_wdr) {
2031 if (mSecCamera->setWDR(new_wdr) < 0) {
2032 ALOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_wdr);
2033 ret = UNKNOWN_ERROR;
2034 }
2035 }
2036
2037 //anti shake
2038 int new_anti_shake = mInternalParameters.getInt("anti-shake");
2039
2040 if (0 <= new_anti_shake) {
2041 if (mSecCamera->setAntiShake(new_anti_shake) < 0) {
2042 ALOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_anti_shake);
2043 ret = UNKNOWN_ERROR;
2044 }
2045 }
2046
2047 // gps latitude
2048 const char *new_gps_latitude_str = params.get(CameraParameters::KEY_GPS_LATITUDE);
2049 if (mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) {
2050 ALOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str);
2051 ret = UNKNOWN_ERROR;
2052 } else {
2053 if (new_gps_latitude_str) {
2054 mParameters.set(CameraParameters::KEY_GPS_LATITUDE, new_gps_latitude_str);
2055 } else {
2056 mParameters.remove(CameraParameters::KEY_GPS_LATITUDE);
2057 }
2058 }
2059
2060 // gps longitude
2061 const char *new_gps_longitude_str = params.get(CameraParameters::KEY_GPS_LONGITUDE);
2062
2063 if (mSecCamera->setGPSLongitude(new_gps_longitude_str) < 0) {
2064 ALOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str);
2065 ret = UNKNOWN_ERROR;
2066 } else {
2067 if (new_gps_longitude_str) {
2068 mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, new_gps_longitude_str);
2069 } else {
2070 mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE);
2071 }
2072 }
2073
2074 // gps altitude
2075 const char *new_gps_altitude_str = params.get(CameraParameters::KEY_GPS_ALTITUDE);
2076
2077 if (mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) {
2078 ALOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str);
2079 ret = UNKNOWN_ERROR;
2080 } else {
2081 if (new_gps_altitude_str) {
2082 mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, new_gps_altitude_str);
2083 } else {
2084 mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE);
2085 }
2086 }
2087
2088 // gps timestamp
2089 const char *new_gps_timestamp_str = params.get(CameraParameters::KEY_GPS_TIMESTAMP);
2090
2091 if (mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) {
2092 ALOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str);
2093 ret = UNKNOWN_ERROR;
2094 } else {
2095 if (new_gps_timestamp_str) {
2096 mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, new_gps_timestamp_str);
2097 } else {
2098 mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
2099 }
2100 }
2101
2102 // gps processing method
2103 const char *new_gps_processing_method_str = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
2104
2105 if (mSecCamera->setGPSProcessingMethod(new_gps_processing_method_str) < 0) {
2106 ALOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str);
2107 ret = UNKNOWN_ERROR;
2108 } else {
2109 if (new_gps_processing_method_str) {
2110 mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, new_gps_processing_method_str);
2111 } else {
2112 mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
2113 }
2114 }
2115
2116 // Recording size
2117 int new_recording_width = mInternalParameters.getInt("recording-size-width");
2118 int new_recording_height= mInternalParameters.getInt("recording-size-height");
2119
2120 if (0 < new_recording_width && 0 < new_recording_height) {
2121 if (mSecCamera->setRecordingSize(new_recording_width, new_recording_height) < 0) {
2122 ALOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_recording_width, new_recording_height);
2123 ret = UNKNOWN_ERROR;
2124 }
2125 } else {
2126 if (mSecCamera->setRecordingSize(new_preview_width, new_preview_height) < 0) {
2127 ALOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_preview_width, new_preview_height);
2128 ret = UNKNOWN_ERROR;
2129 }
2130 }
2131
2132 //gamma
2133 const char *new_gamma_str = mInternalParameters.get("video_recording_gamma");
2134
2135 if (new_gamma_str != NULL) {
2136 int new_gamma = -1;
2137 if (!strcmp(new_gamma_str, "off"))
2138 new_gamma = GAMMA_OFF;
2139 else if (!strcmp(new_gamma_str, "on"))
2140 new_gamma = GAMMA_ON;
2141 else {
2142 ALOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str);
2143 ret = UNKNOWN_ERROR;
2144 }
2145
2146 if (0 <= new_gamma) {
2147 if (mSecCamera->setGamma(new_gamma) < 0) {
2148 ALOGE("%s::mSecCamera->setGamma(%d) fail", __func__, new_gamma);
2149 ret = UNKNOWN_ERROR;
2150 }
2151 }
2152 }
2153
2154 //slow ae
2155 const char *new_slow_ae_str = mInternalParameters.get("slow_ae");
2156
2157 if (new_slow_ae_str != NULL) {
2158 int new_slow_ae = -1;
2159
2160 if (!strcmp(new_slow_ae_str, "off"))
2161 new_slow_ae = SLOW_AE_OFF;
2162 else if (!strcmp(new_slow_ae_str, "on"))
2163 new_slow_ae = SLOW_AE_ON;
2164 else {
2165 ALOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str);
2166 ret = UNKNOWN_ERROR;
2167 }
2168
2169 if (0 <= new_slow_ae) {
2170 if (mSecCamera->setSlowAE(new_slow_ae) < 0) {
2171 ALOGE("%s::mSecCamera->setSlowAE(%d) fail", __func__, new_slow_ae);
2172 ret = UNKNOWN_ERROR;
2173 }
2174 }
2175 }
2176
2177 /*Camcorder fix fps*/
2178 int new_sensor_mode = mInternalParameters.getInt("cam_mode");
2179
2180 if (0 <= new_sensor_mode) {
2181 if (mSecCamera->setSensorMode(new_sensor_mode) < 0) {
2182 ALOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __func__, new_sensor_mode);
2183 ret = UNKNOWN_ERROR;
2184 }
2185 } else {
2186 new_sensor_mode=0;
2187 }
2188
2189 /*Shot mode*/
2190 int new_shot_mode = mInternalParameters.getInt("shot_mode");
2191
2192 if (0 <= new_shot_mode) {
2193 if (mSecCamera->setShotMode(new_shot_mode) < 0) {
2194 ALOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __func__, new_shot_mode);
2195 ret = UNKNOWN_ERROR;
2196 }
2197 } else {
2198 new_shot_mode=0;
2199 }
2200
2201 //blur for Video call
2202 int new_blur_level = mInternalParameters.getInt("blur");
2203
2204 if (0 <= new_blur_level) {
2205 if (mSecCamera->setBlur(new_blur_level) < 0) {
2206 ALOGE("ERR(%s):Fail on mSecCamera->setBlur(%d)", __func__, new_blur_level);
2207 ret = UNKNOWN_ERROR;
2208 }
2209 }
2210
2211
2212 // chk_dataline
2213 int new_dataline = mInternalParameters.getInt("chk_dataline");
2214
2215 if (0 <= new_dataline) {
2216 if (mSecCamera->setDataLineCheck(new_dataline) < 0) {
2217 ALOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __func__, new_dataline);
2218 ret = UNKNOWN_ERROR;
2219 }
2220 }
2221 ALOGV("%s return ret = %d", __func__, ret);
2222
2223 return ret;
2224 }
2225
getParameters() const2226 CameraParameters CameraHardwareSec::getParameters() const
2227 {
2228 ALOGV("%s :", __func__);
2229 return mParameters;
2230 }
2231
sendCommand(int32_t command,int32_t arg1,int32_t arg2)2232 status_t CameraHardwareSec::sendCommand(int32_t command, int32_t arg1, int32_t arg2)
2233 {
2234 return BAD_VALUE;
2235 }
2236
release()2237 void CameraHardwareSec::release()
2238 {
2239 ALOGV("%s", __func__);
2240
2241 /* shut down any threads we have that might be running. do it here
2242 * instead of the destructor. we're guaranteed to be on another thread
2243 * than the ones below. if we used the destructor, since the threads
2244 * have a reference to this object, we could wind up trying to wait
2245 * for ourself to exit, which is a deadlock.
2246 */
2247 if (mPreviewThread != NULL) {
2248 /* this thread is normally already in it's threadLoop but blocked
2249 * on the condition variable or running. signal it so it wakes
2250 * up and can exit.
2251 */
2252 mPreviewThread->requestExit();
2253 mExitPreviewThread = true;
2254 mPreviewRunning = true; /* let it run so it can exit */
2255 mPreviewCondition.signal();
2256 mPreviewThread->requestExitAndWait();
2257 mPreviewThread.clear();
2258 }
2259 if (mAutoFocusThread != NULL) {
2260 /* this thread is normally already in it's threadLoop but blocked
2261 * on the condition variable. signal it so it wakes up and can exit.
2262 */
2263 mFocusLock.lock();
2264 mAutoFocusThread->requestExit();
2265 mExitAutoFocusThread = true;
2266 mFocusCondition.signal();
2267 mFocusLock.unlock();
2268 mAutoFocusThread->requestExitAndWait();
2269 mAutoFocusThread.clear();
2270 }
2271 if (mPictureThread != NULL) {
2272 mPictureThread->requestExitAndWait();
2273 mPictureThread.clear();
2274 }
2275
2276 if (mRawHeap) {
2277 mRawHeap->release(mRawHeap);
2278 mRawHeap = 0;
2279 }
2280 if (mPreviewHeap) {
2281 mPreviewHeap->release(mPreviewHeap);
2282 mPreviewHeap = 0;
2283 }
2284 if (mRecordHeap) {
2285 mRecordHeap->release(mRecordHeap);
2286 mRecordHeap = 0;
2287 }
2288
2289 /* close after all the heaps are cleared since those
2290 * could have dup'd our file descriptor.
2291 */
2292 mSecCamera->DeinitCamera();
2293 }
2294
storeMetaDataInBuffers(bool enable)2295 status_t CameraHardwareSec::storeMetaDataInBuffers(bool enable)
2296 {
2297 // FIXME:
2298 // metadata buffer mode can be turned on or off.
2299 // Samsung needs to fix this.
2300 if (!enable) {
2301 ALOGE("Non-metadata buffer mode is not supported!");
2302 return INVALID_OPERATION;
2303 }
2304 return OK;
2305 }
2306
2307 static CameraInfo sCameraInfo[] = {
2308 {
2309 CAMERA_FACING_BACK,
2310 90, /* orientation */
2311 },
2312 {
2313 CAMERA_FACING_FRONT,
2314 270, /* orientation */
2315 }
2316 };
2317
2318 /** Close this device */
2319
2320 static camera_device_t *g_cam_device;
2321
HAL_camera_device_close(struct hw_device_t * device)2322 static int HAL_camera_device_close(struct hw_device_t* device)
2323 {
2324 ALOGI("%s", __func__);
2325 if (device) {
2326 camera_device_t *cam_device = (camera_device_t *)device;
2327 delete static_cast<CameraHardwareSec *>(cam_device->priv);
2328 free(cam_device);
2329 g_cam_device = 0;
2330 }
2331 return 0;
2332 }
2333
obj(struct camera_device * dev)2334 static inline CameraHardwareSec *obj(struct camera_device *dev)
2335 {
2336 return reinterpret_cast<CameraHardwareSec *>(dev->priv);
2337 }
2338
2339 /** Set the preview_stream_ops to which preview frames are sent */
HAL_camera_device_set_preview_window(struct camera_device * dev,struct preview_stream_ops * buf)2340 static int HAL_camera_device_set_preview_window(struct camera_device *dev,
2341 struct preview_stream_ops *buf)
2342 {
2343 ALOGV("%s", __func__);
2344 return obj(dev)->setPreviewWindow(buf);
2345 }
2346
2347 /** Set the notification and data callbacks */
HAL_camera_device_set_callbacks(struct camera_device * dev,camera_notify_callback notify_cb,camera_data_callback data_cb,camera_data_timestamp_callback data_cb_timestamp,camera_request_memory get_memory,void * user)2348 static void HAL_camera_device_set_callbacks(struct camera_device *dev,
2349 camera_notify_callback notify_cb,
2350 camera_data_callback data_cb,
2351 camera_data_timestamp_callback data_cb_timestamp,
2352 camera_request_memory get_memory,
2353 void* user)
2354 {
2355 ALOGV("%s", __func__);
2356 obj(dev)->setCallbacks(notify_cb, data_cb, data_cb_timestamp,
2357 get_memory,
2358 user);
2359 }
2360
2361 /**
2362 * The following three functions all take a msg_type, which is a bitmask of
2363 * the messages defined in include/ui/Camera.h
2364 */
2365
2366 /**
2367 * Enable a message, or set of messages.
2368 */
HAL_camera_device_enable_msg_type(struct camera_device * dev,int32_t msg_type)2369 static void HAL_camera_device_enable_msg_type(struct camera_device *dev, int32_t msg_type)
2370 {
2371 ALOGV("%s", __func__);
2372 obj(dev)->enableMsgType(msg_type);
2373 }
2374
2375 /**
2376 * Disable a message, or a set of messages.
2377 *
2378 * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
2379 * HAL should not rely on its client to call releaseRecordingFrame() to
2380 * release video recording frames sent out by the cameral HAL before and
2381 * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
2382 * clients must not modify/access any video recording frame after calling
2383 * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
2384 */
HAL_camera_device_disable_msg_type(struct camera_device * dev,int32_t msg_type)2385 static void HAL_camera_device_disable_msg_type(struct camera_device *dev, int32_t msg_type)
2386 {
2387 ALOGV("%s", __func__);
2388 obj(dev)->disableMsgType(msg_type);
2389 }
2390
2391 /**
2392 * Query whether a message, or a set of messages, is enabled. Note that
2393 * this is operates as an AND, if any of the messages queried are off, this
2394 * will return false.
2395 */
HAL_camera_device_msg_type_enabled(struct camera_device * dev,int32_t msg_type)2396 static int HAL_camera_device_msg_type_enabled(struct camera_device *dev, int32_t msg_type)
2397 {
2398 ALOGV("%s", __func__);
2399 return obj(dev)->msgTypeEnabled(msg_type);
2400 }
2401
2402 /**
2403 * Start preview mode.
2404 */
HAL_camera_device_start_preview(struct camera_device * dev)2405 static int HAL_camera_device_start_preview(struct camera_device *dev)
2406 {
2407 ALOGV("%s", __func__);
2408 return obj(dev)->startPreview();
2409 }
2410
2411 /**
2412 * Stop a previously started preview.
2413 */
HAL_camera_device_stop_preview(struct camera_device * dev)2414 static void HAL_camera_device_stop_preview(struct camera_device *dev)
2415 {
2416 ALOGV("%s", __func__);
2417 obj(dev)->stopPreview();
2418 }
2419
2420 /**
2421 * Returns true if preview is enabled.
2422 */
HAL_camera_device_preview_enabled(struct camera_device * dev)2423 static int HAL_camera_device_preview_enabled(struct camera_device *dev)
2424 {
2425 ALOGV("%s", __func__);
2426 return obj(dev)->previewEnabled();
2427 }
2428
2429 /**
2430 * Request the camera HAL to store meta data or real YUV data in the video
2431 * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
2432 * it is not called, the default camera HAL behavior is to store real YUV
2433 * data in the video buffers.
2434 *
2435 * This method should be called before startRecording() in order to be
2436 * effective.
2437 *
2438 * If meta data is stored in the video buffers, it is up to the receiver of
2439 * the video buffers to interpret the contents and to find the actual frame
2440 * data with the help of the meta data in the buffer. How this is done is
2441 * outside of the scope of this method.
2442 *
2443 * Some camera HALs may not support storing meta data in the video buffers,
2444 * but all camera HALs should support storing real YUV data in the video
2445 * buffers. If the camera HAL does not support storing the meta data in the
2446 * video buffers when it is requested to do do, INVALID_OPERATION must be
2447 * returned. It is very useful for the camera HAL to pass meta data rather
2448 * than the actual frame data directly to the video encoder, since the
2449 * amount of the uncompressed frame data can be very large if video size is
2450 * large.
2451 *
2452 * @param enable if true to instruct the camera HAL to store
2453 * meta data in the video buffers; false to instruct
2454 * the camera HAL to store real YUV data in the video
2455 * buffers.
2456 *
2457 * @return OK on success.
2458 */
HAL_camera_device_store_meta_data_in_buffers(struct camera_device * dev,int enable)2459 static int HAL_camera_device_store_meta_data_in_buffers(struct camera_device *dev, int enable)
2460 {
2461 ALOGV("%s", __func__);
2462 return obj(dev)->storeMetaDataInBuffers(enable);
2463 }
2464
2465 /**
2466 * Start record mode. When a record image is available, a
2467 * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding
2468 * frame. Every record frame must be released by a camera HAL client via
2469 * releaseRecordingFrame() before the client calls
2470 * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
2471 * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
2472 * responsibility to manage the life-cycle of the video recording frames,
2473 * and the client must not modify/access any video recording frames.
2474 */
HAL_camera_device_start_recording(struct camera_device * dev)2475 static int HAL_camera_device_start_recording(struct camera_device *dev)
2476 {
2477 ALOGV("%s", __func__);
2478 return obj(dev)->startRecording();
2479 }
2480
2481 /**
2482 * Stop a previously started recording.
2483 */
HAL_camera_device_stop_recording(struct camera_device * dev)2484 static void HAL_camera_device_stop_recording(struct camera_device *dev)
2485 {
2486 ALOGV("%s", __func__);
2487 obj(dev)->stopRecording();
2488 }
2489
2490 /**
2491 * Returns true if recording is enabled.
2492 */
HAL_camera_device_recording_enabled(struct camera_device * dev)2493 static int HAL_camera_device_recording_enabled(struct camera_device *dev)
2494 {
2495 ALOGV("%s", __func__);
2496 return obj(dev)->recordingEnabled();
2497 }
2498
2499 /**
2500 * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
2501 *
2502 * It is camera HAL client's responsibility to release video recording
2503 * frames sent out by the camera HAL before the camera HAL receives a call
2504 * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
2505 * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
2506 * responsibility to manage the life-cycle of the video recording frames.
2507 */
HAL_camera_device_release_recording_frame(struct camera_device * dev,const void * opaque)2508 static void HAL_camera_device_release_recording_frame(struct camera_device *dev,
2509 const void *opaque)
2510 {
2511 ALOGV("%s", __func__);
2512 obj(dev)->releaseRecordingFrame(opaque);
2513 }
2514
2515 /**
2516 * Start auto focus, the notification callback routine is called with
2517 * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be
2518 * called again if another auto focus is needed.
2519 */
HAL_camera_device_auto_focus(struct camera_device * dev)2520 static int HAL_camera_device_auto_focus(struct camera_device *dev)
2521 {
2522 ALOGV("%s", __func__);
2523 return obj(dev)->autoFocus();
2524 }
2525
2526 /**
2527 * Cancels auto-focus function. If the auto-focus is still in progress,
2528 * this function will cancel it. Whether the auto-focus is in progress or
2529 * not, this function will return the focus position to the default. If
2530 * the camera does not support auto-focus, this is a no-op.
2531 */
HAL_camera_device_cancel_auto_focus(struct camera_device * dev)2532 static int HAL_camera_device_cancel_auto_focus(struct camera_device *dev)
2533 {
2534 ALOGV("%s", __func__);
2535 return obj(dev)->cancelAutoFocus();
2536 }
2537
2538 /**
2539 * Take a picture.
2540 */
HAL_camera_device_take_picture(struct camera_device * dev)2541 static int HAL_camera_device_take_picture(struct camera_device *dev)
2542 {
2543 ALOGV("%s", __func__);
2544 return obj(dev)->takePicture();
2545 }
2546
2547 /**
2548 * Cancel a picture that was started with takePicture. Calling this method
2549 * when no picture is being taken is a no-op.
2550 */
HAL_camera_device_cancel_picture(struct camera_device * dev)2551 static int HAL_camera_device_cancel_picture(struct camera_device *dev)
2552 {
2553 ALOGV("%s", __func__);
2554 return obj(dev)->cancelPicture();
2555 }
2556
2557 /**
2558 * Set the camera parameters. This returns BAD_VALUE if any parameter is
2559 * invalid or not supported.
2560 */
HAL_camera_device_set_parameters(struct camera_device * dev,const char * parms)2561 static int HAL_camera_device_set_parameters(struct camera_device *dev,
2562 const char *parms)
2563 {
2564 ALOGV("%s", __func__);
2565 String8 str(parms);
2566 CameraParameters p(str);
2567 return obj(dev)->setParameters(p);
2568 }
2569
2570 /** Return the camera parameters. */
HAL_camera_device_get_parameters(struct camera_device * dev)2571 char *HAL_camera_device_get_parameters(struct camera_device *dev)
2572 {
2573 ALOGV("%s", __func__);
2574 String8 str;
2575 CameraParameters parms = obj(dev)->getParameters();
2576 str = parms.flatten();
2577 return strdup(str.string());
2578 }
2579
HAL_camera_device_put_parameters(struct camera_device * dev,char * parms)2580 void HAL_camera_device_put_parameters(struct camera_device *dev, char *parms)
2581 {
2582 ALOGV("%s", __func__);
2583 free(parms);
2584 }
2585
2586 /**
2587 * Send command to camera driver.
2588 */
HAL_camera_device_send_command(struct camera_device * dev,int32_t cmd,int32_t arg1,int32_t arg2)2589 static int HAL_camera_device_send_command(struct camera_device *dev,
2590 int32_t cmd, int32_t arg1, int32_t arg2)
2591 {
2592 ALOGV("%s", __func__);
2593 return obj(dev)->sendCommand(cmd, arg1, arg2);
2594 }
2595
2596 /**
2597 * Release the hardware resources owned by this object. Note that this is
2598 * *not* done in the destructor.
2599 */
HAL_camera_device_release(struct camera_device * dev)2600 static void HAL_camera_device_release(struct camera_device *dev)
2601 {
2602 ALOGV("%s", __func__);
2603 obj(dev)->release();
2604 }
2605
2606 /**
2607 * Dump state of the camera hardware
2608 */
HAL_camera_device_dump(struct camera_device * dev,int fd)2609 static int HAL_camera_device_dump(struct camera_device *dev, int fd)
2610 {
2611 ALOGV("%s", __func__);
2612 return obj(dev)->dump(fd);
2613 }
2614
HAL_getNumberOfCameras()2615 static int HAL_getNumberOfCameras()
2616 {
2617 ALOGV("%s", __func__);
2618 return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]);
2619 }
2620
HAL_getCameraInfo(int cameraId,struct camera_info * cameraInfo)2621 static int HAL_getCameraInfo(int cameraId, struct camera_info *cameraInfo)
2622 {
2623 ALOGV("%s", __func__);
2624 memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo));
2625 return 0;
2626 }
2627
2628 #define SET_METHOD(m) m : HAL_camera_device_##m
2629
2630 static camera_device_ops_t camera_device_ops = {
2631 SET_METHOD(set_preview_window),
2632 SET_METHOD(set_callbacks),
2633 SET_METHOD(enable_msg_type),
2634 SET_METHOD(disable_msg_type),
2635 SET_METHOD(msg_type_enabled),
2636 SET_METHOD(start_preview),
2637 SET_METHOD(stop_preview),
2638 SET_METHOD(preview_enabled),
2639 SET_METHOD(store_meta_data_in_buffers),
2640 SET_METHOD(start_recording),
2641 SET_METHOD(stop_recording),
2642 SET_METHOD(recording_enabled),
2643 SET_METHOD(release_recording_frame),
2644 SET_METHOD(auto_focus),
2645 SET_METHOD(cancel_auto_focus),
2646 SET_METHOD(take_picture),
2647 SET_METHOD(cancel_picture),
2648 SET_METHOD(set_parameters),
2649 SET_METHOD(get_parameters),
2650 SET_METHOD(put_parameters),
2651 SET_METHOD(send_command),
2652 SET_METHOD(release),
2653 SET_METHOD(dump),
2654 };
2655
2656 #undef SET_METHOD
2657
HAL_camera_device_open(const struct hw_module_t * module,const char * id,struct hw_device_t ** device)2658 static int HAL_camera_device_open(const struct hw_module_t* module,
2659 const char *id,
2660 struct hw_device_t** device)
2661 {
2662 ALOGV("%s", __func__);
2663
2664 int cameraId = atoi(id);
2665 if (cameraId < 0 || cameraId >= HAL_getNumberOfCameras()) {
2666 ALOGE("Invalid camera ID %s", id);
2667 return -EINVAL;
2668 }
2669
2670 if (g_cam_device) {
2671 if (obj(g_cam_device)->getCameraId() == cameraId) {
2672 ALOGV("returning existing camera ID %s", id);
2673 goto done;
2674 } else {
2675 ALOGE("Cannot open camera %d. camera %d is already running!",
2676 cameraId, obj(g_cam_device)->getCameraId());
2677 return -ENOSYS;
2678 }
2679 }
2680
2681 g_cam_device = (camera_device_t *)malloc(sizeof(camera_device_t));
2682 if (!g_cam_device)
2683 return -ENOMEM;
2684
2685 g_cam_device->common.tag = HARDWARE_DEVICE_TAG;
2686 g_cam_device->common.version = 1;
2687 g_cam_device->common.module = const_cast<hw_module_t *>(module);
2688 g_cam_device->common.close = HAL_camera_device_close;
2689
2690 g_cam_device->ops = &camera_device_ops;
2691
2692 ALOGI("%s: open camera %s", __func__, id);
2693
2694 g_cam_device->priv = new CameraHardwareSec(cameraId, g_cam_device);
2695
2696 done:
2697 *device = (hw_device_t *)g_cam_device;
2698 ALOGI("%s: opened camera %s (%p)", __func__, id, *device);
2699 return 0;
2700 }
2701
2702 static hw_module_methods_t camera_module_methods = {
2703 open : HAL_camera_device_open
2704 };
2705
2706 extern "C" {
2707 struct camera_module HAL_MODULE_INFO_SYM = {
2708 common : {
2709 tag : HARDWARE_MODULE_TAG,
2710 version_major : 1,
2711 version_minor : 0,
2712 id : CAMERA_HARDWARE_MODULE_ID,
2713 name : "Crespo camera HAL",
2714 author : "Samsung Corporation",
2715 methods : &camera_module_methods,
2716 },
2717 get_number_of_cameras : HAL_getNumberOfCameras,
2718 get_camera_info : HAL_getCameraInfo
2719 };
2720 }
2721
2722 }; // namespace android
2723
