kal_uint8 usbvideo_camera_effect_setting_attr(USBVideo_Attr_Value *attr)
{
#if 0//JiaShuo Delete for webcam
USBVIDEO_ATTRIBUTE_TYPE attr_type = attr->type;
kal_uint32 attr_value = attr->value;
// update attr PU current value
if(attr_type>USBVIDEO_ATTRIBUTE_CT_MAX)
{
usbvideo_attr_PU_value_list[GET_ATTR_PU_IDX(attr_type)] = attr_value;
usbvideo_attr_setting_PU_index |= 1<<GET_ATTR_PU_IDX(attr_type);
}
#endif
return KAL_TRUE;
}
kal_uint8 usbvideo_camera_update_attr(void)
{
#if 0//JiaShuo Delete for webcam
kal_uint32 i;
for (i=0;i<GET_ATTR_PU_IDX(USBVIDEO_ATTRIBUTE_PU_MAX);i++)
{
if(usbvideo_cam_command_PU_map[i]==USBVIDEO_CAM_ATTR_ISP)
usbvideo_attr_setting_PU_index |= (1<<i);
}
usbvideo_camera_effect_background_setting_attr();
#endif
return KAL_TRUE;
}
/*************************************************************************
* Init / Update Attribute for ISP
*************************************************************************/
void usbvideo_camera_init_attr(void)
{
#if 0//JiaShuo Delete for webcam
kal_uint32 i;
for (i=0;i<GET_ATTR_PU_IDX(USBVIDEO_ATTRIBUTE_PU_MAX);i++)
{
usbvideo_attr_PU_value_list[i] = USBVIDEO_ATTR_PARA.attr_info[i].def;
}
/* CT Part , Fix(Default) Attributes */
usbvideo_cam_command_CT_map[GET_ATTR_CT_IDX(USBVIDEO_ATTRIBUTE_FOCAL_MIN)] = USBVIDEO_CAM_ATTR_FIX;
usbvideo_cam_command_CT_map[GET_ATTR_CT_IDX(USBVIDEO_ATTRIBUTE_FOCAL_MAX)] = USBVIDEO_CAM_ATTR_FIX;
usbvideo_cam_command_CT_map[GET_ATTR_CT_IDX(USBVIDEO_ATTRIBUTE_FOCAL_LENGTH)] = USBVIDEO_CAM_ATTR_FIX;
#endif
}
kal_uint8 usbvideo_camera_effect_getting_attr(USBVideo_Attr_Value *attr)
{
#if 0//JiaShuo Delete for webcam
USBVIDEO_ATTRIBUTE_TYPE attr_type = attr->type;
if(attr_type>USBVIDEO_ATTRIBUTE_CT_MAX)
{
switch(attr->req_type)
{
case USBVIDEO_REQUEST_GET_CUR:
attr->value = usbvideo_attr_PU_value_list[GET_ATTR_PU_IDX(attr_type)];
break;
case USBVIDEO_REQUEST_GET_MIN:
attr->value = USBVIDEO_ATTR_PARA.attr_info[GET_ATTR_PU_IDX(attr->type)].min;
break;
case USBVIDEO_REQUEST_GET_MAX:
attr->value = USBVIDEO_ATTR_PARA.attr_info[GET_ATTR_PU_IDX(attr->type)].max;
break;
case USBVIDEO_REQUEST_GET_DEF:
attr->value = USBVIDEO_ATTR_PARA.attr_info[GET_ATTR_PU_IDX(attr->type)].def;
break;
case USBVIDEO_REQUEST_GET_RES:
attr->value = USBVIDEO_ATTR_PARA.attr_info[GET_ATTR_PU_IDX(attr->type)].res;
break;
default:
EXT_ASSERT(0, (kal_uint32)attr->req_type, 0, 0);
break;
}
return KAL_TRUE;
}
else // CT Part
{
return KAL_FALSE;
}
#endif
return KAL_TRUE;
}
MM_ERROR_CODE_ENUM HI253WebcamFeatureCtrl(kal_uint32 Id, void *In, void *Out, kal_uint32 OutLen, kal_uint32 *RealOutLen)
{
/* supported feature list */
static const USBVideo_Attr_Info HI253_ATTR_INFO[] =
{
{USBVIDEO_ATTRIBUTE_BRIGHTNESS, KAL_TRUE, KAL_TRUE},
{USBVIDEO_ATTRIBUTE_CONTRAST, KAL_TRUE, KAL_TRUE},
{USBVIDEO_ATTRIBUTE_HUE, KAL_FALSE, KAL_FALSE},
{USBVIDEO_ATTRIBUTE_HUE_AUTO, KAL_FALSE, KAL_FALSE},
{USBVIDEO_ATTRIBUTE_SATURATION, KAL_FALSE, KAL_FALSE},
{USBVIDEO_ATTRIBUTE_POWER_LINE_FREQUENCY, KAL_TRUE, KAL_TRUE},
{USBVIDEO_ATTRIBUTE_SHARPNESS, KAL_FALSE, KAL_FALSE},
{USBVIDEO_ATTRIBUTE_BACKLIGHT_COMPENSATION, KAL_FALSE, KAL_FALSE},
{USBVIDEO_ATTRIBUTE_GAMMA, KAL_FALSE, KAL_FALSE},
{USBVIDEO_ATTRIBUTE_WHITE_BALANCE_TMP, KAL_TRUE, KAL_TRUE},
{USBVIDEO_ATTRIBUTE_WHITE_BALANCE_TMP_AUTO, KAL_TRUE, KAL_TRUE},
};
/* supported video size list */
static const USBVideo_Video_Size_Info HI253_VIDEO_SIZE[] =
{
{USBVIDEO_VIDEO_SIZE_1, 160, 120, 0xC000, 912382, 38012, 500000, 500000, 500000, 0},
{USBVIDEO_VIDEO_SIZE_2, 320, 240, 0xC000, 912384, 38016, 500000, 500000, 500000, 0},
{USBVIDEO_VIDEO_SIZE_3, 640, 480, 0xC000, 912384, 38016, 500000, 500000, 500000, 0}
};
/* supported still image size list */
static const USBVideo_Still_Size_Info HI253_STILL_SIZE[] =
{
{USBVIDEO_STILL_SIZE_1, 160, 120, 0xC000},
{USBVIDEO_STILL_SIZE_2, 320, 240, 0xC000},
{USBVIDEO_STILL_SIZE_3, 640, 480, 0xC000}
};
/* supported compression type list*/
static const USBVideo_Compression_Info HI253_STILL_COMPRESSION[] =
{
/*{USBVIDEO_COMPRESSION_1, JPEG_ENCODE_QUALITY_GOOD},*/
{USBVIDEO_COMPRESSION_1, JPEG_ENCODE_QUALITY_LOW },
{USBVIDEO_COMPRESSION_2, JPEG_ENCODE_QUALITY_FAIR}
};
static const USBVIDEO_VIDEO_SIZE_TYPE HI253_g_default_video_size = USBVIDEO_VIDEO_SIZE_1;
static const USBVIDEO_STILL_SIZE_TYPE HI253_g_default_still_size = USBVIDEO_STILL_SIZE_1;
static const USBVIDEO_COMPRESSION_TYPE HI253_g_default_compression = USBVIDEO_COMPRESSION_1;
static const usbvideo_attr_struct HI253WebcamAttrPara =
{
/* min, max, res, def */
{
{0, 4, 1, 0 }, /*0 USBVIDEO_ATTRIBUTE_BACKLIGHT_COMPENSATION*/
{0, 8, 1, 4 }, /*1 USBVIDEO_ATTRIBUTE_BRIGHTNESS*/
{0, 2, 1, 1 }, /*2 USBVIDEO_ATTRIBUTE_CONTRAST*/
{0, 255, 1, 127 }, /*3 USBVIDEO_ATTRIBUTE_GAIN*/
{0, 2, 1, 1 }, /*4 USBVIDEO_ATTRIBUTE_POWER_LINE_FREQUENCY, 0:Disable, 1:50, 2:60*/
{0, 360, 1 , 0 }, /*5 USBVIDEO_ATTRIBUTE_HUE*/
{0, 255, 1, 64 }, /*6 USBVIDEO_ATTRIBUTE_SATURATION*/
{0, 15, 1, 0 }, /*7 USBVIDEO_ATTRIBUTE_SHARPNESS*/
{100, 220, 60, 160 }, /*8 USBVIDEO_ATTRIBUTE_GAMMA*/
{2500, 6500, 500, 5500}, /*9 USBVIDEO_ATTRIBUTE_WHITE_BALANCE_TMP*/
{0, 1, 1, 1 }, /*10 USBVIDEO_ATTRIBUTE_WHITE_BALANCE_TMP_AUTO*/
{0, 0, 0, 0 }, /*11 USBVIDEO_ATTRIBUTE_WHITE_BALANCE_COMP, NOT SUPPORT*/
{0, 1, 1, 1 }, /*12 USBVIDEO_ATTRIBUTE_WHITE_BALANCE_COMP_AUTO*/
{0, 0, 1, 0 }, /*13 USBVIDEO_ATTRIBUTE_DIGITAL_MULTIPLIER, NOT SUPPORT*/
{0, 0, 1, 0 }, /*14 USBVIDEO_ATTRIBUTE_DIGITAL_MULTIPLIER_LIMIT, NOT SUPPORT*/
{0, 1, 1, 0 }, /*15 USBVIDEO_ATTRIBUTE_HUE_AUTO*/
{0, 0, 0, 0 } /*16 USBVIDEO_ATTRIBUTE_MAX_MULTIPLIER, NOT SUPPORT*/
}
};
MM_ERROR_CODE_ENUM ErrCode = MM_ERROR_NONE;
switch(Id)
{
case CAL_FEATURE_WEBCAM_GET_ATTR:
{
USBVideo_Attr_Value *pWebCamAttr = (USBVideo_Attr_Value *)Out;
USBVIDEO_ATTRIBUTE_TYPE AttrType = pWebCamAttr->type;
if (AttrType <= USBVIDEO_ATTRIBUTE_CT_MAX)
{
pWebCamAttr->value = 0; //CT currently is not support
}
else
{
if (AttrType >= ATTR_PU_START)
{
switch(pWebCamAttr->req_type)
{
case USBVIDEO_REQUEST_GET_CUR:
ASSERT(0); //current value is maintained In ISP driver
break;
case USBVIDEO_REQUEST_GET_MIN:
pWebCamAttr->value = HI253WebcamAttrPara.attr_info[GET_ATTR_PU_IDX(AttrType)].min;
break;
case USBVIDEO_REQUEST_GET_MAX:
pWebCamAttr->value = HI253WebcamAttrPara.attr_info[GET_ATTR_PU_IDX(AttrType)].max;
break;
case USBVIDEO_REQUEST_GET_DEF:
pWebCamAttr->value = HI253WebcamAttrPara.attr_info[GET_ATTR_PU_IDX(AttrType)].def;
break;
case USBVIDEO_REQUEST_GET_RES:
pWebCamAttr->value = HI253WebcamAttrPara.attr_info[GET_ATTR_PU_IDX(AttrType)].res;
break;
default:
EXT_ASSERT(0, (kal_uint32)pWebCamAttr->req_type, 0, 0);
break;
}
}
else
{
ASSERT(0);
}
}
}
break;
case CAL_FEATURE_WEBCAM_SET_ATTR:
{
const USBVIDEO_ATTRIBUTE_TYPE AttrType = ((USBVideo_Attr_Value *)In)->type;
const kal_uint32 AttrValue = ((USBVideo_Attr_Value *)In)->value;
CAL_FEATURE_CTRL_STRUCT FeatureCtrlPara;
P_IMAGE_SENSOR_FUNCTION_STRUCT pfSensorFunc = NULL;
HI253SensorFunc(&pfSensorFunc);
/* Sensor Attributes Set */
// update attr PU current value
//usbvideo_attr_PU_value_list[GET_ATTR_PU_IDX(AttrType)] = AttrValue;
switch(AttrType)
{
case USBVIDEO_ATTRIBUTE_POWER_LINE_FREQUENCY:
FeatureCtrlPara.FeatureCtrlCode = CAL_FEATURE_SET_OPERATION;
if(AttrValue == 1) /* 50Hz */
{
FeatureCtrlPara.FeatureSetValue = CAM_BANDING_50HZ;
}
else
{
FeatureCtrlPara.FeatureSetValue = CAM_BANDING_60HZ;
}
ErrCode = pfSensorFunc->SensorFeatureCtrl(CAL_FEATURE_CAMERA_BANDING_FREQ, &FeatureCtrlPara, NULL, 0, NULL);
break;
case USBVIDEO_ATTRIBUTE_BRIGHTNESS:
FeatureCtrlPara.FeatureCtrlCode = CAL_FEATURE_SET_OPERATION;
FeatureCtrlPara.FeatureSetValue = AttrValue;
ErrCode = pfSensorFunc->SensorFeatureCtrl(CAL_FEATURE_CAMERA_EV_VALUE, &FeatureCtrlPara, NULL, 0, NULL);
break;
case USBVIDEO_ATTRIBUTE_CONTRAST:
FeatureCtrlPara.FeatureCtrlCode = CAL_FEATURE_SET_OPERATION;
FeatureCtrlPara.FeatureSetValue = AttrValue;
ErrCode = pfSensorFunc->SensorFeatureCtrl(CAL_FEATURE_CAMERA_CONTRAST, &FeatureCtrlPara, NULL, 0, NULL);
break;
case USBVIDEO_ATTRIBUTE_WHITE_BALANCE_TMP_AUTO:
if (AttrValue > 0) /* AUTO */
{
FeatureCtrlPara.FeatureCtrlCode = CAL_FEATURE_SET_OPERATION;
FeatureCtrlPara.FeatureSetValue = CAM_WB_AUTO;
ErrCode = pfSensorFunc->SensorFeatureCtrl(CAL_FEATURE_CAMERA_WB, &FeatureCtrlPara, NULL, 0, NULL);
}
else
{
///Bin: dothing, because will set by USBVIDEO_ATTRIBUTE_WHITE_BALANCE_TMP;
}
break;
case USBVIDEO_ATTRIBUTE_WHITE_BALANCE_TMP:
FeatureCtrlPara.FeatureCtrlCode = CAL_FEATURE_SET_OPERATION;
if(AttrValue>5800)
FeatureCtrlPara.FeatureSetValue = CAM_WB_DAYLIGHT;
else if(AttrValue>=4800)
FeatureCtrlPara.FeatureSetValue = CAM_WB_INCANDESCENCE;
else if(AttrValue>=3800)
FeatureCtrlPara.FeatureSetValue = CAM_WB_FLUORESCENT;
else// if(AttrValue>=2800)
FeatureCtrlPara.FeatureSetValue = CAM_WB_TUNGSTEN;
ErrCode = pfSensorFunc->SensorFeatureCtrl(CAL_FEATURE_CAMERA_WB, &FeatureCtrlPara, NULL, 0, NULL);
break;
default:
break;
}
}
break;
case CAL_FEATURE_WEBCAM_GET_ATTR_INFO:
((P_CAL_FEATURE_WEBCAM_GET_ATTR_INFO_STRUCT)Out)->pWebCamAttrInfo = HI253_ATTR_INFO;
((P_CAL_FEATURE_WEBCAM_GET_ATTR_INFO_STRUCT)Out)->WebCamAttrInfoNum = sizeof(HI253_ATTR_INFO) / sizeof(HI253_ATTR_INFO[0]);
break;
case CAL_FEATURE_WEBCAM_GET_VIDEO_SIZE:
((P_CAL_FEATURE_WEBCAM_GET_VIDEO_SIZE_STRUCT)Out)->pWebCamVideoSizeInfo = HI253_VIDEO_SIZE;
((P_CAL_FEATURE_WEBCAM_GET_VIDEO_SIZE_STRUCT)Out)->WebCamVideoSizeInfoNum = sizeof(HI253_VIDEO_SIZE) / sizeof(HI253_VIDEO_SIZE[0]);
break;
case CAL_FEATURE_WEBCAM_GET_STILL_SIZE:
((P_CAL_FEATURE_WEBCAM_GET_STILL_SIZE_STRUCT)Out)->pWebCamStillSizeInfo = HI253_STILL_SIZE;
((P_CAL_FEATURE_WEBCAM_GET_STILL_SIZE_STRUCT)Out)->WebCamStillSizeInfoNum = sizeof(HI253_STILL_SIZE) / sizeof(HI253_STILL_SIZE[0]);
break;
case CAL_FEATURE_WEBCAM_GET_COMPRESSION:
((P_CAL_FEATURE_WEBCAM_GET_COMPRESSION_STRUCT)Out)->pWebCamCompressionInfo = HI253_STILL_COMPRESSION;
((P_CAL_FEATURE_WEBCAM_GET_COMPRESSION_STRUCT)Out)->WebCamCompressionInfoNum = sizeof(HI253_STILL_COMPRESSION) / sizeof(HI253_STILL_COMPRESSION[0]);
break;
case CAL_FEATURE_WEBCAM_GET_DEFAULT_IDX:
((P_CAL_FEATURE_WEBCAM_GET_DEFAULT_IDX_STRUCT)Out)->WebCamVideoSizeIdx = HI253_g_default_video_size;
((P_CAL_FEATURE_WEBCAM_GET_DEFAULT_IDX_STRUCT)Out)->WebCamStillSizeIdx = HI253_g_default_still_size;
((P_CAL_FEATURE_WEBCAM_GET_DEFAULT_IDX_STRUCT)Out)->WebCamCompressionIdx = HI253_g_default_compression;
break;
default:
ErrCode = MM_ERROR_INVALID_PARAMETER;
break;
}
return ErrCode;
}
MM_ERROR_CODE_ENUM OV5650MipiWebcamFeatureCtrl(IMAGE_SENSOR_FEATURE_ENUM FeatureId,
void *pFeatureParaIn, void *pFeatureParaOut,
kal_uint32 FeatureParaOutLen, kal_uint32 *pRealFeatureParaOutLen)
{
MM_ERROR_CODE_ENUM ErrorCode = MM_ERROR_NONE;
switch(FeatureId)
{
case CAL_FEATURE_WEBCAM_GET_ATTR:
{
USBVideo_Attr_Value *pWebCamAttr = (USBVideo_Attr_Value *)pFeatureParaOut;
USBVIDEO_ATTRIBUTE_TYPE AttrType = pWebCamAttr->type;
if (AttrType <= USBVIDEO_ATTRIBUTE_CT_MAX)
{
pWebCamAttr->value = 0; ///CT currently is not support
}
else
{
if (AttrType >= ATTR_PU_START)
{
switch (pWebCamAttr->req_type)
{
case USBVIDEO_REQUEST_GET_CUR:
ASSERT(0); ///current value is maintained in ISP driver
break;
case USBVIDEO_REQUEST_GET_MIN:
pWebCamAttr->value = OV5650MipiWebcamAttrPara.attr_info[GET_ATTR_PU_IDX(AttrType)].min;
break;
case USBVIDEO_REQUEST_GET_MAX:
pWebCamAttr->value = OV5650MipiWebcamAttrPara.attr_info[GET_ATTR_PU_IDX(AttrType)].max;
break;
case USBVIDEO_REQUEST_GET_DEF:
pWebCamAttr->value = OV5650MipiWebcamAttrPara.attr_info[GET_ATTR_PU_IDX(AttrType)].def;
break;
case USBVIDEO_REQUEST_GET_RES:
pWebCamAttr->value = OV5650MipiWebcamAttrPara.attr_info[GET_ATTR_PU_IDX(AttrType)].res;
break;
default:
EXT_ASSERT(0, (kal_uint32)pWebCamAttr->req_type, 0, 0);
break;
}
}
else
{
ASSERT(0);
}
}
}
break;
case CAL_FEATURE_WEBCAM_SET_ATTR:
{
// Only for YUV sensor
}
break;
case CAL_FEATURE_WEBCAM_GET_ATTR_INFO:
{
P_CAL_FEATURE_WEBCAM_GET_ATTR_INFO_STRUCT pWebCamAttrInfo = (P_CAL_FEATURE_WEBCAM_GET_ATTR_INFO_STRUCT)pFeatureParaOut;
pWebCamAttrInfo->pWebCamAttrInfo = OV5650MipiWebcamAttrInfo;
pWebCamAttrInfo->WebCamAttrInfoNum = sizeof(OV5650MipiWebcamAttrInfo) / sizeof(USBVideo_Attr_Info);
}
break;
case CAL_FEATURE_WEBCAM_GET_VIDEO_SIZE:
{
P_CAL_FEATURE_WEBCAM_GET_VIDEO_SIZE_STRUCT pWebCamVideoSize = (P_CAL_FEATURE_WEBCAM_GET_VIDEO_SIZE_STRUCT)pFeatureParaOut;
pWebCamVideoSize->pWebCamVideoSizeInfo = OV5650MipiWebcamVideoSize;
pWebCamVideoSize->WebCamVideoSizeInfoNum = sizeof(OV5650MipiWebcamVideoSize) / sizeof(USBVideo_Video_Size_Info);
}
break;
case CAL_FEATURE_WEBCAM_GET_STILL_SIZE:
{
P_CAL_FEATURE_WEBCAM_GET_STILL_SIZE_STRUCT pWebCamStillSize = (P_CAL_FEATURE_WEBCAM_GET_STILL_SIZE_STRUCT)pFeatureParaOut;
pWebCamStillSize->pWebCamStillSizeInfo = OV5650MipiWebcamStillSize;
pWebCamStillSize->WebCamStillSizeInfoNum = sizeof(OV5650MipiWebcamStillSize) / sizeof(USBVideo_Still_Size_Info);
}
break;
case CAL_FEATURE_WEBCAM_GET_COMPRESSION:
{
P_CAL_FEATURE_WEBCAM_GET_COMPRESSION_STRUCT pWebCamCompression = (P_CAL_FEATURE_WEBCAM_GET_COMPRESSION_STRUCT)pFeatureParaOut;
pWebCamCompression->pWebCamCompressionInfo = OV5650MipiWebcamStillCompression;
pWebCamCompression->WebCamCompressionInfoNum = sizeof(OV5650MipiWebcamStillCompression) / sizeof(USBVideo_Compression_Info);
}
break;
case CAL_FEATURE_WEBCAM_GET_DEFAULT_IDX:
{
P_CAL_FEATURE_WEBCAM_GET_DEFAULT_IDX_STRUCT pWebCamDeafultIdx = (P_CAL_FEATURE_WEBCAM_GET_DEFAULT_IDX_STRUCT)pFeatureParaOut;
pWebCamDeafultIdx->WebCamVideoSizeIdx = OV5650MipiWebcamDefaultVideoSize;
pWebCamDeafultIdx->WebCamStillSizeIdx = OV5650MipiWebcamDefaultStillSize;
pWebCamDeafultIdx->WebCamCompressionIdx = OV5650MipiWebcamDefaultCompression;
}
break;
default :
ErrorCode = MM_ERROR_INVALID_PARAMETER;
break;
}
return ErrorCode;
}
