rvntptime.c

基于h323协议的软phone

    /* Shift everything to where the decimal should go */
    if(fracbits != RvUint8Const(32)) {
        if(fracbits < RvUint8Const(32)) {
            result >>= RvUint8Const(32) - fracbits;
        } else result <<= fracbits - RvUint8Const(32);
    }

    return result;
}

/* Convert nanoseconds to its NTP time fraction equivalent. The value */
/* of nsecs must be less than a second. */
RvUint32 RvNtpTimeNsecsToFraction(RvInt32 nsecs)
{
#if defined(RV_RANGECHECK)
    if((nsecs < RvInt32Const(0)) || (nsecs >= RV_TIME_NSECPERSEC))
       return RvUint32Const(0);
#endif

    /* Uses 64 bit math to maintain resolution */
    return (RvUint32)(((RvUint64)nsecs * RvUint64Const(0x100000000)) / RV_TIME64_NSECPERSEC);
}

/* Convert an NTP time fraction to nanoseconds. */
RvInt32 RvNtpTimeFractionToNsecs(RvUint32 fraction)
{
    /* Uses 64 bit math to maintain resolution */
    return (RvInt32)(((RvUint64)fraction * RV_TIME64_NSECPERSEC) / RvUint64Const(0x100000000));
}

#if defined(RV_TEST_CODE)
#include "rvstdio.h"
#include "rv64ascii.h"

#define TESTTIME_SEC1 997380342  /* seconds since 1970 */
#define TESTTIME_NSEC1 750000000 /* in nanoseconds (use values that don't round off) */
#define TESTTIME_NTPSEC1 (TESTTIME_SEC1 + NTPDELTA)
#define TESTTIME_NTPFRAC1 RvNtpTimeNsecsToFraction(TESTTIME_NSEC1)

#define TESTTIME_SEC2 998061863  /* seconds since 1970 */
#define TESTTIME_NSEC2 17578125 /* in nanoseconds (use values that don't round off) */
#define TESTTIME_NTPSEC2 (TESTTIME_SEC2 + NTPDELTA)
#define TESTTIME_NTPFRAC2 RvNtpTimeNsecsToFraction(TESTTIME_NSEC2)

