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
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;
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 }
98
99 /* Find prim-th root of 1, used in decoding */
100 for (iprim = 1; (iprim % prim) != 0; iprim += rs->nn)
101 ;
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 }
127done:
128 ;
129
130}
unsigned char data_t
Definition: ccsds.h:1
#define A0
Definition: char.h:20
int j
Definition: decode_rs.h:73
int i
Definition: decode_rs.h:73
data_t root[NROOTS]
Definition: decode_rs.h:78
#define NULL
Definition: init_rs.h:6
rs pad
Definition: init_rs.h:43
sr
Definition: init_rs.h:64
rs nroots
Definition: init_rs.h:97
rs fcr
Definition: init_rs.h:95
rs prim
Definition: init_rs.h:96
rs iprim
Definition: init_rs.h:102
static int modnn(struct rs *rs, int x)
Definition: rs-common.h:20
Definition: rs-common.h:7
int nn
Definition: rs-common.h:9
int nroots
Definition: rs-common.h:13
int iprim
Definition: rs-common.h:16
data_t * genpoly
Definition: rs-common.h:12
data_t * index_of
Definition: rs-common.h:11
int fcr
Definition: rs-common.h:14
int mm
Definition: rs-common.h:8
int pad
Definition: rs-common.h:17
int prim
Definition: rs-common.h:15
data_t * alpha_to
Definition: rs-common.h:10