GNU Radio's SATNOGS Package
init_rs.h
Go to the documentation of this file.
1 /* Common code for intializing a Reed-Solomon control block (char or int symbols)
2  * Copyright 2004 Phil Karn, KA9Q
3  * May be used under the terms of the GNU Lesser General Public License (LGPL)
4  */
5 #undef NULL
6 #define NULL ((void *)0)
7 
8 {
9  int i, j, sr, root, iprim;
10 
11  rs = NULL;
12  /* Check parameter ranges */
13  if (symsize < 0 || symsize > 8 * sizeof(data_t))
14  {
15  goto done;
16  }
17 
18  if (fcr < 0 || fcr >= (1 << symsize))
19  {
20  goto done;
21  }
22  if (prim <= 0 || prim >= (1 << symsize))
23  {
24  goto done;
25  }
26  if (nroots < 0 || nroots >= (1 << symsize))
27  {
28  goto done; /* Can't have more roots than symbol values! */
29  }
30  if (pad < 0 || pad >= ((1 << symsize) - 1 - nroots))
31  {
32  goto done; /* Too much padding */
33  }
34 
35  rs = (struct rs *)calloc(1, sizeof(struct rs));
36  if (rs == NULL)
37  {
38  goto done;
39  }
40 
41  rs->mm = symsize;
42  rs->nn = (1 << symsize) - 1;
43  rs->pad = pad;
44 
45  rs->alpha_to = (data_t *)malloc(sizeof(data_t) * (rs->nn + 1));
46  if (rs->alpha_to == NULL)
47  {
48  free(rs);
49  rs = NULL;
50  goto done;
51  }
52  rs->index_of = (data_t *)malloc(sizeof(data_t) * (rs->nn + 1));
53  if (rs->index_of == NULL)
54  {
55  free(rs->alpha_to);
56  free(rs);
57  rs = NULL;
58  goto done;
59  }
60 
61  /* Generate Galois field lookup tables */
62  rs->index_of[0] = A0; /* log(zero) = -inf */
63  rs->alpha_to[A0] = 0; /* alpha**-inf = 0 */
64  sr = 1;
65  for (i = 0; i < rs->nn; i++)
66  {
67  rs->index_of[sr] = i;
68  rs->alpha_to[i] = sr;
69  sr <<= 1;
70  if (sr & (1 << symsize)) {
71  sr ^= gfpoly;
72  }
73  sr &= rs->nn;
74  }
75  if (sr != 1)
76  {
77  /* field generator polynomial is not primitive! */
78  free(rs->alpha_to);
79  free(rs->index_of);
80  free(rs);
81  rs = NULL;
82  goto done;
83  }
84 
85  /* Form RS code generator polynomial from its roots */
86  rs->genpoly = (data_t *)malloc(sizeof(data_t) * (nroots + 1));
87  if (rs->genpoly == NULL)
88  {
89  free(rs->alpha_to);
90  free(rs->index_of);
91  free(rs);
92  rs = NULL;
93  goto done;
94  }
95  rs->fcr = fcr;
96  rs->prim = prim;
98 
99  /* Find prim-th root of 1, used in decoding */
100  for (iprim = 1; (iprim % prim) != 0; iprim += rs->nn)
101  ;
102  rs->iprim = iprim / prim;
103 
104  rs->genpoly[0] = 1;
105  for (i = 0, root = fcr *prim; i < nroots; i++, root += prim)
106  {
107  rs->genpoly[i + 1] = 1;
108 
109  /* Multiply rs->genpoly[] by @**(root + x) */
110  for (j = i; j > 0; j--) {
111  if (rs->genpoly[j] != 0) {
112  rs->genpoly[j] = rs->genpoly[j - 1] ^ rs->alpha_to[modnn(rs,
113  rs->index_of[rs->genpoly[j]] + root)];
114  }
115  else {
116  rs->genpoly[j] = rs->genpoly[j - 1];
117  }
118  }
119  /* rs->genpoly[0] can never be zero */
120  rs->genpoly[0] = rs->alpha_to[modnn(rs, rs->index_of[rs->genpoly[0]] + root)];
121  }
122  /* convert rs->genpoly[] to index form for quicker encoding */
123  for (i = 0; i <= nroots; i++)
124  {
125  rs->genpoly[i] = rs->index_of[rs->genpoly[i]];
126  }
127 done:
128  ;
129 
130 }
rs nroots
Definition: init_rs.h:97
int i
Definition: decode_rs.h:71
int j
Definition: decode_rs.h:71
Definition: rs-common.h:7
int iprim
Definition: rs-common.h:16
int fcr
Definition: rs-common.h:14
data_t root[NROOTS]
Definition: decode_rs.h:78
int nn
Definition: rs-common.h:9
data_t * genpoly
Definition: rs-common.h:12
#define NULL
Definition: init_rs.h:6
data_t * alpha_to
Definition: rs-common.h:10
int nroots
Definition: rs-common.h:13
#define A0
Definition: char.h:20
unsigned char data_t
Definition: ccsds.h:1
int prim
Definition: rs-common.h:15
rs pad
Definition: init_rs.h:43
rs fcr
Definition: init_rs.h:95
data_t * index_of
Definition: rs-common.h:11
rs prim
Definition: init_rs.h:96
sr
Definition: init_rs.h:64
static int modnn(struct rs *rs, int x)
Definition: rs-common.h:20
int pad
Definition: rs-common.h:17
int mm
Definition: rs-common.h:8
rs iprim
Definition: init_rs.h:102