void RvNtpTimeTest(void)
{
    RvNtpTime ntime1, ntime2, ntime3, ntime4, ntime5, ntime6, ntime7;
    RvNtpTime *result1, *result2, *result3, *result4, *result5, *result6, *result7;
    RvTime t2, t3;
    RvTime *tptr2, *tptr3;
    RvUint64 ntime64;
    RvChar buf[RV_64TOASCII_BUFSIZE];

    RvPrintf("Starting test of rvntptime.\n");
    RvPrintf("Time#1: Secs=%d NSecs=%d NTPSecs=%u NTPFrac=%08x\n", TESTTIME_SEC1, TESTTIME_NSEC1, TESTTIME_NTPSEC1, TESTTIME_NTPFRAC1);
    RvPrintf("Time#2: Secs=%d NSecs=%d NTPSecs=%u NTPFrac=%08x\n", TESTTIME_SEC2, TESTTIME_NSEC2, TESTTIME_NTPSEC2, TESTTIME_NTPFRAC2);

    /* Start with time 2 since we're going to move it there */
    RvPrintf("RvNtpTimeConstruct Time#2: ");
    result1 = RvNtpTimeConstruct(&ntime1, TESTTIME_NTPSEC2, TESTTIME_NTPFRAC2);
    if(result1 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result1), RvNtpTimeGetFraction(result1));
    } else RvPrintf("NULL ERROR!\n");

    /* tests RvNtpTimeFractionToNsecs too */
    RvPrintf("RvNtpTimeToTime(RV_NTPTIME_ABSOLUTE) Time#2: ");
    tptr2 = RvNtpTimeToTime(&ntime1, &t2, RV_NTPTIME_ABSOLUTE);
    if(tptr2 != NULL) {
        RvPrintf("%d %d\n", RvTimeGetSecs(tptr2), RvTimeGetNsecs(tptr2));
    } else RvPrintf("NULL ERROR!\n");

    /* tests RvNtpTimeNsecsToFraction too */
    RvPrintf("RvNtpTimeContructFromTime(RV_NTPTIME_ABSOLUTE) Time#2: ");
    result2 = RvNtpTimeConstructFromTime(&ntime2, &t2, RV_NTPTIME_ABSOLUTE);
    if(result2 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result2), RvNtpTimeGetFraction(result2));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeSetSecs and RvNtpTimeSetFraction Time#1: ");
    RvNtpTimeSetSecs(&ntime1, TESTTIME_NTPSEC1);
    RvNtpTimeSetFraction(&ntime1, TESTTIME_NTPFRAC1);
    RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result1), RvNtpTimeGetFraction(result1));

    RvPrintf("RvNtpTimeSubtract Time#3 = Time#2 - Time#1: ");
    result3 = RvNtpTimeSubtract(&ntime3, &ntime2, &ntime1);
    if(result3 != NULL) {
        RvPrintf("%i %08x\n", RvNtpTimeGetSecs(result3), RvNtpTimeGetFraction(result3));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeToTime(RV_NTPTIME_RELATIVE) Time#3: ");
    tptr3 = RvNtpTimeToTime(&ntime3, &t3, RV_NTPTIME_RELATIVE);
    if(tptr3 != NULL) {
        RvPrintf("%d %d\n", RvTimeGetSecs(tptr3), RvTimeGetNsecs(tptr3));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeContructFromTime(RV_NTPTIME_RELATIVE) Time#4 = Time#3: ");
    result4 = RvNtpTimeConstructFromTime(&ntime4, &t3, RV_NTPTIME_RELATIVE);
    if(result4 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result4), RvNtpTimeGetFraction(result4));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeAdd Time#5 = Time#4 + Time#1 = Time#2: ");
    result5 = RvNtpTimeAdd(&ntime5, &ntime4, &ntime1);
    if(result5 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result5), RvNtpTimeGetFraction(result5));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeTo64(32, 32) Time#1: ");
    ntime64 = RvNtpTimeTo64(&ntime1, 32, 32);
    Rv64UtoHex(buf, ntime64);
    RvPrintf("%s\n",buf);

    RvPrintf("RvNtpTimeChop(32, 32) Time#1: ");
    result6 = RvNtpTimeChop(&ntime6, &ntime1, 32, 32);
    if(result6 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result6), RvNtpTimeGetFraction(result6));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeConstructFrom64(32) Time#6 = Time#1: ");
    result6 = RvNtpTimeConstructFrom64(&ntime6, ntime64, 32);
    if(result6 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result6), RvNtpTimeGetFraction(result6));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeTo64(32, 8) Time#6: ");
    ntime64 = RvNtpTimeTo64(&ntime6, 32, 8);
    Rv64UtoHex(buf, ntime64);
    RvPrintf("%s\n",buf);

    RvPrintf("RvNtpTimeChop(32, 8) Time#6: ");
    result7 = RvNtpTimeChop(&ntime7, &ntime6, 32, 8);
    if(result7 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result7), RvNtpTimeGetFraction(result7));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeTo64(16,16) Time#6: ");
    ntime64 = RvNtpTimeTo64(&ntime6, 16, 16);
    Rv64UtoHex(buf, ntime64);
    RvPrintf("%s\n",buf);

    RvPrintf("RvNtpTimeChop(16,16) Time#6: ");
    result7 = RvNtpTimeChop(&ntime7, &ntime6, 16, 16);
    if(result7 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result7), RvNtpTimeGetFraction(result7));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeTo64(16, 0) Time#6: ");
    ntime64 = RvNtpTimeTo64(&ntime6, 16, 0);
    Rv64UtoHex(buf, ntime64);
    RvPrintf("%s\n",buf);

    RvPrintf("RvNtpTimeChop(16, 0) Time#6: ");
    result7 = RvNtpTimeChop(&ntime7, &ntime6, 16, 0);
    if(result7 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result7), RvNtpTimeGetFraction(result7));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeTo64(0, 48) Time#6: ");
    ntime64 = RvNtpTimeTo64(&ntime6, 0, 48);
    Rv64UtoHex(buf, ntime64);
    RvPrintf("%s\n",buf);

    RvPrintf("RvNtpTimeChop(0, 48) Time#6: ");
    result7 = RvNtpTimeChop(&ntime7, &ntime6, 0, 48);
    if(result7 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result7), RvNtpTimeGetFraction(result7));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeTo64(64, 0) Time#6: ");
    ntime64 = RvNtpTimeTo64(&ntime6, 64, 0);
    Rv64UtoHex(buf, ntime64);
    RvPrintf("%s\n",buf);

    RvPrintf("RvNtpTimeChop(64, 0) Time#6: ");
    result7 = RvNtpTimeChop(&ntime7, &ntime6, 64, 0);
    if(result7 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result7), RvNtpTimeGetFraction(result7));
    } else RvPrintf("NULL ERROR!\n");

    RvPrintf("RvNtpTimeTo64(0, 64) Time#6: ");
    ntime64 = RvNtpTimeTo64(&ntime6, 0, 64);
    Rv64UtoHex(buf, ntime64);
    RvPrintf("%s\n",buf);

    RvPrintf("RvNtpTimeChop(0, 64) Time#6: ");
    result7 = RvNtpTimeChop(&ntime7, &ntime6, 0, 64);
    if(result7 != NULL) {
        RvPrintf("%u %08x\n", RvNtpTimeGetSecs(result7), RvNtpTimeGetFraction(result7));
    } else RvPrintf("NULL ERROR!\n");

}

#endif /* RV_TEST_CODE */