demux.c

Go to the documentation of this file.

#include "standard.h"
#include "mux.h"
#include "demux.h"
#include "crc3.h"
#include "muxstuff.h"

extern int debug;
extern byte sync_8[1];
extern byte sync_16[2];
extern byte sync_2x16[4];
extern byte sync_24[3];
extern byte sync_32[4];


/* 
 * The DEMUX will do something positive.  
 * 
 */

demux *new_demux(char *name)
{
  int i;
  demux *bob;

  bob = malloc(sizeof(demux));
  if (bob != NULL) {
    bob->num_al_receivers = 0;
    strcpy(bob->name, name);

    for (i=0; i<8; i++) {
      bob->header_reg[i]=0;
      bob->sync_reg[i]=0;
      bob->mpl_reg[i]=0;
    }
    bob->THRESH=0;
    bob->MC=-1;
    bob->PM=-1;
    bob->MPL=-1;
    bob->in_sync=0;
    bob->sync_delay=0;
    bob->goodPackets=0;
    bob->badPackets=0;
    bob->mpl_counter=0;
  }
  return (bob);
}

void close_demux(demux *d)
{
  FILE *outf;
  printf("%s: %d Good CRC Packets (y1), %d Failed CRC Packets , %d bad MPLs\n",
          d->name, d->goodPackets, d->badPackets, d->bad_mpls);
  if (*d->params->stat_file!=0) {
    outf = fopen(d->params->stat_file,"a");
    assert(outf!=NULL);
    fprintf(outf,"%s: %d Good Packets, %d Bad Packets, %d bad MPLs\n",d->name,
          d->goodPackets, d->badPackets, d->bad_mpls);
    fclose(outf);
  }
  free (d);
}


static int correlation(byte a, byte b)
     /*
      * returns the number of bits the same in a and b.
      */
{
  int r=0;
  int i;

  for (i=0; i<8; i++) {
    if ((a & (1 << i)) == (b & (1 << i)))
      r++;
  }
  return r;
}


byte shift_in(demux *d, byte b)
{
  byte tmpA, tmpB;
  int i;
  byte *sync_std=NULL;
  int sync_bytes=((d->params->sync_flag_length)/8);
  int header_bytes=((code_length(d->params->header_code)+1)/8);
  int mpl_bytes=((code_length(d->params->mpl_code)+1)/8);

  /* 
   * Shift in new byte b.  Return byte shifted out. 
   *
   * it will calculate the threshold each time.  if mpl is
   * used, it doesn't need to, this can be improved
   */

  tmpB = b;

  if (d->params->use_mpl) {
    for (i=mpl_bytes-1; i>=0; i--) {
      tmpA = d->mpl_reg[i];
      d->mpl_reg[i] = tmpB;
      tmpB = tmpA;
    }
  }
  for (i=header_bytes-1; i>=0; i--) {
    tmpA = d->header_reg[i];
    d->header_reg[i] = tmpB;
    tmpB = tmpA;
  }
  for (i=sync_bytes-1; i>=0; i--) {
    tmpA = d->sync_reg[i];
    d->sync_reg[i] = tmpB;
    tmpB = tmpA;
  }
  /*
   * Get new values for THRESH, MC, PM, MPL
   */

  d->THRESH=0;

  switch(sync_bytes){
    case 1: sync_std = sync_8;  break;
    case 2: sync_std = sync_16; break;
    case 3: sync_std = sync_24; break;
    case 4: sync_std = sync_32; break;
  }

  /* if level 2 double flag mode.. */
  if (d->params->use_double_flag)
    sync_std = sync_2x16;

  for (i=0; i<sync_bytes; i++) {
    d->THRESH += correlation(d->sync_reg[i], sync_std[i]);
  }

  return tmpB;
}



