HAL3/test/QCameraHAL3Base.cpp

/*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),
    binning_mode(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;
    int *available_ir_modes = NULL;
    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) {
        if(testcase == MENU_TOGGLE_BINNING_CORRECTION) {
            ALOGE("\n Binning Mode Requested is :%d", binning_mode);
            mVideotestCase->binning_mode = binning_mode;
        }
        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;
}

}