和大家分享一下SpeexLib使用中的一些小技巧

jxcylxh

好久没有发帖了，今天闲下来，和大家分享一下自己研究了大半年的Speex语音压缩库。自己水平也不咋样，如果有讲错的地方还望大家指出来，大家一起学习，这个帖子我会以连载的方式来写，好进入正题：
1,：先讲一讲这个东西怎么用
    其实讲到这里，很多人都会想到ST有提供的现成的基于F103系列的库，没错我就是从这个库里面研究起来的，这个库有他的优点：ST专门对几个滤波器函数优化过，使用汇编写的，删除了一些子模式，并且使用定点运算，再这里先贴一下被ST优化过得那几个函数名称：filter_mem16（）， inner_prod（），vq_nbest（）等等，之所以这样才得以在103上面可以运行起来，缺点嘛：就是被阉割过了，只能使用一个模式，你如果想要更高的语音质量就别想用这个库了，它里面默认的质量是4，最好的质量等级是10,，具体的可以看下面的那个结构体：

初始值

其实如果真做语音压缩一类的话，我推荐用F407，开启FPU。或者DSP，优点嘛有很多，其中我认为最有用的就是里面的VBR了，可以做动态变比，也就是当你有语音信息的时候就会编出比较多的数据，没有语音信息时编出的数据非常少,只有1个Byte，这个也就引出了后面的DTX，它的意思就是说你没有语音信号的时候可以不传数据，想想这是不是很方便呢。好这个先提到这里，后面还有预处理什么的，这个VBR就放到后面来讲。有了上面这些参数的定义我们可以初始化到Speex里面去了，可以这样操作:

在这里特别提醒一下大家，这个库使用了一些内存分配，需要从堆里面去开辟内存，所以你的程序如果一运行到初始化就进入硬件错误，没关系，堆开大点就好了，一般对于编码解码来说 ：0x8000的大小就可以了。后面说说怎么编码吧:

这里注意这个Nbyte，不要被ST提供的那个库给迷惑了，正确的用法是这样。
解码是这样：

这里有一些代码是用于缓存语音的，所以自己写了一个环形队列，为了方便大家阅读，我把代码贴出来：

1. /**
   
2.   ******************************************************************************
   
3.   * @file    MemQueue.C
   
4.   * @author  Luoxianhui R&D Driver Software Team
   
5.   * @version V1.0.0
   
6.   * @date    06/09/2013
   
7.   * @brief   MemQueue»·ÐζÓÁлº´æ
   
8.   ******************************************************************************
   
9. **/
   
10.   
    
11. /* Includes ------------------------------------------------------------------*/
    
12. #include "MemQueue.h"
    
13. #include "define.h"
    
14. #include "includes.h"
    
15. /** @addtogroup MemQueue_Driver
    
16.   * @{
    
17.   */
    
18. 
    
19. /** @addtogroup Mem
    
20.   * @{
    
21.   */
    
22. 
    
23. /* Private typedef -----------------------------------------------------------*/
    
24. /* Private define ------------------------------------------------------------*/
    
25. /* Private macro -------------------------------------------------------------*/
    
26. /* Private variables ---------------------------------------------------------*/
    
27. SqQueueChar TestQueue;
    
28. // SqQueueChar RxQueue;
    
29. // SqQueueChar TxQueue;
    
30. SqJitterQueueChar RxQueue;
    
31. 
    
32. 
    
33. SqQueueShort AdQueue;
    
34. SqQueueShort DaQueue;
    
35. /* Private function prototypes -----------------------------------------------*/
    
36. /* Private functions ---------------------------------------------------------*/
    
37. void InitQueueChar(SqQueueChar *Q, INT32U F, INT32U E);
    
38. INT16U QueueLenthChar(SqQueueChar *Q);
    
39. SqQueueSta EnQueueChar(SqQueueChar *Q, INT8U Data);
    
40. SqQueueSta DeQueueChar(SqQueueChar *Q, INT8U *Data);
    
41. SqQueueSta EnQueueStrChar(SqQueueChar *Q, INT8U *Data,INT16U No);
    
42. SqQueueSta DeQueueStrChar(SqQueueChar *Q, INT8U *Data,INT16U No);
    
43. 
    
