byte_rel_comp.cpp

Go to the documentation of this file.

/*
C
C Compression of 32bit integer data into byte-relative format
C
C Each integer is stored relative to the previous value in byte form.The first
C is relative to zero. This allows for numbers to be within + or - 127 of
C the previous value. Where a 32bit integer cannot be expressed in this way a 
C special byte code is used (-128) and the full 32bit integer stored elsewhere.
C The final space used is (NIN-1)/4 +1 + NEXTRA longwords, where NEXTRA is the
C number of extra longwords used in giving absolute values.
C
*/
#include "stdafx.h"
#include "DAEstatus.h"
#include "isisvme_types.h"
#include "byte_rel_comp.h"

#define LARGE_NUMBER    1073741824

int byte_rel_comp(int* data_in, int n_in, char* data_out, int max_out, int& n_out, DAEstatus& status)
{
        int i, icurrent, irel;
    union
        {
                int i;
                char c[4];
        } byte_pack;
        if (n_in <= 0)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "byte rel comp error: nin <= 0");
                return DAEstatus::Failure;
        }
        if (max_out <= n_in)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "byte rel comp error: nin <= 0");
                return DAEstatus::Failure;
        }
    n_out = 0;
        icurrent = 0;
        for(i=0; i<n_in; i++)
        {

// Trap out ridiculously large numbers. They could cause problems in subtraction,
// so force them to be stored absolutely
                if ( (data_in[i] > LARGE_NUMBER) || (data_in[i] < -LARGE_NUMBER) || (icurrent > LARGE_NUMBER) || (icurrent < -LARGE_NUMBER) ) 
                {
                        irel = 128;    // Force absolute mode
                }
                else
                {
                        irel = data_in[i] - icurrent;  // Calc relative offset
                }
// If small put it in a byte
                if ( (irel <= 127) && (irel >= -127) )
                {
                        if (n_out >= max_out){
                                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "byte rel comp error: n_out >= max_out");
                                return DAEstatus::Failure;
                        }
                        data_out[n_out] = static_cast<char>(irel); // Pack relative byte
                        n_out++;
                }
                else
                {
// Otherwise put marker in byte followed by packed 32bit integer
                    if ((n_out + 5) >= max_out)
                        {
                                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "byte rel comp error: n_out + 5 >= max_out");
                                return DAEstatus::Failure;
                        }
                        data_out[n_out] = -128; // pack marker
                        byte_pack.i = data_in[i];
                        data_out[n_out+1] = byte_pack.c[0];
                        data_out[n_out+2] = byte_pack.c[1];
                        data_out[n_out+3] = byte_pack.c[2];
                        data_out[n_out+4] = byte_pack.c[3];
                        n_out += 5;
                }
                icurrent = data_in[i];
        }
        return DAEstatus::Success;
}

/*
C
C Expansion of byte-relative format into 32bit format
C
C Each integer is stored relative to the previous value in byte form.The first
C is relative to zero. This allows for numbers to be within + or - 127 of
C the previous value. Where a 32bit integer cannot be expressed in this way a 
C special byte code is used (-128) and the full 32bit integer stored elsewhere.
C The final space used is (NIN-1)/4 +1 + NEXTRA longwords, where NEXTRA is the
C number of extra longwords used in giving absolute values.
C
C
C Type definitions
C   Passed parameters
        INTEGER NIN
        BYTE    INDATA(NIN)     
C                               Array of NIN compressed bytes
        INTEGER NFROM           
C                               pass back data from this 32bit word onwards
C
        INTEGER NOUT            
C                               Number of 32bit words expected
        INTEGER OUTDATA(NOUT)   
C                               outgoing expanded data
        INTEGER ISTATUS         
C                               Status return
C                                      =1  no problems!
C                                      =3  NOUT .lt.NIN/5
C                                      =2  NIN .le.0
C                                      =4  NOUT .gt.NIN
C                                      =6  number of channels lt NOUT
*/
//n_from is zero based
int byte_rel_expn(char* data_in, int n_in, int n_from, int* data_out, int n_out, DAEstatus& status)
{
        int i, j;
    union
        {
                int i;
                char c[4];
        } byte_pack;
// First check no slip-ups in the input parameters
        if (n_in <= 0)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "byte rel comp error: nin <= 0");
                return DAEstatus::Failure;
        }
        if (n_out + n_from  > n_in)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "byte rel comp error: nin <= 0");
                return DAEstatus::Failure;
        }
// Set initial absolute value to zero and channel counter to zero
        byte_pack.i = 0;
        j = 0;
// Loop over all expected 32bit integers
        for(i=0; i< n_from + n_out; i++)
        {
                if (j >= n_in)
                {
                        status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "byte rel comp error: nin <= 0");
                        return DAEstatus::Failure;
                }
// if number is contained in a byte
                if (data_in[j] != -128)
                {
// add in offset to base
                        byte_pack.i += data_in[j];
                        j++;
                }
                else
                {
// Else skip marker and pick up new absolute value
// check there are enough bytes
                        if (j+4 >= n_in)
                        {
                                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "byte rel comp error: nin <= 0");
                                return DAEstatus::Failure;
                        }
// unpack 4 bytes
                        byte_pack.c[0] = data_in[j+1];
                        byte_pack.c[1] = data_in[j+2];
                        byte_pack.c[2] = data_in[j+3];
                        byte_pack.c[3] = data_in[j+4];
//              CALL VAX_TO_LOCAL_INTS(ITEMP, 1)
                        j += 5;
                }
// update current value
                if (i >= n_from)
                {
                        data_out[i-n_from] = byte_pack.i;
                }
        }

// expansion OK, but excessive number of bytes given to the routine
        if (n_out < n_in / 5)
        {
                status.addInfo(FAC_DAE, "byte rel expn: excessive bytes");
        }
        return DAEstatus::Success;
}