muxstuff.c

Go to the documentation of this file.

#include "muxstuff.h"

extern int debug;


byte sync_8[1] = 
{ 
  0x7E,
};

byte sync_16[2] = 
{
  0x4D,
  0xE1,
};

byte sync_2x16[4] = 
{
  0x4D,
  0xE1,
  0x4D,
  0xE1,
};

byte sync_24[3] = 
{
  0x82,
  0x4E,
  0xE7,
};

byte sync_32[4] = 
{
  0x17,
  0x8A,
  0xCE,
  0x98,
};


static int twotothe(int n)
{
  int r=1;
  while (n>0) {
    r *= 2;
    n--;
  }
  return (r);
}

int **make_mt_bytes(mux_table_entry *mt,
                    int mt_size,
                    int num_channels,
                    int info_bytes)
/*
 * MAKE SURE that the multiplex table used only has MED's that reference
 * existing channels.  Ie if it refers to LCN3 but there is no LCN3
 * --> error.
 */
{
  int **mt_bytes = (int **) malloc(mt_size * sizeof(int *));
  int i,j,k,n,repeating,towhere;

  if (mt_bytes != NULL) {
    for (i=0; i<mt_size; i++) {
      mt_bytes[i] = (int *) malloc(num_channels * sizeof(int));
      if (mt_bytes[i] != NULL) {
        /*
         * Figure out how many bytes get allocated to each channel 
         * per multiplex code.
         */
        for (j=0; j<num_channels; j++)
          mt_bytes[i][j]=0;
        
        repeating=!(mt[i].pattern->non_repeating_part_length);
        n=0;/* counter */
        for (k=0; k<info_bytes; k++) {
          if (!repeating) {
            towhere = mt[i].pattern->non_repeating_part[n++];
            if (towhere >= num_channels)
              error("make_mt_bytes","MUX table contains channels \
                     that are not used"); 
            if (n >= mt[i].pattern->non_repeating_part_length) {
              repeating = 1;
              n=0;
            }
          }
          else {
            towhere = mt[i].pattern->repeating_part[n++];
            if (towhere >= num_channels)
              error("make_mt_bytes","MUX table contains channels \
                     that are not used"); 
            if (n >= mt[i].pattern->repeating_part_length)
              n=0;
          }
          mt_bytes[i][towhere]++;
        }
      }
      else {
        error("make_mt_bytes", "malloc failed");
      }
    }
  }
  else {
    error("make_mt_bytes", "malloc failed");
  }
  return (mt_bytes);
}


float **make_mt_ratios(int **mt_bytes,
                       int mt_size,
                       int num_channels,
                       int info_bytes)
{
  float **mt_ratios = (float **) malloc(mt_size * sizeof(float *));
  int i, j;
 
  int *junkblock;
 
  if (mt_ratios != NULL) {
    /*
     * Go through entire multiplex table.
     */

  /*
  junkblock = (int *) malloc(sizeof(int)*200);
  printf(" junkblock %x ...............................\n",junkblock);
  */

 for (i=0; i<mt_size; i++) {
      mt_ratios[i] = (float *) malloc(num_channels * sizeof(float));
      if (mt_ratios[i] != NULL) {
        if (info_bytes)
          for (j=0; j<num_channels; j++)
            mt_ratios[i][j] = (float) mt_bytes[i][j] / info_bytes;
      }
      else {
        error("make_mt_ratios", "malloc failed");
      }
    }
  }
  else {
    error("make_mt_ratios", "malloc failed");
  }
  return (mt_ratios);
}


