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

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

Windows CE

开发平台：

C/C++

pcm_soft.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: pcm_soft.c 585 2006-01-16 09:48:55Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  25. #include "../dyncode/dyncode.h"
  26. #include "pcm_soft.h"
  28. static INLINE int PCMShift(const audio* Format)
  29. {
  30. int Bit = 0;
  31. if (Format->Bits>8) Bit = 1;
  32. if (Format->Bits>16) Bit = 2;
  33. if (!(Format->Flags & PCM_PLANES) && Format->Channels==2)
  34. ++Bit;
  35. return Bit;
  36. }
  38. void PCM_Init()
  39. {
  40. }
  42. void PCM_Done()
  43. {
  44. pcm_soft* p;
  45. while ((p = Context()->PCM)!=NULL)
  46. {
  47. Context()->PCM = p->Next;
  48. CodeDone(&p->Code);
  49. free(p);
  50. }
  51. }
  53. #if (!defined(ARM) && !defined(SH3) && !defined(MIPS)) || !defined(CONFIG_DYNCODE)
  55. void PCM_S16_To_S16_Stereo(pcm_soft* This,const planes DstPtr,const constplanes SrcPtr,int DstLength,pcmstate* State,int Volume)
  56. {
  57. const int32_t* Src = SrcPtr[0];
  58. int32_t* Dst = DstPtr[0];
  59. int32_t* DstEnd = Dst + (DstLength >> 2);
  61. if (State->Step == 256)
  62. memcpy(Dst,Src,DstLength);
  63. else
  64. {
  65. int Pos = State->Pos;
  66. int Step = State->Step;
  68. while (Dst != DstEnd)
  69. {
  70. *(Dst++) = Src[Pos >> 8];
  71. Pos += Step;
  72. }
  73. }
  74. }
  76. void PCM_P32_To_S16_Stereo(pcm_soft* This,const planes DstPtr,const constplanes SrcPtr,int DstLength,pcmstate* State,int Volume)
  77. {
  78. const int32_t* SrcA = SrcPtr[0];
  79. const int32_t* SrcB = SrcPtr[1];
  80. int16_t* Dst = DstPtr[0];
  81. int16_t* DstEnd = Dst + (DstLength >> 1);
  83. int UpLimit = (1 << This->Src.FracBits) - 1;
  84. int DownLimit = -(1 << This->Src.FracBits);
  85. int Shift = This->Src.FracBits - This->Dst.FracBits;
  87. if (State->Step == 256)
  88. {
  89. while (Dst != DstEnd)
  90. {
  91. int Left = *(SrcA++);
  92. int Right = *(SrcB++);
  94. if (Left > UpLimit) Left = UpLimit;
  95. if (Left < DownLimit) Left = DownLimit;
  97. if (Right > UpLimit) Right = UpLimit;
  98. if (Right < DownLimit) Right = DownLimit;
  100. Dst[0] = (int16_t)(Left >> Shift);
  101. Dst[1] = (int16_t)(Right >> Shift);
  102. Dst += 2;
  103. }
  104. }
  105. else
  106. {
  107. int Pos = State->Pos;
  108. int Step = State->Step;
  110. while (Dst != DstEnd)
  111. {
  112. int Left = SrcA[Pos >> 8];
  113. int Right = SrcB[Pos >> 8];
  115. if (Left > UpLimit) Left = UpLimit;
  116. if (Left < DownLimit) Left = DownLimit;
  118. if (Right > UpLimit) Right = UpLimit;
  119. if (Right < DownLimit) Right = DownLimit;
  121. Dst[0] = (int16_t)(Left >> Shift);
  122. Dst[1] = (int16_t)(Right >> Shift);
  123. Dst += 2;
  124. Pos += Step;
  125. }
  126. }
  127. }
  129. void PCMUniversal(pcm_soft* This,const planes DstPtr,const constplanes SrcPtr,int DstLength,pcmstate* State,int Volume)
  130. {
  131. const uint8_t* Src[2];
  132. const uint8_t* DstEnd;
  133. uint8_t* Dst[2];
  134. bool_t SrcSwap = This->SrcSwap;
  135. bool_t DstSwap = This->DstSwap;
  136. int DstType = This->DstType;
  137. int SrcType = This->SrcType;
  138. int DstStep = 1 << This->DstShift;
  139. int Pos = State->Pos;
  140. int Step = State->Step;
  142. float SrcScale = 0;
  143. float DstScale = 0;
  145. int SrcUnsigned = This->SrcUnsigned;
  146. int DstUnsigned = This->DstUnsigned;
  148. int UpLimit = (1 << This->Src.FracBits) - 1;
  149. int DownLimit = -(1 << This->Src.FracBits);
  151. int SrcShift = 31 - This->Src.FracBits;
  152. int DstShift = 31 - This->Dst.FracBits;
  154. bool_t OnlyLeft = (This->Dst.Flags & PCM_ONLY_LEFT) != 0;
  155. bool_t OnlyRight = (This->Dst.Flags & PCM_ONLY_RIGHT) != 0;
  157. bool_t VolumeShift = This->Src.Bits >= 23;
  158. if (!This->UseVolume)
  159. Volume = 256;
  161. if (SrcType >= 12) SrcScale = (float)(1 << This->Src.FracBits);
  162. if (DstType >= 12) DstScale = 1.0f/(1 << This->Dst.FracBits);
  164. Dst[0] = (uint8_t*) DstPtr[0];
  165. Dst[1] = (uint8_t*) DstPtr[1];
  166. Src[0] = (uint8_t*) SrcPtr[0];
  167. Src[1] = (uint8_t*) SrcPtr[1];
  169. DstEnd = Dst[0] + DstLength;
  171. // mono,packed
  172. // mono,planar
  173. // stereo,packed
  174. // stereo,planar
  176. while (Dst[0] != DstEnd)
  177. {
  178. int Left;
  179. int Right;
  181. if (SrcUnsigned)
  182. switch (SrcType)
  183. {
  184. default:
  185. case 0:
  186. case 1:
  187. Left = Right = ((uint8_t*)Src[0])[Pos >> 8] - SrcUnsigned;
  188. break;
  189. case 2:
  190. Left =  ((uint8_t*)Src[0])[(Pos >> 8)*2] - SrcUnsigned;
  191. Right = ((uint8_t*)Src[0])[(Pos >> 8)*2+1] - SrcUnsigned;
  192. break;
  193. case 3:
  194. Left =  ((uint8_t*)Src[0])[(Pos >> 8)] - SrcUnsigned;
  195. Right = ((uint8_t*)Src[1])[(Pos >> 8)] - SrcUnsigned;
  196. break;
  198. case 4:
  199. case 5:
  200. Left = ((uint16_t*)Src[0])[Pos >> 8];
  201. if (SrcSwap)
  202. Left = SWAP16(Left);
  203. Left -= SrcUnsigned;
  204. Right = Left;
  205. break;
  206. case 6:
  207. Left =  ((uint16_t*)Src[0])[(Pos >> 8)*2];
  208. Right = ((uint16_t*)Src[0])[(Pos >> 8)*2+1];
  209. if (SrcSwap)
  210. {
  211. Left = SWAP16(Left);
  212. Right = SWAP16(Right);
  213. }
  214. Left -= SrcUnsigned;
  215. Right -= SrcUnsigned;
  216. break;
  217. case 7:
  218. Left =  ((uint16_t*)Src[0])[(Pos >> 8)];
  219. Right = ((uint16_t*)Src[1])[(Pos >> 8)];
  220. if (SrcSwap)
  221. {
  222. Left = SWAP16(Left);
  223. Right = SWAP16(Right);
  224. }
  225. Left -= SrcUnsigned;
  226. Right -= SrcUnsigned;
  227. break;
  229. case 8:
  230. case 9:
  231. Left = ((uint32_t*)Src[0])[Pos >> 8];
  232. if (SrcSwap)
  233. Left = SWAP32(Left);
  234. Left -= SrcUnsigned;
  235. Right = Left;
  236. break;
  237. case 10:
  238. Left =  ((uint32_t*)Src[0])[(Pos >> 8)*2];
  239. Right = ((uint32_t*)Src[0])[(Pos >> 8)*2+1];
  240. if (SrcSwap)
  241. {
  242. Left = SWAP32(Left);
  243. Right = SWAP32(Right);
  244. }
  245. Left -= SrcUnsigned;
  246. Right -= SrcUnsigned;
  247. break;
  248. case 11:
  249. Left =  ((uint32_t*)Src[0])[(Pos >> 8)];
  250. Right = ((uint32_t*)Src[1])[(Pos >> 8)];
  251. if (SrcSwap)
  252. {
  253. Left = SWAP32(Left);
  254. Right = SWAP32(Right);
  255. }
  256. Left -= SrcUnsigned;
  257. Right -= SrcUnsigned;
  258. break;
  259. }
  260. else
  261. switch (SrcType)
  262. {
  263. default:
  264. case 0:
  265. case 1:
  266. Left = Right = ((int8_t*)Src[0])[Pos >> 8];
  267. break;
  268. case 2:
  269. Left =  ((int8_t*)Src[0])[(Pos >> 8)*2];
  270. Right = ((int8_t*)Src[0])[(Pos >> 8)*2+1];
  271. break;
  272. case 3:
  273. Left =  ((int8_t*)Src[0])[(Pos >> 8)];
  274. Right = ((int8_t*)Src[1])[(Pos >> 8)];
  275. break;
  277. case 4:
  278. case 5:
  279. Left = ((int16_t*)Src[0])[Pos >> 8];
  280. if (SrcSwap)
  281. Left = (int16_t)SWAP16(Left);
  282. Right = Left;
  283. break;
  284. case 6:
  285. Left = ((int16_t*)Src[0])[(Pos >> 8)*2];
  286. Right = ((int16_t*)Src[0])[(Pos >> 8)*2+1];
  287. if (SrcSwap)
  288. {
  289. Left = (int16_t)SWAP16(Left);
  290. Right = (int16_t)SWAP16(Right);
  291. }
  292. break;
  293. case 7:
  294. Left =  ((int16_t*)Src[0])[(Pos >> 8)];
  295. Right = ((int16_t*)Src[1])[(Pos >> 8)];
  296. if (SrcSwap)
  297. {
  298. Left = (int16_t)SWAP16(Left);
  299. Right = (int16_t)SWAP16(Right);
  300. }
  301. break;
  303. case 8:
  304. case 9:
  305. Left = ((int32_t*)Src[0])[Pos >> 8];
  306. if (SrcSwap)
  307. Left = (int32_t)SWAP32(Left);
  308. Right = Left;
  309. break;
  310. case 10:
  311. Left =  ((int32_t*)Src[0])[(Pos >> 8)*2];
  312. Right = ((int32_t*)Src[0])[(Pos >> 8)*2+1];
  313. if (SrcSwap)
  314. {
  315. Left = (int32_t)SWAP32(Left);
  316. Right = (int32_t)SWAP32(Right);
  317. }
  318. break;
  319. case 11:
  320. Left =  ((int32_t*)Src[0])[(Pos >> 8)];
  321. Right = ((int32_t*)Src[1])[(Pos >> 8)];
  322. if (SrcSwap)
  323. {
  324. Left = (int32_t)SWAP32(Left);
  325. Right = (int32_t)SWAP32(Right);
  326. }
  327. break;
  328. case 12:
  329. case 13:
  330. Left = (int)(((float*)Src[0])[Pos >> 8]*SrcScale);
  331. Right = Left;
  332. break;
  333. case 14:
  334. Left =  (int)(((float*)Src[0])[(Pos >> 8)*2]*SrcScale);
  335. Right = (int)(((float*)Src[0])[(Pos >> 8)*2+1]*SrcScale);
  336. break;
  337. case 15:
  338. Left =  (int)(((float*)Src[0])[(Pos >> 8)]*SrcScale);
  339. Right = (int)(((float*)Src[1])[(Pos >> 8)]*SrcScale);
  340. break;
  341. }
  343. if (Volume != 256)
  344. {
  345. if (VolumeShift)
  346. {
  347. Left = (Left >> 8) * Volume;
  348. Right = (Right >> 8) * Volume;
  349. }
  350. else
  351. {
  352. Left = (Left * Volume) >> 8;
  353. Right = (Right * Volume) >> 8;
  354. }
  355. }
  357. if (Left > UpLimit) Left = UpLimit;
  358. if (Left < DownLimit) Left = DownLimit;
  360. if (Right > UpLimit) Right = UpLimit;
  361. if (Right < DownLimit) Right = DownLimit;
  363. Left <<= SrcShift;
  364. Right <<= SrcShift;
  366. Left >>= DstShift;
  367. Right >>= DstShift;
  369. if (OnlyLeft)
  370. Right = Left;
  371. if (OnlyRight)
  372. Left = Right;
  374. if ((This->Src.Flags ^ This->Dst.Flags) & PCM_SWAPPEDSTEREO)
  375. SwapInt(&Left,&Right);
  377. switch (DstType)
  378. {
  379. default:
  380. case 0:
  381. case 1:
  382. ((int8_t*)Dst[0])[0] = (int8_t)(((Left + Right) >> 1) + DstUnsigned);
  383. break;
  384. case 2:
  385. ((int8_t*)Dst[0])[0] = (int8_t)(Left + DstUnsigned);
  386. ((int8_t*)Dst[0])[1] = (int8_t)(Right + DstUnsigned);
  387. break;
  388. case 3:
  389. ((int8_t*)Dst[0])[0] = (int8_t)(Left + DstUnsigned);
  390. ((int8_t*)Dst[1])[0] = (int8_t)(Right + DstUnsigned);
  391. break;
  393. case 4:
  394. case 5:
  395. Left = ((Left + Right) >> 1) + DstUnsigned;
  396. if (DstSwap)
  397. Left = SWAP16(Left);
  398. ((int16_t*)Dst[0])[0] = (int16_t)Left;
  399. break;
  400. case 6:
  401. Left += DstUnsigned;
  402. Right += DstUnsigned;
  403. if (DstSwap)
  404. {
  405. Left = SWAP16(Left);
  406. Right = SWAP16(Right);
  407. }
  408. ((int16_t*)Dst[0])[0] = (int16_t)Left;
  409. ((int16_t*)Dst[0])[1] = (int16_t)Right;
  410. break;
  411. case 7:
  412. Left += DstUnsigned;
  413. Right += DstUnsigned;
  414. if (DstSwap)
  415. {
  416. Left = SWAP16(Left);
  417. Right = SWAP16(Right);
  418. }
  419. ((int16_t*)Dst[0])[0] = (int16_t)Left;
  420. ((int16_t*)Dst[1])[0] = (int16_t)Right;
  421. break;
  423. case 8:
  424. case 9:
  425. Left = ((Left + Right) >> 1) + DstUnsigned;
  426. if (DstSwap)
  427. Left = SWAP32(Left);
  428. ((int32_t*)Dst[0])[0] = Left;
  429. break;
  430. case 10:
  431. Left += DstUnsigned;
  432. Right += DstUnsigned;
  433. if (DstSwap)
  434. {
  435. Left = SWAP32(Left);
  436. Right = SWAP32(Right);
  437. }
  438. ((int32_t*)Dst[0])[0] = Left;
  439. ((int32_t*)Dst[0])[1] = Right;
  440. break;
  441. case 11:
  442. Left += DstUnsigned;
  443. Right += DstUnsigned;
  444. if (DstSwap)
  445. {
  446. Left = SWAP32(Left);
  447. Right = SWAP32(Right);
  448. }
  449. ((int32_t*)Dst[0])[0] = Left;
  450. ((int32_t*)Dst[1])[0] = Right;
  451. break;
  452. case 12:
  453. case 13:
  454. Left = (Left + Right) >> 1;
  455. ((float*)Dst[0])[0] = (float)Left*DstScale;
  456. break;
  457. case 14:
  458. ((float*)Dst[0])[0] = (float)Left*DstScale;
  459. ((float*)Dst[0])[1] = (float)Right*DstScale;
  460. break;
  461. case 15:
  462. ((float*)Dst[0])[0] = (float)Left*DstScale;
  463. ((float*)Dst[1])[0] = (float)Right*DstScale;
  464. break;
  465. }
  467. Pos += Step;
  468. Dst[0] += DstStep;
  469. Dst[1] += DstStep;
  470. }
  471. }
  473. static int UniversalType(const audio* Format)
  474. {
  475. int Type = (Format->Channels - 1)*2;
  476. if (Format->Flags & PCM_PLANES) Type |= 1;
  477. if (Format->Flags & PCM_FLOAT) 
  478. Type += 12;
  479. else
  480. {
  481. if (Format->Bits>8) Type += 4;
  482. if (Format->Bits>16) Type += 4;
  483. }
  484. return Type;
  485. }
  487. #endif
  489. pcm_soft* PCMCreate(const audio* DstFormat, const audio* SrcFormat, bool_t Dither, bool_t UseVolume)
  490. {
  491. pcm_soft* p = Context()->PCM;
  492. if (p)
  493. Context()->PCM = p->Next;
  494. else
  495. {
  496. p = (pcm_soft*)malloc(sizeof(pcm_soft));
  497. if (!p)
  498. return NULL;
  500. memset(p,0,sizeof(pcm_soft));
  501. CodeInit(&p->Code);
  502. }
  504. if (!EqAudio(&p->Dst,DstFormat) ||
  505. !EqAudio(&p->Src,SrcFormat) ||
  506. p->UseVolume != UseVolume || 
  507. p->Dither != Dither)
  508. {
  509. p->Entry = NULL;
  510. p->Dst = *DstFormat;
  511. p->Src = *SrcFormat;
  512. p->Dither = Dither;
  513. p->UseVolume = UseVolume;
  515. // only PCM streams are supported
  516. if (p->Dst.Format==AUDIOFMT_PCM && p->Src.Format==AUDIOFMT_PCM) 
  517. {
  518. p->SrcSwap = (p->Src.Flags & PCM_SWAPEDBYTES)!=0 && (p->Src.Bits>8);
  519. p->DstSwap = (p->Dst.Flags & PCM_SWAPEDBYTES)!=0 && (p->Dst.Bits>8);
  520. p->SrcShift = PCMShift(&p->Src);
  521. p->DstShift = PCMShift(&p->Dst);
  523. p->SrcUnsigned = (p->Src.Flags & PCM_UNSIGNED) ? (1 << (p->Src.Bits-1)):0;
  524. p->DstUnsigned = (p->Dst.Flags & PCM_UNSIGNED) ? (1 << (p->Dst.Bits-1)):0;
  526. p->UseLeft = (p->Dst.Flags & PCM_ONLY_RIGHT)==0 || (p->Src.Channels <= 1);
  527. p->UseRight = (p->Dst.Flags & PCM_ONLY_LEFT)==0 && (p->Src.Channels > 1);
  528. p->SrcChannels = (p->UseLeft && p->UseRight) ? 2:1;
  530. p->Clip = (p->Src.Bits - p->Src.FracBits) - (p->Dst.Bits - p->Dst.FracBits);
  531. p->Stereo = p->SrcChannels > 1 && p->Dst.Channels > 1;
  532. p->Join = !p->Stereo && (p->SrcChannels > 1);
  534. p->Shift = p->Dst.FracBits - p->Src.FracBits - p->Join;
  535. p->LifeDriveFix = !p->UseVolume && !(p->Src.Flags & PCM_LIFEDRIVE_FIX) && (p->Dst.Flags & PCM_LIFEDRIVE_FIX) && p->Dst.Bits==16;
  536. p->ActualDither = !p->LifeDriveFix && !p->UseVolume && p->Dither && ((p->Clip>0) || (p->Shift<0));
  538. p->Limit2 = p->Src.Bits + p->Join - p->Clip - 1;
  540. if (p->UseVolume && p->Src.Bits < 23)
  541. {
  542. p->Shift -= 8;
  543. p->Limit2 += 8;
  544. }
  546. p->MaxLimit = (1 << p->Limit2) - 1;
  547. p->MinLimit = -(1 << p->Limit2);
  549. p->State.Speed = -1;
  550. p->State.Step = 256;
  552. #if (defined(ARM) || defined(SH3) || defined(MIPS)) && defined(CONFIG_DYNCODE)
  553. CodeStart(&p->Code);
  554. PCMCompile(p);
  555. CodeBuild(&p->Code);
  556. if (p->Code.Size)
  557. p->Entry = (pcmsoftentry)p->Code.Code;
  558. #else
  559. p->SrcType = UniversalType(&p->Src);
  560. p->DstType = UniversalType(&p->Dst);
  561. p->Entry = PCMUniversal;
  563. if (!p->UseVolume && !p->DstUnsigned && p->DstType==6 &&
  564. !((p->Src.Flags ^ p->Dst.Flags) & PCM_SWAPPEDSTEREO) &&
  565. !p->SrcSwap && !p->DstSwap && 
  566. !(p->Dst.Flags & (PCM_ONLY_LEFT|PCM_ONLY_RIGHT)))
  567. {
  568. if (p->Src.FracBits >= p->Dst.FracBits && !p->SrcUnsigned && p->SrcType==11 && !p->SrcSwap && !p->DstSwap)
  569. p->Entry = PCM_P32_To_S16_Stereo;
  570. else
  571. if (p->Src.FracBits == p->Dst.FracBits && !p->SrcUnsigned && p->SrcType==6)
  572. p->Entry = PCM_S16_To_S16_Stereo;
  573. }
  574. #endif
  575. }
  576. }
  578. if (!p->Entry)
  579. {
  580. PCMRelease(p);
  581. p = NULL;
  582. }
  584. PCMReset(p);
  585. return p;
  586. }
  588. void PCMRelease(pcm_soft* p)
  589. {
  590. if (p)
  591. {
  592. p->Next = Context()->PCM;
  593. Context()->PCM = p;
  594. }
  595. }
  597. int PCMDstLength(pcm_soft* p, int SrcLength)
  598. {
  599. return (SrcLength >> p->SrcShift) << p->DstShift;
  600. }
  602. void PCMConvert(pcm_soft* p, const planes Dst, const constplanes Src, int* DstLength, int* SrcLength, int Speed, int Volume)
  603. {
  604. int SrcSamples;
  605. int DstSamples;
  606. int AvailSamples;
  607. if (!p || !p->Entry) return;
  609. SrcSamples = *SrcLength >> p->SrcShift;
  610. DstSamples = *DstLength >> p->DstShift;
  612. if (p->State.Speed != Speed)
  613. {
  614. p->State.Speed = Speed;
  615. p->State.Step = Scale(Speed,p->Src.SampleRate,p->Dst.SampleRate*256);
  616. if (p->State.Step<=0)
  617. p->State.Step = 256;
  618. }
  620. if (p->State.Step != 256)
  621. {
  622. AvailSamples = ((SrcSamples << 8) - p->State.Pos + p->State.Step - 1) / p->State.Step;
  623. if (DstSamples > AvailSamples)
  624. DstSamples = AvailSamples;
  626. AvailSamples = (p->State.Pos + DstSamples * p->State.Step) >> 8;
  627. if (SrcSamples > AvailSamples)
  628. SrcSamples = AvailSamples;
  629. }
  630. else
  631. {
  632. if (DstSamples > SrcSamples)
  633. DstSamples = SrcSamples;
  634. SrcSamples = DstSamples;
  635. }
  637. *SrcLength = SrcSamples << p->SrcShift;
  638. *DstLength = DstSamples << p->DstShift;
  640. if (DstSamples)
  641. p->Entry(p,Dst,Src,*DstLength,&p->State,Volume);
  643. p->State.Pos += (DstSamples * p->State.Step) - (SrcSamples << 8);
  644. }
  646. void PCMReset(pcm_soft* p)
  647. {
  648. if (p)
  649. {
  650. p->State.Pos = 0;
  651. p->State.Dither[0] = 0;
  652. p->State.Dither[1] = 0;
  653. }
  654. }