Mercurial > hg > audiostuff
comparison spandsp-0.0.6pre17/src/spandsp/v17rx.h @ 4:26cd8f1ef0b1
import spandsp-0.0.6pre17
author | Peter Meerwald <pmeerw@cosy.sbg.ac.at> |
---|---|
date | Fri, 25 Jun 2010 15:50:58 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
3:c6c5a16ce2f2 | 4:26cd8f1ef0b1 |
---|---|
1 /* | |
2 * SpanDSP - a series of DSP components for telephony | |
3 * | |
4 * v17rx.h - ITU V.17 modem receive part | |
5 * | |
6 * Written by Steve Underwood <steveu@coppice.org> | |
7 * | |
8 * Copyright (C) 2003 Steve Underwood | |
9 * | |
10 * All rights reserved. | |
11 * | |
12 * This program is free software; you can redistribute it and/or modify | |
13 * it under the terms of the GNU Lesser General Public License version 2.1, | |
14 * as published by the Free Software Foundation. | |
15 * | |
16 * This program is distributed in the hope that it will be useful, | |
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 * GNU Lesser General Public License for more details. | |
20 * | |
21 * You should have received a copy of the GNU Lesser General Public | |
22 * License along with this program; if not, write to the Free Software | |
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
24 * | |
25 * $Id: v17rx.h,v 1.65 2009/07/09 13:52:09 steveu Exp $ | |
26 */ | |
27 | |
28 /*! \file */ | |
29 | |
30 #if !defined(_SPANDSP_V17RX_H_) | |
31 #define _SPANDSP_V17RX_H_ | |
32 | |
33 /*! \page v17rx_page The V.17 receiver | |
34 \section v17rx_page_sec_1 What does it do? | |
35 The V.17 receiver implements the receive side of a V.17 modem. This can operate | |
36 at data rates of 14400, 12000, 9600 and 7200 bits/second. The audio input is a stream | |
37 of 16 bit samples, at 8000 samples/second. The transmit and receive side of V.17 | |
38 modems operate independantly. V.17 is mostly used for FAX transmission over PSTN | |
39 lines, where it provides the standard 14400 bits/second rate. | |
40 | |
41 \section v17rx_page_sec_2 How does it work? | |
42 V.17 uses QAM modulation, at 2400 baud, and trellis coding. Constellations with | |
43 16, 32, 64, and 128 points are defined. After one bit per baud is absorbed by the | |
44 trellis coding, this gives usable bit rates of 7200, 9600, 12000, and 14400 per | |
45 second. | |
46 | |
47 V.17 specifies a training sequence at the start of transmission, which makes the | |
48 design of a V.17 receiver relatively straightforward. The first stage of the | |
49 training sequence consists of 256 | |
50 symbols, alternating between two constellation positions. The receiver monitors | |
51 the signal power, to sense the possible presence of a valid carrier. When the | |
52 alternating signal begins, the power rising above a minimum threshold (-43dBm0) | |
53 causes the main receiver computation to begin. The initial measured power is | |
54 used to quickly set the gain of the receiver. After this initial settling, the | |
55 front end gain is locked, and the adaptive equalizer tracks any subsequent | |
56 signal level variation. The signal is oversampled to 24000 samples/second (i.e. | |
57 signal, zero, zero, signal, zero, zero, ...) and fed to a complex root raised | |
58 cosine pulse shaping filter. This filter has been modified from the conventional | |
59 root raised cosine filter, by shifting it up the band, to be centred at the nominal | |
60 carrier frequency. This filter interpolates the samples, pulse shapes, and performs | |
61 a fractional sample delay at the same time. 192 sets of filter coefficients are used | |
62 to achieve a set of finely spaces fractional sample delays, between zero and | |
63 one sample. By choosing every fifth sample, and the appropriate set of filter | |
64 coefficients, the properly tuned symbol tracker can select data samples at 4800 | |
65 samples/second from points within 0.28 degrees of the centre and mid-points of | |
66 each symbol. The output of the filter is multiplied by a complex carrier, generated | |
67 by a DDS. The result is a baseband signal, requiring no further filtering, apart from | |
68 an adaptive equalizer. The baseband signal is fed to a T/2 adaptive equalizer. | |
69 A band edge component maximisation algorithm is used to tune the sampling, so the samples | |
70 fed to the equalizer are close to the mid point and edges of each symbol. Initially | |
71 the algorithm is very lightly damped, to ensure the symbol alignment pulls in | |
72 quickly. Because the sampling rate will not be precisely the same as the | |
73 transmitter's (the spec. says the symbol timing should be within 0.01%), the | |
74 receiver constantly evaluates and corrects this sampling throughout its | |
75 operation. During the symbol timing maintainence phase, the algorithm uses | |
76 a heavier damping. | |
77 | |
78 The carrier is specified as 1800Hz +- 1Hz at the transmitter, and 1800 +-7Hz at | |
79 the receiver. The receive carrier would only be this inaccurate if the link | |
80 includes FDM sections. These are being phased out, but the design must still | |
81 allow for the worst case. Using an initial 1800Hz signal for demodulation gives | |
82 a worst case rotation rate for the constellation of about one degree per symbol. | |
83 Once the symbol timing synchronisation algorithm has been given time to lock to the | |
84 symbol timing of the initial alternating pattern, the phase of the demodulated signal | |
85 is recorded on two successive symbols - once for each of the constellation positions. | |
86 The receiver then tracks the symbol alternations, until a large phase jump occurs. | |
87 This signifies the start of the next phase of the training sequence. At this | |
88 point the total phase shift between the original recorded symbol phase, and the | |
89 symbol phase just before the phase jump occurred is used to provide a coarse | |
90 estimation of the rotation rate of the constellation, and it current absolute | |
91 angle of rotation. These are used to update the current carrier phase and phase | |
92 update rate in the carrier DDS. The working data already in the pulse shaping | |
93 filter and equalizer buffers is given a similar step rotation to pull it all | |
94 into line. From this point on, a heavily damped integrate and dump approach, | |
95 based on the angular difference between each received constellation position and | |
96 its expected position, is sufficient to track the carrier, and maintain phase | |
97 alignment. A fast rough approximator for the arc-tangent function is adequate | |
98 for the estimation of the angular error. | |
99 | |
100 The next phase of the training sequence is a scrambled sequence of two | |
101 particular symbols. We train the T/2 adaptive equalizer using this sequence. The | |
102 scrambling makes the signal sufficiently diverse to ensure the equalizer | |
103 converges to the proper generalised solution. At the end of this sequence, the | |
104 equalizer should be sufficiently well adapted that is can correctly resolve the | |
105 full QAM constellation. However, the equalizer continues to adapt throughout | |
106 operation of the modem, fine tuning on the more complex data patterns of the | |
107 full QAM constellation. | |
108 | |
109 In the last phase of the training sequence, the modem enters normal data | |
110 operation, with a short defined period of all ones as data. As in most high | |
111 speed modems, data in a V.17 modem passes through a scrambler, to whiten the | |
112 spectrum of the signal. The transmitter should initialise its data scrambler, | |
113 and pass the ones through it. At the end of the ones, real data begins to pass | |
114 through the scrambler, and the transmit modem is in normal operation. The | |
115 receiver tests that ones are really received, in order to verify the modem | |
116 trained correctly. If all is well, the data following the ones is fed to the | |
117 application, and the receive modem is up and running. Unfortunately, some | |
118 transmit side of some real V.17 modems fail to initialise their scrambler before | |
119 sending the ones. This means the first 23 received bits (the length of the | |
120 scrambler register) cannot be trusted for the test. The receive modem, | |
121 therefore, only tests that bits starting at bit 24 are really ones. | |
122 | |
123 The V.17 signal is trellis coded. Two bits of each symbol are convolutionally coded | |
124 to form a 3 bit trellis code - the two original bits, plus an extra redundant bit. It | |
125 is possible to ignore the trellis coding, and just decode the non-redundant bits. | |
126 However, the noise performance of the receiver would suffer. Using a proper | |
127 trellis decoder adds several dB to the noise tolerance to the receiving modem. Trellis | |
128 coding seems quite complex at first sight, but is fairly straightforward once you | |
129 get to grips with it. | |
130 | |
131 Trellis decoding tracks the data in terms of the possible states of the convolutional | |
132 coder at the transmitter. There are 8 possible states of the V.17 coder. The first | |
133 step in trellis decoding is to find the best candidate constellation point | |
134 for each of these 8 states. One of thse will be our final answer. The constellation | |
135 has been designed so groups of 8 are spread fairly evenly across it. Locating them | |
136 is achieved is a reasonably fast manner, by looking up the answers in a set of space | |
137 map tables. The disadvantage is the tables are potentially large enough to affect | |
138 cache performance. The trellis decoder works over 16 successive symbols. The result | |
139 of decoding is not known until 16 symbols after the data enters the decoder. The | |
140 minimum total accumulated mismatch between each received point and the actual | |
141 constellation (termed the distance) is assessed for each of the 8 states. A little | |
142 analysis of the coder shows that each of the 8 current states could be arrived at | |
143 from 4 different previous states, through 4 different constellation bit patterns. | |
144 For each new state, the running total distance is arrived at by inspecting a previous | |
145 total plus a new distance for the appropriate 4 previous states. The minimum of the 4 | |
146 values becomes the new distance for the state. Clearly, a mechanism is needed to stop | |
147 this distance from growing indefinitely. A sliding window, and several other schemes | |
148 are possible. However, a simple single pole IIR is very simple, and provides adequate | |
149 results. | |
150 | |
151 For each new state we store the constellation bit pattern, or path, to that state, and | |
152 the number of the previous state. We find the minimum distance amongst the 8 new | |
153 states for each new symbol. We then trace back through the states, until we reach the | |
154 one 16 states ago which leads to the current minimum distance. The bit pattern stored | |
155 there is the error corrected bit pattern for that symbol. | |
156 | |
157 So, what does Trellis coding actually achieve? TCM is easier to understand by looking | |
158 at the V.23bis modem spec. The V.32bis spec. is very similar to V.17, except that it | |
159 is a full duplex modem and has non-TCM options, as well as the TCM ones in V.17. | |
160 | |
161 V32bis defines two options for pumping 9600 bits per second down a phone line - one | |
162 with and one without TCM. Both run at 2400 baud. The non-TCM one uses simple 16 point | |
163 QAM on the raw data. The other takes two out of every four raw bits, and convolutionally | |
164 encodes them to 3. Now we have 5 bits per symbol, and we need 32 point QAM to send the | |
165 data. | |
166 | |
167 The raw error rate from simple decoding of the 32 point QAM is horrible compared to | |
168 decoding the 16 point QAM. If a point decoded from the 32 point QAM is wrong, the likely | |
169 correct choice should be one of the adjacent ones. It is unlikely to have been one that | |
170 is far away across the constellation, unless there was a huge noise spike, interference, | |
171 or something equally nasty. Now, the 32 point symbols do not exist in isolation. There | |
172 was a kind of temporal smearing in the convolutional coding. It created a well defined | |
173 dependency between successive symbols. If we knew for sure what the last few symbols | |
174 were, they would lead us to a limited group of possible values for the current symbol, | |
175 constrained by the behaviour of the convolutional coder. If you look at how the symbols | |
176 were mapped to constellation points, you will see the mapping tries to spread those | |
177 possible symbols as far apart as possible. This will leave only one that is pretty | |
178 close to the received point, which must be the correct choice. However, this assumes | |
179 we know the last few symbols for sure. Since we don't, we have a bit more work to do | |
180 to achieve reliable decoding. | |
181 | |
182 Instead of decoding to the nearest point on the constellation, we decode to a group of | |
183 likely constellation points in the neighbourhood of the received point. We record the | |
184 mismatch for each - that is the distance across the constellation between the received | |
185 point and the group of nearby points. To avoid square roots, recording x2 + y2 can be | |
186 good enough. Symbol by symbol, we record this information. After a few symbols we can | |
187 stand back and look at the recorded information. | |
188 | |
189 For each symbol we have a set of possible symbol values and error metric pairs. The | |
190 dependency between symbols, created by the convolutional coder, means some paths from | |
191 symbol to symbol are possible and some are not. It we trace back through the possible | |
192 symbol to symbol paths, and total up the error metric through those paths, we end up | |
193 with a set of figures of merit (or more accurately figures of demerit, since | |
194 larger == worse) for the likelihood of each path being the correct one. The path with | |
195 the lowest total metric is the most likely, and gives us our final choice for what we | |
196 think the current symbol really is. | |
197 | |
198 That was hard work. It takes considerable computation to do this selection and traceback, | |
199 symbol by symbol. We need to get quite a lot from this. It needs to drive the error rate | |
200 down so far that is compensates for the much higher error rate due to the larger | |
201 constellation, and then buys us some actual benefit. Well in the example we are looking | |
202 at - V.32bis at 9600bps - it works out the error rate from the TCM option is like using | |
203 the non-TCM option with several dB more signal to noise ratio. That's nice. The non-TCM | |
204 option is pretty reasonable on most phone lines, but a better error rate is always a | |
205 good thing. However, V32bis includes a 14,400bps option. That uses 2400 baud, and 6 bit | |
206 symbols. Convolutional encoding increases that to 7 bits per symbol, by taking 2 bits and | |
207 encoding them to 3. This give a 128 point QAM constellation. Again, the difference between | |
208 using this, and using just an uncoded 64 point constellation is equivalent to maybe 5dB of | |
209 extra signal to noise ratio. However, in this case it is the difference between the modem | |
210 working only on the most optimal lines, and being widely usable across most phone lines. | |
211 TCM absolutely transformed the phone line modem business. | |
212 */ | |
213 | |
214 /*! | |
215 V.17 modem receive side descriptor. This defines the working state for a | |
216 single instance of a V.17 modem receiver. | |
217 */ | |
218 typedef struct v17_rx_state_s v17_rx_state_t; | |
219 | |
220 #if defined(__cplusplus) | |
221 extern "C" | |
222 { | |
223 #endif | |
224 | |
225 /*! Initialise a V.17 modem receive context. | |
226 \brief Initialise a V.17 modem receive context. | |
227 \param s The modem context. | |
228 \param bit_rate The bit rate of the modem. Valid values are 7200, 9600, 12000 and 14400. | |
229 \param put_bit The callback routine used to put the received data. | |
230 \param user_data An opaque pointer passed to the put_bit routine. | |
231 \return A pointer to the modem context, or NULL if there was a problem. */ | |
232 SPAN_DECLARE(v17_rx_state_t *) v17_rx_init(v17_rx_state_t *s, int bit_rate, put_bit_func_t put_bit, void *user_data); | |
233 | |
234 /*! Reinitialise an existing V.17 modem receive context. | |
235 \brief Reinitialise an existing V.17 modem receive context. | |
236 \param s The modem context. | |
237 \param bit_rate The bit rate of the modem. Valid values are 7200, 9600, 12000 and 14400. | |
238 \param short_train TRUE if a short training sequence is expected. | |
239 \return 0 for OK, -1 for bad parameter */ | |
240 SPAN_DECLARE(int) v17_rx_restart(v17_rx_state_t *s, int bit_rate, int short_train); | |
241 | |
242 /*! Release a V.17 modem receive context. | |
243 \brief Release a V.17 modem receive context. | |
244 \param s The modem context. | |
245 \return 0 for OK */ | |
246 SPAN_DECLARE(int) v17_rx_release(v17_rx_state_t *s); | |
247 | |
248 /*! Free a V.17 modem receive context. | |
249 \brief Free a V.17 modem receive context. | |
250 \param s The modem context. | |
251 \return 0 for OK */ | |
252 SPAN_DECLARE(int) v17_rx_free(v17_rx_state_t *s); | |
253 | |
254 /*! Get the logging context associated with a V.17 modem receive context. | |
255 \brief Get the logging context associated with a V.17 modem receive context. | |
256 \param s The modem context. | |
257 \return A pointer to the logging context */ | |
258 SPAN_DECLARE(logging_state_t *) v17_rx_get_logging_state(v17_rx_state_t *s); | |
259 | |
260 /*! Change the put_bit function associated with a V.17 modem receive context. | |
261 \brief Change the put_bit function associated with a V.17 modem receive context. | |
262 \param s The modem context. | |
263 \param put_bit The callback routine used to handle received bits. | |
264 \param user_data An opaque pointer. */ | |
265 SPAN_DECLARE(void) v17_rx_set_put_bit(v17_rx_state_t *s, put_bit_func_t put_bit, void *user_data); | |
266 | |
267 /*! Change the modem status report function associated with a V.17 modem receive context. | |
268 \brief Change the modem status report function associated with a V.17 modem receive context. | |
269 \param s The modem context. | |
270 \param handler The callback routine used to report modem status changes. | |
271 \param user_data An opaque pointer. */ | |
272 SPAN_DECLARE(void) v17_rx_set_modem_status_handler(v17_rx_state_t *s, modem_rx_status_func_t handler, void *user_data); | |
273 | |
274 /*! Process a block of received V.17 modem audio samples. | |
275 \brief Process a block of received V.17 modem audio samples. | |
276 \param s The modem context. | |
277 \param amp The audio sample buffer. | |
278 \param len The number of samples in the buffer. | |
279 \return The number of samples unprocessed. | |
280 */ | |
281 SPAN_DECLARE_NONSTD(int) v17_rx(v17_rx_state_t *s, const int16_t amp[], int len); | |
282 | |
283 /*! Fake processing of a missing block of received V.17 modem audio samples. | |
284 (e.g due to packet loss). | |
285 \brief Fake processing of a missing block of received V.17 modem audio samples. | |
286 \param s The modem context. | |
287 \param len The number of samples to fake. | |
288 \return The number of samples unprocessed. | |
289 */ | |
290 SPAN_DECLARE(int) v17_rx_fillin(v17_rx_state_t *s, int len); | |
291 | |
292 /*! Get a snapshot of the current equalizer coefficients. | |
293 \brief Get a snapshot of the current equalizer coefficients. | |
294 \param s The modem context. | |
295 \param coeffs The vector of complex coefficients. | |
296 \return The number of coefficients in the vector. */ | |
297 #if defined(SPANDSP_USE_FIXED_POINTx) | |
298 SPAN_DECLARE(int) v17_rx_equalizer_state(v17_rx_state_t *s, complexi_t **coeffs); | |
299 #else | |
300 SPAN_DECLARE(int) v17_rx_equalizer_state(v17_rx_state_t *s, complexf_t **coeffs); | |
301 #endif | |
302 | |
303 /*! Get the current received carrier frequency. | |
304 \param s The modem context. | |
305 \return The frequency, in Hertz. */ | |
306 SPAN_DECLARE(float) v17_rx_carrier_frequency(v17_rx_state_t *s); | |
307 | |
308 /*! Get the current symbol timing correction since startup. | |
309 \param s The modem context. | |
310 \return The correction. */ | |
311 SPAN_DECLARE(float) v17_rx_symbol_timing_correction(v17_rx_state_t *s); | |
312 | |
313 /*! Get a current received signal power. | |
314 \param s The modem context. | |
315 \return The signal power, in dBm0. */ | |
316 SPAN_DECLARE(float) v17_rx_signal_power(v17_rx_state_t *s); | |
317 | |
318 /*! Set the power level at which the carrier detection will cut in | |
319 \param s The modem context. | |
320 \param cutoff The signal cutoff power, in dBm0. */ | |
321 SPAN_DECLARE(void) v17_rx_signal_cutoff(v17_rx_state_t *s, float cutoff); | |
322 | |
323 /*! Set a handler routine to process QAM status reports | |
324 \param s The modem context. | |
325 \param handler The handler routine. | |
326 \param user_data An opaque pointer passed to the handler routine. */ | |
327 SPAN_DECLARE(void) v17_rx_set_qam_report_handler(v17_rx_state_t *s, qam_report_handler_t handler, void *user_data); | |
328 | |
329 #if defined(__cplusplus) | |
330 } | |
331 #endif | |
332 | |
333 #endif | |
334 /*- End of file ------------------------------------------------------------*/ |