1 /*
2 * SpanDSP - a series of DSP components for telephony
3 *
4 * g711.h - In line A-law and u-law conversion routines
5 *
6 * Written by Steve Underwood <steveu@coppice.org>
7 *
8 * Copyright (C) 2001 Steve Underwood
9 *
10 * Despite my general liking of the GPL, I place this code in the
11 * public domain for the benefit of all mankind - even the slimy
12 * ones who might try to proprietize my work and use it to my
13 * detriment.
14 *
15 * $Id: g711.h,v 1.1 2006/06/07 15:46:39 steveu Exp $
16 *
17 * Modifications for WebRtc, 2011/04/28, by tlegrand:
18 * -Changed to use WebRtc types
19 * -Changed __inline__ to __inline
20 * -Two changes to make implementation bitexact with ITU-T reference implementation
21 */
22
23 /*! \page g711_page A-law and mu-law handling
24 Lookup tables for A-law and u-law look attractive, until you consider the impact
25 on the CPU cache. If it causes a substantial area of your processor cache to get
26 hit too often, cache sloshing will severely slow things down. The main reason
27 these routines are slow in C, is the lack of direct access to the CPU's "find
28 the first 1" instruction. A little in-line assembler fixes that, and the
29 conversion routines can be faster than lookup tables, in most real world usage.
30 A "find the first 1" instruction is available on most modern CPUs, and is a
31 much underused feature.
32
33 If an assembly language method of bit searching is not available, these routines
34 revert to a method that can be a little slow, so the cache thrashing might not
35 seem so bad :(
36
37 Feel free to submit patches to add fast "find the first 1" support for your own
38 favourite processor.
39
40 Look up tables are used for transcoding between A-law and u-law, since it is
41 difficult to achieve the precise transcoding procedure laid down in the G.711
42 specification by other means.
43 */
44
45 #if !defined(_G711_H_)
46 #define _G711_H_
47
48 #ifdef __cplusplus
49 extern "C" {
50 #endif
51
52 #include "webrtc/typedefs.h"
53
54 #if defined(__i386__)
55 /*! \brief Find the bit position of the highest set bit in a word
56 \param bits The word to be searched
57 \return The bit number of the highest set bit, or -1 if the word is zero. */
top_bit(unsigned int bits)58 static __inline__ int top_bit(unsigned int bits) {
59 int res;
60
61 __asm__ __volatile__(" movl $-1,%%edx;\n"
62 " bsrl %%eax,%%edx;\n"
63 : "=d" (res)
64 : "a" (bits));
65 return res;
66 }
67
68 /*! \brief Find the bit position of the lowest set bit in a word
69 \param bits The word to be searched
70 \return The bit number of the lowest set bit, or -1 if the word is zero. */
bottom_bit(unsigned int bits)71 static __inline__ int bottom_bit(unsigned int bits) {
72 int res;
73
74 __asm__ __volatile__(" movl $-1,%%edx;\n"
75 " bsfl %%eax,%%edx;\n"
76 : "=d" (res)
77 : "a" (bits));
78 return res;
79 }
80 #elif defined(__x86_64__)
81 static __inline__ int top_bit(unsigned int bits) {
82 int res;
83
84 __asm__ __volatile__(" movq $-1,%%rdx;\n"
85 " bsrq %%rax,%%rdx;\n"
86 : "=d" (res)
87 : "a" (bits));
88 return res;
89 }
90
91 static __inline__ int bottom_bit(unsigned int bits) {
92 int res;
93
94 __asm__ __volatile__(" movq $-1,%%rdx;\n"
95 " bsfq %%rax,%%rdx;\n"
96 : "=d" (res)
97 : "a" (bits));
98 return res;
99 }
100 #else
101 static __inline int top_bit(unsigned int bits) {
102 int i;
103
104 if (bits == 0) {
105 return -1;
106 }
107 i = 0;
108 if (bits & 0xFFFF0000) {
109 bits &= 0xFFFF0000;
110 i += 16;
111 }
112 if (bits & 0xFF00FF00) {
113 bits &= 0xFF00FF00;
114 i += 8;
115 }
116 if (bits & 0xF0F0F0F0) {
117 bits &= 0xF0F0F0F0;
118 i += 4;
119 }
120 if (bits & 0xCCCCCCCC) {
121 bits &= 0xCCCCCCCC;
122 i += 2;
123 }
124 if (bits & 0xAAAAAAAA) {
125 bits &= 0xAAAAAAAA;
126 i += 1;
127 }
128 return i;
129 }
130
131 static __inline int bottom_bit(unsigned int bits) {
132 int i;
133
134 if (bits == 0) {
135 return -1;
136 }
137 i = 32;
138 if (bits & 0x0000FFFF) {
139 bits &= 0x0000FFFF;
140 i -= 16;
141 }
142 if (bits & 0x00FF00FF) {
143 bits &= 0x00FF00FF;
144 i -= 8;
145 }
146 if (bits & 0x0F0F0F0F) {
147 bits &= 0x0F0F0F0F;
148 i -= 4;
149 }
150 if (bits & 0x33333333) {
151 bits &= 0x33333333;
152 i -= 2;
153 }
154 if (bits & 0x55555555) {
155 bits &= 0x55555555;
156 i -= 1;
157 }
158 return i;
159 }
160 #endif
161
162 /* N.B. It is tempting to use look-up tables for A-law and u-law conversion.
163 * However, you should consider the cache footprint.
164 *
165 * A 64K byte table for linear to x-law and a 512 byte table for x-law to
166 * linear sound like peanuts these days, and shouldn't an array lookup be
167 * real fast? No! When the cache sloshes as badly as this one will, a tight
168 * calculation may be better. The messiest part is normally finding the
169 * segment, but a little inline assembly can fix that on an i386, x86_64 and
170 * many other modern processors.
171 */
172
173 /*
174 * Mu-law is basically as follows:
175 *
176 * Biased Linear Input Code Compressed Code
177 * ------------------------ ---------------
178 * 00000001wxyza 000wxyz
179 * 0000001wxyzab 001wxyz
180 * 000001wxyzabc 010wxyz
181 * 00001wxyzabcd 011wxyz
182 * 0001wxyzabcde 100wxyz
183 * 001wxyzabcdef 101wxyz
184 * 01wxyzabcdefg 110wxyz
185 * 1wxyzabcdefgh 111wxyz
186 *
187 * Each biased linear code has a leading 1 which identifies the segment
188 * number. The value of the segment number is equal to 7 minus the number
189 * of leading 0's. The quantization interval is directly available as the
190 * four bits wxyz. * The trailing bits (a - h) are ignored.
191 *
192 * Ordinarily the complement of the resulting code word is used for
193 * transmission, and so the code word is complemented before it is returned.
194 *
195 * For further information see John C. Bellamy's Digital Telephony, 1982,
196 * John Wiley & Sons, pps 98-111 and 472-476.
197 */
198
199 //#define ULAW_ZEROTRAP /* turn on the trap as per the MIL-STD */
200 #define ULAW_BIAS 0x84 /* Bias for linear code. */
201
202 /*! \brief Encode a linear sample to u-law
203 \param linear The sample to encode.
204 \return The u-law value.
205 */
linear_to_ulaw(int linear)206 static __inline uint8_t linear_to_ulaw(int linear) {
207 uint8_t u_val;
208 int mask;
209 int seg;
210
211 /* Get the sign and the magnitude of the value. */
212 if (linear < 0) {
213 /* WebRtc, tlegrand: -1 added to get bitexact to reference implementation */
214 linear = ULAW_BIAS - linear - 1;
215 mask = 0x7F;
216 } else {
217 linear = ULAW_BIAS + linear;
218 mask = 0xFF;
219 }
220
221 seg = top_bit(linear | 0xFF) - 7;
222
223 /*
224 * Combine the sign, segment, quantization bits,
225 * and complement the code word.
226 */
227 if (seg >= 8)
228 u_val = (uint8_t)(0x7F ^ mask);
229 else
230 u_val = (uint8_t)(((seg << 4) | ((linear >> (seg + 3)) & 0xF)) ^ mask);
231 #ifdef ULAW_ZEROTRAP
232 /* Optional ITU trap */
233 if (u_val == 0)
234 u_val = 0x02;
235 #endif
236 return u_val;
237 }
238
239 /*! \brief Decode an u-law sample to a linear value.
240 \param ulaw The u-law sample to decode.
241 \return The linear value.
242 */
ulaw_to_linear(uint8_t ulaw)243 static __inline int16_t ulaw_to_linear(uint8_t ulaw) {
244 int t;
245
246 /* Complement to obtain normal u-law value. */
247 ulaw = ~ulaw;
248 /*
249 * Extract and bias the quantization bits. Then
250 * shift up by the segment number and subtract out the bias.
251 */
252 t = (((ulaw & 0x0F) << 3) + ULAW_BIAS) << (((int) ulaw & 0x70) >> 4);
253 return (int16_t)((ulaw & 0x80) ? (ULAW_BIAS - t) : (t - ULAW_BIAS));
254 }
255
256 /*
257 * A-law is basically as follows:
258 *
259 * Linear Input Code Compressed Code
260 * ----------------- ---------------
261 * 0000000wxyza 000wxyz
262 * 0000001wxyza 001wxyz
263 * 000001wxyzab 010wxyz
264 * 00001wxyzabc 011wxyz
265 * 0001wxyzabcd 100wxyz
266 * 001wxyzabcde 101wxyz
267 * 01wxyzabcdef 110wxyz
268 * 1wxyzabcdefg 111wxyz
269 *
270 * For further information see John C. Bellamy's Digital Telephony, 1982,
271 * John Wiley & Sons, pps 98-111 and 472-476.
272 */
273
274 #define ALAW_AMI_MASK 0x55
275
276 /*! \brief Encode a linear sample to A-law
277 \param linear The sample to encode.
278 \return The A-law value.
279 */
linear_to_alaw(int linear)280 static __inline uint8_t linear_to_alaw(int linear) {
281 int mask;
282 int seg;
283
284 if (linear >= 0) {
285 /* Sign (bit 7) bit = 1 */
286 mask = ALAW_AMI_MASK | 0x80;
287 } else {
288 /* Sign (bit 7) bit = 0 */
289 mask = ALAW_AMI_MASK;
290 /* WebRtc, tlegrand: Changed from -8 to -1 to get bitexact to reference
291 * implementation */
292 linear = -linear - 1;
293 }
294
295 /* Convert the scaled magnitude to segment number. */
296 seg = top_bit(linear | 0xFF) - 7;
297 if (seg >= 8) {
298 if (linear >= 0) {
299 /* Out of range. Return maximum value. */
300 return (uint8_t)(0x7F ^ mask);
301 }
302 /* We must be just a tiny step below zero */
303 return (uint8_t)(0x00 ^ mask);
304 }
305 /* Combine the sign, segment, and quantization bits. */
306 return (uint8_t)(((seg << 4) | ((linear >> ((seg) ? (seg + 3) : 4)) & 0x0F)) ^
307 mask);
308 }
309
310 /*! \brief Decode an A-law sample to a linear value.
311 \param alaw The A-law sample to decode.
312 \return The linear value.
313 */
alaw_to_linear(uint8_t alaw)314 static __inline int16_t alaw_to_linear(uint8_t alaw) {
315 int i;
316 int seg;
317
318 alaw ^= ALAW_AMI_MASK;
319 i = ((alaw & 0x0F) << 4);
320 seg = (((int) alaw & 0x70) >> 4);
321 if (seg)
322 i = (i + 0x108) << (seg - 1);
323 else
324 i += 8;
325 return (int16_t)((alaw & 0x80) ? i : -i);
326 }
327
328 /*! \brief Transcode from A-law to u-law, using the procedure defined in G.711.
329 \param alaw The A-law sample to transcode.
330 \return The best matching u-law value.
331 */
332 uint8_t alaw_to_ulaw(uint8_t alaw);
333
334 /*! \brief Transcode from u-law to A-law, using the procedure defined in G.711.
335 \param alaw The u-law sample to transcode.
336 \return The best matching A-law value.
337 */
338 uint8_t ulaw_to_alaw(uint8_t ulaw);
339
340 #ifdef __cplusplus
341 }
342 #endif
343
344 #endif
345