med.h

Go to the documentation of this file.

/* MED.H */ 

#ifndef _MED_H_
#define _MED_H_

/*
 * A med is a list of med elements.
 * 
 * A med element.  Can be either an MedAtom or a MedList. 
 *
 * If the element is an MedAtom, it will be a channel number repeated x times.
 *
 * If the element is a MedList, it will be a list that is repeated x times.
 */

#define UCF  -1
#define MAX_MUX_TABLE_SIZE 16

typedef struct _med { 

  enum { MedAtom, MedList } type;

  int ch;                       /* A channel number.  Used iff type = MedAtom */
  struct _med *list;            /* A list of MEDs.  Used iff type = MedList */

  int rc;                       /* Number of times to repeat.  -1 means UCF */
  struct _med *next;

} med;


typedef struct {
  /*
   * The pattern of bytes which a MultiplexEntryDescriptor defines.  
   * With every MED, there is a non-repeating part and a repeating part.  
   * The non-repeating part comes first.  It is followed by the repeating 
   * part.
   */
  int *non_repeating_part;
  int non_repeating_part_length;
  int *repeating_part;
  int repeating_part_length;

} med_pattern;


typedef struct {
  /* 
   * Information stored in the MUX table.
   */
  med *entry;
  med_pattern *pattern;
  
} mux_table_entry;

/* Function Prototypes */

int prefix (char *s1, char *s2);
/*
 * Returns 1 iff s1 is a prefix of s2.
 */

static void upstring(char *s);
/*
 * Converts a string to upper case.  Assumes ASCII.
 */

static void stripwhitespace(char *s);
/*
 * This function does exactly what it says it does.
 */

static int balanced(char *s);
/*
 * Returns 1 iff the sequence of {'s and }'s in *s forms a DYCK word.
 */

static int atom(char *s);
/*
 * Returns 1 iff prefix(s) is an atom (i.e. one { followed by one }).
 */

static char *advance_past_comma(char *s);
/*
 * Advances to just past the next comma, ignoring stuff in nested {}'s.
 */

static med *new_med(void);
/*
 * mallocs a new med structure
 */

static void check_med1(med *m);
/*
 * helper for the next function
 */

static void check_med(med *m);
/*
 * Checks multiplex entry for multiple RC UCF's or an RC UCF 
 *   in a nested sub-expression.
 * Most of the code is in check_med1();
 */

static med *parse_med1(char *s);
/*
 * helper function for function below
 */

static med *parse_med(char *s);
/*
 * Returns a med structure from a string (i.e., a pointer to the start
 *   of a MED list).  String is expected to have been removed of whitespace
 *   and converted to uppercase.
 *
 * This is the toplevel function.
 *   The top layer is different, since we can have stuff like:
 *   {...},{...}
 */

static void print_med(med *m);
/*
 * Prints out the med pointed to by m.
 *
 * Is recursive (i.e. See print_med(med *m)).
 */

static void print_sample(med *m);
/*
 * Prints out a sample of what output the code will produce.
 *
 * Ex.  {{LCN1,RC5},{LCN2,RC2},RC UCF} will produce:
 *
 * 1111122 repeat until closing flag
 */

static int figure_length1(med *m);
/*
 * Helper function for function below
 */
static int figure_length(med *m);
/*
 * Figure out the length of a pattern a med produces.
 * Do not follow (*next) pointers of (*m).
 */

static void write_pattern1(int *pattern, int *offset, med *m);
/*
 * Helper function for function below
 */

static void write_pattern(int *pattern, int *offset, med *m);
/*
 * Fills in the pattern array
 */
 
static med_pattern *make_pattern(med *m);
/*
 * Makes a pattern for putting data in a MUX-PDU payload packet
 *   or removing data from a MUX-PDU payload.
 *
 * Assumes (*m) is a vaild med structure;
 *
 * See above for struct med_pattern.
 *
 * Since logical channel numbers can only be between 0 and 65535,
 *   (according to H.223/AnnexA), an unnsigned short int array would
 *   suffice.  If logical channel numbers were between 0 and 255, an
 *   unsigned char would be fine.  I don't really care about storage,
 *   so I'm making them natural ints.
 */

static void print_pattern(med_pattern *pat);
/*
 * Prints out the med's pattern
 */

void add_to_mux_table(mux_table_entry *mt, int *size, char *medstr);
/*
 * Adds an multiplex entry to the mux table using the med
 */

#endif

---