From debcb84af11b06dd18695092727cdf8099fb557d Mon Sep 17 00:00:00 2001 From: rymate1234 Date: Sat, 14 Dec 2013 20:33:12 +0000 Subject: [PATCH] missed a spot Change-Id: I351e8035488b8064550a20e5845c7858b31b2197 --- libcamera/Android.mk | 2 - libcamera/QualcommCameraHardware.cpp | 714 +++++++++++++-------------- 2 files changed, 357 insertions(+), 359 deletions(-) diff --git a/libcamera/Android.mk b/libcamera/Android.mk index a7a4df6..e9c88bb 100644 --- a/libcamera/Android.mk +++ b/libcamera/Android.mk @@ -50,7 +50,5 @@ LOCAL_PRELINK_MODULE := false LOCAL_SHARED_LIBRARIES := liblog libdl libutils libcamera_client libbinder libcutils libhardware libui libcamera LOCAL_C_INCLUDES := frameworks/base/services/ frameworks/base/include LOCAL_C_INCLUDES += hardware/libhardware/include/ hardware -LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include -LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr include $(BUILD_SHARED_LIBRARY) diff --git a/libcamera/QualcommCameraHardware.cpp b/libcamera/QualcommCameraHardware.cpp index 740ebac..01ce3e2 100644 --- a/libcamera/QualcommCameraHardware.cpp +++ b/libcamera/QualcommCameraHardware.cpp @@ -554,7 +554,7 @@ static camera_antibanding_type camera_get_location(void) { } memcpy(country_value, value, 3); country_code = atoi(country_value); - ALOGD("value:%s, country value:%s, country code:%d\n", + LOGD("value:%s, country value:%s, country code:%d\n", value, country_value, country_code); int left = 0; int right = country_number - 1; @@ -701,11 +701,11 @@ static struct fifo_queue g_busy_frame_queue = static void cam_frame_wait_video (void) { - ALOGV("cam_frame_wait_video E "); + LOGV("cam_frame_wait_video E "); if ((g_busy_frame_queue.num_of_frames) <=0){ pthread_cond_wait(&(g_busy_frame_queue.wait), &(g_busy_frame_queue.mut)); } - ALOGV("cam_frame_wait_video X"); + LOGV("cam_frame_wait_video X"); return; } @@ -716,7 +716,7 @@ static void cam_frame_wait_video (void) * ===========================================================================*/ void cam_frame_flush_video (void) { - ALOGV("cam_frame_flush_video: in n = %d\n", g_busy_frame_queue.num_of_frames); + LOGV("cam_frame_flush_video: in n = %d\n", g_busy_frame_queue.num_of_frames); pthread_mutex_lock(&(g_busy_frame_queue.mut)); while (g_busy_frame_queue.front) @@ -726,10 +726,10 @@ void cam_frame_flush_video (void) if(node) free(node); - ALOGV("cam_frame_flush_video: node \n"); + LOGV("cam_frame_flush_video: node \n"); } pthread_mutex_unlock(&(g_busy_frame_queue.mut)); - ALOGV("cam_frame_flush_video: out n = %d\n", g_busy_frame_queue.num_of_frames); + LOGV("cam_frame_flush_video: out n = %d\n", g_busy_frame_queue.num_of_frames); return ; } /*=========================================================================== @@ -740,8 +740,8 @@ void cam_frame_flush_video (void) static struct msm_frame * cam_frame_get_video() { struct msm_frame *p = NULL; - ALOGV("cam_frame_get_video... in\n"); - ALOGV("cam_frame_get_video... got lock\n"); + LOGV("cam_frame_get_video... in\n"); + LOGV("cam_frame_get_video... got lock\n"); if (g_busy_frame_queue.front) { //dequeue @@ -751,7 +751,7 @@ static struct msm_frame * cam_frame_get_video() p = (struct msm_frame *)node->f; free (node); } - ALOGV("cam_frame_get_video... out = %x\n", p->buffer); + LOGV("cam_frame_get_video... out = %x\n", p->buffer); } return p; } @@ -765,31 +765,31 @@ static void cam_frame_post_video (struct msm_frame *p) { if (!p) { - ALOGE("post video , buffer is null"); + LOGE("post video , buffer is null"); return; } - ALOGV("cam_frame_post_video... in = %x\n", (unsigned int)(p->buffer)); + LOGV("cam_frame_post_video... in = %x\n", (unsigned int)(p->buffer)); pthread_mutex_lock(&(g_busy_frame_queue.mut)); - ALOGV("post_video got lock. q count before enQ %d", g_busy_frame_queue.num_of_frames); + LOGV("post_video got lock. q count before enQ %d", g_busy_frame_queue.num_of_frames); //enqueue to busy queue struct fifo_node *node = (struct fifo_node *)malloc (sizeof (struct fifo_node)); if (node) { - ALOGV(" post video , enqueing in busy queue"); + LOGV(" post video , enqueing in busy queue"); node->f = p; node->next = NULL; enqueue (&g_busy_frame_queue, node); - ALOGV("post_video got lock. q count after enQ %d", g_busy_frame_queue.num_of_frames); + LOGV("post_video got lock. q count after enQ %d", g_busy_frame_queue.num_of_frames); } else { - ALOGE("cam_frame_post_video error... out of memory\n"); + LOGE("cam_frame_post_video error... out of memory\n"); } pthread_mutex_unlock(&(g_busy_frame_queue.mut)); pthread_cond_signal(&(g_busy_frame_queue.wait)); - ALOGV("cam_frame_post_video... out = %x\n", p->buffer); + LOGV("cam_frame_post_video... out = %x\n", p->buffer); return; } @@ -805,7 +805,7 @@ void QualcommCameraHardware::storeTargetType(void) { } } mCurrentTarget = TARGET_MSM7627; - ALOGV(" Storing the current target type as %d ", mCurrentTarget ); + LOGV(" Storing the current target type as %d ", mCurrentTarget ); return; } @@ -889,7 +889,7 @@ QualcommCameraHardware::QualcommCameraHardware() // start the process here so it will be ready by the time it's // needed. if ((pthread_create(&w_thread, NULL, opencamerafd, NULL)) != 0) { - ALOGE("Camera open thread creation failed"); + LOGE("Camera open thread creation failed"); } memset(&mDimension, 0, sizeof(mDimension)); @@ -922,7 +922,7 @@ QualcommCameraHardware::QualcommCameraHardware() jpegPadding = 0; break; } - ALOGV("constructor EX"); + LOGV("constructor EX"); } @@ -972,7 +972,7 @@ void QualcommCameraHardware::filterPictureSizes(){ void QualcommCameraHardware::initDefaultParameters() { - ALOGV("initDefaultParameters E"); + LOGV("initDefaultParameters E"); // Initialize constant parameter strings. This will happen only once in the // lifetime of the mediaserver process. @@ -1135,14 +1135,14 @@ void QualcommCameraHardware::initDefaultParameters() (!strcmp(mSensorInfo.name, "vx6953")) || (!strcmp(mSensorInfo.name, "ov5642")) || (!strcmp(mSensorInfo.name, "VX6953")) ) { - ALOGI("Parameter Rolloff is not supported for this sensor"); + LOGI("Parameter Rolloff is not supported for this sensor"); } else { mParameters.set(CameraParameters::KEY_SUPPORTED_LENSSHADE_MODES, lensshade_values); } if (setParameters(mParameters) != NO_ERROR) { - ALOGE("Failed to set default parameters?!"); + LOGE("Failed to set default parameters?!"); } mUseOverlay = useOverlay(); @@ -1154,7 +1154,7 @@ void QualcommCameraHardware::initDefaultParameters() mInitialized = true; - ALOGV("initDefaultParameters X"); + LOGV("initDefaultParameters X"); } void QualcommCameraHardware::findSensorType(){ @@ -1173,7 +1173,7 @@ void QualcommCameraHardware::findSensorType(){ } } //default to 5 mp - ALOGD("Failed to find a match for %d x %d, using 5M default",mDimension.raw_picture_width,mDimension.raw_picture_height); + LOGD("Failed to find a match for %d x %d, using 5M default",mDimension.raw_picture_width,mDimension.raw_picture_height); sensorType = sensorTypes; return; } @@ -1182,16 +1182,16 @@ void QualcommCameraHardware::findSensorType(){ bool QualcommCameraHardware::startCamera() { - ALOGV("startCamera E"); + LOGV("startCamera E"); if( mCurrentTarget == TARGET_MAX ) { - ALOGE(" Unable to determine the target type. Camera will not work "); + LOGE(" Unable to determine the target type. Camera will not work "); return false; } #if DLOPEN_LIBMMCAMERA libmmcamera = ::dlopen("liboemcamera.so", RTLD_NOW); - ALOGV("loading liboemcamera at %p", libmmcamera); + LOGV("loading liboemcamera at %p", libmmcamera); if (!libmmcamera) { - ALOGE("FATAL ERROR: could not dlopen liboemcamera.so: %s", dlerror()); + LOGE("FATAL ERROR: could not dlopen liboemcamera.so: %s", dlerror()); return false; } @@ -1282,13 +1282,13 @@ bool QualcommCameraHardware::startCamera() /* The control thread is in libcamera itself. */ if (pthread_join(w_thread, NULL) != 0) { - ALOGE("Camera open thread exit failed"); + LOGE("Camera open thread exit failed"); return false; } mCameraControlFd = camerafd; if (mCameraControlFd < 0) { - ALOGE("startCamera X: %s open failed: %s!", + LOGE("startCamera X: %s open failed: %s!", MSM_CAMERA_CONTROL, strerror(errno)); return false; @@ -1297,7 +1297,7 @@ bool QualcommCameraHardware::startCamera() if( mCurrentTarget != TARGET_MSM7630 ){ fb_fd = open("/dev/graphics/fb0", O_RDWR); if (fb_fd < 0) { - ALOGE("startCamera: fb0 open failed: %s!", strerror(errno)); + LOGE("startCamera: fb0 open failed: %s!", strerror(errno)); return FALSE; } } @@ -1307,7 +1307,7 @@ bool QualcommCameraHardware::startCamera() */ if (LINK_launch_cam_conf_thread()) { - ALOGE("failed to launch the camera config thread"); + LOGE("failed to launch the camera config thread"); return false; } @@ -1315,18 +1315,18 @@ bool QualcommCameraHardware::startCamera() if (ioctl(mCameraControlFd, MSM_CAM_IOCTL_GET_SENSOR_INFO, &mSensorInfo) < 0) - ALOGW("%s: cannot retrieve sensor info!", __FUNCTION__); + LOGW("%s: cannot retrieve sensor info!", __FUNCTION__); else - ALOGI("%s: camsensor name %s, flash %d", __FUNCTION__, + LOGI("%s: camsensor name %s, flash %d", __FUNCTION__, mSensorInfo.name, mSensorInfo.flash_enabled); /* Disabling until support is available. picture_sizes = LINK_default_sensor_get_snapshot_sizes(&PICTURE_SIZE_COUNT); if (!picture_sizes || !PICTURE_SIZE_COUNT) { - ALOGE("startCamera X: could not get snapshot sizes"); + LOGE("startCamera X: could not get snapshot sizes"); return false; } */ - ALOGV("startCamera X"); + LOGV("startCamera X"); return true; } @@ -1371,7 +1371,7 @@ status_t QualcommCameraHardware::dump(int fd, static bool native_get_maxzoom(int camfd, void *pZm) { - ALOGV("native_get_maxzoom E"); + LOGV("native_get_maxzoom E"); struct msm_ctrl_cmd ctrlCmd; int32_t *pZoom = (int32_t *)pZm; @@ -1383,15 +1383,15 @@ static bool native_get_maxzoom(int camfd, void *pZm) ctrlCmd.resp_fd = camfd; if (ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd) < 0) { - ALOGE("native_get_maxzoom: ioctl fd %d error %s", + LOGE("native_get_maxzoom: ioctl fd %d error %s", camfd, strerror(errno)); return false; } - ALOGD("ctrlCmd.value = %d", *(int32_t *)ctrlCmd.value); + LOGD("ctrlCmd.value = %d", *(int32_t *)ctrlCmd.value); memcpy(pZoom, (int32_t *)ctrlCmd.value, sizeof(int32_t)); - ALOGV("native_get_maxzoom X"); + LOGV("native_get_maxzoom X"); return true; } @@ -1407,11 +1407,11 @@ static bool native_set_afmode(int camfd, isp3a_af_mode_t af_type) ctrlCmd.resp_fd = camfd; // FIXME: this will be put in by the kernel if ((rc = ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd)) < 0) - ALOGE("native_set_afmode: ioctl fd %d error %s\n", + LOGE("native_set_afmode: ioctl fd %d error %s\n", camfd, strerror(errno)); - ALOGV("native_set_afmode: ctrlCmd.status == %d\n", ctrlCmd.status); + LOGV("native_set_afmode: ctrlCmd.status == %d\n", ctrlCmd.status); return rc >= 0 && ctrlCmd.status == CAMERA_EXIT_CB_DONE; } @@ -1428,7 +1428,7 @@ static bool native_cancel_afmode(int camfd, int af_fd) if ((rc = ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND_2, &ctrlCmd)) < 0) { - ALOGE("native_cancel_afmode: ioctl fd %d error %s\n", + LOGE("native_cancel_afmode: ioctl fd %d error %s\n", camfd, strerror(errno)); return false; @@ -1447,7 +1447,7 @@ static bool native_start_preview(int camfd) ctrlCmd.resp_fd = camfd; // FIXME: this will be put in by the kernel if (ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd) < 0) { - ALOGE("native_start_preview: MSM_CAM_IOCTL_CTRL_COMMAND fd %d error %s", + LOGE("native_start_preview: MSM_CAM_IOCTL_CTRL_COMMAND fd %d error %s", camfd, strerror(errno)); return false; @@ -1465,23 +1465,23 @@ static bool native_get_picture (int camfd, common_crop_t *crop) ctrlCmd.value = crop; if(ioctl(camfd, MSM_CAM_IOCTL_GET_PICTURE, &ctrlCmd) < 0) { - ALOGE("native_get_picture: MSM_CAM_IOCTL_GET_PICTURE fd %d error %s", + LOGE("native_get_picture: MSM_CAM_IOCTL_GET_PICTURE fd %d error %s", camfd, strerror(errno)); return false; } - ALOGV("crop: in1_w %d", crop->in1_w); - ALOGV("crop: in1_h %d", crop->in1_h); - ALOGV("crop: out1_w %d", crop->out1_w); - ALOGV("crop: out1_h %d", crop->out1_h); + LOGV("crop: in1_w %d", crop->in1_w); + LOGV("crop: in1_h %d", crop->in1_h); + LOGV("crop: out1_w %d", crop->out1_w); + LOGV("crop: out1_h %d", crop->out1_h); - ALOGV("crop: in2_w %d", crop->in2_w); - ALOGV("crop: in2_h %d", crop->in2_h); - ALOGV("crop: out2_w %d", crop->out2_w); - ALOGV("crop: out2_h %d", crop->out2_h); + LOGV("crop: in2_w %d", crop->in2_w); + LOGV("crop: in2_h %d", crop->in2_h); + LOGV("crop: out2_w %d", crop->out2_w); + LOGV("crop: out2_h %d", crop->out2_h); - ALOGV("crop: update %d", crop->update_flag); + LOGV("crop: update %d", crop->update_flag); return true; } @@ -1495,7 +1495,7 @@ static bool native_stop_preview(int camfd) ctrlCmd.resp_fd = camfd; // FIXME: this will be put in by the kernel if(ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd) < 0) { - ALOGE("native_stop_preview: ioctl fd %d error %s", + LOGE("native_stop_preview: ioctl fd %d error %s", camfd, strerror(errno)); return false; @@ -1516,7 +1516,7 @@ static bool native_prepare_snapshot(int camfd) ctrlCmd.resp_fd = camfd; if (ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd) < 0) { - ALOGE("native_prepare_snapshot: ioctl fd %d error %s", + LOGE("native_prepare_snapshot: ioctl fd %d error %s", camfd, strerror(errno)); return false; @@ -1534,7 +1534,7 @@ static bool native_start_snapshot(int camfd) ctrlCmd.resp_fd = camfd; // FIXME: this will be put in by the kernel if(ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd) < 0) { - ALOGE("native_start_snapshot: ioctl fd %d error %s", + LOGE("native_start_snapshot: ioctl fd %d error %s", camfd, strerror(errno)); return false; @@ -1555,7 +1555,7 @@ static bool native_start_raw_snapshot(int camfd) ctrlCmd.resp_fd = camfd; if ((ret = ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd)) < 0) { - ALOGE("native_start_raw_snapshot: ioctl failed. ioctl return value "\ + LOGE("native_start_raw_snapshot: ioctl failed. ioctl return value "\ "is %d \n", ret); return false; } @@ -1573,7 +1573,7 @@ static bool native_stop_snapshot (int camfd) ctrlCmd.resp_fd = -1; if (ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND_2, &ctrlCmd) < 0) { - ALOGE("native_stop_snapshot: ioctl fd %d error %s", + LOGE("native_stop_snapshot: ioctl fd %d error %s", camfd, strerror(errno)); return false; @@ -1598,11 +1598,11 @@ static bool native_start_recording(int camfd) ctrlCmd.resp_fd = camfd; if ((ret = ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd)) < 0) { - ALOGE("native_start_recording: ioctl failed. ioctl return value "\ + LOGE("native_start_recording: ioctl failed. ioctl return value "\ "is %d \n", ret); return false; } - ALOGV("native_start_recording: ioctl good. ioctl return value is %d \n",ret); + LOGV("native_start_recording: ioctl good. ioctl return value is %d \n",ret); /* TODO: Check status of postprocessing if there is any, * PP status should be in ctrlCmd */ @@ -1619,7 +1619,7 @@ static bool native_stop_recording(int camfd) { int ret; struct msm_ctrl_cmd ctrlCmd; - ALOGV("in native_stop_recording "); + LOGV("in native_stop_recording "); ctrlCmd.timeout_ms = 1000; ctrlCmd.type = CAMERA_STOP_RECORDING; ctrlCmd.length = 0; @@ -1627,11 +1627,11 @@ static bool native_stop_recording(int camfd) ctrlCmd.resp_fd = camfd; if ((ret = ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd)) < 0) { - ALOGE("native_stop_video: ioctl failed. ioctl return value is %d \n", + LOGE("native_stop_video: ioctl failed. ioctl return value is %d \n", ret); return false; } - ALOGV("in native_stop_recording returned %d", ret); + LOGV("in native_stop_recording returned %d", ret); return true; } /*=========================================================================== @@ -1651,7 +1651,7 @@ static bool native_start_video(int camfd) ctrlCmd.resp_fd = camfd; if ((ret = ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd)) < 0) { - ALOGE("native_start_video: ioctl failed. ioctl return value is %d \n", + LOGE("native_start_video: ioctl failed. ioctl return value is %d \n", ret); return false; } @@ -1679,7 +1679,7 @@ static bool native_stop_video(int camfd) ctrlCmd.resp_fd = camfd; if ((ret = ioctl(camfd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd)) < 0) { - ALOGE("native_stop_video: ioctl failed. ioctl return value is %d \n", + LOGE("native_stop_video: ioctl failed. ioctl return value is %d \n", ret); return false; } @@ -1702,7 +1702,7 @@ static void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type, uint32_t count, uint8_t copy, void *data) { if(exif_table_numEntries == MAX_EXIF_TABLE_ENTRIES) { - ALOGE("Number of entries exceeded limit"); + LOGE("Number of entries exceeded limit"); return; } @@ -1821,29 +1821,29 @@ bool QualcommCameraHardware::native_jpeg_encode(void) { int jpeg_quality = mParameters.getInt("jpeg-quality"); if (jpeg_quality >= 0) { - ALOGV("native_jpeg_encode, current jpeg main img quality =%d", + LOGV("native_jpeg_encode, current jpeg main img quality =%d", jpeg_quality); if(!LINK_jpeg_encoder_setMainImageQuality(jpeg_quality)) { - ALOGE("native_jpeg_encode set jpeg-quality failed"); + LOGE("native_jpeg_encode set jpeg-quality failed"); return false; } } int thumbnail_quality = mParameters.getInt("jpeg-thumbnail-quality"); if (thumbnail_quality >= 0) { - ALOGV("native_jpeg_encode, current jpeg thumbnail quality =%d", + LOGV("native_jpeg_encode, current jpeg thumbnail quality =%d", thumbnail_quality); if(!LINK_jpeg_encoder_setThumbnailQuality(thumbnail_quality)) { - ALOGE("native_jpeg_encode set thumbnail-quality failed"); + LOGE("native_jpeg_encode set thumbnail-quality failed"); return false; } } int rotation = mParameters.getInt("rotation"); if (rotation >= 0) { - ALOGV("native_jpeg_encode, rotation = %d", rotation); + LOGV("native_jpeg_encode, rotation = %d", rotation); if(!LINK_jpeg_encoder_setRotation(rotation)) { - ALOGE("native_jpeg_encode set rotation failed"); + LOGE("native_jpeg_encode set rotation failed"); return false; } } @@ -1886,7 +1886,7 @@ bool QualcommCameraHardware::native_jpeg_encode(void) mRawHeap->mHeap->getHeapID(), &mCrop, exif_data, exif_table_numEntries, jpegPadding/2)) { - ALOGE("native_jpeg_encode: jpeg_encoder_encode failed."); + LOGE("native_jpeg_encode: jpeg_encoder_encode failed."); return false; } return true; @@ -1904,11 +1904,11 @@ bool QualcommCameraHardware::native_set_parm( ctrlCmd.resp_fd = mCameraControlFd; ctrlCmd.value = value; - ALOGV("%s: fd %d, type %d, length %d", __FUNCTION__, + LOGV("%s: fd %d, type %d, length %d", __FUNCTION__, mCameraControlFd, type, length); if (ioctl(mCameraControlFd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd) < 0 || ctrlCmd.status != CAM_CTRL_SUCCESS) { - ALOGE("%s: error (%s): fd %d, type %d, length %d, status %d", + LOGE("%s: error (%s): fd %d, type %d, length %d, status %d", __FUNCTION__, strerror(errno), mCameraControlFd, type, length, ctrlCmd.status); return false; @@ -1924,19 +1924,19 @@ void QualcommCameraHardware::jpeg_set_location() #define PARSE_LOCATION(what,type,fmt,desc) do { \ pt.what = 0; \ const char *what##_str = mParameters.get("gps-"#what); \ - ALOGV("GPS PARM %s --> [%s]", "gps-"#what, what##_str); \ + LOGV("GPS PARM %s --> [%s]", "gps-"#what, what##_str); \ if (what##_str) { \ type what = 0; \ if (sscanf(what##_str, fmt, &what) == 1) \ pt.what = what; \ else { \ - ALOGE("GPS " #what " %s could not" \ + LOGE("GPS " #what " %s could not" \ " be parsed as a " #desc, what##_str); \ encode_location = false; \ } \ } \ else { \ - ALOGV("GPS " #what " not specified: " \ + LOGV("GPS " #what " not specified: " \ "defaulting to zero in EXIF header."); \ encode_location = false; \ } \ @@ -1951,20 +1951,20 @@ void QualcommCameraHardware::jpeg_set_location() #undef PARSE_LOCATION if (encode_location) { - ALOGD("setting image location ALT %d LAT %lf LON %lf", + LOGD("setting image location ALT %d LAT %lf LON %lf", pt.altitude, pt.latitude, pt.longitude); /* Disabling until support is available. if (!LINK_jpeg_encoder_setLocation(&pt)) { - ALOGE("jpeg_set_location: LINK_jpeg_encoder_setLocation failed."); + LOGE("jpeg_set_location: LINK_jpeg_encoder_setLocation failed."); } */ } - else ALOGV("not setting image location"); + else LOGV("not setting image location"); } void QualcommCameraHardware::runFrameThread(void *data) { - ALOGV("runFrameThread E"); + LOGV("runFrameThread E"); int cnt; @@ -1974,9 +1974,9 @@ void QualcommCameraHardware::runFrameThread(void *data) // lifetime of this object. We do not want to dlclose() libqcamera while // LINK_cam_frame is still running. void *libhandle = ::dlopen("liboemcamera.so", RTLD_NOW); - ALOGV("FRAME: loading libqcamera at %p", libhandle); + LOGV("FRAME: loading libqcamera at %p", libhandle); if (!libhandle) { - ALOGE("FATAL ERROR: could not dlopen liboemcamera.so: %s", dlerror()); + LOGE("FATAL ERROR: could not dlopen liboemcamera.so: %s", dlerror()); } if (libhandle) #endif @@ -1991,7 +1991,7 @@ void QualcommCameraHardware::runFrameThread(void *data) #if DLOPEN_LIBMMCAMERA if (libhandle) { ::dlclose(libhandle); - ALOGV("FRAME: dlclose(libqcamera)"); + LOGV("FRAME: dlclose(libqcamera)"); } #endif @@ -2000,12 +2000,12 @@ void QualcommCameraHardware::runFrameThread(void *data) mFrameThreadWait.signal(); mFrameThreadWaitLock.unlock(); - ALOGV("runFrameThread X"); + LOGV("runFrameThread X"); } void QualcommCameraHardware::runVideoThread(void *data) { - ALOGD("runVideoThread E"); + LOGD("runVideoThread E"); msm_frame* vframe = NULL; while(true) { @@ -2014,23 +2014,23 @@ void QualcommCameraHardware::runVideoThread(void *data) // Exit the thread , in case of stop recording.. mVideoThreadWaitLock.lock(); if(mVideoThreadExit){ - ALOGV("Exiting video thread.."); + LOGV("Exiting video thread.."); mVideoThreadWaitLock.unlock(); pthread_mutex_unlock(&(g_busy_frame_queue.mut)); break; } mVideoThreadWaitLock.unlock(); - ALOGV("in video_thread : wait for video frame "); + LOGV("in video_thread : wait for video frame "); // check if any frames are available in busyQ and give callback to // services/video encoder cam_frame_wait_video(); - ALOGV("video_thread, wait over.."); + LOGV("video_thread, wait over.."); // Exit the thread , in case of stop recording.. mVideoThreadWaitLock.lock(); if(mVideoThreadExit){ - ALOGV("Exiting video thread.."); + LOGV("Exiting video thread.."); mVideoThreadWaitLock.unlock(); pthread_mutex_unlock(&(g_busy_frame_queue.mut)); break; @@ -2040,7 +2040,7 @@ void QualcommCameraHardware::runVideoThread(void *data) // Get the video frame to be encoded vframe = cam_frame_get_video (); pthread_mutex_unlock(&(g_busy_frame_queue.mut)); - ALOGV("in video_thread : got video frame "); + LOGV("in video_thread : got video frame "); if (UNLIKELY(mDebugFps)) { debugShowVideoFPS(); @@ -2048,10 +2048,10 @@ void QualcommCameraHardware::runVideoThread(void *data) if(vframe != NULL) { // Find the offset within the heap of the current buffer. - ALOGV("Got video frame : buffer %d base %d ", vframe->buffer, mRecordHeap->mHeap->base()); + LOGV("Got video frame : buffer %d base %d ", vframe->buffer, mRecordHeap->mHeap->base()); ssize_t offset = (ssize_t)vframe->buffer - (ssize_t)mRecordHeap->mHeap->base(); - ALOGV("offset = %d , alignsize = %d , offset later = %d", offset, mRecordHeap->mAlignedBufferSize, (offset / mRecordHeap->mAlignedBufferSize)); + LOGV("offset = %d , alignsize = %d , offset later = %d", offset, mRecordHeap->mAlignedBufferSize, (offset / mRecordHeap->mAlignedBufferSize)); offset /= mRecordHeap->mAlignedBufferSize; @@ -2062,9 +2062,9 @@ void QualcommCameraHardware::runVideoThread(void *data) char buf[128]; sprintf(buf, "/data/%d_v.yuv", frameCnt); int file_fd = open(buf, O_RDWR | O_CREAT, 0777); - ALOGV("dumping video frame %d", frameCnt); + LOGV("dumping video frame %d", frameCnt); if (file_fd < 0) { - ALOGE("cannot open file\n"); + LOGE("cannot open file\n"); } else { @@ -2077,7 +2077,7 @@ void QualcommCameraHardware::runVideoThread(void *data) #endif // Enable IF block to give frames to encoder , ELSE block for just simulation #if 1 - ALOGV("in video_thread : got video frame, before if check giving frame to services/encoder"); + LOGV("in video_thread : got video frame, before if check giving frame to services/encoder"); mCallbackLock.lock(); int msgEnabled = mMsgEnabled; data_callback_timestamp rcb = mDataCallbackTimestamp; @@ -2085,16 +2085,16 @@ void QualcommCameraHardware::runVideoThread(void *data) mCallbackLock.unlock(); if(rcb != NULL && (msgEnabled & CAMERA_MSG_VIDEO_FRAME) ) { - ALOGV("in video_thread : got video frame, giving frame to services/encoder"); + LOGV("in video_thread : got video frame, giving frame to services/encoder"); rcb(systemTime(), CAMERA_MSG_VIDEO_FRAME, mRecordHeap->mBuffers[offset], rdata); } #else // 720p output2 : simulate release frame here: - ALOGE("in video_thread simulation , releasing the video frame"); + LOGE("in video_thread simulation , releasing the video frame"); LINK_camframe_free_video(vframe); #endif - } else ALOGE("in video_thread get frame returned null"); + } else LOGE("in video_thread get frame returned null"); } // end of while loop @@ -2104,30 +2104,30 @@ void QualcommCameraHardware::runVideoThread(void *data) mVideoThreadWait.signal(); mVideoThreadWaitLock.unlock(); - ALOGV("runVideoThread X"); + LOGV("runVideoThread X"); } void *video_thread(void *user) { - ALOGV("video_thread E"); + LOGV("video_thread E"); sp obj = QualcommCameraHardware::getInstance(); if (obj != 0) { obj->runVideoThread(user); } - else ALOGE("not starting video thread: the object went away!"); - ALOGV("video_thread X"); + else LOGE("not starting video thread: the object went away!"); + LOGV("video_thread X"); return NULL; } void *frame_thread(void *user) { - ALOGD("frame_thread E"); + LOGD("frame_thread E"); sp obj = QualcommCameraHardware::getInstance(); if (obj != 0) { obj->runFrameThread(user); } - else ALOGW("not starting frame thread: the object went away!"); - ALOGD("frame_thread X"); + else LOGW("not starting frame thread: the object went away!"); + LOGD("frame_thread X"); return NULL; } @@ -2140,7 +2140,7 @@ bool QualcommCameraHardware::initPreview() videoWidth = previewWidth; // temporary , should be configurable later videoHeight = previewHeight; - ALOGV("initPreview E: preview size=%dx%d videosize = %d x %d", previewWidth, previewHeight, videoWidth, videoHeight ); + LOGV("initPreview E: preview size=%dx%d videosize = %d x %d", previewWidth, previewHeight, videoWidth, videoHeight ); if( ( mCurrentTarget == TARGET_MSM7630 ) || (mCurrentTarget == TARGET_QSD8250)) { mDimension.video_width = videoWidth; @@ -2149,23 +2149,23 @@ bool QualcommCameraHardware::initPreview() // for 720p , preview can be 768X432 previewWidth = mDimension.display_width; previewHeight= mDimension.display_height; - ALOGV("initPreview : preview size=%dx%d videosize = %d x %d", previewWidth, previewHeight, mDimension.video_width, mDimension.video_height ); + LOGV("initPreview : preview size=%dx%d videosize = %d x %d", previewWidth, previewHeight, mDimension.video_width, mDimension.video_height ); } mFrameThreadWaitLock.lock(); while (mFrameThreadRunning) { - ALOGV("initPreview: waiting for old frame thread to complete."); + LOGV("initPreview: waiting for old frame thread to complete."); mFrameThreadWait.wait(mFrameThreadWaitLock); - ALOGV("initPreview: old frame thread completed."); + LOGV("initPreview: old frame thread completed."); } mFrameThreadWaitLock.unlock(); mInSnapshotModeWaitLock.lock(); while (mInSnapshotMode) { - ALOGV("initPreview: waiting for snapshot mode to complete."); + LOGV("initPreview: waiting for snapshot mode to complete."); mInSnapshotModeWait.wait(mInSnapshotModeWaitLock); - ALOGV("initPreview: snapshot mode completed."); + LOGV("initPreview: snapshot mode completed."); } mInSnapshotModeWaitLock.unlock(); @@ -2183,13 +2183,13 @@ bool QualcommCameraHardware::initPreview() if (!mPreviewHeap->initialized()) { mPreviewHeap.clear(); - ALOGE("initPreview X: could not initialize Camera preview heap."); + LOGE("initPreview X: could not initialize Camera preview heap."); return false; } if( mCurrentTarget == TARGET_MSM7630 ) { mPostViewHeap.clear(); if(mPostViewHeap == NULL) { - ALOGV(" Allocating Postview heap "); + LOGV(" Allocating Postview heap "); /* mPostViewHeap should be declared only for 7630 target */ mPostViewHeap = new PmemPool("/dev/pmem_adsp", @@ -2203,7 +2203,7 @@ bool QualcommCameraHardware::initPreview() if (!mPostViewHeap->initialized()) { mPostViewHeap.clear(); - ALOGE(" Failed to initialize Postview Heap"); + LOGE(" Failed to initialize Postview Heap"); return false; } } @@ -2243,7 +2243,7 @@ bool QualcommCameraHardware::initPreview() else frame_parms.video_frame = frames[kPreviewBufferCount - 2]; - ALOGV ("initpreview before cam_frame thread carete , video frame buffer=%lu fd=%d y_off=%d cbcr_off=%d \n", + LOGV ("initpreview before cam_frame thread carete , video frame buffer=%lu fd=%d y_off=%d cbcr_off=%d \n", (unsigned long)frame_parms.video_frame.buffer, frame_parms.video_frame.fd, frame_parms.video_frame.y_off, frame_parms.video_frame.cbcr_off); mFrameThreadRunning = !pthread_create(&mFrameThread, @@ -2254,13 +2254,13 @@ bool QualcommCameraHardware::initPreview() mFrameThreadWaitLock.unlock(); } - ALOGV("initPreview X: %d", ret); + LOGV("initPreview X: %d", ret); return ret; } void QualcommCameraHardware::deinitPreview(void) { - ALOGI("deinitPreview E"); + LOGI("deinitPreview E"); // When we call deinitPreview(), we signal to the frame thread that it // needs to exit, but we DO NOT WAIT for it to complete here. The problem @@ -2277,31 +2277,31 @@ void QualcommCameraHardware::deinitPreview(void) // detached, and use a separate mechanism to wait for it to complete. LINK_camframe_terminate(); - ALOGI("deinitPreview X"); + LOGI("deinitPreview X"); } bool QualcommCameraHardware::initRawSnapshot() { - ALOGV("initRawSnapshot E"); + LOGV("initRawSnapshot E"); //get width and height from Dimension Object bool ret = native_set_parm(CAMERA_SET_PARM_DIMENSION, sizeof(cam_ctrl_dimension_t), &mDimension); if(!ret){ - ALOGE("initRawSnapshot X: failed to set dimension"); + LOGE("initRawSnapshot X: failed to set dimension"); return false; } int rawSnapshotSize = mDimension.raw_picture_height * mDimension.raw_picture_width; - ALOGV("raw_snapshot_buffer_size = %d, raw_picture_height = %d, "\ + LOGV("raw_snapshot_buffer_size = %d, raw_picture_height = %d, "\ "raw_picture_width = %d", rawSnapshotSize, mDimension.raw_picture_height, mDimension.raw_picture_width); if (mRawSnapShotPmemHeap != NULL) { - ALOGV("initRawSnapshot: clearing old mRawSnapShotPmemHeap."); + LOGV("initRawSnapshot: clearing old mRawSnapShotPmemHeap."); mRawSnapShotPmemHeap.clear(); } @@ -2317,10 +2317,10 @@ bool QualcommCameraHardware::initRawSnapshot() if (!mRawSnapShotPmemHeap->initialized()) { mRawSnapShotPmemHeap.clear(); - ALOGE("initRawSnapshot X: error initializing mRawSnapshotHeap"); + LOGE("initRawSnapshot X: error initializing mRawSnapshotHeap"); return false; } - ALOGV("initRawSnapshot X"); + LOGV("initRawSnapshot X"); return true; } @@ -2330,7 +2330,7 @@ bool QualcommCameraHardware::initRaw(bool initJpegHeap) int rawWidth, rawHeight; mParameters.getPictureSize(&rawWidth, &rawHeight); - ALOGV("initRaw E: picture size=%dx%d", rawWidth, rawHeight); + LOGV("initRaw E: picture size=%dx%d", rawWidth, rawHeight); int thumbnailBufferSize; //Thumbnail height should be smaller than Picture height @@ -2357,7 +2357,7 @@ bool QualcommCameraHardware::initRaw(bool initJpegHeap) (THUMBNAIL_SMALL_HEIGHT * rawWidth)/ rawHeight; } - ALOGV("Thumbnail Size Width %d Height %d", + LOGV("Thumbnail Size Width %d Height %d", mDimension.ui_thumbnail_width, mDimension.ui_thumbnail_height); @@ -2370,12 +2370,12 @@ bool QualcommCameraHardware::initRaw(bool initJpegHeap) bool ret = native_set_parm(CAMERA_SET_PARM_DIMENSION, sizeof(cam_ctrl_dimension_t), &mDimension); if(!ret) { - ALOGE("initRaw X: failed to set dimension"); + LOGE("initRaw X: failed to set dimension"); return false; } if (mJpegHeap != NULL) { - ALOGV("initRaw: clearing old mJpegHeap."); + LOGV("initRaw: clearing old mJpegHeap."); mJpegHeap.clear(); } @@ -2387,7 +2387,7 @@ bool QualcommCameraHardware::initRaw(bool initJpegHeap) else mJpegMaxSize = rawWidth * rawHeight * 3 / 2; - ALOGV("initRaw: initializing mRawHeap."); + LOGV("initRaw: initializing mRawHeap."); mRawHeap = new PmemPool("/dev/pmem_adsp", MemoryHeapBase::READ_ONLY | MemoryHeapBase::NO_CACHING, @@ -2399,19 +2399,19 @@ bool QualcommCameraHardware::initRaw(bool initJpegHeap) "snapshot camera"); if (!mRawHeap->initialized()) { - ALOGE("initRaw X failed "); + LOGE("initRaw X failed "); mRawHeap.clear(); - ALOGE("initRaw X: error initializing mRawHeap"); + LOGE("initRaw X: error initializing mRawHeap"); return false; } - ALOGV("do_mmap snapshot pbuf = %p, pmem_fd = %d", + LOGV("do_mmap snapshot pbuf = %p, pmem_fd = %d", (uint8_t *)mRawHeap->mHeap->base(), mRawHeap->mHeap->getHeapID()); // Jpeg if (initJpegHeap) { - ALOGV("initRaw: initializing mJpegHeap."); + LOGV("initRaw: initializing mJpegHeap."); mJpegHeap = new AshmemPool(mJpegMaxSize, kJpegBufferCount, @@ -2421,7 +2421,7 @@ bool QualcommCameraHardware::initRaw(bool initJpegHeap) if (!mJpegHeap->initialized()) { mJpegHeap.clear(); mRawHeap.clear(); - ALOGE("initRaw X failed: error initializing mJpegHeap."); + LOGE("initRaw X failed: error initializing mJpegHeap."); return false; } @@ -2441,43 +2441,43 @@ bool QualcommCameraHardware::initRaw(bool initJpegHeap) mThumbnailHeap.clear(); mJpegHeap.clear(); mRawHeap.clear(); - ALOGE("initRaw X failed: error initializing mThumbnailHeap."); + LOGE("initRaw X failed: error initializing mThumbnailHeap."); return false; } } - ALOGV("initRaw X"); + LOGV("initRaw X"); return true; } void QualcommCameraHardware::deinitRawSnapshot() { - ALOGV("deinitRawSnapshot E"); + LOGV("deinitRawSnapshot E"); mRawSnapShotPmemHeap.clear(); - ALOGV("deinitRawSnapshot X"); + LOGV("deinitRawSnapshot X"); } void QualcommCameraHardware::deinitRaw() { - ALOGV("deinitRaw E"); + LOGV("deinitRaw E"); mThumbnailHeap.clear(); mJpegHeap.clear(); mRawHeap.clear(); mDisplayHeap.clear(); - ALOGV("deinitRaw X"); + LOGV("deinitRaw X"); } void QualcommCameraHardware::release() { - ALOGD("release E"); + LOGD("release E"); Mutex::Autolock l(&mLock); #if DLOPEN_LIBMMCAMERA if (libmmcamera == NULL) { - ALOGE("ERROR: multiple release!"); + LOGE("ERROR: multiple release!"); return; } #else @@ -2517,7 +2517,7 @@ void QualcommCameraHardware::release() ctrlCmd.type = (uint16_t)CAMERA_EXIT; ctrlCmd.resp_fd = mCameraControlFd; // FIXME: this will be put in by the kernel if (ioctl(mCameraControlFd, MSM_CAM_IOCTL_CTRL_COMMAND, &ctrlCmd) < 0) - ALOGE("ioctl CAMERA_EXIT fd %d error %s", + LOGE("ioctl CAMERA_EXIT fd %d error %s", mCameraControlFd, strerror(errno)); LINK_release_cam_conf_thread(); @@ -2530,7 +2530,7 @@ void QualcommCameraHardware::release() #if DLOPEN_LIBMMCAMERA if (libmmcamera) { ::dlclose(libmmcamera); - ALOGV("dlclose(libqcamera)"); + LOGV("dlclose(libqcamera)"); libmmcamera = NULL; } #endif @@ -2540,12 +2540,12 @@ void QualcommCameraHardware::release() singleton_releasing_start_time = systemTime(); singleton_lock.unlock(); - ALOGD("release X"); + LOGD("release X"); } QualcommCameraHardware::~QualcommCameraHardware() { - ALOGD("~QualcommCameraHardware E"); + LOGD("~QualcommCameraHardware E"); singleton_lock.lock(); if( mCurrentTarget == TARGET_MSM7630 || mCurrentTarget == TARGET_QSD8250 ) { @@ -2557,26 +2557,26 @@ QualcommCameraHardware::~QualcommCameraHardware() singleton_releasing_start_time = 0; singleton_wait.signal(); singleton_lock.unlock(); - ALOGD("~QualcommCameraHardware X"); + LOGD("~QualcommCameraHardware X"); } sp QualcommCameraHardware::getRawHeap() const { - ALOGV("getRawHeap"); + LOGV("getRawHeap"); return mDisplayHeap != NULL ? mDisplayHeap->mHeap : NULL; } sp QualcommCameraHardware::getPreviewHeap() const { - ALOGV("getPreviewHeap"); + LOGV("getPreviewHeap"); return mPreviewHeap != NULL ? mPreviewHeap->mHeap : NULL; } status_t QualcommCameraHardware::startPreviewInternal() { - ALOGV("in startPreviewInternal : E"); + LOGV("in startPreviewInternal : E"); if(mCameraRunning) { - ALOGV("startPreview X: preview already running."); + LOGV("startPreview X: preview already running."); return NO_ERROR; } @@ -2584,7 +2584,7 @@ status_t QualcommCameraHardware::startPreviewInternal() mLastQueuedFrame = NULL; mPreviewInitialized = initPreview(); if (!mPreviewInitialized) { - ALOGE("startPreview X initPreview failed. Not starting preview."); + LOGE("startPreview X initPreview failed. Not starting preview."); return UNKNOWN_ERROR; } } @@ -2602,7 +2602,7 @@ status_t QualcommCameraHardware::startPreviewInternal() deinitPreview(); mPreviewInitialized = false; mOverlay = NULL; - ALOGE("startPreview X: native_start_preview failed!"); + LOGE("startPreview X: native_start_preview failed!"); return UNKNOWN_ERROR; } @@ -2610,29 +2610,29 @@ status_t QualcommCameraHardware::startPreviewInternal() exif_table_numEntries = 0; if(native_get_maxzoom(mCameraControlFd, (void *)&mMaxZoom) == true){ - ALOGD("Maximum zoom value is %d", mMaxZoom); + LOGD("Maximum zoom value is %d", mMaxZoom); mParameters.set("zoom-supported", "true"); } else { - ALOGE("Failed to get maximum zoom value...setting max zoom to zero"); + LOGE("Failed to get maximum zoom value...setting max zoom to zero"); mParameters.set("zoom-supported", "false"); mMaxZoom = 0; } mParameters.set("max-zoom",mMaxZoom); - ALOGV("startPreviewInternal X"); + LOGV("startPreviewInternal X"); return NO_ERROR; } status_t QualcommCameraHardware::startPreview() { - ALOGV("startPreview E"); + LOGV("startPreview E"); Mutex::Autolock l(&mLock); return startPreviewInternal(); } void QualcommCameraHardware::stopPreviewInternal() { - ALOGV("stopPreviewInternal E: %d", mCameraRunning); + LOGV("stopPreviewInternal E: %d", mCameraRunning); if (mCameraRunning) { // Cancel auto focus. { @@ -2663,7 +2663,7 @@ void QualcommCameraHardware::stopPreviewInternal() deinitPreview(); if( ( mCurrentTarget == TARGET_MSM7630 ) || (mCurrentTarget == TARGET_QSD8250)) { mVideoThreadWaitLock.lock(); - ALOGV("in stopPreviewInternal: making mVideoThreadExit 1"); + LOGV("in stopPreviewInternal: making mVideoThreadExit 1"); mVideoThreadExit = 1; mVideoThreadWaitLock.unlock(); // 720p : signal the video thread , and check in video thread if stop is called, if so exit video thread. @@ -2677,21 +2677,21 @@ void QualcommCameraHardware::stopPreviewInternal() } mPreviewInitialized = false; } - else ALOGE("stopPreviewInternal: failed to stop preview"); + else LOGE("stopPreviewInternal: failed to stop preview"); } - ALOGV("stopPreviewInternal X: %d", mCameraRunning); + LOGV("stopPreviewInternal X: %d", mCameraRunning); } void QualcommCameraHardware::stopPreview() { - ALOGV("stopPreview: E"); + LOGV("stopPreview: E"); Mutex::Autolock l(&mLock); { if (mDataCallbackTimestamp && (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) return; } stopPreviewInternal(); - ALOGV("stopPreview: X"); + LOGV("stopPreview: X"); } void QualcommCameraHardware::runAutoFocus() @@ -2723,7 +2723,7 @@ void QualcommCameraHardware::runAutoFocus() mAutoFocusFd = open(MSM_CAMERA_CONTROL, O_RDWR); if (mAutoFocusFd < 0) { - ALOGE("autofocus: cannot open %s: %s", + LOGE("autofocus: cannot open %s: %s", MSM_CAMERA_CONTROL, strerror(errno)); mAutoFocusThreadRunning = false; @@ -2737,9 +2737,9 @@ void QualcommCameraHardware::runAutoFocus() // lifetime of this object. We do not want to dlclose() libqcamera while // LINK_cam_frame is still running. libhandle = ::dlopen("liboemcamera.so", RTLD_NOW); - ALOGV("AF: loading libqcamera at %p", libhandle); + LOGV("AF: loading libqcamera at %p", libhandle); if (!libhandle) { - ALOGE("FATAL ERROR: could not dlopen liboemcamera.so: %s", dlerror()); + LOGE("FATAL ERROR: could not dlopen liboemcamera.so: %s", dlerror()); close(mAutoFocusFd); mAutoFocusFd = -1; mAutoFocusThreadRunning = false; @@ -2753,17 +2753,17 @@ void QualcommCameraHardware::runAutoFocus() mParameters.get(CameraParameters::KEY_FOCUS_MODE)); /* This will block until either AF completes or is cancelled. */ - ALOGV("af start (fd %d mode %d)", mAutoFocusFd, afMode); + LOGV("af start (fd %d mode %d)", mAutoFocusFd, afMode); status_t err; err = mAfLock.tryLock(); if(err == NO_ERROR) { { Mutex::Autolock cameraRunningLock(&mCameraRunningLock); if(mCameraRunning){ - ALOGV("Start AF"); + LOGV("Start AF"); status = native_set_afmode(mAutoFocusFd, afMode); }else{ - ALOGV("As Camera preview is not running, AF not issued"); + LOGV("As Camera preview is not running, AF not issued"); status = false; } } @@ -2772,12 +2772,12 @@ void QualcommCameraHardware::runAutoFocus() else{ //AF Cancel would have acquired the lock, //so, no need to perform any AF - ALOGV("As Cancel auto focus is in progress, auto focus request " + LOGV("As Cancel auto focus is in progress, auto focus request " "is ignored"); status = FALSE; } - ALOGV("af done: %d", (int)status); + LOGV("af done: %d", (int)status); close(mAutoFocusFd); mAutoFocusFd = -1; @@ -2796,23 +2796,23 @@ void QualcommCameraHardware::runAutoFocus() #if DLOPEN_LIBMMCAMERA if (libhandle) { ::dlclose(libhandle); - ALOGV("AF: dlclose(libqcamera)"); + LOGV("AF: dlclose(libqcamera)"); } #endif } status_t QualcommCameraHardware::cancelAutoFocusInternal() { - ALOGV("cancelAutoFocusInternal E"); + LOGV("cancelAutoFocusInternal E"); if(!sensorType->hasAutoFocusSupport){ - ALOGV("cancelAutoFocusInternal X"); + LOGV("cancelAutoFocusInternal X"); return NO_ERROR; } #if 0 if (mAutoFocusFd < 0) { - ALOGV("cancelAutoFocusInternal X: not in progress"); + LOGV("cancelAutoFocusInternal X: not in progress"); return NO_ERROR; } #endif @@ -2823,13 +2823,13 @@ status_t QualcommCameraHardware::cancelAutoFocusInternal() if(err == NO_ERROR) { //Got Lock, means either AF hasn't started or // AF is done. So no need to cancel it, just change the state - ALOGV("As Auto Focus is not in progress, Cancel Auto Focus " + LOGV("As Auto Focus is not in progress, Cancel Auto Focus " "is ignored"); mAfLock.unlock(); } else { //AF is in Progess, So cancel it - ALOGV("Lock busy...cancel AF"); + LOGV("Lock busy...cancel AF"); rc = native_cancel_afmode(mCameraControlFd, mAutoFocusFd) ? NO_ERROR : UNKNOWN_ERROR; @@ -2837,29 +2837,29 @@ status_t QualcommCameraHardware::cancelAutoFocusInternal() - ALOGV("cancelAutoFocusInternal X: %d", rc); + LOGV("cancelAutoFocusInternal X: %d", rc); return rc; } void *auto_focus_thread(void *user) { - ALOGV("auto_focus_thread E"); + LOGV("auto_focus_thread E"); sp obj = QualcommCameraHardware::getInstance(); if (obj != 0) { obj->runAutoFocus(); } - else ALOGW("not starting autofocus: the object went away!"); - ALOGV("auto_focus_thread X"); + else LOGW("not starting autofocus: the object went away!"); + LOGV("auto_focus_thread X"); return NULL; } status_t QualcommCameraHardware::autoFocus() { - ALOGV("autoFocus E"); + LOGV("autoFocus E"); Mutex::Autolock l(&mLock); if (mCameraControlFd < 0) { - ALOGE("not starting autofocus: main control fd %d", mCameraControlFd); + LOGE("not starting autofocus: main control fd %d", mCameraControlFd); return UNKNOWN_ERROR; } @@ -2867,7 +2867,7 @@ status_t QualcommCameraHardware::autoFocus() mAutoFocusThreadLock.lock(); if (!mAutoFocusThreadRunning) { if (native_prepare_snapshot(mCameraControlFd) == FALSE) { - ALOGE("native_prepare_snapshot failed!\n"); + LOGE("native_prepare_snapshot failed!\n"); mAutoFocusThreadLock.unlock(); return UNKNOWN_ERROR; } @@ -2882,7 +2882,7 @@ status_t QualcommCameraHardware::autoFocus() !pthread_create(&thr, &attr, auto_focus_thread, NULL); if (!mAutoFocusThreadRunning) { - ALOGE("failed to start autofocus thread"); + LOGE("failed to start autofocus thread"); mAutoFocusThreadLock.unlock(); return UNKNOWN_ERROR; } @@ -2890,13 +2890,13 @@ status_t QualcommCameraHardware::autoFocus() mAutoFocusThreadLock.unlock(); } - ALOGV("autoFocus X"); + LOGV("autoFocus X"); return NO_ERROR; } status_t QualcommCameraHardware::cancelAutoFocus() { - ALOGV("cancelAutoFocus E"); + LOGV("cancelAutoFocus E"); Mutex::Autolock l(&mLock); int rc = NO_ERROR; @@ -2904,23 +2904,23 @@ status_t QualcommCameraHardware::cancelAutoFocus() rc = cancelAutoFocusInternal(); } - ALOGV("cancelAutoFocus X"); + LOGV("cancelAutoFocus X"); return rc; } void QualcommCameraHardware::runSnapshotThread(void *data) { - ALOGV("runSnapshotThread E"); + LOGV("runSnapshotThread E"); if(mSnapshotFormat == PICTURE_FORMAT_JPEG){ if (native_start_snapshot(mCameraControlFd)) receiveRawPicture(); else - ALOGE("main: native_start_snapshot failed!"); + LOGE("main: native_start_snapshot failed!"); } else if(mSnapshotFormat == PICTURE_FORMAT_RAW){ if(native_start_raw_snapshot(mCameraControlFd)){ receiveRawSnapshot(); } else { - ALOGE("main: native_start_raw_snapshot failed!"); + LOGE("main: native_start_raw_snapshot failed!"); } } mInSnapshotModeWaitLock.lock(); @@ -2932,9 +2932,9 @@ void QualcommCameraHardware::runSnapshotThread(void *data) mJpegThreadWaitLock.lock(); while (mJpegThreadRunning) { - ALOGV("runSnapshotThread: waiting for jpeg thread to complete."); + LOGV("runSnapshotThread: waiting for jpeg thread to complete."); mJpegThreadWait.wait(mJpegThreadWaitLock); - ALOGV("runSnapshotThread: jpeg thread completed."); + LOGV("runSnapshotThread: jpeg thread completed."); } mJpegThreadWaitLock.unlock(); //clear the resources @@ -2946,32 +2946,32 @@ void QualcommCameraHardware::runSnapshotThread(void *data) mSnapshotThreadWait.signal(); mSnapshotThreadWaitLock.unlock(); - ALOGV("runSnapshotThread X"); + LOGV("runSnapshotThread X"); } void *snapshot_thread(void *user) { - ALOGD("snapshot_thread E"); + LOGD("snapshot_thread E"); sp obj = QualcommCameraHardware::getInstance(); if (obj != 0) { obj->runSnapshotThread(user); } - else ALOGW("not starting snapshot thread: the object went away!"); - ALOGD("snapshot_thread X"); + else LOGW("not starting snapshot thread: the object went away!"); + LOGD("snapshot_thread X"); return NULL; } status_t QualcommCameraHardware::takePicture() { - ALOGV("takePicture(%d)", mMsgEnabled); + LOGV("takePicture(%d)", mMsgEnabled); Mutex::Autolock l(&mLock); // Wait for old snapshot thread to complete. mSnapshotThreadWaitLock.lock(); while (mSnapshotThreadRunning) { - ALOGV("takePicture: waiting for old snapshot thread to complete."); + LOGV("takePicture: waiting for old snapshot thread to complete."); mSnapshotThreadWait.wait(mSnapshotThreadWaitLock); - ALOGV("takePicture: old snapshot thread completed."); + LOGV("takePicture: old snapshot thread completed."); } if( mCurrentTarget == TARGET_MSM7630 ) { @@ -2999,13 +2999,13 @@ status_t QualcommCameraHardware::takePicture() if(mSnapshotFormat == PICTURE_FORMAT_JPEG){ if (!initRaw(mDataCallback && (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE))) { - ALOGE("initRaw failed. Not taking picture."); + LOGE("initRaw failed. Not taking picture."); mSnapshotThreadWaitLock.unlock(); return UNKNOWN_ERROR; } } else if(mSnapshotFormat == PICTURE_FORMAT_RAW ){ if(!initRawSnapshot()){ - ALOGE("initRawSnapshot failed. Not taking picture."); + LOGE("initRawSnapshot failed. Not taking picture."); mSnapshotThreadWaitLock.unlock(); return UNKNOWN_ERROR; } @@ -3028,22 +3028,22 @@ status_t QualcommCameraHardware::takePicture() mInSnapshotMode = true; mInSnapshotModeWaitLock.unlock(); - ALOGV("takePicture: X"); + LOGV("takePicture: X"); return mSnapshotThreadRunning ? NO_ERROR : UNKNOWN_ERROR; } status_t QualcommCameraHardware::cancelPicture() { status_t rc; - ALOGV("cancelPicture: E"); + LOGV("cancelPicture: E"); rc = native_stop_snapshot(mCameraControlFd) ? NO_ERROR : UNKNOWN_ERROR; - ALOGV("cancelPicture: X: %d", rc); + LOGV("cancelPicture: X: %d", rc); return rc; } status_t QualcommCameraHardware::setParameters(const CameraParameters& params) { - ALOGV("setParameters: E params = %p", ¶ms); + LOGV("setParameters: E params = %p", ¶ms); Mutex::Autolock l(&mLock); status_t rc, final_rc = NO_ERROR; @@ -3071,7 +3071,7 @@ status_t QualcommCameraHardware::setParameters(const CameraParameters& params) if ((rc = setContrast(params))) final_rc = rc; if ((rc = setSaturation(params))) final_rc = rc; - ALOGV("setParameters: X"); + LOGV("setParameters: X"); //return final_rc; /* Just let whatever passed go through */ return NO_ERROR; @@ -3079,20 +3079,20 @@ status_t QualcommCameraHardware::setParameters(const CameraParameters& params) CameraParameters QualcommCameraHardware::getParameters() const { - ALOGV("getParameters: EX"); + LOGV("getParameters: EX"); return mParameters; } status_t QualcommCameraHardware::sendCommand(int32_t command, int32_t arg1, int32_t arg2) { - ALOGV("sendCommand: EX"); + LOGV("sendCommand: EX"); return BAD_VALUE; } extern "C" sp openCameraHardware() { - ALOGV("openCameraHardware: call createInstance"); + LOGV("openCameraHardware: call createInstance"); return QualcommCameraHardware::createInstance(); } @@ -3115,7 +3115,7 @@ extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo) extern "C" sp HAL_openCameraHardware(int cameraId) { - ALOGV("openCameraHardware: call createInstance"); + LOGV("openCameraHardware: call createInstance"); return QualcommCameraHardware::createInstance(); } @@ -3126,7 +3126,7 @@ wp QualcommCameraHardware::singleton; // and return it. sp QualcommCameraHardware::createInstance() { - ALOGD("createInstance: E"); + LOGD("createInstance: E"); singleton_lock.lock(); @@ -3134,21 +3134,21 @@ sp QualcommCameraHardware::createInstance() while (singleton_releasing) { if((singleton_releasing_start_time != 0) && (systemTime() - singleton_releasing_start_time) > SINGLETON_RELEASING_WAIT_TIME){ - ALOGV("in createinstance system time is %lld %lld %lld ", + LOGV("in createinstance system time is %lld %lld %lld ", systemTime(), singleton_releasing_start_time, SINGLETON_RELEASING_WAIT_TIME); singleton_lock.unlock(); - ALOGE("Previous singleton is busy and time out exceeded. Returning null"); + LOGE("Previous singleton is busy and time out exceeded. Returning null"); return NULL; } - ALOGI("Wait for previous release."); + LOGI("Wait for previous release."); singleton_wait.waitRelative(singleton_lock, SINGLETON_RELEASING_RECHECK_TIMEOUT); - ALOGI("out of Wait for previous release."); + LOGI("out of Wait for previous release."); } if (singleton != 0) { sp hardware = singleton.promote(); if (hardware != 0) { - ALOGD("createInstance: X return existing hardware=%p", &(*hardware)); + LOGD("createInstance: X return existing hardware=%p", &(*hardware)); singleton_lock.unlock(); return hardware; } @@ -3158,7 +3158,7 @@ sp QualcommCameraHardware::createInstance() struct stat st; int rc = stat("/dev/oncrpc", &st); if (rc < 0) { - ALOGD("createInstance: X failed to create hardware: %s", strerror(errno)); + LOGD("createInstance: X failed to create hardware: %s", strerror(errno)); singleton_lock.unlock(); return NULL; } @@ -3169,13 +3169,13 @@ sp QualcommCameraHardware::createInstance() singleton = hardware; if (!cam->startCamera()) { - ALOGE("%s: startCamera failed!", __FUNCTION__); + LOGE("%s: startCamera failed!", __FUNCTION__); singleton_lock.unlock(); return NULL; } cam->initDefaultParameters(); - ALOGD("createInstance: X created hardware=%p", &(*hardware)); + LOGD("createInstance: X created hardware=%p", &(*hardware)); singleton_lock.unlock(); return hardware; } @@ -3185,23 +3185,23 @@ sp QualcommCameraHardware::getInstance() { sp hardware = singleton.promote(); if (hardware != 0) { - // ALOGV("getInstance: X old instance of hardware"); + // LOGV("getInstance: X old instance of hardware"); return sp(static_cast(hardware.get())); } else { - ALOGV("getInstance: X new instance of hardware"); + LOGV("getInstance: X new instance of hardware"); return sp(); } } void QualcommCameraHardware::receiveRecordingFrame(struct msm_frame *frame) { - ALOGV("receiveRecordingFrame E"); + LOGV("receiveRecordingFrame E"); // post busy frame if (frame) { cam_frame_post_video (frame); } - else ALOGE("in receiveRecordingFrame frame is NULL"); - ALOGV("receiveRecordingFrame X"); + else LOGE("in receiveRecordingFrame frame is NULL"); + LOGV("receiveRecordingFrame X"); } @@ -3242,7 +3242,7 @@ bool QualcommCameraHardware::native_zoom_image(int fd, int srcOffset, int dstOff e->src_rect.w = previewWidth; e->src_rect.h = previewHeight; } - //ALOGV(" native_zoom : SRC_RECT : x,y = %d,%d \t w,h = %d, %d", + //LOGV(" native_zoom : SRC_RECT : x,y = %d,%d \t w,h = %d, %d", // e->src_rect.x, e->src_rect.y, e->src_rect.w, e->src_rect.h); e->dst_rect.x = 0; @@ -3252,7 +3252,7 @@ bool QualcommCameraHardware::native_zoom_image(int fd, int srcOffset, int dstOff result = ioctl(fb_fd, MSMFB_BLIT, &zoomImage.list); if (result < 0) { - ALOGE("MSM_FBIOBLT failed! line=%d\n", __LINE__); + LOGE("MSM_FBIOBLT failed! line=%d\n", __LINE__); return FALSE; } return TRUE; @@ -3269,7 +3269,7 @@ void QualcommCameraHardware::debugShowPreviewFPS() const nsecs_t diff = now - mLastFpsTime; if (diff > ms2ns(250)) { mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; - ALOGI("Preview Frames Per Second: %.4f", mFps); + LOGI("Preview Frames Per Second: %.4f", mFps); mLastFpsTime = now; mLastFrameCount = mFrameCount; } @@ -3286,17 +3286,17 @@ void QualcommCameraHardware::debugShowVideoFPS() const nsecs_t diff = now - mLastFpsTime; if (diff > ms2ns(250)) { mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; - ALOGI("Video Frames Per Second: %.4f", mFps); + LOGI("Video Frames Per Second: %.4f", mFps); mLastFpsTime = now; mLastFrameCount = mFrameCount; } } void QualcommCameraHardware::receivePreviewFrame(struct msm_frame *frame) { -// ALOGV("receivePreviewFrame E"); +// LOGV("receivePreviewFrame E"); if (!mCameraRunning) { - ALOGE("ignoring preview callback--camera has been stopped"); + LOGE("ignoring preview callback--camera has been stopped"); return; } @@ -3326,7 +3326,7 @@ void QualcommCameraHardware::receivePreviewFrame(struct msm_frame *frame) ssize_t dstOffset_addr = offset * mPreviewHeap->mAlignedBufferSize; if( !native_zoom_image(mPreviewHeap->mHeap->getHeapID(), offset_addr, dstOffset_addr, crop)) { - ALOGE(" Error while doing MDP zoom "); + LOGE(" Error while doing MDP zoom "); offset = offset_addr / mPreviewHeap->mAlignedBufferSize; } } @@ -3340,16 +3340,16 @@ void QualcommCameraHardware::receivePreviewFrame(struct msm_frame *frame) rcb(systemTime(), CAMERA_MSG_VIDEO_FRAME, mPreviewHeap->mBuffers[offset], rdata); Mutex::Autolock rLock(&mRecordFrameLock); if (mReleasedRecordingFrame != true) { - ALOGV("block waiting for frame release"); + LOGV("block waiting for frame release"); mRecordWait.wait(mRecordFrameLock); - ALOGV("frame released, continuing"); + LOGV("frame released, continuing"); } mReleasedRecordingFrame = false; } } mInPreviewCallback = false; -// ALOGV("receivePreviewFrame X"); +// LOGV("receivePreviewFrame X"); } @@ -3357,7 +3357,7 @@ bool QualcommCameraHardware::initRecord() { char *pmem_region; - ALOGV("initREcord E"); + LOGV("initREcord E"); mRecordFrameSize = (mDimension.video_width * mDimension.video_height *3)/2; @@ -3377,7 +3377,7 @@ bool QualcommCameraHardware::initRecord() if (!mRecordHeap->initialized()) { mRecordHeap.clear(); - ALOGE("initRecord X: could not initialize record heap."); + LOGE("initRecord X: could not initialize record heap."); return false; } for (int cnt = 0; cnt < kRecordBufferCount; cnt++) { @@ -3388,7 +3388,7 @@ bool QualcommCameraHardware::initRecord() recordframes[cnt].cbcr_off = mDimension.video_width * mDimension.video_height; recordframes[cnt].path = OUTPUT_TYPE_V; - ALOGV ("initRecord : record heap , video buffers buffer=%lu fd=%d y_off=%d cbcr_off=%d \n", + LOGV ("initRecord : record heap , video buffers buffer=%lu fd=%d y_off=%d cbcr_off=%d \n", (unsigned long)recordframes[cnt].buffer, recordframes[cnt].fd, recordframes[cnt].y_off, recordframes[cnt].cbcr_off); } @@ -3399,9 +3399,9 @@ bool QualcommCameraHardware::initRecord() mVideoThreadWaitLock.lock(); while (mVideoThreadRunning) { - ALOGV("initRecord: waiting for old video thread to complete."); + LOGV("initRecord: waiting for old video thread to complete."); mVideoThreadWait.wait(mVideoThreadWaitLock); - ALOGV("initRecord : old video thread completed."); + LOGV("initRecord : old video thread completed."); } mVideoThreadWaitLock.unlock(); @@ -3409,31 +3409,31 @@ bool QualcommCameraHardware::initRecord() LINK_cam_frame_flush_free_video(); for(int i=ACTIVE_VIDEO_BUFFERS+1;i 0){ msm_frame* vframe = cam_frame_get_video (); LINK_camframe_free_video(vframe); } - ALOGV("frames in busy Q = %d after deQueing", g_busy_frame_queue.num_of_frames); + LOGV("frames in busy Q = %d after deQueing", g_busy_frame_queue.num_of_frames); // Start video thread and wait for busy frames to be encoded, this thread // should be closed in stopRecording @@ -3455,7 +3455,7 @@ status_t QualcommCameraHardware::startRecording() void QualcommCameraHardware::stopRecording() { - ALOGV("stopRecording: E"); + LOGV("stopRecording: E"); Mutex::Autolock l(&mLock); { mRecordFrameLock.lock(); @@ -3465,7 +3465,7 @@ void QualcommCameraHardware::stopRecording() if(mDataCallback && !(mCurrentTarget == TARGET_QSD8250) && (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)) { - ALOGV("stopRecording: X, preview still in progress"); + LOGV("stopRecording: X, preview still in progress"); return; } } @@ -3484,13 +3484,13 @@ void QualcommCameraHardware::stopRecording() stopPreviewInternal(); recordingState = 0; // recording not started - ALOGV("stopRecording: X"); + LOGV("stopRecording: X"); } void QualcommCameraHardware::releaseRecordingFrame( const sp& mem __attribute__((unused))) { - ALOGV("releaseRecordingFrame E"); + LOGV("releaseRecordingFrame E"); Mutex::Autolock rLock(&mRecordFrameLock); mReleasedRecordingFrame = true; mRecordWait.signal(); @@ -3501,11 +3501,11 @@ void QualcommCameraHardware::releaseRecordingFrame( size_t size; sp heap = mem->getMemory(&offset, &size); msm_frame* releaseframe = NULL; - ALOGV(" in release recording frame : heap base %d offset %d buffer %d ", heap->base(), offset, heap->base() + offset ); + LOGV(" in release recording frame : heap base %d offset %d buffer %d ", heap->base(), offset, heap->base() + offset ); int cnt; for (cnt = 0; cnt < kRecordBufferCount; cnt++) { if((unsigned int)recordframes[cnt].buffer == (unsigned int)(heap->base()+ offset)){ - ALOGV("in release recording frame found match , releasing buffer %d", (unsigned int)recordframes[cnt].buffer); + LOGV("in release recording frame found match , releasing buffer %d", (unsigned int)recordframes[cnt].buffer); releaseframe = &recordframes[cnt]; break; } @@ -3518,14 +3518,14 @@ void QualcommCameraHardware::releaseRecordingFrame( mFrameThreadWaitLock.unlock(); } else { - ALOGE("in release recordingframe XXXXX error , buffer not found"); + LOGE("in release recordingframe XXXXX error , buffer not found"); for (int i=0; i< kRecordBufferCount; i++) { - ALOGE(" recordframes[%d].buffer = %d", i, (unsigned int)recordframes[i].buffer); + LOGE(" recordframes[%d].buffer = %d", i, (unsigned int)recordframes[i].buffer); } } } - ALOGV("releaseRecordingFrame X"); + LOGV("releaseRecordingFrame X"); } bool QualcommCameraHardware::recordingEnabled() @@ -3539,9 +3539,9 @@ void QualcommCameraHardware::notifyShutter(common_crop_t *crop) image_rect_type size; if (mShutterPending && mNotifyCallback && (mMsgEnabled & CAMERA_MSG_SHUTTER)) { - ALOGV("out2_w=%d, out2_h=%d, in2_w=%d, in2_h=%d", + LOGV("out2_w=%d, out2_h=%d, in2_w=%d, in2_h=%d", crop->out2_w, crop->out2_h, crop->in2_w, crop->in2_h); - ALOGV("out1_w=%d, out1_h=%d, in1_w=%d, in1_h=%d", + LOGV("out1_w=%d, out1_h=%d, in1_w=%d, in1_h=%d", crop->out1_w, crop->out1_h, crop->in1_w, crop->in1_h); // To workaround a bug in MDP which happens if either @@ -3577,8 +3577,8 @@ void QualcommCameraHardware::notifyShutter(common_crop_t *crop) static void receive_shutter_callback(common_crop_t *crop) { - ALOGV("receive_shutter_callback: E"); - ALOGV("receive_shutter_callback: X"); + LOGV("receive_shutter_callback: E"); + LOGV("receive_shutter_callback: X"); } // Crop the picture in place. @@ -3615,14 +3615,14 @@ static void crop_yuv420(uint32_t width, uint32_t height, void QualcommCameraHardware::receiveRawSnapshot(){ - ALOGV("receiveRawSnapshot E"); + LOGV("receiveRawSnapshot E"); Mutex::Autolock cbLock(&mCallbackLock); if (mDataCallback && (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)) { if(native_get_picture(mCameraControlFd, &mCrop) == false) { - ALOGE("receiveRawSnapshot X: native_get_picture failed!"); + LOGE("receiveRawSnapshot X: native_get_picture failed!"); return; } /* Its necessary to issue another notifyShutter here with @@ -3642,17 +3642,17 @@ void QualcommCameraHardware::receiveRawSnapshot(){ //cleanup deinitRawSnapshot(); - ALOGV("receiveRawSnapshot X"); + LOGV("receiveRawSnapshot X"); } void QualcommCameraHardware::receiveRawPicture() { - ALOGV("receiveRawPicture: E"); + LOGV("receiveRawPicture: E"); Mutex::Autolock cbLock(&mCallbackLock); if (mDataCallback && (mMsgEnabled & CAMERA_MSG_RAW_IMAGE)) { if(native_get_picture(mCameraControlFd, &mCrop) == false) { - ALOGE("getPicture failed!"); + LOGE("getPicture failed!"); return; } mCrop.in1_w &= ~1; @@ -3693,7 +3693,7 @@ void QualcommCameraHardware::receiveRawPicture() mDataCallback(CAMERA_MSG_RAW_IMAGE, mDisplayHeap->mBuffers[0], mCallbackCookie); } - else ALOGV("Raw-picture callback was canceled--skipping."); + else LOGV("Raw-picture callback was canceled--skipping."); if (mDataCallback && (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)) { mJpegSize = 0; @@ -3702,19 +3702,19 @@ void QualcommCameraHardware::receiveRawPicture() mJpegThreadRunning = true; mJpegThreadWaitLock.unlock(); if(native_jpeg_encode()) { - ALOGV("receiveRawPicture: X (success)"); + LOGV("receiveRawPicture: X (success)"); return; } - ALOGE("jpeg encoding failed"); + LOGE("jpeg encoding failed"); } else { - ALOGE("receiveRawPicture X: jpeg_encoder_init failed."); + LOGE("receiveRawPicture X: jpeg_encoder_init failed."); mJpegThreadWaitLock.unlock(); } } - else ALOGV("JPEG callback is NULL, not encoding image."); + else LOGV("JPEG callback is NULL, not encoding image."); deinitRaw(); - ALOGV("receiveRawPicture: X"); + LOGV("receiveRawPicture: X"); } void QualcommCameraHardware::receiveJpegPictureFragment( @@ -3724,9 +3724,9 @@ void QualcommCameraHardware::receiveJpegPictureFragment( remaining -= mJpegSize; uint8_t *base = (uint8_t *)mJpegHeap->mHeap->base(); - ALOGV("receiveJpegPictureFragment size %d", buff_size); + LOGV("receiveJpegPictureFragment size %d", buff_size); if (buff_size > remaining) { - ALOGE("receiveJpegPictureFragment: size %d exceeds what " + LOGE("receiveJpegPictureFragment: size %d exceeds what " "remains in JPEG heap (%d), truncating", buff_size, remaining); @@ -3738,7 +3738,7 @@ void QualcommCameraHardware::receiveJpegPictureFragment( void QualcommCameraHardware::receiveJpegPicture(void) { - ALOGV("receiveJpegPicture: E image (%d uint8_ts out of %d)", + LOGV("receiveJpegPicture: E image (%d uint8_ts out of %d)", mJpegSize, mJpegHeap->mBufferSize); Mutex::Autolock cbLock(&mCallbackLock); @@ -3756,14 +3756,14 @@ void QualcommCameraHardware::receiveJpegPicture(void) mDataCallback(CAMERA_MSG_COMPRESSED_IMAGE, buffer, mCallbackCookie); buffer = NULL; } - else ALOGV("JPEG callback was cancelled--not delivering image."); + else LOGV("JPEG callback was cancelled--not delivering image."); mJpegThreadWaitLock.lock(); mJpegThreadRunning = false; mJpegThreadWait.signal(); mJpegThreadWaitLock.unlock(); - ALOGV("receiveJpegPicture: X callback done."); + LOGV("receiveJpegPicture: X callback done."); } bool QualcommCameraHardware::previewEnabled() @@ -3775,7 +3775,7 @@ status_t QualcommCameraHardware::setPreviewSize(const CameraParameters& params) { int width, height; params.getPreviewSize(&width, &height); - ALOGV("requested preview size %d x %d", width, height); + LOGV("requested preview size %d x %d", width, height); // Validate the preview size for (size_t i = 0; i < previewSizeCount; ++i) { @@ -3785,7 +3785,7 @@ status_t QualcommCameraHardware::setPreviewSize(const CameraParameters& params) // targets) if(width == 1280 && height == 720 && ((mCurrentTarget == TARGET_MSM7630) || (mCurrentTarget == TARGET_QSD8250))){ - ALOGD("change preview resolution to 768X432 since recording is in 720p"); + LOGD("change preview resolution to 768X432 since recording is in 720p"); mDimension.display_width = preview_sizes[2].width; mDimension.display_height= preview_sizes[2].height; }else { @@ -3796,7 +3796,7 @@ status_t QualcommCameraHardware::setPreviewSize(const CameraParameters& params) return NO_ERROR; } } - ALOGE("Invalid preview size requested: %dx%d", width, height); + LOGE("Invalid preview size requested: %dx%d", width, height); return BAD_VALUE; } @@ -3805,15 +3805,15 @@ status_t QualcommCameraHardware::setPreviewFrameRate(const CameraParameters& par if((!strcmp(mSensorInfo.name, "vx6953")) || (!strcmp(mSensorInfo.name, "VX6953")) || (!strcmp(sensorType->name, "2mp"))){ - ALOGI("set fps is not supported for this sensor"); + LOGI("set fps is not supported for this sensor"); return NO_ERROR; } uint16_t previousFps = (uint16_t)mParameters.getPreviewFrameRate(); uint16_t fps = (uint16_t)params.getPreviewFrameRate(); - ALOGV("requested preview frame rate is %u", fps); + LOGV("requested preview frame rate is %u", fps); if(mInitialized && (fps == previousFps)){ - ALOGV("fps same as previous fps"); + LOGV("fps same as previous fps"); return NO_ERROR; } @@ -3831,7 +3831,7 @@ status_t QualcommCameraHardware::setPictureSize(const CameraParameters& params) { int width, height; params.getPictureSize(&width, &height); - ALOGV("requested picture size %d x %d", width, height); + LOGV("requested picture size %d x %d", width, height); // Validate the picture size for (int i = 0; i < supportedPictureSizesCount; ++i) { @@ -3858,7 +3858,7 @@ status_t QualcommCameraHardware::setPictureSize(const CameraParameters& params) mDimension.picture_height = height; return NO_ERROR; } else - ALOGE("Invalid picture size requested: %dx%d", width, height); + LOGE("Invalid picture size requested: %dx%d", width, height); return BAD_VALUE; } @@ -3868,7 +3868,7 @@ status_t QualcommCameraHardware::setJpegQuality(const CameraParameters& params) if (quality > 0 && quality <= 100) { mParameters.set(CameraParameters::KEY_JPEG_QUALITY, quality); } else { - ALOGE("Invalid jpeg quality=%d", quality); + LOGE("Invalid jpeg quality=%d", quality); rc = BAD_VALUE; } @@ -3876,7 +3876,7 @@ status_t QualcommCameraHardware::setJpegQuality(const CameraParameters& params) if (quality > 0 && quality <= 100) { mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, quality); } else { - ALOGE("Invalid jpeg thumbnail quality=%d", quality); + LOGE("Invalid jpeg thumbnail quality=%d", quality); rc = BAD_VALUE; } return rc; @@ -3895,14 +3895,14 @@ status_t QualcommCameraHardware::setEffect(const CameraParameters& params) if(!strcmp(sensorType->name, "2mp") && (value != CAMERA_EFFECT_OFF) &&(value != CAMERA_EFFECT_MONO) && (value != CAMERA_EFFECT_NEGATIVE) &&(value != CAMERA_EFFECT_SOLARIZE) && (value != CAMERA_EFFECT_SEPIA)) { - ALOGE("Special effect parameter is not supported for this sensor"); + LOGE("Special effect parameter is not supported for this sensor"); return NO_ERROR; } if(((value == CAMERA_EFFECT_MONO) || (value == CAMERA_EFFECT_NEGATIVE) || (value == CAMERA_EFFECT_AQUA) || (value == CAMERA_EFFECT_SEPIA)) && (value_wb != CAMERA_WB_AUTO)) { - ALOGE("Color Effect value will not be set " \ + LOGE("Color Effect value will not be set " \ "when the whitebalance selected is %s", str_wb); return NO_ERROR; } @@ -3914,14 +3914,14 @@ status_t QualcommCameraHardware::setEffect(const CameraParameters& params) } } } - ALOGE("Invalid effect value: %s", (str == NULL) ? "NULL" : str); + LOGE("Invalid effect value: %s", (str == NULL) ? "NULL" : str); return BAD_VALUE; } status_t QualcommCameraHardware::setAutoExposure(const CameraParameters& params) { if(!strcmp(sensorType->name, "2mp")) { - ALOGE("Auto Exposure not supported for this sensor"); + LOGE("Auto Exposure not supported for this sensor"); return NO_ERROR; } const char *str = params.get(CameraParameters::KEY_AUTO_EXPOSURE); @@ -3934,14 +3934,14 @@ status_t QualcommCameraHardware::setAutoExposure(const CameraParameters& params) return ret ? NO_ERROR : UNKNOWN_ERROR; } } - ALOGE("Invalid auto exposure value: %s", (str == NULL) ? "NULL" : str); + LOGE("Invalid auto exposure value: %s", (str == NULL) ? "NULL" : str); return BAD_VALUE; } status_t QualcommCameraHardware::setSharpness(const CameraParameters& params) { if(!strcmp(sensorType->name, "2mp")) { - ALOGE("Sharpness not supported for this sensor"); + LOGE("Sharpness not supported for this sensor"); return NO_ERROR; } int sharpness = params.getInt(CameraParameters::KEY_SHARPNESS); @@ -3949,7 +3949,7 @@ status_t QualcommCameraHardware::setSharpness(const CameraParameters& params) || sharpness > CAMERA_MAX_SHARPNESS)) return UNKNOWN_ERROR; - ALOGV("setting sharpness %d", sharpness); + LOGV("setting sharpness %d", sharpness); mParameters.set(CameraParameters::KEY_SHARPNESS, sharpness); bool ret = native_set_parm(CAMERA_SET_PARM_SHARPNESS, sizeof(sharpness), (void *)&sharpness); @@ -3959,7 +3959,7 @@ status_t QualcommCameraHardware::setSharpness(const CameraParameters& params) status_t QualcommCameraHardware::setContrast(const CameraParameters& params) { if(!strcmp(sensorType->name, "2mp")) { - ALOGE("Contrast not supported for this sensor"); + LOGE("Contrast not supported for this sensor"); return NO_ERROR; } int contrast = params.getInt(CameraParameters::KEY_CONTRAST); @@ -3967,7 +3967,7 @@ status_t QualcommCameraHardware::setContrast(const CameraParameters& params) || (contrast > CAMERA_MAX_CONTRAST)) return UNKNOWN_ERROR; - ALOGV("setting contrast %d", contrast); + LOGV("setting contrast %d", contrast); mParameters.set(CameraParameters::KEY_CONTRAST, contrast); bool ret = native_set_parm(CAMERA_SET_PARM_CONTRAST, sizeof(contrast), (void *)&contrast); @@ -3977,7 +3977,7 @@ status_t QualcommCameraHardware::setContrast(const CameraParameters& params) status_t QualcommCameraHardware::setSaturation(const CameraParameters& params) { if(!strcmp(sensorType->name, "2mp")) { - ALOGE("Saturation not supported for this sensor"); + LOGE("Saturation not supported for this sensor"); return NO_ERROR; } @@ -3992,13 +3992,13 @@ status_t QualcommCameraHardware::setSaturation(const CameraParameters& params) || (saturation > CAMERA_MAX_SATURATION)) return UNKNOWN_ERROR; - ALOGV("setting saturation %d", saturation); + LOGV("setting saturation %d", saturation); mParameters.set(CameraParameters::KEY_SATURATION, saturation); bool ret = native_set_parm(CAMERA_SET_PARM_SATURATION, sizeof(saturation), (void *)&saturation); return ret ? NO_ERROR : UNKNOWN_ERROR; } else { - ALOGE(" Saturation value will not be set " \ + LOGE(" Saturation value will not be set " \ "when the effect selected is %s", str); return NO_ERROR; } @@ -4007,7 +4007,7 @@ status_t QualcommCameraHardware::setSaturation(const CameraParameters& params) status_t QualcommCameraHardware::setBrightness(const CameraParameters& params) { int brightness = params.getInt("luma-adaptation"); if (mBrightness != brightness) { - ALOGV(" new brightness value : %d ", brightness); + LOGV(" new brightness value : %d ", brightness); mBrightness = brightness; bool ret = native_set_parm(CAMERA_SET_PARM_BRIGHTNESS, sizeof(mBrightness), @@ -4053,10 +4053,10 @@ status_t QualcommCameraHardware::setWhiteBalance(const CameraParameters& params) return ret ? NO_ERROR : UNKNOWN_ERROR; } } - ALOGE("Invalid whitebalance value: %s", (str == NULL) ? "NULL" : str); + LOGE("Invalid whitebalance value: %s", (str == NULL) ? "NULL" : str); return BAD_VALUE; } else { - ALOGE("Whitebalance value will not be set " \ + LOGE("Whitebalance value will not be set " \ "when the effect selected is %s", str_effect); return NO_ERROR; } @@ -4065,7 +4065,7 @@ status_t QualcommCameraHardware::setWhiteBalance(const CameraParameters& params) status_t QualcommCameraHardware::setFlash(const CameraParameters& params) { if (!mSensorInfo.flash_enabled) { - ALOGV("%s: flash not supported", __FUNCTION__); + LOGV("%s: flash not supported", __FUNCTION__); return NO_ERROR; } @@ -4079,14 +4079,14 @@ status_t QualcommCameraHardware::setFlash(const CameraParameters& params) return ret ? NO_ERROR : UNKNOWN_ERROR; } } - ALOGE("Invalid flash mode value: %s", (str == NULL) ? "NULL" : str); + LOGE("Invalid flash mode value: %s", (str == NULL) ? "NULL" : str); return BAD_VALUE; } status_t QualcommCameraHardware::setAntibanding(const CameraParameters& params) { if(!strcmp(sensorType->name, "2mp") || !strcmp(mSensorInfo.name, "ov5642")) { - ALOGE("Parameter AntiBanding is not supported for this sensor"); + LOGE("Parameter AntiBanding is not supported for this sensor"); return NO_ERROR; } return NO_ERROR; @@ -4108,7 +4108,7 @@ status_t QualcommCameraHardware::setAntibanding(const CameraParameters& params) return ret ? NO_ERROR : UNKNOWN_ERROR; } } - ALOGE("Invalid antibanding value: %s", (str == NULL) ? "NULL" : str); + LOGE("Invalid antibanding value: %s", (str == NULL) ? "NULL" : str); return BAD_VALUE; } @@ -4118,7 +4118,7 @@ status_t QualcommCameraHardware::setLensshadeValue(const CameraParameters& param (!strcmp(mSensorInfo.name, "vx6953")) || (!strcmp(mSensorInfo.name, "ov5642")) || (!strcmp(mSensorInfo.name, "VX6953")) ) { - ALOGI("Parameter Rolloff is not supported for this sensor"); + LOGI("Parameter Rolloff is not supported for this sensor"); return NO_ERROR; } const char *str = params.get(CameraParameters::KEY_LENSSHADE); @@ -4132,7 +4132,7 @@ status_t QualcommCameraHardware::setLensshadeValue(const CameraParameters& param return NO_ERROR; } } - ALOGE("Invalid lensShade value: %s", (str == NULL) ? "NULL" : str); + LOGE("Invalid lensShade value: %s", (str == NULL) ? "NULL" : str); return BAD_VALUE; } @@ -4162,7 +4162,7 @@ status_t QualcommCameraHardware::setISOValue(const CameraParameters& params) { return NO_ERROR; } } - ALOGE("Invalid Iso value: %s", (str == NULL) ? "NULL" : str); + LOGE("Invalid Iso value: %s", (str == NULL) ? "NULL" : str); return BAD_VALUE; } @@ -4225,7 +4225,7 @@ status_t QualcommCameraHardware::setRotation(const CameraParameters& params) || rotation == 270) { mParameters.set(CameraParameters::KEY_ROTATION, rotation); } else { - ALOGE("Invalid rotation value: %d", rotation); + LOGE("Invalid rotation value: %d", rotation); rc = BAD_VALUE; } } @@ -4247,7 +4247,7 @@ status_t QualcommCameraHardware::setZoom(const CameraParameters& params) static const int ZOOM_STEP = 1; int32_t zoom_level = params.getInt("zoom"); - ALOGV("Set zoom=%d", zoom_level); + LOGV("Set zoom=%d", zoom_level); if(zoom_level >= 0 && zoom_level <= mMaxZoom) { mParameters.set("zoom", zoom_level); int32_t zoom_value = ZOOM_STEP * zoom_level; @@ -4274,7 +4274,7 @@ status_t QualcommCameraHardware::setFocusMode(const CameraParameters& params) return NO_ERROR; } } - ALOGE("Invalid focus mode value: %s", (str == NULL) ? "NULL" : str); + LOGE("Invalid focus mode value: %s", (str == NULL) ? "NULL" : str); return BAD_VALUE; } @@ -4288,7 +4288,7 @@ status_t QualcommCameraHardware::setOrientation(const CameraParameters& params) // pictures should be rotated. mParameters.set("orientation", str); } else { - ALOGE("Invalid orientation value: %s", str); + LOGE("Invalid orientation value: %s", str); return BAD_VALUE; } } @@ -4305,7 +4305,7 @@ status_t QualcommCameraHardware::setPictureFormat(const CameraParameters& params if(value != NOT_FOUND){ mParameters.set(CameraParameters::KEY_PICTURE_FORMAT, str); } else { - ALOGE("Invalid Picture Format value: %s", str); + LOGE("Invalid Picture Format value: %s", str); return BAD_VALUE; } } @@ -4349,7 +4349,7 @@ QualcommCameraHardware::AshmemPool::AshmemPool(int buffer_size, int num_buffers, frame_size, name) { - ALOGV("constructing MemPool %s backed by ashmem: " + LOGV("constructing MemPool %s backed by ashmem: " "%d frames @ %d uint8_ts, " "buffer size %d", mName, @@ -4389,13 +4389,13 @@ QualcommCameraHardware::PmemPool::PmemPool(const char *pmem_pool, mPmemType(pmem_type), mCameraControlFd(dup(camera_control_fd)) { - ALOGV("constructing MemPool %s backed by pmem pool %s: " + LOGV("constructing MemPool %s backed by pmem pool %s: " "%d frames @ %d bytes, buffer size %d", mName, pmem_pool, num_buffers, frame_size, buffer_size); - ALOGV("%s: duplicating control fd %d --> %d", + LOGV("%s: duplicating control fd %d --> %d", __FUNCTION__, camera_control_fd, mCameraControlFd); @@ -4407,7 +4407,7 @@ QualcommCameraHardware::PmemPool::PmemPool(const char *pmem_pool, new MemoryHeapBase(pmem_pool, mAlignedSize, flags); if (masterHeap->getHeapID() < 0) { - ALOGE("failed to construct master heap for pmem pool %s", pmem_pool); + LOGE("failed to construct master heap for pmem pool %s", pmem_pool); masterHeap.clear(); return; } @@ -4421,30 +4421,30 @@ QualcommCameraHardware::PmemPool::PmemPool(const char *pmem_pool, mFd = mHeap->getHeapID(); if (::ioctl(mFd, PMEM_GET_SIZE, &mSize)) { - ALOGE("pmem pool %s ioctl(PMEM_GET_SIZE) error %s (%d)", + LOGE("pmem pool %s ioctl(PMEM_GET_SIZE) error %s (%d)", pmem_pool, ::strerror(errno), errno); mHeap.clear(); return; } - ALOGV("pmem pool %s ioctl(fd = %d, PMEM_GET_SIZE) is %ld", + LOGV("pmem pool %s ioctl(fd = %d, PMEM_GET_SIZE) is %ld", pmem_pool, mFd, mSize.len); - ALOGD("mBufferSize=%d, mAlignedBufferSize=%d\n", mBufferSize, mAlignedBufferSize); + LOGD("mBufferSize=%d, mAlignedBufferSize=%d\n", mBufferSize, mAlignedBufferSize); // Unregister preview buffers with the camera drivers. Allow the VFE to write // to all preview buffers except for the last one. // Only Register the preview, snapshot and thumbnail buffers with the kernel. if( (strcmp("postview", mName) != 0) ){ int num_buf = num_buffers; if(!strcmp("preview", mName)) num_buf = kPreviewBufferCount; - ALOGD("num_buffers = %d", num_buf); + LOGD("num_buffers = %d", num_buf); for (int cnt = 0; cnt < num_buf; ++cnt) { int active = 1; if(pmem_type == MSM_PMEM_VIDEO){ active = (cnt 0) delete [] mBuffers; mHeap.clear(); - ALOGV("destroying MemPool %s completed", mName); + LOGV("destroying MemPool %s completed", mName); } static bool register_buf(int camfd, @@ -4531,14 +4531,14 @@ static bool register_buf(int camfd, pmemBuf.active = vfe_can_write; - ALOGV("register_buf: camfd = %d, reg = %d buffer = %p can_write = %d", + LOGV("register_buf: camfd = %d, reg = %d buffer = %p can_write = %d", camfd, !register_buffer, buf, pmemBuf.active); if (ioctl(camfd, register_buffer ? MSM_CAM_IOCTL_REGISTER_PMEM : MSM_CAM_IOCTL_UNREGISTER_PMEM, &pmemBuf) < 0) { - ALOGE("register_buf: MSM_CAM_IOCTL_(UN)REGISTER_PMEM fd %d error %s", + LOGE("register_buf: MSM_CAM_IOCTL_(UN)REGISTER_PMEM fd %d error %s", camfd, strerror(errno)); return false; @@ -4581,34 +4581,34 @@ static void receive_camframe_callback(struct msm_frame *frame) static void receive_jpeg_fragment_callback(uint8_t *buff_ptr, uint32_t buff_size) { - ALOGV("receive_jpeg_fragment_callback E"); + LOGV("receive_jpeg_fragment_callback E"); sp obj = QualcommCameraHardware::getInstance(); if (obj != 0) { obj->receiveJpegPictureFragment(buff_ptr, buff_size); } - ALOGV("receive_jpeg_fragment_callback X"); + LOGV("receive_jpeg_fragment_callback X"); } static void receive_jpeg_callback(jpeg_event_t status) { - ALOGV("receive_jpeg_callback E (completion status %d)", status); + LOGV("receive_jpeg_callback E (completion status %d)", status); if (status == JPEG_EVENT_DONE) { sp obj = QualcommCameraHardware::getInstance(); if (obj != 0) { obj->receiveJpegPicture(); } } - ALOGV("receive_jpeg_callback X"); + LOGV("receive_jpeg_callback X"); } // 720p : video frame calbback from camframe static void receive_camframe_video_callback(struct msm_frame *frame) { - ALOGV("receive_camframe_video_callback E"); + LOGV("receive_camframe_video_callback E"); sp obj = QualcommCameraHardware::getInstance(); if (obj != 0) { obj->receiveRecordingFrame(frame); } - ALOGV("receive_camframe_video_callback X"); + LOGV("receive_camframe_video_callback X"); } void QualcommCameraHardware::setCallbacks(notify_callback notify_cb, @@ -4648,19 +4648,19 @@ bool QualcommCameraHardware::useOverlay(void) } else mUseOverlay = FALSE; - ALOGV(" Using Overlay : %s ", mUseOverlay ? "YES" : "NO" ); + LOGV(" Using Overlay : %s ", mUseOverlay ? "YES" : "NO" ); return mUseOverlay; } status_t QualcommCameraHardware::setOverlay(const sp &Overlay) { if( Overlay != NULL) { - ALOGV(" Valid overlay object "); + LOGV(" Valid overlay object "); mOverlayLock.lock(); mOverlay = Overlay; mOverlayLock.unlock(); } else { - ALOGV(" Overlay object NULL. returning "); + LOGV(" Overlay object NULL. returning "); mOverlay = NULL; return UNKNOWN_ERROR; } @@ -4668,13 +4668,13 @@ status_t QualcommCameraHardware::setOverlay(const sp &Overlay) } void QualcommCameraHardware::receive_camframetimeout(void) { - ALOGV("receive_camframetimeout: E"); + LOGV("receive_camframetimeout: E"); Mutex::Autolock l(&mCamframeTimeoutLock); - ALOGD(" Camframe timed out. Not receiving any frames from camera driver "); + LOGD(" Camframe timed out. Not receiving any frames from camera driver "); camframe_timeout_flag = TRUE; mNotifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_UKNOWN, 0, mCallbackCookie); - ALOGV("receive_camframetimeout: X"); + LOGV("receive_camframetimeout: X"); } static void receive_camframetimeout_callback(void) { @@ -4685,20 +4685,20 @@ static void receive_camframetimeout_callback(void) { } void QualcommCameraHardware::storePreviewFrameForPostview(void) { - ALOGV(" storePreviewFrameForPostview : E "); + LOGV(" storePreviewFrameForPostview : E "); /* Since there is restriction on the maximum overlay dimensions * that can be created, we use the last preview frame as postview * for 7x30. */ - ALOGV(" Copying the preview buffer to postview buffer %d ", + LOGV(" Copying the preview buffer to postview buffer %d ", mPreviewFrameSize); if( mPostViewHeap != NULL && mLastQueuedFrame != NULL) { memcpy(mPostViewHeap->mHeap->base(), (uint8_t *)mLastQueuedFrame, mPreviewFrameSize ); } else - ALOGE(" Failed to store Preview frame. No Postview "); + LOGE(" Failed to store Preview frame. No Postview "); - ALOGV(" storePreviewFrameForPostview : X "); + LOGV(" storePreviewFrameForPostview : X "); } bool QualcommCameraHardware::isValidDimension(int width, int height) { @@ -4730,44 +4730,44 @@ bool QualcommCameraHardware::isValidDimension(int width, int height) { } status_t QualcommCameraHardware::getBufferInfo(sp& Frame, size_t *alignedSize) { status_t ret; - ALOGV(" getBufferInfo : E "); + LOGV(" getBufferInfo : E "); if( ( mCurrentTarget == TARGET_MSM7630 ) || (mCurrentTarget == TARGET_QSD8250) ) { if( mRecordHeap != NULL){ - ALOGV(" Setting valid buffer information "); + LOGV(" Setting valid buffer information "); Frame = mRecordHeap->mBuffers[0]; if( alignedSize != NULL) { *alignedSize = mRecordHeap->mAlignedBufferSize; - ALOGV(" HAL : alignedSize = %d ", *alignedSize); + LOGV(" HAL : alignedSize = %d ", *alignedSize); ret = NO_ERROR; } else { - ALOGE(" HAL : alignedSize is NULL. Cannot update alignedSize "); + LOGE(" HAL : alignedSize is NULL. Cannot update alignedSize "); ret = UNKNOWN_ERROR; } } else { - ALOGE(" RecordHeap is null. Buffer information wont be updated "); + LOGE(" RecordHeap is null. Buffer information wont be updated "); Frame = NULL; ret = UNKNOWN_ERROR; } } else { if(mPreviewHeap != NULL) { - ALOGV(" Setting valid buffer information "); + LOGV(" Setting valid buffer information "); Frame = mPreviewHeap->mBuffers[0]; if( alignedSize != NULL) { *alignedSize = mPreviewHeap->mAlignedBufferSize; - ALOGV(" HAL : alignedSize = %d ", *alignedSize); + LOGV(" HAL : alignedSize = %d ", *alignedSize); ret = NO_ERROR; } else { - ALOGE(" HAL : alignedSize is NULL. Cannot update alignedSize "); + LOGE(" HAL : alignedSize is NULL. Cannot update alignedSize "); ret = UNKNOWN_ERROR; } } else { - ALOGE(" PreviewHeap is null. Buffer information wont be updated "); + LOGE(" PreviewHeap is null. Buffer information wont be updated "); Frame = NULL; ret = UNKNOWN_ERROR; } } - ALOGV(" getBufferInfo : X "); + LOGV(" getBufferInfo : X "); return ret; }