hs_os.c

OS接口代码,实现OS中间件功能,抽取OS接口,........

*		partition:	指定将要分配内存的分区
*		num:	元素数量
*		size:		每个元素的内存大小
*
* Output:
*		无
*
* Return:
*		其他				- 成功，返回第一个元素的内存地址
*		NULL				- 失败
*
* Others:
*
****************************************************************************/
void *HS_OS_CallocEx (IN U32 partition, IN U32 num, IN U32 size)
{
    return HS_OS_Calloc(num, size);
}

/***************************************************************************
* Function:
*		HS_OS_Realloc
*
* Description:
*		为指针重新分配内存
*
* Input:
*		addr:	原内存地址
*		size:		新的内存大小
*
* Output:
*		无
*
* Return:
*		其他				- 成功，返回内存地址
*		NULL				- 失败
*
* Others:
*
****************************************************************************/
void* HS_OS_Realloc (IN void* addr, IN U32 size)
{
    void *pMem;

    pMem = realloc(addr, size);

    if (NULL == pMem)
    {
        hs_debug_print(ERROR_LEVEL, "Memory realloc fail!\n");
    }

    return (pMem);
}

/***************************************************************************
* Function:
*		HS_OS_Free
*
* Description:
*		释放内存
*
* Input:
*		addr:	内存地址
*
* Output:
*		无
*
* Return:
*		无
*
* Others:
*
****************************************************************************/
HS_ErrorCode_e HS_OS_Free (IN void* addr)
{

    if (NULL == addr)
    {
        hs_debug_print(ERROR_LEVEL, "Invalid parameter!\n");
        return HS_ERROR_PARA;
    }

    free(addr);

    return HS_NO_ERROR;
}

/***************************************************************************
* Function:
*		HS_OS_Memset
*
* Description:
*		为一段空间填充值
*
* Input:
*		addr:	内存地址
*		value:	欲填充的值
*		size:	需填充的空间大小(Byte)
*
* Output:
*		无
*
* Return:
*		a pointer to the memory area addr.
*
* Others:
*
****************************************************************************/
void *HS_OS_Memset (IN void *addr,  IN S32 value, IN U32 size)
{
    return memset(addr, value, size);
}


/***************************************************************************
* Function:
*		HS_OS_GetPartitionFreeSpace
*
* Description:
*		返回指定的内存分区的剩余空间大小
*
* Input:
*		partition:	内存地址
*
* Output:
*		size:   剩余空间大小，单位Byte
*
* Return:
*		无
*
* Others:
*
****************************************************************************/
HS_ErrorCode_e HS_OS_GetPartitionFreeSpace (IN U32 partition, OUT U32 *size)
{
    struct sysinfo sysInfo;
    if(0 != sysinfo(&sysInfo))
    {
        return HS_ERROR_FAILURE;
    }
    *size = sysInfo.freeram;
    return HS_NO_ERROR;
}

/***************************************************************************
* Function:
*		HS_OS_DelayS
*
* Description:
*		秒级延迟，延迟指定的时间
*
* Input:
*		ulSeconds:	延迟的秒数
*
* Output:
*		无
*
* Return:
*		无
*
* Others:
*
****************************************************************************/
void HS_OS_DelayS (IN U32 ulSeconds)
{
    usleep(ulSeconds * 1000 * 1000);
}

/***************************************************************************
* Function:
*		HS_OS_DelayMs
*
* Description:
*		毫秒级延迟，延迟指定的时间
*
* Input:
*		ulMSeconds:	延迟的毫秒数
*
* Output:
*		无
*
* Return:
*		无
*
* Others:
*
****************************************************************************/
void	HS_OS_DelayMs (IN U32 ulMSeconds)
{
    usleep(ulMSeconds * 1000);
}

/***************************************************************************
* Function:
*		HS_OS_GetTimeMs
*
* Description:
*		获得自开机开始到当前的时间，单位毫秒
*
* Input:
*		无
*
* Output:
*		无
*
* Return:
*		无
*
* Others:
*
****************************************************************************/
U64 HS_OS_GetTimeMs (void)
{
#if 0    
    U32 ret = 0;
    struct timeval tv;
    struct timezone tz;

    ret = gettimeofday(&tv, &tz);
    if (ret EQUAL 0)
    {
        return tv.tv_sec * 1000 + tv.tv_usec / 1000;
    }

    return 0;
#else
    return (U64)(times(NULL) * 1000 / sysconf(_SC_CLK_TCK)); 
#endif
}