void demultiplex(demux *d)
     /*
      * This is kind of the opposite of multiplex().
      */
{
  int i, j, mplok;
  int towhere;
  byte b;
  int sync_bytes=((d->params->sync_flag_length)/8);
  int header_bytes=((code_length(d->params->header_code)+1)/8);
  int mpl_bytes=((code_length(d->params->mpl_code)+1)/8);

  int delay_bytes = sync_bytes + header_bytes;

  int check = 0;

  if (d->params->use_mpl) {
    delay_bytes += mpl_bytes;
  }

#define MT (d->params->mux_table)
#define AL (d->al_receivers)

  if (!channel_read_indication(d->input)) {
    if (debug)
      printf("%s DEMUX [%s] Nothing to read yet.\n", print_time(), d->name);
  }

  while (channel_read_indication(d->input)) {

    if (debug)
      printf("%s DEMUX [%s] reading data.\n", print_time(), d->name);
    /*
     * get new byte.
     */
    b = channel_read(d->input);

    d->mpl_counter--;

    /*
     * shift in new byte, get out old byte.  
     */
    b = shift_in(d, b);
   
    /*
     * process incoming data 
     */

    if (d->sync_delay) {
      d->sync_delay --;
      if (debug) {
        printf("%s DEMUX [%s] Delay... delay remaining = %d\n",
                 print_time(), d->name, d->sync_delay);
      }
    }
    else {
      if (d->in_sync) {
          towhere = mux_byte_source(&MT[d->MC], d->byte_count);
         
          if (debug) {
            printf("%s DEMUX [%s] Sending byte %d to LCN%d\n", print_time(), 
                    d->name, d->byte_count, towhere);
          }
          
          send_to_al(AL[towhere], b);

          d->byte_count++;
      }
    }
     
    /* 
     * if we've found a sync flag (and mpl counter < 0), do some stuff.  
     */
    if ((d->THRESH >= d->params->sync_threshold) && (d->mpl_counter < 0)) {
      /* found a syncflag.  */
      if (debug) {
        printf("%s DEMUX [%s] Got SYNC.  correlation=%d\n", print_time(), d->name, d->THRESH);
      }
      
      /*
       * send closing flag message to AL's
       */
      
      for (i=0;i<d->num_al_receivers;i++)
        send_closing_flag(AL[i]);

      /* 
       * found sync flag.  set MC, PM, and MPL.  :-)
       */
      
      if (d->params->level==2) {
        deconstruct_header_level2(d->header_reg, &d->MC, &d->PM, &d->MPL);
          if (debug)
            printf("%s DEMUX [%s] MC = %d, MPL = %d\n", print_time(), d->name, 
                    d->MC, d->MPL);
          d->goodPackets++;
          check = 1;
      }
      else {
        check = deconstruct_header(d->header_reg, &d->MC, &d->PM, 
                                   d->params->header_code, d->params->level);

        if (check) {
          if (debug)
            printf("%s DEMUX [%s] MC = %d, PM = %d\n", print_time(), d->name, 
                    d->MC, d->PM);
          d->goodPackets++;
        }
        else {
          if (debug) printf("%s DEMUX [%s] Bad Hdr Recd\n", print_time(), d->name);
          d->badPackets++;
        }
      }

      /* reset received bytes */
      d->byte_count=0;
      
      d->in_sync=1;
      
      /*
       * Do some testing of MC
       */
      if (d->MC < 0 || d->MC >= MUX_TABLE_SIZE || !check) {
        if (debug)
          printf("%s DEMUX [%s] Receiving invalid MC.\n",print_time(), d->name);
        d->in_sync=0;
        d->MC=-1;
      }
      if (d->params->mux_table[d->MC].pattern == NULL) {
        if (debug)
          printf("%s DEMUX [%s] Receiving invalid MC.\n",print_time(), d->name);
        d->in_sync=0;
        d->MC=-1;
      }

      if (d->params->use_mpl && d->params->level!=2) {
        mplok = deconstruct_mpl(d->mpl_reg, &d->MPL, d->params->mpl_code);
        if (debug)  {
          if (mplok) {
            printf("%s DEMUX [%s] Receiving MPL %d\n", print_time(), 
                    d->name,d->MPL);
          }
          else {
            printf("%s DEMUX [%s] Receiving bad MPL, ignoring\n", print_time(), 
                    d->name);
            d->bad_mpls++;
          }
        }
        if (mplok) {
          d->mpl_counter = d->MPL;
        }
      }

      /*
       * set sync_delay.  sync_delay is the number of bytes in flag+header, 
       * which need to be read out of the buffer before you start reading data.
       */
      d->sync_delay = delay_bytes;
    }
  }
}

---