/libcamera/ExynosCameraHWInterface.cpp
C++ | 4539 lines | 3428 code | 698 blank | 413 comment | 1065 complexity | d254f181d8152368d9bdea60f63284f8 MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- /*
- **
- ** Copyright 2008, The Android Open Source Project
- ** Copyright 2010, Samsung Electronics Co. LTD
- **
- ** Licensed under the Apache License, Version 2.0 (the "License");
- ** you may not use this file except in compliance with the License.
- ** You may obtain a copy of the License at
- **
- ** http://www.apache.org/licenses/LICENSE-2.0
- **
- ** Unless required by applicable law or agreed to in writing, software
- ** distributed under the License is distributed on an "AS IS" BASIS,
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- ** See the License for the specific language governing permissions and
- ** limitations under the License.
- */
- /*!
- * \file ExynosCameraHWInterface.h
- * \brief source file for Android Camera HAL
- * \author thun.hwang(thun.hwang@samsung.com)
- * \date 2010/06/03
- *
- * <b>Revision History: </b>
- * - 2011/12/31 : thun.hwang(thun.hwang@samsung.com) \n
- * Initial version
- *
- * - 2012/02/01 : Sangwoo, Park(sw5771.park@samsung.com) \n
- * Adjust Android Standard features
- *
- * - 2012/03/14 : sangwoo.park(sw5771.park@samsung.com) \n
- * Change file, class name to ExynosXXX.
- *
- */
- #include <sys/types.h>
- #include <sys/stat.h>
- //#define LOG_NDEBUG 0
- #define LOG_TAG "ExynosCameraHWInterface"
- #include <utils/Log.h>
- #include "ExynosCameraHWInterface.h"
- #include "exynos_format.h"
- #define VIDEO_COMMENT_MARKER_H (0xFFBE)
- #define VIDEO_COMMENT_MARKER_L (0xFFBF)
- #define VIDEO_COMMENT_MARKER_LENGTH (4)
- #define JPEG_EOI_MARKER (0xFFD9)
- #define HIBYTE(x) (((x) >> 8) & 0xFF)
- #define LOBYTE(x) ((x) & 0xFF)
- /*TODO: This values will be changed */
- #define BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR "0.10,1.20,Infinity"
- #define FRONT_CAMERA_FOCUS_DISTANCES_STR "0.20,0.25,Infinity"
- #define BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR "0.10,0.20,Infinity"
- #define BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR "0.10,1.20,Infinity"
- #define BACK_CAMERA_FOCUS_DISTANCE_INFINITY "Infinity"
- #define FRONT_CAMERA_FOCUS_DISTANCE_INFINITY "Infinity"
- // This hack does two things:
- // -- it sets preview to NV21 (YUV420SP)
- // -- it sets gralloc to YV12
- //
- // The reason being: the samsung encoder understands only yuv420sp, and gralloc
- // does yv12 and rgb565. So what we do is we break up the interleaved UV in
- // separate V and U planes, which makes preview look good, and enabled the
- // encoder as well.
- //
- // FIXME: Samsung needs to enable support for proper yv12 coming out of the
- // camera, and to fix their video encoder to work with yv12.
- // FIXME: It also seems like either Samsung's YUV420SP (NV21) or img's YV12 has
- // the color planes switched. We need to figure which side is doing it
- // wrong and have the respective party fix it.
- namespace android {
- static const int INITIAL_SKIP_FRAME = 8;
- static const int EFFECT_SKIP_FRAME = 1;
- gralloc_module_t const* ExynosCameraHWInterface::m_grallocHal;
- ExynosCameraHWInterface::ExynosCameraHWInterface(int cameraId, camera_device_t *dev)
- :
- m_captureInProgress(false),
- m_skipFrame(0),
- m_notifyCb(0),
- m_dataCb(0),
- m_dataCbTimestamp(0),
- m_callbackCookie(0),
- m_msgEnabled(0),
- m_faceDetected(false),
- m_halDevice(dev),
- m_numOfAvailableVideoBuf(0)
- {
- ALOGV("DEBUG(%s):", __func__);
- int ret = 0;
- m_previewWindow = NULL;
- m_secCamera = ExynosCamera::createInstance();
- for (int i = 0; i < NUM_OF_PREVIEW_BUF; i++) {
- m_previewHeap[i] = NULL;
- m_previewBufHandle[i] = NULL;
- m_previewStride[i] = 0;
- m_avaliblePreviewBufHandle[i] = false;
- m_flagGrallocLocked[i] = false;
- m_matchedGrallocIndex[i] = -1;
- m_grallocVirtAddr[i] = NULL;
- }
- m_minUndequeuedBufs = 0;
- #ifndef USE_3DNR_DMAOUT
- m_cntVideoBuf = 0;
- #endif
- m_oldPictureBufQueueHead = NULL;
- m_getMemoryCb = NULL;
- m_exynosPreviewCSC = NULL;
- m_exynosPictureCSC = NULL;
- m_exynosVideoCSC = NULL;
- m_frameMetadata.number_of_faces = 0;
- m_frameMetadata.faces = m_faces;
- for (int i = 0; i < NUM_OF_VIDEO_BUF; i++) {
- m_videoHeap[i] = NULL;
- m_resizedVideoHeap[i] = NULL;
- }
- m_ion_client = ion_client_create();
- for (int i = 0; i < NUM_OF_PICTURE_BUF; i++)
- m_pictureHeap[i] = NULL;
- m_rawHeap = NULL;
- m_exitAutoFocusThread = false;
- m_exitPreviewThread = false;
- m_exitVideoThread = false;
- /* whether the PreviewThread is active in preview or stopped. we
- * create the thread but it is initially in stopped state.
- */
- m_previewRunning = false;
- m_videoRunning = false;
- m_pictureRunning = false;
- #ifndef USE_3DNR_DMAOUT
- m_videoStart = false;
- #endif
- m_previewStartDeferred = false;
- m_recordingHint = false;
- if (!m_grallocHal) {
- ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&m_grallocHal);
- if (ret)
- ALOGE("ERR(%s):Fail on loading gralloc HAL", __func__);
- }
- if (m_secCamera->create(cameraId) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->create(%d)", __func__, cameraId);
- return;
- }
- m_initDefaultParameters(cameraId);
- CSC_METHOD cscMethod = CSC_METHOD_HW;
- m_exynosPreviewCSC = csc_init(cscMethod);
- if (m_exynosPreviewCSC == NULL)
- ALOGE("ERR(%s):csc_init() fail", __func__);
- m_exynosPictureCSC = csc_init(cscMethod);
- if (m_exynosPictureCSC == NULL)
- ALOGE("ERR(%s):csc_init() fail", __func__);
- m_exynosVideoCSC = csc_init(cscMethod);
- if (m_exynosVideoCSC == NULL)
- ALOGE("ERR(%s):csc_init() fail", __func__);
- m_previewThread = new PreviewThread(this);
- m_videoThread = new VideoThread(this);
- m_autoFocusThread = new AutoFocusThread(this);
- m_pictureThread = new PictureThread(this);
- }
- ExynosCameraHWInterface::~ExynosCameraHWInterface()
- {
- close(m_ion_client);
- this->release();
- }
- status_t ExynosCameraHWInterface::setPreviewWindow(preview_stream_ops *w)
- {
- m_previewWindow = w;
- ALOGV("DEBUG(%s):m_previewWindow %p", __func__, m_previewWindow);
- if (m_previewWindow == NULL) {
- ALOGV("DEBUG(%s):preview window is NULL!", __func__);
- return OK;
- }
- m_previewLock.lock();
- if (m_previewRunning == true && m_previewStartDeferred == false) {
- ALOGV("DEBUG(%s):stop preview (window change)", __func__);
- m_stopPreviewInternal();
- }
- if (m_previewWindow->get_min_undequeued_buffer_count(m_previewWindow, &m_minUndequeuedBufs) != 0) {
- ALOGE("ERR(%s):could not retrieve min undequeued buffer count", __func__);
- return INVALID_OPERATION;
- }
- if (NUM_OF_PREVIEW_BUF <= m_minUndequeuedBufs) {
- ALOGE("ERR(%s):min undequeued buffer count %d is too high (expecting at most %d)", __func__,
- m_minUndequeuedBufs, NUM_OF_PREVIEW_BUF - 1);
- }
- if (m_previewWindow->set_buffer_count(m_previewWindow, NUM_OF_PREVIEW_BUF) != 0) {
- ALOGE("ERR(%s):could not set buffer count", __func__);
- return INVALID_OPERATION;
- }
- int previewW, previewH;
- int hal_pixel_format = HAL_PIXEL_FORMAT_YV12;
- m_params.getPreviewSize(&previewW, &previewH);
- const char *str_preview_format = m_params.getPreviewFormat();
- ALOGV("DEBUG(%s):str preview format %s width : %d height : %d ", __func__, str_preview_format, previewW, previewH);
- if (!strcmp(str_preview_format,
- CameraParameters::PIXEL_FORMAT_RGB565)) {
- hal_pixel_format = HAL_PIXEL_FORMAT_RGB_565;
- } else if (!strcmp(str_preview_format,
- CameraParameters::PIXEL_FORMAT_RGBA8888)) {
- hal_pixel_format = HAL_PIXEL_FORMAT_RGBA_8888;
- } else if (!strcmp(str_preview_format,
- CameraParameters::PIXEL_FORMAT_YUV420SP)) {
- hal_pixel_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
- } else if (!strcmp(str_preview_format,
- CameraParameters::PIXEL_FORMAT_YUV420P))
- hal_pixel_format = HAL_PIXEL_FORMAT_YV12;
- if (m_previewWindow->set_usage(m_previewWindow,
- GRALLOC_USAGE_SW_WRITE_OFTEN |
- #ifdef USE_EGL
- #else
- GRALLOC_USAGE_HWC_HWOVERLAY |
- #endif
- GRALLOC_USAGE_HW_ION) != 0) {
- ALOGE("ERR(%s):could not set usage on gralloc buffer", __func__);
- return INVALID_OPERATION;
- }
- if (m_previewWindow->set_buffers_geometry(m_previewWindow,
- previewW, previewH,
- hal_pixel_format) != 0) {
- ALOGE("ERR(%s):could not set buffers geometry to %s",
- __func__, str_preview_format);
- return INVALID_OPERATION;
- }
- if (m_previewRunning == true && m_previewStartDeferred == true) {
- ALOGV("DEBUG(%s):start/resume preview", __func__);
- if (m_startPreviewInternal() == true) {
- m_previewStartDeferred = false;
- m_previewCondition.signal();
- }
- }
- m_previewLock.unlock();
- return OK;
- }
- void ExynosCameraHWInterface::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)
- {
- m_notifyCb = notify_cb;
- m_dataCb = data_cb;
- m_dataCbTimestamp = data_cb_timestamp;
- m_getMemoryCb = get_memory;
- m_callbackCookie = user;
- }
- void ExynosCameraHWInterface::enableMsgType(int32_t msgType)
- {
- ALOGV("DEBUG(%s):msgType = 0x%x, m_msgEnabled before = 0x%x",
- __func__, msgType, m_msgEnabled);
- m_msgEnabled |= msgType;
- m_previewLock.lock();
- if ( msgType & CAMERA_MSG_PREVIEW_FRAME
- && m_previewRunning == true
- && m_previewStartDeferred == true) {
- ALOGV("DEBUG(%s):starting deferred preview", __func__);
- if (m_startPreviewInternal() == true) {
- m_previewStartDeferred = false;
- m_previewCondition.signal();
- }
- }
- m_previewLock.unlock();
- ALOGV("DEBUG(%s):m_msgEnabled = 0x%x", __func__, m_msgEnabled);
- }
- void ExynosCameraHWInterface::disableMsgType(int32_t msgType)
- {
- ALOGV("DEBUG(%s):msgType = 0x%x, m_msgEnabled before = 0x%x",
- __func__, msgType, m_msgEnabled);
- m_msgEnabled &= ~msgType;
- ALOGV("DEBUG(%s):m_msgEnabled = 0x%x", __func__, m_msgEnabled);
- }
- bool ExynosCameraHWInterface::msgTypeEnabled(int32_t msgType)
- {
- return (m_msgEnabled & msgType);
- }
- status_t ExynosCameraHWInterface::startPreview()
- {
- int ret = OK;
- ALOGV("DEBUG(%s):", __func__);
- Mutex::Autolock lock(m_stateLock);
- if (m_captureInProgress == true) {
- ALOGE("%s : capture in progress, not allowed", __func__);
- return INVALID_OPERATION;
- }
- m_previewLock.lock();
- if (m_previewRunning == true) {
- ALOGE("%s : preview thread already running", __func__);
- m_previewLock.unlock();
- return INVALID_OPERATION;
- }
- m_previewRunning = true;
- m_previewStartDeferred = false;
- if (m_previewWindow == NULL) {
- if (!(m_msgEnabled & CAMERA_MSG_PREVIEW_FRAME)) {
- ALOGV("DEBUG(%s):deferring", __func__);
- m_previewStartDeferred = true;
- m_previewLock.unlock();
- return NO_ERROR;
- }
- ALOGE("%s(%d): m_previewWindow is NULL", __func__, __LINE__);
- return UNKNOWN_ERROR;
- }
- if (m_startPreviewInternal() == true) {
- m_previewCondition.signal();
- ret = OK;
- } else {
- ret = UNKNOWN_ERROR;
- }
- m_previewLock.unlock();
- return ret;
- }
- void ExynosCameraHWInterface::stopPreview()
- {
- ALOGV("DEBUG(%s):", __func__);
- /* request that the preview thread stop. */
- m_previewLock.lock();
- m_stopPreviewInternal();
- m_previewLock.unlock();
- }
- bool ExynosCameraHWInterface::previewEnabled()
- {
- Mutex::Autolock lock(m_previewLock);
- ALOGV("DEBUG(%s):%d", __func__, m_previewRunning);
- return m_previewRunning;
- }
- status_t ExynosCameraHWInterface::storeMetaDataInBuffers(bool enable)
- {
- if (!enable) {
- ALOGE("Non-m_frameMetadata buffer mode is not supported!");
- return INVALID_OPERATION;
- }
- return OK;
- }
- status_t ExynosCameraHWInterface::startRecording()
- {
- ALOGV("DEBUG(%s):", __func__);
- Mutex::Autolock lock(m_videoLock);
- int videoW, videoH, videoFormat, videoFramesize;
- m_secCamera->getVideoSize(&videoW, &videoH);
- videoFormat = m_secCamera->getVideoFormat();
- videoFramesize = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(videoFormat), videoW, videoH);
- int orgVideoFrameSize = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(videoFormat), m_orgVideoRect.w, m_orgVideoRect.h);
- for (int i = 0; i < NUM_OF_VIDEO_BUF; i++) {
- #ifdef USE_3DNR_DMAOUT
- ExynosBuffer videoBuf;
- if (m_videoHeap[i] != NULL) {
- m_videoHeap[i]->release(m_videoHeap[i]);
- m_videoHeap[i] = 0;
- }
- m_videoHeap[i] = m_getMemoryCb(-1, videoFramesize, 1, NULL);
- if (!m_videoHeap[i]) {
- ALOGE("ERR(%s):m_getMemoryCb(m_videoHeap[%d], size(%d) fail", __func__, i, videoFramesize);
- return UNKNOWN_ERROR;
- }
- m_getAlignedYUVSize(videoFormat, videoW, videoH, &videoBuf);
- videoBuf.virt.extP[0] = (char *)m_videoHeap[i]->data;
- for (int j = 1; j < 3; j++) {
- if (videoBuf.size.extS[j] != 0)
- videoBuf.virt.extP[j] = videoBuf.virt.extP[j-1] + videoBuf.size.extS[j-1];
- else
- videoBuf.virt.extP[j] = NULL;
- }
- videoBuf.reserved.p = i;
- m_secCamera->setVideoBuf(&videoBuf);
- #endif
- // original VideoSized heap
- if (m_resizedVideoHeap[i] != NULL) {
- m_resizedVideoHeap[i]->release(m_resizedVideoHeap[i]);
- m_resizedVideoHeap[i] = 0;
- }
- m_resizedVideoHeap[i] = m_getMemoryCb(-1, orgVideoFrameSize, 1, NULL);
- if (!m_resizedVideoHeap[i]) {
- ALOGE("ERR(%s):m_getMemoryCb(m_resizedVideoHeap[%d], size(%d) fail", __func__, i, orgVideoFrameSize);
- return UNKNOWN_ERROR;
- }
- }
- if (m_videoRunning == false) {
- if (m_secCamera->startVideo() == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->startVideo()", __func__);
- return UNKNOWN_ERROR;
- }
- m_numOfAvailableVideoBuf = NUM_OF_VIDEO_BUF;
- #ifdef USE_3DNR_DMAOUT
- m_videoRunning = true;
- m_videoCondition.signal();
- #else
- m_videoStart = true;
- #endif
- }
- return NO_ERROR;
- }
- void ExynosCameraHWInterface::stopRecording()
- {
- ALOGV("DEBUG(%s):", __func__);
- #ifndef USE_3DNR_DMAOUT
- m_videoStart = false;
- #endif
- if (m_videoRunning == true) {
- m_videoRunning = false;
- Mutex::Autolock lock(m_videoLock);
- m_videoCondition.signal();
- /* wait until video thread is stopped */
- m_videoStoppedCondition.wait(m_videoLock);
- } else
- ALOGV("DEBUG(%s):video not running, doing nothing", __func__);
- }
- bool ExynosCameraHWInterface::recordingEnabled()
- {
- return m_videoStart;
- }
- void ExynosCameraHWInterface::releaseRecordingFrame(const void *opaque)
- {
- // This lock makes video lock up
- // Mutex::Autolock lock(m_videoLock);
- int i;
- bool find = false;
- // HACK : this causes recording slow
- /*
- for (i = 0; i < NUM_OF_VIDEO_BUF; i++) {
- if ((char *)m_videoHeap[i]->data == (char *)opaque) {
- find = true;
- break;
- }
- }
- if (find == true) {
- ExynosBuffer videoBuf;
- videoBuf.reserved.p = i;
- m_secCamera->putVideoBuf(&videoBuf);
- m_numOfAvailableVideoBuf++;
- if (NUM_OF_VIDEO_BUF <= m_numOfAvailableVideoBuf)
- m_numOfAvailableVideoBuf = NUM_OF_VIDEO_BUF;
- } else {
- ALOGV("DEBUG(%s):no matched index(%p)", __func__, (char *)opaque);
- }
- */
- }
- status_t ExynosCameraHWInterface::autoFocus()
- {
- ALOGV("DEBUG(%s):", __func__);
- /* signal m_autoFocusThread to run once */
- m_focusCondition.signal();
- return NO_ERROR;
- }
- status_t ExynosCameraHWInterface::cancelAutoFocus()
- {
- if (m_secCamera->cancelAutoFocus() == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->cancelAutoFocus()", __func__);
- return UNKNOWN_ERROR;
- }
- return NO_ERROR;
- }
- status_t ExynosCameraHWInterface::takePicture()
- {
- Mutex::Autolock lock(m_stateLock);
- if (m_captureInProgress == true) {
- ALOGE("%s : capture already in progress", __func__);
- return INVALID_OPERATION;
- }
- if (m_pictureRunning == false) {
- ALOGI("%s(%d): m_pictureRunning is false", __func__, __LINE__);
- if (m_startPictureInternal() == false) {
- ALOGE("%s(%d): m_startPictureInternal() fail!!!", __func__, __LINE__);
- return INVALID_OPERATION;
- }
- }
- m_pictureLock.lock();
- m_captureInProgress = true;
- m_pictureLock.unlock();
- if (m_pictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
- ALOGE("%s : couldn't run picture thread", __func__);
- return INVALID_OPERATION;
- }
- return NO_ERROR;
- }
- status_t ExynosCameraHWInterface::cancelPicture()
- {
- ALOGV("DEBUG(%s):", __func__);
- if (m_pictureThread.get()) {
- ALOGV("DEBUG(%s):waiting for picture thread to exit", __func__);
- m_pictureThread->requestExitAndWait();
- ALOGV("DEBUG(%s):picture thread has exited", __func__);
- }
- return NO_ERROR;
- }
- status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
- {
- ALOGV("DEBUG(%s):", __func__);
- status_t ret = NO_ERROR;
- /* if someone calls us while picture thread is running, it could screw
- * up the sensor quite a bit so return error. we can't wait because
- * that would cause deadlock with the callbacks
- */
- m_stateLock.lock();
- if (m_captureInProgress == true) {
- m_stateLock.unlock();
- m_pictureLock.lock();
- m_pictureCondition.waitRelative(m_pictureLock, (2000 * 1000000));
- m_pictureLock.unlock();
- }
- m_stateLock.unlock();
- ///////////////////////////////////////////////////
- // Google Official API : Camera.Parameters
- // http://developer.android.com/reference/android/hardware/Camera.Parameters.html
- ///////////////////////////////////////////////////
- // recording hint
- const char *newRecordingHint = params.get(CameraParameters::KEY_RECORDING_HINT);
- if (newRecordingHint != NULL) {
- if (strcmp(newRecordingHint, "true") == 0)
- m_recordingHint = true;
- else
- m_recordingHint = false;
- m_secCamera->setRecordingHint(m_recordingHint);
- }
- // preview size
- int newPreviewW = 0;
- int newPreviewH = 0;
- int newCalPreviewW = 0;
- int newCalPreviewH = 0;
- int previewMaxW = 0;
- int previewMaxH = 0;
- params.getPreviewSize(&newPreviewW, &newPreviewH);
- // In general, it will show preview max size
- m_secCamera->getSupportedPreviewSizes(&previewMaxW, &previewMaxH);
- newCalPreviewW = previewMaxW;
- newCalPreviewH = previewMaxH;
- // When recording, it will show video max size
- if (m_recordingHint == true) {
- m_secCamera->getSupportedVideoSizes(&newCalPreviewW, &newCalPreviewH);
- if ( previewMaxW < newCalPreviewW
- || previewMaxH < newCalPreviewH) {
- newCalPreviewW = previewMaxW;
- newCalPreviewH = previewMaxH;
- }
- }
- m_orgPreviewRect.w = newPreviewW;
- m_orgPreviewRect.h = newPreviewH;
- // TODO : calibrate original preview ratio
- //m_getRatioSize(newCalPreviewW, newCalPreviewH, newPreviewW, newPreviewH, &newPreviewW, &newPreviewH);
- newPreviewW = newCalPreviewW;
- newPreviewH = newCalPreviewH;
- const char *strNewPreviewFormat = params.getPreviewFormat();
- ALOGV("DEBUG(%s):newPreviewW x newPreviewH = %dx%d, format = %s",
- __func__, newPreviewW, newPreviewH, strNewPreviewFormat);
- if (0 < newPreviewW &&
- 0 < newPreviewH &&
- strNewPreviewFormat != NULL &&
- m_isSupportedPreviewSize(newPreviewW, newPreviewH) == true) {
- int newPreviewFormat = 0;
- if (!strcmp(strNewPreviewFormat, CameraParameters::PIXEL_FORMAT_RGB565))
- newPreviewFormat = V4L2_PIX_FMT_RGB565;
- else if (!strcmp(strNewPreviewFormat, CameraParameters::PIXEL_FORMAT_RGBA8888))
- newPreviewFormat = V4L2_PIX_FMT_RGB32;
- else if (!strcmp(strNewPreviewFormat, CameraParameters::PIXEL_FORMAT_YUV420SP))
- newPreviewFormat = V4L2_PIX_FMT_NV21;
- else if (!strcmp(strNewPreviewFormat, CameraParameters::PIXEL_FORMAT_YUV420P))
- newPreviewFormat = V4L2_PIX_FMT_YVU420M;
- else if (!strcmp(strNewPreviewFormat, "yuv420sp_custom"))
- newPreviewFormat = V4L2_PIX_FMT_NV12T;
- else if (!strcmp(strNewPreviewFormat, "yuv422i"))
- newPreviewFormat = V4L2_PIX_FMT_YUYV;
- else if (!strcmp(strNewPreviewFormat, "yuv422p"))
- newPreviewFormat = V4L2_PIX_FMT_YUV422P;
- else
- newPreviewFormat = V4L2_PIX_FMT_NV21; //for 3rd party
- m_orgPreviewRect.colorFormat = newPreviewFormat;
- int curPreviewW, curPreviewH;
- m_secCamera->getPreviewSize(&curPreviewW, &curPreviewH);
- int curPreviewFormat = m_secCamera->getPreviewFormat();
- if (curPreviewW != newPreviewW ||
- curPreviewH != newPreviewH ||
- curPreviewFormat != newPreviewFormat) {
- if ( m_secCamera->setPreviewSize(newPreviewW, newPreviewH) == false
- || m_secCamera->setPreviewFormat(newPreviewFormat) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setPreviewSize(width(%d), height(%d), format(%d))",
- __func__, newPreviewW, newPreviewH, newPreviewFormat);
- ret = UNKNOWN_ERROR;
- } else {
- if (m_previewWindow) {
- if (m_previewRunning == true && m_previewStartDeferred == false) {
- ALOGE("ERR(%s):preview is running, cannot change size and format!", __func__);
- ret = INVALID_OPERATION;
- }
- ALOGV("DEBUG(%s):m_previewWindow (%p) set_buffers_geometry", __func__, m_previewWindow);
- ALOGV("DEBUG(%s):m_previewWindow->set_buffers_geometry (%p)", __func__,
- m_previewWindow->set_buffers_geometry);
- m_previewWindow->set_buffers_geometry(m_previewWindow,
- newPreviewW, newPreviewH,
- newPreviewFormat);
- ALOGV("DEBUG(%s):DONE m_previewWindow (%p) set_buffers_geometry", __func__, m_previewWindow);
- }
- m_params.setPreviewSize(newPreviewW, newPreviewH);
- m_params.setPreviewFormat(strNewPreviewFormat);
- }
- }
- else {
- ALOGV("DEBUG(%s):preview size and format has not changed", __func__);
- }
- } else {
- ALOGE("ERR(%s):Invalid preview size(%dx%d)", __func__, newPreviewW, newPreviewH);
- ret = INVALID_OPERATION;
- }
- int newPictureW = 0;
- int newPictureH = 0;
- params.getPictureSize(&newPictureW, &newPictureH);
- ALOGV("DEBUG(%s):newPictureW x newPictureH = %dx%d", __func__, newPictureW, newPictureH);
- if (0 < newPictureW && 0 < newPictureH) {
- int orgPictureW, orgPictureH = 0;
- m_secCamera->getPictureSize(&orgPictureW, &orgPictureH);
- if (m_secCamera->setPictureSize(newPictureW, newPictureH) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setPictureSize(width(%d), height(%d))",
- __func__, newPictureW, newPictureH);
- ret = UNKNOWN_ERROR;
- } else {
- int tempW, tempH = 0;
- m_secCamera->getPictureSize(&tempW, &tempH);
- if (tempW != orgPictureW || tempH != orgPictureH) {
- if (m_pictureRunning == true) {
- if (m_stopPictureInternal() == false)
- ALOGE("ERR(%s):m_stopPictureInternal() fail", __func__);
- if (m_startPictureInternal() == false)
- ALOGE("ERR(%s):m_startPictureInternal() fail", __func__);
- }
- }
- m_orgPictureRect.w = newPictureW;
- m_orgPictureRect.h = newPictureH;
- m_params.setPictureSize(newPictureW, newPictureH);
- }
- }
- // picture format
- const char *newPictureFormat = params.getPictureFormat();
- ALOGV("DEBUG(%s):newPictureFormat %s", __func__, newPictureFormat);
- if (newPictureFormat != NULL) {
- int value = 0;
- if (!strcmp(newPictureFormat, CameraParameters::PIXEL_FORMAT_RGB565))
- value = V4L2_PIX_FMT_RGB565;
- else if (!strcmp(newPictureFormat, CameraParameters::PIXEL_FORMAT_RGBA8888))
- value = V4L2_PIX_FMT_RGB32;
- else if (!strcmp(newPictureFormat, CameraParameters::PIXEL_FORMAT_YUV420SP))
- value = V4L2_PIX_FMT_NV21;
- else if (!strcmp(newPictureFormat, "yuv420sp_custom"))
- value = V4L2_PIX_FMT_NV12T;
- else if (!strcmp(newPictureFormat, "yuv420p"))
- value = V4L2_PIX_FMT_YUV420;
- else if (!strcmp(newPictureFormat, "yuv422i"))
- value = V4L2_PIX_FMT_YUYV;
- else if (!strcmp(newPictureFormat, "uyv422i_custom")) //Zero copy UYVY format
- value = V4L2_PIX_FMT_UYVY;
- else if (!strcmp(newPictureFormat, "uyv422i")) //Non-zero copy UYVY format
- value = V4L2_PIX_FMT_UYVY;
- else if (!strcmp(newPictureFormat, CameraParameters::PIXEL_FORMAT_JPEG))
- value = V4L2_PIX_FMT_YUYV;
- else if (!strcmp(newPictureFormat, "yuv422p"))
- value = V4L2_PIX_FMT_YUV422P;
- else
- value = V4L2_PIX_FMT_NV21; //for 3rd party
- if (value != m_secCamera->getPictureFormat()) {
- if (m_secCamera->setPictureFormat(value) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setPictureFormat(format(%d))", __func__, value);
- ret = UNKNOWN_ERROR;
- } else {
- m_orgPictureRect.colorFormat = value;
- m_params.setPictureFormat(newPictureFormat);
- }
- }
- }
- // JPEG image quality
- int newJpegQuality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
- ALOGV("DEBUG(%s):newJpegQuality %d", __func__, newJpegQuality);
- // we ignore bad values
- if (newJpegQuality >=1 && newJpegQuality <= 100) {
- if (m_secCamera->setJpegQuality(newJpegQuality) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setJpegQuality(quality(%d))", __func__, newJpegQuality);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_JPEG_QUALITY, newJpegQuality);
- }
- }
- // JPEG thumbnail size
- int newJpegThumbnailW = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
- int newJpegThumbnailH = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
- if (0 <= newJpegThumbnailW && 0 <= newJpegThumbnailH) {
- if (m_secCamera->setJpegThumbnailSize(newJpegThumbnailW, newJpegThumbnailH) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, newJpegThumbnailW, newJpegThumbnailH);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, newJpegThumbnailW);
- m_params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, newJpegThumbnailH);
- }
- }
- // JPEG thumbnail quality
- int newJpegThumbnailQuality = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
- ALOGV("DEBUG(%s):newJpegThumbnailQuality %d", __func__, newJpegThumbnailQuality);
- // we ignore bad values
- if (newJpegThumbnailQuality >=1 && newJpegThumbnailQuality <= 100) {
- if (m_secCamera->setJpegThumbnailQuality(newJpegThumbnailQuality) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setJpegThumbnailQuality(quality(%d))",
- __func__, newJpegThumbnailQuality);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, newJpegThumbnailQuality);
- }
- }
- // Video size
- int newVideoW = 0;
- int newVideoH = 0;
- params.getVideoSize(&newVideoW, &newVideoH);
- ALOGV("DEBUG(%s):newVideoW (%d) newVideoH (%d)", __func__, newVideoW, newVideoH);
- if (0 < newVideoW && 0 < newVideoH && m_videoStart == false) {
- m_orgVideoRect.w = newVideoW;
- m_orgVideoRect.h = newVideoH;
- if (m_secCamera->setVideoSize(newVideoW, newVideoH) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setVideoSize(width(%d), height(%d))",
- __func__, newVideoW, newVideoH);
- ret = UNKNOWN_ERROR;
- }
- m_params.setVideoSize(newVideoW, newVideoH);
- }
- // video stablization
- const char *newVideoStabilization = params.get(CameraParameters::KEY_VIDEO_STABILIZATION);
- bool currVideoStabilization = m_secCamera->getVideoStabilization();
- ALOGV("DEBUG(%s):newVideoStabilization %s", __func__, newVideoStabilization);
- if (newVideoStabilization != NULL) {
- bool toggle = false;
- if (!strcmp(newVideoStabilization, "true"))
- toggle = true;
- if ( currVideoStabilization != toggle) {
- if (m_secCamera->setVideoStabilization(toggle) == false) {
- ALOGE("ERR(%s):setVideoStabilization() fail", __func__);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_VIDEO_STABILIZATION, newVideoStabilization);
- }
- }
- }
- // 3dnr
- const char *new3dnr = params.get("3dnr");
- ALOGV("DEBUG(%s):new3drn %s", __func__, new3dnr);
- if (new3dnr != NULL) {
- bool toggle = false;
- if (!strcmp(new3dnr, "true"))
- toggle = true;
- if (m_secCamera->set3DNR(toggle) == false) {
- ALOGE("ERR(%s):set3DNR() fail", __func__);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set("3dnr", new3dnr);
- }
- }
- // odc
- const char *newOdc = params.get("odc");
- ALOGV("DEBUG(%s):newOdc %s", __func__, new3dnr);
- if (newOdc != NULL) {
- bool toggle = false;
- if (!strcmp(newOdc, "true"))
- toggle = true;
- if (m_secCamera->setODC(toggle) == false) {
- ALOGE("ERR(%s):setODC() fail", __func__);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set("odc", newOdc);
- }
- }
- // frame rate
- int newFrameRate = params.getPreviewFrameRate();
- ALOGV("DEBUG(%s):newFrameRate %d", __func__, newFrameRate);
- // ignore any fps request, we're determine fps automatically based
- // on scene mode. don't return an error because it causes CTS failure.
- if (newFrameRate != m_params.getPreviewFrameRate()) {
- if (m_secCamera->setPreviewFrameRate(newFrameRate) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setPreviewFrameRate(%d)", __func__, newFrameRate);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.setPreviewFrameRate(newFrameRate);
- }
- }
- // zoom
- int newZoom = params.getInt(CameraParameters::KEY_ZOOM);
- ALOGV("DEBUG(%s):newZoom %d", __func__, newZoom);
- if (0 <= newZoom) {
- if (m_secCamera->setZoom(newZoom) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setZoom(newZoom(%d))", __func__, newZoom);
- ret = UNKNOWN_ERROR;
- }
- else {
- m_params.set(CameraParameters::KEY_ZOOM, newZoom);
- }
- }
- // rotation
- int newRotation = params.getInt(CameraParameters::KEY_ROTATION);
- ALOGV("DEBUG(%s):newRotation %d", __func__, newRotation);
- if (0 <= newRotation) {
- ALOGV("DEBUG(%s):set orientation:%d", __func__, newRotation);
- if (m_secCamera->setRotation(newRotation) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setRotation(%d)", __func__, newRotation);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_ROTATION, newRotation);
- }
- }
- // auto exposure lock
- const char *newAutoExposureLock = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
- if (newAutoExposureLock != NULL) {
- bool toggle = false;
- if (!strcmp(newAutoExposureLock, "true"))
- toggle = true;
- if (m_secCamera->setAutoExposureLock(toggle) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setAutoExposureLock()", __func__);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, newAutoExposureLock);
- }
- }
- // exposure
- int minExposureCompensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
- int maxExposureCompensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
- int newExposureCompensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
- ALOGV("DEBUG(%s):newExposureCompensation %d", __func__, newExposureCompensation);
- if ((minExposureCompensation <= newExposureCompensation) &&
- (newExposureCompensation <= maxExposureCompensation)) {
- if (m_secCamera->setExposureCompensation(newExposureCompensation) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setExposureCompensation(exposure(%d))", __func__, newExposureCompensation);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, newExposureCompensation);
- }
- }
- // auto white balance lock
- const char *newAutoWhitebalanceLock = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
- if (newAutoWhitebalanceLock != NULL) {
- bool toggle = false;
- if (!strcmp(newAutoWhitebalanceLock, "true"))
- toggle = true;
- if (m_secCamera->setAutoWhiteBalanceLock(toggle) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setAutoWhiteBalanceLock()", __func__);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, newAutoWhitebalanceLock);
- }
- }
- // white balance
- const char *newWhiteBalance = params.get(CameraParameters::KEY_WHITE_BALANCE);
- ALOGV("DEBUG(%s):newWhiteBalance %s", __func__, newWhiteBalance);
- if (newWhiteBalance != NULL) {
- int value = -1;
- if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_AUTO))
- value = ExynosCamera::WHITE_BALANCE_AUTO;
- else if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_INCANDESCENT))
- value = ExynosCamera::WHITE_BALANCE_INCANDESCENT;
- else if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_FLUORESCENT))
- value = ExynosCamera::WHITE_BALANCE_FLUORESCENT;
- else if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT))
- value = ExynosCamera::WHITE_BALANCE_WARM_FLUORESCENT;
- else if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_DAYLIGHT))
- value = ExynosCamera::WHITE_BALANCE_DAYLIGHT;
- else if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT))
- value = ExynosCamera::WHITE_BALANCE_CLOUDY_DAYLIGHT;
- else if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_TWILIGHT))
- value = ExynosCamera::WHITE_BALANCE_TWILIGHT;
- else if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_SHADE))
- value = ExynosCamera::WHITE_BALANCE_SHADE;
- else {
- ALOGE("ERR(%s):Invalid white balance(%s)", __func__, newWhiteBalance); //twilight, shade, warm_flourescent
- ret = UNKNOWN_ERROR;
- }
- if (0 <= value) {
- if (m_secCamera->setWhiteBalance(value) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setWhiteBalance(white(%d))", __func__, value);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_WHITE_BALANCE, newWhiteBalance);
- }
- }
- }
- // Metering
- // This is the additional API(not Google API).
- // But, This is set berfore the below KEY_METERING_AREAS.
- const char *strNewMetering = params.get("metering");
- ALOGV("DEBUG(%s):strNewMetering %s", __func__, strNewMetering);
- if (strNewMetering != NULL) {
- int newMetering = -1;
- if (!strcmp(strNewMetering, "average"))
- newMetering = ExynosCamera::METERING_MODE_AVERAGE;
- else if (!strcmp(strNewMetering, "center"))
- newMetering = ExynosCamera::METERING_MODE_CENTER;
- else if (!strcmp(strNewMetering, "matrix"))
- newMetering = ExynosCamera::METERING_MODE_MATRIX;
- else if (!strcmp(strNewMetering, "spot"))
- newMetering = ExynosCamera::METERING_MODE_SPOT;
- else {
- ALOGE("ERR(%s):Invalid metering newMetering(%s)", __func__, strNewMetering);
- ret = UNKNOWN_ERROR;
- }
- if (0 <= newMetering) {
- if (m_secCamera->setMeteringMode(newMetering) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setMeteringMode(%d)", __func__, newMetering);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set("metering", strNewMetering);
- }
- }
- }
- // metering areas
- const char *newMeteringAreas = params.get(CameraParameters::KEY_METERING_AREAS);
- int maxNumMeteringAreas = m_secCamera->getMaxNumMeteringAreas();
- if (newMeteringAreas != NULL && maxNumMeteringAreas != 0) {
- // ex : (-10,-10,0,0,300),(0,0,10,10,700)
- ExynosRect2 *rect2s = new ExynosRect2[maxNumMeteringAreas];
- int *weights = new int[maxNumMeteringAreas];
- int validMeteringAreas = m_bracketsStr2Ints((char *)newMeteringAreas, maxNumMeteringAreas, rect2s, weights);
- if (0 < validMeteringAreas) {
- for (int i = 0; i < validMeteringAreas; i++) {
- rect2s[i].x1 = m_calibratePosition(2000, newPreviewW, rect2s[i].x1 + 1000);
- rect2s[i].y1 = m_calibratePosition(2000, newPreviewH, rect2s[i].y1 + 1000);
- rect2s[i].x2 = m_calibratePosition(2000, newPreviewW, rect2s[i].x2 + 1000);
- rect2s[i].y2 = m_calibratePosition(2000, newPreviewH, rect2s[i].y2 + 1000);
- }
- if (m_secCamera->setMeteringAreas(validMeteringAreas, rect2s, weights) == false) {
- ALOGE("ERR(%s):setMeteringAreas(%s) fail", __func__, newMeteringAreas);
- ret = UNKNOWN_ERROR;
- }
- else {
- m_params.set(CameraParameters::KEY_METERING_AREAS, newMeteringAreas);
- }
- }
- delete [] rect2s;
- delete [] weights;
- }
- // anti banding
- const char *newAntibanding = params.get(CameraParameters::KEY_ANTIBANDING);
- ALOGV("DEBUG(%s):newAntibanding %s", __func__, newAntibanding);
- if (newAntibanding != NULL) {
- int value = -1;
- if (!strcmp(newAntibanding, CameraParameters::ANTIBANDING_AUTO))
- value = ExynosCamera::ANTIBANDING_AUTO;
- else if (!strcmp(newAntibanding, CameraParameters::ANTIBANDING_50HZ))
- value = ExynosCamera::ANTIBANDING_50HZ;
- else if (!strcmp(newAntibanding, CameraParameters::ANTIBANDING_60HZ))
- value = ExynosCamera::ANTIBANDING_60HZ;
- else if (!strcmp(newAntibanding, CameraParameters::ANTIBANDING_OFF))
- value = ExynosCamera::ANTIBANDING_OFF;
- else {
- ALOGE("ERR(%s):Invalid antibanding value(%s)", __func__, newAntibanding);
- ret = UNKNOWN_ERROR;
- }
- if (0 <= value) {
- if (m_secCamera->setAntibanding(value) == false) {
- ALOGE("ERR(%s):Fail on m_secCamera->setAntibanding(%d)", __func__, value);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_ANTIBANDING, newAntibanding);
- }
- }
- }
- // scene mode
- const char *strNewSceneMode = params.get(CameraParameters::KEY_SCENE_MODE);
- const char *strCurSceneMode = m_params.get(CameraParameters::KEY_SCENE_MODE);
- // fps range
- int newMinFps = 0;
- int newMaxFps = 0;
- int curMinFps = 0;
- int curMaxFps = 0;
- params.getPreviewFpsRange(&newMinFps, &newMaxFps);
- m_params.getPreviewFpsRange(&curMinFps, &curMaxFps);
- /* our fps range is determined by the sensor, reject any request
- * that isn't exactly what we're already at.
- * but the check is performed when requesting only changing fps range
- */
- if (strNewSceneMode && strCurSceneMode) {
- if (!strcmp(strNewSceneMode, strCurSceneMode)) {
- if ((newMinFps != curMinFps) || (newMaxFps != curMaxFps)) {
- ALOGW("%s : requested newMinFps = %d, newMaxFps = %d not allowed",
- __func__, newMinFps, newMaxFps);
- ALOGE("%s : curMinFps = %d, curMaxFps = %d",
- __func__, curMinFps, curMaxFps);
- ret = UNKNOWN_ERROR;
- }
- }
- } else {
- /* Check basic validation if scene mode is different */
- if ((newMaxFps < newMinFps) ||
- (newMinFps < 0) || (newMaxFps < 0))
- ret = UNKNOWN_ERROR;
- }
- if (strNewSceneMode != NULL) {
- int newSceneMode = -1;
- const char *strNewFlashMode = params.get(CameraParameters::KEY_FLASH_MODE);
- const char *strNewFocusMode = params.get(CameraParameters::KEY_FOCUS_MODE);
- // fps range is (15000,30000) by default.
- m_params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
- m_params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000");
- if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_AUTO)) {
- newSceneMode = ExynosCamera::SCENE_MODE_AUTO;
- } else {
- // defaults for non-auto scene modes
- if (m_secCamera->getSupportedFocusModes() != 0)
- strNewFocusMode = CameraParameters::FOCUS_MODE_AUTO;
- strNewFlashMode = CameraParameters::FLASH_MODE_OFF;
- if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_ACTION)) {
- newSceneMode = ExynosCamera::SCENE_MODE_ACTION;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_PORTRAIT)) {
- newSceneMode = ExynosCamera::SCENE_MODE_PORTRAIT;
- strNewFlashMode = CameraParameters::FLASH_MODE_AUTO;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_LANDSCAPE)) {
- newSceneMode = ExynosCamera::SCENE_MODE_LANDSCAPE;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_NIGHT)) {
- newSceneMode = ExynosCamera::SCENE_MODE_NIGHT;
- m_params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(4000,30000)");
- m_params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "4000,30000");
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT)) {
- newSceneMode = ExynosCamera::SCENE_MODE_NIGHT_PORTRAIT;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_THEATRE)) {
- newSceneMode = ExynosCamera::SCENE_MODE_THEATRE;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_BEACH)) {
- newSceneMode = ExynosCamera::SCENE_MODE_BEACH;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_SNOW)) {
- newSceneMode = ExynosCamera::SCENE_MODE_SNOW;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_SUNSET)) {
- newSceneMode = ExynosCamera::SCENE_MODE_SUNSET;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO)) {
- newSceneMode = ExynosCamera::SCENE_MODE_STEADYPHOTO;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_FIREWORKS)) {
- newSceneMode = ExynosCamera::SCENE_MODE_FIREWORKS;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_SPORTS)) {
- newSceneMode = ExynosCamera::SCENE_MODE_SPORTS;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_PARTY)) {
- newSceneMode = ExynosCamera::SCENE_MODE_PARTY;
- strNewFlashMode = CameraParameters::FLASH_MODE_AUTO;
- } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT)) {
- newSceneMode = ExynosCamera::SCENE_MODE_CANDLELIGHT;
- } else {
- ALOGE("ERR(%s):unmatched scene_mode(%s)",
- __func__, strNewSceneMode); //action, night-portrait, theatre, steadyphoto
- ret = UNKNOWN_ERROR;
- }
- }
- // focus mode
- if (strNewFocusMode != NULL) {
- int newFocusMode = -1;
- if (!strcmp(strNewFocusMode, CameraParameters::FOCUS_MODE_AUTO)) {
- newFocusMode = ExynosCamera::FOCUS_MODE_AUTO;
- m_params.set(CameraParameters::KEY_FOCUS_DISTANCES,
- BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
- } else if (!strcmp(strNewFocusMode, CameraParameters::FOCUS_MODE_INFINITY)) {
- newFocusMode = ExynosCamera::FOCUS_MODE_INFINITY;
- m_params.set(CameraParameters::KEY_FOCUS_DISTANCES,
- BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR);
- } else if (!strcmp(strNewFocusMode, CameraParameters::FOCUS_MODE_MACRO)) {
- newFocusMode = ExynosCamera::FOCUS_MODE_MACRO;
- m_params.set(CameraParameters::KEY_FOCUS_DISTANCES,
- BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR);
- } else if (!strcmp(strNewFocusMode, CameraParameters::FOCUS_MODE_FIXED)) {
- newFocusMode = ExynosCamera::FOCUS_MODE_FIXED;
- } else if (!strcmp(strNewFocusMode, CameraParameters::FOCUS_MODE_EDOF)) {
- newFocusMode = ExynosCamera::FOCUS_MODE_EDOF;
- } else if (!strcmp(strNewFocusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO)) {
- newFocusMode = ExynosCamera::FOCUS_MODE_CONTINUOUS_VIDEO;
- } else if (!strcmp(strNewFocusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)) {
- newFocusMode = ExynosCamera::FOCUS_MODE_CONTINUOUS_PICTURE;
- } else {
- ALOGE("ERR(%s):unmatched focus_mode(%s)", __func__, strNewFocusMode);
- ret = UNKNOWN_ERROR;
- }
- if (0 <= newFocusMode) {
- if (m_secCamera->setFocusMode(newFocusMode) == false) {
- ALOGE("ERR(%s):m_secCamera->setFocusMode(%d) fail", __func__, newFocusMode);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_FOCUS_MODE, strNewFocusMode);
- }
- }
- }
- // flash mode
- if (strNewFlashMode != NULL) {
- int newFlashMode = -1;
- if (!strcmp(strNewFlashMode, CameraParameters::FLASH_MODE_OFF))
- newFlashMode = ExynosCamera::FLASH_MODE_OFF;
- else if (!strcmp(strNewFlashMode, CameraParameters::FLASH_MODE_AUTO))
- newFlashMode = ExynosCamera::FLASH_MODE_AUTO;
- else if (!strcmp(strNewFlashMode, CameraParameters::FLASH_MODE_ON))
- newFlashMode = ExynosCamera::FLASH_MODE_ON;
- else if (!strcmp(strNewFlashMode, CameraParameters::FLASH_MODE_RED_EYE))
- newFlashMode = ExynosCamera::FLASH_MODE_RED_EYE;
- else if (!strcmp(strNewFlashMode, CameraParameters::FLASH_MODE_TORCH))
- newFlashMode = ExynosCamera::FLASH_MODE_TORCH;
- else {
- ALOGE("ERR(%s):unmatched flash_mode(%s)", __func__, strNewFlashMode); //red-eye
- ret = UNKNOWN_ERROR;
- }
- if (0 <= newFlashMode) {
- if (m_secCamera->setFlashMode(newFlashMode) == false) {
- ALOGE("ERR(%s):m_secCamera->setFlashMode(%d) fail", __func__, newFlashMode);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_FLASH_MODE, strNewFlashMode);
- }
- }
- }
- // scene mode
- if (0 <= newSceneMode) {
- if (m_secCamera->setSceneMode(newSceneMode) == false) {
- ALOGE("ERR(%s):m_secCamera->setSceneMode(%d) fail", __func__, newSceneMode);
- ret = UNKNOWN_ERROR;
- } else {
- m_params.set(CameraParameters::KEY_SCENE_MODE, strNewSceneMode);
- }
- }
- }
- // focus areas
- const char *newFocusAreas = params.get(CameraParameters::KEY_FOCUS_AREAS);
- int maxNumFocusAreas = m_secCamera->getMaxNumFocusAreas();
- if (newFocusAreas != NULL && maxNumFocusAreas != 0) {
- int curFocusMode = m_secCamera->getFocusMode();
- // In CameraParameters.h
- // Focus area only has effect if the cur focus mode is FOCUS_MODE_AUTO,
- // FOCUS_MODE_MACRO, FOCUS_MODE_CONTINUOUS_VIDEO, or
- // FOCUS_MODE_CONTINUOUS_PICTURE.
- if ( curFocusMode & ExynosCamera::FOCUS_MODE_AUTO
- …
Large files files are truncated, but you can click here to view the full file