Home | History | Annotate | Download | only in test 
      1 /*Copyright (c) 2016, The Linux Foundation. All rights reserved.
      2 *
      3 * Redistribution and use in source and binary forms, with or without
      4 * modification, are permitted provided that the following conditions are
      5 * met:
      6 *     * Redistributions of source code must retain the above copyright
      7 *       notice, this list of conditions and the following disclaimer.
      8 *     * Redistributions in binary form must reproduce the above
      9 *       copyright notice, this list of conditions and the following
     10 *       disclaimer in the documentation and/or other materials provided
     11 *       with the distribution.
     12 *     * Neither the name of The Linux Foundation nor the names of its
     13 *       contributors may be used to endorse or promote products derived
     14 *       from this software without specific prior written permission.
     15 *
     16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
     17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
     19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
     20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 *
     28 */
     29 
     30 #include "QCameraHAL3MainTestContext.h"
     31 #include "QCameraHAL3SnapshotTest.h"
     32 #include "QCameraHAL3RawSnapshotTest.h"
     33 #include "QCameraHAL3PreviewTest.h"
     34 
     35 #ifdef QCAMERA_HAL3_SUPPORT
     36 #define LIB_PATH /usr/lib/hw/camera.msm8953.so
     37 #else
     38 #define LIB_PATH /system/lib/hw/camera.msm8953.so
     39 #endif
     40 
     41 extern "C" {
     42 extern int set_camera_metadata_vendor_ops(const vendor_tag_ops_t *query_ops);
     43 }
     44 
     45 /*#ifdef CAMERA_CHIPSET_8953
     46 #define CHIPSET_LIB lib/hw/camera.msm8953.so
     47 #else
     48 #define CHIPSET_LIB lib/hw/camera.msm8937.so
     49 #endif*/
     50 
     51 #define CAM_LIB(s) STR_LIB_PATH(s)
     52 #define STR_LIB_PATH(s) #s
     53 
     54 namespace qcamera {
     55 
     56 QCameraHAL3PreviewTest *mPreviewtestCase = NULL;
     57 QCameraHAL3VideoTest *mVideotestCase = NULL;
     58 QCameraHAL3SnapshotTest *mSnapshottestCase = NULL;
     59 QCameraHAL3RawSnapshotTest *mRawSnapshottestCase = NULL;
     60 
     61 struct timeval start_time;
     62 int capture_received;
     63 int pfd[2];
     64 extern int test_case_end;
     65 extern int snapshot_buffer;
     66 
     67 pthread_cond_t mRequestAppCond;
     68 std::list<uint32_t> PreviewQueue;
     69 std::list<uint32_t> VideoQueue;
     70 
     71 pthread_mutex_t TestAppLock = PTHREAD_MUTEX_INITIALIZER;
     72 pthread_mutex_t mCaptureRequestLock = PTHREAD_MUTEX_INITIALIZER;
     73 
     74 
     75 
     76 static void camera_device_status_change(
     77         const struct camera_module_callbacks* callbacks,
     78         int camera_id, int new_status)
     79 {
     80     /* Stub function */
     81     if (callbacks == NULL) {
     82         LOGD("Parameters are NULL %d %d", camera_id, new_status);
     83     }
     84 }
     85 
     86 static void torch_mode_status_change(
     87         const struct camera_module_callbacks* callbacks,
     88         const char* camera_id, int new_status)
     89 {
     90     /* Stub function */
     91     if((callbacks == NULL) || (camera_id == NULL)) {
     92         LOGD("Parameters are NULL %d", new_status);
     93     }
     94 }
     95 
     96 static void Notify(
     97         const camera3_callback_ops *cb,
     98         const camera3_notify_msg *msg)
     99 {
    100     /* Stub function */
    101     if((cb == NULL) || (msg == NULL)) {
    102         LOGD("Parameters are NULL ");
    103     }
    104 }
    105 
    106 static void ProcessCaptureResult(
    107         const camera3_callback_ops *cb,
    108         const camera3_capture_result *result)
    109 {
    110     buffer_thread_msg_t msg;
    111     extern CameraHAL3Base *mCamHal3Base;
    112     int frame_num;
    113     extern int req_sent;
    114     extern int preview_buffer_allocated;
    115     extern int video_buffer_allocated;
    116     int num;
    117     if(cb == NULL) {
    118         LOGD("callback returned is NULL");
    119     }
    120     LOGD("Cam Capture Result Callback %d and %d",
    121             result->num_output_buffers, mCamHal3Base->mFrameCount);
    122     if (mCamHal3Base->mTestCaseSelected == MENU_START_PREVIEW ||
    123             mCamHal3Base->mTestCaseSelected == MENU_START_VIDEO) {
    124         if (result->num_output_buffers == 1) {
    125             frame_num = result->frame_number;
    126             LOGD("Frame width:%d and height:%d and format:%d",
    127                     result->output_buffers->stream->width,
    128                     result->output_buffers->stream->height,
    129                     result->output_buffers->stream->format);
    130             (mCamHal3Base->mFrameCount)++;
    131             LOGD("Preview/Video Capture Result %d and fcount: %d and req_Sent:%d and %d ",
    132             result->num_output_buffers, mCamHal3Base->mFrameCount, req_sent, result->frame_number);
    133             if (test_case_end == 0) {
    134                 if (mCamHal3Base->mTestCaseSelected == MENU_START_PREVIEW) {
    135                     num = (result->frame_number)%preview_buffer_allocated;
    136                     PreviewQueue.push_back(num);
    137                 }
    138                 else {
    139                     num = (result->frame_number)%video_buffer_allocated;
    140                            VideoQueue.push_back(num);
    141                 }
    142                 pthread_cond_signal(&mRequestAppCond);
    143                 memset(&msg, 0, sizeof(buffer_thread_msg_t));
    144             }
    145         }
    146     }
    147     else {
    148         extern int fcount_captured;
    149         if (result->num_output_buffers == 1) {
    150             LOGD("snapshot/Raw Capture1 Result Callback %d and %d",
    151                     result->num_output_buffers, fcount_captured);
    152             (mCamHal3Base->mFrameCount)++;
    153             fcount_captured++;
    154             LOGD("\n Capture %d done preparing for capture ", fcount_captured);
    155             memset(&msg, 0, sizeof(buffer_thread_msg_t));
    156             write(pfd[1], &msg, sizeof(buffer_thread_msg_t));
    157         }
    158     }
    159 }
    160 
    161 CameraHAL3Base::CameraHAL3Base(int cameraIndex) :
    162     mCameraIndex(cameraIndex),
    163     mLibHandle(NULL),
    164     mFrameCount(0),
    165     mSecElapsed(1),
    166     mTestCaseSelected(0),
    167     mPreviewRunning(0),
    168     mVideoRunning(0),
    169     mSnapShotRunning(0),
    170     binning_mode(0)
    171 {
    172 
    173 }
    174 
    175 
    176 int CameraHAL3Base::hal3appCameraTestLoad()
    177 {
    178     int rc = HAL3_CAM_OK;
    179     int numCam;
    180     int32_t res = 0;
    181     hal3_camera_test_obj_t *my_test_obj;
    182     mLibHandle = new hal3_camera_lib_test;
    183     memset(mLibHandle, 0, sizeof(hal3_camera_lib_handle));
    184     rc = hal3appTestLoad(&mLibHandle->app_obj);
    185     camera_module_t *my_if_handle = mLibHandle->app_obj.hal3_lib.halModule_t;
    186     if (HAL3_CAM_OK != rc) {
    187         LOGE("hal3 err\n");
    188         goto EXIT;
    189     }
    190 
    191     numCam = my_if_handle->get_number_of_cameras();
    192     printf("\n Number of Cameras are : %d ", numCam);
    193     if (my_if_handle->get_vendor_tag_ops) {
    194         mLibHandle->app_obj.mVendorTagOps = vendor_tag_ops_t();
    195         my_if_handle->get_vendor_tag_ops(&(mLibHandle->app_obj.mVendorTagOps));
    196 
    197         res = set_camera_metadata_vendor_ops(&(mLibHandle->app_obj.mVendorTagOps));
    198         if (0 != res) {
    199             printf("%s: Could not set vendor tag descriptor, "
    200                     "received error %s (%d). \n", __func__,
    201                     strerror(-res), res);
    202             goto EXIT;
    203         }
    204     }
    205     my_test_obj = &(mLibHandle->test_obj);
    206     my_test_obj->module_cb.torch_mode_status_change = &torch_mode_status_change;
    207     my_test_obj->module_cb.camera_device_status_change = &camera_device_status_change;
    208     my_if_handle->set_callbacks(&(my_test_obj->module_cb));
    209     my_if_handle->get_camera_info(0, &(mLibHandle->test_obj.cam_info));
    210     camcap_info = mLibHandle->test_obj.cam_info;
    211     hal3app_cam_settings = (camcap_info.static_camera_characteristics);
    212     display_capability();
    213     return numCam;
    214     EXIT:
    215     return rc;
    216 
    217 }
    218 
    219 void CameraHAL3Base::display_capability()
    220 {
    221     ALOGE("Camera Here");
    222     int i;
    223     int *available_ir_modes = NULL;
    224     if(hal3app_cam_settings.exists(QCAMERA3_IR_AVAILABLE_MODES)) {
    225         ALOGE("\n mrad check1 ");
    226         entry_hal3app = hal3app_cam_settings.find(QCAMERA3_IR_AVAILABLE_MODES);
    227         available_ir_modes = (int *) malloc((entry_hal3app.count)*sizeof(int ));
    228         for(i =0;i < (int)entry_hal3app.count; i++){
    229                     available_ir_modes[i] = entry_hal3app.data.i32[i];
    230             ALOGE("\n mrad cap %d ", available_ir_modes[i]);
    231 
    232         }
    233     }
    234 }
    235 
    236 int CameraHAL3Base::hal3appCameraLibOpen(int camid)
    237 {
    238     int rc;
    239     rc = hal3appCamOpen(&mLibHandle->app_obj, (int)camid, &(mLibHandle->test_obj));
    240     if (rc != HAL3_CAM_OK) {
    241         LOGE("hal3appCamOpen() camidx=%d, err=%d\n",
    242                 camid, rc);
    243         goto EXIT;
    244     }
    245     rc = hal3appCamInitialize((int)camid, &mLibHandle->test_obj);
    246     EXIT:
    247     return rc;
    248 }
    249 
    250 int CameraHAL3Base::hal3appTestLoad(hal3_camera_app_t *my_hal3_app)
    251 {
    252     memset(&my_hal3_app->hal3_lib, 0, sizeof(hal3_interface_lib_t));
    253     printf("\nLibrary path is :%s", CAM_LIB(LIB_PATH));
    254     my_hal3_app->hal3_lib.ptr = dlopen(CAM_LIB(LIB_PATH), RTLD_NOW);
    255 
    256     if (!my_hal3_app->hal3_lib.ptr) {
    257         LOGE("Error opening HAL libraries %s\n",
    258                 dlerror());
    259         return -HAL3_CAM_E_GENERAL;
    260     }
    261     my_hal3_app->hal3_lib.halModule_t =
    262         (camera_module_t*)dlsym(my_hal3_app->hal3_lib.ptr, HAL_MODULE_INFO_SYM_AS_STR);
    263     if (my_hal3_app->hal3_lib.halModule_t == NULL) {
    264         LOGE("Error opening HAL library %s\n",
    265                 dlerror());
    266         return -HAL3_CAM_E_GENERAL;
    267     }
    268     return HAL3_CAM_OK;
    269 }
    270 
    271 int CameraHAL3Base::hal3appCamOpen(
    272         hal3_camera_app_t *my_hal3_app,
    273         int camid,
    274         hal3_camera_test_obj_t *my_test_obj)
    275 {
    276     camera_module_t *my_if_handle = my_hal3_app->hal3_lib.halModule_t;
    277     my_if_handle->common.methods->open(&(my_if_handle->common), "0",
    278             reinterpret_cast<hw_device_t**>(&(my_test_obj->device)));
    279     printf("\n Camera ID %d Opened \n", camid);
    280     return HAL3_CAM_OK;
    281 }
    282 
    283 int CameraHAL3Base::hal3appCamInitialize(int camid, hal3_camera_test_obj_t *my_test_obj)
    284 {
    285     int rc = 0;
    286     camera3_device_t *device_handle = my_test_obj->device;
    287     my_test_obj->callback_ops.notify = &Notify;
    288     my_test_obj->callback_ops.process_capture_result = &ProcessCaptureResult;
    289     rc = device_handle->ops->initialize(my_test_obj->device, &(my_test_obj->callback_ops));
    290     if (rc != HAL3_CAM_OK) {
    291         LOGE("hal3appCamInitialize() camidx=%d, err=%d\n",
    292                 camid, rc);
    293         goto EXIT;
    294     }
    295     EXIT:
    296     return rc;
    297 }
    298 
    299 
    300 void CameraHAL3Base::hal3appCheckStream(int testcase, int camid)
    301 {
    302     if (testcase != MENU_START_PREVIEW) {
    303         if (mPreviewtestCase != NULL) {
    304             mPreviewtestCase->previewTestEnd(mLibHandle, camid);
    305             delete mPreviewtestCase;
    306             mPreviewtestCase = NULL;
    307         }
    308     }
    309     if (testcase != MENU_START_VIDEO){
    310         if (mVideotestCase != NULL) {
    311             mVideotestCase->videoTestEnd(mLibHandle, camid);
    312             delete mVideotestCase;
    313             mVideotestCase = NULL;
    314         }
    315     }
    316 
    317     if (testcase != MENU_START_CAPTURE){
    318         if (mSnapshottestCase != NULL) {
    319             delete mSnapshottestCase;
    320             mSnapshottestCase = NULL;
    321         }
    322     }
    323 
    324     if (testcase != MENU_START_RAW_CAPTURE) {
    325         if (mRawSnapshottestCase != NULL) {
    326             delete mRawSnapshottestCase;
    327             mRawSnapshottestCase = NULL;
    328         }
    329     }
    330 }
    331 
    332 
    333 int CameraHAL3Base::hal3appCameraPreviewInit(int testcase, int camid, int w, int h)
    334 {
    335     extern int req_sent;
    336     int testCaseEndComplete = 0;
    337     if (w == 0 || h == 0) {
    338         printf("\n Frame dimension is wrong");
    339         return -1;
    340     }
    341     if ( mPreviewtestCase != NULL) {
    342         if(testcase == MENU_TOGGLE_IR_MODE) {
    343             ALOGE("\n IR mode requested is :%d", ir_mode);
    344             mPreviewtestCase->ir_mode = ir_mode;
    345         }
    346         if(testcase == MENU_TOGGLE_SVHDR_MODE) {
    347             ALOGE("\n SVHDR mode requested is :%d", svhdr_mode);
    348             mPreviewtestCase->svhdr_mode = svhdr_mode;
    349         }
    350         return 0;
    351     }
    352     else {
    353         testCaseEndComplete = 0;
    354         do {
    355             if (mVideoRunning == 1) {
    356                 hal3appCheckStream(MENU_START_PREVIEW, camid);
    357             }
    358             pthread_mutex_lock(&TestAppLock);
    359             mTestCaseSelected = MENU_START_PREVIEW;
    360             if (mVideoRunning != 1) {
    361                 hal3appCheckStream(MENU_START_PREVIEW, camid);
    362             }
    363             mPreviewtestCase = new QCameraHAL3PreviewTest(0);
    364             printf("\n\n Testing the Resolution : %d X %d", w, h);
    365             req_sent = 0;
    366             PreviewQueue.clear();
    367             capture_received = 0; mSecElapsed = 1;
    368             snapshot_buffer = -1; mFrameCount = 0;
    369             mPreviewtestCase->width = w; mPreviewtestCase->height = h;
    370             mPreviewtestCase->ir_mode = 0; mPreviewtestCase->svhdr_mode = 0;
    371             mPreviewtestCase->initTest(mLibHandle,
    372                     (int) MENU_START_PREVIEW, camid, w, h);
    373             testCaseEndComplete = 1;
    374         }while(testCaseEndComplete != 1);
    375     }
    376     return 0;
    377 }
    378 
    379 int CameraHAL3Base::hal3appCameraVideoInit(int testcase, int camid, int w, int h)
    380 {
    381     extern int req_sent;
    382     int testCaseEndComplete = 0;
    383     if (w == 0 || h == 0) {
    384         printf("\n Frame dimension is wrong");
    385         return -1;
    386     }
    387 
    388     if (mVideotestCase != NULL) {
    389         if(testcase == MENU_TOGGLE_BINNING_CORRECTION) {
    390             ALOGE("\n Binning Mode Requested is :%d", binning_mode);
    391             mVideotestCase->binning_mode = binning_mode;
    392         }
    393         return 0;
    394     }
    395     else {
    396         testCaseEndComplete = 0;
    397         do {
    398             if (mPreviewRunning == 1) {
    399                 hal3appCheckStream(MENU_START_VIDEO, camid);
    400             }
    401             pthread_mutex_lock(&TestAppLock);
    402             mTestCaseSelected = MENU_START_VIDEO;
    403             if (mPreviewRunning != 1) {
    404                 hal3appCheckStream(MENU_START_VIDEO, camid);
    405             }
    406             mVideotestCase = new QCameraHAL3VideoTest(0);
    407             VideoQueue.clear();
    408             printf("\n\nTesting the Resolution : %d X %d", w, h);
    409             req_sent = 0;
    410             capture_received =0; mSecElapsed = 1; test_case_end = 0;
    411             mVideotestCase->width = w; mVideotestCase->height = h;
    412             snapshot_buffer = -1; mFrameCount = 0;
    413             mVideotestCase->initTest(mLibHandle,
    414                     (int) MENU_START_VIDEO, camid, w, h);
    415             testCaseEndComplete = 1;
    416         }while(testCaseEndComplete !=1);
    417     }
    418     return 0;
    419 }
    420 
    421 
    422 int CameraHAL3Base::hal3appRawCaptureInit(hal3_camera_lib_test *handle, int camid, int req_cap)
    423 {
    424     int testCaseEndComplete = 0;
    425     if(handle == NULL) {
    426         LOGE("Camera Handle is NULL");
    427     }
    428     if (mSnapShotRunning != 1) {
    429         hal3appCheckStream(MENU_START_RAW_CAPTURE, camid);
    430     }
    431     testCaseEndComplete = 0;
    432     do {
    433         pthread_mutex_lock(&TestAppLock);
    434         if (mSnapShotRunning == 1) {
    435             hal3appCheckStream(MENU_START_RAW_CAPTURE, camid);
    436         }
    437         printf("\n capture:%d", req_cap);
    438         mTestCaseSelected = MENU_START_RAW_CAPTURE;
    439         mRawSnapshottestCase = new QCameraHAL3RawSnapshotTest(req_cap);
    440         mRawSnapshottestCase->mRequestedCapture = req_cap;
    441         mRawSnapshottestCase->initTest(mLibHandle,
    442         (int) MENU_START_RAW_CAPTURE, camid, RAWSNAPSHOT_CAPTURE_WIDTH,
    443                 RAWSNAPSHOT_CAPTURE_HEIGHT);
    444         testCaseEndComplete = 1;
    445     }while(testCaseEndComplete !=1);
    446     return 0;
    447 }
    448 
    449 int CameraHAL3Base::hal3appCameraCaptureInit(hal3_camera_lib_test *handle,
    450         int camid, int req_cap)
    451 {
    452     int testCaseEndComplete = 0;
    453     if(handle == NULL) {
    454         LOGE("Camera Handle is NULL");
    455     }
    456     if (mSnapShotRunning != 1) {
    457         hal3appCheckStream(MENU_START_CAPTURE, camid);
    458     }
    459     testCaseEndComplete = 0;
    460     do {
    461         pthread_mutex_lock(&TestAppLock);
    462         if (mSnapShotRunning == 1) {
    463             hal3appCheckStream(MENU_START_CAPTURE, camid);
    464         }
    465         printf("\n capture:%d", req_cap);
    466         mTestCaseSelected = MENU_START_CAPTURE;
    467         mSnapshottestCase = new QCameraHAL3SnapshotTest(req_cap);
    468         mSnapshottestCase->mRequestedCapture = req_cap;
    469         mSnapshottestCase->initTest(mLibHandle,
    470             (int) MENU_START_CAPTURE, camid, SNAPSHOT_CAPTURE_WIDTH, SNAPSHOT_CAPTURE_HEIGHT);
    471         testCaseEndComplete = 1;
    472     }while(testCaseEndComplete != 1);
    473     return 0;
    474 }
    475 
    476 }
    477 
    478