al_sending.c

Go to the documentation of this file.

#include "standard.h"
#include "al_sending.h"
#include "arq.h"
#include "Buffer.h"
#include "rcpc.h"
#include "error.h"
#include "bits.h"
#include "bytes.h"
#include "bch.h"
#include "uep_rcpcc.h"

extern int debug;

int al_send_request(al_sending_entity *which, bytes *al_sdu)
     /*
      * Called by an AL user to send an SDU through a logical channel.  Data
      * is put into the al_sending_entity buffer and will be made into an AL_PDU
      * and sent when an AL_PDU is requested by the MUX.  Note: the pdu does
      * not make it to the remote end in a whole format, ie. the size of it
      * may change.
      *
      * Returns 1 if succesful, 0 if unsuccesful (ie. buffer full)
      */
{
  int i;
  byte b;
  
  /* 
   * check to make sure there's sufficient room in buffer for
   * incoming SDU.  If not, fail. 
   */
  if ((bsize(which->al_sdus)) < num_bytes(al_sdu) + blevel(which->al_sdus))
    return 0;
  
  /* otherwise put the bytes into the buffer and now free it */
  for (i=0;i<num_bytes(al_sdu);i++) {
    b=get_byte(al_sdu,i);
    bwrite(which->al_sdus,&b);
  }
  
  return 1;
}

int al_send_byte(al_sending_entity *which, unsigned char b)
     /* 
      * Sends a single byte to an al-sending entity's incoming data buffer.
      */
{
  if (bsize(which->al_sdus) < (1+blevel(which->al_sdus)))
    return (0);
  
  bwrite(which->al_sdus, &b);
  return (1);
}

int al_request(al_sending_entity *which)
     /*
      * This function is called by the MUX to see if an al_sending_entity
      * has data which needs to be sent.  
      *
      * Return values:
      * 
      * 0     When the al_sending_entity has nothing to send.
      * -1    There is an ARQ waiting to be requested.
      * 1     New data available (no ARQ). 
      */
{
  int val;
  if (blevel(which->forward_arq))
    val = -1;
  else if (blevel(which->al_sdus))
    val = 1;
  else
    val = 0;
  return val;
}

int al_requested_size(al_sending_entity *which)
     /*
      * This function is called by the MUX to see how big an ARQ packet needs
      * to be sent.  It returns the AL-PDU length needed for the ARQ, or 0 if
      * there are no forward ARQ's.
      */
{
  int i,val=0;
  buf_rcpc* grossie;
  arq_message* jon;
  
  if (blevel(which->forward_arq)) {
    /*
     * return size of al_pdu at top of buffer (plus forward/backward control)
     * Check all buf_rcpc's in rcpcs buffer and see which one's sequence 
     * number matches the sequence number of the arq message on top of the
     * forward_arq buffer
     */
    
    if ((jon = bpeek(which->forward_arq,0)) == NULL) {
      printf("al_requested_size() - ERROR forward arq buffer has entries that");
      printf(" can't be read!\n");
    }
    
    for(i=0;i<blevel(which->rcpcs);i++) {
      grossie = (buf_rcpc *) bpeek(which->rcpcs,i);
      if (grossie->sequence_number == jon->sequence_number) {
        val = grossie->length;
        break;
      }
    }

    /* add on for control fields */
    val += 4; /* for forward control */
    if (blevel(which->backward_arq))
      val+=4;
    if (i == blevel(which->rcpcs)) {
      printf("al_requested_size() - ERROR trying to send arq for sequence");
      printf(" number not in rcpcs buffer\n"); 
    }
  }
  else
    val = 0;
 
  return val;
}

int al_buffer_level(al_sending_entity *which)
     /*
      * This function is called by the MUX to see how much NEW data this channel
      * has waiting to send so that it can devise an appropriate multiplex 
      * code that assigns a block of data to the channel associated with this
      * al_sending_entity.
      *
      * Also can be called by the al-user (sender) to perform rate control.
      * The H.263 encoder does this to control its frame rate. 
      */
{
  return blevel(which->al_sdus);  /* returns number of BYTEs in buffer */
}


void al_arq_request(al_sending_entity *which, arq_message *clone)
     /*
      * This function is called by the corresponding al_receiving entity
      * when it wants to request a retransmission of a particular AL_SDU
      * 
      */
{
  bwrite(which->backward_arq,clone);
}

void al_arq_received(al_sending_entity *which, arq_message *clone)
     /*
      * This function is called by the corresponding al_receiving entity
      * when it wants to report that a retransmission request has been
      * received.  The al_sending_entity saves the incoming arq_message
      *   
      */
{
  bwrite(which->forward_arq,clone);  
}


al_sending_entity *new_al_sending_entity( channel_info *nfo)
     /*
      * Makes a new AL-Sending Entity.  Is passed a struct of channel parameters.
      */

