rtd2533b_osdfunc.c

Realtek LCD monitor chip RTD25xx source code

        switch(*(pArray + cnt))
        {
            case _EXT_:
                if(*(pArray + cnt + 1) > 3)
                    return;
                temp = _EXT_ + *(pArray + cnt + 1);
                cnt += 2;
                break;

            case _REPEAT_:
                if(temp1 < (*(pArray + cnt + 1) - 1))
                    temp1++;                
                else
                {
                    cnt += 2;
                    temp1 = 0;
                    continue;
                }
                break;

            case _NEXT_:
                cnt++;
                COsdFxCalcStartAddress(++ucRow, ucCol, _WRITE_BYTE1);
                continue;

            default:
                temp = *(pArray + cnt);
                cnt++;
                break;
        }

        CScalerWrite(_OSD_DATA_PORT_92, 1, &temp, _NON_AUTOINC);
    }
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
BYTE COsdFxGetColWithinText(BYTE ucPos, BYTE ucSelect, BYTE code *pArray)
{
    BYTE cnt, ss, temp, temp1, temp2;
    WORD length;

    length = cnt = ss = temp = temp1 = 0;

    while(_TRUE)
    {
        if(*(pArray + cnt) == _END_)
        {
            if(temp == ucSelect)
                break;
            else
            {
                pArray += (cnt + 1);
                cnt = 0;
            }
            temp++;
        }
        cnt++;
    }

    cnt = temp1 = 0;

    while(*(pArray + cnt) != _END_)
    {
        switch(*(pArray + cnt))
        {
            case _EXT_:
                if(*(pArray + cnt + 1) > 3)
                    return 0;
                temp = _EXT_ + *(pArray + cnt + 1);
                cnt += 2;
                break;

            case _REPEAT_:
                if(temp1 < (*(pArray + cnt + 1) - 1))
                    temp1++;                
                else
                {
                    cnt += 2;
                    temp1 = 0;
                    continue;
                }
                break;

            default:
                temp = *(pArray + cnt);
                cnt++;
                break;
        }

        ucPos++;
        ss = 0;
        temp2 = 0;
        while(_TRUE)
        {
            if((temp == (tOSD_CHARWIDTH_TABLE[0])[ss*2]) && ((tOSD_CHARWIDTH_TABLE[0])[ss*2+1] != _END_))
            {
                length += ((tOSD_CHARWIDTH_TABLE[0])[ss*2+1] & 0x0f);
                break;
            }
            else
            {
                if(((tOSD_CHARWIDTH_TABLE[0])[ss*2] == _END_) && ((tOSD_CHARWIDTH_TABLE[0])[ss*2+1] == _END_))
                {
                    temp2 = 1;
                    break;
                }
            }
            ss++;
        }

        ss = 0;
        while(temp2 == 1)
        {
            if((temp == (tOSD_CHARWIDTH_TABLE[ucSelect+1])[ss*2]) && ((tOSD_CHARWIDTH_TABLE[ucSelect+1])[ss*2+1] != _END_))
            {
                length += ((tOSD_CHARWIDTH_TABLE[ucSelect+1])[ss*2+1] & 0x0f);
                break;
            }
            else
            {
                if(((tOSD_CHARWIDTH_TABLE[ucSelect+1])[ss*2] == _END_) && ((tOSD_CHARWIDTH_TABLE[ucSelect+1])[ss*2+1] == _END_))
                {
                    length += 12;
                    break;
                }
            }
            ss++;
        }
    }

	temp = 12 - length%12;
	if(length%12)
		cnt = (temp < 4) ? temp + 12 : temp;
	else
		cnt = 0;

	if(cnt == 0)
		cnt = 0;
	else if( cnt < 12)
		cnt = 1;
	else
		cnt = 2;

	temp = (BYTE)(length/12) + cnt;

	return (ucPos - temp) + ((length%12) ? 1 : 0);
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
void COsdFxLoadIcon(BYTE ucRow, BYTE ucCol, BYTE code *pArray)
{
    COsdFxLoadText(ucRow, ucCol, 0, pArray);
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
void COsdFxChange1bitColor(BYTE ucRow, BYTE ucCol, BYTE ucSizeW, BYTE ucSizeH, BYTE ucForegroundColor, BYTE ucBackgroundColor)
{
    BYTE cntY, temp;

    temp = ((ucForegroundColor & 0x0f) << 4) | (ucBackgroundColor & 0x0f);

    for(cntY=0;cntY<ucSizeH;cntY++)
    {
        COsdFxCalcStartAddress(ucRow + cntY, ucCol, _WRITE_BYTE2);

        CScalerWriteAmount(_OSD_DATA_PORT_92, ucSizeW, temp, _NON_AUTOINC);
    }
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
void COsdFxChange2bitColor(BYTE ucRow, BYTE ucCol, BYTE ucSizeW, BYTE ucSizeH, BYTE ucColor0, BYTE ucColor1, BYTE ucColor2, BYTE ucColor3)
{
    BYTE cntY, temp;

    temp = 0xa0 | ((ucColor3 & 0x07) << 1) | ((ucColor0 & 0x04) >> 2);

    for(cntY=0;cntY<ucSizeH;cntY++)
    {
        COsdFxCalcStartAddress(ucRow + cntY, ucCol, _WRITE_BYTE0);

        CScalerWriteAmount(_OSD_DATA_PORT_92, ucSizeW, temp, _NON_AUTOINC);
    }

    temp = ((ucColor0 & 0x03) << 6) | ((ucColor2 & 0x07) << 3) | (ucColor1 & 0x07);

    for(cntY=0;cntY<ucSizeH;cntY++)
    {
        COsdFxCalcStartAddress(ucRow + cntY, ucCol, _WRITE_BYTE2);

        CScalerWriteAmount(_OSD_DATA_PORT_92, ucSizeW, temp, _NON_AUTOINC);
    }

}
/*
//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
void COsdFxChange4bitLUTColor(BYTE ucRow, BYTE ucCol, BYTE ucSizeW, BYTE ucSizeH, BYTE ucColor0)
{
    BYTE ucCntY, ucTemp;

    ucTemp = 0x90 | (ucColor0 & 0x0f);

    for(ucCntY=0;ucCntY<ucSizeH;ucCntY++)
    {
        COsdFxCalcStartAddress(ucRow + ucCntY, ucCol, _WRITE_BYTE0);

        CScalerWriteAmount(_OSD_DATA_PORT_92, ucSizeW, ucTemp, _NON_AUTOINC);
    }

    ucTemp = 0x00;

    for(ucCntY=0;ucCntY<ucSizeH;ucCntY++)
    {
        COsdFxCalcStartAddress(ucRow + ucCntY, ucCol, _WRITE_BYTE2);

        CScalerWriteAmount(_OSD_DATA_PORT_92, ucSizeW, ucTemp, _NON_AUTOINC);
    }
}
*/
//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
void COsdFxDrawWindow(WORD usXStart, WORD usYStart, WORD usXEnd, WORD usYEnd, BYTE *pStyle)
{
    BYTE cnt0, cnt1;

    cnt0    = CScalerGetBit(_OVERLAY_CTRL_6C, _BIT0);

    pData[0]    = (cnt0 == 0x00) ? 0xc1 : 0xe1;
    pData[1]    = ((*(pStyle)) * 4) + 1;
    CScalerWrite(_OSD_ADDR_MSB_90, 2, pData, _AUTOINC);

    pData[0]    = ((usXStart & 0x03F) << 2);
    pData[1]    = (((usYStart & 0x007) << 5) | ((usXStart & 0x7C0) >> 6));
    pData[2]    = (usYStart >> 3);
    pData[3]    = ((usXEnd & 0x03F) << 2);
    pData[4]    = (((usYEnd & 0x007) << 5) | ((usXEnd & 0x7C0) >> 6));
    pData[5]    = (usYEnd >> 3);
    CScalerWrite(_OSD_DATA_PORT_92, 6, pData, _NON_AUTOINC);

    CTimerDelayXms(40);

    for(cnt1=0;cnt1<2;cnt1++)
    {	
        pData[0]    = 0xc1;
        pData[1]    = ((*(pStyle)) * 4) + (cnt1 * 3);
        CScalerWrite(_OSD_ADDR_MSB_90, 2, pData, _AUTOINC);

        for(cnt0=0;cnt0<3;cnt0++)
            pData[cnt0]   = (*(pStyle + ((cnt1 * 3) + cnt0) + 1));

        CScalerWrite(_OSD_DATA_PORT_92, 3, pData, _NON_AUTOINC);
    }
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
void COsdFxHLine(BYTE ucRow, BYTE ucCol, BYTE ucLength, BYTE ucValue, BYTE ucIndicate)
{
    COsdFxCalcStartAddress(ucRow, ucCol, ucIndicate);

    if(ucIndicate == _WRITE_BYTEALL)
        CScalerWriteAmount(_OSD_DATA_PORT_92, ucLength * 3, ucValue, _NON_AUTOINC);
    else
        CScalerWriteAmount(_OSD_DATA_PORT_92, ucLength, ucValue, _NON_AUTOINC);
}
/*
//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
void COsdFxVLine(BYTE ucRow, BYTE ucCol, BYTE ucLength, BYTE ucValue, BYTE ucIndicate)
{
    BYTE cnt;

    for(cnt=0;cnt<ucLength;cnt++)
    {
        COsdFxCalcStartAddress(ucRow + cnt, ucCol, ucIndicate);

        if(ucIndicate == _WRITE_BYTEALL)
            CScalerWriteAmount(_OSD_DATA_PORT_92, 3, ucValue, _NON_AUTOINC);
        else
            CScalerWriteAmount(_OSD_DATA_PORT_92, 1, ucValue, _NON_AUTOINC);
    }
}
*/
//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
void COsdFxSetPosition(WORD usOsdActWidth, WORD usOsdActHeight, BYTE ucHPos, BYTE ucVPos, BYTE ucPar)
{
    if(ucHPos > _OSD_HPOSITION_RANGE)
        ucHPos = _OSD_HPOSITION_RANGE;

    if(ucVPos > _OSD_VPOSITION_RANGE)
        ucVPos = _OSD_VPOSITION_RANGE;

	usOsdActWidth  = _OSD_HPOSITION_OFFSET + (DWORD)((ucHPos)*((Panel[ucPanelSelect].DHEndPos - Panel[ucPanelSelect].DHStartPos)/4 - usOsdActWidth/4 - 4)) / _OSD_HPOSITION_RANGE;
	usOsdActHeight = _OSD_VPOSITION_OFFSET + (DWORD)((_OSD_VPOSITION_RANGE - ucVPos)*((Panel[ucPanelSelect].DVEndPos - Panel[ucPanelSelect].DVStartPos)/4 - usOsdActHeight/4 - 6)) / _OSD_VPOSITION_RANGE;

    CScalerSetBit(_OSD_SCRAMBLE_93, 0xf8, 0x02);

    pData[0] = CScalerGetBit(_OVERLAY_CTRL_6C, _BIT0);

    pData[0] = (pData[0] == 0x00) ? 0xc0 : 0xe0;
    pData[1] = 0x00;
    CScalerWrite(_OSD_ADDR_MSB_90, 2, pData, _AUTOINC);

    pData[0] = usOsdActHeight >> 1;
    pData[1] = (BYTE)(usOsdActWidth >> 2);
    pData[2] = ((BYTE)(usOsdActWidth & 0x0003) << 6) | ((usOsdActHeight & 0x01) << 5) | ucPar;
    CScalerWrite(_OSD_DATA_PORT_92, 3, pData, _NON_AUTOINC);
 
    CTimerWaitForEvent(_EVENT_DEN_STOP);
    CTimerWaitForEvent(_EVENT_DEN_STOP);
    CScalerSetBit(_OSD_SCRAMBLE_93, 0xf8, 0x05);
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
WORD COsdFxGetAdcClockRange(BYTE ucPar)
{
    WORD delta;

    CAdjustCheckAdcClockRange(stModeUserData.Clock, &delta);

    if(ucPar == _GET_CLOCKRANGE_MAX)
    {
        if(delta < _CLOCK_BIAS)
        {
            return (stModeInfo.IHTotal + delta);
        }
        else
        {
            if(stModeUserCenterData.CenterClock < stModeInfo.IHTotal)
            {
                if((stModeUserCenterData.CenterClock - stModeInfo.IHTotal + delta) < _CLOCK_BIAS)
                {
                    return (stModeInfo.IHTotal - delta + 2 * _CLOCK_BIAS);
                }
                else
                {
                    return (stModeUserCenterData.CenterClock + _CLOCK_BIAS);
                }
            }
            else
            {
                if((stModeInfo.IHTotal + delta - stModeUserCenterData.CenterClock) < _CLOCK_BIAS)
                {
                    return (stModeInfo.IHTotal + delta);
                }
                else
                {
                    return (stModeUserCenterData.CenterClock + _CLOCK_BIAS);
                }
            }
        }
    }
    else if(ucPar == _GET_CLOCKRANGE_MIN)
    {
        if(delta < _CLOCK_BIAS)
        {
            return (stModeInfo.IHTotal - delta);
        }
        else
        {
            if(stModeUserCenterData.CenterClock < stModeInfo.IHTotal)
            {
                if((stModeUserCenterData.CenterClock - stModeInfo.IHTotal + delta) < _CLOCK_BIAS)
                {
                    return (stModeInfo.IHTotal - delta);
                }
                else
                {
                    return (stModeUserCenterData.CenterClock - _CLOCK_BIAS);
                }
            }
            else
            {
                if((stModeInfo.IHTotal + delta - stModeUserCenterData.CenterClock) < _CLOCK_BIAS)
                {
                    return (stModeInfo.IHTotal + delta - 2 * _CLOCK_BIAS);
                }
                else
                {
                    return (stModeUserCenterData.CenterClock - _CLOCK_BIAS);
                }
            }
        }
    }
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
WORD COsdFxGetHPositionRange(BYTE ucPar)
{
    if(ucPar == _GET_HPOSITIONRANGE_MAX)
        return (stModeUserCenterData.CenterHPos + _HPOSITION_BIAS);
    else if(ucPar == _GET_HPOSITIONRANGE_MIN)
        return (stModeUserCenterData.CenterHPos - _HPOSITION_BIAS);
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
WORD COsdFxGetVPositionRange(BYTE ucPar)
{
    if(ucPar == _GET_VPOSITIONRANGE_MAX)
        return (stModeUserCenterData.CenterVPos + _VPOSITION_BIAS);
    else if(ucPar == _GET_VPOSITIONRANGE_MIN)
        return (stModeUserCenterData.CenterVPos - _VPOSITION_BIAS);
}

//--------------------------------------------------
// Description  : 
// Input Value  : 
// Output Value : 
//--------------------------------------------------
WORD COsdFxDetOverRange(WORD ucValue, WORD ucMax, WORD ucMin, BYTE ucSymbol)
{
    switch(ucSymbol)
    {
        case _DET_OVERRANGE_MAX:
            if (ucValue >= ucMax)
            {
                return ucMax;
            }
            else
            {
                ucValue++;
                return ucValue;
            }

        case _DET_OVERRANGE_MIN:
            if (ucValue <= ucMin)
            {
                return ucMin;
            }
            else
            {
                ucValue--;
                return ucValue;
            }
    }
}


#endif  // End of #if((_SCALER_TYPE == _RTD2533B) || (_SCALER_TYPE == _RTD2023L) || (_SCALER_TYPE == _RTD2023S) || (_SCALER_TYPE == _RTD2023L_VB) || (_SCALER_TYPE == _RTD2023S_VB))