/***************************************************************************
* Function:
*		HS_OS_GetVersion
*
* Description:
*		获取OS  模块版本号
*
* Input:
*		pchVer:	指向保存版本号的缓冲区的指针
*		size:		缓冲区的大小
*
* Output:
*		无
*
* Return:
*		实际的版本号的长度
*
* Others:
*
****************************************************************************/
U32 HS_OS_GetVersion(U8 *pchVer, U32 iSize)
{
    char    achTmp[32]  = HS_OS_VERSIONSTR; /*存放版本信息*/
    int     iActLen;
    int     iRetLen;

    iActLen = strlen(achTmp) + 1;

    if (pchVer == NULL)
    {
        iRetLen = iActLen; /*实际的版本信息长度*/
    }
    else
    {
        if (iSize < 0)
        {
            iRetLen = 0;
        }
        else if (iSize > iActLen)
        {
            iRetLen = iActLen;
        }
        else
        {
            iRetLen = iSize;
        }

        strncpy((char *)pchVer, achTmp, iRetLen);
    }

    return iRetLen;
}

#if 0
void  hs_set_debug_level( int level )
{
    g_nDebugLevel = level;

}
int hs_get_debug_level(void)
{
    return g_nDebugLevel;
}

void  hs_printf(const char *format, ...)
{
    char g_strOutBuff[1024];

    va_list args;
    va_start(args, format);
    vsprintf(g_strOutBuff, format, args);
    va_end(args);

    //STTBX_Print(g_strOutBuff);
    printf(g_strOutBuff);
    return;
}


#if HS_BYTEORDER == HS_LIL_ENDIAN
U16  HS_LE16_2_System16(U16 value)
{
    return value;
}
U16  HS_BE16_2_System16(U16 value)
{
    return hs_swap16(value);
}
U32  HS_LE32_2_System16(U16 value)
{
    return value;
}
U32  HS_BE32_2_System16(U16 value)
{
    return hs_swap32(value);

}
U16  HS_System16_2_LE16(U16 value)
{
    return value;
}
U16  HS_System16_2_BE16(U16 value)
{
    return hs_swap16(value);

}
U32  HS_System32_2_LE32(U16 value)
{
    return value;
}
U32  HS_System32_2_BE32(U16 value)
{
    return hs_swap32(value);
}
#elif HS_BYTEORDER == HS_BIL_ENDIAN
U16  HS_LE16_2_System16(U16 value)
{
    return hs_swap16(value);
}
U16  HS_BE16_2_System16(U16 value)
{
    return (value);
}
U32  HS_LE32_2_System16(U16 value)
{
    return hs_swap32(value);
}
U32  HS_BE32_2_System16(U16 value)
{
    return (value);

}
U16  HS_System16_2_LE16(U16 value)
{
    return hs_swap16(value);
}
U16  HS_System16_2_BE16(U16 value)
{
    return (value);

}
U32  HS_System32_2_LE32(U16 value)
{
    return hs_swap32(value);
}
U32  HS_System32_2_BE32(U16 value)
{
    return (value);
}
#else
#error "You seem to have an unsupported byteorder"
#endif

static U16 hs_swap16(U16 value)
{
    return((value << 8) | (value >> 8));
}

static U32 hs_swap32(U32 value)
{
    return((value << 24) | ((value << 8)&0x00FF0000) | ((value >> 8)&0x0000FF00) | (value >> 24));
}
#if 0

static U64 HSConvertMilliSeconds2Ticks( U32 dwMilliSeconds)
{
    U32  TicksPerSec = 0;

    TicksPerSec = ST_GetClocksPerSecond() / 1000;
    return time_plus(time_now(), dwMilliSeconds * TicksPerSec);
}
#endif

