478 lines
16 KiB
C++
478 lines
16 KiB
C++
|
/*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;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|