1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
% ldpc.m
%
#{
David Rowe 2013
Octave functions for the CML LDPC library.
To install and compile CML support:
$ sudo apt-get install liboctave-dev
$ git clone [email protected]:drowe67/cml.git
$ cd cml
$ make
If you have configured codec2 with cmake -DUNITTEST=1, then you will
already have CML (e.g. under build_linux/cml), as it is used to run unit tests.
To use CML when running Octave simulations from the Octave CLI, set an
environment variable for CML_PATH in your shell or in your
codec2/octave/.octaverc file:
setenv("CML_PATH",sprintf("%s/codec2/build_linux/cml",getenv("HOME")))
#}
1;
function init_cml()
currentdir = pwd;
path_to_cml = getenv("CML_PATH");
if exist(path_to_cml, 'dir') == 7
cd(path_to_cml)
CmlStartup
cd(currentdir);
else
printf("\n---------------------------------------------------\n");
printf("Can't start CML in path: %s\n", path_to_cml);
printf("See CML_PATH instructions at top of this script (ldpc.m)\n");
printf("-----------------------------------------------------\n\n");
assert(0);
end
end
% init using built in WiMax or DVSB2 code
function code_param = ldpc_init_builtin(code, rate, framesize, modulation, mod_order, mapping, constellation)
if strcmp(code,'wimax')
[code_param.H_rows, code_param.H_cols, code_param.P_matrix] = InitializeWiMaxLDPC( rate, framesize, 0 );
end
if strcmp(code,'dvbs2')
[code_param.H_rows, code_param.H_cols, code_param.P_matrix] = InitializeDVBS2( rate, framesize);
end
if nargin == 7
code_param.S_matrix = constellation;
else
if length(mapping) == 0
code_param.S_matrix = CreateConstellation( modulation, mod_order);
else
code_param.S_matrix = CreateConstellation( modulation, mod_order, mapping );
end
end
code_param.bits_per_symbol = log2(mod_order);
code_param.ldpc_data_bits_per_frame = length(code_param.H_cols) - length(code_param.P_matrix);
code_param.ldpc_parity_bits_per_frame = framesize - code_param.ldpc_data_bits_per_frame;
code_param.ldpc_coded_bits_per_frame = framesize;
code_param.data_bits_per_frame = code_param.ldpc_data_bits_per_frame;
code_param.coded_bits_per_frame = code_param.ldpc_coded_bits_per_frame;
code_param.coded_syms_per_frame = code_param.coded_bits_per_frame/code_param.bits_per_symbol;
endfunction
% init using user supplied code
function [code_param framesize rate] = ldpc_init_user(HRA, modulation, mod_order, mapping, constellation)
[Nr Nc] = size(HRA);
rate = (Nc-Nr)/Nc;
framesize = Nc;
[H_rows, H_cols] = Mat2Hrows(HRA);
code_param.H_rows = H_rows;
code_param.H_cols = H_cols;
code_param.P_matrix = [];
if nargin == 5
code_param.S_matrix = constellation;
else
if length(mapping) == 0
code_param.S_matrix = CreateConstellation( modulation, mod_order);
else
code_param.S_matrix = CreateConstellation( modulation, mod_order, mapping );
end
end
code_param.bits_per_symbol = log2(mod_order);
code_param.ldpc_data_bits_per_frame = length(code_param.H_cols) - length(code_param.P_matrix);
code_param.ldpc_parity_bits_per_frame = framesize - code_param.ldpc_data_bits_per_frame;
code_param.ldpc_coded_bits_per_frame = framesize;
% these variables support 1's stuffing (not using all data bits to lower code rate)
code_param.data_bits_per_frame = code_param.ldpc_data_bits_per_frame;
code_param.coded_bits_per_frame = code_param.ldpc_coded_bits_per_frame;
code_param.coded_syms_per_frame = code_param.coded_bits_per_frame/code_param.bits_per_symbol;
endfunction
function [codeword s] = ldpc_enc(data, code_param)
if code_param.data_bits_per_frame != code_param.ldpc_data_bits_per_frame
% optionally lower the code rate by "1's stuffing" - setting Nunused data bits to 1
Nunused = code_param.ldpc_data_bits_per_frame - code_param.data_bits_per_frame;
codeword = LdpcEncode([data ones(1,Nunused)], code_param.H_rows, code_param.P_matrix);
% remove unused data bits from codeword, as they are known to the receiver and don't need to be transmitted
codeword = [ codeword(1:code_param.data_bits_per_frame) codeword(code_param.ldpc_data_bits_per_frame+1:end) ];
else
codeword = LdpcEncode( data, code_param.H_rows, code_param.P_matrix );
end
s = Modulate( codeword, code_param.S_matrix );
endfunction
function [detected_data paritychecks] = ldpc_dec(code_param, max_iterations, ...
demod_type, decoder_type, r, ...
EsNo, fading)
% handle "1's stuffing" case where we don't use all data bits
Nunused = code_param.ldpc_data_bits_per_frame - code_param.data_bits_per_frame;
symbol_likelihood = Demod2D( r, code_param.S_matrix, EsNo, fading);
% initialize the extrinsic decoder input
input_somap_c = zeros(1, code_param.ldpc_coded_bits_per_frame - Nunused);
bit_likelihood = Somap( symbol_likelihood, demod_type, input_somap_c );
input_decoder_c = bit_likelihood(1:(code_param.ldpc_coded_bits_per_frame-Nunused));
% insert "very likely" LLRs for unsed data bits (in 1's stuffing case)
input_decoder_c = [input_decoder_c(1:code_param.data_bits_per_frame) ...
100*ones(1,Nunused) ...
input_decoder_c(code_param.data_bits_per_frame+1:end)];
[x_hat paritychecks] = MpDecode( -input_decoder_c, code_param.H_rows, code_param.H_cols, ...
max_iterations, decoder_type, 1, 1);
[mx mx_ind] = max(paritychecks);
detected_data = x_hat(mx_ind,:);
endfunction
% Packs a binary array into an array of 8 bit bytes, MSB first
function packed = packmsb(unpacked)
packed = zeros(1,floor(length(unpacked)+7)/8);
bit = 7; byte = 1;
for i=1:length(unpacked)
packed(byte) = bitor(packed(byte), bitshift(unpacked(i),bit));
bit--;
if (bit < 0)
bit = 7;
byte++;
end
end
endfunction
% unpacks an array of 8 bit bytes into a binary array of unpacked bits, MSB first
function unpacked = unpackmsb(packed)
bit = 7; byte = 1;
for i=1:length(packed)*8
unpacked(i) = bitand(bitshift(packed(byte), -bit), 1);
bit--;
if (bit < 0)
bit = 7;
byte++;
end
end
endfunction
% symbol interleaver that acts on bits 2 at a time
function y = interleave_bits(interleaver, x)
y = zeros(1,length(x));
for i = 1:length(interleaver)
dst = interleaver(i);
y(2*(dst-1)+1:2*dst) = x(2*(i-1)+1:2*(i));
end
endfunction
% symbol de-interleaver
function x = deinterleave_symbols(interleaver, y)
for i = 1:length(interleaver)
x(i) = y(interleaver(i));
end
endfunction
|
