rhodes 3.0.2 → 3.1.0.beta.1

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/qrcode/rs.c

@@ -1,799 +0,0 @@
-/*Copyright (C) 1991-1995  Henry Minsky (hqm@ua.com, hqm@ai.mit.edu)
-  Copyright (C) 2008-2009  Timothy B. Terriberry (tterribe@xiph.org)
-  You can redistribute this library and/or modify it under the terms of the
-   GNU Lesser General Public License as published by the Free Software
-   Foundation; either version 2.1 of the License, or (at your option) any later
-   version.*/
-#include <stdlib.h>
-#include <string.h>
-#include "rs.h"
-
-/*Reed-Solomon encoder and decoder.
-  Original implementation (C) Henry Minsky (hqm@ua.com, hqm@ai.mit.edu),
-   Universal Access 1991-1995.
-  Updates by Timothy B. Terriberry (C) 2008-2009:
-   - Properly reject codes when error-locator polynomial has repeated roots or
-      non-trivial irreducible factors.
-   - Removed the hard-coded parity size and performed general API cleanup.
-   - Allow multiple representations of GF(2**8), since different standards use
-      different irreducible polynomials.
-   - Allow different starting indices for the generator polynomial, since
-      different standards use different values.
-   - Greatly reduced the computation by eliminating unnecessary operations.
-   - Explicitly solve for the roots of low-degree polynomials instead of using
-      an exhaustive search.
-     This is another major speed boost when there are few errors.*/
-
-
-/*Galois Field arithmetic in GF(2**8).*/
-
-void rs_gf256_init(rs_gf256 *_gf,unsigned _ppoly){
-  unsigned p;
-  int      i;
-  /*Initialize the table of powers of a primtive root, alpha=0x02.*/
-  p=1;
-  for(i=0;i<256;i++){
-    _gf->exp[i]=_gf->exp[i+255]=p;
-    p=((p<<1)^(-(p>>7)&_ppoly))&0xFF;
-  }
-  /*Invert the table to recover the logs.*/
-  for(i=0;i<255;i++)_gf->log[_gf->exp[i]]=i;
-  /*Note that we rely on the fact that _gf->log[0]=0 below.*/
-  _gf->log[0]=0;
-}
-
-/*Multiplication in GF(2**8) using logarithms.*/
-static unsigned rs_gmul(const rs_gf256 *_gf,unsigned _a,unsigned _b){
-  return _a==0||_b==0?0:_gf->exp[_gf->log[_a]+_gf->log[_b]];
-}
-
-/*Division in GF(2**8) using logarithms.
-  The result of division by zero is undefined.*/
-static unsigned rs_gdiv(const rs_gf256 *_gf,unsigned _a,unsigned _b){
-  return _a==0?0:_gf->exp[_gf->log[_a]+255-_gf->log[_b]];
-}
-
-/*Multiplication in GF(2**8) when one of the numbers is known to be non-zero
-   (proven by representing it by its logarithm).*/
-static unsigned rs_hgmul(const rs_gf256 *_gf,unsigned _a,unsigned _logb){
-  return _a==0?0:_gf->exp[_gf->log[_a]+_logb];
-}
-
-/*Square root in GF(2**8) using logarithms.*/
-static unsigned rs_gsqrt(const rs_gf256 *_gf,unsigned _a){
-  unsigned loga;
-  if(!_a)return 0;
-  loga=_gf->log[_a];
-  return _gf->exp[loga+(255&-(loga&1))>>1];
-}
-
-/*Polynomial root finding in GF(2**8).
-  Each routine returns a list of the distinct roots (i.e., with duplicates
-   removed).*/
-
-/*Solve a quadratic equation x**2 + _b*x + _c in GF(2**8) using the method
-   of~\cite{Wal99}.
-  Returns the number of distinct roots.
-  ARTICLE{Wal99,
-    author="C. Wayne Walker",
-    title="New Formulas for Solving Quadratic Equations over Certain Finite
-     Fields",
-    journal="{IEEE} Transactions on Information Theory",
-    volume=45,
-    number=1,
-    pages="283--284",
-    month=Jan,
-    year=1999
-  }*/
-static int rs_quadratic_solve(const rs_gf256 *_gf,unsigned _b,unsigned _c,
- unsigned char _x[2]){
-  unsigned b;
-  unsigned logb;
-  unsigned logb2;
-  unsigned logb4;
-  unsigned logb8;
-  unsigned logb12;
-  unsigned logb14;
-  unsigned logc;
-  unsigned logc2;
-  unsigned logc4;
-  unsigned c8;
-  unsigned g3;
-  unsigned z3;
-  unsigned l3;
-  unsigned c0;
-  unsigned g2;
-  unsigned l2;
-  unsigned z2;
-  int      inc;
-  /*If _b is zero, all we need is a square root.*/
-  if(!_b){
-    _x[0]=rs_gsqrt(_gf,_c);
-    return 1;
-  }
-  /*If _c is zero, 0 and _b are the roots.*/
-  if(!_c){
-    _x[0]=0;
-    _x[1]=_b;
-    return 2;
-  }
-  logb=_gf->log[_b];
-  logc=_gf->log[_c];
-  /*If _b lies in GF(2**4), scale x to move it out.*/
-  inc=logb%(255/15)==0;
-  if(inc){
-    b=_gf->exp[logb+254];
-    logb=_gf->log[b];
-    _c=_gf->exp[logc+253];
-    logc=_gf->log[_c];
-  }
-  else b=_b;
-  logb2=_gf->log[_gf->exp[logb<<1]];
-  logb4=_gf->log[_gf->exp[logb2<<1]];
-  logb8=_gf->log[_gf->exp[logb4<<1]];
-  logb12=_gf->log[_gf->exp[logb4+logb8]];
-  logb14=_gf->log[_gf->exp[logb2+logb12]];
-  logc2=_gf->log[_gf->exp[logc<<1]];
-  logc4=_gf->log[_gf->exp[logc2<<1]];
-  c8=_gf->exp[logc4<<1];
-  g3=rs_hgmul(_gf,
-   _gf->exp[logb14+logc]^_gf->exp[logb12+logc2]^_gf->exp[logb8+logc4]^c8,logb);
-  /*If g3 doesn't lie in GF(2**4), then our roots lie in an extension field.
-    Note that we rely on the fact that _gf->log[0]==0 here.*/
-  if(_gf->log[g3]%(255/15)!=0)return 0;
-  /*Construct the corresponding quadratic in GF(2**4):
-    x**2 + x/alpha**(255/15) + l3/alpha**(2*(255/15))*/
-  z3=rs_gdiv(_gf,g3,_gf->exp[logb8<<1]^b);
-  l3=rs_hgmul(_gf,rs_gmul(_gf,z3,z3)^rs_hgmul(_gf,z3,logb)^_c,255-logb2);
-  c0=rs_hgmul(_gf,l3,255-2*(255/15));
-  /*Construct the corresponding quadratic in GF(2**2):
-    x**2 + x/alpha**(255/3) + l2/alpha**(2*(255/3))*/
-  g2=rs_hgmul(_gf,
-   rs_hgmul(_gf,c0,255-2*(255/15))^rs_gmul(_gf,c0,c0),255-255/15);
-  z2=rs_gdiv(_gf,g2,_gf->exp[255-(255/15)*4]^_gf->exp[255-(255/15)]);
-  l2=rs_hgmul(_gf,
-   rs_gmul(_gf,z2,z2)^rs_hgmul(_gf,z2,255-(255/15))^c0,2*(255/15));
-  /*Back substitute to the solution in the original field.*/
-  _x[0]=_gf->exp[_gf->log[z3^rs_hgmul(_gf,
-   rs_hgmul(_gf,l2,255/3)^rs_hgmul(_gf,z2,255/15),logb)]+inc];
-  _x[1]=_x[0]^_b;
-  return 2;
-}
-
-/*Solve a cubic equation x**3 + _a*x**2 + _b*x + _c in GF(2**8).
-  Returns the number of distinct roots.*/
-static int rs_cubic_solve(const rs_gf256 *_gf,
- unsigned _a,unsigned _b,unsigned _c,unsigned char _x[3]){
-  unsigned k;
-  unsigned logd;
-  unsigned d2;
-  unsigned logd2;
-  unsigned logw;
-  int      nroots;
-  /*If _c is zero, factor out the 0 root.*/
-  if(!_c){
-    nroots=rs_quadratic_solve(_gf,_a,_b,_x);
-    if(_b)_x[nroots++]=0;
-    return nroots;
-  }
-  /*Substitute x=_a+y*sqrt(_a**2+_b) to get y**3 + y + k == 0,
-     k = (_a*_b+c)/(_a**2+b)**(3/2).*/
-  k=rs_gmul(_gf,_a,_b)^_c;
-  d2=rs_gmul(_gf,_a,_a)^_b;
-  if(!d2){
-    int logx;
-    if(!k){
-      /*We have a triple root.*/
-      _x[0]=_a;
-      return 1;
-    }
-    logx=_gf->log[k];
-    if(logx%3!=0)return 0;
-    logx/=3;
-    _x[0]=_a^_gf->exp[logx];
-    _x[1]=_a^_gf->exp[logx+255/3];
-    _x[2]=_a^_x[0]^_x[1];
-    return 3;
-  }
-  logd2=_gf->log[d2];
-  logd=logd2+(255&-(logd2&1))>>1;
-  k=rs_gdiv(_gf,k,_gf->exp[logd+logd2]);
-  /*Substitute y=w+1/w and z=w**3 to get z**2 + k*z + 1 == 0.*/
-  nroots=rs_quadratic_solve(_gf,k,1,_x);
-  if(nroots<1){
-    /*The Reed-Solomon code is only valid if we can find 3 distinct roots in
-       GF(2**8), so if we know there's only one, we don't actually need to find
-       it.
-      Note that we're also called by the quartic solver, but if we contain a
-       non-trivial irreducible factor, than so does the original
-       quartic~\cite{LW72}, and failing to return a root here actually saves us
-       some work there, also.*/
-    return 0;
-  }
-  /*Recover w from z.*/
-  logw=_gf->log[_x[0]];
-  if(logw){
-    if(logw%3!=0)return 0;
-    logw/=3;
-    /*Recover x from w.*/
-    _x[0]=_gf->exp[_gf->log[_gf->exp[logw]^_gf->exp[255-logw]]+logd]^_a;
-    logw+=255/3;
-    _x[1]=_gf->exp[_gf->log[_gf->exp[logw]^_gf->exp[255-logw]]+logd]^_a;
-    _x[2]=_x[0]^_x[1]^_a;
-    return 3;
-  }
-  else{
-    _x[0]=_a;
-    /*In this case _x[1] is a double root, so we know the Reed-Solomon code is
-       invalid.
-      Note that we still have to return at least one root, because if we're
-       being called by the quartic solver, the quartic might still have 4
-       distinct roots.
-      But we don't need more than one root, so we can avoid computing the
-       expensive one.*/
-    /*_x[1]=_gf->exp[_gf->log[_gf->exp[255/3]^_gf->exp[2*(255/3)]]+logd]^_a;*/
-    return 1;
-  }
-}
-
-/*Solve a quartic equation x**4 + _a*x**3 + _b*x**2 + _c*x + _d in GF(2**8) by
-   decomposing it into the cases given by~\cite{LW72}.
-  Returns the number of distinct roots.
-  @ARTICLE{LW72,
-    author="Philip A. Leonard and Kenneth S. Williams",
-    title="Quartics over $GF(2^n)$",
-    journal="Proceedings of the American Mathematical Society",
-    volume=36,
-    number=2,
-    pages="347--450",
-    month=Dec,
-    year=1972
-  }*/
-static int rs_quartic_solve(const rs_gf256 *_gf,
- unsigned _a,unsigned _b,unsigned _c,unsigned _d,unsigned char _x[3]){
-  unsigned r;
-  unsigned s;
-  unsigned t;
-  unsigned b;
-  int      nroots;
-  int      i;
-  /*If _d is zero, factor out the 0 root.*/
-  if(!_d){
-    nroots=rs_cubic_solve(_gf,_a,_b,_c,_x);
-    if(_c)_x[nroots++]=0;
-    return nroots;
-  }
-  if(_a){
-    unsigned loga;
-    /*Substitute x=(1/y) + sqrt(_c/_a) to eliminate the cubic term.*/
-    loga=_gf->log[_a];
-    r=rs_hgmul(_gf,_c,255-loga);
-    s=rs_gsqrt(_gf,r);
-    t=_d^rs_gmul(_gf,_b,r)^rs_gmul(_gf,r,r);
-    if(t){
-      unsigned logti;
-      logti=255-_gf->log[t];
-      /*The result is still quartic, but with no cubic term.*/
-      nroots=rs_quartic_solve(_gf,0,rs_hgmul(_gf,_b^rs_hgmul(_gf,s,loga),logti),
-       _gf->exp[loga+logti],_gf->exp[logti],_x);
-      for(i=0;i<nroots;i++)_x[i]=_gf->exp[255-_gf->log[_x[i]]]^s;
-    }
-    else{
-      /*s must be a root~\cite{LW72}, and is in fact a double-root~\cite{CCO69}.
-        Thus we're left with only a quadratic to solve.
-        @ARTICLE{CCO69,
-          author="Robert T. Chien and B. D. Cunningham and I. B. Oldham",
-          title="Hybrid Methods for Finding Roots of a Polynomial---With
-           Applications to {BCH} Decoding",
-          journal="{IEEE} Transactions on Information Theory",
-          volume=15,
-          number=2,
-          pages="329--335",
-          month=Mar,
-          year=1969
-        }*/
-      nroots=rs_quadratic_solve(_gf,_a,_b^r,_x);
-      /*s may be a triple root if s=_b/_a, but not quadruple, since _a!=0.*/
-      if(nroots!=2||_x[0]!=s&&_x[1]!=s)_x[nroots++]=s;
-    }
-    return nroots;
-  }
-  /*If there are no odd powers, it's really just a quadratic in disguise.*/
-  if(!_c)return rs_quadratic_solve(_gf,rs_gsqrt(_gf,_b),rs_gsqrt(_gf,_d),_x);
-  /*Factor into (x**2 + r*x + s)*(x**2 + r*x + t) by solving for r, which can
-     be shown to satisfy r**3 + _b*r + _c == 0.*/
-  nroots=rs_cubic_solve(_gf,0,_b,_c,_x);
-  if(nroots<1){
-    /*The Reed-Solomon code is only valid if we can find 4 distinct roots in
-       GF(2**8).
-      If the cubic does not factor into 3 (possibly duplicate) roots, then we
-       know that the quartic must have a non-trivial irreducible factor.*/
-    return 0;
-  }
-  r=_x[0];
-  /*Now solve for s and t.*/
-  b=rs_gdiv(_gf,_c,r);
-  nroots=rs_quadratic_solve(_gf,b,_d,_x);
-  if(nroots<2)return 0;
-  s=_x[0];
-  t=_x[1];
-  /*_c=r*(s^t) was non-zero, so s and t must be distinct.
-    But if z is a root of z**2 ^ r*z ^ s, then so is (z^r), and s = z*(z^r).
-    Hence if z is also a root of z**2 ^ r*z ^ t, then t = s, a contradiction.
-    Thus all four roots are distinct, if they exist.*/
-  nroots=rs_quadratic_solve(_gf,r,s,_x);
-  return nroots+rs_quadratic_solve(_gf,r,t,_x+nroots);
-}
-
-/*Polynomial arithmetic with coefficients in GF(2**8).*/
-
-static void rs_poly_zero(unsigned char *_p,int _dp1){
-  memset(_p,0,_dp1*sizeof(*_p));
-}
-
-static void rs_poly_copy(unsigned char *_p,const unsigned char *_q,int _dp1){
-  memcpy(_p,_q,_dp1*sizeof(*_p));
-}
-
-/*Multiply the polynomial by the free variable, x (shift the coefficients).
-  The number of coefficients, _dp1, must be non-zero.*/
-static void rs_poly_mul_x(unsigned char *_p,const unsigned char *_q,int _dp1){
-  memmove(_p+1,_q,(_dp1-1)*sizeof(*_p));
-  _p[0]=0;
-}
-
-/*Divide the polynomial by the free variable, x (shift the coefficients).
-  The number of coefficients, _dp1, must be non-zero.*/
-static void rs_poly_div_x(unsigned char *_p,const unsigned char *_q,int _dp1){
-  memmove(_p,_q+1,(_dp1-1)*sizeof(*_p));
-  _p[_dp1-1]=0;
-}
-
-/*Compute the first (d+1) coefficients of the product of a degree e and a
-   degree f polynomial.*/
-static void rs_poly_mult(const rs_gf256 *_gf,unsigned char *_p,int _dp1,
- const unsigned char *_q,int _ep1,const unsigned char *_r,int _fp1){
-  int m;
-  int i;
-  rs_poly_zero(_p,_dp1);
-  m=_ep1<_dp1?_ep1:_dp1;
-  for(i=0;i<m;i++)if(_q[i]!=0){
-    unsigned logqi;
-    int      n;
-    int      j;
-    n=_dp1-i<_fp1?_dp1-i:_fp1;
-    logqi=_gf->log[_q[i]];
-    for(j=0;j<n;j++)_p[i+j]^=rs_hgmul(_gf,_r[j],logqi);
-  }
-}
-
-/*Decoding.*/
-
-/*Computes the syndrome of a codeword.*/
-static void rs_calc_syndrome(const rs_gf256 *_gf,int _m0,
- unsigned char *_s,int _npar,const unsigned char *_data,int _ndata){
-  int i;
-  int j;
-  for(j=0;j<_npar;j++){
-    unsigned alphaj;
-    unsigned sj;
-    sj=0;
-    alphaj=_gf->log[_gf->exp[j+_m0]];
-    for(i=0;i<_ndata;i++)sj=_data[i]^rs_hgmul(_gf,sj,alphaj);
-    _s[j]=sj;
-  }
-}
-
-/*Berlekamp-Peterson and Berlekamp-Massey Algorithms for error-location,
-   modified to handle known erasures, from \cite{CC81}, p. 205.
-  This finds the coefficients of the error locator polynomial.
-  The roots are then found by looking for the values of alpha**n where
-   evaluating the polynomial yields zero.
-  Error correction is done using the error-evaluator equation on p. 207.
-  @BOOK{CC81,
-    author="George C. Clark, Jr and J. Bibb Cain",
-    title="Error-Correction Coding for Digitial Communications",
-    series="Applications of Communications Theory",
-    publisher="Springer",
-    address="New York, NY",
-    month=Jun,
-    year=1981
-  }*/
-
-/*Initialize lambda to the product of (1-x*alpha**e[i]) for erasure locations
-   e[i].
-  Note that the user passes in array indices counting from the beginning of the
-   data, while our polynomial indexes starting from the end, so
-   e[i]=(_ndata-1)-_erasures[i].*/
-static void rs_init_lambda(const rs_gf256 *_gf,unsigned char *_lambda,int _npar,
- const unsigned char *_erasures,int _nerasures,int _ndata){
-  int i;
-  int j;
-  rs_poly_zero(_lambda,(_npar<4?4:_npar)+1);
-  _lambda[0]=1;
-  for(i=0;i<_nerasures;i++)for(j=i+1;j>0;j--){
-    _lambda[j]^=rs_hgmul(_gf,_lambda[j-1],_ndata-1-_erasures[i]);
-  }
-}
-
-/*From \cite{CC81}, p. 216.
-  Returns the number of errors detected (degree of _lambda).*/
-static int rs_modified_berlekamp_massey(const rs_gf256 *_gf,
- unsigned char *_lambda,const unsigned char *_s,unsigned char *_omega,int _npar,
- const unsigned char *_erasures,int _nerasures,int _ndata){
-  unsigned char tt[256];
-  int           n;
-  int           l;
-  int           k;
-  int           i;
-  /*Initialize _lambda, the error locator-polynomial, with the location of
-     known erasures.*/
-  rs_init_lambda(_gf,_lambda,_npar,_erasures,_nerasures,_ndata);
-  rs_poly_copy(tt,_lambda,_npar+1);
-  l=_nerasures;
-  k=0;
-  for(n=_nerasures+1;n<=_npar;n++){
-    unsigned d;
-    rs_poly_mul_x(tt,tt,n-k+1);
-    d=0;
-    for(i=0;i<=l;i++)d^=rs_gmul(_gf,_lambda[i],_s[n-1-i]);
-    if(d!=0){
-      unsigned logd;
-      logd=_gf->log[d];
-      if(l<n-k){
-        int t;
-        for(i=0;i<=n-k;i++){
-          unsigned tti;
-          tti=tt[i];
-          tt[i]=rs_hgmul(_gf,_lambda[i],255-logd);
-          _lambda[i]=_lambda[i]^rs_hgmul(_gf,tti,logd);
-        }
-        t=n-k;
-        k=n-l;
-        l=t;
-      }
-      else for(i=0;i<=l;i++)_lambda[i]=_lambda[i]^rs_hgmul(_gf,tt[i],logd);
-    }
-  }
-  rs_poly_mult(_gf,_omega,_npar,_lambda,l+1,_s,_npar);
-  return l;
-}
-
-/*Finds all the roots of an error-locator polynomial _lambda by evaluating it
-   at successive values of alpha, and returns the positions of the associated
-   errors in _epos.
-  Returns the number of valid roots identified.*/
-static int rs_find_roots(const rs_gf256 *_gf,unsigned char *_epos,
- const unsigned char *_lambda,int _nerrors,int _ndata){
-  unsigned alpha;
-  int      nroots;
-  int      i;
-  nroots=0;
-  if(_nerrors<=4){
-    /*Explicit solutions for higher degrees are possible.
-      Chien uses large lookup tables to solve quintics, and Truong et al. give
-       special algorithms for degree up through 11, though they use exhaustive
-       search (with reduced complexity) for some portions.
-      Quartics are good enough for reading CDs, and represent a reasonable code
-       complexity trade-off without requiring any extra tables.
-      Note that _lambda[0] is always 1.*/
-    _nerrors=rs_quartic_solve(_gf,_lambda[1],_lambda[2],_lambda[3],_lambda[4],
-     _epos);
-    for(i=0;i<_nerrors;i++)if(_epos[i]){
-      alpha=_gf->log[_epos[i]];
-      if((int)alpha<_ndata)_epos[nroots++]=alpha;
-    }
-    return nroots;
-  }
-  else for(alpha=0;(int)alpha<_ndata;alpha++){
-    unsigned alphai;
-    unsigned sum;
-    sum=0;
-    alphai=0;
-    for(i=0;i<=_nerrors;i++){
-      sum^=rs_hgmul(_gf,_lambda[_nerrors-i],alphai);
-      alphai=_gf->log[_gf->exp[alphai+alpha]];
-    }
-    if(!sum)_epos[nroots++]=alpha;
-  }
-  return nroots;
-}
-
-/*Corrects a codeword with _ndata<256 bytes, of which the last _npar are parity
-   bytes.
-  Known locations of errors can be passed in the _erasures array.
-  Twice as many (up to _npar) errors with a known location can be corrected
-   compared to errors with an unknown location.
-  Returns the number of errors corrected if successful, or a negative number if
-   the message could not be corrected because too many errors were detected.*/
-int rs_correct(const rs_gf256 *_gf,int _m0,unsigned char *_data,int _ndata,
- int _npar,const unsigned char *_erasures,int _nerasures){
-  /*lambda must have storage for at least five entries to avoid special cases
-     in the low-degree polynomial solver.*/
-  unsigned char lambda[256];
-  unsigned char omega[256];
-  unsigned char epos[256];
-  unsigned char s[256];
-  int           i;
-  /*If we already have too many erasures, we can't possibly succeed.*/
-  if(_nerasures>_npar)return -1;
-  /*Compute the syndrome values.*/
-  rs_calc_syndrome(_gf,_m0,s,_npar,_data,_ndata);
-  /*Check for a non-zero value.*/
-  for(i=0;i<_npar;i++)if(s[i]){
-    int nerrors;
-    int j;
-    /*Construct the error locator polynomial.*/
-    nerrors=rs_modified_berlekamp_massey(_gf,lambda,s,omega,_npar,
-     _erasures,_nerasures,_ndata);
-    /*If we can't locate any errors, we can't force the syndrome values to
-       zero, and must have a decoding error.
-      Conversely, if we have too many errors, there's no reason to even attempt
-       the root search.*/
-    if(nerrors<=0||nerrors-_nerasures>_npar-_nerasures>>1)return -1;
-    /*Compute the locations of the errors.
-      If they are not all distinct, or some of them were outside the valid
-       range for our block size, we have a decoding error.*/
-    if(rs_find_roots(_gf,epos,lambda,nerrors,_ndata)<nerrors)return -1;
-    /*Now compute the error magnitudes.*/
-    for(i=0;i<nerrors;i++){
-      unsigned a;
-      unsigned b;
-      unsigned alpha;
-      unsigned alphan1;
-      unsigned alphan2;
-      unsigned alphanj;
-      alpha=epos[i];
-      /*Evaluate omega at alpha**-1.*/
-      a=0;
-      alphan1=255-alpha;
-      alphanj=0;
-      for(j=0;j<_npar;j++){
-        a^=rs_hgmul(_gf,omega[j],alphanj);
-        alphanj=_gf->log[_gf->exp[alphanj+alphan1]];
-      }
-      /*Evaluate the derivative of lambda at alpha**-1
-        All the odd powers vanish.*/
-      b=0;
-      alphan2=_gf->log[_gf->exp[alphan1<<1]];
-      alphanj=alphan1+_m0*alpha%255;
-      for(j=1;j<=_npar;j+=2){
-        b^=rs_hgmul(_gf,lambda[j],alphanj);
-        alphanj=_gf->log[_gf->exp[alphanj+alphan2]];
-      }
-      /*Apply the correction.*/
-      _data[_ndata-1-alpha]^=rs_gdiv(_gf,a,b);
-    }
-    return nerrors;
-  }
-  return 0;
-}
-
-/*Encoding.*/
-
-/*Create an _npar-coefficient generator polynomial for a Reed-Solomon code
-   with _npar<256 parity bytes.*/
-void rs_compute_genpoly(const rs_gf256 *_gf,int _m0,
- unsigned char *_genpoly,int _npar){
-  int i;
-  if(_npar<=0)return;
-  rs_poly_zero(_genpoly,_npar);
-  _genpoly[0]=1;
-  /*Multiply by (x+alpha^i) for i = 1 ... _ndata.*/
-  for(i=0;i<_npar;i++){
-    unsigned alphai;
-    int      n;
-    int      j;
-    n=i+1<_npar-1?i+1:_npar-1;
-    alphai=_gf->log[_gf->exp[_m0+i]];
-    for(j=n;j>0;j--)_genpoly[j]=_genpoly[j-1]^rs_hgmul(_gf,_genpoly[j],alphai);
-    _genpoly[0]=rs_hgmul(_gf,_genpoly[0],alphai);
-  }
-}
-
-/*Adds _npar<=_ndata parity bytes to an _ndata-_npar byte message.
-  _data must contain room for _ndata<256 bytes.*/
-void rs_encode(const rs_gf256 *_gf,unsigned char *_data,int _ndata,
- const unsigned char *_genpoly,int _npar){
-  unsigned char *lfsr;
-  unsigned       d;
-  int            i;
-  int            j;
-  if(_npar<=0)return;
-  lfsr=_data+_ndata-_npar;
-  rs_poly_zero(lfsr,_npar);
-  for(i=0;i<_ndata-_npar;i++){
-    d=_data[i]^lfsr[0];
-    if(d){
-      unsigned logd;
-      logd=_gf->log[d];
-      for(j=0;j<_npar-1;j++){
-        lfsr[j]=lfsr[j+1]^rs_hgmul(_gf,_genpoly[_npar-1-j],logd);
-      }
-      lfsr[_npar-1]=rs_hgmul(_gf,_genpoly[0],logd);
-    }
-    else rs_poly_div_x(lfsr,lfsr,_npar);
-  }
-}
-
-#if defined(RS_TEST_ENC)
-#include <stdio.h>
-#include <stdlib.h>
-
-int main(void){
-  rs_gf256 gf;
-  int      k;
-  rs_gf256_init(&gf,QR_PPOLY);
-  srand(0);
-  for(k=0;k<64*1024;k++){
-    unsigned char genpoly[256];
-    unsigned char data[256];
-    unsigned char epos[256];
-    int           ndata;
-    int           npar;
-    int           nerrors;
-    int           i;
-    ndata=rand()&0xFF;
-    npar=ndata>0?rand()%ndata:0;
-    for(i=0;i<ndata-npar;i++)data[i]=rand()&0xFF;
-    rs_compute_genpoly(&gf,QR_M0,genpoly,npar);
-    rs_encode(&gf,QR_M0,data,ndata,genpoly,npar);
-    /*Write a clean version of the codeword.*/
-    printf("%i %i",ndata,npar);
-    for(i=0;i<ndata;i++)printf(" %i",data[i]);
-    printf(" 0\n");
-    /*Write the correct output to compare the decoder against.*/
-    fprintf(stderr,"Success!\n",nerrors);
-    for(i=0;i<ndata;i++)fprintf(stderr,"%i%s",data[i],i+1<ndata?" ":"\n");
-    if(npar>0){
-      /*Corrupt it.*/
-      nerrors=rand()%(npar+1);
-      if(nerrors>0){
-        /*This test is not quite correct: there could be so many errors it
-           comes within (npar>>1) errors of another valid codeword.
-          I don't know a simple way to test for that without trying to decode
-           the corrupt codeword, though, which is the very code we're trying to
-           test.*/
-        if(nerrors<=npar>>1){
-          fprintf(stderr,"Success!\n",nerrors);
-          for(i=0;i<ndata;i++){
-            fprintf(stderr,"%i%s",data[i],i+1<ndata?" ":"\n");
-          }
-        }
-        else fprintf(stderr,"Failure.\n");
-        fprintf(stderr,"Success!\n",nerrors);
-        for(i=0;i<ndata;i++)fprintf(stderr,"%i%s",data[i],i+1<ndata?" ":"\n");
-        for(i=0;i<ndata;i++)epos[i]=i;
-        for(i=0;i<nerrors;i++){
-          unsigned char e;
-          int           ei;
-          ei=rand()%(ndata-i)+i;
-          e=epos[ei];
-          epos[ei]=epos[i];
-          epos[i]=e;
-          data[e]^=rand()%255+1;
-        }
-        /*First with no erasure locations.*/
-        printf("%i %i",ndata,npar);
-        for(i=0;i<ndata;i++)printf(" %i",data[i]);
-        printf(" 0\n");
-        /*Now with erasure locations.*/
-        printf("%i %i",ndata,npar);
-        for(i=0;i<ndata;i++)printf(" %i",data[i]);
-        printf(" %i",nerrors);
-        for(i=0;i<nerrors;i++)printf(" %i",epos[i]);
-        printf("\n");
-      }
-    }
-  }
-  return 0;
-}
-#endif
-
-#if defined(RS_TEST_DEC)
-#include <stdio.h>
-
-int main(void){
-  rs_gf256 gf;
-  rs_gf256_init(&gf,QR_PPOLY);
-  for(;;){
-    unsigned char data[255];
-    unsigned char erasures[255];
-    int idata[255];
-    int ierasures[255];
-    int ndata;
-    int npar;
-    int nerasures;
-    int nerrors;
-    int i;
-    if(scanf("%i",&ndata)<1||ndata<0||ndata>255||
-     scanf("%i",&npar)<1||npar<0||npar>ndata)break;
-    for(i=0;i<ndata;i++){
-      if(scanf("%i",idata+i)<1||idata[i]<0||idata[i]>255)break;
-      data[i]=idata[i];
-    }
-    if(i<ndata)break;
-    if(scanf("%i",&nerasures)<1||nerasures<0||nerasures>ndata)break;
-    for(i=0;i<nerasures;i++){
-      if(scanf("%i",ierasures+i)<1||ierasures[i]<0||ierasures[i]>=ndata)break;
-      erasures[i]=ierasures[i];
-    }
-    nerrors=rs_correct(&gf,QR_M0,data,ndata,npar,erasures,nerasures);
-    if(nerrors>=0){
-      unsigned char data2[255];
-      unsigned char genpoly[255];
-      for(i=0;i<ndata-npar;i++)data2[i]=data[i];
-      rs_compute_genpoly(&gf,QR_M0,genpoly,npar);
-      rs_encode(&gf,QR_M0,data2,ndata,genpoly,npar);
-      for(i=ndata-npar;i<ndata;i++)if(data[i]!=data2[i]){
-        printf("Abject failure! %i!=%i\n",data[i],data2[i]);
-      }
-      printf("Success!\n",nerrors);
-      for(i=0;i<ndata;i++)printf("%i%s",data[i],i+1<ndata?" ":"\n");
-    }
-    else printf("Failure.\n");
-  }
-  return 0;
-}
-#endif
-
-#if defined(RS_TEST_ROOTS)
-#include <stdio.h>
-
-/*Exhaustively test the root finder.*/
-int main(void){
-  rs_gf256 gf;
-  int      a;
-  int      b;
-  int      c;
-  int      d;
-  rs_gf256_init(&gf,QR_PPOLY);
-  for(a=0;a<256;a++)for(b=0;b<256;b++)for(c=0;c<256;c++)for(d=0;d<256;d++){
-    unsigned char x[4];
-    unsigned char r[4];
-    unsigned      x2;
-    unsigned      e[5];
-    int           nroots;
-    int           mroots;
-    int           i;
-    int           j;
-    nroots=rs_quartic_solve(&gf,a,b,c,d,x);
-    for(i=0;i<nroots;i++){
-      x2=rs_gmul(&gf,x[i],x[i]);
-      e[0]=rs_gmul(&gf,x2,x2)^rs_gmul(&gf,a,rs_gmul(&gf,x[i],x2))^
-       rs_gmul(&gf,b,x2)^rs_gmul(&gf,c,x[i])^d;
-      if(e[0]){
-        printf("Invalid root: (0x%02X)**4 ^ 0x%02X*(0x%02X)**3 ^ "
-         "0x%02X*(0x%02X)**2 ^ 0x%02X(0x%02X) ^ 0x%02X = 0x%02X\n",
-         x[i],a,x[i],b,x[i],c,x[i],d,e[0]);
-      }
-      for(j=0;j<i;j++)if(x[i]==x[j]){
-        printf("Repeated root %i=%i: (0x%02X)**4 ^ 0x%02X*(0x%02X)**3 ^ "
-         "0x%02X*(0x%02X)**2 ^ 0x%02X(0x%02X) ^ 0x%02X = 0x%02X\n",
-         i,j,x[i],a,x[i],b,x[i],c,x[i],d,e[0]);
-      }
-    }
-    mroots=0;
-    for(j=1;j<256;j++){
-      int logx;
-      int logx2;
-      logx=gf.log[j];
-      logx2=gf.log[gf.exp[logx<<1]];
-      e[mroots]=d^rs_hgmul(&gf,c,logx)^rs_hgmul(&gf,b,logx2)^
-       rs_hgmul(&gf,a,gf.log[gf.exp[logx+logx2]])^gf.exp[logx2<<1];
-      if(!e[mroots])r[mroots++]=j;
-    }
-    /*We only care about missing roots if the quartic had 4 distinct, non-zero
-       roots.*/
-    if(mroots==4)for(j=0;j<mroots;j++){
-      for(i=0;i<nroots;i++)if(x[i]==r[j])break;
-      if(i>=nroots){
-        printf("Missing root: (0x%02X)**4 ^ 0x%02X*(0x%02X)**3 ^ "
-         "0x%02X*(0x%02X)**2 ^ 0x%02X(0x%02X) ^ 0x%02X = 0x%02X\n",
-         r[j],a,r[j],b,r[j],c,r[j],d,e[j]);
-      }
-    }
-  }
-  return 0;
-}
-#endif