G711算法学习

 1 #define    SIGN_BIT    (0x80)        /* Sign bit for a A-law byte. */
 2 #define    QUANT_MASK    (0xf)        /* Quantization field mask. */
 3 #define    NSEGS        (8)            /* Number of A-law segments. */
 4 #define    SEG_SHIFT    (4)            /* Left shift for segment number. */
 5 #define    SEG_MASK    (0x70)        /* Segment field mask. */
 6 #define    BIAS        (0x84)        /* Bias for linear code. */
 7 
 8 static const int16_t seg_uend[8] = { 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF };
 9 static const int16_t seg_aend[8] = { 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF };;
10 
11 static int16_t search(int16_t val, const int16_t *table, int16_t    size)
12 {
13     int    i;
14 
15     for (i = 0; i < size; i++) {
16         if (val <= *table++)
17             return (i);
18     }
19     return (size);
20 }
21 
22 static uint8_t linear2alaw(int16_t pcm_val) /* 2‘s complement (16-bit range) */
23 {
24     int16_t  mask;
25     int16_t  seg;
26     uint8_t  aval;
27 
28     pcm_val = pcm_val >> 3;//这里右移3位，因为采样值是16bit，而A-law是13bit数据，存储在高13位上，低3位被舍弃
29 
30     if (pcm_val >= 0) {
31         mask = 0xD5;//二进制的11010101
32     }
33     else {
34         mask = 0x55;//二进制的01010101，与0xD5只有符号位的不同
35         pcm_val = -pcm_val - 1;//负数转换为正数计算
36     }
37 
38     seg = search(pcm_val, seg_aend, 8);//查找采样值对应哪一段折线
39 
40     if (seg >= 8) {
41         return (uint8_t)(0x7F);//越界时直接返回最大值
42     }
43     else {
44         //以下按照表格处理，低4位是数据，5~7位是指数，最高位是符号
45         aval = (uint8_t)seg << SEG_SHIFT;
46         if (seg < 2)
47             aval |= (pcm_val >> 1) & QUANT_MASK;
48         else
49             aval |= (pcm_val >> seg) & QUANT_MASK;
50 
51         return (aval);
52     }
53 }

 1 static int16_t alaw2linear(uint8_t a_val)
 2 {
 3     int16_t    t;
 4     int16_t    seg;
 5 
 6     a_val ^= 0x55;//异或操作把mask还原
 7 
 8     t = (a_val & QUANT_MASK) << 4;//取低4位，即上表中的abcd值，然后左移4位变成abcd0000
 9     seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;//取中间3位，指数部分
10     switch (seg)
11     {
12     case 0://表中第一行，abcd0000 -> abcd1000
13         t += 8;
14         break;
15     case 1://表中第二行，abcd0000 -> 1abcd1000
16         t += 0x108;
17         break;
18     default://表中其他行，abcd0000 -> 1abcd1000 的基础上继续左移
19         t += 0x108;
20         t <<= seg - 1;
21         break;
22     }
23     return ((a_val & SIGN_BIT) ? t : -t);
24 }

 1 static int16_t ulaw2linear(uint8_t u_val)
 2 {
 3     int16_t    t;
 4 
 5     /* Complement to obtain normal u-law value. */
 6     u_val = ~u_val;
 7 
 8     /*
 9     * Extract and bias the quantization bits. Then
10     * shift up by the segment number and subtract out the bias.
11     */
12 
13     t = ((u_val & QUANT_MASK) << 3) + BIAS;
14     t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
15 
16     return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
17 }
18 
19 static uint8_t linear2ulaw(int16_t pcm_val)    /* 2‘s complement (16-bit range) */
20 {
21     int16_t        mask;
22     int16_t        seg;
23     uint8_t        uval;
24 
25     /* Get the sign and the magnitude of the value. */
26     if (pcm_val < 0) {
27         pcm_val = BIAS - pcm_val;
28         mask = 0x7F;
29     }
30     else {
31         pcm_val += BIAS;
32         mask = 0xFF;
33     }
34 
35     /* Convert the scaled magnitude to segment number. */
36     seg = search(pcm_val, seg_uend, 8);
37 
38     /*
39     * Combine the sign, segment, quantization bits;
40     * and complement the code word.
41     */
42     if (seg >= 8)        /* out of range, return maximum value. */
43         return (0x7F ^ mask);
44     else {
45         uval = (seg << 4) | ((pcm_val >> (seg + 3)) & 0xF);
46         return (uval ^ mask);
47     }
48 }