mux_parameters *new_mux_parameters(char *name)
     /* 
      * A function to query the parameters shared between a multiplexer and 
      * the corresponding demultiplexer.
      */
{
  mux_parameters *p;
  int x, y, n;
  char str[256];

  p = (mux_parameters *) malloc(sizeof(mux_parameters));
  if (p != NULL) {

    p->sync_flag_length = DEF_MUX_SYNC_FLAG;
    p->info_field_length = DEF_INFO_FIELD_LENGTH;
    p->sync_threshold = DEF_MUX_SYNC_THRESH;

    p->use_mpl = DEF_USE_MPL;
    p->header_code = DEF_HEADER_CODE;
    p->mpl_code = DEF_MPL_CODE;

    p->payload_min = DEF_PAYLOAD_MIN;
    p->payload_max = DEF_PAYLOAD_MAX;

    p->mux_table_size=0;
    p->mt_bytes=NULL;
    p->mt_ratios=NULL;
    
    for (x=0; x<MUX_TABLE_SIZE; x++) {
      p->mux_table[x].entry=NULL;
      p->mux_table[x].pattern=NULL;
    }
  }
  return (p);
}



static byte h223_headers[16] =
/*
 * not including pm bit (bit 0)
 * Bit 0 set to 0.  
 *
 * [ CRC | MC | PM ]
 *
 *  0: 0000 0000
 *  1: 1010 0010
 *  2: 1110 0100
 *  3: 0100 0110
 *  4: 0110 1000
 *  5: 1100 1010
 *  6: 1000 1100
 *  7: 0010 1110
 *  8: 1101 0000
 *  9: 0111 0010
 * 10: 0011 0100
 * 11: 1001 0110
 * 12: 1011 1000
 * 13: 0001 1010
 * 14: 0101 1100
 * 15: 1111 1110
 */
{
  0x00,   /*  0 */
  0xA2,   /*  1 */
  0xE4,   /*  2 */
  0x46,   /*  3 */
  0x68,   /*  4 */
  0xCA,   /*  5 */
  0x8C,   /*  6 */
  0x2E,   /*  7 */
  0xD0,   /*  8 */
  0x72,   /*  9 */
  0x34,   /* 10 */
  0x96,   /* 11 */
  0xB8,   /* 12 */
  0x1A,   /* 13 */
  0x5C,   /* 14 */
  0xFE,   /* 15 */
};


byte *construct_header(int mc, int pm, bch_type code, int level)
     /*
      * Constructs the header.  
      * NOTE: CRC is always 3 bits.  
      * MC is always 4 bits.
      * pm should be either 1 or 0, nothing else.
      *
      * compute crc field, add crc field to bits field
      * 
      * 
      * Bit fields look like this:
      *
      */
{
  static byte h[8];
  unsigned long bits=0;
  unsigned int crcBits=0;

  if (debug) {
    printf("construct_header() MC = %d, %PM = %d\n", mc, pm);
  }

  if (level==1) { /* level 0 will also come here */
    crcBits = lookup_crc(mc); 
    bits = (mc << 4) | (crcBits << 1) | pm;
    h[0] = bits;
  }
  else
    error("construct_header","invalid level");

  return (h);
}

byte *construct_header_level2(int mc, int pm, int mpl)
/*
 * constructs concatenated header with mc, pm and mpl protected
 * by golay code
 *
 * mc 4 bits
 * pm 1 bit
 * mpl 7 bits
 */
{
  static byte ret[4];
  long bits,encoded;
  
  bits = (mc&0xF);
  bits = bits << 1;
  bits = bits | pm&0x1;
  bits = bits << 7;
  bits = bits | (mpl&0x7F);

  encoded = encode_golay(bits);

  /* now, encoded should contain codeword in 24 lsb bits of encoded */ 
  ret[0] = ((encoded >> 16)&0x000000FF);
  ret[1] = ((encoded >> 8)&0x000000FF);
  ret[2] = (encoded&0x000000FF);
  return ret;
}


int deconstruct_header(byte *header,int *mc,int *pm,bch_type code,int level)
     /*
      * Deconstructs the header, check crc for level 1.
      * returns 1 if crc checks valid, 0 if not  
      *
      */
{
  unsigned long hbits=0;
  unsigned int recdCrcBits=0;
  int returnval;

  if (level == 1) { /* 0 will also come here */
    decode_bch(&hbits, header, code, 1);
    *pm = (hbits & 1);
    recdCrcBits = (hbits >> 1) & 0x07;
    *mc = (hbits >> 4) & 0x0F;

    if (recdCrcBits == lookup_crc(*mc))
      returnval = 1;
    else
      returnval = 0;
  }
  
  if (debug) {
    printf("deconstruct_header() MC = %d, PM = %d, CRC = %d\n",*mc,*pm,returnval);
  }

  return returnval;
}

