精华内容
下载资源
问答
  • G711原理

    2020-05-27 19:52:52
    G.711是国际电信联盟ITU-T定制出来的一套语音压缩标准,它代表了对数PCM(logarithmic pulse-code modulation)抽样标准,是主流的波形声音编解码标准,主要用于电话。 主要用脉冲编码调制对音频采样,采样率为8k每...

    G.711是国际电信联盟ITU-T定制出来的一套语音压缩标准,它代表了对数PCM(logarithmic pulse-code modulation)抽样标准,是主流的波形声音编解码标准,主要用于电话。

    1. 主要用脉冲编码调制对音频采样,采样率为8k每秒。它利用一个 64Kbps 未压缩通道传输语音讯号。
    2. 压缩率为1:2, 即把16位成8位。

    G.711 标准下主要有两种压缩算法。

    1. u-law algorithm (又称u-law, ulaw, mu-law),主要运用于北美和日本。
    2. A-law algorithm,主要运用于欧洲和世界其他地区。特别设计用来方便计算机处理的。

    G.711将14bit(uLaw)或者13bit(aLaw)采样的PCM数据编码成8bit的数据流,播放的时候在将此8bit的数据还原成14bit或者13bit进行播放,不同于MPEG这种对于整体或者一段数据进行考虑再进行编解码的做法,G711是波形编解码算法,就是一个sample对应一个编码,所以压缩比固定为:

    • 8/14 = 57% (uLaw)
    • 8/13 = 62% (aLaw)

    3. G.711原理

    G.711是将语音模拟信号进行一种非线性量化, 详细的资料可以在ITU 上下到相关的spec 。下面主要列出一些性能参数:
    G.711(PCM方式)

    • 采样率:8kHz
    • 信息量:64kbps/channel
    • 理论延迟:0.125msec
    • 品质:MOS值4.10

    算法原理:
    A-law的公式如下,一般采用A=87.6

     

    image

    画出图来则是如下图,用x表示输入的采样值,F(x)表示通过A-law变换后的采样值,y是对F(x)进行量化后的采样值。

    image

    由此可见

    • 在输入的x为高值的时候,F(x)的变化是缓慢的,有较大范围的x对应的F(x)最终被量化为同一个y,精度较低。
    • 相反在低声强区域,也就是x为低值的时候,F(x)的变化很剧烈,有较少的不同x对应的F(x)被量化为同一个y。意思就是说在声音比较小的区域,精度较高。

    对应反量化公式(即上面函数的反函数):

    image

    3.1 G.711A(A-LAW)压缩十三折线法

    G.711A输入的是13位(S16的高13位),这种格式是经过特别设计的,便于数字设备进行快速运算。

    1. 取符号位并取反得到s。
    2. 获取强度位eee,获取方法如下图所示
    3. 获取高位样本位wxyz
    4. 组合为seeewxyz,将seeewxyz逢偶数为取补数。

    A-law如下表计算。

    • 第一列是采样点,共13bit,最高位为符号位。
    • 对于前两行,折线斜率均为1/2,跟负半段的相应区域位于同一段折线上。
    • 对于3到8行,斜率分别是1/4到1/128,共6段折线。
    • 总共13段折线,这就是所谓的A-law十三段折线法。

    转换表:
    线性输入代码        压缩码
    s0000000wxyz`a    s000wxyz
    s0000001wxyz`a    s001wxyz
    s000001wxyz`ab    s010wxyz
    s00001wxyz`abc    s011wxyz
    s0001wxyz`abcd    s100wxyz
    s001wxyz`abcde    s101wxyz
    s01wxyz`abcdef    s110wxyz
    s1wxyz`abcdefg    s111wxyz

    其中s是符号位,并倒引号标记后的位`被丢弃。

    示例:

    输入pcm数据为1234,二进制对应为(0000 0100 1101 0010)
    二进制变换下排列组合方式(0 00001 0011 010010)
    1、获取符号位最高位为0,取反,s=1
    2、获取强度位00001,查表,编码制应该是eee=011
    3、获取高位样本wxyz=0011
    4、组合为10110011,逢偶数为取反为11100110,得到E6

    3.2 G.711u(u-law)

    使用在北美和日本,输入的是14位,编码算法就是查表,计算出:基础值+平均偏移值

    μ-law的公式如下,μ取值一般为255

     

    image

    image

    相应的μ-law的计算方法如下表

     

     

    示例:
    输入pcm数据为1234
    1、取得范围值,查表得 +2014 to +991 in 16 intervals of 64
    2、得到基础值为0xA0
    3、得到间隔数为64
    4、得到区间基本值2014
    5、当前值1234和区间基本值差异2014-1234=780
    6、偏移值=780/间隔数=780/64,取整得到12
    7、输出为0xA0+12=0xAC

    3.2 A-law和u-law对比

    A-law和u-law画在同一个坐标轴中就能发现A-law在低强度信号下,精度要稍微高一些。

     

    实际应用中,我们确实可以用浮点数计算的方式把F(x)结果计算出来,然后进行量化,但是这样一来计算量会比较大,实际上对于A-law(A=87.6时),是采用13折线近似的方式来计算的,而μ-law(μ=255时)则是15段折线近似的方式。



     

     

    展开全文
  • g711编码原理 量化与采样 数字音频信号处理 数字音频处理概念 数字音频处理要做的大方向是把我们所听到的声音以数字的方式记录下来,让计算机进行处理。 先来简单说说声音这部分: 此时此刻你所能听到的...

    本文参考网址:
    g711编码原理
    量化与采样

    数字音频信号处理

    数字音频处理概念

    数字音频处理要做的大方向是把我们所听到的声音以数字的方式记录下来,让计算机进行处理。

    先来简单说说声音这部分:

    此时此刻你所能听到的动静就是声音,,这个声音是通过我的声带震动产生的,你之所以能听到是因为我的声带震动迫使着空气震动,声音在空气中以波的形式传播,空气震动迫使你的耳骨膜震动,从而听到声音。

    怎么记录声音?

    既然震动耳骨膜能让人听到声音,那么我们就用某个物体来模仿我们的耳骨膜来接收声音。例如:留声机中的振片就相当于人类的耳骨膜。

    我们把振片接收的声音通过AD变换器转变为数字信号。

    AD变换器(analogue digital) 模拟数字

    模拟信号到数字信号分为3部:采样,量化,编码

    采样:声音的模拟信号是一段连续的波形,数字信号是对波形进行采样得到的(采样:采集样本),一个点表示一个样本,采样所取得的数值是音频的模拟电压值。

    量化:用数字化的值来表示电压,就要把电压值划分成若干等级,每个等级可表示为一个数值,这就是量化。量化简单的说就是对采样点进行近似值表示,分得级越多,数字音频质量就越高。通常电话语音用8位(256级)或CD用16位(65536级)。

    编码:模拟信号转为数字信号说白了就是将模拟信号进行编码,将量化值以二进制的方式进行表示叫编码。


    PCM

    PCM(pulse code modulation脉冲编码调制)是把声音从模拟信号转成数字信号的一种技术。

    也就是A/D变换器。

    原理: 按照一个固定的频率去采样。所以对pcm来说有两个重要的指标:采样频率和量化精度。

    【采样频率】

    刚才我们说样本是从波形中采集到的一个点。一次只能在波形中采一个样本。我们为了让计算机还原波形,必须要在规定时间内进行足够多次采样操作才能接近原波形。我们知道,频率 = 1 / 周期,画个源波形和采样波形。如果采样率为1Hz,那么周期为1,表示每一秒采一次样本,如果采样率是2,那么周期为0.5,表示每0.5秒采一次,波形就变成这样,可以推断出,在规定时间内,采样频率越高,声音还原的效果越好。咱们通信音频采样率一般为8000Hz,也就是1秒采8000次样本。

    采样定理: 用大于信号最高频率两倍的频率,对周期信号进行采样,可以保证完全重构原始信号。

    人的听力感知范围是20~20000Hz,信号最高频率是20000Hz,所以cd的采样频率大于40000Hz就能还原出人耳所能感知到到的所有声音,常见的比如44.1kHz,48kHz, 96kHz
    之所以会取一个大于40k的采样频率比如44.1k、48k甚至更高的96k,可能是因为采样后需要量化,量化会有误差,为了缩小量化误差,要么提高采样频率,要么增加量化精度。

    【量化精度】

    也就是刚才我们说的对电压值进行分级,一级表示一个数值,用这个数值去近似表示采样点,一个数值表示一个样本,量化精度越高,量化值就越接近采样点,越接近就越准确。
    量化分为均匀量化和非均匀量化。
    在这里插入图片描述
    由图可知:均匀量化中,量化间隔均匀划分,无论电压信号强弱,每个样本的绝对误差都相等,结果导致振幅较低的地方失真严重,不适合弱信号(例如语音信号)。
    非均匀量化,弱信号量化间隔密,强信号量化间隔疏。

    如果按照非均匀量化,弱信号量化间隔密,能表示弱信号的量化值也就变多了,改善了弱信号失真的情况。
    改善弱信号失真的方法有两种,一种是刚才说的,采用非均匀量化的方式,第二种就是提高量化精度。
    同样的波形在相同的采样频率下比较分8位和分16位,明显是16bit能细化出更多不相同的样本值。

    编码:

    刚才我们说道,把量化值用二进制的方式表示叫编码。
    有些编码方式不会对原始数据量进行压缩,所以原生16bitpcm样本是没经过压缩的编码数据。压缩是编码的一种。

    数据压缩分为有损压缩和无损压缩,有损压缩虽说是有损,不影响正常收听。

    压缩的方式有很多种:

    1. 在一个样本内部进行压缩。
    2. 相邻两个样本间取不相同的地方(做差)进行压缩,所以在播放时,后一个样本依赖于前一个样本。
    3. 将样本以块来处理,取平均值。

    现在介绍第一种压缩方式——在样本内部进行压缩。

    g711是一种由国际电信联盟制定的一套语音压缩标准,主要用于电话语音通信,而人声最大频率一般在3.4kHz,所以只要以8k的采样频率对人声进行采样,就可以保证完全还原原始声音。
    g711的内容是将一个13bit或14bit的样本编码成一个8bit的样本。
    g711标准主要分两种压缩方法:a-law和mu-law,

    a-law:将一个13bit的pcm样本压缩成一个8bit的pcm样本。

    mu-law:将一个14bit的pcm样本压缩成一个8bit的pcm样本。

    【问题】:刚才不是说pcm是16位的么,怎么就变成了13bit14bit

    【解答】
    13bit14bit取决于你A/D转换器的量化精度,对13bit精度的量化值进行编码,得到一个13bit二进制pcm样本值,也得用2字节也就是16bit去存,在这种编码规则下,13位14位和16位的样本都是用2字节来存,无法将他们区分出来,所以就看你是让高13位赋予意义还是让低13位赋予意义。

    对于一个pcm二进制样本来说,高位代表强信号,低位代表弱信号。我最开始写代码取的是高13位,我用强信号去代表整个样本,结果就导致了弱信号解析不清楚,音频质量一般,声音有点小,感觉像是给你的耳朵盖上一层棉被听音乐。于是我就改取了低13位,采取放大弱信号的方式,整体运行出来的音质更好一些。

    a-law

    a-law采用13折线法编码,13折线是从“非均匀量化”基点出发,非均匀量化是精分低信号,粗分高信号。alaw编码的目标是将一个13bit的pcm样本压缩成一个8bit样本.

    1. 假设x/y的最大取值范围都是-1~+1.
    2. x/y轴分别代表量化级和分段序号(输入/输出)。所以13折线法的目的实际上是在给量化级分段,每段用一个固定的序号来表示。
    3. 将x轴不均等分成8段。按照每次1/2取分,分成8个段,7个点。在这里插入图片描述
    4. 将y轴均匀分8份
    5. 将x/y轴各段交点连接起来
      分成7个点:1/128,1/64,1/32,1/16,1/8,1/4,1/2
      分成8个段:1/128,1/128,1/64,1/32,1/16,1/8,1/4,1/2(x轴每个点之间的间隔)

    【由图可知】:

    0~1/128段和1/128~1/64的距离相等(是1/64平分来的),所以这两段的斜率相同,可以将第一第二段看作一大段,所以实际上是分了7段不同的斜率。
    因为取值是±1,所以反向还有一段一样的图,因为±1±2斜率相同,所以将其合成一大段,这时整个图总共有13段斜率不同的折线,这就是13折线法的由来。

    x轴的量化我还没画完,实际上它是这样的。当我们在x轴每一段中再均等分16份,这时他就是128级,因为他是8bit,得分到256级为止,我就不在细化了。
    可以看到折线的变化越来越平缓,当x值较大时,有大范围的x都被量化成8,量化精度较低,当x值较小时,折线变化剧烈,量化精度高。

    在16bit的pcm中挑出13bit,经过了13折线法,生成了一个8bit的样本,

    看表格第二纵列
    在这里插入图片描述
    压缩后的数据只有8bit,用char来存放,s是符号位,八段序号对应000~111(8段),abcd是从16bit的pcm中截取的有效样本。

    看表格第一竖列一共有13bit,第一位是符号位,序号位是符号位之后碰到的第一个1之间的位数,包括这个1…序号位最多有7位,这7位从低位往高位数,第一位是1就对应1,第二位是1就对应2,第7位是1就对应7,全是0就对应0.

    所以代码的难点只有在13位的pcm中找符号位之后的第一个1。(就这么简单)

    看代码

    关于位运算:

    & 与 :同1则1
    | 或 :有1则1
    ~取反:按位取反
    ^ 亦或:相同为1
    << 左移:×
    >> 右移:/
    十进制中想要把0010向左移一位
    变成0100,是不是要 * 10^1, 
    所以十进制的0010 << 2,
    就表示0010 * 10^2
    同理,二进制的0010 << 1 是0010 × 2的1次方
    

    代码流程:

    1. 取符号位。
    2. 找符号位后第一个1,获取序号位。将除了符号位以外的12位取出,传入函数中去找第一个一。
    3. 拼接符号位,序号位,样本位。
    4. 返回对偶位二进制位取反。
      在这里插入图片描述

    问题:负数变正数时为什么要-1?

    解答:我们传进来的数是有符号数,例如4bit的有符号二进制表示是从0~7, -1~-8。把负数取绝对值变正数之后变成1~8,总体比0~7大1,所以-pcm变正后要-1.

    查找第一个1

    【计算式】:

    将除符号位外的12位进行与运算

    1000 0000 0000 进行与运算,同1则1
    ,如果与出来的结果为0,那么表示这一位不是1,
    如果与出来的数不为0, 则表示该样本的序号位是7,
    函数返回所对应的序号.
    flag二进制上的1右移一位变成
    0100 0000 0000 以同样的方式进行与,
    直到找到第一个1,找不到意味着全是0,返回0.
    

    【记录式】:

    若这12位pcm > 0111 1111 1111(0x7ff),
    则表示这12位pcm的最高位是1(1xxx xxxx xxxx),
    最高位是1对应的是序号7,返回7.
    
    如果pcm < 0111 1111 1111, 
    让pcm与0011 1111 1111比较,
    如果大于返回6, 小于的话就将最高位的1变为0
    这时我们就能打出个表,从0x1f~0x7ff
    

    当序号位 = 0时, pcm要右移一位才能把abcd都放在低4位

    否则,序号位 = 几就右移几位,目的是将abcd放在低4位

    最后就是把符号位,序号位,样本位放在8bit中该放的位置。

    0xd5 = 1101 0101。

    这就是alaw算法实现压缩。

    pcma转pcm代码

    在这里插入图片描述

    mulaw

    mu-law:将14bit的pcm样本变8bit。不均匀量化

    比alaw多一位

    折线图我就不细讲了。

    看表
    在这里插入图片描述
    看第二纵列,依然是符号位s,序号位000~111(共8段),有效位abcd

    看第一纵列,序号位最长是8. 序号位从低位往高位看,1在第1位代表0, 在第2位代表1,在第八位代表7.

    ​ 规律:1在第n位代表n - 1

    偏移表
    在这里插入图片描述

    代码流程

    1. 取符号位
    2. 将除符号位外的13位取出,找第一个一,获取序号位
    3. 拼接
    4. 全部取反
      在这里插入图片描述

    和alaw不一样的地方是mu-law整体会进行一个线性的偏移,
    原本mulaw14bit的pcm样本除去一位符号位外还剩13bit,13bit二进制位有213种状态 = 8192,关于mulaw的相关文档上写着8159是mulaw的最大量化级。
    偏移量为33.
    所以为了方便计算机进行处理,给所有的样本都+33
    为什么??!!
    这一块我到现在都不是很懂,有哪个明白的大佬能帮忙解释一下么。。。。
    pcm += (0x84 >> 2)这行代码是从sox源码中抄的。sox加33为什么用这么骚的操作?
    直接加不好么?变成pcm += 0x21不是更直接么?

    pcmu转pcm代码

    在这里插入图片描述

    调制

    编好码后进行调制,怎么调制才能播放?

    三个条件一个都不能少。

    1. 声道数:单 / 立体
    2. 样本位数:一个样本的二进制位数。4bit、8bit、16bit、32bit
    3. 采样频率:表示一秒采集样本的次数。(一次一个样本)采样频率越高,样本数量越多,还原的越好。

    像平时我们接触的什么mp3,wav格式的音频里面都记录着这三条基本信息,mp3,wav都是音频数据的装载容器,信息记录在容器的头部,播放器通过这些信息才知道要怎么解析这段音频数据。

    pcm不是按一帧装一个样本来打包的,而是按照打包率进行打包,咱们组对音频的采样频率规定为8kHz,1帧有160个样本。
    所以160/8000 = 0.02s的打包率,1s = 1000ms ,打包率 = 20ms,所以1s / 20ms = 50Hz,也就是一秒收50帧。

    往常我们播放视频音乐时出现的xxkb/s是比特率,表示一秒钟处理的bit数。
    比特率 = 样本位数 * 采样频率 * 声道数
    以压缩后的8位pcm,采样频率为8000Hz,一帧有160个样本例。

    一秒采8000个样本。一个样本占8bite,所以一秒收8bit * 8000个样本 * 1个声道数 = 64kb/s 的比特率。
    一帧的播放时间 = 160 / 8000(打包率) * 1000ms

    展开全文
  • G711编码原理ppt

    2015-04-12 16:25:31
    G711编码原理ppt,介绍ulaw,alaw编码原理
  • G711(G711a+g711u)编码原理及代码

    千次阅读 2019-08-05 17:48:11
    G711编码的声音清晰度好,语音自然度高,但压缩效率低,数据量大常在32Kbps以上。常用于电话语音(推荐使用64Kbps),sampling rate为8K,压缩率为2,即把S16格式的数据压缩为8bit,...

    G711编码的声音清晰度好,语音自然度高,但压缩效率低,数据量大常在32Kbps以上。常用于电话语音(推荐使用64Kbps),sampling rate为8K,压缩率为2,即把S16格式的数据压缩为8bit,分为a-law和u-law。


    a-law也叫g711a,输入的是13位(其实是S16的高13位),使用在欧洲和其他地区,这种格式是经过特别设计的,便于数字设备进行快速运算。

    运算过程如下:

    (1)      取符号位并取反得到s,

    (2)      获取强度位eee,获取方法如图所示

    (3)      获取高位样本位wxyz

    (4)      组合为seeewxyz,将seeewxyz逢偶数为取补数,编码完毕

    示例:

    输入pcm数据为3210,二进制对应为(0000 1100 1000 1010)

    二进制变换下排列组合方式(0 0001 1001 0001010)

    (1)      获取符号位最高位为0,取反,s=1

    (2)      获取强度位0001,查表,编码制应该是eee=100

    (3)      获取高位样本wxyz=1001

    (4)      组合为11001001,逢偶数为取反为10011100

    编码完毕。

    u-law也叫g711u,使用在北美和日本,输入的是14位,编码算法就是查表,没啥复杂算法,就是基础值+平均偏移值,具体示例如下:

    pcm=2345

    (1)取得范围值

    +4062 to +2015 in 16 intervals of 128

     

    (2)得到基础值0x90,

    (3)间隔数128,

    (4)区间基本值4062,

    (5)当前值2345和区间基本值差异4062-2345=1717,

    (6)偏移值=1717/间隔数=1717/128,取整得到13,

    (7)输出为0x90+13=0x9D

    Code如下

    
     
    1. #include <stdio.h>
    2. #define SIGN_BIT (0x80) /* Sign bit for a A-law byte. */
    3. #define QUANT_MASK (0xf) /* Quantization field mask. */
    4. #define NSEGS (8) /* Number of A-law segments. */
    5. #define SEG_SHIFT (4) /* Left shift for segment number. */
    6. #define SEG_MASK (0x70) /* Segment field mask. */
    7. #define BIAS (0x84) /* Bias for linear code. */
    8. #define CLIP 8159
    9. #define G711_A_LAW (0)
    10. #define G711_MU_LAW (1)
    11. #define DATA_LEN (16)
    12. static short seg_aend[ 8] = {
    13. 0x1F, 0x3F, 0x7F, 0xFF,
    14. 0x1FF, 0x3FF, 0x7FF, 0xFFF
    15. };
    16. static short seg_uend[ 8] = {
    17. 0x3F, 0x7F, 0xFF, 0x1FF,
    18. 0x3FF, 0x7FF, 0xFFF, 0x1FFF
    19. };
    20. unsigned char _u2a[ 128] = {
    21. /* u- to A-law conversions */
    22. 1, 1, 2, 2, 3, 3, 4, 4,
    23. 5, 5, 6, 6, 7, 7, 8, 8,
    24. 9, 10, 11, 12, 13, 14, 15, 16,
    25. 17, 18, 19, 20, 21, 22, 23, 24,
    26. 25, 27, 29, 31, 33, 34, 35, 36,
    27. 37, 38, 39, 40, 41, 42, 43, 44,
    28. 46, 48, 49, 50, 51, 52, 53, 54,
    29. 55, 56, 57, 58, 59, 60, 61, 62,
    30. 64, 65, 66, 67, 68, 69, 70, 71,
    31. 72, 73, 74, 75, 76, 77, 78, 79,
    32. 81, 82, 83, 84, 85, 86, 87, 88,
    33. 89, 90, 91, 92, 93, 94, 95, 96,
    34. 97, 98, 99, 100, 101, 102, 103, 104,
    35. 105, 106, 107, 108, 109, 110, 111, 112,
    36. 113, 114, 115, 116, 117, 118, 119, 120,
    37. 121, 122, 123, 124, 125, 126, 127, 128
    38. };
    39. unsigned char _a2u[ 128] = {
    40. /* A- to u-law conversions */
    41. 1, 3, 5, 7, 9, 11, 13, 15,
    42. 16, 17, 18, 19, 20, 21, 22, 23,
    43. 24, 25, 26, 27, 28, 29, 30, 31,
    44. 32, 32, 33, 33, 34, 34, 35, 35,
    45. 36, 37, 38, 39, 40, 41, 42, 43,
    46. 44, 45, 46, 47, 48, 48, 49, 49,
    47. 50, 51, 52, 53, 54, 55, 56, 57,
    48. 58, 59, 60, 61, 62, 63, 64, 64,
    49. 65, 66, 67, 68, 69, 70, 71, 72,
    50. 73, 74, 75, 76, 77, 78, 79, 79,
    51. 80, 81, 82, 83, 84, 85, 86, 87,
    52. 88, 89, 90, 91, 92, 93, 94, 95,
    53. 96, 97, 98, 99, 100, 101, 102, 103,
    54. 104, 105, 106, 107, 108, 109, 110, 111,
    55. 112, 113, 114, 115, 116, 117, 118, 119,
    56. 120, 121, 122, 123, 124, 125, 126, 127
    57. };
    58. static short search(int val, short *table, int size)
    59. {
    60. int i;
    61. for (i = 0; i < size; i++) {
    62. if (val <= *table++)
    63. return (i);
    64. }
    65. return (size);
    66. }
    67. /*
    68. * linear2alaw() - Convert a 16-bit linear PCM value to 8-bit A-law
    69. *
    70. * linear2alaw() accepts an 16-bit integer and encodes it as A-law data.
    71. *
    72. *Linear Input CodeCompressed Code
    73. *---------------------------------------
    74. *0000000wxyza000wxyz
    75. *0000001wxyza001wxyz
    76. *000001wxyzab010wxyz
    77. *00001wxyzabc011wxyz
    78. *0001wxyzabcd100wxyz
    79. *001wxyzabcde101wxyz
    80. *01wxyzabcdef110wxyz
    81. *1wxyzabcdefg111wxyz
    82. *
    83. * For further information see John C. Bellamy's Digital Telephony, 1982,
    84. * John Wiley & Sons, pps 98-111 and 472-476.
    85. */
    86. unsigned char linear2alaw(int pcm_val)/* 2's complement (16-bit range) */
    87. {
    88. int mask;
    89. int seg;
    90. unsigned char aval;
    91. pcm_val = pcm_val >> 3;
    92. if (pcm_val >= 0) {
    93. mask = 0xD5; /* sign (7th) bit = 1 */
    94. } else {
    95. mask = 0x55; /* sign bit = 0 */
    96. pcm_val = -pcm_val - 1;
    97. }
    98. /* Convert the scaled magnitude to segment number. */
    99. seg = search(pcm_val, seg_aend, 8);
    100. /* Combine the sign, segment, and quantization bits. */
    101. if (seg >= 8) /* out of range, return maximum value. */
    102. return ( unsigned char) ( 0x7F ^ mask);
    103. else {
    104. aval = ( unsigned char) seg << SEG_SHIFT;
    105. if (seg < 2)
    106. aval |= (pcm_val >> 1) & QUANT_MASK;
    107. else
    108. aval |= (pcm_val >> seg) & QUANT_MASK;
    109. return (aval ^ mask);
    110. }
    111. }
    112. /*
    113. * alaw2linear() - Convert an A-law value to 16-bit linear PCM
    114. *
    115. */
    116. int alaw2linear(unsigned char a_val)
    117. {
    118. int t;
    119. int seg;
    120. a_val ^= 0x55;
    121. t = (a_val & QUANT_MASK) << 4;
    122. seg = (( unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
    123. switch (seg) {
    124. case 0:
    125. t += 8;
    126. break;
    127. case 1:
    128. t += 0x108;
    129. break;
    130. default:
    131. t += 0x108;
    132. t <<= seg - 1;
    133. }
    134. return ((a_val & SIGN_BIT) ? t : -t);
    135. }
    136. /*
    137. * linear2ulaw() - Convert a linear PCM value to u-law
    138. *
    139. * In order to simplify the encoding process, the original linear magnitude
    140. * is biased by adding 33 which shifts the encoding range from (0 - 8158) to
    141. * (33 - 8191). The result can be seen in the following encoding table:
    142. *
    143. *Biased Linear Input CodeCompressed Code
    144. *---------------------------------------
    145. *00000001wxyza000wxyz
    146. *0000001wxyzab001wxyz
    147. *000001wxyzabc010wxyz
    148. *00001wxyzabcd011wxyz
    149. *0001wxyzabcde100wxyz
    150. *001wxyzabcdef101wxyz
    151. *01wxyzabcdefg110wxyz
    152. *1wxyzabcdefgh111wxyz
    153. *
    154. * Each biased linear code has a leading 1 which identifies the segment
    155. * number. The value of the segment number is equal to 7 minus the number
    156. * of leading 0's. The quantization interval is directly available as the
    157. * four bits wxyz. * The trailing bits (a - h) are ignored.
    158. *
    159. * Ordinarily the complement of the resulting code word is used for
    160. * transmission, and so the code word is complemented before it is returned.
    161. *
    162. * For further information see John C. Bellamy's Digital Telephony, 1982,
    163. * John Wiley & Sons, pps 98-111 and 472-476.
    164. */
    165. unsigned char linear2ulaw(short pcm_val)/* 2's complement (16-bit range) */
    166. {
    167. short mask;
    168. short seg;
    169. unsigned char uval;
    170. /* Get the sign and the magnitude of the value. */
    171. pcm_val = pcm_val >> 2;
    172. if (pcm_val < 0) {
    173. pcm_val = -pcm_val;
    174. mask = 0x7F;
    175. } else {
    176. mask = 0xFF;
    177. }
    178. if (pcm_val > CLIP)
    179. pcm_val = CLIP; /* clip the magnitude */
    180. pcm_val += (BIAS >> 2);
    181. /* Convert the scaled magnitude to segment number. */
    182. seg = search(pcm_val, seg_uend, 8);
    183. /*
    184. * Combine the sign, segment, quantization bits;
    185. * and complement the code word.
    186. */
    187. if (seg >= 8) /* out of range, return maximum value. */
    188. return ( unsigned char) ( 0x7F ^ mask);
    189. else {
    190. uval = ( unsigned char) (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF);
    191. return (uval ^ mask);
    192. }
    193. }
    194. /*
    195. * ulaw2linear() - Convert a u-law value to 16-bit linear PCM
    196. *
    197. * First, a biased linear code is derived from the code word. An unbiased
    198. * output can then be obtained by subtracting 33 from the biased code.
    199. *
    200. * Note that this function expects to be passed the complement of the
    201. * original code word. This is in keeping with ISDN conventions.
    202. */
    203. short ulaw2linear(unsigned char u_val)
    204. {
    205. short t;
    206. /* Complement to obtain normal u-law value. */
    207. u_val = ~u_val;
    208. /*
    209. * Extract and bias the quantization bits. Then
    210. * shift up by the segment number and subtract out the bias.
    211. */
    212. t = ((u_val & QUANT_MASK) << 3) + BIAS;
    213. t <<= (( unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
    214. return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
    215. }
    216. /* A-law to u-law conversion */
    217. unsigned char alaw2ulaw(unsigned char aval)
    218. {
    219. aval &= 0xff;
    220. return ( unsigned char) ((aval & 0x80) ? ( 0xFF ^ _a2u[aval ^ 0xD5]) :
    221. ( 0x7F ^ _a2u[aval ^ 0x55]));
    222. }
    223. /* u-law to A-law conversion */
    224. unsigned char ulaw2alaw(unsigned char uval)
    225. {
    226. uval &= 0xff;
    227. return ( unsigned char) ((uval & 0x80) ? ( 0xD5 ^ (_u2a[ 0xFF ^ uval] - 1)) :
    228. ( unsigned char) ( 0x55 ^ (_u2a[ 0x7F ^ uval] - 1)));
    229. }
    230. int encode(char *a_psrc, char *a_pdst, int in_data_len, unsigned char type)
    231. {
    232. int i;
    233. short *psrc = ( short *)a_psrc;
    234. int out_data_len = in_data_len / sizeof( short);
    235. if (a_psrc == NULL || a_pdst == NULL) {
    236. return ( -1);
    237. }
    238. if (in_data_len <= 0) {
    239. return ( -1);
    240. }
    241. if (type == G711_A_LAW) {
    242. for (i = 0; i < out_data_len; i++) {
    243. a_pdst[i] = ( char)linear2alaw(psrc[i]);
    244. }
    245. } else {
    246. for (i = 0; i < out_data_len; i++) {
    247. a_pdst[i] = ( char)linear2ulaw(psrc[i]);
    248. }
    249. }
    250. return (i);
    251. }
    252. int decode(char *a_psrc, char *a_pdst, int in_data_len, unsigned char type)
    253. {
    254. int i;
    255. short *pdst = ( short *)a_pdst;
    256. int out_data_len = in_data_len / sizeof( char);
    257. if (a_psrc == NULL || a_pdst == NULL) {
    258. return ( -1);
    259. }
    260. if (type == G711_A_LAW) {
    261. for (i = 0; i < out_data_len; i++) {
    262. pdst[i] = ( short)alaw2linear(( unsigned char)a_psrc[i]);
    263. }
    264. } else {
    265. for (i = 0; i < out_data_len; i++) {
    266. pdst[i] = ( short)ulaw2linear(( unsigned char)a_psrc[i]);
    267. }
    268. }
    269. return (i * sizeof( short));
    270. }
    271. int main(int argc, char **argv)
    272. {
    273. int i = 0;
    274. int n = 0;
    275. unsigned short pcm_buf[DATA_LEN] = { 0}; /*store linear pcm data*/
    276. unsigned short pcm_buf2[DATA_LEN] = { 0}; /*store linear pcm data*/
    277. unsigned char g711_buf[DATA_LEN] = { 0};
    278. FILE * fp_in = fopen( "input.wav", "r");
    279. FILE * fp_out = fopen( "pcm.g711_alaw", "w");
    280. FILE * fp_out_pcm = fopen( "pcm2.wav", "w");
    281. unsigned char header[ 128] = { 0 };
    282. fread(header, 1, 0x2c, fp_in);
    283. fwrite(header, 1, 0x2c, fp_out_pcm);
    284. while (DATA_LEN * 2 == fread(pcm_buf, 1, DATA_LEN * 2, fp_in)) {
    285. printf( "encode %d was trans\n",
    286. encode(pcm_buf, g711_buf, sizeof(pcm_buf), G711_A_LAW));
    287. fwrite(g711_buf, 1, DATA_LEN, fp_out);
    288. printf( "decode %d was trans\n",
    289. decode(g711_buf, pcm_buf2, sizeof(g711_buf), G711_A_LAW));
    290. fwrite(pcm_buf2, 1, DATA_LEN* 2, fp_out_pcm);
    291. }
    292. fclose(fp_in);
    293. fclose(fp_out);
    294. fclose(fp_out_pcm);
    295. return 0;
    296. }


    转自:https://blog.csdn.net/szfhy/article/details/52448906

    展开全文
  • G711编码原理及代码

    千次阅读 2018-09-18 09:53:57
    G711编码的声音清晰度好,语音自然度高,但压缩效率低,数据量大常在32Kbps以上。常用于电话语音(推荐使用64Kbps),sampling rate为8K,压缩率为2,即把S16格式的数据压缩为8bit,分为a-law和u-law。     a-law...

    G711编码的声音清晰度好,语音自然度高,但压缩效率低,数据量大常在32Kbps以上。常用于电话语音(推荐使用64Kbps),sampling rate为8K,压缩率为2,即把S16格式的数据压缩为8bit,分为a-law和u-law。

     

     

    a-law也叫g711a,输入的是13位(其实是S16的高13位),使用在欧洲和其他地区,这种格式是经过特别设计的,便于数字设备进行快速运算。

    运算过程如下:

    (1)      取符号位并取反得到s,

    (2)      获取强度位eee,获取方法如图所示

    (3)      获取高位样本位wxyz

    (4)      组合为seeewxyz,将seeewxyz逢偶数为取补数,编码完毕

     

    示例:

    输入pcm数据为3210,二进制对应为(0000 1100 1000 1010)

    二进制变换下排列组合方式(0 0001 1001 0001010)

    (1)      获取符号位最高位为0,取反,s=1

    (2)      获取强度位0001,查表,编码制应该是eee=100

    (3)      获取高位样本wxyz=1001

    (4)      组合为11001001,逢偶数为取反为10011100

    编码完毕。

     

    u-law也叫g711u,使用在北美和日本,输入的是14位,编码算法就是查表,没啥复杂算法,就是基础值+平均偏移值,具体示例如下:

    pcm=2345

    (1)取得范围值

    +4062 to +2015 in 16 intervals of 128

     

    (2)得到基础值0x90,

    (3)间隔数128,

    (4)区间基本值4062,

    (5)当前值2345和区间基本值差异4062-2345=1717,

    (6)偏移值=1717/间隔数=1717/128,取整得到13,

    (7)输出为0x90+13=0x9D

     

    Code如下

    #include <stdio.h>
     
    #define         SIGN_BIT        (0x80)      /* Sign bit for a A-law byte. */
    #define         QUANT_MASK      (0xf)       /* Quantization field mask. */
    #define         NSEGS           (8)         /* Number of A-law segments. */
    #define         SEG_SHIFT       (4)         /* Left shift for segment number. */
    #define         SEG_MASK        (0x70)      /* Segment field mask. */
    #define         BIAS            (0x84)      /* Bias for linear code. */
    #define		CLIP            8159
    
    #define		G711_A_LAW	(0)
    #define		G711_MU_LAW	(1)
    #define		DATA_LEN	(16)
     
    static short seg_aend[8] = {
    	0x1F, 0x3F, 0x7F, 0xFF,
    	0x1FF, 0x3FF, 0x7FF, 0xFFF
    };
    
    static short seg_uend[8] = {
    	0x3F, 0x7F, 0xFF, 0x1FF,
    	0x3FF, 0x7FF, 0xFFF, 0x1FFF
    };
     
    unsigned char _u2a[128] = {
    	/* u- to A-law conversions */
    	1,1,2,2,3,3,4,4,
    	5,5,6,6,7,7,8,8,
    	9,10,11,12,13,14,15,16,
    	17,18,19,20,21,22,23,24,
    	25,27,29,31,33,34,35,36,
    	37,38,39,40,41,42,43,44,
    	46,48,49,50,51,52,53,54,
    	55,56,57,58,59,60,61,62,
    	64,65,66,67,68,69,70,71,
    	72,73,74,75,76,77,78,79,
    	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
    };
     
    unsigned char _a2u[128] = {
    	/* A- to u-law conversions */
    	1,3,5,7,9,11,13,15,
    	16,17,18,19,20,21,22,23,
    	24,25,26,27,28,29,30,31,
    	32,32,33,33,34,34,35,35,
    	36,37,38,39,40,41,42,43,
    	44,45,46,47,48,48,49,49,
    	50,51,52,53,54,55,56,57,
    	58,59,60,61,62,63,64,64,
    	65,66,67,68,69,70,71,72,
    	73,74,75,76,77,78,79,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
    };
     
    static short search(int val, short *table, int size)
    {
    	int i;
    	for (i = 0; i < size; i++) {
    		if (val <= *table++)
    			return (i);
     
    	}
    	return (size);
    }
     
    /*
     * linear2alaw() - Convert a 16-bit linear PCM value to 8-bit A-law
     *
     * linear2alaw() accepts an 16-bit integer and encodes it as A-law data.
     *
     *Linear Input CodeCompressed Code
     *---------------------------------------
     *0000000wxyza000wxyz
     *0000001wxyza001wxyz
     *000001wxyzab010wxyz
     *00001wxyzabc011wxyz
     *0001wxyzabcd100wxyz
     *001wxyzabcde101wxyz
     *01wxyzabcdef110wxyz
     *1wxyzabcdefg111wxyz
     *
     * For further information see John C. Bellamy's Digital Telephony, 1982,
     * John Wiley & Sons, pps 98-111 and 472-476.
     */
    unsigned char linear2alaw(int pcm_val)/* 2's complement (16-bit range) */
    {
     
    	int mask;
    	int seg;
    	unsigned char aval;
     
    	pcm_val = pcm_val >> 3;
     
    	if (pcm_val >= 0) {
    		mask = 0xD5;/* sign (7th) bit = 1 */
    	} else {
    		mask = 0x55;/* sign bit = 0 */
    		pcm_val = -pcm_val - 1;
    	}
     
    	/* Convert the scaled magnitude to segment number. */
    	seg = search(pcm_val, seg_aend, 8);
     
    	/* Combine the sign, segment, and quantization bits. */
     
    	if (seg >= 8)/* out of range, return maximum value. */
    		return (unsigned char) (0x7F ^ mask);
    	else {
    		aval = (unsigned char) seg << SEG_SHIFT;
    		if (seg < 2)
    			aval |= (pcm_val >> 1) & QUANT_MASK;
    		else
    			aval |= (pcm_val >> seg) & QUANT_MASK;
    		return (aval ^ mask);
    	}
     
    }
     
    /*
     * alaw2linear() - Convert an A-law value to 16-bit linear PCM
     *
     */
    int alaw2linear(unsigned char a_val)
    {
     
    	int t;
    	int seg;
     
    	a_val ^= 0x55;
     
    	t = (a_val & QUANT_MASK) << 4;
    	seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
    	switch (seg) {
    	case 0:
    		t += 8;
    		break;
    	case 1:
    		t += 0x108;
    		break;
    	default:
    		t += 0x108;
    		t <<= seg - 1;
     
    	}
    	return ((a_val & SIGN_BIT) ? t : -t);
    }
     
     
    /*
     * linear2ulaw() - Convert a linear PCM value to u-law
     *
     * In order to simplify the encoding process, the original linear magnitude
     * is biased by adding 33 which shifts the encoding range from (0 - 8158) to
     * (33 - 8191). The result can be seen in the following encoding table:
     *
     *Biased Linear Input CodeCompressed Code
     *---------------------------------------
     *00000001wxyza000wxyz
     *0000001wxyzab001wxyz
     *000001wxyzabc010wxyz
     *00001wxyzabcd011wxyz
     *0001wxyzabcde100wxyz
     *001wxyzabcdef101wxyz
     *01wxyzabcdefg110wxyz
     *1wxyzabcdefgh111wxyz
     *
     * Each biased linear code has a leading 1 which identifies the segment
     * number. The value of the segment number is equal to 7 minus the number
     * of leading 0's. The quantization interval is directly available as the
     * four bits wxyz.  * The trailing bits (a - h) are ignored.
     *
     * Ordinarily the complement of the resulting code word is used for
     * transmission, and so the code word is complemented before it is returned.
     *
     * For further information see John C. Bellamy's Digital Telephony, 1982,
     * John Wiley & Sons, pps 98-111 and 472-476.
     */
    unsigned char linear2ulaw(short pcm_val)/* 2's complement (16-bit range) */
    {
    	short mask;
    	short seg;
    	unsigned char uval;
     
    	/* Get the sign and the magnitude of the value. */
    	pcm_val = pcm_val >> 2;
    	if (pcm_val < 0) {
    		pcm_val = -pcm_val;
    		mask = 0x7F;
    	} else {
    		mask = 0xFF;
    	}
            if (pcm_val > CLIP)
    		pcm_val = CLIP;/* clip the magnitude */
    	pcm_val += (BIAS >> 2);
     
    	/* Convert the scaled magnitude to segment number. */
    	seg = search(pcm_val, seg_uend, 8);
     
    	/*
    	 * Combine the sign, segment, quantization bits;
    	 * and complement the code word.
    	 */
    	if (seg >= 8)/* out of range, return maximum value. */
    		return (unsigned char) (0x7F ^ mask);
    	else {
     
    		uval = (unsigned char) (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF);
    		return (uval ^ mask);
    	}
    }
     
    /*
     * ulaw2linear() - Convert a u-law value to 16-bit linear PCM
     *
     * First, a biased linear code is derived from the code word. An unbiased
     * output can then be obtained by subtracting 33 from the biased code.
     *
     * Note that this function expects to be passed the complement of the
     * original code word. This is in keeping with ISDN conventions.
     */
    short ulaw2linear(unsigned char u_val)
    {
    	short t;
     
    	/* Complement to obtain normal u-law value. */
    	u_val = ~u_val;
     
    	/*
    	 * Extract and bias the quantization bits. Then
    	 * shift up by the segment number and subtract out the bias.
    	 */
    	t = ((u_val & QUANT_MASK) << 3) + BIAS;
    	t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
    	return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
    }
     
    /* A-law to u-law conversion */
    unsigned char alaw2ulaw(unsigned char aval)
    {
    	aval &= 0xff;
    	return (unsigned char) ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :
    	    (0x7F ^ _a2u[aval ^ 0x55]));
    }
     
    /* u-law to A-law conversion */
    unsigned char ulaw2alaw(unsigned char uval)
    {
    	uval &= 0xff;
    	return (unsigned char) ((uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)) :
    	    (unsigned char) (0x55 ^ (_u2a[0x7F ^ uval] - 1)));
    }
     
    int encode(char *a_psrc, char *a_pdst, int in_data_len, unsigned char type)
    {
     
    	int i;
    	short *psrc = (short *)a_psrc;
    	int out_data_len = in_data_len / sizeof(short);
     
    	if (a_psrc == NULL || a_pdst == NULL) {
    		return (-1);
    	}
     
    	if (in_data_len <= 0) {
    		return (-1);
    	}
     
     
    	if (type == G711_A_LAW) {
    		for (i = 0; i < out_data_len; i++) {
    			a_pdst[i] = (char)linear2alaw(psrc[i]);
    		}
    	} else {
    		for (i = 0; i < out_data_len; i++) {
    			a_pdst[i] = (char)linear2ulaw(psrc[i]);
    		}
    	}
    	return (i);
    }
     
    int decode(char *a_psrc, char *a_pdst, int in_data_len, unsigned char type)
    {
    
    	int i;
    	short *pdst = (short *)a_pdst;
    	int out_data_len = in_data_len / sizeof(char);
    
    	if (a_psrc == NULL || a_pdst == NULL) {
    		return (-1);
    	}
    
    	if (type == G711_A_LAW) {
    		for (i = 0; i < out_data_len; i++) {
    			pdst[i] = (short)alaw2linear((unsigned char)a_psrc[i]);
    		}
    	} else {
    		for (i = 0; i < out_data_len; i++) {
    			pdst[i] = (short)ulaw2linear((unsigned char)a_psrc[i]);
    		}
    	}
    
    	return (i * sizeof(short));
    }
    
    int main(int argc, char **argv)
    {
    	int i = 0;
    	int n = 0;
    	unsigned short pcm_buf[DATA_LEN] = {0}; /*store linear pcm data*/
    	unsigned short pcm_buf2[DATA_LEN] = {0}; /*store linear pcm data*/
    	unsigned char g711_buf[DATA_LEN] = {0};
    
    	FILE * fp_in = fopen("input.wav", "r");
    	FILE * fp_out = fopen("pcm.g711_alaw", "w");
    	FILE * fp_out_pcm = fopen("pcm2.wav", "w");
    
    	unsigned char header[128] = { 0 };
    	fread(header, 1, 0x2c, fp_in);
    	fwrite(header, 1, 0x2c, fp_out_pcm);
    
    	while (DATA_LEN * 2 == fread(pcm_buf, 1, DATA_LEN * 2, fp_in)) {
    
    		printf("encode %d was trans\n",
    			encode(pcm_buf, g711_buf, sizeof(pcm_buf), G711_A_LAW));
    
    		fwrite(g711_buf, 1, DATA_LEN, fp_out);
    
    		printf("decode %d was trans\n",
    			decode(g711_buf, pcm_buf2, sizeof(g711_buf), G711_A_LAW));
    	
    		fwrite(pcm_buf2, 1, DATA_LEN*2, fp_out_pcm);
    	}
    
    	fclose(fp_in);
    	fclose(fp_out);
    	fclose(fp_out_pcm);
    	return 0;
    }

     转自:https://blog.csdn.net/szfhy/article/details/52448906

    展开全文
  • G711编码原理

    千次阅读 2017-05-26 14:20:13
    G.711 正是利用语音信号的这种特性采用非均匀量化编码。在量化的时候可以让量化区间在小信号的时候取较小,在大信号的时候取较大,这样就能有效提高量化的信噪比  首先将输入信号的幅度归一化便于分析,然后将...
  • 【音频】G711编码原理

    万次阅读 多人点赞 2018-07-03 16:51:56
    它是国际电信联盟ITU-T定制出来的一套语音压缩标准,它代表了对数PCM(logarithmic pulse-code modulation)抽样标准,主要用于电话。...G.711是主流的波形声音编解码器。G.711 标准下主要有两种压缩算法。一种是u-l...
  • G.711编码原理及代码

    千次阅读 2015-04-12 16:19:49
    G711音频编码原理及代码。
  • G.711编码原理

    2020-12-10 14:27:50
    1、熟悉G711a/u两种格式的基本原理 2、熟悉两种压缩算法的实现步骤及提供源码实现 G.711是国际电信联盟ITU-T定制出来的一套语音压缩标准,它代表了对数PCM(logarithmic pulse-code modulation)抽样标准,是主流的...
  • 两者都是对一个采样进行压缩,区别在于g711-a将13位转换为8位压缩数据,g711-u将14位转换为8位压缩数据。 压缩比固定为: 8/14 = 57% (uLaw) 8/13 = 62% (aLaw) 但事实上写代码的时候,常常将16位转换位8位。压缩比...
  • G.711编解码原理

    千次阅读 2015-05-31 17:56:11
    wiki上关于G.711的介绍以及A-law和mu-law原理解释 http://en.wikipedia.org/wiki/G.711 自带的中文不能打开,google不知道为啥翻译不了,用了个bing将就着看吧 ...
  • 参考自:...G711也称为PCM(脉冲编码调制),是国际电信联盟制定出来的一套语音压缩标准,主要用于电话。G711编码的声音清晰度好,语音自然度高,但压缩效率低,数据量大常在...
  • g711

    千次阅读 2012-04-12 09:23:40
    g711实际上的算法原理是利用一系列的折线段,代替log曲线 从代码上看,即非线性量化,即将语音信号分成几个大区间,每个区间的量化精度不同 这可能是基于这么一个事实,即振幅高的采样点比较少,大部分采样...
  • g711是一种由国际电信联盟制定的一套语音压缩标准,主要用于电话语音通信,而人声最大频率一般在3.4kHz,所以只要以8k的采样频率对人声进行采样,就可以保证完全还原原始声音。 g711的内容是将一个13bit或14bit的...
  • 目录G711简介G711A算法原理压缩方法举例代码G711U算法原理压缩方法举例代码G711A与G711U对比 G711简介   G711是国际电信联盟ITU-T定制出来的一套语音压缩标准,它代表了对数PCM(logarithmic pulse-code ...
  • LPCM LPCM: linear pulse code modulation LPCM,即线性脉冲编码调制,是一种非压缩... 各种应用场合中的LPCM(PCM)原理是一样的,区别在于采样频率和量化精度不同。 声音之所以能够数字化,是因为人耳所能听...
  • 介绍了各种语音压缩算法的思想以及相关算法的各种源程序,并对程序进行介绍等 介绍了各种语音压缩算法的思想以及相关算法的各种源程序,并对程序进行介绍等
  • 音频编码G711校验

    2018-03-21 17:00:56
    G711编码 G711它是国际电信联盟ITU-T定制出来的一套语音压缩标准,它代表了对数PCM(logarithmic pulse-code modulation)抽样标准,主要用于电话。它主要用脉冲编码调制对音频采样,采样率为8k每秒。它利用一个 64...
  • G711 G729音频编码总结

    千次阅读 2015-08-04 15:45:08
    g729编码,每次只能编码160个字节,编码后为10个字节大小,16:1的压缩比,如果要编码320字节的数据,需要分两次进行,并且G729A不支持多路同时解码,否则声音会有问题,G729b也不行,ITU上的代码都不支持多路解码,...
  • G711算法的公式和曲线

    2018-12-05 09:26:39
    G711压扩算法 G711算法采用8kHz采样率,有A-law和μ-law两种压扩方式,分别是将13bit和14bit编码为8bit,因此G711固定码率是8kHz*8bit=64kbps。两者都是对数变换,A-law更加方便计算机处理。μ-law提供了略微高一些...

空空如也

空空如也

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

g711原理