44. void InitQueueShort(SqQueueShort *Q, INT32U F, INT32U E);
    
45. INT16U QueueLenthShort(SqQueueShort *Q);
    
46. SqQueueSta EnQueueShort(SqQueueShort *Q, INT16S Data);
    
47. SqQueueSta DeQueueShort(SqQueueShort *Q, INT16S *Data);
    
48. SqQueueSta EnQueueStrShort(SqQueueShort *Q, INT16S *Data,INT16U No);
    
49. SqQueueSta DeQueueStrShort(SqQueueShort *Q, INT16S *Data,INT16U No);
    
50. 
    
51. 
    
52. void InitJitterQueueChar(SqJitterQueueChar *Q, INT32U F, INT32U E);
    
53. INT16U JitterQueueLenthChar(SqJitterQueueChar *Q);
    
54. SqQueueSta DeJitterQueueChar(SqJitterQueueChar *Q, INT8U *Data, INT16U *No);
    
55. SqQueueSta EnJitterQueueChar(SqJitterQueueChar *Q, INT8U *Data, INT16U No);
    
56. 
    
57. 
    
58. void InitQueueShort(SqQueueShort *Q, INT32U F, INT32U E)
    
59. {
    
60.         Q->sRear  = 0;
    
61.         Q->sFront = 0;
    
62.         Q->BufFullShortScal = F;
    
63.         Q->BufEmptyShortScal = E;
    
64.        
    
65. }
    
66. 
    
67. 
    
68. INT16U QueueLenthShort(SqQueueShort *Q)
    
69. {
    
70.         return(((Q->sRear) - (Q->sFront) + BufSizeShort) % BufSizeShort);
    
71. }
    
72. 
    
73. 
    
74. SqQueueSta EnQueueShort(SqQueueShort *Q, INT16S Data)
    
75. {
    
76.         if((((Q->sRear)+1) % BufSizeShort) ==  (Q->sFront))  return FALSE;
    
77.         (*Q).gBuf[Q->sRear] = Data;
    
78.         Q->sRear = (Q->sRear + 1) % BufSizeShort;
    
79.         return TRUE;
    
80. }
    
81. 
    
82. 
    
83. SqQueueSta DeQueueShort(SqQueueShort *Q, INT16S *Data)
    
84. {
    
85.         if(Q->sRear == Q->sFront) return FALSE;
    
86.        
    
87.         *Data = (*Q).gBuf[Q->sFront];
    
88.         Q->sFront = (Q->sFront + 1) % BufSizeShort;
    
89.         return TRUE;
    
90. }
    
91. 
    
92. SqQueueSta EnQueueStrShort(SqQueueShort *Q, INT16S *Data,INT16U No)
    
93. {
    
94.         OS_CPU_SR cpu_sr=0;
    
95. 
    
96.         INT16U i = 0;
    
97.         INT16U Len = 0;
    
98. 
    
99. 
    
100.         Len = QueueLenthShort(Q);
     
101.         if(Len >= Q->BufFullShortScal)
     
102.         {
     
103.                 Q->BufEmpty = BufFull;
     
104.         }
     
105.         if(Len <= Q->BufEmptyShortScal)
     
106.         {
     
107.                 Q->BufEmpty = BufEmpty;
     
108.         }
     
109.         if( Len >= (BufSizeShort-No)) return FALSE;       
     
110.         OS_ENTER_CRITICAL();
     
111.         for(i=0; i<No; i++)
     
112.   {
     
113.                 EnQueueShort(Q,Data[i]);
     
114.   }       
     
115.         OS_EXIT_CRITICAL();
     
116.         return TRUE;
     
117.        
     
118. }
     
119. 
     
120. SqQueueSta DeQueueStrShort(SqQueueShort *Q, INT16S *Data,INT16U No)
     
121. {
     
122.         INT16U i = 0;
     
123.         INT16U Len = 0;
     
124.         OS_CPU_SR cpu_sr=0;
     
125.         Len = QueueLenthShort(Q);
     
126.         if(Len >= Q->BufFullShortScal)
     
127.         {
     
128.                 Q->BufEmpty = BufFull;
     
129.         }
     
130.         if(Len <= Q->BufEmptyShortScal)
     
131.         {
     
132.                 Q->BufEmpty = BufEmpty;
     
133.         }
     
134.         if(Len <= No) return FALSE;
     
135.   OS_ENTER_CRITICAL();
     
136.         for(i=0; i<No; i++)
     
137.         {       
     
138.           DeQueueShort(Q,&(Data[i]));
     
139.         }
     
140.         OS_EXIT_CRITICAL();
     
141.         return TRUE;
     
142. }
     
