开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
adpcm.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：11k
源码类别：

Windows CE

开发平台：

C/C++

adpcm.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: adpcm.c 565 2006-01-12 14:11:44Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "adpcm.h"
  26. #include "g726/g72x.h"
  28. typedef struct state 
  29. {
  30.     int Predictor;
  31.     int StepIndex;
  32.     int Step;
  33.     int Sample1;
  34.     int Sample2;
  35.     int CoEff1;
  36.     int CoEff2;
  37.     int IDelta;
  39. } state;
  41. typedef struct adpcm
  42. {
  43. codec Codec;
  44. buffer Data;
  46. int Channel; //IMA_QT
  47. int16_t* Buffer;
  48. state State[2];
  49. g726_state G726[2];
  51. } adpcm;
  53. static const int IndexTable[16] = 
  54. {
  55.     -1, -1, -1, -1, 2, 4, 6, 8,
  56.     -1, -1, -1, -1, 2, 4, 6, 8,
  57. };
  59. static const int StepTable[89] = 
  60. {
  61.     7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
  62.     19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
  63.     50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
  64.     130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
  65.     337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
  66.     876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
  67.     2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
  68.     5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
  69.     15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
  70. };
  72. // AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile
  73. static const int AdaptationTable[] = 
  74. {
  75. 230, 230, 230, 230, 307, 409, 512, 614,
  76. 768, 614, 512, 409, 307, 230, 230, 230
  77. };
  78. static const int AdaptCoeff1[] = 
  79. {
  80. 256, 512, 0, 192, 240, 460, 392
  81. };
  82. static const int AdaptCoeff2[] = 
  83. {
  84. 0, -256, 0, 64, 0, -208, -232
  85. };
  87. static _INLINE int IMA_Calc(state* s, int v)
  88. {
  89.     int StepIndex;
  90.     int Predictor;
  91.     int Diff,Step;
  93.     Step = StepTable[s->StepIndex];
  94.     StepIndex = s->StepIndex + IndexTable[v];
  96.     if (StepIndex < 0) 
  97. StepIndex = 0;
  98.     else if (StepIndex > 88) 
  99. StepIndex = 88;
  101.     Diff = ((2 * (v & 7) + 1) * Step) >> 3;
  103.     Predictor = s->Predictor;
  104.     if (v & 8) 
  105. Predictor -= Diff;
  106.     else 
  107. Predictor += Diff;
  109. if (Predictor > 32767) 
  110. Predictor = 32767;
  111. else if (Predictor < -32768) 
  112. Predictor = -32768;
  114.     s->Predictor = Predictor;
  115.     s->StepIndex = StepIndex;
  117.     return Predictor;
  118. }
  120. static _INLINE int MS_Calc(state* s, int v)
  121. {
  122.     int Predictor;
  124.     Predictor = ((s->Sample1 * s->CoEff1) + (s->Sample2 * s->CoEff2)) >> 8;
  125.     Predictor += ((v & 0x08) ? v-0x10:v) * s->IDelta;
  127. if (Predictor > 32767) 
  128. Predictor = 32767;
  129. else if (Predictor < -32768) 
  130. Predictor = -32768;
  132.     s->Sample2 = s->Sample1;
  133.     s->Sample1 = Predictor;
  134.     s->IDelta = (AdaptationTable[v] * s->IDelta) >> 8;
  135.     if (s->IDelta < 16) 
  136. s->IDelta = 16;
  138.     return Predictor;
  139. }
  141. static int Process(adpcm* p, const packet* Packet, const flowstate* State)
  142. {
  143. int i;
  144. int Predictor;
  145. const uint8_t* In;
  146. const uint8_t* InEnd;
  147. int16_t* Out = p->Buffer;
  149. if (Packet)
  150. {
  151. if (Packet->RefTime >= 0)
  152. p->Codec.Packet.RefTime = Packet->RefTime;
  154. BufferPack(&p->Data,0);
  155. BufferWrite(&p->Data,Packet->Data[0],Packet->Length,1024);
  156. }
  157. else
  158. p->Codec.Packet.RefTime = TIME_UNKNOWN;
  160. if (!BufferRead(&p->Data,&In,p->Codec.In.Format.Format.Audio.BlockAlign))
  161. return ERR_NEED_MORE_DATA;
  163. InEnd = In + p->Codec.In.Format.Format.Audio.BlockAlign;
  165. switch (p->Codec.Node.Class)
  166. {
  167. case ADPCM_G726_ID:
  168. {
  169. g726_state *g1,*g2;
  170. g1 = g2 = &p->G726[0];
  171. if (p->Codec.In.Format.Format.Audio.Channels==2)
  172. ++g2;
  174. switch (p->Codec.In.Format.Format.Audio.Bits)
  175. {
  176. case 2:
  177. for (;In<InEnd;++In,Out+=4)
  178. {
  179. Out[0] = (int16_t)g726_16_decoder(In[0] >> 6,g1);
  180. Out[1] = (int16_t)g726_16_decoder(In[0] >> 4,g2);
  181. Out[2] = (int16_t)g726_16_decoder(In[0] >> 2,g1);
  182. Out[3] = (int16_t)g726_16_decoder(In[0],g2);
  183. }
  184. break;
  185. case 3:
  186. InEnd -= 2;
  187. for (;In<InEnd;In+=3,Out+=8)
  188. {
  189. Out[0] = (int16_t)g726_24_decoder(In[0] >> 5,g1);
  190. Out[1] = (int16_t)g726_24_decoder(In[0] >> 2,g2);
  191. Out[2] = (int16_t)g726_24_decoder((In[0] << 1) | (In[1] >> 7),g1);
  192. Out[3] = (int16_t)g726_24_decoder(In[1] >> 4,g2);
  193. Out[4] = (int16_t)g726_24_decoder(In[1] >> 1,g1);
  194. Out[5] = (int16_t)g726_24_decoder((In[1] << 2) | (In[2] >> 6),g2);
  195. Out[6] = (int16_t)g726_24_decoder(In[2] >> 3,g1);
  196. Out[7] = (int16_t)g726_24_decoder(In[2] >> 0,g2);
  197. }
  198. break;
  199. case 4:
  200. for (;In<InEnd;++In,Out+=2)
  201. {
  202. Out[0] = (int16_t)g726_32_decoder(In[0] >> 4,g1);
  203. Out[1] = (int16_t)g726_32_decoder(In[0],g2);
  204. }
  205. break;
  206. case 5:
  207. InEnd -= 4;
  208. for (;In<InEnd;In+=5,Out+=8)
  209. {
  210. Out[0] = (int16_t)g726_40_decoder(In[0] >> 3,g1);
  211. Out[1] = (int16_t)g726_40_decoder((In[0] << 2) | (In[1] >> 6),g2);
  212. Out[2] = (int16_t)g726_40_decoder(In[1] >> 1,g1);
  213. Out[3] = (int16_t)g726_40_decoder((In[1] << 4) | (In[2] >> 4),g2);
  214. Out[4] = (int16_t)g726_40_decoder((In[2] << 1) | (In[3] >> 7),g1);
  215. Out[5] = (int16_t)g726_40_decoder(In[3] >> 2,g2);
  216. Out[6] = (int16_t)g726_40_decoder((In[3] << 3) | (In[4] >> 5),g1);
  217. Out[7] = (int16_t)g726_40_decoder(In[4] >> 0,g2);
  218. }
  219. break;
  220. }
  221. break;
  222. }
  223. case ADPCM_IMA_QT_ID:
  224. {
  225. int No,Ch;
  226. Ch = p->Codec.In.Format.Format.Audio.Channels;
  227. for (No=0;No<Ch;++No)
  228. {
  229. state *s;
  230. s = &p->State[0];
  231. s->Predictor = (int16_t)((In[1] & 0x80) | (In[0] << 8));
  233. s->StepIndex = In[1] & 0x7F;
  234. if (s->StepIndex > 88) 
  235. s->StepIndex = 88;
  237. In+=2;
  238. InEnd=In+32;
  239. Out = p->Buffer+No;
  241. for (;In<InEnd;++In)
  242. {
  243. *Out = (int16_t)IMA_Calc(s, In[0] & 0x0F);
  244. Out+=Ch;
  245. *Out = (int16_t)IMA_Calc(s, In[0] >> 4);
  246. Out+=Ch;
  247. }
  248. }
  250. Out = p->Buffer+Ch*64;
  251. break;
  252. }
  254. case ADPCM_IMA_ID:
  255. {
  256. state *s1,*s2;
  257. s1 = &p->State[0];
  258. s1->Predictor = (int16_t)(In[0] | (In[1] << 8));
  259. In+=2;
  261. s1->StepIndex = *In++;
  262. if (s1->StepIndex > 88) 
  263. s1->StepIndex = 88;
  264. ++In;
  266. if (p->Codec.In.Format.Format.Audio.Channels == 2)
  267. {
  268. s2 = &p->State[1];
  269. s2->Predictor = (int16_t)(In[0] | (In[1] << 8));
  270. In+=2;
  272. s2->StepIndex = *In++;
  273. if (s2->StepIndex > 88) 
  274. s2->StepIndex = 88;
  275. ++In;
  277. for (i=4;In<InEnd;++In,Out+=4)
  278. {
  279. Out[0] = (int16_t)IMA_Calc(s1, In[0] & 0x0F);
  280. Out[1] = (int16_t)IMA_Calc(s2, In[4] & 0x0F);
  281. Out[2] = (int16_t)IMA_Calc(s1, In[0] >> 4);
  282. Out[3] = (int16_t)IMA_Calc(s2, In[4] >> 4);
  284. if (--i==0)
  285. {
  286. i=4;
  287. In+=4;
  288. }
  289. }
  290. }
  291. else
  292. {
  293. for (;In<InEnd;++In,Out+=2)
  294. {
  295. Out[0] = (int16_t)IMA_Calc(s1, In[0] & 0x0F);
  296. Out[1] = (int16_t)IMA_Calc(s1, In[0] >> 4);
  297. }
  298. }
  299. break;
  300. }
  301. case ADPCM_MS_ID:
  302. {
  303. state *s1,*s2;
  304. s1 = &p->State[0];
  305. s2 = p->Codec.In.Format.Format.Audio.Channels==2 ? &p->State[1] : s1;
  307. Predictor = *In++;
  308. if (Predictor > 7)
  309. Predictor = 7;
  310. s1->CoEff1 = AdaptCoeff1[Predictor];
  311. s1->CoEff2 = AdaptCoeff2[Predictor];
  313. if (s2 != s1)
  314. {
  315. Predictor = *In++;
  316. if (Predictor > 7)
  317. Predictor = 7;
  318. s2->CoEff1 = AdaptCoeff1[Predictor];
  319. s2->CoEff2 = AdaptCoeff2[Predictor];
  320. }
  322. s1->IDelta = (int16_t)(In[0] | (In[1] << 8));
  323. In+=2;
  325. if (s2 != s1)
  326. {
  327. s2->IDelta = (int16_t)(In[0] | (In[1] << 8));
  328. In+=2;
  329. }
  331. s1->Sample1 = (int16_t)(In[0] | (In[1] << 8));
  332. In+=2;
  333. if (s2 != s1)
  334. {
  335. s2->Sample1 = (int16_t)(In[0] | (In[1] << 8));
  336. In+=2;
  337. }
  339. s1->Sample2 = (int16_t)(In[0] | (In[1] << 8));
  340. In+=2;
  341. if (s2 != s1)
  342. {
  343. s2->Sample2 = (int16_t)(In[0] | (In[1] << 8));
  344. In+=2;
  345. }
  347. *Out++ = (int16_t)s1->Sample1;
  348. if (s2 != s1) *Out++ = (int16_t)s2->Sample1;
  350. *Out++ = (int16_t)s1->Sample2;
  351. if (s2 != s1) *Out++ = (int16_t)s2->Sample2;
  353. for (;In<InEnd;++In,Out+=2)
  354. {
  355. Out[0] = (int16_t)MS_Calc(s1, In[0] >> 4);
  356. Out[1] = (int16_t)MS_Calc(s2, In[0] & 0x0F);
  357. }
  358. break;
  359. }
  360. }
  362. p->Codec.Packet.Length = (uint8_t*)Out - (uint8_t*)p->Buffer;
  363. return ERR_NONE;
  364. }
  366. static int UpdateInput(adpcm* p)
  367. {
  368. BufferClear(&p->Data);
  369. free(p->Buffer);
  370. p->Buffer = NULL;
  372. if (p->Codec.In.Format.Type == PACKET_AUDIO)
  373. {
  374. PacketFormatPCM(&p->Codec.Out.Format,&p->Codec.In.Format,16);
  376. if (!p->Codec.In.Format.Format.Audio.BlockAlign)
  377. p->Codec.In.Format.Format.Audio.BlockAlign = 1024;
  379. if (p->Codec.Node.Class == ADPCM_IMA_QT_ID)
  380. p->Codec.In.Format.Format.Audio.BlockAlign = (32+2)*p->Codec.In.Format.Format.Audio.Channels;
  382. if (p->Codec.Node.Class == ADPCM_G726_ID)
  383. {
  384. p->Codec.In.Format.Format.Audio.BlockAlign = 120;
  385. g726_init_state(&p->G726[0]);
  386. g726_init_state(&p->G726[1]);
  387. }
  389. p->Buffer = (int16_t*) malloc(sizeof(int16_t)*4*p->Codec.In.Format.Format.Audio.BlockAlign);
  390. if (!p->Buffer)
  391. return ERR_OUT_OF_MEMORY;
  393. p->Codec.Packet.Data[0] = p->Buffer;
  394. }
  396. return ERR_NONE;
  397. }
  399. static int Flush(adpcm* p)
  400. {
  401. if (p->Codec.Node.Class == ADPCM_G726_ID)
  402. {
  403. g726_init_state(&p->G726[0]);
  404. g726_init_state(&p->G726[1]);
  405. }
  406. BufferDrop(&p->Data);
  407. p->Channel = 0;
  408. return ERR_NONE;
  409. }
  411. static int Create(adpcm* p)
  412. {
  413. p->Codec.Process = (packetprocess)Process;
  414. p->Codec.UpdateInput = (nodefunc)UpdateInput;
  415. p->Codec.Flush = (nodefunc)Flush;
  416. return ERR_NONE;
  417. }
  419. static const nodedef ADPCM =
  420. {
  421. sizeof(adpcm)|CF_ABSTRACT,
  422. ADPCM_CLASS,
  423. CODEC_CLASS,
  424. PRI_DEFAULT,
  425. (nodecreate)Create,
  426. NULL,
  427. };
  429. static const nodedef ADPCM_MS =
  430. {
  431. 0, //parent size
  432. ADPCM_MS_ID,
  433. ADPCM_CLASS,
  434. PRI_DEFAULT,
  435. NULL,
  436. NULL,
  437. };
  439. static const nodedef ADPCM_IMA =
  440. {
  441. 0, //parent size
  442. ADPCM_IMA_ID,
  443. ADPCM_CLASS,
  444. PRI_DEFAULT,
  445. NULL,
  446. NULL,
  447. };
  449. static const nodedef ADPCM_IMA_QT =
  450. {
  451. 0, //parent size
  452. ADPCM_IMA_QT_ID,
  453. ADPCM_CLASS,
  454. PRI_DEFAULT,
  455. NULL,
  456. NULL,
  457. };
  459. static const nodedef ADPCM_G726 =
  460. {
  461. 0, //parent size
  462. ADPCM_G726_ID,
  463. ADPCM_CLASS,
  464. PRI_DEFAULT,
  465. NULL,
  466. NULL,
  467. };
  469. void ADPCM_Init()
  470. {
  471. NodeRegisterClass(&ADPCM);
  472. NodeRegisterClass(&ADPCM_MS);
  473. NodeRegisterClass(&ADPCM_IMA);
  474. NodeRegisterClass(&ADPCM_IMA_QT);
  475. NodeRegisterClass(&ADPCM_G726);
  476. }
  478. void ADPCM_Done()
  479. {
  480. NodeUnRegisterClass(ADPCM_MS_ID);
  481. NodeUnRegisterClass(ADPCM_IMA_ID);
  482. NodeUnRegisterClass(ADPCM_IMA_QT_ID);
  483. NodeUnRegisterClass(ADPCM_G726_ID);
  484. NodeUnRegisterClass(ADPCM_CLASS);
  485. }