pdf417_enc.c

PDF417编码的算法的源程序

              if (j % 2 == 1)
                {

                  tmp = (tmp + GPRIME -
                         Alpha_to[modbase (s[i + 1 - j] + lambda[j])]) %
                    GPRIME;
                }
              else
                {

                  tmp =
                    (tmp +
                     Alpha_to[modbase (s[i + 1 - j] + lambda[j])]) % GPRIME;
                }
              if (debug)
                {
                  printf
                    ("In tmp loop  tmp = %d i = %d j = %d s[i+1-j] = %d lambda[j] = %d \n",
                     tmp, i, j, s[i + 1 - j], lambda[j]);
                }
            }
        }
      if (tmp != 0)
        deg_omega = i;
      omega[i] = Index_of[tmp];
      if (debug)
        {
          printf ("Omega [i] = %d i = %d \n", omega[i], i);
        }

    }
  omega[synd_len] = A0;
  if (debug)
    {
      printf ("Degree of omega = %d \n", deg_omega);
    }

  /*
   * Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
   * inv(X(l))**(B0-1) and den = lambda_pr(inv(X(l))) all in poly-form
   */
  for (j = count - 1; j >= 0; j--)
    {
      num1 = 0;
      for (i = deg_omega; i >= 0; i--)
        {
          if (omega[i] != A0)
            {
              //    num1  = ( num1 + Alpha_to[modbase(omega[i] + (i * root[j])]) % GPRIME;
              num1 =
                (num1 +
                 Alpha_to[modbase (omega[i] + ((i + 1) * root[j]))]) % GPRIME;
              if (debug)
                {
                  printf ("Num1 = %d i = %d omega[i] = %d root[j] = %d \n",
                          num1, i, omega[i], root[j]);
                }
            }
        }
      //  num2 = Alpha_to[modbase(root[j] * (1 - 1) + data_len)];

      num2 = 1;
      den = 0;

      // denominator if product of all (1 - Bj Bk) for k != j
      // if count = 1, then den = 1

      den = 1;
      for (k = 0; k < count; k += 1)
        {
          if (k != j)
            {
              tmp =
                (1 + GPRIME -
                 Alpha_to[modbase (GPRIME - 1 - root[k] + root[j])]) % GPRIME;

              den = Alpha_to[modbase (Index_of[den] + Index_of[tmp])];
            }
        }

      if (debug)
        {
          printf ("den = %d \n", den);
        }

      if (den == 0)
        {
#if DEBUG >= 1
          printf ("\n ERROR: denominator = 0\n");
#endif
          /* Convert to dual- basis */
          count = -1;
          goto finish;
        }

      if (debug)
        {
          printf ("Index num1 = %d Index num2 = %d Index of den = %d \n",
                  Index_of[num1], Index_of[num2], Index_of[den]);
        }

      error_val = Alpha_to[modbase (Index_of[num1] + Index_of[num2] +
                                    GPRIME - 1 - Index_of[den])] % GPRIME;

      if (debug)
        {
          printf ("error_val = %d \n", error_val);
        }

      /* Apply error to data */
      if (num1 != 0)
        {
          if (loc[j] < data_len + 1)
            {
              fix_loc = data_len - loc[j];
              if (debug)
                {
                  printf ("Fix loc = %d \n", fix_loc);
                }
              if (fix_loc < data_len + 1)
                {
                  data[fix_loc] =
                    (data[fix_loc] + GPRIME - error_val) % GPRIME;
                }
            }
        }
    }
finish:
  if (debug)
    {
      printf ("At FINISH \n");
    }
  if (eras_pos != NULL)
    {
      for (i = 0; i < count; i++)
        {
          if (eras_pos != NULL)
            eras_pos[i] = loc[i];
        }
    }
  return count;
}

// calculate syndromes for the encoded message + correction
// this is to check to see that the error correction codes are correct
//

void
syndromes (int message_len, int synd_count)
{

  int i, j;
  int power_val;
  int synd_val;
  int debug;
  debug = 0;

  for (i = 0; i < synd_count; i += 1)
    {

      synd_array[i] = 0;
    }


  for (i = 0; i < synd_count; i += 1)
    {

      power_val = powers_of_3[i + 1];

      if (debug)
        {
          printf ("Power val = %d \n", power_val);
        }
      synd_val = 0;
      for (j = 0; j < message_len; j += 1)
        {
          synd_val = (data[j] + synd_val) % GPRIME;
          synd_val = (power_val * synd_val) % GPRIME;
          if (debug)
            {
              printf ("Sval = %d \n", synd_val);
            }
        }

      synd_array[i] = synd_val;

      if (debug)
        {
          printf ("i = %d syndrome = %d \n", i, synd_array[i]);
        }

    }


}

void
put_back_len (int inval)
{

  int debug;
  debug = 0;


  if (debug)
    {
      printf ("Put back len, Code = %d \n", inval);
    }


  codes[0] = inval;
  data[0] = inval;


}                               /* put back len */