143. 
     
144. void InitQueueChar(SqQueueChar *Q, INT32U F, INT32U E)
     
145. {
     
146.         Q->sRear  = 0;
     
147.         Q->sFront = 0;
     
148.         Q->BufFullCharScal = F;
     
149.         Q->BufEmptyCharScal = E;
     
150. }
     
151. 
     
152. 
     
153. INT16U QueueLenthChar(SqQueueChar *Q)
     
154. {
     
155.         return(((Q->sRear) - (Q->sFront) + BufSizeChar) % BufSizeChar);
     
156. }
     
157. 
     
158. 
     
159. SqQueueSta EnQueueChar(SqQueueChar *Q, INT8U Data)
     
160. {
     
161.         if((((Q->sRear)+1) % BufSizeChar) ==  (Q->sFront))  return FALSE;
     
162.         (*Q).gBuf[Q->sRear] = Data;
     
163.         Q->sRear = (Q->sRear + 1) % BufSizeChar;
     
164.         return TRUE;
     
165. }
     
166. 
     
167. 
     
168. SqQueueSta DeQueueChar(SqQueueChar *Q, INT8U *Data)
     
169. {
     
170.         if(Q->sRear == Q->sFront) return FALSE;
     
171.        
     
172.         *Data = (*Q).gBuf[Q->sFront];
     
173.         Q->sFront = (Q->sFront + 1) % BufSizeChar;
     
174.         return TRUE;
     
175. }
     
176. 
     
177. SqQueueSta EnQueueStrChar(SqQueueChar *Q, INT8U *Data,INT16U No)
     
178. {
     
179.         INT16U i = 0;
     
180.         INT16U Len = 0;
     
181.         OS_CPU_SR cpu_sr=0;
     
182.         Len = QueueLenthChar(Q);
     
183.         if(Len >= Q->BufFullCharScal)
     
184.         {
     
185.                 Q->BufEmpty = BufFull;
     
186.         }
     
187.         if(Len <= Q->BufEmptyCharScal)
     
188.         {
     
189.                 Q->BufEmpty = BufEmpty;
     
190.         }
     
191.         if(Len >= (BufSizeChar-No)) return FALSE;       
     
192.         OS_ENTER_CRITICAL();
     
193.         for(i=0; i<No; i++)
     
194.   {
     
195.                 EnQueueChar(Q,Data[i]);
     
196.   }       
     
197.         OS_EXIT_CRITICAL();
     
198.         return TRUE;
     
199. }
     
200. 
     
201. SqQueueSta DeQueueStrChar(SqQueueChar *Q, INT8U *Data,INT16U No)
     
202. {
     
203.         INT16U i = 0;
     
204.         INT16U Len = 0;
     
205.         OS_CPU_SR cpu_sr=0;
     
206.         Len = QueueLenthChar(Q);
     
207.         if(Len >= Q->BufFullCharScal)
     
208.         {
     
209.                 Q->BufEmpty = BufFull;
     
210.         }
     
211.         if(Len <= Q->BufEmptyCharScal)
     
212.         {
     
213.                 Q->BufEmpty = BufEmpty;
     
214.         }
     
215.         if(Len <= No) return FALSE;
     
216.   OS_ENTER_CRITICAL();
     
217.         for(i=0; i<No; i++)
     
218.         {       
     
219.           DeQueueChar(Q,&(Data[i]));
     
220.         }
     
221.         OS_EXIT_CRITICAL();  
     
222.         return TRUE;
     
223. }
     
224. 
     
225. 
     
226. 
     
227. 
     
228. 
     
229. 
     
230. void InitJitterQueueChar(SqJitterQueueChar *Q, INT32U F, INT32U E)
     
231. {
     
232.         Q->sRear  = 0;
     
233.         Q->sFront = 0;
     
234.         Q->BufFullJitterCharScal = F;
     
235.         Q->BufEmptyJitterCharScal = E;
     
236. }
     
