comutl.c

ct952 source code use for Digital Frame Photo

// Micky1.20, add NO_FLOAT_POINT, NO_DIRECT_OPERATION, NO_SHIFT
// Micky1.07, remove CHIP_W9928 for 28AF related codes

#include    "winav.h"

#include    "comutl.h"

// LLY.043, define some global variable for temporal usage
BYTE    _bCOMUTLTmp1, _bCOMUTLTmp2, _bCOMUTLTmp3;

//!!! __dwCOMUTLTemp _wCOMUTLTemp and _bCOMUTLTmp1/2/3, uDword
// will be used at the same time
DWORD   __dwCOMUTLTemp;
UDWORD      uDWord;
UWORD      uWord;
// porting from DVDINFO
//***************************************************************************
//  Function    :   ::COMUTL_ReadBufferDWORD
//  Abstract    :
//  Arguments   :   pStr                : Destination string pointer
//                  wOffset             : The starting offse of unit
//  Return      :   Getting Value (DWORD)
//  Side Effect :
//  Notes       :
//***************************************************************************
DWORD   COMUTL_ReadBufferDWORD ( char * pStr, int wOffset )
{
#ifdef    USE_LITTLE_ENDIAN
    uDWord. cS[3]= pStr[ wOffset ];
    uDWord. cS[2]= pStr[ wOffset+ 1];
    uDWord. cS[1]= pStr[ wOffset+ 2];
    uDWord. cS[0]= pStr[ wOffset+ 3];
#else
    uDWord. cS[3]= pStr[ wOffset+ 3];
    uDWord. cS[2]= pStr[ wOffset+ 2];
    uDWord. cS[1]= pStr[ wOffset+ 1];
    uDWord. cS[0]= pStr[ wOffset+ 0];
#endif    // USE_LITTLE_ENDIAN

    return  uDWord. dwVal;
}

//***************************************************************************
//  Function    :   ::COMUTL_ReadBufferWORD
//  Abstract    :
//  Arguments   :   pStr                : Destination string pointer
//                  wOffset             : The starting offse of unit
//  Return      :   Getting Value (WORD)
//  Side Effect :
//  Notes       :
//***************************************************************************
WORD    COMUTL_ReadBufferWORD ( char * pStr, int wOffset )
{

#ifdef    USE_LITTLE_ENDIAN
    uWord. cS[1]= pStr[ wOffset ];
    uWord. cS[0]= pStr[ wOffset+ 1];
#else
    uWord. cS[1]= pStr[ wOffset+ 1 ];
    uWord. cS[0]= pStr[ wOffset ];
#endif    // USE_LITTLE_ENDIAN

    return  uWord. nVal;
}

//  *********************************************************************
//  Function    :   COMUTL_DecimaltoBCD
//  Description :       Convert the decimal value into BCD value
//  Arguments   :   bVal        : decimal value
//  Return      :   BCD value
//  Side Effect :
//  *********************************************************************
BYTE    COMUTL_DecimaltoBCD ( BYTE bVal )
{
        return ((bVal%10) & 0x0F) | (((bVal/10) << 4) & 0xF0);
}

//  *********************************************************************
//  Function    :   COMUTL_BCDtoDecimal
//  Description :       Convert the BCD value into decimal
//  Arguments   :   bVal        : BCD value
//  Return      :   Decimal value
//  Side Effect :
//  *********************************************************************
BYTE    COMUTL_BCDtoDecimal ( BYTE bVal )
{
        return (bVal&0x0F) + ((bVal&0xF0) >> 4) * 10;
}

//  *********************************************************************
//  Function    :   COMUTL_MSFToHSG
//  Description :       Convert the time format from mm:ss:ff into HSG(sector)
//  Arguments   :       msftime : 0f:sm
//  Return      :       the converted HSG value
//  Side Effect :
//  *********************************************************************
DWORD       COMUTL_MSFtoHSG ( DWORD msfTime )
{

    uDWord.cS[0]= MSF_MINUTE ( msfTime );
    uDWord.cS[1]= MSF_SECOND ( msfTime );
    uDWord.cS[2]= MSF_FRAME ( msfTime );

    // HSG = mm*75L*60L + ss*75L + ff - 150L
    __dwCOMUTLTemp= uDWord.cS[0]* 75L* 60L+ uDWord.cS[1]* 75L+ uDWord.cS[2];

    if (__dwCOMUTLTemp >150)
        __dwCOMUTLTemp -= 150L;
    else
        __dwCOMUTLTemp=0L;

    return __dwCOMUTLTemp;
}

//  *********************************************************************
//  Function    :   COMUTL_HSGToMSF
//  Description :   Convert the time format from HSG(sector) into mm:ss:ff
//  Arguments   :
//  Return      :   The converted mm:ss:ff value, 0f:sm
//  Side Effect :
//  *********************************************************************
DWORD       COMUTL_HSGtoMSF ( DWORD hsgTime )
{

    hsgTime+= 150L;

    __dwCOMUTLTemp= hsgTime/ 75;

    uDWord.cS[0]=(BYTE)(__dwCOMUTLTemp/60);
    uDWord.cS[1]=(BYTE)(__dwCOMUTLTemp%60);     // MAX. is 59
    uDWord.cS[2]=(BYTE)(hsgTime%75);

    // convert mm:ss:ff into DWORD format xf:sm
    __dwCOMUTLTemp= MAKE_MSF ( uDWord.cS[0], uDWord.cS[1], uDWord.cS[2] );

    return __dwCOMUTLTemp;
}


