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

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

Windows CE

开发平台：

C/C++

waveout_win32.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: waveout_win32.c 543 2006-01-07 22:06:24Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  25. #include <math.h>
  27. #if defined(TARGET_WIN32) || defined(TARGET_WINCE)
  29. #define BUFFER_MUSIC 1*TICKSPERSEC
  30. #define BUFFER_VIDEO 2*TICKSPERSEC
  32. #ifndef STRICT
  33. #define STRICT
  34. #endif
  35. #include <windows.h>
  37. #define BENCH_SIZE 32
  39. struct waveout;
  41. typedef struct wavebuffer
  42. {
  43. WAVEHDR Head;
  44. planes Planes;
  45. struct wavebuffer* Next; //next in chain
  46. struct wavebuffer* GlobalNext;
  47. tick_t RefTime;
  48. tick_t EstRefTime;
  49. int Bytes;
  50. block Block;
  52. } wavebuffer;
  54. typedef struct waveout
  55. {
  56. node Node;
  57. node Timer;
  58. pin Pin;
  59. packetformat Input;
  60. packetformat Output;
  61. packetprocess Process;
  63. wavebuffer* Buffers; // global chain
  64. wavebuffer* FreeFirst;
  65. wavebuffer* FreeLast;
  67. int BufferLength; // one buffer length (waveout format)
  68. tick_t BufferScaledTime; // scaled time of one waveout buffer (BufferLength)
  69. int BufferScaledAdjust; // waveout bytes to scaled time convert (12bit fixed point)
  71. int Total; // source format
  72. int Dropped; // dropped packets
  74. int Bytes; // output format
  75. int FillPos;
  76. int Skip;
  77. wavebuffer* FillFirst;
  78. wavebuffer* FillLast;
  79. wavebuffer** Pausing;
  80. tick_t FillLastTime;
  82. HWAVEOUT Handle;
  83. CRITICAL_SECTION Section;
  85. void* PCM;
  86. int PCMSpeed;
  87. int BufferLimit;
  88. int BufferLimitFull;
  89. tick_t Tick;
  90. int TimeRef;
  91. LONG Waiting; // number of waiting buffers in WaveOut
  92. LONG Used; // number of used buffers (waiting or in fill chain)
  94. bool_t Play;
  95. fraction Speed;
  96. fraction SpeedTime;
  97. int AdjustedRate;
  99. bool_t Dither;
  100. bool_t BufferMode;
  101. int Stereo;
  102. int Quality;
  104. bool_t ForcePriority;
  105. bool_t SoftwareVolume;
  106. bool_t MonoVol;
  107. bool_t Mute; 
  108. int PreAmp;
  109. int VolumeDev; // backup value when mute is turned on
  110. int VolumeSoft;
  111. int VolumeSoftLog;
  112. int VolumeRamp;
  114. WAVEFORMATEX Format;
  116. int BenchWait[BENCH_SIZE];
  117. int BenchSum[BENCH_SIZE];
  118. int BenchCurrSum;
  119. int BenchAvg;
  120. int BenchAdj;
  121. size_t BenchAvgLimit;
  122. int BenchSpeedAvg;
  123. int BenchWaitPos;
  125. } waveout;
  127. #define WAVEOUT(p) ((waveout*)((char*)(p)-OFS(waveout,Timer)))
  129. static void Pause(waveout* p);
  130. static void Write(waveout* p, tick_t CurrTime);
  132. static int SetVolumeSoft(waveout* p,int v,bool_t m)
  133. {
  134. int OldVolumeSoftLog = p->VolumeSoftLog;
  135. bool_t OldSkip = p->Mute || p->VolumeSoft==0;
  137. p->VolumeSoft = v;
  138. p->Mute = m;
  140. if (p->SoftwareVolume || p->PreAmp)
  141. {
  142. if (p->SoftwareVolume && p->Handle && (p->Mute || p->VolumeSoft==0)!=OldSkip)
  143. {
  144. if (!OldSkip)
  145. Pause(p);
  146. else 
  147. if (p->Play)
  148. {
  149. // adjust tick so packets without RefTime won't mess up timing
  150. EnterCriticalSection(&p->Section);
  151. p->Tick += Scale(GetTimeTick()-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
  152. p->TimeRef = GetTimeTick();
  153. LeaveCriticalSection(&p->Section);
  154. }
  155. }
  157. v += p->PreAmp;
  158. if (v<-40) v=-40;
  160. p->VolumeSoftLog = (int)(pow(10,(50+v)/62.3));
  161. if (p->VolumeSoftLog < 3)
  162. p->VolumeSoftLog = 3;
  163. }
  164. else
  165. p->VolumeSoftLog = 256;
  167. if (p->Handle)
  168. {
  169. int Adjust = ScaleRound(p->VolumeSoftLog,256,OldVolumeSoftLog);
  170. if (Adjust != 256)
  171. {
  172. wavebuffer* List;
  173. EnterCriticalSection(&p->Section);
  174. for (List=p->Buffers;List;List=List->GlobalNext)
  175. VolumeMul(Adjust,(void*)List->Block.Ptr,p->BufferLength,&p->Output.Format.Audio);
  176. LeaveCriticalSection(&p->Section);
  177. }
  178. }
  180. return ERR_NONE;
  181. }
  183. static int GetVolume(waveout* p)
  184. {
  185. if (!p->SoftwareVolume)
  186. {
  187. DWORD Value;
  188. if (waveOutGetVolume(NULL,&Value) == MMSYSERR_NOERROR)
  189. {
  190. if (p->MonoVol)
  191. {
  192. Value &= 0xFFFF;
  193. Value |= Value << 16;
  194. }
  195. if (Value)
  196. p->Mute = 0;
  197. if (!p->Mute)
  198. p->VolumeDev = ((LOWORD(Value)+HIWORD(Value)+600)*100) / (0xFFFF*2);
  199. }
  200. return p->VolumeDev;
  201. }
  202. return p->VolumeSoft;
  203. }
  205. static tick_t Time(waveout* p)
  206. {
  207. if (p->Speed.Num==0)
  208. return TIME_BENCH;
  210. if (p->Play)
  211. {
  212. tick_t t;
  213. EnterCriticalSection(&p->Section);
  214. t = p->Tick + Scale(GetTimeTick()-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
  215. LeaveCriticalSection(&p->Section);
  216. return t;
  217. }
  219. return p->Tick;
  220. }
  222. static int TimerGet(void* pt, int No, void* Data, int Size)
  223. {
  224. waveout* p = WAVEOUT(pt);
  225. int Result = ERR_INVALID_PARAM;
  226. switch (No)
  227. {
  228. case TIMER_PLAY: GETVALUE(p->Play,bool_t); break;
  229. case TIMER_SPEED: GETVALUE(p->Speed,fraction); break;
  230. case TIMER_TIME: GETVALUE(Time(p),tick_t); break;
  231. }
  232. return Result;
  233. }
  235. static int Get(waveout* p, int No, void* Data, int Size)
  236. {
  237. int Result = ERR_INVALID_PARAM;
  238. switch (No)
  239. {
  240. case OUT_INPUT: GETVALUE(p->Pin,pin); break;
  241. case OUT_INPUT|PIN_FORMAT: GETVALUE(p->Input,packetformat); break;
  242. case OUT_INPUT|PIN_PROCESS: GETVALUE(p->Process,packetprocess); break;
  243. case OUT_OUTPUT|PIN_FORMAT: GETVALUE(p->Output,packetformat); break;
  244. case OUT_TOTAL:GETVALUE(p->Total,int); break;
  245. case OUT_DROPPED:GETVALUE(p->Dropped,int); break;
  246. case AOUT_VOLUME: GETVALUE(GetVolume(p),int); break;
  247. case AOUT_MUTE: GETVALUE(p->Mute,bool_t); break;
  248. case AOUT_PREAMP: GETVALUE(p->PreAmp,int); break;
  249. case AOUT_STEREO: GETVALUE(p->Stereo,int); break; 
  250. case AOUT_MODE: GETVALUE(p->BufferMode,bool_t); break;
  251. case AOUT_QUALITY: GETVALUE(p->Quality,int); break;
  252. case AOUT_TIMER: GETVALUE(&p->Timer,node*); break;
  253. }
  254. return Result;
  255. }
  257. static void UpdateBenchAvg(waveout* p)
  258. {
  259. int n;
  261. p->BenchAvg += 4;
  262. p->BenchAdj = (24*16) / p->BenchAvg;
  263. p->BenchSpeedAvg = SPEED_ONE/(p->BenchAvg*BENCH_SIZE);
  265. n = p->Input.Format.Audio.Bits >> 3;
  266. if (!(p->Input.Format.Audio.Flags & PCM_PLANES))
  267. n *= p->Input.Format.Audio.Channels;
  268. n = p->Output.Format.Audio.SampleRate;
  269. if (n>0)
  270. p->BenchAvgLimit = (n * p->BenchAvg) / 160;
  271. else
  272. p->BenchAvgLimit = MAX_INT;
  274. p->BenchCurrSum += 2 * BENCH_SIZE;
  275. for (n=0;n<BENCH_SIZE;++n)
  276. {
  277. p->BenchSum[n] += 2 * BENCH_SIZE;
  278. p->BenchWait[n] += 2;
  279. }
  280. }
  282. static void ReleaseBuffer(waveout* p,wavebuffer* Buffer,bool_t UpdateTick)
  283. {
  284. EnterCriticalSection(&p->Section);
  286. if (UpdateTick)
  287. {
  288. tick_t Old;
  289. int Time = GetTimeTick();
  291. Old = p->Tick + Scale(Time-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
  293. if (Buffer->RefTime >= 0)
  294. p->Tick = Buffer->RefTime + p->BufferScaledTime;
  295. else
  296. p->Tick += p->BufferScaledTime;
  297. p->TimeRef = Time;
  299. //DEBUG_MSG2(-1,T("WaveOutTime: %d %d"),Old,p->Tick);
  301. // if difference is little then just adjust (because GetTimeTick() is more linear)
  302. if (abs(Old - p->Tick) < TICKSPERSEC/2)
  303. p->Tick = Old + ((p->Tick - Old) >> 2);
  304. }
  306. Buffer->Next = NULL;
  307. if (p->FreeLast)
  308. p->FreeLast->Next = Buffer;
  309. else
  310. p->FreeFirst = Buffer;
  311. p->FreeLast = Buffer;
  312. p->Used--;
  313. LeaveCriticalSection(&p->Section);
  314. }
  316. static void Reset(waveout* p)
  317. {
  318. int n;
  320. // release buffers already sended to device
  321. if (p->Handle)
  322. {
  323. tick_t OldTick = p->Tick;
  324. waveOutReset(p->Handle);
  325. p->Tick = OldTick;
  326. }
  328. if (p->FillLast && p->FillLast->RefTime >= 0)
  329. p->FillLastTime = p->FillLast->RefTime;
  331. // release fill chain
  332. while (p->FillFirst)
  333. {
  334. wavebuffer* Buffer = p->FillFirst;
  335. p->FillFirst = Buffer->Next;
  336. ReleaseBuffer(p,Buffer,0);
  337. }
  339. p->FillLast = NULL;
  340. p->FillPos = p->BufferLength;
  341. p->Skip = 0;
  342. p->Bytes = 0;
  343. p->BufferLimit = p->BufferLimitFull;
  345. p->BenchAvg = 16-4;
  346. UpdateBenchAvg(p);
  348. p->BenchWaitPos = 0;
  349. p->BenchCurrSum = p->BenchAvg * BENCH_SIZE;
  350. for (n=0;n<BENCH_SIZE;++n)
  351. {
  352. p->BenchSum[n] = p->BenchCurrSum;
  353. p->BenchWait[n] = p->BenchAvg;
  354. }
  356. PCMReset(p->PCM); // init dither and subsample position
  357. }
  359. static wavebuffer* GetBuffer(waveout* p)
  360. {
  361. wavebuffer* Buffer;
  363. // try to find a free buffer
  365. EnterCriticalSection(&p->Section);
  366. Buffer = p->FreeFirst;
  367. if (Buffer)
  368. {
  369. p->FreeFirst = Buffer->Next;
  370. if (Buffer == p->FreeLast)
  371. p->FreeLast = NULL;
  372. }
  373. if (!Buffer)
  374. {
  375. block Block;
  376. if (AllocBlock(p->BufferLength,&Block,p->Used>=20,HEAP_DYNAMIC))
  377. {
  378. Buffer = (wavebuffer*)malloc(sizeof(wavebuffer));
  379. if (!Buffer)
  380. FreeBlock(&Block);
  381. }
  383. if (Buffer)
  384. {
  385. Buffer->Block = Block;
  386. Buffer->Planes[0] = (uint8_t*)Block.Ptr;
  387. Buffer->Next = NULL;
  389. memset(&Buffer->Head,0,sizeof(WAVEHDR));
  390. Buffer->Head.lpData = (char*)Buffer->Block.Ptr;
  391. Buffer->Head.dwUser = (DWORD)Buffer;
  392. Buffer->Head.dwBufferLength = p->BufferLength;
  393. Buffer->Head.dwBytesRecorded = p->BufferLength;
  395. if (waveOutPrepareHeader(p->Handle, &Buffer->Head, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
  396. {
  397. FreeBlock(&Buffer->Block);
  398. free(Buffer);
  399. Buffer = NULL;
  400. }
  401. else
  402. {
  403. Buffer->GlobalNext = p->Buffers;
  404. p->Buffers = Buffer;
  405. }
  406. }
  407. else
  408. {
  409. p->BufferLimitFull = p->Used;
  410. if (p->BufferLimit > p->Used)
  411. p->BufferLimit = p->Used;
  412. else
  413. if (p->BufferLimit > 4)
  414. p->BufferLimit--;
  415. }
  417. }
  419. if (Buffer)
  420. {
  421. p->Used++;
  422. Buffer->RefTime = -1;
  423. Buffer->Next =NULL;
  424. }
  426. LeaveCriticalSection(&p->Section);
  427. return Buffer;
  428. }
  430. static void Write(waveout* p, tick_t CurrTime)
  431. {
  432. if (p->Play)
  433. {
  434. while (p->FillFirst != p->FillLast)
  435. {
  436. wavebuffer* Buffer = p->FillFirst;
  438. if (!p->Waiting && CurrTime >= 0 && Buffer->EstRefTime >= 0 && Buffer->EstRefTime > CurrTime + SHOWAHEAD)
  439. break;
  441. p->FillFirst = Buffer->Next;
  443. if (p->SoftwareVolume && (p->Mute || p->VolumeSoft==0))
  444. ReleaseBuffer(p,Buffer,0);
  445. else
  446. {
  447. if (waveOutWrite(p->Handle, &Buffer->Head, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
  448. ReleaseBuffer(p,Buffer,0);
  449. else
  450. InterlockedIncrement(&p->Waiting);
  451. }
  452. }
  453. }
  454. }
  456. static int Send(waveout* p, const constplanes Planes, int Length, tick_t RefTime, tick_t CurrTime, int Speed)
  457. {
  458. wavebuffer* Buffer;
  459. int DstLength;
  460. int SrcLength;
  461. planes DstPlanes;
  462. constplanes SrcPlanes;
  464. p->Total += Length;
  466. SrcPlanes[0] = Planes[0];
  467. SrcPlanes[1] = Planes[1];
  469. if (p->Skip > 0)
  470. {
  471. SrcLength = min(p->Skip,Length);
  472. SrcPlanes[0] = (uint8_t*)SrcPlanes[0] + SrcLength;
  473. SrcPlanes[1] = (uint8_t*)SrcPlanes[1] + SrcLength;
  474. Length -= SrcLength;
  475. p->Skip -= SrcLength;
  476. }
  478. while (Length > 0)
  479. {
  480. if (p->FillPos >= p->BufferLength)
  481. {
  482. // allocate new buffer
  483. Buffer = GetBuffer(p);
  484. if (!Buffer)
  485. break;
  487. if (p->FillLast)
  488. {
  489. wavebuffer* Last = p->FillLast;
  490. if (Last->RefTime>=0)
  491. p->FillLastTime = Last->EstRefTime = Last->RefTime;
  492. else
  493. {
  494. if (p->FillLastTime>=0)
  495. p->FillLastTime += p->BufferScaledTime;
  496. Last->EstRefTime = p->FillLastTime;
  497. }
  498. Last->Next = Buffer;
  499. }
  500. else
  501. p->FillFirst = Buffer;
  502. p->FillLast = Buffer;
  503. p->FillPos = 0;
  504. Buffer->Bytes = p->Bytes;
  505. }
  506. else
  507. Buffer = p->FillLast;
  509. if (RefTime >= 0)
  510. {
  511. Buffer->RefTime = RefTime - ((p->FillPos * p->BufferScaledAdjust) >> 12);
  512. if (Buffer->RefTime < 0)
  513. Buffer->RefTime = 0;
  514. RefTime = TIME_UNKNOWN;
  515. }
  517. SrcLength = Length;
  518. DstLength = p->BufferLength - p->FillPos;
  519. DstPlanes[0] = (uint8_t*)Buffer->Block.Ptr + p->FillPos;
  521. PCMConvert(p->PCM,DstPlanes,SrcPlanes,&DstLength,&SrcLength,Speed,p->VolumeSoftLog);
  523. if (p->VolumeRamp < RAMPLIMIT)
  524. p->VolumeRamp = VolumeRamp(p->VolumeRamp,DstPlanes[0],DstLength,&p->Output.Format.Audio);
  526. p->Bytes += DstLength;
  527. p->FillPos += DstLength;
  529. SrcPlanes[0] = (uint8_t*)SrcPlanes[0] + SrcLength;
  530. SrcPlanes[1] = (uint8_t*)SrcPlanes[1] + SrcLength;
  531. Length -= SrcLength;
  533. if (!SrcLength)
  534. break;
  535. }
  537. if (Length && p->Input.Format.Audio.BlockAlign>0)
  538. p->Skip = p->Input.Format.Audio.BlockAlign - Length % p->Input.Format.Audio.BlockAlign;
  540. Write(p,CurrTime);
  541. return ERR_NONE;
  542. }
  544. static void CALLBACK WaveProc(HWAVEOUT hwo, UINT uMsg, DWORD dwInstance, 
  545.                                DWORD dwParam1, DWORD dwParam2)
  546. {
  547.     if (uMsg == WOM_DONE)
  548.     {
  549. wavebuffer* Buffer = (wavebuffer*)(((WAVEHDR*)dwParam1)->dwUser);
  550. waveout* p = (waveout*)dwInstance;
  551. if (p->ForcePriority)
  552. {
  553. void* Thread = GetCurrentThread();
  554. if (GetThreadPriority(Thread)!=THREAD_PRIORITY_HIGHEST)
  555. SetThreadPriority(Thread,THREAD_PRIORITY_HIGHEST);
  556. }
  557. if (p->Pausing)
  558. {
  559. // add buffer to fill chain
  560. Buffer->Next = *p->Pausing;
  561. *p->Pausing = Buffer;
  562. p->Pausing = &Buffer->Next;
  563. }
  564. else
  565. ReleaseBuffer(p,Buffer,1);
  566. InterlockedDecrement(&p->Waiting);
  567.     }
  568. }
  570. static int UpdatePCM(waveout* p,const audio* InputFormat)
  571. {
  572. p->SpeedTime = p->Speed;
  573. p->SpeedTime.Num *= TICKSPERSEC;
  574. p->SpeedTime.Den *= GetTimeFreq();
  576. p->BufferScaledTime = Scale(TICKSPERSEC,p->Speed.Num*p->BufferLength,p->Speed.Den*p->Format.nAvgBytesPerSec);
  577. if (p->BufferLength)
  578. p->BufferScaledAdjust = (p->BufferScaledTime*4096) / p->BufferLength;
  579. else
  580. p->BufferScaledAdjust = 0;
  581. if (!p->Speed.Num)
  582. p->PCMSpeed = SPEED_ONE;
  583. else
  584. p->PCMSpeed = Scale(SPEED_ONE,p->Speed.Num,p->Speed.Den);
  585. p->AdjustedRate = Scale(p->Output.Format.Audio.SampleRate,p->Speed.Den,p->Speed.Num);
  587. PCMRelease(p->PCM);
  588. p->PCM = PCMCreate(&p->Output.Format.Audio,InputFormat,p->Dither,p->SoftwareVolume || p->PreAmp);
  589. return ERR_NONE;
  590. }
  592. static int UpdateBufferTime(waveout* p)
  593. {
  594. p->BufferLimit = Scale(p->BufferMode?BUFFER_VIDEO:BUFFER_MUSIC,p->Format.nAvgBytesPerSec,p->BufferLength*TICKSPERSEC);
  595. p->BufferLimitFull = p->BufferLimit;
  596. return ERR_NONE;
  597. }
  599. static int Process(waveout* p,const packet* Packet,const flowstate* State)
  600. {
  601. if (!Packet)
  602. {
  603. if (State->DropLevel)
  604. ++p->Dropped;
  605. else
  606. Write(p,State->CurrTime);
  607. return (p->Waiting<=0 || p->Speed.Num==0) ? ERR_NONE : ERR_BUFFER_FULL;
  608. }
  610. if (p->Speed.Num==0) // benchmark mode (auto adjust speed)
  611. {
  612. int Pos = p->BenchWaitPos;
  613. int OldSum;
  614. int Speed;
  616. if (p->Play)
  617. {
  618. while (Packet->Length > p->BenchAvgLimit)
  619. UpdateBenchAvg(p);
  621. p->BenchCurrSum -= p->BenchWait[Pos];
  622. p->BenchWait[Pos] = (p->Waiting * p->BufferLength) >> 12;
  623. p->BenchCurrSum += p->BenchWait[Pos];
  625. OldSum = p->BenchSum[Pos];
  626. p->BenchSum[Pos] = p->BenchCurrSum;
  628. if (++Pos == BENCH_SIZE)
  629. Pos = 0;
  631. p->BenchWaitPos = Pos;
  633. if (p->BenchCurrSum < 2*BENCH_SIZE*p->BenchAvg)
  634. Speed = (p->BenchCurrSum+1) * p->BenchSpeedAvg;
  635. else
  636. Speed = 2*SPEED_ONE+(p->BenchCurrSum-2*BENCH_SIZE*p->BenchAvg+1) * 4*p->BenchSpeedAvg;
  638. Speed -= p->BenchAdj*(p->BenchCurrSum - OldSum);
  640. if (p->Waiting < 3)
  641. Speed -= SPEED_ONE/5;
  642. }
  643. else
  644. Speed = SPEED_ONE;
  646. //DEBUG_MSG3(-1,T("Audio speed:%d length:%d (wait:%d)"),Speed,Packet->Length,p->Waiting);
  647. return Send(p,Packet->Data,Packet->Length,Packet->RefTime,State->CurrTime,Speed);
  648. }
  650. if (State->DropLevel)
  651. return ERR_NONE;
  653. if (p->Used >= p->BufferLimit)
  654. {
  655. Write(p,State->CurrTime);
  656. return ERR_BUFFER_FULL;
  657. }
  659. DEBUG_MSG3(DEBUG_AUDIO,T("Waveout reftime:%d used:%d waiting:%d"),Packet->RefTime,p->Used,p->Waiting);
  660. return Send(p,Packet->Data,Packet->Length,Packet->RefTime,State->CurrTime,p->PCMSpeed);
  661. }
  663. static bool_t FreeBuffers(waveout* p);
  665. static int UpdateInput(waveout* p)
  666. {
  667. Reset(p);
  668. FreeBuffers(p);
  670. if (p->Handle)
  671. {
  672. waveOutClose(p->Handle);
  673. p->Handle = NULL;
  674. }
  675. p->Total = 0;
  676. p->Dropped = 0;
  677. p->Process = DummyProcess;
  679. if (p->Input.Type == PACKET_AUDIO)
  680. {
  681. MMRESULT MMResult;
  682. int Try;
  684. if (p->Input.Format.Audio.Format != AUDIOFMT_PCM) 
  685. {
  686. PacketFormatClear(&p->Input);
  687. return ERR_INVALID_DATA;
  688. }
  690. if (p->Input.Format.Audio.Channels == 0 ||
  691. p->Input.Format.Audio.SampleRate == 0)
  692. return ERR_NONE; // probably initialized later
  694. p->Output.Type = PACKET_AUDIO;
  695. p->Output.Format.Audio = p->Input.Format.Audio;
  696. p->Output.Format.Audio.Flags = 0;
  697. p->Dither = 0;
  699. if (p->Stereo==STEREO_SWAPPED)
  700. p->Output.Format.Audio.Flags |= PCM_SWAPPEDSTEREO;
  701. else
  702. if (p->Stereo!=STEREO_NORMAL)
  703. {
  704. p->Output.Format.Audio.Channels = 1;
  705. if (p->Stereo==STEREO_LEFT)
  706. p->Output.Format.Audio.Flags |= PCM_ONLY_LEFT;
  707. if (p->Stereo==STEREO_RIGHT)
  708. p->Output.Format.Audio.Flags |= PCM_ONLY_RIGHT;
  709. }
  711. switch (p->Quality)
  712. {
  713. case 0: // low quality for very poor devices
  714. p->Output.Format.Audio.Bits = 8;
  715. p->Output.Format.Audio.FracBits = 7;
  716. p->Output.Format.Audio.Channels = 1;
  717. p->Output.Format.Audio.SampleRate = 22050;
  718. break;
  720. case 1: // no dither and only standard samplerate
  721. p->Output.Format.Audio.Bits = 16;
  722. p->Output.Format.Audio.FracBits = 15;
  723. if (p->Output.Format.Audio.SampleRate >= 44100)
  724. p->Output.Format.Audio.SampleRate = 44100;
  725. else
  726. p->Output.Format.Audio.SampleRate = 22050;
  727. break;
  729. default:
  730. case 2: // original samplerate 
  731. p->Output.Format.Audio.Bits = 16;
  732. p->Output.Format.Audio.FracBits = 15;
  733. p->Dither = 1;
  734. break;
  735. }
  737. Try = 0;
  738. do
  739. {
  740. if (p->Output.Format.Audio.Bits <= 8)
  741. p->Output.Format.Audio.Flags |= PCM_UNSIGNED;
  743. p->Format.wFormatTag = WAVE_FORMAT_PCM;
  744. p->Format.nChannels = (WORD)p->Output.Format.Audio.Channels;
  745. p->Format.nSamplesPerSec = p->Output.Format.Audio.SampleRate;
  746. p->Format.wBitsPerSample = (WORD)p->Output.Format.Audio.Bits;
  747. p->Format.nBlockAlign = (WORD)((p->Format.nChannels * p->Format.wBitsPerSample) >> 3);
  748. p->Format.nAvgBytesPerSec = p->Format.nSamplesPerSec * p->Format.nBlockAlign;
  749. p->Format.cbSize = 0;
  751. MMResult = waveOutOpen(&p->Handle, WAVE_MAPPER, &p->Format,(DWORD)WaveProc,
  752. (DWORD)p,CALLBACK_FUNCTION);
  754. if (MMResult==WAVERR_BADFORMAT)
  755. {
  756. ++Try;
  757. if (Try==1)
  758. {
  759. if (p->Output.Format.Audio.SampleRate > 35000)
  760. p->Output.Format.Audio.SampleRate = 44100;
  761. else
  762. ++Try;
  763. }
  764. if (Try==2)
  765. {
  766. if (p->Output.Format.Audio.SampleRate != 22050)
  767. p->Output.Format.Audio.SampleRate = 22050;
  768. else
  769. ++Try;
  770. }
  771. if (Try==3)
  772. {
  773. if (p->Output.Format.Audio.Channels > 1)
  774. p->Output.Format.Audio.Channels = 1;
  775. else
  776. ++Try;
  777. }
  778. if (Try==4)
  779. {
  780. if (p->Output.Format.Audio.Bits != 8)
  781. {
  782. p->Output.Format.Audio.Bits = 8;
  783. p->Output.Format.Audio.FracBits = 7;
  784. }
  785. else
  786. ++Try;
  787. }
  788. if (Try==5)
  789. break;
  790. }
  791. }
  792. while (MMResult==WAVERR_BADFORMAT);
  794. if (p->Handle)
  795. {
  796. p->Process = Process;
  797. p->TimeRef = GetTimeTick();
  798. p->BufferLength = 4096;
  799. if (p->Format.nAvgBytesPerSec > 65536)
  800. p->BufferLength *= 2;
  801. if (p->Format.nAvgBytesPerSec > 2*65536)
  802. p->BufferLength *= 2;
  803. UpdateBufferTime(p);
  805. p->FillPos = p->BufferLength;
  806. p->VolumeRamp = 0;
  808. UpdatePCM(p,&p->Input.Format.Audio);
  809. Reset(p);
  810. }
  811. else
  812. {
  813. PacketFormatClear(&p->Input);
  814. ShowError(p->Node.Class,ERR_ID,ERR_DEVICE_ERROR);
  815. return ERR_DEVICE_ERROR;
  816. }
  817. }
  818. else
  819. if (p->Input.Type != PACKET_NONE)
  820. return ERR_INVALID_DATA;
  822. return ERR_NONE;
  823. }
  825. static int Update(waveout* p)
  826. {
  827. wavebuffer *OldFirst;
  828. wavebuffer *OldLast;
  829. audio OldFormat;
  830. wavebuffer* OldBuffers;
  831. wavebuffer* OldFill;
  832. int OldFillPos; 
  833. int OldUsed;
  834. bool_t OldVolume;
  835. int OldPreAmp;
  836. wavebuffer *Buffer,*Next;
  838. EnterCriticalSection(&p->Section);
  840. OldVolume = p->SoftwareVolume;
  841. OldPreAmp = p->PreAmp;
  842. OldUsed = p->Used;
  843. OldFirst = p->FreeFirst;
  844. OldLast = p->FreeLast;
  845. OldFormat = p->Output.Format.Audio;
  846. OldFormat.SampleRate = p->AdjustedRate;
  848. OldFill = p->FillFirst;
  849. OldFillPos = p->FillPos;
  851. p->FillFirst = NULL;
  852. p->FillLast = NULL;
  853. p->FillPos = p->BufferLength;
  854. p->FreeFirst = NULL;
  855. p->FreeLast = NULL;
  857. LeaveCriticalSection(&p->Section);
  859. Reset(p);
  861. OldBuffers = p->FreeFirst;
  862. if (p->FreeLast)
  863. p->FreeLast->Next = OldFill;
  864. else
  865. OldBuffers = OldFill;
  867. if (OldBuffers)
  868. p->FillLastTime = OldBuffers->EstRefTime - p->BufferScaledTime;
  870. p->PreAmp = 0;
  871. p->SoftwareVolume = 0;
  872. p->Used = OldUsed;
  873. p->FreeFirst = OldFirst;
  874. p->FreeLast = OldLast;
  876. // setup temporary format
  877. UpdatePCM(p,&OldFormat);
  879. for (Buffer=OldBuffers;Buffer;Buffer=Next)
  880. {
  881. Next = Buffer->Next;
  882. Send(p,Buffer->Planes,Next ? p->BufferLength:OldFillPos,Buffer->RefTime,-1,p->PCMSpeed);
  883. ReleaseBuffer(p,Buffer,0);
  884. }
  886. p->SoftwareVolume = OldVolume;
  887. p->PreAmp = OldPreAmp;
  888. UpdatePCM(p,&p->Input.Format.Audio);
  889. return ERR_NONE;
  890. }
  892. static bool_t FreeBuffers(waveout* p)
  893. {
  894. wavebuffer** Ptr;
  895. wavebuffer* Buffer;
  896. bool_t Changed = 0;
  898. while (p->FreeFirst)
  899. {
  900. Buffer = p->FreeFirst;
  901. p->FreeFirst = Buffer->Next;
  903. // remove from global chain
  904. Ptr = &p->Buffers;
  905. while (*Ptr && *Ptr != Buffer)
  906. Ptr = &(*Ptr)->GlobalNext;
  907. if (*Ptr == Buffer)
  908. *Ptr = Buffer->Next;
  910. waveOutUnprepareHeader(p->Handle, &Buffer->Head, sizeof(WAVEHDR));
  911. FreeBlock(&Buffer->Block);
  912. free(Buffer);
  913. Changed = 1;
  914. }
  915. p->FreeLast = NULL;
  917. return Changed;
  918. }
  920. static int Hibernate(waveout* p,int Mode)
  921. {
  922. bool_t Changed = 0;
  924. EnterCriticalSection(&p->Section);
  925. Changed = FreeBuffers(p);
  926. LeaveCriticalSection(&p->Section);
  928. return Changed ? ERR_NONE : ERR_OUT_OF_MEMORY;
  929. }
  931. static void Pause(waveout* p)
  932. {
  933. p->Pausing = &p->FillFirst;
  934. waveOutReset(p->Handle);
  935. p->Pausing = NULL;
  936. p->FillLast = p->FillFirst;
  937. if (p->FillLast)
  938. while (p->FillLast->Next) p->FillLast = p->FillLast->Next;
  939. }
  941. static int UpdatePlay(waveout* p)
  942. {
  943. if (p->Play)
  944. {
  945. p->TimeRef = GetTimeTick();
  946. if (p->Handle)
  947. Write(p,p->Tick);
  948. }
  949. else
  950. {
  951. if (!p->Waiting)
  952. p->Tick += Scale(GetTimeTick()-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
  953. else
  954. if (p->Handle)
  955. Pause(p);
  956. }
  957. return ERR_NONE;
  958. }
  960. static int SetVolumeDev(waveout* p,int v)
  961. {
  962. p->VolumeDev = v;
  963. if (p->Mute)
  964. waveOutSetVolume(NULL,0);
  965. else
  966. waveOutSetVolume(NULL,0x10001 * ((0xFFFF * p->VolumeDev) / 100));
  967. return ERR_NONE;
  968. }
  970. static int TimerSet(void* pt, int No, const void* Data, int Size)
  971. {
  972. waveout* p = WAVEOUT(pt);
  973. int Result = ERR_INVALID_PARAM;
  974. switch (No)
  975. {
  976. case TIMER_PLAY: SETVALUECMP(p->Play,bool_t,UpdatePlay(p),EqBool); break;
  977. case TIMER_SPEED: SETVALUECMP(p->Speed,fraction,Update(p),EqFrac); break;
  978. case TIMER_TIME:
  979. assert(Size == sizeof(tick_t));
  980. EnterCriticalSection(&p->Section);
  981. p->Tick = *(tick_t*)Data;
  982. p->TimeRef = GetTimeTick();
  983. LeaveCriticalSection(&p->Section);
  984. Result = ERR_NONE;
  985. break;
  986. }
  987. return Result;
  988. }
  990. static void UpdateSoftwareVolume(waveout* p)
  991. {
  992. bool_t SoftwareVolume = !QueryAdvanced(ADVANCED_SYSTEMVOLUME);
  993. if (SoftwareVolume != p->SoftwareVolume)
  994. {
  995. p->SoftwareVolume = SoftwareVolume;
  996. SetVolumeSoft(p,p->VolumeSoft,p->Mute);
  997. if (p->Handle)
  998. UpdatePCM(p,&p->Input.Format.Audio);
  999. }
  1000. }
  1002. static int UpdatePreAmp(waveout* p)
  1003. {
  1004. SetVolumeSoft(p,p->VolumeSoft,p->Mute);
  1005. if (p->Handle)
  1006. UpdatePCM(p,&p->Input.Format.Audio);
  1007. return ERR_NONE;
  1008. }
  1010. static int Set(waveout* p, int No, const void* Data, int Size)
  1011. {
  1012. int Result = ERR_INVALID_PARAM;
  1013. switch (No)
  1014. {
  1015. case OUT_INPUT|PIN_FORMAT: 
  1016. if (PacketFormatSimilarAudio(&p->Input,(const packetformat*)Data))
  1017. {
  1018. PacketFormatCopy(&p->Input,(const packetformat*)Data);
  1019. Result = UpdatePCM(p,&p->Input.Format.Audio);
  1020. }
  1021. else
  1022. SETPACKETFORMATCMP(p->Input,packetformat,UpdateInput(p)); 
  1023. break;
  1024. case OUT_INPUT: SETVALUE(p->Pin,pin,ERR_NONE); break;
  1025. case OUT_TOTAL: SETVALUE(p->Total,int,ERR_NONE); break;
  1026. case OUT_DROPPED: SETVALUE(p->Dropped,int,ERR_NONE); break;
  1028. case AOUT_VOLUME: 
  1029. assert(Size==sizeof(int));
  1030. UpdateSoftwareVolume(p);
  1031. if (p->SoftwareVolume)
  1032. Result = SetVolumeSoft(p,*(int*)Data,p->Mute);
  1033. else
  1034. Result = SetVolumeDev(p,*(int*)Data);
  1035. break;
  1037. case AOUT_PREAMP: SETVALUECMP(p->PreAmp,int,UpdatePreAmp(p),EqInt); break; 
  1039. case AOUT_MUTE:
  1040. assert(Size==sizeof(bool_t));
  1041. UpdateSoftwareVolume(p);
  1042. if (p->SoftwareVolume)
  1043. Result = SetVolumeSoft(p,p->VolumeSoft,*(bool_t*)Data);
  1044. else
  1045. {
  1046. if (!p->Mute) GetVolume(p); // save old volume to p->VolumeDev
  1047. p->Mute = *(bool_t*)Data;
  1048. Result = SetVolumeDev(p,p->VolumeDev);
  1049. }
  1050. break;
  1052. case AOUT_STEREO: SETVALUECMP(p->Stereo,int,UpdateInput(p),EqInt); break; 
  1053. case AOUT_QUALITY: SETVALUECMP(p->Quality,int,UpdateInput(p),EqInt); break; 
  1054. case AOUT_MODE: SETVALUE(p->BufferMode,bool_t,UpdateBufferTime(p)); break;
  1056. case FLOW_FLUSH:
  1057. Reset(p);
  1058. p->FillLastTime = TIME_UNKNOWN;
  1059. p->VolumeRamp = 0;
  1060. Result = ERR_NONE;
  1061. break;
  1063. case NODE_SETTINGSCHANGED:
  1064. p->ForcePriority = QueryAdvanced(ADVANCED_WAVEOUTPRIORITY);
  1065. break;
  1067. case NODE_HIBERNATE:
  1068. assert(Size == sizeof(int));
  1069. Result = Hibernate(p,*(int*)Data);
  1070. break;
  1071. }
  1072. return Result;
  1073. }
  1075. static int Create(waveout* p)
  1076. {
  1077. WAVEOUTCAPS Caps;
  1079. if (waveOutGetNumDevs()==0)
  1080. return ERR_NOT_SUPPORTED;
  1082. waveOutGetDevCaps(WAVE_MAPPER,&Caps,sizeof(Caps));
  1084. p->Node.Get = (nodeget)Get;
  1085. p->Node.Set = (nodeset)Set;
  1087. p->Timer.Class = TIMER_CLASS;
  1088. p->Timer.Enum = TimerEnum;
  1089. p->Timer.Get = TimerGet;
  1090. p->Timer.Set = TimerSet;
  1092. p->VolumeDev = 70; //default when device is muted
  1093. p->VolumeSoftLog = 256;
  1094. p->Quality = 2;
  1095. p->Speed.Den = p->Speed.Num = 1;
  1096. p->SpeedTime.Num = TICKSPERSEC;
  1097. p->SpeedTime.Den = GetTimeFreq();
  1098. p->MonoVol = (Caps.dwSupport & WAVECAPS_LRVOLUME) == 0;
  1100. InitializeCriticalSection(&p->Section);
  1101. return ERR_NONE;
  1102. }
  1104. static void Delete(waveout* p)
  1105. {
  1106. PacketFormatClear(&p->Input);
  1107. PCMRelease(p->PCM);
  1108. DeleteCriticalSection(&p->Section);
  1109. }
  1111. static const nodedef WaveOut =
  1112. {
  1113. sizeof(waveout)|CF_GLOBAL,
  1114. WAVEOUT_ID,
  1115. AOUT_CLASS,
  1116. PRI_DEFAULT,
  1117. (nodecreate)Create,
  1118. (nodedelete)Delete,
  1119. };
  1121. void WaveOut_Init()
  1122. {
  1123. NodeRegisterClass(&WaveOut);
  1124. }
  1126. void WaveOut_Done()
  1127. {
  1128. NodeUnRegisterClass(WAVEOUT_ID);
  1129. }
  1131. #endif