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

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

Windows CE

开发平台：

C/C++

waveout_palmos.c：源码内容
  1. /*****************************************************************************  *  * This program is free software ; you can redistribute it and/or modify  * it under the terms of the GNU General Public License as published by  * the Free Software Foundation; either version 2 of the License, or  * (at your option) any later version.  *  * This program is distributed in the hope that it will be useful,  * but WITHOUT ANY WARRANTY; without even the implied warranty of  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  * GNU General Public License for more details.  *  * You should have received a copy of the GNU General Public License  * along with this program; if not, write to the Free Software  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *  * $Id: waveout_palmos.c 623 2006-02-01 13:19:15Z picard $  *  * The Core Pocket Media Player  * Copyright (c) 2004-2005 Gabor Kovacs  *  ****************************************************************************/ #include "../common.h" #if defined(TARGET_PALMOS)
  2. #define DRVBUFFER 4096
  3. #define BUFFER_MIN 4*DRVBUFFER
  4. #define BUFFER_MUSIC 65536*8
  5. #define BUFFER_VIDEO 65536
  6. #define VOLLIMIT (16384-64)
  7. #include "pace.h"
  8. typedef struct waveout_palm
  9. {
  10. waveout_base Base;
  11. SndStreamRef Stream;
  13. sysregs SysRegs;
  14. void* PCMCopy;
  15. int CopySpeed;
  16. bool_t Mute;
  17. int Volume;
  18. int PreAmp;
  19. int Pan;
  20. bool_t Play;
  21. bool_t Started;
  22. fraction Speed;
  23. fraction SpeedTime;
  25. buffer Buffer;
  26. bool_t BufferMode;
  27. int VolumeRamp;
  28. int BytePerSample; // output bytes per sample
  29. int BytePerSec; // output bytes per seconds (before speed adjustment)
  30. int SpeedBytePerSec; // speed adjusted BytePerSec
  31. int Ratio; //input to output bytepersec (8.8 fixed point)
  32. int Skip;
  33. int DrvBufferSize;
  34. tick_t DrvBufferDelay;
  35. tick_t BufferTick;
  36. tick_t Tick;
  37. int TimeRef;
  38. int BenchSpeed;
  39. int BenchLeft;
  40. bool_t AlwaysClose;
  41. bool_t Force16Bits;
  42. int Vol;
  44. Boolean Native;
  45. m68kcallback CallBack;
  47. } waveout_palm;
  49. #define WAVEOUT(p) ((waveout_palm*)((char*)(p)-OFS(waveout_palm,Base.Timer)))
  51. static void ManualSleep(int MSec)
  52. {
  53. int t0 = GetTimeTick();
  54. int Wait = (GetTimeFreq()*MSec)/1024;
  55. if (Wait==0) Wait=1;
  56. while (GetTimeTick()-t0<Wait);
  57. }
  59. static int Stop(waveout_palm* p)
  60. {
  61. if (p->Started)
  62. {
  63. p->Started = 0;
  64. SndStreamStop(p->Stream);
  65. ManualSleep(50); // try to make sure callback exited
  66. if (p->AlwaysClose)
  67. {
  68. SndStreamDelete(p->Stream);
  69. p->Stream = 0;
  70. }
  71. p->DrvBufferSize = 0;
  72. p->DrvBufferDelay = 0;
  73. }
  74. return ERR_NONE;
  75. }
  77. static int CreateStream(waveout_palm* p);
  79. static void Start(waveout_palm* p,tick_t CurrTime)
  80. {
  81. if (p->Play && !p->Started && p->Buffer.WritePos != p->Buffer.ReadPos &&
  82. (CurrTime<0 || p->BufferTick <= CurrTime+SHOWAHEAD) &&
  83. (p->Stream || CreateStream(p)==ERR_NONE))
  84. {
  85. p->Started = 1;
  86. SndStreamStart(p->Stream);
  87. }
  88. }
  90. static int UpdateBufferMode(waveout_palm* p)
  91. {
  92. int Size;
  94. if (p->Started)
  95. return ERR_NONE;
  97. BufferPack(&p->Buffer,0);
  99. Size = p->BufferMode ? BUFFER_VIDEO : BUFFER_MUSIC;
  100. if (Context()->LowMemory)
  101. Size >>= 1;
  103. if (Size < BUFFER_MIN)
  104. Size = BUFFER_MIN;
  105. Size = ALIGN16(Size);
  107. DisableOutOfMemory();
  108. for (;Size >= BUFFER_MIN;Size >>= 1)
  109. if (BufferAlloc(&p->Buffer,Size,1))
  110. {
  111. EnableOutOfMemory();
  112. if (p->Buffer.WritePos >= p->Buffer.Allocated)
  113. p->Buffer.WritePos = 0;
  114. return ERR_NONE;
  115. }
  117. EnableOutOfMemory();
  118. ShowOutOfMemory();
  119. return ERR_OUT_OF_MEMORY;
  120. }
  122. static Err Callback(waveout_palm* p,SndStreamRef Stream,void *Buffer,uint32_t Frames)
  123. {
  124. // as a general rule we don't call any OS callbacks here, because
  125. // we only have one emulstate structure and if both threads
  126. // call an m68k syscall this could mean problems...
  128. constplanes SrcPlanes;
  129. planes DstPlanes;
  130. int SrcLength,DstLength;
  131. int WritePos,ReadPos,Length,Speed;
  133. LoadSysRegs(&p->SysRegs);
  135. Length = Frames * p->BytePerSample;
  136. DstPlanes[0] = Buffer;
  138. if (p->Started)
  139. {
  140. WritePos = p->Buffer.WritePos;
  141. ReadPos = p->Buffer.ReadPos;
  143. if (p->DrvBufferSize != Length)
  144. {
  145. //assuming double buffering
  146. p->DrvBufferSize = Length;
  147. p->DrvBufferDelay = Scale(2*Length,TICKSPERSEC,p->SpeedBytePerSec); 
  148. }
  150. Speed = p->CopySpeed;
  151. if (Speed <= 0) 
  152. {
  153. /* int Middle = p->Buffer.Allocated >> 1;
  154. int Left = ReadPos - WritePos;
  155. if (Left<0)
  156. Left += p->Buffer.Allocated;
  158. Speed = p->BenchSpeed;
  160. if (Left > Middle && p->BenchLeft < Left)
  161. {
  162. Speed -= Left - p->BenchLeft;
  163. if (Speed < SPEED_ONE/8)
  164. Speed = SPEED_ONE/8;
  165. }
  167. if (Left < Middle && p->BenchLeft > Left)
  168. Speed -= Left - p->BenchLeft;
  170. p->BenchSpeed = Speed;
  171. p->BenchLeft = Left;
  172. */
  173. Speed = SPEED_ONE;
  174. }
  176. while (Length>0)
  177. {
  178. if (WritePos < ReadPos)
  179. SrcLength = p->Buffer.Allocated - ReadPos;
  180. else
  181. SrcLength = WritePos - ReadPos;
  182. SrcPlanes[0] = p->Buffer.Data + ReadPos;
  183. DstLength = Length;
  185. PCMConvert(p->PCMCopy,DstPlanes,SrcPlanes,&DstLength,&SrcLength,Speed,256);
  187. DstPlanes[0] = (uint8_t*)DstPlanes[0] + DstLength;
  188. Length -= DstLength;
  190. ReadPos += SrcLength;
  191. if (ReadPos == p->Buffer.Allocated)
  192. ReadPos = 0;
  194. if (!DstLength)
  195. break;
  196. }
  198. p->Buffer.ReadPos = ReadPos;
  199. }
  201. if (Length)
  202. memset(DstPlanes[0],(p->Base.Output.Format.Audio.Flags & PCM_UNSIGNED)?0x80:0x00,Length);
  204. return errNone;
  205. }
  207. DLLEXPORT unsigned long WaveOutCallBack(const void *emulStateP, void *userData68KP, Call68KFuncType *call68KFuncP)
  208. {
  209. UInt32 Param[4];
  210. memcpy(Param,userData68KP,16);
  211. return Callback((waveout_palm*)SWAP32(Param[0]),(SndStreamRef)SWAP32(Param[1]),
  212. (void*)SWAP32(Param[2]),SWAP32(Param[3]));
  213. }
  215. static int Process(waveout_palm* p,const packet* Packet,const flowstate* State)
  216. {
  217. constplanes SrcPlanes;
  218. planes DstPlanes;
  219. int Length,SrcLength,DstLength,Left,ReadPos,WritePos;
  221. ReadPos = p->Buffer.ReadPos;
  222. WritePos = p->Buffer.WritePos;
  224. if (!Packet)
  225. {
  226. if (State->DropLevel)
  227. ++p->Base.Dropped;
  228. return (!p->Started || !p->Speed.Num || WritePos==ReadPos) ? ERR_NONE : ERR_BUFFER_FULL;
  229. }
  231. DstLength = (Packet->Length * p->Ratio + 255) >> 8; // it may give little larger as needed length
  233. if (DstLength > p->Buffer.Allocated - DRVBUFFER*2)
  234. {
  235. ++p->Base.Dropped;
  236. return ERR_NONE; // drop large packets
  237. }
  239. // avoid filling the buffer full (it would mean buffer is empty)
  240. ReadPos -= p->BytePerSample;
  241. if (ReadPos < 0)
  242. ReadPos += p->Buffer.Allocated;
  244. // check if there is enough free space in buffer
  245. Left = ReadPos - WritePos;
  246. if (Left<0)
  247. Left += p->Buffer.Allocated;
  249. if (DstLength > Left)
  250. {
  251. if (!p->Started)
  252. Start(p,State->CurrTime);
  254. if (p->Speed.Num)
  255. return ERR_BUFFER_FULL;
  257. // in benchmark mode we need the package to 
  258. // be processed to measure real performance
  260. WritePos = ReadPos - DstLength;
  261. WritePos &= ~3; // align to dword (DstLength is just an approx)
  262. if (WritePos<0)
  263. WritePos += p->Buffer.Allocated;
  265. Left = ReadPos - WritePos;
  266. if (Left<0)
  267. Left += p->Buffer.Allocated;
  268. }
  270. // process packet
  271. SrcPlanes[0] = Packet->Data[0];
  272. SrcPlanes[1] = Packet->Data[1];
  273. Length = Packet->Length;
  274. p->Base.Total += Length;
  276. if (Packet->RefTime >= 0)
  277. {
  278. int Diff = p->Buffer.Allocated - Left; // bytes already in the buffer (with 100% speed)
  279. p->BufferTick = Packet->RefTime - Scale(Diff,TICKSPERSEC,p->BytePerSec) - p->DrvBufferDelay;
  280. if (p->BufferTick < 0)
  281. p->BufferTick = 0;
  283. if (p->Started)
  284. {
  285. // adjust timer if it's already running
  286. int Time = GetTimeTick();
  287. tick_t Tick = Scale(Time-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
  288. tick_t Old = p->Tick + Tick;
  290. // if difference is little then just adjust (because GetTimeTick() is more linear)
  291. if (abs(Old - p->BufferTick) < TICKSPERSEC/2)
  292. p->BufferTick = Old + ((p->BufferTick - Old) >> 2);
  294. p->Tick = p->BufferTick;
  295. p->TimeRef = Time;
  296. }
  297. }
  299. if (p->Skip)
  300. {
  301. SrcLength = min(p->Skip,Length);
  302. SrcPlanes[0] = (uint8_t*)SrcPlanes[0] + SrcLength;
  303. SrcPlanes[1] = (uint8_t*)SrcPlanes[1] + SrcLength;
  304. Length -= SrcLength;
  305. p->Skip -= SrcLength;
  306. }
  308. while (Length>0)
  309. {
  310. if (ReadPos < WritePos)
  311. DstLength = p->Buffer.Allocated - WritePos;
  312. else
  313. DstLength = ReadPos - WritePos;
  314. DstPlanes[0] = p->Buffer.Data + WritePos;
  315. SrcLength = Length;
  317. PCMConvert(p->Base.PCM,DstPlanes,SrcPlanes,&DstLength,&SrcLength,SPEED_ONE,p->Vol/4); //volume needed only for lifedrive fix
  319. if (p->VolumeRamp < RAMPLIMIT)
  320. p->VolumeRamp = VolumeRamp(p->VolumeRamp,DstPlanes[0],DstLength,&p->Base.Output.Format.Audio);
  322. SrcPlanes[0] = (uint8_t*)SrcPlanes[0] + SrcLength;
  323. SrcPlanes[1] = (uint8_t*)SrcPlanes[1] + SrcLength;
  324. Length -= SrcLength;
  326. WritePos += DstLength;
  327. if (WritePos == p->Buffer.Allocated)
  328. WritePos = 0;
  330. if (!SrcLength) // unaligned input (not supported)
  331. break;
  332. }
  334. p->Buffer.WritePos = WritePos;
  336. if (Length>0 && p->Base.Input.Format.Audio.BlockAlign>0)
  337. p->Skip = p->Base.Input.Format.Audio.BlockAlign - Length % p->Base.Input.Format.Audio.BlockAlign;
  339. if (!p->Started)
  340. Start(p,State->CurrTime);
  342. return ERR_NONE;
  343. }
  345. static int Flush(waveout_palm* p)
  346. {
  347. Stop(p);
  348. p->Skip = 0;
  349. p->VolumeRamp = 0;
  350. p->BufferTick = -1;
  351. p->Buffer.ReadPos = p->Buffer.WritePos = 0;
  352. p->BenchSpeed = SPEED_ONE;
  353. p->BenchLeft = 0;
  354. return ERR_NONE;
  355. }
  357. static int Done(waveout_palm* p)
  358. {
  359. Flush(p);
  360. if (p->Stream)
  361. {
  362. // Tungsten T1 seems to still use one or two callbacks after stopping
  363. SndStreamSetVolume(p->Stream,0);
  364. ManualSleep(100);
  365. SndStreamDelete(p->Stream);
  366. p->Stream = 0;
  367. }
  368. BufferClear(&p->Buffer);
  369. PCMRelease(p->PCMCopy);
  370. p->PCMCopy = NULL;
  371. PCMRelease(p->Base.PCM);
  372. p->Base.PCM = NULL;
  373. return ERR_NONE;
  374. }
  376. static const int32_t VolDb[201] = { //pow(10,(50+N)/49.828)
  377. 10,10,11,11,12,12,13,13,14,15,
  378. 16,16,17,18,19,20,21,22,23,24,
  379. 25,26,27,29,30,32,33,35,36,38,
  380. 40,42,44,46,48,50,53,55,58,61,
  381. 64,67,70,73,76,80,84,88,92,97,
  382. 101,106,111,116,122,128,134,140,147,154,
  383. 161,168,176,185,194,203,212,222,233,244,
  384. 256,268,280,294,308,322,337,353,370,388,
  385. 406,425,445,466,488,512,536,561,588,616,
  386. 645,675,707,741,776,812,851,891,933,977,
  387. 1024,1072,1123,1176,1232,1290,1351,1415,1482,1552,
  388. 1625,1702,1783,1867,1955,2048,2145,2246,2352,2464,
  389. 2580,2702,2830,2964,3104,3251,3405,3566,3734,3911,
  390. 4096,4290,4493,4705,4928,5161,5405,5661,5928,6209,
  391. 6503,6810,7132,7470,7823,8193,8580,8986,9411,9856,
  392. 10323,10811,11322,11858,12418,13006,13621,14265,14940,15646,
  393. 16386,17161,17973,18823,19713,20646,21622,22645,23716,24838,
  394. 26012,27243,28531,29881,31294,32774,34324,35947,37647,39428,
  395. 41293,43246,45291,47433,49676,52026,54486,57063,59762,62589,
  396. 65549,68649,71896,75296,78857,82587,86493,90584,94868,99355,
  397. 104054};
  399. static int UpdateVolume(waveout_palm* p)
  400. {
  401. if (p->Stream)
  402. {
  403. if (p->Mute || p->Volume<0)
  404. p->Vol = 0;
  405. else
  406. {
  407. int PreAmp = p->PreAmp+100;
  408. if (PreAmp<0) PreAmp=0;
  409. if (PreAmp>200) PreAmp=200;
  410. p->Vol = Scale(p->Volume,VolDb[PreAmp],100);
  411. if (p->Vol > VOLLIMIT)
  412. p->Vol = VOLLIMIT;
  413. }
  415. SndStreamSetVolume(p->Stream,p->Vol);
  416. }
  417. return ERR_NONE;
  418. }
  420. static int UpdatePan(waveout_palm* p)
  421. {
  422. if (p->Stream)
  423. SndStreamSetPan(p->Stream,(p->Pan*1024)/100);
  424. return ERR_NONE;
  425. }
  427. static NOINLINE int UpdateSpeed(waveout_palm* p)
  428. {
  429. p->SpeedTime = p->Speed;
  430. p->SpeedTime.Num *= TICKSPERSEC;
  431. p->SpeedTime.Den *= GetTimeFreq();
  432. if (!p->Speed.Num)
  433. p->CopySpeed = 0; //benchmark mode
  434. else
  435. p->CopySpeed = Scale(SPEED_ONE,p->Speed.Num,p->Speed.Den);
  436. p->SpeedBytePerSec = Scale(p->BytePerSec,p->Speed.Den,p->Speed.Num);
  437. p->DrvBufferSize = 0;
  438. p->DrvBufferDelay = 0;
  439. return ERR_NONE;
  440. }
  442. static int CreateStream(waveout_palm* p)
  443. {
  444. SndSampleType Type;
  445. SndStreamWidth Width;
  447. #if defined(_M_IX86)
  448. // this mess is all about avoiding simulator error message (no clue why the orginal pointer is invalid)
  449. static uint8_t CallbackJmp[] = {0xB8,0,0,0,0,0xFF,0xE0};
  450. SndStreamBufferCallback CallbackPtr = (SndStreamBufferCallback)CallbackJmp;
  451. *(SndStreamBufferCallback*)(CallbackJmp+1) = (SndStreamBufferCallback)Callback;
  452. if (!p->Native)
  453. CallbackPtr = (SndStreamBufferCallback)m68kCallBack(p->CallBack,(NativeFuncType*)T("tcpmp.dllWaveOutCallBack"));
  454. #else
  455. SndStreamBufferCallback CallbackPtr = (SndStreamBufferCallback)Callback;
  456. if (!p->Native)
  457. CallbackPtr = (SndStreamBufferCallback)m68kCallBack(p->CallBack,WaveOutCallBack);
  458. #endif
  460. if (p->Base.Output.Format.Audio.Bits==16)
  461. {
  462. if (p->Base.Output.Format.Audio.Flags & PCM_SWAPEDBYTES)
  463. Type = sndInt16Big;
  464. else
  465. Type = sndInt16Little;
  466. }
  467. else
  468. if (p->Base.Output.Format.Audio.Bits==8)
  469. {
  470. if (p->Base.Output.Format.Audio.Flags & PCM_UNSIGNED)
  471. Type = sndUInt8;
  472. else
  473. Type = sndInt8;
  474. }
  475. else
  476. return ERR_NOT_SUPPORTED;
  478. switch (p->Base.Output.Format.Audio.Channels)
  479. {
  480. case 1: Width = sndMono; break;
  481. case 2: Width = sndStereo; break;
  482. default: 
  483. return ERR_NOT_SUPPORTED;
  484. }
  486. SaveSysRegs(&p->SysRegs);
  487. if (SndStreamCreate(&p->Stream,sndOutput,p->Base.Output.Format.Audio.SampleRate,Type,
  488. Width,CallbackPtr,p,DRVBUFFER,p->Native) != errNone)
  489. return ERR_DEVICE_ERROR;
  491. UpdateVolume(p);
  492. UpdatePan(p);
  493. return ERR_NONE;
  494. }
  496. static void Force16Bits(waveout_palm* p)
  497. {
  498. if (p->Base.Output.Format.Audio.Bits<16)
  499. {
  500. p->Base.Output.Format.Audio.Flags &= ~PCM_UNSIGNED;
  501. p->Base.Output.Format.Audio.Bits = 16;
  502. p->Base.Output.Format.Audio.FracBits = 15;
  503. }
  504. }
  506. static int Init(waveout_palm* p)
  507. {
  508. int Model = QueryPlatform(PLATFORM_MODEL);
  509. int InputRate;
  510. int Result;
  512. if (p->Force16Bits)
  513. Force16Bits(p); // NX80v with MCA2 doesn't like 8bit output?
  515. if (Model == MODEL_LIFEDRIVE)
  516. p->Base.Output.Format.Audio.Flags |= PCM_LIFEDRIVE_FIX;
  518. if (Model == MODEL_TUNGSTEN_T || Model == MODEL_TUNGSTEN_T2 || Model == MODEL_TUNGSTEN_T3)
  519. {
  520. if (Model != MODEL_TUNGSTEN_T3 && p->Base.Output.Format.Audio.SampleRate > 44100) //48000hz unstable on T|T and T2
  521. p->Base.Output.Format.Audio.SampleRate = 44100;
  522. // on my T3 (updated ROM) 24000hz crashes almost always
  523. if (p->Base.Output.Format.Audio.SampleRate > 22050 && p->Base.Output.Format.Audio.SampleRate < 32000)
  524. p->Base.Output.Format.Audio.SampleRate = 32000;
  525. if (p->Base.Output.Format.Audio.SampleRate > 16000 && p->Base.Output.Format.Audio.SampleRate < 22050)
  526. p->Base.Output.Format.Audio.SampleRate = 22050;
  527. if (p->Base.Output.Format.Audio.SampleRate > 11025 && p->Base.Output.Format.Audio.SampleRate < 16000)
  528. p->Base.Output.Format.Audio.SampleRate = 16000;
  529. }
  531. if (Model == MODEL_ZODIAC)
  532. {
  533. // it seems Zodiac doesn't support 48000Hz
  534. if (p->Base.Output.Format.Audio.SampleRate > 44100)
  535. p->Base.Output.Format.Audio.SampleRate = 44100;
  536. }
  538. // in general for digital camera movies:
  539. if (p->Base.Output.Format.Audio.SampleRate > 8000 && p->Base.Output.Format.Audio.SampleRate < 11025)
  540. {
  541. p->Base.Output.Format.Audio.SampleRate = 11025;
  542. Force16Bits(p);
  543. }
  544. if (p->Base.Output.Format.Audio.SampleRate <= 8000)
  545. {
  546. p->Base.Output.Format.Audio.SampleRate = 8000;
  547. Force16Bits(p);
  548. }
  550. InputRate = (p->Base.Input.Format.Audio.Bits/8)*p->Base.Input.Format.Audio.SampleRate;
  551. if (!(p->Base.Input.Format.Audio.Flags & PCM_PLANES))
  552. InputRate *= p->Base.Input.Format.Audio.Channels;
  553. if (!InputRate)
  554. return ERR_NOT_SUPPORTED;
  556. Result = CreateStream(p);
  557. if (Result != ERR_NONE)
  558. return Result;
  560. p->BufferMode = 1;
  561. p->TimeRef = GetTimeTick();
  562. p->BytePerSample = (p->Base.Output.Format.Audio.Bits * p->Base.Output.Format.Audio.Channels)/8;
  563. p->BytePerSec = p->Base.Output.Format.Audio.SampleRate * p->BytePerSample;
  564. p->Ratio = (256 * p->BytePerSec + InputRate - 1) / InputRate;
  566. WaveOutPCM(&p->Base);
  567. p->PCMCopy = PCMCreate(&p->Base.Output.Format.Audio,&p->Base.Output.Format.Audio,0,0);
  569. if (!p->PCMCopy || !p->Base.PCM)
  570. return ERR_OUT_OF_MEMORY;
  572. if (UpdateBufferMode(p) != ERR_NONE)
  573. return ERR_OUT_OF_MEMORY;
  575. UpdateSpeed(p);
  576. return ERR_NONE;
  577. }
  579. static int UpdatePlay(waveout_palm* p)
  580. {
  581. if (p->Play)
  582. {
  583. p->TimeRef = GetTimeTick();
  584. Start(p,p->Tick);
  585. }
  586. else
  587. {
  588. //tick_t Adjust = p->DrvBufferDelay; can be too big jump into the future, which is disturbing at pause
  589. int Tick = GetTimeTick();
  590. Stop(p);
  591. p->Tick += Scale(Tick-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);// + Adjust;
  592. }
  593. return ERR_NONE;
  594. }
  596. static int TimerGet(void* pt, int No, void* Data, int Size)
  597. {
  598. waveout_palm* p = WAVEOUT(pt);
  599. int Result = ERR_INVALID_PARAM;
  600. switch (No)
  601. {
  602. case TIMER_PLAY: GETVALUE(p->Play,bool_t); break;
  603. case TIMER_SPEED: GETVALUE(p->Speed,fraction); break;
  604. case TIMER_TIME:
  605. assert(Size == sizeof(tick_t));
  607. if (p->Speed.Num==0)
  608. *(tick_t*)Data = TIME_BENCH;
  609. else
  610. if (p->Play)
  611. *(tick_t*)Data = p->Tick + Scale(GetTimeTick()-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
  612. else
  613. *(tick_t*)Data = p->Tick;
  615. Result = ERR_NONE;
  616. break;
  617. }
  618. return Result;
  619. }
  621. static int TimerSet(void* pt, int No, const void* Data, int Size)
  622. {
  623. waveout_palm* p = WAVEOUT(pt);
  624. int Result = ERR_INVALID_PARAM;
  625. switch (No)
  626. {
  627. case TIMER_PLAY: SETVALUECMP(p->Play,bool_t,UpdatePlay(p),EqBool); break;
  628. case TIMER_SPEED: SETVALUECMP(p->Speed,fraction,UpdateSpeed(p),EqFrac); break;
  629. case TIMER_TIME:
  630. assert(Size == sizeof(tick_t));
  631. p->Tick = *(tick_t*)Data;
  632. p->TimeRef = GetTimeTick();
  633. Result = ERR_NONE;
  634. break;
  635. }
  636. return Result;
  637. }
  639. static int Get(waveout_palm* p, int No, void* Data, int Size)
  640. {
  641. int Result = WaveOutBaseGet(&p->Base,No,Data,Size);
  642. switch (No)
  643. {
  644. case AOUT_VOLUME: GETVALUE(p->Volume,int); break;
  645. case AOUT_MUTE: GETVALUE(p->Mute,bool_t); break;
  646. case AOUT_PREAMP: GETVALUE(p->PreAmp,int); break;
  647. case AOUT_PAN: GETVALUE(p->Pan,int); break;
  648. case AOUT_MODE: GETVALUE(p->BufferMode,bool_t); break;
  649. }
  650. return Result;
  651. }
  652. static int Set(waveout_palm* p, int No, const void* Data, int Size) { int Result = WaveOutBaseSet(&p->Base,No,Data,Size); switch (No) { case AOUT_VOLUME: SETVALUECMP(p->Volume,int,UpdateVolume(p),EqInt); break; case AOUT_MUTE: SETVALUECMP(p->Mute,bool_t,UpdateVolume(p),EqBool); break; 
  653. case AOUT_PREAMP: SETVALUECMP(p->PreAmp,int,UpdateVolume(p),EqInt); break;
  654. case AOUT_PAN: SETVALUECMP(p->Pan,int,UpdatePan(p),EqInt); break;
  655. case AOUT_MODE: SETVALUECMP(p->BufferMode,bool_t,UpdateBufferMode(p),EqBool); break;
  656. case FLOW_FLUSH:
  657. Result = Flush(p);
  658. break;
  659. } return Result; }
  660. static int Create(waveout_palm* p)
  661. {
  662. int Model = QueryPlatform(PLATFORM_MODEL);
  663. UInt32 CompanyID;
  664. UInt32 Version;
  666. if (Model!=MODEL_TUNGSTEN_T && (FtrGet(sysFileCSoundMgr, sndFtrIDVersion, &Version)!=errNone || Version<100))
  667. return ERR_NOT_SUPPORTED;
  669. p->Base.Init = (nodefunc)Init;
  670. p->Base.Done = (nodefunc)Done;
  671. p->Base.Process = (packetprocess)Process;
  672. p->Base.Node.Get = (nodeget)Get;
  673. p->Base.Node.Set = (nodeset)Set;
  674. p->Base.Timer.Class = TIMER_CLASS;
  675. p->Base.Timer.Enum = TimerEnum;
  676. p->Base.Timer.Get = TimerGet;
  677. p->Base.Timer.Set = TimerSet;
  678. p->Base.Quality = 2;
  679. p->Speed.Num = 1;
  680. p->Speed.Den = 1;
  682. FtrGet(sysFtrCreator, sysFtrNumOEMCompanyID, &CompanyID);
  683. FtrGet(sysFtrCreator, sysFtrNumROMVersion, &Version);
  685. // I think MCA2 doesn't like more stop and start sequences. Stream has to deleted and recreated
  686. p->AlwaysClose = CompanyID == 'sony' && sysGetROMVerMajor(Version)==5 && sysGetROMVerMinor(Version)<2;
  687. p->Force16Bits = sysGetROMVerMajor(Version)==5 && sysGetROMVerMinor(Version)<2;
  688. p->Native = 1;
  690. if (Model==MODEL_QDA700)
  691. p->Native = 0; // crashes with ARM callback(?)
  693. return ERR_NONE;
  694. }
  696. static const nodedef WaveOut =
  697. {
  698. sizeof(waveout_palm)|CF_GLOBAL,
  699. WAVEOUT_ID,
  700. AOUT_CLASS,
  701. PRI_DEFAULT,
  702. (nodecreate)Create,
  703. };
  704. void WaveOut_Init() { NodeRegisterClass(&WaveOut);
  705. } void WaveOut_Done() { NodeUnRegisterClass(WAVEOUT_ID); } #endif