精华内容
下载资源
问答
  • A律压缩代码

    2012-06-06 13:04:57
    A律压缩解压编码是国际电报电话协会(CCITT,Consultative Committee forInternational Telegraph and Telephone)最早推出的G.711语音压缩解压编码的一种格式的主要内容。其中欧洲和中国等国家采用A律压缩解压编码...
  • 语音信号的μ/A律压缩

    2020-11-13 08:00:54
    采用DSP可以直接对PCM编码后的语音信号进行μ律和A律压缩。  PCM编码即脉冲编码调制,也就是将模拟信号转换数码,然后再转换成二进制数字信号的方法。几种常用的二进制编码格式如表1所示。  表1 几种常用的二...
  • A律压缩编码

    2012-05-04 15:31:24
    关于A律压缩编码的实现与设计,具有参考实用价值
  • 基于FPGA快速A律压缩编码的设计与实现、电子技术,开发板制作交流
  • G.711 u律;A律 压缩算法

    千次阅读 2016-05-06 15:33:19
    A律 压缩算法   [cpp] view plain copy  print? /**********************************************************************   * g711.c   * u-law, A-law and linear ...

    G.711  u律;A律 压缩算法

     

    [cpp]  view plain  copy
     print ?
    1. /********************************************************************** 
    2.  * g711.c 
    3.  * u-law, A-law and linear PCM conversions. 
    4.  **********************************************************************/  
    5.   
    6. #define SIGN_BIT    (0x80)      /* Sign bit for a A-law byte. */  
    7. #define QUANT_MASK  (0xf)       /* Quantization field mask.   */  
    8. #define NSEGS       (8)         /* Number of A-law segments.  */  
    9. #define SEG_SHIFT   (4)         /* Left shift for segment number. */  
    10. #define SEG_MASK    (0x70)      /* Segment field mask. */  
    11.   
    12. static short seg_end[8] = {0xFF, 0x1FF, 0x3FF, 0x7FF,  
    13.                            0xFFF, 0x1FFF, 0x3FFF, 0x7FFF};  
    14.   
    15. /* copy from CCITT G.711 specifications */  
    16. unsigned char _u2a[128] = { /* u- to A-law conversions */  
    17.     1,  1,  2,  2,  3,  3,  4,  4,  
    18.     5,  5,  6,  6,  7,  7,  8,  8,  
    19.     9,  10, 11, 12, 13, 14, 15, 16,  
    20.     17, 18, 19, 20, 21, 22, 23, 24,  
    21.     25, 27, 29, 31, 33, 34, 35, 36,  
    22.     37, 38, 39, 40, 41, 42, 43, 44,  
    23.     46, 48, 49, 50, 51, 52, 53, 54,  
    24.     55, 56, 57, 58, 59, 60, 61, 62,  
    25.     64, 65, 66, 67, 68, 69, 70, 71,  
    26.     72, 73, 74, 75, 76, 77, 78, 79,  
    27.     81, 82, 83, 84, 85, 86, 87, 88,  
    28.     89, 90, 91, 92, 93, 94, 95, 96,  
    29.     97, 98, 99, 100,101,102,103,104,  
    30.     105,106,107,108,109,110,111,112,  
    31.     113,114,115,116,117,118,119,120,  
    32.     121,122,123,124,125,126,127,128  
    33. };  
    34.   
    35. unsigned char _a2u[128] = { /* A- to u-law conversions */  
    36.     1,  3,  5,  7,  9,  11, 13, 15,  
    37.     16, 17, 18, 19, 20, 21, 22, 23,  
    38.     24, 25, 26, 27, 28, 29, 30, 31,  
    39.     32, 32, 33, 33, 34, 34, 35, 35,  
    40.     36, 37, 38, 39, 40, 41, 42, 43,  
    41.     44, 45, 46, 47, 48, 48, 49, 49,  
    42.     50, 51, 52, 53, 54, 55, 56, 57,  
    43.     58, 59, 60, 61, 62, 63, 64, 64,  
    44.     65, 66, 67, 68, 69, 70, 71, 72,  
    45.     73, 74, 75, 76, 77, 78, 79, 79,  
    46.     80, 81, 82, 83, 84, 85, 86, 87,  
    47.     88, 89, 90, 91, 92, 93, 94, 95,  
    48.     96, 97, 98, 99, 100,101,102,103,  
    49.     104,105,106,107,108,109,110,111,  
    50.     112,113,114,115,116,117,118,119,  
    51.     120,121,122,123,124,125,126,127  
    52. };  
    53.   
    54. static int search(int val,short *table,int size)  
    55. {  
    56.     int     i;  
    57.     for (i = 0; i < size; i++) {  
    58.         if (val <= *table++)  
    59.             return (i);  
    60.     }  
    61.     return (size);  
    62. }  
    63.   
    64. /********************************************************************* 
    65.  * linear2alaw() - Convert a 16-bit linear PCM value to 8-bit A-law 
    66.  *   
    67.  * linear2alaw() accepts an 16-bit integer and encodes it as A-law data. 
    68.  * 
    69.  *  Linear Input Code       Compressed Code 
    70.  *  -----------------       ------------------ 
    71.  *  0000000wxyza            000wxyz 
    72.  *  0000001wxyza            001wxyz 
    73.  *  000001wxyzab            010wxyz 
    74.  *  00001wxyzabc            011wxyz 
    75.  *  0001wxyzabcd            100wxyz 
    76.  *  001wxyzabcde            101wxyz 
    77.  *  01wxyzabcdef            110wxyz 
    78.  *  1wxyzabcdefg            111wxyz 
    79.  * 
    80.  * For further information see John C. Bellamy's Digital Telephony, 1982, 
    81.  * John Wiley & Sons, pps 98-111 and 472-476. 
    82.  *********************************************************************/  
    83. unsigned char linear2alaw(int pcm_val)  /* 2's complement (16-bit range) */  
    84. {  
    85.     int             mask;  
    86.     int             seg;  
    87.     unsigned char   aval;  
    88.   
    89.     if (pcm_val >= 0) {  
    90.         mask = 0xD5;        /* sign (7th) bit = 1 */  
    91.     } else {  
    92.         mask = 0x55;        /* sign bit = 0 */  
    93.         pcm_val = -pcm_val - 8;  
    94.     }  
    95.   
    96.     /* Convert the scaled magnitude to segment number. */  
    97.     seg = search(pcm_val, seg_end, 8);  
    98.   
    99.     /* Combine the sign, segment, and quantization bits. */  
    100.   
    101.     if (seg >= 8)        /* out of range, return maximum value. */  
    102.         return (0x7F ^ mask);  
    103.     else {  
    104.         aval = seg << SEG_SHIFT;  
    105.         if (seg < 2)  
    106.             aval |= (pcm_val >> 4) & QUANT_MASK;  
    107.         else  
    108.             aval |= (pcm_val >> (seg + 3)) & QUANT_MASK;  
    109.         return (aval ^ mask);  
    110.     }  
    111. }  
    112.   
    113. /********************************************************************* 
    114.  *    alaw2linear() - Convert an A-law value to 16-bit linear PCM 
    115.  *********************************************************************/  
    116. int alaw2linear(unsigned char a_val)  
    117. {  
    118.     int     t;  
    119.     int     seg;  
    120.   
    121.     a_val ^= 0x55;  
    122.   
    123.     t = (a_val & QUANT_MASK) << 4;  
    124.     seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;  
    125.     switch (seg) {  
    126.     case 0:  
    127.         t += 8;  
    128.         break;  
    129.     case 1:  
    130.         t += 0x108;  
    131.         break;  
    132.     default:  
    133.         t += 0x108;  
    134.         t <<= seg - 1;  
    135.     }  
    136.     return ((a_val & SIGN_BIT) ? t : -t);  
    137. }  
    138.   
    139. #define BIAS        (0x84)      /* Bias for linear code. */  
    140.   
    141. /********************************************************************* 
    142.  * linear2ulaw() - Convert a linear PCM value to u-law 
    143.  * 
    144.  * In order to simplify the encoding process, the original linear magnitude 
    145.  * is biased by adding 33 which shifts the encoding range from (0 - 8158) to 
    146.  * (33 - 8191). The result can be seen in the following encoding table: 
    147.  * 
    148.  *  Biased Linear Input Code    Compressed Code 
    149.  *  ------------------------    --------------- 
    150.  *  00000001wxyza               000wxyz 
    151.  *  0000001wxyzab               001wxyz 
    152.  *  000001wxyzabc               010wxyz 
    153.  *  00001wxyzabcd               011wxyz 
    154.  *  0001wxyzabcde               100wxyz 
    155.  *  001wxyzabcdef               101wxyz 
    156.  *  01wxyzabcdefg               110wxyz 
    157.  *  1wxyzabcdefgh               111wxyz 
    158.  * 
    159.  * Each biased linear code has a leading 1 which identifies the segment 
    160.  * number. The value of the segment number is equal to 7 minus the number 
    161.  * of leading 0's. The quantization interval is directly available as the 
    162.  * four bits wxyz.  * The trailing bits (a - h) are ignored. 
    163.  * 
    164.  * Ordinarily the complement of the resulting code word is used for 
    165.  * transmission, and so the code word is complemented before it is returned. 
    166.  * 
    167.  * For further information see John C. Bellamy's Digital Telephony, 1982, 
    168.  * John Wiley & Sons, pps 98-111 and 472-476. 
    169.  *********************************************************************/  
    170. unsigned char linear2ulaw(int pcm_val)  /* 2's complement (16-bit range) */  
    171. {  
    172.     int     mask;  
    173.     int     seg;  
    174.     unsigned char   uval;  
    175.   
    176.     /* Get the sign and the magnitude of the value. */  
    177.     if (pcm_val < 0) {  
    178.         pcm_val = BIAS - pcm_val;  
    179.         mask = 0x7F;  
    180.     } else {  
    181.         pcm_val += BIAS;  
    182.         mask = 0xFF;  
    183.     }  
    184.   
    185.     /* Convert the scaled magnitude to segment number. */  
    186.     seg = search(pcm_val, seg_end, 8);  
    187.   
    188.     /* 
    189.      * Combine the sign, segment, quantization bits; 
    190.      * and complement the code word. 
    191.      */  
    192.     if (seg >= 8)        /* out of range, return maximum value. */  
    193.         return (0x7F ^ mask);  
    194.     else {  
    195.         uval = (seg << 4) | ((pcm_val >> (seg + 3)) & 0xF);  
    196.         return (uval ^ mask);  
    197.     }  
    198.   
    199. }  
    200.   
    201. /********************************************************************* 
    202.  * ulaw2linear() - Convert a u-law value to 16-bit linear PCM 
    203.  * 
    204.  * First, a biased linear code is derived from the code word. An unbiased 
    205.  * output can then be obtained by subtracting 33 from the biased code. 
    206.  * 
    207.  * Note that this function expects to be passed the complement of the 
    208.  * original code word. This is in keeping with ISDN conventions. 
    209.  *********************************************************************/  
    210. int ulaw2linear( unsigned char  u_val)  
    211. {  
    212.     int     t;  
    213.   
    214.     /* Complement to obtain normal u-law value. */  
    215.     u_val = ~u_val;  
    216.   
    217.     /* 
    218.      * Extract and bias the quantization bits. Then 
    219.      * shift up by the segment number and subtract out the bias. 
    220.      */  
    221.     t = ((u_val & QUANT_MASK) << 3) + BIAS;  
    222.     t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;  
    223.   
    224.     return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));  
    225. }  
    226.   
    227. /* A-law to u-law conversion */  
    228. unsigned char alaw2ulaw(unsigned char   aval)  
    229. {  
    230.     aval &= 0xff;  
    231.     return ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :  
    232.         (0x7F ^ _a2u[aval ^ 0x55]));  
    233. }  
    234.   
    235. /* u-law to A-law conversion */  
    236. unsigned char ulaw2alaw(unsigned char   uval)  
    237. {  
    238.     uval &= 0xff;  
    239.     return ((uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)):  
    240.            (0x55 ^ (_u2a[0x7F ^ uval] - 1)));  
    241. }  

     

    展开全文
  • C语言 A律压缩

    千次阅读 2016-05-05 21:45:13
    deviation = (a[i] + a[i - 1 ]) / 2 - vaule; if (deviation 0 ) deviation = -deviation; for (i = 0 ;i 8 ;i++) printf ( "[%d]" ,b[i]); printf ( "\n" ); printf ( "deviation = %d\n" ,...

    这里写图片描述

    昨天的compress之所以传出一个空值,是因为compress运行后,数组b被释放,所以需要给他定义一个static,它就使得b[8]存放在内存中的静态存储区中,所占用的存储单元一直不释放直到整个程序运行结束 。

    #include <stdio.h>
    #include <stdlib.h>
    
    int * compress(int vaule)
    {
        int i, j;
        int temp, a_temp;
        int deviation;
        static int b[8] = {0};//必须是static,否则运行结束后b[]会被释放
        int a[16];
        int c[8] = {16,32,64,128,256,512,1024,2048};
        int d[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    
        printf("please input vaule:");
        scanf("%d",&vaule);
    
        if(vaule < 0){
            //vaule = abs(vaule);
            vaule = -vaule;
        }
        else
            b[0] = 1;
    
        for(i = 0;i < 7;i++){
            if(vaule < c[i]){
                printf("i = %d\n",i);
    
                break;
            }
        }
        //段落码
        switch (i) {
        case 0:
            b[1] = 0;
            b[2] = 0;
            b[3] = 0;
            break;
        case 1:
            b[1] = 0;
            b[2] = 0;
            b[3] = 1;
            break;
        case 2:
            b[1] = 0;
            b[2] = 1;
            b[3] = 0;
            break;
        case 3:
            b[1] = 0;
            b[2] = 1;
            b[3] = 1;
            break;
        case 4:
            b[1] = 1;
            b[2] = 0;
            b[3] = 0;
            break;
        case 5:
            b[1] = 1;
            b[2] = 0;
            b[3] = 1;
            break;
        case 6:
            b[1] = 1;
            b[2] = 1;
            b[3] = 0;
            break;
        case 7:
            b[1] = 1;
            b[2] = 1;
            b[3] = 1;
            break;
        default:
            break;
        }
    
        printf("c[%d] = %d",i,c[i]);
        printf("\n");
    
        if(i == 0)
            temp = c[i] - 0;
        else
            temp = c[i] - c[i - 1];
    
        printf("temp = %d\n",temp);
    
        printf("a[] = ");
        a_temp = temp / 16;
        a[15] = c[i];
    
        for(i = 14, j = 0;i > 0, j < 16; i--, j++) {
    
            a[i] = a[15] - a_temp * d[j];
        }
        for(i = 0;i<16;i++){
            printf("[%d]",a[i]);
        }
        printf("\n");
    
        for(i = 0;i < 16;i++){
            if(vaule < a[i]){
                printf("i = %d\n",i);
    
                break;
            }
        }
        //段内码
        switch (i) {
        case 0:
            b[4] = 0;
            b[5] = 0;
            b[6] = 0;
            b[7] = 0;
            break;
        case 1:
            b[4] = 0;
            b[5] = 0;
            b[6] = 0;
            b[7] = 1;
            break;
        case 2:
            b[4] = 0;
            b[5] = 0;
            b[6] = 1;
            b[7] = 0;
            break;
        case 3:
            b[4] = 0;
            b[5] = 0;
            b[6] = 1;
            b[7] = 1;
            break;
        case 4:
            b[4] = 0;
            b[5] = 1;
            b[6] = 0;
            b[7] = 0;
            break;
        case 5:
            b[4] = 0;
            b[5] = 1;
            b[6] = 0;
            b[7] = 1;
            break;
        case 6:
            b[4] = 0;
            b[5] = 1;
            b[6] = 1;
            b[7] = 0;
            break;
        case 7:
            b[4] = 0;
            b[5] = 1;
            b[6] = 1;
            b[7] = 1;
            break;
        case 8:
            b[4] = 1;
            b[5] = 0;
            b[6] = 0;
            b[7] = 0;
            break;
        case 9:
            b[4] = 1;
            b[5] = 0;
            b[6] = 0;
            b[7] = 1;
            break;
        case 10:
            b[4] = 1;
            b[5] = 0;
            b[6] = 1;
            b[7] = 0;
            break;
        case 11:
            b[4] = 1;
            b[5] = 0;
            b[6] = 1;
            b[7] = 1;
            break;
        case 12:
            b[4] = 1;
            b[5] = 1;
            b[6] = 0;
            b[7] = 0;
            break;
        case 13:
            b[4] = 1;
            b[5] = 1;
            b[6] = 0;
            b[7] = 1;
            break;
        case 14:
            b[4] = 1;
            b[5] = 1;
            b[6] = 1;
            b[7] = 0;
            break;
        case 15:
            b[4] = 1;
            b[5] = 1;
            b[6] = 1;
            b[7] = 1;
        default:
            break;
        }
    
        //计算偏差值
        deviation = (a[i] + a[i - 1]) / 2 - vaule;
        if(deviation < 0)
            deviation = -deviation;
    
        for(i = 0;i < 8;i++)
            printf("[%d]",b[i]);
    
        printf("\n");
    
        printf("deviation = %d\n",deviation);
    
    
        //printf("b = %d\n",b);
        //printf("*b = %d\n",*b);
    
        return b;
    }
    
    void decompress(int b[])
    {
        int temp;
        int k;
        char seg;
        int c[8] = {1,1,2,4,8,16,32,64};
        int d[8] = {0,16,32,64,128,256,512,1024};
    
       if(b[0] == 0){
           seg = '+';
       }
       else
           seg = '-';
    
    
       k = b[1] * 4 + b[2] * 2 + b[3];
    
       temp = d[k] + c[k] * (b[4] * 8 + b[5] * 4 + b[6] * 2 + b[7]);
    
       printf("vaule = %c%d\n",seg,temp);
    }
    
    int main()
    {
        int vaule;
        int *b;
        int a[8];
        int i;
    
        b = compress(vaule);
        //printf("%d\n",b);
        //printf("%d\n",*b);
    
        for(i = 0;i < 8;i++){
            a[i] = *(b + i);
            printf("[%d]",a[i]);
        }
    
        decompress(a);
    
        return 0;
    }
    
    展开全文
  • 对PCM中非均匀量化与折叠二进制码的仿真实现
  • alaw_mulaw/a-law_compression.cr.mtialaw_mulaw/a-law_compression.mpfalaw_mulaw/int2alaw.valaw_mulaw/linear2ulaw.valaw_mulaw/sim_linear2ulaw.valaw_mulaw/test_int2alaw(05-29).txtalaw_mulaw/test_int2alaw....

    alaw_mulaw/a-law_compression.cr.mti

    alaw_mulaw/a-law_compression.mpf

    alaw_mulaw/int2alaw.v

    alaw_mulaw/linear2ulaw.v

    alaw_mulaw/sim_linear2ulaw.v

    alaw_mulaw/test_int2alaw(05-29).txt

    alaw_mulaw/test_int2alaw.v

    alaw_mulaw/test_ulaw2int(5-29).txt

    alaw_mulaw/test_ulaw2int.v

    alaw_mulaw/transcript

    alaw_mulaw/u-law_expansion.cr.mti

    alaw_mulaw/u-law_expansion.mpf

    alaw_mulaw/ulaw2int.v

    alaw_mulaw/work/int2alaw/verilog.asm

    alaw_mulaw/work/int2alaw/_primary.dat

    alaw_mulaw/work/int2alaw/_primary.vhd

    alaw_mulaw/work/test_int2alaw/verilog.asm

    alaw_mulaw/work/test_int2alaw/_primary.dat

    alaw_mulaw/work/test_int2alaw/_primary.vhd

    alaw_mulaw/work/test_ulaw2int/verilog.asm

    alaw_mulaw/work/test_ulaw2int/_primary.dat

    alaw_mulaw/work/test_ulaw2int/_primary.vhd

    alaw_mulaw/work/ulaw2int/verilog.asm

    alaw_mulaw/work/ulaw2int/_primary.dat

    alaw_mulaw/work/ulaw2int/_primary.vhd

    alaw_mulaw/work/_info

    alaw_mulaw/work/int2alaw

    alaw_mulaw/work/test_int2alaw

    alaw_mulaw/work/test_ulaw2int

    alaw_mulaw/work/ulaw2int

    alaw_mulaw/work

    alaw_mulaw

    www.dssz.com.txt

    展开全文
  • A律压缩程序

    2012-06-06 13:06:03
    A律压缩解压编码是国际电报电话协会(CCITT,Consultative Committee forInternational Telegraph and Telephone)最早推出的G.711语音压缩解压编码的一种格式的主要内容。其中欧洲和中国等国家采用A律压缩解压编码...
  • 语音信号压缩A律

    2013-11-25 15:45:25
    基于DSP课程设计的语音信号压缩A律 课程内容: 1. 完成语音信号采集; 2. 对语音信号进行A律压缩; 3. 传输压缩后的信号;
  • A-Law算法实现PCM压缩,用于把16bit的wav音频数据压缩成8bit,能大大的降低传输带宽。压缩噪音小,非常高效的一个算法。
  • 摘要:本文介绍了G.711标准的A律压缩算法的基本原理,设计出了A律编解码的软件流程框图,在以TMS320VC5416为处理器的硬件开发平台上实现了语音信号的A律压缩解压算法,并给出了C54x的汇编语言程序。  0 引言  ...
  • 摘要:本文介绍了G.711标准的A律压缩算法的基本原理,设计出了A律编解码的软件流程框图,在以TMS320VC5416为处理器的硬件开发平台上实现了语音信号的A律压缩解压算法,并给出了C54x的汇编语言程序。  0 引言  ...
  • A律和μ律

    2020-12-10 15:30:59
    A律可用13段折线逼近(相当于A=87.6),便于用数字电路实现。 13段折线的压缩特性如下图。过程为: 第一步:把x(x>0 部分)划分为不均匀的8段。第一分点取在V/2处,然后每段都是剩下部分的1/2。;依次取第八段为V...
  • 基于MATLAB的A律非均匀量化

    千次阅读 2019-03-30 17:47:43
    (1)A律压缩特性: 其中,A 为压缩系数;y 为归一化的压缩器输出电压;x 为归一化的压缩器输入电压 (2)MATLAB实现 function y=a_pcm(x,a) %x为一个序列,值在0到1,A律量化将得到的结果存在序列y中 t=1/a; %a...

    (1)A律压缩特性:

    在这里插入图片描述
    其中,A 为压缩系数;y 为归一化的压缩器输出电压;x 为归一化的压缩器输入电压
    (2)MATLAB实现

    function y=a_pcm(x,a)   %x为一个序列,值在0到1,A律量化将得到的结果存在序列y中
    t=1/a;                  %a为一个正实数,大于1
    for i=1:length(x)
        if x(i)>=0          %判断输入序列值是否大于0
            if (x(i)<=t)
                y(i)=(a*x(i))/(1+log(a)); %若值小于1/a,用此算法
            else
                y(i)=(1+log(a*x(i)))/(1+log(a)); %若值大于1/a,用此算法
            end
        else
            if (x(i)>=-t)
                y(i)=-(a*-x(i))/(1+log(a));     %若值小于0,用此算法
            else
                y(i)=-(1+log(a*-x(i)))/(1+log(a));
            end
        end
    end
    

    上述为A律量化函数

    x=[0:0.001:1];%定义幅度序列
    y1=a_pcm(x,1);%参数为1的A律曲线
    y2=a_pcm(x,10);
    y3=a_pcm(x,87.65);
    plot(x,y1,':',x,y2,'-',x,y3,'-.');
    legend('A=1','A=10','A=87.65')
    title('对数量化特性曲线')
    

    在这里插入图片描述

    t=0:0.0001:0.005;
    y=sin(1000*pi*t);      %输入模拟信号
    figure
    subplot(2,1,1)
    plot(t,y)
    axis([0,0.005,-1,1])
    xlabel('时间')
    ylabel('幅值')
    title('原始信号')
    z=a_pcm(y,87.65);       %实用中,A=87.65,sin(0)到sin(0.005)的量化值
    z
    subplot(2,1,2)
    plot(t,z)
    axis([0,0.005,-1,1])
    xlabel('时间')
    ylabel('幅值')
    title('量化信号')
    

    A=87.65
    在这里插入图片描述

    A=10
    在这里插入图片描述
    A=1
    在这里插入图片描述

    展开全文
  • highspeedlogic算法仿真---A律折线论文

    千次阅读 2020-08-29 16:17:42
    ·A律与μ律能使信号量噪比基本保持恒定 在通信中,由于信号量噪比的不恒定而影响通信质量。为了对不同的信号强度保持信号量噪比恒定,在理论上要求压缩特性为对数特性。为了使信号量噪比保持恒定,引入A压缩律与...
  • A律折线与miu律折线

    2021-06-02 09:22:40
    1.问题描述: 在通信中,由于信号量噪比...最后得到一般来说,U律的15折线比A律的13折线,各个段落的斜率都相差2倍,所以小信号的信号量噪比也比A律大一倍,但是对于大信号来说,u律比a律差。 A律压扩 其特性可表示为:
  • A律与13折线

    万次阅读 2012-11-15 21:40:56
    今天趁着无聊,试试通信原理上课讲到的用十三折线近似A律对数压缩特性 原本以为很快,没想到困难重重。 为了验证两者之间近似效果好不好,首先想到的就是将A律与十三折线呈现在一张图上看看效果 画十三折线和A律...
  • PCM编码的格式和原理;A律和u 律压缩解压的原理;A律律压缩解压实现方法.
  • pcm.m 进行8级均匀量化 pcm_2_2.m 8位均匀量化,12位均匀量化,8位非均匀量化对比 pcm_3.m 实现A律13折线编码
  • a律和u律的算法实现步骤

    千次阅读 2013-01-09 12:37:10
    u8位  int BIAS = 0x84; //132, or 1000 0100 偏置  int MAX = 32635; //32767 (max 15-bit integer) minus BIAS;最高位除开符号位 符号位就是16位的第一位。  int sign = (pcm & 0x8000) >> 8; if ...
  • 设计出了A律编解码的软件流程框图,在以TMS320VC5502为处理器的硬件开发平台上实现了语音信号的A律压缩解压算法,并给出了压缩程序流程图。 目 录 摘 要 1 Abstract 2 引 言 3 1绪 论 1 1.1课题的背景 1 1.2课题的...
  • PCM音频压缩A-Law算法,uLaw

    万次阅读 2018-02-28 15:16:21
    参考相关:“关于pcm音频头与a-law音频头的互换代码” http://blog.csdn.net/fjhyy/article/details/6593049 https://baike.baidu.com/item/A%E5%BE%8B/5923040 http://www.sohu.com/a/147745747_464086 ...
  • A律十三折线法G711编解码介绍

    千次阅读 2020-08-26 10:54:03
    G711国际电信联盟ITU-T定制出来的一套语音压缩标准,主要用于对PCM音频数据编码,将PCM16bit数据压缩为为8Bit,它是主流的波形音频编码器,相当于只在帧内压缩,不会从帧间之间来考虑压缩;其主要用于PCM采样率为8K...
  • DSP内部的缓冲串口(McBSPs)带有硬件实现的μ律/A律压缩解压,用户只需要在相应寄存器中进行设置就可以了。在进行A律压缩时,采样后的12位数据,默认其最高位为符号位,压缩时要保持最高位即符号位不变,原数据的后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,960
精华内容 1,184
关键字:

A律压缩