2 * Copyright © 2012 Keith Packard <keithp@keithp.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 2 of the License.
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22 * 'input' is 8-bits per symbol soft decision data
23 * 'len' is output byte length
30 static const struct ao_soft_sym ao_fec_decode_table[16] = {
32 { 0x00, 0x00 }, { 0xff, 0xff }, /* 000 */
33 { 0x00, 0xff }, { 0xff, 0x00 }, /* 001 */
34 { 0xff, 0xff }, { 0x00, 0x00 }, /* 010 */
35 { 0xff, 0x00 }, { 0x00, 0xff }, /* 011 */
36 { 0xff, 0xff }, { 0x00, 0x00 }, /* 100 */
37 { 0xff, 0x00 }, { 0x00, 0xff }, /* 101 */
38 { 0x00, 0x00 }, { 0xff, 0xff }, /* 110 */
39 { 0x00, 0xff }, { 0xff, 0x00 } /* 111 */
43 ao_soft_sym(uint8_t bits)
47 s.a = ((bits & 2) >> 1) * 0xff;
48 s.b = (bits & 1) * 0xff;
53 ao_next_state(uint8_t state, uint8_t bit)
55 return ((state << 1) | bit) & 0x7;
58 static inline uint16_t ao_abs(int16_t x) { return x < 0 ? -x : x; }
60 static inline uint16_t
61 ao_cost(struct ao_soft_sym a, struct ao_soft_sym b)
63 return ao_abs(a.a - b.a) + ao_abs(a.b - b.b);
69 ao_fec_decode(uint8_t *in, int len, uint8_t *out)
71 uint16_t cost[2][NUM_STATE], min_cost;
72 uint8_t prev[len/2 + 1][NUM_STATE];
73 uint16_t prev_bits[2][NUM_STATE];
76 uint8_t state = 0, min_state;
79 for (state = 0; state < NUM_STATE; state++) {
80 cost[0][state] = 0xffff;
81 prev_bits[0][state] = 0;
88 for (i = 0; i < len; i += 2) {
91 struct ao_soft_sym s = { .a = in[i], .b = in[i+1] };
93 for (state = 0; state < NUM_STATE; state++)
94 cost[n][state] = 0xffff;
96 for (state = 0; state < NUM_STATE; state++) {
97 int zero_cost = ao_cost(s, ao_fec_decode_table[state * 2 + 0]);
98 int one_cost = ao_cost(s, ao_fec_decode_table[state * 2 + 1]);
100 uint8_t zero_state = ao_next_state(state, 0);
101 uint8_t one_state = ao_next_state(state, 1);
103 zero_cost += cost[p][state];
104 one_cost += cost[p][state];
105 if (zero_cost < cost[n][zero_state]) {
106 prev[b+1][zero_state] = state;
107 cost[n][zero_state] = zero_cost;
108 prev_bits[n][zero_state] = (prev_bits[p][state] << 1) | (state & 1);
111 if (one_cost < cost[n][one_state]) {
112 prev[b+1][one_state] = state;
113 cost[n][one_state] = one_cost;
114 prev_bits[n][one_state] = (prev_bits[p][state] << 1) | (state & 1);
119 printf ("bit %3d symbol %2x %2x:", i/2, s.a, s.b);
120 for (state = 0; state < NUM_STATE; state++) {
121 printf (" %5d(%04x)", cost[n][state], prev_bits[n][state]);
128 if ((b - dump) > 16 || i + 2 >= len) {
129 uint8_t dist = b - (dump + 9);
131 min_cost = cost[p][0];
133 for (state = 1; state < NUM_STATE; state++) {
134 if (cost[p][state] < min_cost) {
135 min_cost = cost[p][state];
139 for (rev = 0; rev < dist; rev++) {
140 min_state = prev[b][min_state];
144 printf ("\tbit %3d min_cost %5d old bit %3d old_state %x bits %02x\n",
145 i/2, min_cost, b-1, min_state, (prev_bits[p][min_state] >> dist) & 0xff);
147 out[dump/8] = prev_bits[p][min_state] >> dist;