// **************************************************************************
//  Function    :   COMUTL_Delay
//  Description :   Loop for delay a moment
//  Arguments   :   wLoop:the loop time
//  Return      :   none
//  Side Effect :
// **************************************************************************
#ifdef  NOT_SUPPORT_TIMER
void COMUTL_Delay(WORD wLoop)
{
    DWORD   i;
    for(i=0;i<wLoop;i++);
}
#endif      // NOT_SUPPORT_TIMER

// ** TCH0.38; begin...
// **************************************************************************
//  Function    :   COMUTL_StrUpr
//  Description :   Transfer Lowercase to Uppercase; other is no effect.
//  Arguments   :   pS      : char pointer
//  Return      :   none
//  Side Effect :
// **************************************************************************
void COMUTL_StrUpr ( char * pS )
{
    for ( _bCOMUTLTmp1=0; _bCOMUTLTmp1< 255; _bCOMUTLTmp1++ )
    {
        if ( ! (pS[_bCOMUTLTmp1] ) )
        {
            break;
        }

        if ( (pS[_bCOMUTLTmp1] >= 97) && (pS[_bCOMUTLTmp1] <= 122) )
        {
// Micky1.20, 4M flash, reduce common bank lib.
// use Array[]-=xx will invoke C51 lib (?C?CILDOPTR), 34 bytes
#ifdef  NO_DIRECT_OPERATION
            _bCOMUTLTmp3 = pS[_bCOMUTLTmp1];
            _bCOMUTLTmp3 -= 32;
            pS[_bCOMUTLTmp1] = _bCOMUTLTmp3;
#else
            pS[_bCOMUTLTmp1]-= 32;     // Lowercase to Uppercase.
#endif
        }
    }
}

// **************************************************************************
//  Function    :   COMUTL_SwapDWORD
//  Description :   Swap a DWORD by BYTE unit.
//  Arguments   :   pdwPtr   : DWORD pointer
//  Return      :   none
//  Side Effect :
// **************************************************************************
void COMUTL_SwapDWORD ( DWORD * pdwPtr )
{

    __dwCOMUTLTemp= *pdwPtr;
    for ( _bCOMUTLTmp1= 0; _bCOMUTLTmp1< 4 ;_bCOMUTLTmp1++ )
    {
        uDWord.cS[_bCOMUTLTmp1]= (BYTE) (__dwCOMUTLTemp>> (_bCOMUTLTmp1*8) );
    }

    __dwCOMUTLTemp= 0;
    for ( _bCOMUTLTmp1= 0; _bCOMUTLTmp1< 4 ;_bCOMUTLTmp1++ )
    {
        __dwCOMUTLTemp |= ((DWORD)uDWord.cS[_bCOMUTLTmp1])<< ((3-_bCOMUTLTmp1)*8);
    }

    * pdwPtr= __dwCOMUTLTemp;
}

// wyc1.01-909, add one function to swap WORD for FAT usage.
// **************************************************************************
//  Function    :   COMUTL_SwapWORD
//  Description :   Swap a WORD by BYTE unit.
//  Arguments   :   pwPtr   : WORD pointer
//  Return      :   none
//  Side Effect :
// **************************************************************************
void COMUTL_SwapWORD ( WORD * pwPtr )
{

    __dwCOMUTLTemp= *pwPtr;
    for ( _bCOMUTLTmp1= 0; _bCOMUTLTmp1< 2 ;_bCOMUTLTmp1++ )
    {
        uDWord.cS[_bCOMUTLTmp1]= (BYTE) (__dwCOMUTLTemp>> (_bCOMUTLTmp1*8) );
    }

    __dwCOMUTLTemp= 0;
    for ( _bCOMUTLTmp1= 0; _bCOMUTLTmp1< 2 ;_bCOMUTLTmp1++ )
    {
        __dwCOMUTLTemp |= ((WORD)uDWord.cS[_bCOMUTLTmp1])<< ((1-_bCOMUTLTmp1)*8);
    }

    * pwPtr= (WORD)__dwCOMUTLTemp;
}


// ** TCH0.39; begin...
//***************************************************************************
//  Function    :   ::COMUTL_HMStoSecond
//  Abstract    :
//  Arguments   :   ptr                 :
//  Return      :   Second NO.
//  Side Effect :
//  Notes       :
//***************************************************************************
WORD    COMUTL_HMStoSecond ( BYTE * ptr )
{
    uWord.nVal= 0;

    uDWord.cS[0]= COMUTL_BCDtoDecimal ( ptr[0] );
    uWord.nVal+= 3600* (WORD) uDWord.cS[0];

    uDWord.cS[0]= COMUTL_BCDtoDecimal ( ptr[1] );
    uWord.nVal+= 60* (WORD) uDWord.cS[0];

    uDWord.cS[0]= COMUTL_BCDtoDecimal ( ptr[2] );
    uWord.nVal+= (WORD) uDWord.cS[0];

    return  uWord.nVal;
}

//***************************************************************************
//  Function    :   ::COMUTL_HMSFtoSecond
//  Abstract    :
//  Arguments   :   ptr                 :
//  Return      :   Second NO.
//  Side Effect :
//  Notes       :
//***************************************************************************