237. 
     
238. 
     
239. INT16U JitterQueueLenthChar(SqJitterQueueChar *Q)
     
240. {
     
241.         return(((Q->sRear) - (Q->sFront) + BufSizeJitterChar) % BufSizeJitterChar);
     
242. }
     
243. 
     
244. 
     
245. SqQueueSta EnJitterQueueChar(SqJitterQueueChar *Q, INT8U *Data, INT16U No)
     
246. {
     
247.         INT16U i = 0;
     
248.         INT16U Len = 0;
     
249.         if((((Q->sRear)+1) % BufSizeJitterChar) ==  (Q->sFront))  return FALSE;
     
250.        
     
251.         Len = JitterQueueLenthChar(Q);
     
252.        
     
253.         if(Len >= Q->BufFullJitterCharScal)
     
254.         {
     
255.                 Q->BufEmpty = BufFull;
     
256.         }
     
257.         if(Len <= Q->BufEmptyJitterCharScal)
     
258.         {
     
259.                 Q->BufEmpty = BufEmpty;
     
260.         }
     
261.        
     
262.         (*Q).gBuf[Q->sRear][0] = No;
     
263.         for(i=0; i<No; i++)
     
264.   {
     
265.          (*Q).gBuf[Q->sRear][i + 1] = Data[i];
     
266.         }
     
267.         Q->sRear = (Q->sRear + 1) % BufSizeJitterChar;
     
268.         return TRUE;
     
269. }
     
270. 
     
271. 
     
272. SqQueueSta DeJitterQueueChar(SqJitterQueueChar *Q, INT8U *Data, INT16U *No)
     
273. {
     
274.         INT16U i = 0;
     
275.         INT16U Len = 0;
     
276.         if(Q->sRear == Q->sFront) return FALSE;
     
277.        
     
278.         Len = JitterQueueLenthChar(Q);
     
279.        
     
280.         if(Len >= Q->BufFullJitterCharScal)
     
281.         {
     
282.                 Q->BufEmpty = BufFull;
     
283.         }
     
284.         if(Len <= Q->BufEmptyJitterCharScal)
     
285.         {
     
286.                 Q->BufEmpty = BufEmpty;
     
287.         }
     
288.         *No = (*Q).gBuf[Q->sFront][0];
     
289.         for(i=0; i<(*Q).gBuf[Q->sFront][0]; i++)
     
290.         {
     
291.                 Data[i] = (*Q).gBuf[Q->sFront][i + 1];
     
292.         }
     
293.         Q->sFront = (Q->sFront + 1) % BufSizeJitterChar;
     
294.         return TRUE;
     
295. }
     
296. 
     

复制代码

下面是头文件

1. #ifndef _MEMQUEUE_H_
   
2. #define _MEMQUEUE_H_
   
3. 
   
4. #include "define.h"
   
5. 
   
6. #define BufSizeChar    2160
   
7. #define BufSizeShort   3200
   
8. 
   
9. #define BufFullChar     BufSizeChar - 920
   
10. #define BufFullShort    BufSizeShort - 960
    
11. 
    
12. #define BufEmptyChar     60
    
13. #define BufEmptyShort    640
    
14. 
    
15. 
    
16. #define BufSizeJitterChar     250
    
17. #define FramSizeJitterChar    70
    
18. 
    
19. #define BufFullJitterChar     BufSizeJitterChar - 200
    
20. #define BufEmptyJitterChar     10
    
21. 
    
22. 
    
23. 
    
24. typedef enum {FALSE, TRUE, BufFull, BufEmpty} SqQueueSta;
    
25. 
    
26. 
    
27. 
    
28. typedef struct _SqJitterQueueChar
    
29. {
    
30.         INT8U  gBuf[BufSizeJitterChar][FramSizeJitterChar];
    
31. 
    
32.         INT16U  sFront;
    
33.         INT16U  sRear;
    
34.         INT32U  BufFullJitterCharScal;
    
35.         INT32U  BufEmptyJitterCharScal;
    
36.   SqQueueSta BufEmpty;       
    
37. }SqJitterQueueChar;
    
38. 
    
39. 
    
40. typedef struct _SqQueueChar
    