void deconstruct_header_level2(byte *header,int *mc,int *pm,int *mpl)
/* 
 * deconstructs the level 2 header, described above in construct_header
 * sets mc, pm and mpl to received value
 */
{
  long codeword,decoded;

  /* form long out of byte array style header for golay decoding.  mask
     out MSB because only 23 bit code, not 24 bit code */
  codeword = ((header[0] & 0x7F)<<16) | header[1]<<8 | header[2];

  decoded = decode_golay(codeword);
  
  *mc = (decoded>>8) & 0xF; 
  *pm = (decoded>>7) & 0x1;
  *mpl = decoded & 0x7F;
  if (debug)
    printf("deconstruct_header() MC = %d, PM = %d, MPL = %d\n",*mc,*pm,*mpl);
}

byte *construct_mpl(int mpl, bch_type code)
{
  static byte mplf[8];
  unsigned long bits=0;

  bits = mpl;
  
  if (debug) {
    printf("construct_mpl() MPL = %d\n", mpl);
  }
  
  encode_bch(bits, mplf, code);
  
  return (mplf);
}

int deconstruct_mpl(byte *mplf, int *mpl, bch_type code)
     /* 
      * returns status of detection (0 if errors detected, 1 if not) 
      * at this point, only will return 1 because using for correction
      */
{
  unsigned long bits=0;
  int status;

  status = decode_bch(&bits, mplf, code, 1);
  *mpl = bits;

  if (debug) {
    printf("deconstruct_mpl() MPL = %d\n", *mpl);
  }

  return status;
}

void swapbits(bytes *b, int a1, int a2)
     /*
      * Swaps two bits.
      */
{
  byte x = get_byte(b, (a1 / 8));
  byte y = get_byte(b, (a2 / 8));
  byte tmp = x;
  if (y & (1 << (a2 % 8))) {
    x |= (1 << (a1 % 8));
  }
  else {
    x &= ~(1 << (a1 % 8));
  }
  if (tmp & (1 << (a1 % 8))) {
    y |= (1 << (a2 % 8));
  }
  else {
    y &= ~(1 << (a2 % 8));
  }
  set_byte(b, (a1 / 8), x);
  set_byte(b, (a2 / 8), y);
}


void swapbytes(bytes *b, int a1, int a2)
     /*
      * Swaps bytes at a1 and a2 of (b).
      */
{
  byte x1, x2;
  x1 = get_byte(b, a1);
  x2 = get_byte(b, a2);
  set_byte(b, a1, x2);
  set_byte(b, a2, x1);
}


void interleave_header(bytes *mux_pdu, int sync_bytes, 
                              int header_bytes, int mode)
/*
 * Performs interleaving of the header throughout the area taken up by 
 * the header and the information field of the MUX-PDU.
 * 
 * Swaps bits or bytes around since that is the simplest way of doing it.
 */
{
  int i, j;
  int field_length = num_bytes(mux_pdu) - sync_bytes;

  if (mode == BIT_INTERLEAVING) {
    for (i = header_bytes * 8 - 1; i > 0; i--) {
      j = field_length * 8 / i;
      swapbits(mux_pdu, i, j);
    }    
  }
  else if (mode == BYTE_INTERLEAVING) {
    for (i = header_bytes - 1; i > 0; i--) {
      j = field_length / i;
      swapbytes(mux_pdu, i, j);
    }
  }
}


int mux_byte_source(mux_table_entry *mte, int x)
/*
 * Returns the channel that octet x of the information field of a packet
 * multiplexed with mux table entry *(mte) should come from or should 
 * return to.
 */
{
  int source;
  
  if (x < mte->pattern->non_repeating_part_length) {
    source = mte->pattern->non_repeating_part[x];
  }
  else {
    x -= mte->pattern->non_repeating_part_length;
    x %= mte->pattern->repeating_part_length;
    source = mte->pattern->repeating_part[x];
  }
  return(source);
}

---