void
numeric_compact (char *instring)
{



  int b900_result[16];

  int save_val[16];

  int ii, jj, kk;
  int carryin;
  int slen;
  int leading;
  int mm;
  int this_digit;
  int debug;


  debug = 0;

  if (debug)
    {
     printf ("In numeric_compact - instring = %s \n", instring);
    }

  /* calculate the base 900 values */

  if (digit_table_valid == FALSE)
    {
      digit_vals[0][0] = 0;
      digit_vals[0][1] = 0;
      digit_vals[0][2] = 0;
      digit_vals[0][3] = 0;
      digit_vals[0][4] = 0;

      digit_vals[0][5] = 0;
      digit_vals[0][6] = 0;
      digit_vals[0][7] = 0;
      digit_vals[0][8] = 0;
      digit_vals[0][9] = 0;

      digit_vals[0][10] = 0;
      digit_vals[0][11] = 0;
      digit_vals[0][12] = 0;
      digit_vals[0][13] = 0;
      digit_vals[0][14] = 0;
      digit_vals[0][15] = 1;

      for (jj = 1; jj < 46; jj += 1)
        {

          for (ii = 15; ii > -1; ii -= 1) /* multiply base 900 gits by 10 */
            {
              digit_vals[jj][ii] = (digit_vals[jj - 1][ii]) * 10;
            }

          for (ii = 15; ii > -1; ii -= 1)
            {
              save_val[ii] = digit_vals[jj][ii];
            }

          for (ii = 14; ii > -1; ii -= 1)
            {
              digit_vals[jj][ii] =
                digit_vals[jj][ii] + ((save_val[ii + 1]) / 900);
              /* add in carry */
            }

          for (ii = 15; ii > -1; ii -= 1)
            {
              digit_vals[jj][ii] = ((digit_vals[jj][ii]) % 900); /* get result */

            }

        }

      digit_table_valid = TRUE;

      if (debug)
        {
          for (jj = 0; jj < 46; jj += 1)
            {
              printf
                (" jj = %d : %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d \n",
                 jj, digit_vals[jj][15], digit_vals[jj][14],
                 digit_vals[jj][13], digit_vals[jj][12], digit_vals[jj][11],
                 digit_vals[jj][10], digit_vals[jj][9], digit_vals[jj][8],
                 digit_vals[jj][7], digit_vals[jj][6], digit_vals[jj][5],
                 digit_vals[jj][4], digit_vals[jj][3], digit_vals[jj][2],
                 digit_vals[jj][1], digit_vals[jj][0]);
            }
        }
    }

  b900_result[0] = 0;
  b900_result[1] = 0;
  b900_result[2] = 0;
  b900_result[3] = 0;
  b900_result[4] = 0;

  b900_result[5] = 0;
  b900_result[6] = 0;
  b900_result[7] = 0;
  b900_result[8] = 0;
  b900_result[9] = 0;

  b900_result[10] = 0;
  b900_result[11] = 0;
  b900_result[12] = 0;
  b900_result[13] = 0;
  b900_result[14] = 0;
  b900_result[15] = 0;

  slen = strlen (instring);
  if (debug)
    {
     printf ("In numeric compact, slen = %d string = %s \n", slen, instring);
    }

  for (ii = strlen (instring) - 1; ii > -1; ii -= 1)
    {

      this_digit = instring[ii] - '0';

      if (debug)
        {
          printf (" this_digit = %d \n", this_digit);
        }

      for (kk = 0; kk < this_digit; kk += 1)
        {
          carryin = 0;
          for (mm = 15; mm > -1; mm -= 1) /* add 10^ (slen-ii) * this_digit */
            {
              b900_result[mm] += digit_vals[slen - ii - 1][mm] + carryin;
              if (b900_result[mm] > 899)
                {
                  carryin = 1;
                  b900_result[mm] = b900_result[mm] - 900;
                }
              else
                {
                  carryin = 0;
                }
            }
        }

    }

  leading = FALSE;
  for (kk = 0; kk < 16; kk += 1)
    {
      if ((b900_result[kk] != 0) || (leading == TRUE))
        {
          leading = TRUE;
          put_back (b900_result[kk]);
        }
      else                      /* b900_result[kk] == 0 and leading = FALSE */
        {
          mm = 0;
        }
    }

  if (leading == FALSE)         /* not possible if leading 1 added */
    {
      put_back (0);
    }


}

void
nc (char *instring)
{

  int ll;
  int jj;

  int slen;

  char tempstr[MAX_LINE + 100];
  char short_str[MAX_LINE];
  int debug;

  debug = 0;

  slen = strlen (instring);

  if (debug)
    {
     printf ("In nc - strlen = %d \n", slen);
     printf ("In string = %s \n", instring);
    }

  if (strlen (instring) < 45)
    {
      tempstr[0] = '1';
      tempstr[1] = NULLCHAR;
      strcat (tempstr, instring);
      numeric_compact (tempstr);
    }
  else                          /* more than one group */
    {

      ll = 0;
      while (ll < (strlen (instring) - 44)) /* do the groups */
        {
          short_str[0] = '1';
          for (jj = 0; jj < 44; jj += 1)
            {

              short_str[jj + 1] = instring[jj + ll];
            }
          short_str[jj + 1] = NULLCHAR;
          numeric_compact (short_str);
          ll += 44;
        }
      /* do whats left */

      short_str[0] = '1';

      if (strlen (instring) - ll > 0)
        {
          for (jj = ll; jj < strlen (instring); jj += 1)
            {

              short_str[jj - ll + 1] = instring[jj];

            }
          short_str[jj - ll + 1] = NULLCHAR;
          numeric_compact (short_str);
        }
    }

}                               /* nc */

  /* byte compact a string */

void
byte_compact (char *instring)
{

#define byte_comp_6 924
#define byte_comp_05  901
  int ii;
  int groups;
  int rem;
  long t_code_a[10];
  long t_code_b[10];

  int carry;
  char tstr[MAX_LINE + 256];

  int jj, kk;
  long sum[10];

  int str_len;
  long remainder;

  long valuea;                  /* need to be 32 bit */
  long valueb;                  /* need to be 32 bit */
  long value;
  char this_char;
  int debug;

  debug = 0;
  str_len = strlen (instring);

  if (debug)
    printf ("Byte compact - string = %s \n", instring);

  if ((str_len % 2) != 0