41. {
    
42.         INT8U  gBuf[BufSizeChar];
    
43. 
    
44.         INT16U  sFront;
    
45.         INT16U  sRear;
    
46.         INT32U  BufFullCharScal;
    
47.         INT32U  BufEmptyCharScal;
    
48.   SqQueueSta BufEmpty;       
    
49. }SqQueueChar;
    
50. 
    
51. 
    
52. typedef struct _SqQueueShort
    
53. {
    
54.         INT16S  gBuf[BufSizeShort];
    
55. 
    
56.         INT16U  sFront;
    
57.         INT16U  sRear;       
    
58.         INT32U  BufFullShortScal;
    
59.         INT32U  BufEmptyShortScal;
    
60.         SqQueueSta BufEmpty;
    
61.        
    
62. }SqQueueShort;
    
63. 
    
64. 
    
65. extern SqQueueChar TestQueue;
    
66. // extern SqQueueChar RxQueue;
    
67. // extern SqQueueChar TxQueue;
    
68. extern SqJitterQueueChar RxQueue;
    
69. // extern SqJitterQueueChar TxQueue;
    
70. 
    
71. extern SqQueueShort AdQueue;
    
72. extern SqQueueShort DaQueue;
    
73. 
    
74. void InitQueueChar(SqQueueChar *Q, INT32U F, INT32U E);
    
75. INT16U QueueLenthChar(SqQueueChar *Q);
    
76. SqQueueSta EnQueueChar(SqQueueChar *Q, INT8U Data);
    
77. SqQueueSta DeQueueChar(SqQueueChar *Q, INT8U *Data);
    
78. SqQueueSta EnQueueStrChar(SqQueueChar *Q, INT8U *Data,INT16U No);
    
79. SqQueueSta DeQueueStrChar(SqQueueChar *Q, INT8U *Data,INT16U No);
    
80. 
    
81. void InitQueueShort(SqQueueShort *Q, INT32U F, INT32U E);
    
82. INT16U QueueLenthShort(SqQueueShort *Q);
    
83. SqQueueSta EnQueueShort(SqQueueShort *Q, INT16S Data);
    
84. SqQueueSta DeQueueShort(SqQueueShort *Q, INT16S *Data);
    
85. SqQueueSta EnQueueStrShort(SqQueueShort *Q, INT16S *Data,INT16U No);
    
86. SqQueueSta DeQueueStrShort(SqQueueShort *Q, INT16S *Data,INT16U No);
    
87. 
    
88. 
    
89. void InitJitterQueueChar(SqJitterQueueChar *Q, INT32U F, INT32U E);
    
90. INT16U JitterQueueLenthChar(SqJitterQueueChar *Q);
    
91. SqQueueSta DeJitterQueueChar(SqJitterQueueChar *Q, INT8U *Data, INT16U *No);
    
92. SqQueueSta EnJitterQueueChar(SqJitterQueueChar *Q, INT8U *Data, INT16U No);
    
93. 
    
94. #endif
    
95. 
    

复制代码

好今天先说到这里，后续，希望对大家有用。

Excellence

gujiamao_love

真的很有用，马上要做个声音强度检测的设备应该会用到

gzhmcu

#在这里快速回复#谢谢分享

radar_12345

收下,谢谢!

jjkkty

可以发一个工程文件出来么？

lixun00

感谢这样的分享

fengyunyu

后续还有么？

jxcylxh

fengyunyu 发表于 2014-4-28 20:43
后续还有么？

有，等我有时间一点点的写。

yaphet0206

关于speex的问题 急需请教  我是个学生 QQ812377513 恳请楼主给个Q或劳烦加我下  真心求教 真心谢过了

wangweigang0

这个不错，上次玩了玩，但没做无线传输。不知道这个做出来用于对讲机效果怎么样。

yaphet0206

wangweigang0 发表于 2014-9-19 08:01
这个不错，上次玩了玩，但没做无线传输。不知道这个做出来用于对讲机效果怎么样。 ...

在么  speex 问题请教

yaphet0206

我的 问题 及 对应的程序 整理到 附件中的压缩文件里了  谁帮忙看下 指点下   正在一个人苦苦摸索的小白  谢谢 各位了

yaphet0206

刚才的附件 有文字遗漏  重新发一个

网上捷克

好的，谢谢，正在研究无线语音