STM32

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

2019-12-25 18:46发布

站内问答 / STM32/STM8
5702 15 15
好久没有发帖了，今天闲下来，和大家分享一下自己研究了大半年的Speex语音压缩库。自己水平也不咋样，如果有讲错的地方还望大家指出来，大家一起学习，这个帖子我会以连载的方式来写，好进入正题：
1,：先讲一讲这个东西怎么用
    其实讲到这里，很多人都会想到ST有提供的现成的基于F103系列的库，没错我就是从这个库里面研究起来的，这个库有他的优点：ST专门对几个滤波器函数优化过，使用汇编写的，删除了一些子模式，并且使用定点运算，再这里先贴一下被ST优化过得那几个函数名称：filter_mem16（）， inner_prod（），vq_nbest（）等等，之所以这样才得以在103上面可以运行起来，缺点嘛：就是被阉割过了，只能使用一个模式，你如果想要更高的语音质量就别想用这个库了，它里面默认的质量是4，最好的质量等级是10,，具体的可以看下面的那个结构体：
5.jpg (98.27 KB, 下载次数: 0) 下载附件 2013-12-20 15:24 上传
这里有一些代码是用于缓存语音的，所以自己写了一个环形队列，为了方便大家阅读，我把代码贴出来：
  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.   */

  19. /** @addtogroup Mem
  20.   * @{
  21.   */

  23. /* Private typedef -----------------------------------------------------------*/
  24. /* Private define ------------------------------------------------------------*/
  25. /* Private macro -------------------------------------------------------------*/
  26. /* Private variables ---------------------------------------------------------*/
  27. SqQueueChar TestQueue;
  28. // SqQueueChar RxQueue;
  29. // SqQueueChar TxQueue;
  30. SqJitterQueueChar RxQueue;


  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);

  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);


  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);


  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. }


  68. INT16U QueueLenthShort(SqQueueShort *Q)
  69. {
  70.         return(((Q->sRear) - (Q->sFront) + BufSizeShort) % BufSizeShort);
  71. }


  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. }


  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. }

  92. SqQueueSta EnQueueStrShort(SqQueueShort *Q, INT16S *Data,INT16U No)
  93. {
  94.         OS_CPU_SR cpu_sr=0;

  96.         INT16U i = 0;
  97.         INT16U Len = 0;


  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. }

  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. }

  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. }


  153. INT16U QueueLenthChar(SqQueueChar *Q)
  154. {
  155.         return(((Q->sRear) - (Q->sFront) + BufSizeChar) % BufSizeChar);
  156. }


  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. }


  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. }

  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. }

  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. }






  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. }


  239. INT16U JitterQueueLenthChar(SqJitterQueueChar *Q)
  240. {
  241.         return(((Q->sRear) - (Q->sFront) + BufSizeJitterChar) % BufSizeJitterChar);
  242. }


  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. }


  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. }

复制代码




下面是头文件




  1. #ifndef _MEMQUEUE_H_
  2. #define _MEMQUEUE_H_

  4. #include "define.h"

  6. #define BufSizeChar    2160
  7. #define BufSizeShort   3200

  9. #define BufFullChar     BufSizeChar - 920
  10. #define BufFullShort    BufSizeShort - 960

  12. #define BufEmptyChar     60
  13. #define BufEmptyShort    640


  16. #define BufSizeJitterChar     250
  17. #define FramSizeJitterChar    70

  19. #define BufFullJitterChar     BufSizeJitterChar - 200
  20. #define BufEmptyJitterChar     10



  24. typedef enum {FALSE, TRUE, BufFull, BufEmpty} SqQueueSta;



  28. typedef struct _SqJitterQueueChar
  29. {
  30.         INT8U  gBuf[BufSizeJitterChar][FramSizeJitterChar];

  32.         INT16U  sFront;
  33.         INT16U  sRear;
  34.         INT32U  BufFullJitterCharScal;
  35.         INT32U  BufEmptyJitterCharScal;
  36.   SqQueueSta BufEmpty;       
  37. }SqJitterQueueChar;


  40. typedef struct _SqQueueChar
  41. {
  42.         INT8U  gBuf[BufSizeChar];

  44.         INT16U  sFront;
  45.         INT16U  sRear;
  46.         INT32U  BufFullCharScal;
  47.         INT32U  BufEmptyCharScal;
  48.   SqQueueSta BufEmpty;       
  49. }SqQueueChar;


  52. typedef struct _SqQueueShort
  53. {
  54.         INT16S  gBuf[BufSizeShort];

  56.         INT16U  sFront;
  57.         INT16U  sRear;       
  58.         INT32U  BufFullShortScal;
  59.         INT32U  BufEmptyShortScal;
  60.         SqQueueSta BufEmpty;
  61.        
  62. }SqQueueShort;


  65. extern SqQueueChar TestQueue;
  66. // extern SqQueueChar RxQueue;
  67. // extern SqQueueChar TxQueue;
  68. extern SqJitterQueueChar RxQueue;
  69. // extern SqJitterQueueChar TxQueue;

  71. extern SqQueueShort AdQueue;
  72. extern SqQueueShort DaQueue;

  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);

  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);


  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);

  94. #endif

复制代码

好今天先说到这里，后续，希望对大家有用。
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
14条回答
fengyunyu
1楼-- · 2019-12-26 15:25
 精彩回答 2  元偷偷看……
jxcylxh
2楼-- · 2019-12-26 20:43
fengyunyu 发表于 2014-4-28 20:43
后续还有么？

有，等我有时间一点点的写。
yaphet0206
3楼-- · 2019-12-26 23:02
关于speex的问题 急需请教  我是个学生 QQ812377513 恳请楼主给个Q或劳烦加我下  真心求教 真心谢过了
wangweigang0
4楼-- · 2019-12-27 02:27
这个不错，上次玩了玩，但没做无线传输。不知道这个做出来用于对讲机效果怎么样。
yaphet0206
5楼-- · 2019-12-27 03:58
wangweigang0 发表于 2014-9-19 08:01
这个不错，上次玩了玩，但没做无线传输。不知道这个做出来用于对讲机效果怎么样。 ...

在么  speex 问题请教
yaphet0206
6楼-- · 2019-12-27 05:35
 精彩回答 2  元偷偷看……
上一页 1 2 3 下一页

一周热门 更多>