S8  *hs_os_get_err_text(HS_ErrorCode_e err_code)
{

    switch (err_code)
    {

    case HS_NO_ERROR:
        return (S8 *)"HS_NO_ERROR";
    case HS_ERROR_NOT_INIT:
        return (S8 *)"HS_ERROR_NOT_INIT";
    case HS_ERROR_HW:
        return (S8 *)"HS_ERROR_HW";
    case HS_ERROR_AGC_UNLOCK:
        return (S8 *)"HS_ERROR_AGC_UNLOCK";
    case HS_ERROR_STOP:
        return (S8 *)"HS_ERROR_STOP";
    case HS_ERROR_NO_MEMORY:
        return (S8 *)"HS_ERROR_NO_MEMORY";
    case HS_ERROR_UNKNOWN_DEVICE:
        return (S8 *)"HS_ERROR_UNKNOWN_DEVICE";
    case HS_ERROR_ALREADY_INITIALIZED:
        return (S8 *)"HS_ERROR_ALREADY_INITIALIZED";
    case HS_ERROR_NO_FREE_HANDLES:
        return (S8 *)"HS_ERROR_NO_FREE_HANDLES";
    case HS_ERROR_OPEN_HANDLE:
        return (S8 *)"HS_ERROR_OPEN_HANDLE";
    case HS_ERROR_INVALID_HANDLE:
        return (S8 *)"HS_ERROR_INVALID_HANDLE";
    case HS_ERROR_FEATURE_NOT_SUPPORTED:
        return (S8 *)"HS_ERROR_FEATURE_NOT_SUPPORTED";
    case HS_ERROR_INTERRUPT_INSTALL:
        return (S8 *)"HS_ERROR_INTERRUPT_INSTALL";
    case HS_ERROR_INTERRUPT_UNINSTALL:
        return (S8 *)"HS_ERROR_INTERRUPT_UNINSTALL";
    case HS_ERROR_TIMEOUT:
        return (S8 *)"HS_ERROR_TIMEOUT";
    case HS_ERROR_DEVICE_BUSY:
        return (S8 *)"HS_ERROR_DEVICE_BUSY";
    case HS_ERROR_FAILURE:
        return (S8 *)"HS_ERROR_FAILURE";
    case HS_ERROR_SI_PARSE_FAILED:
        return (S8 *)"HS_ERROR_SI_PARSE_FAILED";
    case HS_ERROR_WRONG_SI_DATA:
        return (S8 *)"HS_ERROR_WRONG_SI_DATA";
    case HS_ERROR_BAD_PARA:
        return (S8 *)"HS_ERROR_BAD_PARA";
    case HS_ERROR_PARSE_NIT_FAILED:
        return (S8 *)"HS_ERROR_PARSE_NIT_FAILED";
    case HS_ERROR_CREATE_TASK_FAILED:
        return (S8 *)"HS_ERROR_CREATE_TASK_FAILED";
    case HS_ERROR_SUBTABLE_MAX_OPENED:
        return (S8 *)"HS_ERROR_SUBTABLE_MAX_OPENED";
    case HS_ERROR_NO_FREE_SUBTABLE:
        return (S8 *)"HS_ERROR_NO_FREE_SUBTABLE";
    case HS_ERROR_CREATE_SEMAPHORE_FAILED:
        return (S8 *)"HS_ERROR_CREATE_SEMAPHORE_FAILED";
    case HS_ERROR_CANNOT_LOCK_CHANNEL:
        return (S8 *)"HS_ERROR_CANNOT_LOCK_CHANNEL";
    case HS_ERROR_CANNOT_READ_PAT:
        return (S8 *)"HS_ERROR_CANNOT_READ_PAT";
    case HS_ERROR_CANNOT_READ_PMT:
        return (S8 *)"HS_ERROR_CANNOT_READ_PMT";
    case HS_ERROR_CANNOT_READ_SDT:
        return (S8 *)"HS_ERROR_CANNOT_READ_SDT";
    case HS_ERROR_OPEN_DEMUX_FAILED:
        return (S8 *)"HS_ERROR_OPEN_DEMUX_FAILED";
        /* 网路升级 begin*/
    case HS_ERROR_NU_NOTSUITABLEVERSION:			/* 服务器端没有合适的升级版本 */
        return (S8*)"HS_ERROR_NU_NOTSUITABLEVERSION";
    case HS_ERROR_NU_SEVERDOWN:				/* 服务器当掉或者网络不通 */
        return (S8*)"HS_ERROR_NU_SEVERDOWN";
    case HS_ERROR_NU_OTHRE_FAILURE:			/* 其他网络升级错误 */
        return (S8*)"HS_ERROR_NU_OTHRE_FAILURE";
        /*demux*/
    case HS_ERROR_MUTEX_CREATE:/*mutex 建立错误*/
        return (S8*)"HS_ERROR_MUTEX_CREATE";
    case HS_ERROR_MUTEX_LOCK:/*mutex 锁定错误*/
        return (S8*)"HS_ERROR_MUTEX_LOCK";
    case HS_ERROR_MUTEX_UNLOCK:/*mutex 解锁错误*/
        return (S8*)"HS_ERROR_MUTEX_UNLOCK";
    case HS_ERROR_MUTEX_DELETE:/*mutex 销毁错误*/
        return (S8*)"HS_ERROR_MUTEX_DELETE";

        /* 网路升级 end*/
    default:
        return (S8 *)"UNKNOWN_ERROR";
    }
}

char *hs_get_file_name(char * p_str)
{
    int i = 0;

    for (i = strlen(p_str) - 1; i >= 0; i--)
    {
        if (p_str[i] == '\\')
        {
            return &p_str[i + 1];
        }
    }
    return p_str;
}
#endif