| /*Copyright (c) 2016, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| #include "QCameraHAL3MainTestContext.h" |
| #include "QCameraHAL3SnapshotTest.h" |
| #include "QCameraHAL3RawSnapshotTest.h" |
| #include "QCameraHAL3PreviewTest.h" |
| |
| #ifdef QCAMERA_HAL3_SUPPORT |
| #define LIB_PATH /usr/lib/hw/camera.msm8953.so |
| #else |
| #define LIB_PATH /system/lib/hw/camera.msm8953.so |
| #endif |
| |
| extern "C" { |
| extern int set_camera_metadata_vendor_ops(const vendor_tag_ops_t *query_ops); |
| } |
| |
| /*#ifdef CAMERA_CHIPSET_8953 |
| #define CHIPSET_LIB lib/hw/camera.msm8953.so |
| #else |
| #define CHIPSET_LIB lib/hw/camera.msm8937.so |
| #endif*/ |
| |
| #define CAM_LIB(s) STR_LIB_PATH(s) |
| #define STR_LIB_PATH(s) #s |
| |
| namespace qcamera { |
| |
| QCameraHAL3PreviewTest *mPreviewtestCase = NULL; |
| QCameraHAL3VideoTest *mVideotestCase = NULL; |
| QCameraHAL3SnapshotTest *mSnapshottestCase = NULL; |
| QCameraHAL3RawSnapshotTest *mRawSnapshottestCase = NULL; |
| |
| struct timeval start_time; |
| int capture_received; |
| int pfd[2]; |
| extern int test_case_end; |
| extern int snapshot_buffer; |
| |
| pthread_cond_t mRequestAppCond; |
| std::list<uint32_t> PreviewQueue; |
| std::list<uint32_t> VideoQueue; |
| |
| pthread_mutex_t TestAppLock = PTHREAD_MUTEX_INITIALIZER; |
| pthread_mutex_t mCaptureRequestLock = PTHREAD_MUTEX_INITIALIZER; |
| |
| |
| |
| static void camera_device_status_change( |
| const struct camera_module_callbacks* callbacks, |
| int camera_id, int new_status) |
| { |
| /* Stub function */ |
| if (callbacks == NULL) { |
| LOGD("Parameters are NULL %d %d", camera_id, new_status); |
| } |
| } |
| |
| static void torch_mode_status_change( |
| const struct camera_module_callbacks* callbacks, |
| const char* camera_id, int new_status) |
| { |
| /* Stub function */ |
| if((callbacks == NULL) || (camera_id == NULL)) { |
| LOGD("Parameters are NULL %d", new_status); |
| } |
| } |
| |
| static void Notify( |
| const camera3_callback_ops *cb, |
| const camera3_notify_msg *msg) |
| { |
| /* Stub function */ |
| if((cb == NULL) || (msg == NULL)) { |
| LOGD("Parameters are NULL "); |
| } |
| } |
| |
| static void ProcessCaptureResult( |
| const camera3_callback_ops *cb, |
| const camera3_capture_result *result) |
| { |
| buffer_thread_msg_t msg; |
| extern CameraHAL3Base *mCamHal3Base; |
| int frame_num; |
| extern int req_sent; |
| extern int preview_buffer_allocated; |
| extern int video_buffer_allocated; |
| int num; |
| if(cb == NULL) { |
| LOGD("callback returned is NULL"); |
| } |
| LOGD("Cam Capture Result Callback %d and %d", |
| result->num_output_buffers, mCamHal3Base->mFrameCount); |
| if (mCamHal3Base->mTestCaseSelected == MENU_START_PREVIEW || |
| mCamHal3Base->mTestCaseSelected == MENU_START_VIDEO) { |
| if (result->num_output_buffers == 1) { |
| frame_num = result->frame_number; |
| LOGD("Frame width:%d and height:%d and format:%d", |
| result->output_buffers->stream->width, |
| result->output_buffers->stream->height, |
| result->output_buffers->stream->format); |
| (mCamHal3Base->mFrameCount)++; |
| LOGD("Preview/Video Capture Result %d and fcount: %d and req_Sent:%d and %d ", |
| result->num_output_buffers, mCamHal3Base->mFrameCount, req_sent, result->frame_number); |
| if (test_case_end == 0) { |
| if (mCamHal3Base->mTestCaseSelected == MENU_START_PREVIEW) { |
| num = (result->frame_number)%preview_buffer_allocated; |
| PreviewQueue.push_back(num); |
| } |
| else { |
| num = (result->frame_number)%video_buffer_allocated; |
| VideoQueue.push_back(num); |
| } |
| pthread_cond_signal(&mRequestAppCond); |
| memset(&msg, 0, sizeof(buffer_thread_msg_t)); |
| } |
| } |
| } |
| else { |
| extern int fcount_captured; |
| if (result->num_output_buffers == 1) { |
| LOGD("snapshot/Raw Capture1 Result Callback %d and %d", |
| result->num_output_buffers, fcount_captured); |
| (mCamHal3Base->mFrameCount)++; |
| fcount_captured++; |
| LOGD("\n Capture %d done preparing for capture ", fcount_captured); |
| memset(&msg, 0, sizeof(buffer_thread_msg_t)); |
| write(pfd[1], &msg, sizeof(buffer_thread_msg_t)); |
| } |
| } |
| } |
| |
| CameraHAL3Base::CameraHAL3Base(int cameraIndex) : |
| mCameraIndex(cameraIndex), |
| mLibHandle(NULL), |
| mFrameCount(0), |
| mSecElapsed(1), |
| mTestCaseSelected(0), |
| mPreviewRunning(0), |
| mVideoRunning(0), |
| mSnapShotRunning(0) |
| { |
| |
| } |
| |
| |
| int CameraHAL3Base::hal3appCameraTestLoad() |
| { |
| int rc = HAL3_CAM_OK; |
| int numCam; |
| int32_t res = 0; |
| hal3_camera_test_obj_t *my_test_obj; |
| mLibHandle = new hal3_camera_lib_test; |
| memset(mLibHandle, 0, sizeof(hal3_camera_lib_handle)); |
| rc = hal3appTestLoad(&mLibHandle->app_obj); |
| camera_module_t *my_if_handle = mLibHandle->app_obj.hal3_lib.halModule_t; |
| if (HAL3_CAM_OK != rc) { |
| LOGE("hal3 err\n"); |
| goto EXIT; |
| } |
| |
| numCam = my_if_handle->get_number_of_cameras(); |
| printf("\n Number of Cameras are : %d ", numCam); |
| if (my_if_handle->get_vendor_tag_ops) { |
| mLibHandle->app_obj.mVendorTagOps = vendor_tag_ops_t(); |
| my_if_handle->get_vendor_tag_ops(&(mLibHandle->app_obj.mVendorTagOps)); |
| |
| res = set_camera_metadata_vendor_ops(&(mLibHandle->app_obj.mVendorTagOps)); |
| if (0 != res) { |
| printf("%s: Could not set vendor tag descriptor, " |
| "received error %s (%d). \n", __func__, |
| strerror(-res), res); |
| goto EXIT; |
| } |
| } |
| my_test_obj = &(mLibHandle->test_obj); |
| my_test_obj->module_cb.torch_mode_status_change = &torch_mode_status_change; |
| my_test_obj->module_cb.camera_device_status_change = &camera_device_status_change; |
| my_if_handle->set_callbacks(&(my_test_obj->module_cb)); |
| my_if_handle->get_camera_info(0, &(mLibHandle->test_obj.cam_info)); |
| camcap_info = mLibHandle->test_obj.cam_info; |
| hal3app_cam_settings = (camcap_info.static_camera_characteristics); |
| display_capability(); |
| return numCam; |
| EXIT: |
| return rc; |
| |
| } |
| |
| void CameraHAL3Base::display_capability() |
| { |
| ALOGE("Camera Here"); |
| int i,j; |
| int *available_ir_modes = NULL, *available_svhdr_mode = NULL, count_stream; |
| if(hal3app_cam_settings.exists(QCAMERA3_IR_AVAILABLE_MODES)) { |
| ALOGE("\n mrad check1 "); |
| entry_hal3app = hal3app_cam_settings.find(QCAMERA3_IR_AVAILABLE_MODES); |
| available_ir_modes = (int *) malloc((entry_hal3app.count)*sizeof(int )); |
| for(i =0;i < (int)entry_hal3app.count; i++){ |
| available_ir_modes[i] = entry_hal3app.data.i32[i]; |
| ALOGE("\n mrad cap %d ", available_ir_modes[i]); |
| |
| } |
| } |
| } |
| |
| int CameraHAL3Base::hal3appCameraLibOpen(int camid) |
| { |
| int rc; |
| rc = hal3appCamOpen(&mLibHandle->app_obj, (int)camid, &(mLibHandle->test_obj)); |
| if (rc != HAL3_CAM_OK) { |
| LOGE("hal3appCamOpen() camidx=%d, err=%d\n", |
| camid, rc); |
| goto EXIT; |
| } |
| rc = hal3appCamInitialize((int)camid, &mLibHandle->test_obj); |
| EXIT: |
| return rc; |
| } |
| |
| int CameraHAL3Base::hal3appTestLoad(hal3_camera_app_t *my_hal3_app) |
| { |
| memset(&my_hal3_app->hal3_lib, 0, sizeof(hal3_interface_lib_t)); |
| printf("\nLibrary path is :%s", CAM_LIB(LIB_PATH)); |
| my_hal3_app->hal3_lib.ptr = dlopen(CAM_LIB(LIB_PATH), RTLD_NOW); |
| |
| if (!my_hal3_app->hal3_lib.ptr) { |
| LOGE("Error opening HAL libraries %s\n", |
| dlerror()); |
| return -HAL3_CAM_E_GENERAL; |
| } |
| my_hal3_app->hal3_lib.halModule_t = |
| (camera_module_t*)dlsym(my_hal3_app->hal3_lib.ptr, HAL_MODULE_INFO_SYM_AS_STR); |
| if (my_hal3_app->hal3_lib.halModule_t == NULL) { |
| LOGE("Error opening HAL library %s\n", |
| dlerror()); |
| return -HAL3_CAM_E_GENERAL; |
| } |
| return HAL3_CAM_OK; |
| } |
| |
| int CameraHAL3Base::hal3appCamOpen( |
| hal3_camera_app_t *my_hal3_app, |
| int camid, |
| hal3_camera_test_obj_t *my_test_obj) |
| { |
| camera_module_t *my_if_handle = my_hal3_app->hal3_lib.halModule_t; |
| my_if_handle->common.methods->open(&(my_if_handle->common), "0", |
| reinterpret_cast<hw_device_t**>(&(my_test_obj->device))); |
| printf("\n Camera ID %d Opened \n", camid); |
| return HAL3_CAM_OK; |
| } |
| |
| int CameraHAL3Base::hal3appCamInitialize(int camid, hal3_camera_test_obj_t *my_test_obj) |
| { |
| int rc = 0; |
| camera3_device_t *device_handle = my_test_obj->device; |
| my_test_obj->callback_ops.notify = &Notify; |
| my_test_obj->callback_ops.process_capture_result = &ProcessCaptureResult; |
| rc = device_handle->ops->initialize(my_test_obj->device, &(my_test_obj->callback_ops)); |
| if (rc != HAL3_CAM_OK) { |
| LOGE("hal3appCamInitialize() camidx=%d, err=%d\n", |
| camid, rc); |
| goto EXIT; |
| } |
| EXIT: |
| return rc; |
| } |
| |
| |
| void CameraHAL3Base::hal3appCheckStream(int testcase, int camid) |
| { |
| if (testcase != MENU_START_PREVIEW) { |
| if (mPreviewtestCase != NULL) { |
| mPreviewtestCase->previewTestEnd(mLibHandle, camid); |
| delete mPreviewtestCase; |
| mPreviewtestCase = NULL; |
| } |
| } |
| if (testcase != MENU_START_VIDEO){ |
| if (mVideotestCase != NULL) { |
| mVideotestCase->videoTestEnd(mLibHandle, camid); |
| delete mVideotestCase; |
| mVideotestCase = NULL; |
| } |
| } |
| |
| if (testcase != MENU_START_CAPTURE){ |
| if (mSnapshottestCase != NULL) { |
| delete mSnapshottestCase; |
| mSnapshottestCase = NULL; |
| } |
| } |
| |
| if (testcase != MENU_START_RAW_CAPTURE) { |
| if (mRawSnapshottestCase != NULL) { |
| delete mRawSnapshottestCase; |
| mRawSnapshottestCase = NULL; |
| } |
| } |
| } |
| |
| |
| int CameraHAL3Base::hal3appCameraPreviewInit(int testcase, int camid, int w, int h) |
| { |
| extern int req_sent; |
| int testCaseEndComplete = 0; |
| if (w == 0 || h == 0) { |
| printf("\n Frame dimension is wrong"); |
| return -1; |
| } |
| if ( mPreviewtestCase != NULL) { |
| if(testcase == MENU_TOGGLE_IR_MODE) { |
| ALOGE("\n IR mode requested is :%d", ir_mode); |
| mPreviewtestCase->ir_mode = ir_mode; |
| } |
| if(testcase == MENU_TOGGLE_SVHDR_MODE) { |
| ALOGE("\n SVHDR mode requested is :%d", svhdr_mode); |
| mPreviewtestCase->svhdr_mode = svhdr_mode; |
| } |
| return 0; |
| } |
| else { |
| testCaseEndComplete = 0; |
| do { |
| if (mVideoRunning == 1) { |
| hal3appCheckStream(MENU_START_PREVIEW, camid); |
| } |
| pthread_mutex_lock(&TestAppLock); |
| mTestCaseSelected = MENU_START_PREVIEW; |
| if (mVideoRunning != 1) { |
| hal3appCheckStream(MENU_START_PREVIEW, camid); |
| } |
| mPreviewtestCase = new QCameraHAL3PreviewTest(0); |
| printf("\n\n Testing the Resolution : %d X %d", w, h); |
| req_sent = 0; |
| PreviewQueue.clear(); |
| capture_received = 0; mSecElapsed = 1; |
| snapshot_buffer = -1; mFrameCount = 0; |
| mPreviewtestCase->width = w; mPreviewtestCase->height = h; |
| mPreviewtestCase->ir_mode = 0; mPreviewtestCase->svhdr_mode = 0; |
| mPreviewtestCase->initTest(mLibHandle, |
| (int) MENU_START_PREVIEW, camid, w, h); |
| testCaseEndComplete = 1; |
| }while(testCaseEndComplete != 1); |
| } |
| return 0; |
| } |
| |
| int CameraHAL3Base::hal3appCameraVideoInit(int testcase, int camid, int w, int h) |
| { |
| extern int req_sent; |
| int testCaseEndComplete = 0; |
| if (w == 0 || h == 0) { |
| printf("\n Frame dimension is wrong"); |
| return -1; |
| } |
| |
| if (mVideotestCase != NULL) { |
| LOGD("testcase is : %d", testcase); |
| return 0; |
| } |
| else { |
| testCaseEndComplete = 0; |
| do { |
| if (mPreviewRunning == 1) { |
| hal3appCheckStream(MENU_START_VIDEO, camid); |
| } |
| pthread_mutex_lock(&TestAppLock); |
| mTestCaseSelected = MENU_START_VIDEO; |
| if (mPreviewRunning != 1) { |
| hal3appCheckStream(MENU_START_VIDEO, camid); |
| } |
| mVideotestCase = new QCameraHAL3VideoTest(0); |
| VideoQueue.clear(); |
| printf("\n\nTesting the Resolution : %d X %d", w, h); |
| req_sent = 0; |
| capture_received =0; mSecElapsed = 1; test_case_end = 0; |
| mVideotestCase->width = w; mVideotestCase->height = h; |
| snapshot_buffer = -1; mFrameCount = 0; |
| mVideotestCase->initTest(mLibHandle, |
| (int) MENU_START_VIDEO, camid, w, h); |
| testCaseEndComplete = 1; |
| }while(testCaseEndComplete !=1); |
| } |
| return 0; |
| } |
| |
| |
| int CameraHAL3Base::hal3appRawCaptureInit(hal3_camera_lib_test *handle, int camid, int req_cap) |
| { |
| int testCaseEndComplete = 0; |
| if(handle == NULL) { |
| LOGE("Camera Handle is NULL"); |
| } |
| if (mSnapShotRunning != 1) { |
| hal3appCheckStream(MENU_START_RAW_CAPTURE, camid); |
| } |
| testCaseEndComplete = 0; |
| do { |
| pthread_mutex_lock(&TestAppLock); |
| if (mSnapShotRunning == 1) { |
| hal3appCheckStream(MENU_START_RAW_CAPTURE, camid); |
| } |
| printf("\n capture:%d", req_cap); |
| mTestCaseSelected = MENU_START_RAW_CAPTURE; |
| mRawSnapshottestCase = new QCameraHAL3RawSnapshotTest(req_cap); |
| mRawSnapshottestCase->mRequestedCapture = req_cap; |
| mRawSnapshottestCase->initTest(mLibHandle, |
| (int) MENU_START_RAW_CAPTURE, camid, RAWSNAPSHOT_CAPTURE_WIDTH, |
| RAWSNAPSHOT_CAPTURE_HEIGHT); |
| testCaseEndComplete = 1; |
| }while(testCaseEndComplete !=1); |
| return 0; |
| } |
| |
| int CameraHAL3Base::hal3appCameraCaptureInit(hal3_camera_lib_test *handle, |
| int camid, int req_cap) |
| { |
| int testCaseEndComplete = 0; |
| if(handle == NULL) { |
| LOGE("Camera Handle is NULL"); |
| } |
| if (mSnapShotRunning != 1) { |
| hal3appCheckStream(MENU_START_CAPTURE, camid); |
| } |
| testCaseEndComplete = 0; |
| do { |
| pthread_mutex_lock(&TestAppLock); |
| if (mSnapShotRunning == 1) { |
| hal3appCheckStream(MENU_START_CAPTURE, camid); |
| } |
| printf("\n capture:%d", req_cap); |
| mTestCaseSelected = MENU_START_CAPTURE; |
| mSnapshottestCase = new QCameraHAL3SnapshotTest(req_cap); |
| mSnapshottestCase->mRequestedCapture = req_cap; |
| mSnapshottestCase->initTest(mLibHandle, |
| (int) MENU_START_CAPTURE, camid, SNAPSHOT_CAPTURE_WIDTH, SNAPSHOT_CAPTURE_HEIGHT); |
| testCaseEndComplete = 1; |
| }while(testCaseEndComplete != 1); |
| return 0; |
| } |
| |
| } |
| |
