void ctp_cypress_cy8ctma340_power(kal_bool ON)
{
static kal_bool power_status = KAL_FALSE;
kal_bool sleep, wakeup;
if(ON == power_status) //do not turn on/off pmu ldo again.
return;
power_status = ON;
if(gpio_ctp_power_enable_pin != 0xFF)
{
DclGPIO_Control(ctp_gpio_power_handle, GPIO_CMD_SET_MODE_0, NULL);
DclGPIO_Control(ctp_gpio_power_handle, GPIO_CMD_SET_DIR_OUT, NULL);
}
if(gpio_ctp_reset_pin != 0xFF)
{
DclGPIO_Control(ctp_gpio_reset_handle, GPIO_CMD_SET_MODE_0, NULL);
DclGPIO_Control(ctp_gpio_reset_handle, GPIO_CMD_SET_DIR_OUT, NULL);
}
if(ON)
{
wakeup = CTP_I2C_write_byte(HST_MODE_ADDR, HST_MODE_NORMAL); //toggle the controller.
if(gpio_ctp_power_enable_pin != 0xFF)
DclGPIO_Control(ctp_gpio_power_handle, GPIO_CMD_WRITE_HIGH, NULL);
ctp_i2c_udelay(1000);
if(gpio_ctp_reset_pin != 0xFF)
DclGPIO_Control(ctp_gpio_reset_handle, GPIO_CMD_WRITE_LOW, NULL);
ctp_i2c_udelay(10000);
if(gpio_ctp_reset_pin != 0xFF)
DclGPIO_Control(ctp_gpio_reset_handle, GPIO_CMD_WRITE_HIGH, NULL);
drv_trace2(TRACE_GROUP_10, CTP_CAPACITIVE_POWER, ON, wakeup);
}
else
{
sleep = CTP_I2C_write_byte(HST_MODE_ADDR, HST_MODE_DEEP_SLEEP); //toggle the controller.
drv_trace2(TRACE_GROUP_10, CTP_CAPACITIVE_POWER, ON, sleep);
if(!sleep)
{
if(gpio_ctp_power_enable_pin != 0xFF)
DclGPIO_Control(ctp_gpio_power_handle, GPIO_CMD_WRITE_LOW, NULL);
drv_trace0(TRACE_GROUP_10, CTP_CAPACITIVE_POWER_DOWN);
}
}
ctp_i2c_power_on(ON, CTP_I2C_LDO, 0);
}
static void VideoH264DecFreeDisp(void *ptr)
{
if (ptr == NULL)
{
ASSERT(0);
return;
}
if (rH264SwCtrl.pfnOutputOneFrame)
{
drv_trace2(TRACE_GROUP_10,OPEN_API_OUTPUTFRAME, (kal_uint32)ptr,1);
rH264SwCtrl.pfnOutputOneFrame((kal_uint32)ptr, KAL_TRUE);
}
}
static kal_uint8 is_equal( kal_uint8 *src , kal_uint8 *dst , kal_int32 len )
{
kal_int32 i;
for( i = 0 ; i < len ; i++ )
{
if ( src[i] != dst[i] )
{
drv_trace2( TRACE_GROUP_7, CTP_GOODIX_DWN_MEMCMP_TRACE, src[i], dst[i]);
return 0;
}
}
return 1;
}
void VideoH264DecSetParam(OPEN_API_PARAM_TYPE_T rType, void *pParam, kal_uint32 u4Size)
{
if (pParam == NULL)
{
ASSERT(0);
return;
}
drv_trace2(TRACE_GROUP_10,OPEN_API_ENTERVIDEOH264DECGETPARAM,rType,*((kal_uint32*)pParam));
switch (rType)
{
case OPEN_API_PARAM_FLUSH_BUFFER_CMD:
VideoH264DecOutputPic((kal_uint32)H264SW_OPENAPI_EOF);
break;
default:
ASSERT(0);
break;
}
}
static void VideoH264DecOutputPic(kal_uint32 u4FlushBuffer)
{
H264SwDecPicture rDecPic;
kal_uint32 u4OutAddr;
if (!rH264SwCtrl.pfnOutputOneFrame)
{
ASSERT(0);
return;
}
while (H264SwDecNextPicture(rH264SwCtrl.prH264DecInst, &rDecPic,
u4FlushBuffer) == H264SWDEC_PIC_RDY)
{
kal_bool fgError = KAL_FALSE;
drv_trace1(TRACE_GROUP_8, H264DEC_OUTPUT_IDR, rDecPic.isIdrPicture);
if (rDecPic.isEOF) break;
if (rH264SwCtrl.fgFrmBufferSwitch == KAL_TRUE)
{
if (rH264SwCtrl.fgFrmBufferCacheable == KAL_TRUE)
{
u4OutAddr = OpenAPIExtBufferCacheableSwitch((kal_uint32)rDecPic.pOutputPicture,
rH264SwCtrl.u4BufferSize, OPEN_API_NON_CACHEABLE);
}
else
{
u4OutAddr = OpenAPIExtBufferCacheableSwitch((kal_uint32)rDecPic.pOutputPicture,
rH264SwCtrl.u4BufferSize, OPEN_API_CACHEABLE);
}
}
else
{
u4OutAddr = (kal_uint32)rDecPic.pOutputPicture;
}
if (rDecPic.nbrOfErrMBs > 0)
{
fgError = KAL_TRUE;
}
drv_trace4(TRACE_GROUP_8, H264DEC_DISPLAY_INFO, u4OutAddr, rDecPic.displayWidth,
rDecPic.displayHeight, u4FlushBuffer);
drv_trace2(TRACE_GROUP_10,OPEN_API_OUTPUTFRAME, u4OutAddr,0);
rH264SwCtrl.pfnOutputOneFrame(u4OutAddr, fgError);
}
}
static kal_uint8 gt818_reset( void )
{
kal_uint8 ret = 1;
kal_uint8 retry_count = 0;
outbuf[0] = 1;
outbuf[1] = 1;
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);
kal_sleep_task(5);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_LOW, NULL);
kal_sleep_task(5);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);
kal_sleep_task(120);
search_i2c:
//gt818_i2c_write( guitar_i2c_address, 0x00FF, outbuf, 1 );
//kal_sleep_task( 12 );
gt818_i2c_read( guitar_i2c_address, 0x00FF, inbuf, 1 );
if ( inbuf[0] != 0x55 )
{
drv_trace2( TRACE_GROUP_7, CTP_GOODIX_DWN_REGISTER_TRACE, 0x00FF, inbuf[0] );
kal_sleep_task(10);
if ( retry_count < 10 )
{
retry_count++;
goto search_i2c;
}
else
{
ASSERT(0);
}
}
drv_trace1( TRACE_GROUP_7, CTP_GOODIX_DWN_DETECT_ADDR_TRACE, guitar_i2c_address );
kal_sleep_task(120);
return ret;
}
/*------------------------------------------------------------------------------
Function name: H264SwDecMalloc
Purpose:
Example implementation of H264SwDecMalloc function. Prototype of this
function is given in H264SwDecApi.h. This implementation uses
library function malloc for allocation of memory.
------------------------------------------------------------------------------*/
static void *VideoH264DecMalloc(unsigned int size)
{
void *ptr = NULL;
kal_uint32 u4Size;
if (rH264SwCtrl.pAdmId == NULL)
{
ASSERT(0);
}
u4Size = H264_ROUND_UP_TO_POWER_OF_TWO(size, 4);
ptr = kal_adm_alloc(rH264SwCtrl.pAdmId, u4Size);
if (ptr == NULL)
{
kal_uint32 u4LeftSize = kal_adm_get_total_left_size(rH264SwCtrl.pAdmId);
EXT_ASSERT(0, u4LeftSize, (kal_uint32)size, 0);
}
drv_trace2(TRACE_GROUP_10,OPEN_API_SW_GETMEMORY,size,(kal_uint32)ptr);
return ptr;
}
VIDEO_ENCODER_CODEC_ERROR_T MPEG4HWEncEncodeOneUnit(VIDEO_BUFFERHEADER_TYPE_T *prBufferHeader)
{
VIDEO_ENCODER_CODEC_ERROR_T eRet = VIDEO_ENCODER_CODEC_ERROR_NONE;
// kal_uint8* pu1Buffer;
kal_uint8* pu1StartAddr;
kal_uint8* pu1EndAddr;
kal_uint8* pu1WritePtr;
kal_uint8* pu1ReadAddr;
kal_uint8* pu1NextWritePtr;
kal_uint32 u4AvailLen, u4BuffLen;
kal_uint32 u4NextAvailLen;
kal_uint8* pu1Addr;
ASSERT(rpMPEG4HWEncDriver);
if(prBufferHeader)
video_dbg_trace(VIDEO_DBG_OWNER_ENCODER, VIDEO_DBG_HWENCV2_ENCODEONEUNIT, (kal_uint32) prBufferHeader->pu1Buffer);
if(!prBufferHeader && !rMPEG4HWEncCtrl.pu1YUV)
return VIDEO_ENCODER_CODEC_ERROR_NONE;
if(!mpeg4_encore_check_encoder_status() ||
!mepg4_encore_check_bits_buffer_status())
{
//return VIDEO_ENCODER_CODEC_PAUSE_ENCODE; //hw in use
ASSERT(0);
}
VideoEncoderAllocateBitstreamBuffer(&pu1StartAddr, &pu1EndAddr, &pu1WritePtr, &pu1ReadAddr, &u4BuffLen);
ASSERT(KAL_FALSE == VideoCommIsExtBufferCacheable((kal_uint32)pu1StartAddr, ROUND_UP_TO_POWER_OF_TWO(u4BuffLen,CPU_CACHE_LINE_SIZE)));
if ((kal_uint32)pu1ReadAddr <= (kal_uint32)pu1WritePtr)
{
u4AvailLen = (kal_uint32)pu1EndAddr - (kal_uint32)pu1WritePtr;
pu1Addr = pu1EndAddr;
#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif
}
else // (u4WP < u4RP)
{
u4AvailLen = (kal_uint32)pu1ReadAddr - (kal_uint32)pu1WritePtr;
pu1Addr = pu1ReadAddr;
}
VideoEncoderQueryBitstreamNewWP((pu1WritePtr+u4AvailLen), &pu1NextWritePtr, &u4NextAvailLen);
if( (rMPEG4HWEncCtrl.eScenario == VIDEO_ENCODER_SCENARIO_VT && u4AvailLen <ENC_MIN_BUF_SIZE_VT) ||
(rMPEG4HWEncCtrl.eScenario == VIDEO_ENCODER_SCENARIO_ENCODER && u4AvailLen < ENC_MAX_VOP_SIZE) )
{
// next free buffer is not continuous
if (pu1NextWritePtr != pu1WritePtr+1)
{
VideoEncoderUpdateBitstreamWP((pu1WritePtr+u4AvailLen), 0);
}
VideoEncoderAllocateBitstreamBuffer(&pu1StartAddr, &pu1EndAddr, &pu1WritePtr, &pu1ReadAddr, &u4BuffLen);
if ((kal_uint32)pu1ReadAddr <= (kal_uint32)pu1WritePtr)
{
u4AvailLen = (kal_uint32)pu1EndAddr - (kal_uint32)pu1WritePtr;
pu1Addr = pu1EndAddr;
}
else // (u4WP < u4RP)
{
u4AvailLen = (kal_uint32)pu1ReadAddr - (kal_uint32)pu1WritePtr;
pu1Addr = pu1ReadAddr;
}
if( (rMPEG4HWEncCtrl.eScenario == VIDEO_ENCODER_SCENARIO_VT && u4AvailLen <ENC_MIN_BUF_SIZE_VT) ||
(rMPEG4HWEncCtrl.eScenario == VIDEO_ENCODER_SCENARIO_ENCODER && u4AvailLen < ENC_MAX_VOP_SIZE) )
{
MPEG4EncCallbackEncPause(pu1StartAddr);
drv_trace1(TRACE_GROUP_10, MPEG4HWENC_ENCODE_BUF_NOT_ENOUGH, u4AvailLen);
return VIDEO_ENCODER_CODEC_BS_BUFFER_NOT_ENOUGH;
}
}
rMPEG4HWEncCtrl.pu1Buffer = prBufferHeader->pu1Buffer;
rMPEG4HWEncCtrl.u8TimeStamp = prBufferHeader->u8TimeStamp;
rMPEG4HWEncCtrl.pu1YUV = 0;
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_ENCODE, (kal_uint32)(rMPEG4HWEncCtrl.pu1Buffer), rMPEG4HWEncCtrl.u8TimeStamp);
rpMPEG4HWEncDriver->encode( rMPEG4HWEncCtrl.pu1Buffer, rMPEG4HWEncCtrl.u8TimeStamp, pu1WritePtr, pu1Addr);
return eRet;
}
VIDEO_ENCODER_CODEC_ERROR_T MPEG4HWEncSetParameter(VIDEO_ENCODER_PARAM_TYPE_T eCmd, void *pParam)
{
VIDEO_ENCODER_CODEC_ERROR_T eRet = VIDEO_ENCODER_CODEC_ERROR_NONE;
ASSERT(rpMPEG4HWEncDriver);
switch(eCmd)
{
case VENC_PARAM_WIDTH:
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_WIDTH, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_uint32*)pParam);
break;
case VENC_PARAM_HEIGHT:
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_HEIGHT, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_uint32*)pParam);
break;
case VENC_PARAM_BITRATE:
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_BITRATE, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_uint32*)pParam);
break;
case VENC_PARAM_FRAME_RATE:
rMPEG4HWEncCtrl.u4FrameRate = *(kal_uint32*)(pParam);
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_FRAME_RATE, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_uint32*)pParam);
break;
case VENC_PARAM_GEN_HEADER_FRM_RATE:
rMPEG4HWEncCtrl.u4GenHeaderFrameRate = *(kal_uint32*)(pParam);
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_TIME_INCREMENT, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_uint32*)pParam);
break;
case VENC_PARAM_SYNC_INTERVAL:
if(!*(kal_uint32*)(pParam))
*(kal_uint32*)(pParam) = ENC_DEFAULT_INTRA_PERIOD;
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_SYNC_INTERVAL, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_uint32*)pParam);
break;
case VENC_PARAM_MAX_PKG_SIZE:
rMPEG4HWEncCtrl.u4MaxPktSize = *(kal_uint32*)(pParam);
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_MAX_PKG_SIZE, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_uint32*)pParam);
break;
case VENC_PARAM_SHORT_HEADER:
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_SHORT_HEADER, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_bool*)pParam);
break;
case VENC_PARAM_FORCE_ENCODE_I:
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_FORCE_ENCODE_I, pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, *(kal_uint32*)pParam);
break;
case VENC_PARAM_QUALITY:
rMPEG4HWEncCtrl.eQuality = *(VIDEO_ENCODER_QUALITY_T*)(pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM_QUALITY, eCmd, rMPEG4HWEncCtrl.eQuality);
break;
case VENC_PARAM_SCENARIO:
{
MPEG4_ENCORE_SCENARIO eScenario;
rMPEG4HWEncCtrl.eScenario = *(VIDEO_ENCODER_SCENARIO_T*)(pParam);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM_SCENARIO, eCmd, rMPEG4HWEncCtrl.eScenario);
switch(rMPEG4HWEncCtrl.eScenario)
{
case VIDEO_ENCODER_SCENARIO_ENCODER:
eScenario = MPEG4_ENCORE_SCENARIO_REC;
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_SCENARIO, (void *)&eScenario);
break;
case VIDEO_ENCODER_SCENARIO_VT:
eScenario = MPEG4_ENCORE_SCENARIO_VT;
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_SCENARIO, (void *)&eScenario);
break;
default:
ASSERT(0);
break;
}
break;
}
case VENC_PARAM_CODEC_TYPE:
{
kal_bool fgShortHeader = KAL_FALSE;
rMPEG4HWEncCtrl.eCodecType = *(VIDEO_ENCODER_CODEC_T*)(pParam);
if(rMPEG4HWEncCtrl.eCodecType == ENCODER_CODEC_TYPE_H263)
{
fgShortHeader = KAL_TRUE;
}
else if(rMPEG4HWEncCtrl.eCodecType == ENCODER_CODEC_TYPE_MPEG4)
{
}
else
{
ASSERT(0);
}
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_SHORT_HEADER, &fgShortHeader);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM_CODEC_TYPE, eCmd, rMPEG4HWEncCtrl.eCodecType);
break;
}
case VENC_PARAM_ROTATE:
eRet = VIDEO_ENCODER_CODEC_PARAM_NOT_SUPPORT;
break;
#if 1
case VENC_PARAM_SET_CALLBACK:
{
VIDEO_ENCODER_ADAPT_CALLBACK_T* prCallbacks = (VIDEO_ENCODER_ADAPT_CALLBACK_T*)(pParam);
ASSERT(prCallbacks->pfnReleaseFrame);
ASSERT(prCallbacks->pfnEncoderPaused);
ASSERT(prCallbacks->pfnGenBitstream);
rMPEG4HWEncCtrl.pfYUVDone = prCallbacks->pfnReleaseFrame;
rMPEG4HWEncCtrl.pfEncPause = prCallbacks->pfnEncoderPaused;
rMPEG4HWEncCtrl.pfBITSDone = prCallbacks->pfnGenBitstream;
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_SET_PARAM, eCmd, 1);
}
break;
#else
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif
default:
eRet = VIDEO_ENCODER_CODEC_PARAM_NOT_SUPPORT;
break;
}
return eRet;
}
VIDEO_ENCODER_CODEC_ERROR_T MPEG4HWEncGetParameter(VIDEO_ENCODER_PARAM_TYPE_T eCmd, void* pParam)
{
VIDEO_ENCODER_CODEC_ERROR_T eRet = VIDEO_ENCODER_CODEC_ERROR_NONE;
VIDEO_ENC_MEMORY_T *prMemorySize;
switch(eCmd)
{
case VENC_PARAM_MEMORY_REQUIREMENT:
prMemorySize = (VIDEO_ENC_MEMORY_T*)pParam;
switch(rMPEG4HWEncCtrl.eScenario)
{
case VIDEO_ENCODER_SCENARIO_ENCODER:
prMemorySize->u4ExternalSize = ENC_MAX_EXT_MEMORY(ENC_MAX_FRAME_WIDTH, ENC_MAX_FRAME_HEIGHT) + ENC_MAX_RESUME_BUFFER_SIZE + CPU_CACHE_LINE_SIZE_MINE;
prMemorySize->u4InternalSize = ENC_MAX_INT_MEMORY(ENC_MAX_FRAME_WIDTH, ENC_MAX_FRAME_HEIGHT);
break;
case VIDEO_ENCODER_SCENARIO_VT:
prMemorySize->u4ExternalSize = ENC_MAX_EXT_MEMORY(ENC_MAX_FRAME_WIDTH_VT, ENC_MAX_FRAME_HEIGHT_VT) + ENC_MAX_RESUME_BUFFER_SIZE_VT + CPU_CACHE_LINE_SIZE_MINE;
prMemorySize->u4InternalSize = ENC_MAX_INT_MEMORY(ENC_MAX_FRAME_WIDTH_VT, ENC_MAX_FRAME_HEIGHT_VT);
break;
default:
ASSERT(0);
break;
}
break;
case VENC_PARAM_BITSTREAM_IN_CACHE:
*(kal_bool*)pParam = KAL_FALSE;
break;
case VENC_PARAM_FRM_BUFFER_ALIGNMENT:
*(kal_uint32*)pParam = ENC_YUV_BUFFER_ALIGNED_BYTES;
break;
case VENC_PARAM_HOLD_RES_TILL_RELEASE_FRM:
switch(rMPEG4HWEncCtrl.eScenario)
{
case VIDEO_ENCODER_SCENARIO_ENCODER:
*(kal_bool*)pParam = KAL_FALSE;
break;
case VIDEO_ENCODER_SCENARIO_VT:
*(kal_bool*)pParam = KAL_TRUE;
break;
default:
ASSERT(0);
break;
}
break;
case VENC_PARAM_IS_BLOCKBASED_YUV:
*(kal_bool*)pParam = KAL_TRUE;
break;
default:
//ASSERT(0);
eRet = VIDEO_ENCODER_CODEC_PARAM_NOT_SUPPORT;
break;
}
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_GET_PARAM, eCmd, *(kal_uint32*)pParam);
return eRet;
}
/*
* FUNCTION
* bmt_charge_start
*
* DESCRIPTION
* This function is to start charging algorithm.
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_charge_start(void)
{
#if defined(__EVB__) && defined(__MTK_INTERNAL__)
/* under construction !*/
#elif defined(__DRV_BMT_NO_CHARGING__)
return;
#else //#if defined(__EVB__)
#if defined(__DRV_BMT_PRECHARGE_TO_FULL_DIRECTLY__)
double adc;
#endif //#if defined(__DRV_BMT_PRECHARGE_TO_FULL_DIRECTLY__)
DCL_STATUS adc_status;
ADC_CTRL_MODIFY_PARAM_T adc_para;
#if defined(MT6236) || defined(MT6252)
PMU_CTRL_CHR_SET_CHR_CURRENT set_chr_current;
#endif
//#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
// kal_set_timer(bmt_sw_polling_timerId, (kal_timer_func_ptr)bmt_sw_polling_ov, NULL,43 , 0);
//#endif //#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
BMT_Charge(KAL_FALSE);
BMT.pmictrl_state = PMIC_CHARGEOFF;
#if defined(__DRV_BMT_PRECHARGE_TO_FULL_DIRECTLY__)
if(g_battery_pre_voltage == 0)
BMT_Current_Voltage(DCL_VBAT_ADC_CHANNEL, &g_battery_pre_voltage,&adc);
BMT.bat_state = CHR_PRE_FULL_CHECK;
#else //defined(__DRV_BMT_PRECHARGE_TO_FULL_DIRECTLY__)
BMT.bat_state = CHR_PRE;
#endif //defined(__DRV_BMT_PRECHARGE_TO_FULL_DIRECTLY__)
BMT.VBAT_UEM= VBAT_UEM_CHR_IN_FISRT;
low_charger_count = 0;
low_current_count = 0;
low_temper_count = 0;
over_temper_count = 0;
#if defined(DRV_BMT_HW_PRECC_WORKAROUND)
SW_Workaround_Flag = KAL_TRUE;
HW_Plug_Status = bmt_chr_uninit;
Manual_Disable_Charge_Flag = KAL_FALSE;
#endif
#if defined(DRV_BMT_HIGH_VCHG_ADAPTIVE_CHARGE_CURRENT_SUPPORT)
First_Time_Charge_Enable = KAL_TRUE;
bmt_high_vchg_current = 0xFFFFFFF;
Pre_VCharge_AVG = 0;
Cur_VCharge_MAX = 0;
#endif
bmt_enable_sleepmode(KAL_FALSE);
// #ifdef MTK_SLEEP_ENABLE
// L1SM_SleepDisable(bmt_sm_handle);
// #endif
adc_para.u4Period = 1;
adc_para.u1EvaluateCount = 1;
adc_status = DclSADC_Control(bmt_adc_handle, ADC_CMD_MODIFY_PARAM, (DCL_CTRL_DATA_T *)&adc_para);
if(adc_status != STATUS_OK)
{
ASSERT(0);
}
adc_status = DclSADC_Control(bmt_adc_handle, ADC_CMD_START_MEASURE, NULL);
if(adc_status != STATUS_OK)
{
ASSERT(0);
}
#ifdef __BMT_CHARGE_GUARD_TIME__
bmt_set_guardtimer(KAL_TICKS_1_MIN*BMT_CHARGE_GUARD_TIME_PERIOD);
drv_trace2(TRACE_GROUP_10, BMT_SAFETY_AND_GUARD_TIMER_START_TRC, BMT_TOTAL_CHARGE_TIME, BMT_CHARGE_GUARD_TIME_PERIOD);
#else // __BMT_CHARGE_GUARD_TIME__
#if defined(DRV_BMT_HIGH_VCHG_ADAPTIVE_CHARGE_CURRENT_SUPPORT)
bmt_safety_timer_config = KAL_FALSE;
#else
stack_start_timer(&ChargeTimeout_timer, 0, KAL_TICKS_1_MIN*BMT_TOTAL_CHARGE_TIME);
drv_trace1(TRACE_GROUP_10, BMT_SAFETY_TIMER_START_TRC, BMT_TOTAL_CHARGE_TIME);
SaftyTimer_Flag = BMT_SAFETY_TIMER_ON;
#endif //#if defined(DRV_BMT_HIGH_VCHG_ADAPTIVE_CHARGE_CURRENT_SUPPORT)
#endif // __BMT_CHARGE_GUARD_TIME__
#if defined(MT6236) || defined(MT6252)
set_chr_current.current = PMU_CHARGE_CURRENT_200_00_MA; // Pre-CC 200mA
DclPMU_Control(bmt_PmuHandler, CHR_SET_CHR_CURRENT, (DCL_CTRL_DATA_T *)&set_chr_current);
#else
bmt_set_chr_current();
#endif
#if defined(PMIC_CHARGE_WDT) // Defined in pmic_features.h
bmt_charge_enable_wdt(KAL_TRUE);
#endif // #if defined(PMIC_CHARGE_WDT)
drv_trace0(TRACE_GROUP_10, BMT_CHARGING_START_TRC);
#endif//#if defined(__EVB__)
}
void VideoH264DecGetParam(OPEN_API_PARAM_TYPE_T rType, void *pParam, kal_uint32 u4Size)
{
H264SwDecInfo rDecInfo;
H264SwDecCapability rDecCap;
kal_uint32 *pu4Param;
OPEN_API_MEM_INFO_T *prMemInfo;
if (pParam == NULL)
{
ASSERT(0);
return;
}
switch(rType)
{
case OPEN_API_PARAM_WIDTH:
if ((u4Size != sizeof(kal_uint32)) || (!rH264SwCtrl.fgIsCodecInit))
{
ASSERT(0);
}
pu4Param = (kal_uint32 *)pParam;
ASSERT(pu4Param);
if (rH264SwCtrl.u2FrameWidth)
{
*pu4Param = (kal_uint32)rH264SwCtrl.u2FrameWidth;
}
else
{
if (H264SwDecGetInfo(rH264SwCtrl.prH264DecInst, &rDecInfo) != H264SWDEC_OK)
{
drv_trace1(TRACE_GROUP_8, H264DEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
*pu4Param = 0;
}
*pu4Param = rDecInfo.picWidth;
}
break;
case OPEN_API_PARAM_HEIGHT:
if ((u4Size != sizeof(kal_uint32)) || (!rH264SwCtrl.fgIsCodecInit))
{
ASSERT(0);
}
pu4Param = (kal_uint32 *)pParam;
ASSERT(pu4Param);
if (rH264SwCtrl.u2FrameHeight)
{
*pu4Param = (kal_uint32)rH264SwCtrl.u2FrameHeight;
}
else
{
if (H264SwDecGetInfo(rH264SwCtrl.prH264DecInst, &rDecInfo) != H264SWDEC_OK)
{
drv_trace1(TRACE_GROUP_8, H264DEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
*pu4Param = 0;
}
*pu4Param = rDecInfo.picHeight;
}
break;
case OPEN_API_PARAM_REAL_WIDTH:
if ((u4Size != sizeof(kal_uint32)) || (!rH264SwCtrl.fgIsCodecInit))
{
ASSERT(0);
}
pu4Param = (kal_uint32 *)pParam;
ASSERT(pu4Param);
*pu4Param = (rH264SwCtrl.fgCropping) ? (kal_uint32)rH264SwCtrl.u2RealWidth:
(kal_uint32)rH264SwCtrl.u2FrameWidth;
break;
case OPEN_API_PARAM_REAL_HEIGHT:
if ((u4Size != sizeof(kal_uint32)) || (!rH264SwCtrl.fgIsCodecInit))
{
ASSERT(0);
}
pu4Param = (kal_uint32 *)pParam;
ASSERT(pu4Param);
*pu4Param = (rH264SwCtrl.fgCropping) ? (kal_uint32)rH264SwCtrl.u2RealHeight :
(kal_uint32)rH264SwCtrl.u2FrameHeight;
break;
case OPEN_API_PARAM_MEM_INFO:
if (H264SWDEC_OK != H264SwDecQueryCapability(&rDecCap, H264SW_QVGA))
{
ASSERT(0);
}
if (u4Size != sizeof(OPEN_API_MEM_INFO_T))
{
ASSERT(0);
}
prMemInfo = (OPEN_API_MEM_INFO_T *)pParam;
ASSERT(prMemInfo);
#if defined(DRV_FEATURE__MM_INTMEM_IF)
prMemInfo->u4IntMemSize = 0;
#else
prMemInfo->u4IntMemSize = rDecCap.intMemSize;
#endif
prMemInfo->u4ExtMemSize = rDecCap.extMemSize;
prMemInfo->fgExtCacheable = KAL_TRUE;
break;
default:
ASSERT(0);
break;
}
drv_trace2(TRACE_GROUP_10,OPEN_API_ENTERVIDEOH264DECGETPARAM,rType,*((kal_uint32*)pu4Param));
}
H264_DECODE_STATUS_CODE_T VideoH264DecNALu(VIDEO_DECODE_PARAM_T *prParam)
{
H264SwDecInput rDecInput;
H264SwDecOutput rDecOutput;
H264SwDecReturnBs rBsInfo;
H264SwDecInfo rDecInfo;
H264SwDecRet rDecResult = H264SWDEC_OK;
kal_bool fgNotSupport = KAL_FALSE;
//kal_bool fgCurBsBufferCacheable;
kal_bool fgAgain = KAL_FALSE;
kal_bool fgCurrentBsCacheable = KAL_FALSE;
if ((prParam == NULL) || (!rH264SwCtrl.fgIsCodecInit))
{
drv_trace1(TRACE_GROUP_8, H264DEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
return H264_STATUS_ERROR;
}
if (prParam->u4AddrOfNALu == 0)
{
drv_trace1(TRACE_GROUP_8, H264DEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
return H264_STATUS_ERROR;
}
drv_trace4(TRACE_GROUP_10,OPEN_API_ENTERVIDEOH264DECNALU, prParam->u4AddrOfNALu,prParam->u4LengthOfNALu,
((*((kal_uint8*)prParam->u4AddrOfNALu))>>5)&0x3,(*((kal_uint8*)prParam->u4AddrOfNALu))&0x1F);
fgCurrentBsCacheable = OpenAPIIsExtBufferCacheable(prParam->u4AddrOfNALu, prParam->u4LengthOfNALu);
if (fgCurrentBsCacheable)
{
//ASSERT(0);
//return H264_STATUS_ERROR;
if (rH264SwCtrl.fgBsBufferCacheable)
{
rDecInput.pStream = (u8 *)prParam->u4AddrOfNALu;
}
else
{
rDecInput.pStream = (u8 *)OpenAPIExtBufferCacheableSwitchAlignMemory((kal_uint32)prParam->u4AddrOfNALu,
prParam->u4LengthOfNALu, OPEN_API_NON_CACHEABLE);
}
}
else
{
if (rH264SwCtrl.fgBsBufferCacheable)
{
rDecInput.pStream = (u8 *)OpenAPIExtBufferCacheableSwitchAlignMemory((kal_uint32)prParam->u4AddrOfNALu,
prParam->u4LengthOfNALu, OPEN_API_CACHEABLE);
}
else
{
rDecInput.pStream = (u8 *)prParam->u4AddrOfNALu;
}
}
rBsInfo.pBsAddr = (u8 *)prParam->u4AddrOfNALu;
rBsInfo.BsTotalLen = prParam->u4LengthOfNALu;
rBsInfo.NaluCnt = 1;
rBsInfo.totalNalu = 1;
rDecInput.dataLen = prParam->u4LengthOfNALu;
rDecInput.pBsBuffer = &rBsInfo;
/* decode one decoding unit */
do
{
rDecResult = H264SwDecDecode(rH264SwCtrl.prH264DecInst, &rDecInput, &rDecOutput);
drv_trace2(TRACE_GROUP_8, H264DEC_DECODE_RESULT, rDecResult, rDecInput.dataLen);
VideoH264DecOutputPic(0);
switch(rDecResult)
{
case H264SWDEC_PIC_RDY_BUFF_NOT_EMPTY:
//decoding a frame, but buffer is too long, or below
if (rDecOutput.pStrmCurrPos == rDecInput.pStream)
{
//only flush pic after change sps; need decoding next slice
fgAgain = KAL_TRUE;
break;
}
// do not break for the following action
case H264SWDEC_PIC_RDY:
//output pic
return H264_STATUS_DECODE_OK;
case H264SWDEC_HDRS_RDY_BUFF_NOT_EMPTY:
if (H264SwDecGetInfo(rH264SwCtrl.prH264DecInst, &rDecInfo) != H264SWDEC_OK)
{
drv_trace1(TRACE_GROUP_8, H264DEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
return H264_STATUS_ERROR;
}
drv_trace4(TRACE_GROUP_8, H264DEC_BITSTREAM_INFO, rDecInfo.picWidth, rDecInfo.picHeight,
rDecInfo.maxDpb, rDecInfo.profile);
//we do not support to change resolution
if (((rDecInfo.picWidth != rH264SwCtrl.u2FrameWidth) && rH264SwCtrl.u2FrameWidth)
|| ((rDecInfo.picHeight != rH264SwCtrl.u2FrameHeight) && rH264SwCtrl.u2FrameHeight))
{
drv_trace0(TRACE_GROUP_8, H264DEC_SUPPORT_ERROR);
fgNotSupport = KAL_TRUE;
}
if (fgNotSupport)
{
drv_trace0(TRACE_GROUP_8, H264DEC_SUPPORT_ERROR);
H264SwDecReturnBitstream(&rBsInfo);
return H264_STATUS_ERROR;
}
drv_trace0(TRACE_GROUP_8, H264DEC_CHANGE_SPS);
rH264SwCtrl.u2FrameHeight = (kal_uint16)rDecInfo.picHeight;
rH264SwCtrl.u2FrameWidth = (kal_uint16)rDecInfo.picWidth;
rH264SwCtrl.u4BufferSize = (((kal_uint32)rH264SwCtrl.u2FrameHeight *
(kal_uint32)rH264SwCtrl.u2FrameWidth) *3) >> 1;
rH264SwCtrl.fgCropping = (rDecInfo.croppingFlag == 0) ? KAL_FALSE : KAL_TRUE;
rH264SwCtrl.u2RealHeight = (kal_uint16)rDecInfo.cropParams.cropOutHeight;
rH264SwCtrl.u2RealWidth = (kal_uint16)rDecInfo.cropParams.cropOutWidth;
fgAgain = KAL_TRUE;
break;
case H264SWDEC_STRM_PROCESSED:
return H264_STATUS_OK;
case H264SWDEC_PARAM_ERR:
drv_trace1(TRACE_GROUP_8, H264DEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
return H264_STATUS_ERROR;
case H264SWDEC_PARAMSET_ERROR:
return H264_STATUS_SPS_ERROR;
case H264SWDEC_STRM_ERR:
fgAgain = KAL_FALSE;
//return H264_STATUS_DECODE_ERROR;
break;
default:
drv_trace0(TRACE_GROUP_8, H264DEC_DECODE_ERROR);
return H264_STATUS_ERROR;
}
}while(fgAgain == KAL_TRUE);
//ASSERT(0);
return H264_STATUS_OK;
}
VIDEO_DECODER_CODEC_ERROR_T H264HwDecoderStartAdapt(VIDEO_BUFFERHEADER_TYPE_T *prBufferHeader)
{
VIDEO_DECODER_CODEC_ERROR_T rRet = VIDEO_DECODER_CODEC_ERROR_NONE;
H264_DECODER_INPUT_PARAM_T *prInputParam;
H264_DECODER_PAYLOAD_INFO_T *prPayload;
kal_uint32 u4PayloadCnt = 0;
//kal_bool fgNotSupport = KAL_FALSE;
kal_bool fgCurBsBufferCacheable;
H264_DECODE_STATUS_CODE_T eResult = H264_STATUS_OK;
VIDEO_DECODE_PARAM_T rDecParam;
H264_HW_DEC_RETURN_BS_T *prReturnBs = NULL;
kal_uint32 u4Addr, u4Length;
kal_uint32 u4Width, u4Height, u4RealWidth, u4RealHeight;
kal_uint16 Idx;
if (prBufferHeader == NULL)
{
drv_trace1(TRACE_GROUP_8, H264HWDEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
return VIDEO_DECODER_CODEC_ERROR;
}
prInputParam = (H264_DECODER_INPUT_PARAM_T *)prBufferHeader->pPrivateData;
if ((prInputParam == NULL) || (prBufferHeader->pu1Buffer == NULL) || (prBufferHeader->u4BuffSize == 0))
{
drv_trace1(TRACE_GROUP_8, H264HWDEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
return VIDEO_DECODER_CODEC_ERROR;
}
prPayload = prInputParam->pu1PayloadAddress;
if ((prPayload == NULL) || (prInputParam->u4PayloadNumber == 0))
{
drv_trace1(TRACE_GROUP_8, H264HWDEC_ARGUMENT_ERROR, __LINE__);
ASSERT(0);
return VIDEO_DECODER_CODEC_ERROR;
}
drv_trace1(TRACE_GROUP_8, H264HWDEC_PAYLOAD_INFO, prInputParam->u4PayloadNumber);
if ((prPayload[0].u4Length != 0) && (prPayload[0].u4Length <= prBufferHeader->u4BuffSize))
{
fgCurBsBufferCacheable = VideoCommIsExtBufferCacheable(prPayload[0].u4Address, prPayload[0].u4Length);
}
else
{
fgCurBsBufferCacheable = rH264HwDecCtrl.fgBsBufferCacheable;
}
for (Idx = 0; Idx < H264_HW_RETURN_BS_NUM; Idx++)
{
if (rH264HwReturnBs[Idx].fgUsed == KAL_FALSE)
{
rH264HwReturnBs[Idx].fgUsed = KAL_TRUE;
prReturnBs = &rH264HwReturnBs[Idx];
prReturnBs->BsTotalLen = prBufferHeader->u4BuffSize;
prReturnBs->pBsAddr = prBufferHeader->pu1Buffer;
//prReturnBs.totalNalu = prInputParam->u4PayloadNumber;
break;
}
}
if (Idx == H264_HW_RETURN_BS_NUM)
{
ASSERT(0);
return VIDEO_DECODER_CODEC_ERROR;
}
rH264HwDecCtrl.u2GetPicInOneTrigger = 0;
do
{
u4Addr = prPayload[u4PayloadCnt].u4Address;
u4Length = prPayload[u4PayloadCnt].u4Length;
if ((u4Length > prBufferHeader->u4BuffSize) || (u4Length == 0))
{
drv_trace2(TRACE_GROUP_8, H264HWDEC_ABNORMAL_NALU_SIZE, u4Length, prBufferHeader->u4BuffSize);
if (u4Length > prBufferHeader->u4BuffSize)
{
u4Length = 0; //huge nalu size, error bitstream, don't decoding, only count nalu num
}
}
if (rH264HwDecCtrl.fgBsBufferCacheable)
{
if ((fgCurBsBufferCacheable == KAL_FALSE) && (u4Length != 0))
{
u4Addr = VideoCommExtBufferCacheableSwitchAlignMemory(u4Addr , u4Length, VIDEO_CACHEABLE);
}
}
else
{
if ((fgCurBsBufferCacheable == KAL_TRUE) && (u4Length != 0))
{
u4Addr = VideoCommExtBufferCacheableSwitchAlignMemory(u4Addr , u4Length, VIDEO_NON_CACHEABLE);
}
}
//rReturnBs.NaluCnt = u4PayloadCnt + 1;
rDecParam.u4AddrOfNALu = u4Addr;
rDecParam.u4LengthOfNALu = u4Length;
rDecParam.pReseved = (void *)prReturnBs;
/* decode one decoding unit */
eResult = VideoH264DecNALu(&rDecParam);
drv_trace2(TRACE_GROUP_8, H264HWDEC_DECODE_RESULT, eResult, u4Length);
switch(eResult)
{
case H264_STATUS_OK:
case H264_STATUS_DECODE_OK:
if ((!rH264HwDecCtrl.u2FrameWidth) && (!rH264HwDecCtrl.u2FrameHeight))
{
H264_DECODER_CUSTOM_SETTING_T rCustomSetting;
VideoH264DecGetParam(OPEN_API_PARAM_WIDTH, &u4Width, sizeof(kal_uint32));
VideoH264DecGetParam(OPEN_API_PARAM_HEIGHT, &u4Height, sizeof(kal_uint32));
VideoH264DecGetParam(OPEN_API_PARAM_REAL_WIDTH, &u4RealWidth, sizeof(kal_uint32));
VideoH264DecGetParam(OPEN_API_PARAM_REAL_HEIGHT, &u4RealHeight, sizeof(kal_uint32));
rH264HwDecCtrl.u2FrameHeight = (kal_uint16)u4Height;
rH264HwDecCtrl.u2FrameWidth = (kal_uint16)u4Width;
rH264HwDecCtrl.u4BufferSize = ((u4Width * u4Height) *3) >> 1;
VideoDecoderGetCustomSetting(&rCustomSetting);
if ((rH264HwDecCtrl.u2FrameHeight > rCustomSetting.u4MaxHeight) ||
(rH264HwDecCtrl.u2FrameWidth > rCustomSetting.u4MaxWidth))
{
H264HwDecoderReturnBitstream((kal_uint32)prReturnBs);
return VIDEO_DECODER_CODEC_ERROR_NOT_SUPPORT;
}
/* Error handle */
if (u4Width == 0 || u4Height == 0)
{
return VIDEO_DECODER_CODEC_ERROR_NOT_SUPPORT;
}
//First slice, set yuv buffer
VideoDecoderSetYUVBuffer(&u4Width, &u4Height, 4, 0, 0);
if ((u4Width != u4RealWidth) || (u4Height != u4RealHeight))
{
rH264HwDecCtrl.fgCropping = KAL_TRUE;
}
else
{
rH264HwDecCtrl.fgCropping = KAL_FALSE;
}
}
u4PayloadCnt++;
break;
case H264_STATUS_SPS_ERROR:
case H264_STATUS_PPS_ERROR:
drv_trace1(TRACE_GROUP_8, H264HWDEC_HEADER_ERROR, __LINE__);
H264HwDecoderReturnBitstream((kal_uint32)prReturnBs);
return VIDEO_DECODER_CODEC_ERROR_NOT_SUPPORT;
case H264_STATUS_ERROR:
case H264_STATUS_DECODE_ERROR:
default:
drv_trace0(TRACE_GROUP_8, H264HWDEC_DECODE_ERROR);
VIDEO_WARNING(VIDEO_DBG_OWNER_DECODER);
u4PayloadCnt++;
break;
}
}while(u4PayloadCnt < prInputParam->u4PayloadNumber);
//Send a AU boundary to trigger current frame decoding
rDecParam.u4AddrOfNALu = (kal_uint32)_au1H264DummyDelimiter;
rDecParam.u4LengthOfNALu = H264_HW_DUMMY_DELIMITER_LENGTH;
rDecParam.pReseved = NULL;
eResult = VideoH264DecNALu(&rDecParam);
//FIXME: in unsync mode, it can't return bitstream here!!!
//H264HwDecoderReturnBitstream((kal_uint32)&rReturnBs);
return rRet;
}
static kal_uint8 gt818_update_firmware( kal_uint8 *nvram, kal_uint16 length )
{
kal_uint8 ret,err,retry_time;
kal_uint16 cur_code_addr;
kal_uint16 cur_frame_num, total_frame_num;
if( length > TPD_NVRAM_LEN - NVRAM_BOOT_SECTOR_LEN )
{
drv_trace2( TRACE_GROUP_7, CTP_GOODIX_DWN_CHECK_IMAGE_SIZE_TRACE, length, TPD_NVRAM_LEN - NVRAM_BOOT_SECTOR_LEN );
downloader_errno = 1;
return 0;
}
retry_time = 5;
CTP_DWN_DEBUG_LINE_TRACE();
do
{
err = 0;
//ret = gt818_i2c_write( guitar_i2c_address, NVRAM_UPDATE_START_ADDR, nvram, length );
ret = gt818_i2c_write( guitar_i2c_address, NVRAM_UPDATE_START_ADDR, nvram, length );
if ( ret == 0 )
{
CTP_DWN_DEBUG_LINE_TRACE();
err = 1;
}
} while ( err == 1 && (--retry_time) > 0 );
//} while ( 1 );
if( err == 1 )
{
downloader_errno = 2;
CTP_DWN_DEBUG_LINE_TRACE();
return 0;
}
#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#else
total_frame_num = length;
for ( cur_frame_num = 0 ; cur_frame_num < total_frame_num ; cur_frame_num++ ) // read out all the code
{
cur_code_addr = NVRAM_UPDATE_START_ADDR + cur_frame_num;
retry_time=5;
do
{
err = 0;
ret = gt818_i2c_read( guitar_i2c_address, cur_code_addr, inbuf, 1);
if ( ret == 0 )
{
err = 1;
}
if( is_equal( &nvram[cur_frame_num], inbuf, 1 ) == 0 )
{
err = 1;
}
} while ( err == 1 && (--retry_time) > 0 );
if( err == 1 )
{
break;
}
}
#endif
CTP_DWN_DEBUG_LINE_TRACE();
if( err == 1 )
{
downloader_errno = 3;
CTP_DWN_DEBUG_LINE_TRACE();
return 0;
}
ret = gt818_nvram_store();
kal_sleep_task( 5 );
if( ret == 0 )
{
downloader_errno = 4;
CTP_DWN_DEBUG_LINE_TRACE();
return 0;
}
ret = gt818_nvram_recall();
kal_sleep_task( 5 );
if( ret == 0 )
{
downloader_errno = 5;
CTP_DWN_DEBUG_LINE_TRACE();
return 0;
}
return 1;
}
static kal_int32 gt818_downloader_probe( kal_uint16 cur_ver, kal_uint8 *firmware_ptr )
{
//TODO: process file
//struct file *fp;
kal_uint32 rlen;
kal_uint16 length;
kal_uint16 retry = 0;
FS_HANDLE handle;
int ret = 0;
ctp_firmware_info_t *fw_info = (ctp_firmware_info_t *)firmware_ptr;
unsigned char *data_ptr = &(fw_info->data);
kal_wchar CTP_FIRMWARE_PATH[64];
kal_int16 drv_letter;
kal_bool delete_firmware = KAL_FALSE;
CTP_DWN_DEBUG_LINE_TRACE();
length = 0;
drv_letter = FS_GetDrive(FS_DRIVE_V_NORMAL, 2, FS_DRIVE_I_SYSTEM | FS_DRIVE_V_NORMAL); // phone memory
kal_wsprintf( CTP_FIRMWARE_PATH, "%c:\\%s", drv_letter, GT818_FW_STRING );
ret = FS_CheckFile(CTP_FIRMWARE_PATH);
if(ret < 0)
{
drv_letter = FS_GetDrive( FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE ); //SD Card
kal_wsprintf( CTP_FIRMWARE_PATH, "%c:\\%s", drv_letter, GT818_FW_STRING );
}
else
{
delete_firmware = KAL_TRUE; // need delete firmware after update
}
handle = FS_Open( CTP_FIRMWARE_PATH, FS_READ_ONLY );
if ( handle >= 0 ) // file system first
{
do
{
rlen = 0;
ret = FS_Read( handle, &data_ptr[length], 256, &rlen );
length += rlen;
if ( rlen != 256 )
{
CTP_DWN_DEBUG_LINE_TRACE();
break;
}
else
{
drv_trace1( TRACE_GROUP_7, CTP_GOODIX_DWN_READ_IMAGE_TRACE, rlen);
}
} while ( 1 );
FS_Close( handle );
}
else
{
const int MAGIC_NUMBER_1 = 0x4D454449;
const int MAGIC_NUMBER_2 = 0x4154454B;
unsigned short checksum = 0;
int i;
drv_trace2( TRACE_GROUP_7, CTP_GOODIX_DWN_MAGIC_NUM_TRACE, fw_info->magic_number_1, fw_info->magic_number_2 );
drv_trace2( TRACE_GROUP_7, CTP_GOODIX_DWN_MAGIC_NUM_TRACE, MAGIC_NUMBER_1, MAGIC_NUMBER_2 );
drv_trace2( TRACE_GROUP_7, CTP_GOODIX_DWN_VERSION_TRACE, cur_ver, fw_info->version );
drv_trace2( TRACE_GROUP_7, CTP_GOODIX_DWN_IMAGE_INFO_TRACE, fw_info->length, fw_info->checksum );
if ( fw_info->magic_number_1 != MAGIC_NUMBER_1 && fw_info->magic_number_2 != MAGIC_NUMBER_2 )
{
CTP_DWN_DEBUG_LINE_TRACE();
goto exit_downloader;
}
if ( cur_ver >= fw_info->version )
{
CTP_DWN_DEBUG_LINE_TRACE();
goto exit_downloader;
}
// check if it is the same chip version
if ( get_chip_version( cur_ver ) != get_chip_version( fw_info->version ) )
{
CTP_DWN_DEBUG_LINE_TRACE();
goto exit_downloader;
}
for ( i = 0 ; i < fw_info->length ; i++ )
checksum += data_ptr[i];
checksum = checksum%0xFFFF;
if ( checksum != fw_info->checksum )
{
CTP_DWN_DEBUG_LINE_TRACE();
goto exit_downloader;
}
length = fw_info->length;
}
while ( gt818_update_proc( data_ptr, length ) == 0 && retry < 2 ) retry++;
if ( (handle >= 0) && delete_firmware) //delete firmware when firmware in phone memory
FS_Delete( CTP_FIRMWARE_PATH );
//free_ctrl_buffer( nvram );
ret = 1;
exit_downloader:
return ret;
}
VIDEO_ENCODER_CODEC_ERROR_T MPEG4HWEncOpen(void)
{
VIDEO_ENCODER_CODEC_ERROR_T eRet = VIDEO_ENCODER_CODEC_ERROR_NONE;
MPEG4_ENCORE_SCENARIO eScenario;
kal_bool fgrCacheable;
MPEG4_ENCORE_MEM_INFO *rMPEG4Mem = &rMPEG4HWEncCtrl.rMPEG4Mem;
kal_mem_set(rMPEG4Mem, 0, sizeof(MPEG4_ENCORE_MEM_INFO));
rpMPEG4HWEncDriver = GetMPEG4HWEncDriverHandle();
ASSERT(rMPEG4HWEncCtrl.eScenario!=VIDEO_ENCODER_SCENARIO_NONE);
switch(rMPEG4HWEncCtrl.eScenario)
{
case VIDEO_ENCODER_SCENARIO_ENCODER:
eScenario = MPEG4_ENCORE_SCENARIO_REC;
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_SCENARIO, (void *)&eScenario);
rMPEG4Mem->int_mem_size = ENC_MAX_INT_MEMORY(ENC_MAX_FRAME_WIDTH, ENC_MAX_FRAME_HEIGHT)+8;
rMPEG4Mem->ext_mem_size = ENC_MAX_EXT_MEMORY(ENC_MAX_FRAME_WIDTH, ENC_MAX_FRAME_HEIGHT)+8;
rMPEG4Mem->res_mem_size = ENC_MAX_RESUME_BUFFER_SIZE;
break;
case VIDEO_ENCODER_SCENARIO_VT:
eScenario = MPEG4_ENCORE_SCENARIO_VT;
rpMPEG4HWEncDriver->set_param(MPEG4_ENCORE_PARAM_SCENARIO, (void *)&eScenario);
rMPEG4Mem->int_mem_size = ENC_MAX_INT_MEMORY(ENC_MAX_FRAME_WIDTH_VT, ENC_MAX_FRAME_HEIGHT_VT)+8;
rMPEG4Mem->ext_mem_size = ENC_MAX_EXT_MEMORY(ENC_MAX_FRAME_WIDTH_VT, ENC_MAX_FRAME_HEIGHT_VT)+8;
rMPEG4Mem->res_mem_size = ENC_MAX_RESUME_BUFFER_SIZE_VT;
break;
default :
ASSERT(0);
break;
}
rMPEG4Mem->int_mem_addr = (kal_uint8 *)VideoEncoderGetIntMem(rMPEG4Mem->int_mem_size);
ASSERT(rMPEG4Mem->int_mem_addr);
rMPEG4Mem->int_mem_addr = (kal_uint8 *)(((kal_uint32)rMPEG4Mem->int_mem_addr + 7) & 0xfffffff8);
rMPEG4Mem->ext_mem_addr = (kal_uint8 *)VideoEncoderMallocAligned(rMPEG4Mem->ext_mem_size);
ASSERT(rMPEG4Mem->ext_mem_addr);
rMPEG4Mem->ext_mem_addr = (kal_uint8 *)(((kal_uint32)rMPEG4Mem->ext_mem_addr + 7) & 0xfffffff8);
fgrCacheable = VideoCommIsExtBufferCacheable((kal_uint32)rMPEG4Mem->ext_mem_addr, rMPEG4Mem->ext_mem_size);
if(fgrCacheable)
{
rMPEG4Mem->ext_mem_addr = (kal_uint8*)VideoCommExtBufferCacheableSwitchAlignMemory(
(kal_uint32)rMPEG4Mem->ext_mem_addr, rMPEG4Mem->ext_mem_size, VIDEO_NON_CACHEABLE);
}
rMPEG4Mem->res_mem_addr = (kal_uint8 *)VideoEncoderMallocAligned(rMPEG4Mem->res_mem_size);
ASSERT(rMPEG4Mem->res_mem_addr);
fgrCacheable = VideoCommIsExtBufferCacheable((kal_uint32)rMPEG4Mem->res_mem_addr, rMPEG4Mem->res_mem_size);
if(fgrCacheable)
{
rMPEG4Mem->res_mem_addr = (kal_uint8*)VideoCommExtBufferCacheableSwitchAlignMemory(
(kal_uint32)rMPEG4Mem->res_mem_addr, rMPEG4Mem->res_mem_size, VIDEO_NON_CACHEABLE);
}
rpMPEG4HWEncDriver->open(rMPEG4Mem);
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_OPEN, rMPEG4Mem->int_mem_size, rMPEG4Mem->ext_mem_size);
return eRet;
}
DCL_STATUS DclSKBD_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
{
switch (cmd)
{
case KBD_CMD_SET_LONG_PRESS_TIME:
{
SKBD_CTRL_TIME_T* prCtrlSLP;
prCtrlSLP = &(data->rKBDCtrTime);
KBD.longpress_timeout = prCtrlSLP->u4Tick;
break;
}
case KBD_CMD_SET_REPEAT_PRESS_TIME:
{
SKBD_CTRL_TIME_T* prCtrlTime ;
prCtrlTime = &(data->rKBDCtrTime);
KBD.repeat_time = prCtrlTime->u4Tick;
break;
}
case KBD_CMD_SET_DETECTION_MODE:
{
SKBD_CTRL_MODE_T* prCtrlMode;
prCtrlMode = &(data->rKBDCtrMode);
prCtrlMode->bFlag = (DCL_BOOL)kbd_SetDetectionMode((kbd_key_det_mode)prCtrlMode->Det_Mode);
break;
}
case KBD_CMD_GET_KEY_DATA:
{
kal_bool fg ;
//kbd_data keydata;
SKBD_CTRL_KEYDATA_T* prCtrlData ;
prCtrlData = &(data->rKBDCtrGetData);
fg = Kbd_GetKeyDatas((kbd_data*)prCtrlData);
if(KAL_FALSE == fg)
return STATUS_BUFFER_EMPTY;
break;
}
case KBD_CMD_PEEK_KEY_DATA:
{
kal_bool fg;
SKBD_CTRL_PEEKDATA_T* prCtrlData1;
prCtrlData1 = &(data->rKBDCtrPeekData);
fg = Kbd_PeekKeyDatas((kbd_data*)prCtrlData1->keydata, (kal_bool)prCtrlData1->specify_read, (kal_uint32)prCtrlData1->read_pointer, (kal_uint32*)prCtrlData1->current_read_pointer);
if(KAL_FALSE == fg)
return STATUS_BUFFER_EMPTY;
break;
}
case KBD_CMD_GET_DETECTION_MODE:
{
SKBD_CTRL_MODE_T* prCtrlMode1;
prCtrlMode1 = &(data->rKBDCtrMode);
prCtrlMode1->Det_Mode = kbd_key_detection_mode;
break;
}
case KBD_CMD_CTRL_KEY_SUPPORT:
{
SKBD_CTRL_KEYSUPPORT_T* pCtrl = &(data->rKBDCtrlKeySupport);
pCtrl->fgIKBS = kbd_IsKeySupported(pCtrl->uKey);
break;
}
case KBD_CMD_CTRL_KEY_MULTIPLE:
{
SKBD_CTRL_MULTIKEY_T* pCtrl = &(data->rKBDCtrlMultiple);
pCtrl->fgIMK = kbd_IsKeymutiple(pCtrl->uKey);
break;
}
case KBD_CMD_GET_KEY_EVENT_CNT:
{
kal_uint8 left;
SKBD_CTRL_KEY_CNT_T* pCtrl = &(data->rKBDCtrkeyCnt);
kbdbuffer_get_roomleft(left);
pCtrl->keycnt = (kbd_buffer_size - left - 1);
break;
}
case KBD_CMD_PUT_KEY_DATA:
{
SKBD_CTRL_PUTKEY_T* PtrlData;
PtrlData = &(data->rKBDCtrPutKey);
kbd_SendKey(PtrlData->keydata);
break;
}
case KBD_CMD_FIND_TWO_STEP:
{
SKBD_CTRL_FIND_TWO_STEP_T* pctrldata;
pctrldata = &(data->rKBDCtrlFindTwoStepKey);
#ifdef __KBD_2STEP_KEY_SUPPORT__
*(pctrldata->number)=1;
*(pctrldata->two_step)=DEVICE_KEY_FUNCTION;
#else
*(pctrldata->two_step)=0;
#endif
#if !defined(LOW_COST_SUPPORT)
drv_trace2(TRACE_GROUP_10, KBD_2STEP_KEY_QUERY, *(pctrldata->two_step), *(pctrldata->number));
#endif // #if !defined(LOW_COST_SUPPORT)
}
break;
default:
break;
}
return STATUS_OK;
}
kal_bool _VideoDecoderScenarioTypeChecking(VIDEO_DECODER_MGR_T *prDecoderMGR, VIDEO_DECODER_CODEC_T eCodec, VIDEO_DECODER_SCENARIO_T eScenario)
{
VIDEO_DECODER_MGR_DNZ_T* prVDMgrDNZ = &prDecoderMGR->rVDMgrDNZ;
prVDMgrDNZ->eScenario = eScenario;
switch (eCodec)
{
#ifdef __VE_MPEG4_DEC_SW_SUPPORT__
case VIDEO_CODEC_MPEG4:
{
prVDMgrDNZ->eCodec = CODEC_MPEG4;
switch (eScenario)
{
case VIDEO_SCENARIO_PLAYER:
case VIDEO_SCENARIO_KMV:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_PLAYER);
break;
#ifdef __VE_VIDEO_VT_SUPPORT__
case VIDEO_SCENARIO_VT:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_VIDEOCALL);
break;
#endif
case VIDEO_SCENARIO_QVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_QVGA);
break;
case VIDEO_SCENARIO_QVGA_MPEG4SP:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_QVGA_MPEG4SP);
break;
// preview
case VIDEO_SCENARIO_PREVIEW:
case VIDEO_SCENARIO_PREVIEW_KMV:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_PREVIEW);
break;
case VIDEO_SCENARIO_QCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_QCIF);
break;
case VIDEO_SCENARIO_VGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_VGA);
break;
case VIDEO_SCENARIO_CIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_CIF);
break;
case VIDEO_SCENARIO_UPTOCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_UPTOCIF);
break;
case VIDEO_SCENARIO_UPTOQVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_MPEG4, VADP_UPTOQVGA);
break;
default:
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
}
break;
case VIDEO_CODEC_H263:
{
prVDMgrDNZ->eCodec = CODEC_H263;
switch (eScenario)
{
case VIDEO_SCENARIO_PLAYER:
case VIDEO_SCENARIO_KMV:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263,VADP_PLAYER);
break;
#ifdef __VE_VIDEO_VT_SUPPORT__
case VIDEO_SCENARIO_VT:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_VIDEOCALL);
break;
#endif
case VIDEO_SCENARIO_QVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_QVGA);
break;
case VIDEO_SCENARIO_QVGA_MPEG4SP:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_QVGA_MPEG4SP);
break;
// preview
case VIDEO_SCENARIO_PREVIEW:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_PREVIEW);
break;
case VIDEO_SCENARIO_QCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_QCIF);
break;
case VIDEO_SCENARIO_VGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_VGA);
break;
case VIDEO_SCENARIO_CIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_CIF);
break;
case VIDEO_SCENARIO_UPTOCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_UPTOCIF);
break;
case VIDEO_SCENARIO_UPTOQVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H263, VADP_UPTOQVGA);
break;
default:
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
}
break;
#endif
#ifdef __VE_MPEG4_DEC_HW_SUPPORT__
case VIDEO_CODEC_MPEG4:
{
prVDMgrDNZ->eCodec = CODEC_MPEG4;
prVDMgrDNZ->prCodecAPI = GetMPEG4HwDecoderHandler(eScenario);
}
break;
case VIDEO_CODEC_H263:
{
prVDMgrDNZ->eCodec = CODEC_H263;
prVDMgrDNZ->prCodecAPI = GetMPEG4HwDecoderHandler(eScenario);
}
break;
#endif
#ifdef __VE_H264_DEC_SW_SUPPORT__
case VIDEO_CODEC_H264:
{
prVDMgrDNZ->eCodec = CODEC_H264;
switch (eScenario)
{
case VIDEO_SCENARIO_PLAYER:
case VIDEO_SCENARIO_KMV:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_PLAYER);
break;
case VIDEO_SCENARIO_QVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_QVGA);
break;
case VIDEO_SCENARIO_QVGA_MPEG4SP:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_QVGA_MPEG4SP);
break;
// preview
case VIDEO_SCENARIO_PREVIEW:
case VIDEO_SCENARIO_PREVIEW_KMV:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_PREVIEW);
break;
case VIDEO_SCENARIO_QCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_QCIF);
break;
case VIDEO_SCENARIO_VGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_VGA);
break;
case VIDEO_SCENARIO_CIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_CIF);
break;
case VIDEO_SCENARIO_UPTOCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_UPTOCIF);
break;
case VIDEO_SCENARIO_UPTOQVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_H264, VADP_UPTOQVGA);
break;
default:
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
}
break;
#endif
#ifdef __VE_H264_DEC_HW_SUPPORT__
case VIDEO_CODEC_H264:
{
prVDMgrDNZ->eCodec = CODEC_H264;
prVDMgrDNZ->prCodecAPI = GetH264HwDecoderHandler(eScenario);
}
break;
#endif
#ifdef __VE_RV_DEC_SW_SUPPORT__
case VIDEO_CODEC_RV9_10:
{
prVDMgrDNZ->eCodec = CODEC_RV9_10;
switch (eScenario)
{
case VIDEO_SCENARIO_PLAYER:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_PLAYER);
break;
case VIDEO_SCENARIO_QVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_QVGA);
break;
case VIDEO_SCENARIO_QVGA_MPEG4SP:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_QVGA_MPEG4SP);
break;
// preview
case VIDEO_SCENARIO_PREVIEW:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_PREVIEW);
break;
case VIDEO_SCENARIO_QCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_QCIF);
break;
case VIDEO_SCENARIO_VGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_VGA);
break;
case VIDEO_SCENARIO_CIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_CIF);
break;
case VIDEO_SCENARIO_UPTOCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_UPTOCIF);
break;
case VIDEO_SCENARIO_UPTOQVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_RV9_10, VADP_UPTOQVGA);
break;
default:
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
}
break;
#endif
#ifdef __VE_MJPEG_DEC_SW_SUPPORT__
case VIDEO_CODEC_MJPEG:
{
prVDMgrDNZ->eCodec = CODEC_MJPEG;
switch (eScenario)
{
case VIDEO_SCENARIO_PLAYER:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
case VIDEO_SCENARIO_QVGA:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
case VIDEO_SCENARIO_QVGA_MPEG4SP:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
// preview
case VIDEO_SCENARIO_PREVIEW:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
case VIDEO_SCENARIO_QCIF:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
case VIDEO_SCENARIO_VGA:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
case VIDEO_SCENARIO_CIF:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
case VIDEO_SCENARIO_UPTOQVGA:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
case VIDEO_SCENARIO_UPTOCIF:
prVDMgrDNZ->prCodecAPI = GetMJPEGDecoderHandler(eScenario);
if (prVDMgrDNZ->prCodecAPI == NULL)
{
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
break;
default:
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
}
break;
#endif
#ifdef __VE_VP8_DEC_SW_SUPPORT__
case VIDEO_CODEC_VP8:
{
prVDMgrDNZ->eCodec = CODEC_VP8;
switch (eScenario)
{
case VIDEO_SCENARIO_PLAYER:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_PLAYER);
break;
case VIDEO_SCENARIO_QVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_QVGA);
break;
case VIDEO_SCENARIO_QVGA_MPEG4SP:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_QVGA_MPEG4SP);
break;
// preview
case VIDEO_SCENARIO_PREVIEW:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_PREVIEW);
break;
case VIDEO_SCENARIO_QCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_QCIF);
break;
case VIDEO_SCENARIO_VGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_VGA);
break;
case VIDEO_SCENARIO_CIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_CIF);
break;
case VIDEO_SCENARIO_UPTOCIF:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_UPTOCIF);
break;
case VIDEO_SCENARIO_UPTOQVGA:
prVDMgrDNZ->prCodecAPI = GetVideoDecoderAdapterHandle(VADP_CODEC_VP8, VADP_UPTOQVGA);
break;
default:
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
}
break;
#endif
default:
drv_trace4(TRACE_GROUP_10, VDEC_GET_HDLR, eCodec, eScenario, VIDEO_ERROR_UNDEFINED, 0);
return KAL_FALSE;
}
if (NULL == prVDMgrDNZ->prCodecAPI)
{
drv_trace2(TRACE_GROUP_10, VDEC_FAIL_GET_HDLR, eCodec, eScenario);
return KAL_FALSE;
}
return KAL_TRUE;
}
