Exemplo n.º 1
0
int seed_fsdh(struct seed_fsdh *dest, char *src)
{
int swap;
char tbuff[10];

    assert(sizeof(short) == 2);
    assert(sizeof(long)  == 4);

    sscanf(src, "%06dD             ", &dest->seqno);

    memcpy(dest->staid, src+ 8, 5); dest->staid[5] = 0;
    util_strtrm(dest->staid);
    memcpy(dest->locid, src+13, 2); dest->locid[2] = 0;
    util_strtrm(dest->locid);
    memcpy(dest->chnid, src+15, 3); dest->chnid[3] = 0;
    util_strtrm(dest->chnid);
    memcpy(dest->netid, src+18, 2); dest->netid[2] = 0;
    util_strtrm(dest->netid);

    dest->start = seed_ttodt(src+20, &dest->order);
    memcpy(&dest->nsamp,  src+30, 2);
    memcpy(&dest->srfact, src+32, 2);
    memcpy(&dest->srmult, src+34, 2);
    memcpy(&dest->active, src+36, 1);
    memcpy(&dest->ioclck, src+37, 1);
    memcpy(&dest->qual,   src+38, 1);
    memcpy(&dest->more,   src+39, 1);
    memcpy(&dest->tcorr,  src+40, 4);
    memcpy(&dest->bod,    src+44, 2);
    memcpy(&dest->first,  src+46, 2);

    if (dest->swap = (dest->order != util_order())) {
        util_sswap(&dest->nsamp,  1);
        util_sswap(&dest->srfact, 1);
        util_sswap(&dest->srmult, 1);
        util_lswap(&dest->tcorr,  1);
        util_sswap(&dest->bod,    1);
        util_sswap(&dest->first,  1);
    }

    return 0;
}
Exemplo n.º 2
0
BOOL reftek_sc(struct reftek_sc *dest, UINT8 *src)
{
REAL32 value, factor;
CHAR temp[16], *token[2];
UINT8 *off, *ptr;
UINT16 i, ndx;
INT32 ntoken;

/* Load the common header */

    reftek_com(src, &dest->exp, &dest->unit, &dest->seqno, &dest->tstamp);

/* Load the record specific parts */

    dest->nchan = 0;
    for (i = 0; i < 5; i++) {
        off = src + 202 + (i * 146);

        ptr = off + 0;
        memcpy((void *) temp, (void *) ptr, (size_t) 2);
        temp[2] = 0;
        util_strtrm(temp);
        if (strlen(temp) > 0) {
            ndx = dest->nchan;
            dest->chan[ndx].num = atoi(temp);

            ptr = off + 2;
            strncpy((char *) dest->chan[ndx].name, (char *) ptr, 10);
            dest->chan[ndx].name[10] = 0;
            util_strtrm(dest->chan[ndx].name);

            ptr = off + 70;
            strncpy((char *) temp, (char *) ptr, 4);
            temp[4] = 0;
            util_strtrm(temp);
            dest->chan[ndx].gain = (REAL32) atof(temp);

            ptr = off + 74;
            strncpy((char *) dest->chan[ndx].model, (char *) ptr, 12);
            dest->chan[ndx].model[12] = 0;
            util_strtrm(dest->chan[ndx].model);

            ptr = off + 86;
            strncpy((char *) dest->chan[ndx].sn, (char *) ptr, 12);
            dest->chan[ndx].sn[12] = 0;
            util_strtrm(dest->chan[ndx].sn);

            ptr = off + 138;
            strncpy((char *) temp, (char *) ptr, 8);
            temp[8] = 0;
            util_strtrm(temp);
            ntoken = util_parse(temp, token, " ", 2, 0);
            if (ntoken == 2) {
                value = (REAL32) atof(token[0]);
                if (strcasecmp(token[1], "mV") == 0) {
                    factor = 1000.0 * 65536.0;
                } else if (strcasecmp(token[1], "uV") == 0) {
                    factor = 1000000.0 * 65536.0;
                } else if (strcasecmp(token[1], "V") == 0) {
                    factor = 1.0 * 65536.0;
                } else {
                    factor = 1.0;
                    value  = -12345.0;
                }
            } else {
                factor = 1.0;
                value  = -12345.0;
            }
            dest->chan[ndx].scale = value / factor;

            ++dest->nchan;
        }
    }

    return TRUE;

}