{ 
  al_sending_entity *new_al;
  
  new_al = (al_sending_entity *) malloc(sizeof(al_sending_entity));
  /*  printf("New al sending entity has address %x\n",new_al); */
  if (new_al == NULL) {
    error("new_al_sending_entity","can't malloc al_sending entity");
  }
  else {
    new_al->al_sdus = mkbuffer(MAX_AL_BUFFER_SIZE,sizeof(byte));
    new_al->rcpcs = mkbuffer(32,sizeof(buf_rcpc));
    new_al->forward_arq = mkbuffer(MAX_ARQ_BUFFER_SIZE,sizeof(arq_message));
    new_al->backward_arq = mkbuffer(MAX_ARQ_BUFFER_SIZE,sizeof(arq_message));
    new_al->vs = 0;

    /* Copy parameters from channel_info *nfo */
    new_al->type = nfo->type;
    new_al->framed = nfo->framed;
    new_al->seq_num = nfo->seq_num;
    new_al->rcpc_code = nfo->rcpc_code;
    new_al->rcpc_rate = nfo->rcpc_rate;
    new_al->arq_type = nfo->arq_type;
    new_al->crc_bytes = nfo->crc_bytes;
  }
  return new_al;
}

void make_forward_control(bytes *forward_control,unsigned int snf, 
                          unsigned int pt,unsigned int rn)
     /*
      * Makes a (31,11) BCH encoded forward control field with:
      *   sequence number forward snf,
      *   payload type pt,
      *   retransmission number rn,
      *  and determines CRCf field.
      *
      * Returns in forward_control (which will be a pointer to a bytes structure 
      * of length 4.  It should just be an empty bytes pointer when passed in) 
      *
      * (only used in old H.223/Annex A)
      */
{
  int i;
  unsigned int *field;
  byte crc;
  
  field = (unsigned int *) malloc(sizeof(unsigned int));
  *field = 0;

    if (field == NULL) error("make_forward_control","can't allocate field");
  /* set the snf part of field */
  for(i=6;i<=10;i++)
    setbitint(field,i,getbitint(snf,i+6));
  
  /* set the pt part of field */
  setbitint(field,11,pt);
  
  /* set the rn part of field */
  setbitint(field,12,rn);
  
  /* figure out 4 bit CRC and append here */
  crc = makecrc4(*field);
  *field = *field | crc;
  
  /* perform (31,11) BCH on it */
  encode_bch(*field,forward_control->block,2);
  free(field);
}

void make_backward_control(bytes* backward_control,unsigned int snb,
                           unsigned int sm)
     /*
      * Makes a (31,11) BCH encoded backward control field with:
      *   sequence number backward snb,
      *   supervisory message sm,
      *  and determines CRCb field.
      *
      * Returns in backward_control (which should be a pointer to an empty 
      * bytes structure (ie not initialized))
      *
      * (only used in old H.223/Annex A)
      */
{
  int i;
  unsigned int *field;
  byte *block;
  byte crc;
  
  field = (unsigned int *) malloc(sizeof(unsigned int));
  *field = 0;
  if (field == NULL)
    error("make_backward_control","can't malloc field");
  block = (byte *) calloc(4, sizeof(byte));
  if (field == NULL)
    error("make_backward_control","can't malloc block");
  
  /* set snb part of field */
  for(i=6;i<=10;i++)
    setbitint(field,i,getbitint(snb,i+6));
  
  /* set sm part of field */
  for(i=11;i<=12;i++)
    setbitint(field,i,getbitint(sm,i+4));
  
  /* figure out 4 bit CRC and append here */
  crc = makecrc4(*field);
  printf("al_sending field %x crc %x\n",*field,crc);
  *field = *field | crc;
  printf("al_sending resulting field %x\n",*field);
  
  /* perform (31,11) BCH on it */
  encode_bch(*field,block,2);
  backward_control->block = block;
  backward_control->length = 4;
  free(field);
}


int inc_sn(al_sending_entity *which)
     /*
      * returns the current sequence number available from which, and
      * then increments it.
      */
{
  int returnval = which->vs;
  which->vs = (which->vs + 1) % 32;
  return returnval;
}


bytes *get_al_pdu(al_sending_entity *which, int size)
     /*   
      * Constructs an AL-PDU of total size size (including headers, 
      * FEC, CRC if appropriate).
      * 
      * If there is a forward retransmission request to send (and the size 
      * compatible) it shall send it.
      * If there is a backward_arq message for one or more AL sending entities, 
      * it shall include a backward control field.
      * (old h.223/a only)
      *
      */  
{
  int i;
  bytes *al_pdu=NULL;
  byte b;
  byte crc8val = 0;
  unsigned short crc16val = 0; 

  al_pdu = new_bytes(size);
  
  if (which->type == AL1) {
    /* no crc */
    for(i=0; i<size;i++) {
      bread(which->al_sdus, &b);
      set_byte(al_pdu, i, b);
    }
  }
  else if (which->type == AL2) {
    /* add a one byte crc */
    for(i=0; i<size-1;i++) {
      bread(which->al_sdus, &b);
      crc8(&crc8val,b);
      set_byte(al_pdu, i, b);
    }
    set_byte(al_pdu, size - 1, crc8val);
  }
  else if (which->type == AL3) {
    /* add a two byte crc */
    for(i=0; i<size-2;i++) {
      bread(which->al_sdus, &b);
      crc16(&crc16val,b);
      set_byte(al_pdu, i, b);
    }
    set_byte(al_pdu, size - 2, (byte) (crc16val >> 8));
    set_byte(al_pdu, size - 1, (byte) crc16val & 0x00FF);
  }

  return al_pdu;
}

---