gen-patt.c

Reference Implementation of G.711 standard and other voice codecs

    if (BEReid == (SCD_EID *) 0)
    {
      fprintf (stderr, " File with EID-states doesn't exist. Creating one.\n");
      BER = ber_rate;

      /* Setup new EID */
      if ((BEReid = open_eid (BER, BER_gamma)) == (SCD_EID *) 0)
      {
	HARAKIRI ("Couldn't create EID for bit errors\n", 1);
      }
    }
    else
      fprintf (stderr,
	       "%s %s: BER=%.2f%% Gamma=%.2f%%\n",
	       "Using BER/Gamma from EID-state file",
	       state_file, BER * 100, BER_gamma * 100);

    ber_rate = BER;
    break;

  case 'F':
    /* Try to open EID-States file. */
    FEReid = recall_eid_from_file (state_file, &FER, &FER_gamma);
    if (FEReid == (SCD_EID *) 0)
    {
      fprintf (stderr, " File with EID-states doesn't exist. Create one\n");

      /* Setup new EID */
      FER = ber_rate;
      if ((FEReid = open_eid (FER, FER_gamma)) == (SCD_EID *) 0)
      {
	HARAKIRI ("Couldn't create EID for frame errors\n", 1);
      }
    }
    else
      fprintf (stderr,
	       "%s %s: FER=%.2f%% Gamma=%.2f%%\n",
	       "Using FER/Gamma from EID-state file",
	       state_file, FER * 100, FER_gamma * 100);

    ber_rate = FER;
    break;

  case 'B':
    /* Try to open burst eid state file */
    burst_eid = recall_burst_eid_from_file (state_file, index);
    if (burst_eid == (BURST_EID *) 0)
    {
      fprintf (stderr,
	       " File with burst EID-states doesn't exist. Create one\n");

      /* Setup new EID */
      if ((burst_eid = open_burst_eid (index)) == (BURST_EID *) 0)
      {
	HARAKIRI ("Couldn't create EID for burst frame errors\n", 1);
      }
    }

    break;
  default:
    HARAKIRI ("Wrong mode parameter. Allowed values are R,F,B\n", 1);
    break;
  }

  /*   
     **  Allocate memory for G.192 data buffer
   */
  error_pat = (short *) calloc (EID_BUFFER_LENGTH, sizeof (short));
  if (error_pat == (short *) 0)
  {
    HARAKIRI ("Could not allocate memory for error pattern buffer\n", 1);
  }

  /* 
     ** Initialize arrays
   */
  for (i = 0; i < EID_BUFFER_LENGTH; i++)
    frame_erased[i] = G192_FER;	/* 0x6B20 */
  if (mode=='R') /* For BER, use '0's, for (B)FER use good frame flags */
    for (i = 0; i < EID_BUFFER_LENGTH; i++)
      frame_okay[i] = G192_ZERO; 	/* 0x007F */
  else
    for (i = 0; i < EID_BUFFER_LENGTH; i++)
      frame_okay[i] = G192_SYNC; 	/* 0x6B21 */


  /* 
     ** Try obtaining a pattern within the given error/erasure rate
   */
  do
  {
    /*   
       **  Initializations necessary for each iteraction **
     */

    /* Increase counter */
    iteraction++;

    /* Rewind file */
    fseek (out_file_ptr, 0l, 0);

    /* Reset variables */
    ber1 = 0.0;
    processed = 0.0;
    generated = 0.0;
    disturbed = 0.0;

    /*   
       **  Generate the bit streams
     */
    switch (mode)
    {
    case 'R':
      {
	/* Initialize frame buffer with OK samples */
	/* memcpy (error_pat, frame_okay, EID_BUFFER_LENGTH); */
        for (i=0; i<EID_BUFFER_LENGTH; i++)
          error_pat[i] = frame_okay[i];

	/* Skip initial samples, saving undisturbed bits */
	for (i = 0; i < start_frame; i += EID_BUFFER_LENGTH)
	{
	  /* Use EID_BUFFER_LENGTH for start_frame/EID_BUFFER_LENGTH
	     iteractions and start_frame % EID_BUFFER_LENGTH for the
	     last iteraction */
	  k = i + EID_BUFFER_LENGTH > start_frame
	    /* ? start_frame % EID_BUFFER_LENGTH +1 */
	    ? start_frame % EID_BUFFER_LENGTH
	    : EID_BUFFER_LENGTH;

	  items = save_data(error_pat, k, out_file_ptr);
	  if (items < 0)
	    HARAKIRI ("Error saving data to file\n", 8);
	  generated += items;
	}

	/* Generate bits subject to disturbance*/
	for (i = start_frame; i < number_of_frames; i += EID_BUFFER_LENGTH)
	{
	  /* Checks how many frame erasures are necessary here.
	     If this is not the last round of collections, then
	     get EID_BUFFER_LENGTH frame erasure indications. If this
	     is the last iteraction in the loop, get only the remainder
	     of samples not all EID_BUFFER_LENGTH samples */
	  k = i + EID_BUFFER_LENGTH > number_of_frames
	    ? number_of_frames - generated
	    : EID_BUFFER_LENGTH;

	  /* Run bit error generator */
	  ber1 = BER_generator (BEReid, k, error_pat);

	  /* Save data to file according to the defined format */
	  items = save_data (error_pat, k, out_file_ptr);
	  if (items < 0)
	    HARAKIRI ("Error saving data to file\n", 8);

	  /* Update counters */
	  disturbed += ber1;
	  processed += items;
	  generated += items;
	}
	break;
      }

    case 'F':
    case 'B':
      {
	/* Reset burst EID generator, if required */
	if (mode == 'B' && reset)
	  reset_burst_eid(burst_eid);

	/* Skip initial frames */
	for (i = 0; i < start_frame; i += EID_BUFFER_LENGTH)
	{
	  /* Use EID_BUFFER_LENGTH for start_frame/EID_BUFFER_LENGTH
	     iteractions and start_frame % EID_BUFFER_LENGTH for the
	     last iteraction */
	  k = i + EID_BUFFER_LENGTH > start_frame
	    /* ? start_frame % EID_BUFFER_LENGTH +1 */
	    ? start_frame % EID_BUFFER_LENGTH
	    : EID_BUFFER_LENGTH;

	  items = save_data (frame_okay, k, out_file_ptr);
	  generated += items;
	}

	/* Generate frame subject to disturbance */
	for (i = start_frame; i < number_of_frames; i+= EID_BUFFER_LENGTH)
	{
	  /* Checks how many frame erasures are necessary here.
	     If this is not the last round of collections, then
	     get EID_BUFFER_LENGTH frame erasure indications. If this
	     is the last iteraction in the loop, get only the remainder
	     of samples not all EID_BUFFER_LENGTH samples */
	  k = i + EID_BUFFER_LENGTH > number_of_frames
	    ? number_of_frames - generated
	    : EID_BUFFER_LENGTH;
	  /*
	  k = i + EID_BUFFER_LENGTH > number_of_frames
	    ? number_of_frames % EID_BUFFER_LENGTH
	    : EID_BUFFER_LENGTH;
	  */

	  /* Run either Gilbert or Bellcore frame erasure model */
	  ber1 = mode == 'F'
	    ? run_FER_generator_random (error_pat, FEReid, k)
	    : run_FER_generator_burst (error_pat, burst_eid, k);

	  /* Save intermediate data in buffer */
	  items = save_data (error_pat, k, out_file_ptr);
	  if (items < 0)
	    HARAKIRI ("Error saving data to file\n", 8);

	  /* Update counters */
	  disturbed += ber1;
	  processed += items;
	  generated += items;
	}

	break;
      }
    }

    /* Calculate Bit/Frame error rate */
#ifdef OLD_CALCULATION
    percentage = disturbed / processed;	
#else
    percentage = disturbed / generated;
#endif
    if (!quiet)
      fprintf (stderr, "Run iteraction %ld with deviation %f\t(%.4f%%)\n",
	       iteraction, ber_rate - percentage,
	       100 * percentage);
  }
  while (tolerance >= 0 &&
	 fabs (ber_rate - percentage) > tolerance &&
	 iteraction < max_iteraction);

  /*
     ** .. Print some statistics ...
   */

  /* Common code */
  percentage *= 100.0; /* Bit/Frame error rate */

  /*   
     **  Print summary of options on screen
   */
  fprintf (stderr, "Pattern file:   %s\n", data_file_name);
  fprintf (stderr, "Pattern format: %s\n", format_str(save_format));
  fprintf (stderr, "Operating mode: %s ", mode_str (mode));
  switch (mode)
  {
  case 'R':
    fprintf (stderr, "(Generate Random Frame Erasures: Gilbert model)\n");
    fprintf (stderr, "Desired BER= %5.2f %%\n", 100 * ber_rate);
    fprintf (stderr, "Gamma= %5.4f %%\n", BER_gamma);
    break;
  case 'F':
    fprintf (stderr, "(Generate Random Frame Erasures: Gilbert model)\n");
    fprintf (stderr, "Desired FER= %5.2f %%\n", 100 * ber_rate);
    fprintf (stderr, "Gamma= %5.4f %%\n", FER_gamma);
    break;
  case 'B':
    fprintf (stderr, "(Generate Burst Frame Erasures: Bellcore model)\n");
    fprintf (stderr, "Desired BFER= %5.2f %%\n", 100 * ber_rate);
    break;
  }
  fprintf (stderr, "State variable file: %s\n", state_file);


  switch (mode)
  {
  case 'R':
    {
      save_EID_to_file (BEReid, state_file, BER, BER_gamma);
      fprintf (stderr, ">>Results\n");
      fprintf (stderr, "  Generated bits    : %.0f \n", generated);
      fprintf (stderr, "  Processed bits    : %.0f \n", processed);
      fprintf (stderr, "  Distorted bits    : %.0f \n", disturbed);
      fprintf (stderr, "  Bit Error Rate    : %f %c\n", percentage, percent);
      break;
    }

  case 'F':
    {
      if (FER != 0.0)
	save_EID_to_file (FEReid, state_file, FER, FER_gamma);
      fprintf (stderr, ">>Results\n");
      fprintf (stderr, "  Generated frames  : %.0f \n", generated);
      fprintf (stderr, "  Processed frames  : %.0f \n", processed);
      fprintf (stderr, "  Distorted frames  : %.0f \n", disturbed);
      fprintf (stderr, "  Frame Erasure Rate: %f %c\n", percentage, percent);
      break;
    }

  case 'B':
    {
      save_burst_eid_to_file (burst_eid, state_file);

      fprintf (stderr, ">>Results\n");
      fprintf (stderr, "  Generated frames  : %.0f \n", generated);
      fprintf (stderr, "  Processed frames  : %.0f \n", processed);
      fprintf (stderr, "  Distorted frames  : %.0f \n", disturbed);
      fprintf (stderr, "  Frame Erasure Rate  : %f %c\n", percentage, percent);

      /* Display contents of state counters */
      fprintf (stderr, "  Contents of state counters (Bellcore model)%s:\n  ",
	       reset || tolerance==-1 ?"":" since reset");
      for (j = 0; j < MODEL_SIZE; j++)
	printf ("%ld   ", burst_eid->internal[j]);

      /* itot = number of good frames */
      itot = burst_eid->internal[0];
      for (i = 1; i < MODEL_SIZE; i++)	/* plus number of bad frames */
	itot = itot + i * burst_eid->internal[i];

      /* Total frames processed should equal number of trials */
      printf ("\n  Total frames (all iterations%s)= %ld\n",
	      reset || tolerance==-1 ?"":" since reset", itot);
      break;
    }
  }				/* End switch */

  /*  
     **  Close the output file and quit
   */
  fclose (out_file_ptr);

#ifndef VMS			/* return value to OS if not VMS */
  return 0;
#endif
}