API tools faq
paste
Advertisement
xiahanlu

CDirectMusic2.hxx

xiahanlu
Jul 5th, 2018
197
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.76 KB | None | 0 0
raw download clone embed print report
  1. // CDirectMusic2.hxx
  2. // Provide Basic midi input and output (no midi keyboard input).
  3. # if _MSC_VER >= 1000
  4. # pragma once
  5. # endif // _MSC_VER >= 1000
  6.  
  7. // lots of code from
  8. //
  9. // <1> DirectMidi Librarary http://directmidi.sourceforge.net/
  10. // <2> Mircosoft DirectX 9.0b SDK (with directmusic version) source code samples.
  11. // <3> codeproject's project https://www.codeproject.com/Articles/2651/Developing-MIDI-applications-with-DirectMusic
  12. //
  13. // thanks them !
  14. //
  15. // I don't know much about DirectMusic and MIDI. :(
  16. // The code doesn't write very well. soory - moecmks
  17.  
  18. # if !defined (_CDIRECTMUSIC2_INCLUED_HEADER_CXX_)
  19. # define _CDIRECTMUSIC2_INCLUED_HEADER_CXX_
  20.  
  21. # define INITGUID
  22.  
  23. # include <atldef.h> // for ATLASSERT
  24. # include <initguid.h>
  25. # include <dmksctrl.h>
  26. # include <directx/include/dsound.h>
  27. # include <directx/include/dmusicc.h>
  28. # include <directx/include/dmusici.h>
  29. # include <directx/include/dmusics.h>
  30. # include <directx/include/dmusicf.h>
  31. # include <directx/include/dmusbuff.h>
  32. # include <directx/include/dmplugin.h>
  33.  
  34. class CDirectMusic2 {
  35. public:
  36. struct DSFX_InitParam {
  37. const GUID *IID_object;
  38. const GUID *GUID_object;
  39. DWORD dwSize;
  40. };
  41.  
  42. private:
  43. // Global CDirectMusic2 COM root and settings.
  44. static IDirectMusic *sm_DirectMusic_root;
  45. static IDirectSound8 *sm_DirectSound_root;
  46. static const int CURRENT_USE_EFFECT_TOTAL = 9;
  47. static DSFX_InitParam sm_DSFX_InitParam[CURRENT_USE_EFFECT_TOTAL];
  48.  
  49. public:
  50. static BOOL CALLBACK DSEnumCallback__(
  51. LPGUID lpGuid,
  52. LPCTSTR lpcstrDescription,
  53. LPCTSTR lpcstrModule,
  54. LPVOID lpContext )
  55.  
  56. {
  57. // Enum audio device, for test .
  58. return TRUE;
  59. }
  60.  
  61. // Global init for all CDirectMusic2 object
  62. static void InitDirectMusic (HWND hWindow) {
  63. HRESULT sig = CoCreateInstance (CLSID_DirectMusic, NULL,
  64. CLSCTX_INPROC, IID_IDirectMusic8,(void**)& sm_DirectMusic_root);
  65. ATLASSERT (SUCCEEDED (sig));
  66.  
  67. // enum device.
  68. // DirectSoundEnumerate (DSEnumCallback__, NULL);
  69.  
  70. sig = DirectSoundCreate8 (NULL, & sm_DirectSound_root, NULL);
  71. ATLASSERT (SUCCEEDED (sig));
  72. sig = sm_DirectSound_root->SetCooperativeLevel (hWindow, DSSCL_PRIORITY);
  73. ATLASSERT (SUCCEEDED (sig));
  74. sig = sm_DirectMusic_root->SetDirectSound (sm_DirectSound_root, hWindow);
  75. ATLASSERT (SUCCEEDED (sig));
  76. }
  77. // Global uninit for all CDirectMusic2 object
  78. static void UninitDirectMusic (void) {
  79. release_com<IDirectSound8>(sm_DirectSound_root);
  80. release_com<IDirectMusic>(sm_DirectMusic_root);
  81. }
  82.  
  83. public:
  84. // pos in group index.
  85. enum IDIRECTEFFECTS_POS_ {
  86. IDIRECTEFFECTS_POS_CHORUS = 0,
  87. IDIRECTEFFECTS_POS_COMPRESSOR,
  88. IDIRECTEFFECTS_POS_DISTORTION,
  89. IDIRECTEFFECTS_POS_ECHO,
  90. IDIRECTEFFECTS_POS_FLANGER,
  91. IDIRECTEFFECTS_POS_GARGLE,
  92. IDIRECTEFFECTS_POS_PARAMEQ,
  93. IDIRECTEFFECTS_POS_REVERB,
  94. IDIRECTEFFECTS_POS_REVERB_LEVEL2
  95. };
  96. // standard directsound effects .
  97. union DSFX_desc {
  98. DSFXChorus efs_chorus;
  99. DSFXCompressor efs_compressor;
  100. DSFXDistortion efs_distortion;
  101. DSFXEcho efs_echo;
  102. DSFXFlanger efs_flanger;
  103. DSFXGargle efs_gargle;
  104. DSFXParamEq efs_paramEq;
  105. DSFXWavesReverb efs_reverb;
  106. DSFXI3DL2Reverb efs_reverb_level2;
  107. };
  108. // FX sound object set.
  109. union DSFX_object {
  110. IDirectSoundFXChorus8 * efs_chorus;
  111. IDirectSoundFXCompressor8 * efs_compressor;
  112. IDirectSoundFXDistortion8 * efs_distortion;
  113. IDirectSoundFXEcho8 * efs_echo;
  114. IDirectSoundFXFlanger8 * efs_flanger;
  115. IDirectSoundFXGargle8 * efs_gargle;
  116. IDirectSoundFXParamEq8 * efs_paramEq;
  117. IDirectSoundFXWavesReverb8 *efs_reverb;
  118. IDirectSoundFXI3DL2Reverb8 *efs_reverb_level2;
  119. IUnknown *com_pointer;
  120. void *common_pointer;
  121. };
  122.  
  123. struct DSFX_Reverb2 {
  124. DSFXI3DL2Reverb desc;
  125. int Quality;
  126. int Type;
  127. };
  128. // for use .
  129. struct DSFX_vec {
  130. DSFX_desc desc;
  131. DSFX_object object;
  132. DSFX_InitParam *init_param;
  133. BOOL enable;
  134. };
  135. private:
  136. // class object var.
  137. DSFX_vec DSFX_vec_[CURRENT_USE_EFFECT_TOTAL];
  138.  
  139. // directmusic object pointer .
  140. IDirectSoundBuffer * m_pDSBuf;
  141. IDirectSoundBuffer8 * m_pDSBuf8;
  142. IDirectMusicLoader8 * m_pLoader;
  143. IDirectMusicDownloadedInstrument8 * m_pDLSInstrument; // DLS instructments
  144. IDirectMusicInstrument8 * m_pInstrument; // instructments set
  145. IDirectMusicPort8 * m_pOutPort;
  146. IDirectMusicCollection8 * m_pCollection;
  147. IDirectMusicBuffer8 * m_pDMBuf8;
  148. IReferenceClock * m_pClock;
  149.  
  150. std::vector <CString> m_vecCollectionDLS; // DLS cache from files.
  151. std::vector <CString> m_vecInstrInDLS;
  152.  
  153. DMUS_PORTPARAMS8 m_OutParams;
  154.  
  155. DWORD m_SelDLSIndex;
  156. DWORD m_SelInstructments;
  157. public:
  158. // export private object method .
  159. void Get_vecCollectionDLS (std::vector <CString> *& p) { p = & m_vecCollectionDLS; }
  160. void Get_vecInstrInDLS (std::vector <CString> *&p) { p = & m_vecInstrInDLS; }
  161. public:
  162. // deconstruct
  163. ~CDirectMusic2 (void) {
  164. ReleaseInstructment ();
  165. ReleaseCollection ();
  166.  
  167. HRESULT sig = m_pOutPort->Activate (FALSE);
  168. ATLASSERT (SUCCEEDED (sig));
  169.  
  170. // Release effects .
  171. for (DWORD id =0; id != CURRENT_USE_EFFECT_TOTAL; id++) {
  172. DSFX_vec_[id].init_param = & sm_DSFX_InitParam[id];
  173. DSFX_vec_[id].enable = FALSE;
  174. DSFX_vec_[id].object.com_pointer->Release ();
  175. DSFX_vec_[id].object.common_pointer = NULL;
  176. }
  177. sig = m_pDSBuf8->Stop ();
  178. ATLASSERT (SUCCEEDED (sig));
  179.  
  180. sig = m_pDSBuf8->SetFX (0, NULL, NULL);
  181. ATLASSERT (SUCCEEDED (sig));
  182.  
  183. release_com <IReferenceClock> ( m_pClock);
  184. release_com <IDirectMusicLoader8> ( m_pLoader);
  185. release_com <IDirectMusicBuffer8> ( m_pDMBuf8);
  186. release_com <IDirectMusicPort8> ( m_pOutPort);
  187. release_com <IDirectSoundBuffer8> ( m_pDSBuf8);
  188. release_com <IDirectSoundBuffer> ( m_pDSBuf);
  189. }
  190. // construct
  191. CDirectMusic2 (void) {
  192.  
  193. m_pDSBuf = NULL;
  194. m_pDSBuf8 = NULL;
  195. m_pLoader = NULL;
  196. m_pOutPort = NULL;
  197. m_pDMBuf8 = NULL;
  198. m_pClock = NULL;
  199. m_pDLSInstrument = NULL;
  200. m_pInstrument = NULL;
  201.  
  202. ZeroMemory (& m_OutParams, sizeof (DMUS_PORTPARAMS8));
  203. m_OutParams.dwSize = sizeof (m_OutParams);
  204.  
  205. // create IDirectMusicBuffer8 interface.
  206. DMUS_BUFFERDESC dmbuf_desc; // Create the DirectMusic buffer to store MIDI messages
  207. ZeroMemory (& dmbuf_desc, sizeof (DMUS_BUFFERDESC));
  208. dmbuf_desc.dwSize = sizeof (DMUS_BUFFERDESC);
  209. dmbuf_desc.guidBufferFormat = GUID_NULL;
  210. dmbuf_desc.cbBuffer = DMUS_EVENT_SIZE (32); // at least 32 bytes to store messages
  211.  
  212. HRESULT sig = sm_DirectMusic_root->CreateMusicBuffer (& dmbuf_desc,& m_pDMBuf8, NULL);
  213. ATLASSERT (SUCCEEDED (sig));
  214.  
  215. // create loader
  216. sig = CoCreateInstance(CLSID_DirectMusicLoader,NULL,
  217. CLSCTX_INPROC_SERVER,IID_IDirectMusicLoader8, (LPVOID *)& m_pLoader);
  218. ATLASSERT (SUCCEEDED (sig));
  219.  
  220. ZeroMemory (& DSFX_vec_[0], sizeof (DSFX_vec_));
  221.  
  222. // load effects global settings.
  223. for (DWORD id =0; id != CURRENT_USE_EFFECT_TOTAL; id++) {
  224. DSFX_vec_[id].init_param = & sm_DSFX_InitParam[id];
  225. DSFX_vec_[id].enable = FALSE;
  226. DSFX_vec_[id].object.common_pointer = NULL;
  227. }
  228.  
  229. // enum outport.
  230. DMUS_PORTCAPS portinf;
  231. DWORD dwIndex = 0;
  232. HRESULT hr = -1;
  233.  
  234. ZeroMemory (& portinf, sizeof(portinf));
  235. portinf.dwSize = sizeof (DMUS_PORTCAPS);
  236.  
  237. while ((hr = sm_DirectMusic_root->EnumPort (dwIndex++, & portinf)) == S_OK) {
  238.  
  239. if (portinf.dwClass == DMUS_PC_OUTPUTCLASS) {
  240. if (portinf.dwFlags & DMUS_PC_DLS2) {
  241. // Create DLS output .
  242. ZeroMemory (& m_OutParams, sizeof (m_OutParams));
  243. m_OutParams.dwSize = sizeof (m_OutParams);
  244.  
  245. HRESULT sig = sm_DirectMusic_root->CreatePort (portinf.guidPort, & m_OutParams, & m_pOutPort, NULL);
  246. ATLASSERT (SUCCEEDED (sig));
  247.  
  248. // get clock
  249. sig = m_pOutPort->GetLatencyClock (& m_pClock);
  250. ATLASSERT (SUCCEEDED (sig));
  251.  
  252. // XXX: ext wave memory size.
  253. struct WAVEFORMATEX__ {
  254. WAVEFORMATEX wave_;
  255. BYTE ext[256];
  256. } wave2;
  257. DWORD dwExtWaveSize;
  258. DWORD dwBufferSize;
  259. ZeroMemory (& wave2.wave_, sizeof (wave2.wave_));
  260. sig = m_pOutPort->GetFormat (& wave2.wave_, & dwExtWaveSize, & dwBufferSize);
  261. ATLASSERT (SUCCEEDED (sig));
  262.  
  263. // create directsound buffer attach to directmusic port..
  264. DSBUFFERDESC dsbuf_desc;
  265. ZeroMemory (& dsbuf_desc, sizeof (DSBUFFERDESC));
  266. dsbuf_desc.dwSize = sizeof ( DSBUFFERDESC );
  267. # if 1
  268. dsbuf_desc.dwFlags = DSBCAPS_LOCSOFTWARE | DSBCAPS_CTRLFX | DSBCAPS_CTRLVOLUME | DSBCAPS_GLOBALFOCUS;
  269. # else
  270. dsbuf_desc.dwFlags = DSBCAPS_LOCHARDWARE | DSBCAPS_CTRLFX | DSBCAPS_CTRLVOLUME | DSBCAPS_GLOBALFOCUS;
  271. # endif
  272. dsbuf_desc.dwBufferBytes = dwBufferSize;
  273. dsbuf_desc.lpwfxFormat = & wave2.wave_;
  274.  
  275. sig = sm_DirectSound_root->CreateSoundBuffer (& dsbuf_desc, & m_pDSBuf, NULL);
  276. ATLASSERT (SUCCEEDED (sig));
  277.  
  278. // get IDirectSoundBuffer8 from IDirectSoundBuffer
  279.  
  280. sig = m_pDSBuf->QueryInterface (IID_IDirectSoundBuffer8, (LPVOID *) & m_pDSBuf8);
  281. ATLASSERT (SUCCEEDED (sig));
  282.  
  283. m_pDSBuf8->SetVolume (DSBVOLUME_MAX);
  284.  
  285. m_pOutPort->SetDirectSound (sm_DirectSound_root, m_pDSBuf8);
  286.  
  287. // Get default dls
  288. DMUS_OBJECTDESC dmusdesc;
  289.  
  290. ZeroMemory(& dmusdesc, sizeof (DMUS_OBJECTDESC));
  291. dmusdesc.dwSize = sizeof (DMUS_OBJECTDESC);
  292. dmusdesc.guidClass = CLSID_DirectMusicCollection;
  293. dmusdesc.guidObject = GUID_DefaultGMCollection;
  294. dmusdesc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_OBJECT;
  295.  
  296. ATLASSERT (m_pLoader != NULL);
  297. sig = m_pLoader->GetObject (& dmusdesc, IID_IDirectMusicCollection, (LPVOID *)& m_pCollection);
  298. ATLASSERT (SUCCEEDED (sig));
  299.  
  300. m_vecCollectionDLS.push_back (_T ("default dls"));
  301.  
  302. EnumDLSInstructment (NULL);
  303. AdjustInstructmentsIndex (47);
  304. return ;
  305. }
  306. }
  307. }
  308. // never reach here.
  309. ATLASSERT (FALSE);
  310. }
  311.  
  312. void EnumDLSInstructment (/* not release */ std::vector <CString> **instructments) {
  313. ATLASSERT (m_pCollection != NULL);
  314.  
  315. m_vecInstrInDLS.clear ();
  316. DWORD id = 0;
  317.  
  318. while (TRUE) {
  319. DWORD patch;
  320. TCHAR szBuf[MAX_PATH], szBuf2[MAX_PATH];
  321. HRESULT sig = m_pCollection->EnumInstrument (id ++, & patch, szBuf, sizeof (szBuf)/ sizeof (szBuf[0]));
  322. ATLASSERT (sig == S_FALSE || (sig == S_OK));
  323. if (sig == S_FALSE) break ;
  324. _stprintf (szBuf2, _T ("%d %s"), id, szBuf);
  325. m_vecInstrInDLS.push_back (szBuf2);
  326. }
  327. if (instructments != NULL)
  328. * instructments = & m_vecInstrInDLS;
  329. }
  330.  
  331. // adjust InstructIndex
  332. void AdjustInstructmentsIndex (DWORD instruct_id = 0) {
  333.  
  334. ATLASSERT (m_pCollection != NULL);
  335. BYTE bSelInstruct = (BYTE) (m_SelInstructments = instruct_id);
  336.  
  337. ReleaseInstructment ();
  338.  
  339. WCHAR szBuf[MAX_PATH];
  340. DWORD patch;
  341. HRESULT sig = m_pCollection->EnumInstrument (m_SelInstructments, & patch, szBuf, sizeof (szBuf)/ sizeof (szBuf[0]));
  342. ATLASSERT (SUCCEEDED (sig));
  343.  
  344. sig = m_pCollection->GetInstrument (patch, & m_pInstrument);
  345. ATLASSERT (SUCCEEDED (sig));
  346. sig = m_pInstrument->SetPatch (1);
  347. ATLASSERT (SUCCEEDED (sig));
  348.  
  349. DMUS_NOTERANGE t = { 0, 127 }; // standard midi range,
  350. sig = m_pOutPort->DownloadInstrument (m_pInstrument,
  351. & m_pDLSInstrument, & t, 1);// octave group := 1 ...
  352. ATLASSERT (SUCCEEDED (sig));
  353.  
  354. bSelInstruct = 1;
  355.  
  356. sig = m_pOutPort->Activate (FALSE);
  357. ATLASSERT (SUCCEEDED (sig));
  358.  
  359. sig = m_pOutPort->Activate (TRUE);
  360. ATLASSERT (SUCCEEDED (sig));
  361.  
  362. SendMidiMsg (EncodeMidiMessage (0xC0, 0, 1, 0));
  363. }
  364.  
  365. // adjust CollectionIndex
  366. int AdjustCollectionIndex (DWORD collection_id = 0, DWORD instruct_id = 0) {
  367. if (TRUE /*isDirectMuscSoftSynthesizer () != FALSE*/) {
  368. ReleaseInstructment ();
  369. ReleaseCollection ();
  370.  
  371. // get collection
  372. int res = 0;
  373. HRESULT sig =0;
  374. // Load default DLS .
  375. if (collection_id == 0)
  376. LoadDefaultDLSCollection ();
  377. else
  378. res = LoadDLSCollection (collection_id);
  379. if (res != 0)
  380. LoadDefaultDLSCollection ();
  381. m_SelInstructments = instruct_id;
  382. m_SelDLSIndex = collection_id;
  383.  
  384. EnumDLSInstructment (NULL);
  385. AdjustInstructmentsIndex (m_SelInstructments);
  386.  
  387. return res;
  388. }
  389. // never reach here .
  390. ATLASSERT (FALSE);
  391. }
  392.  
  393. void GetEffectDesc_Really ( IDIRECTEFFECTS_POS_ pos) {
  394. DSFX_vec &t= DSFX_vec_[pos];
  395. HRESULT sig = -1;
  396. // UnactivateOutport ();
  397. # define PRIVATE_UNWIND(_pos, _dummy) \
  398. case (_pos): \
  399. sig = t.object.efs_##_dummy##->GetAllParameters (& t.desc.efs_##_dummy##); \
  400. break;
  401. switch (pos ) {
  402. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_CHORUS, chorus);
  403. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_COMPRESSOR, compressor);
  404. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_DISTORTION, distortion);
  405. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_ECHO, echo);
  406. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_FLANGER, flanger);
  407. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_GARGLE, gargle);
  408. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_PARAMEQ, paramEq);
  409. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_REVERB, reverb);
  410. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_REVERB_LEVEL2, reverb_level2);
  411. # undef PRIVATE_UNWIND
  412. default: ATLASSERT (FALSE); break;
  413. }
  414. ATLASSERT (SUCCEEDED (sig));
  415. }
  416.  
  417. void SetEffectDesc_Really ( IDIRECTEFFECTS_POS_ pos) {
  418. DSFX_vec &t= DSFX_vec_[pos];
  419. # define PRIVATE_UNWIND(_pos, _dummy) \
  420. case (_pos): \
  421. t.object.efs_##_dummy->SetAllParameters (& t.desc.efs_##_dummy); \
  422. break;
  423. switch (pos ) {
  424. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_CHORUS, chorus);
  425. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_COMPRESSOR, compressor);
  426. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_DISTORTION, distortion);
  427. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_ECHO, echo);
  428. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_FLANGER, flanger);
  429. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_GARGLE, gargle);
  430. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_PARAMEQ, paramEq);
  431. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_REVERB, reverb);
  432. PRIVATE_UNWIND (IDIRECTEFFECTS_POS_REVERB_LEVEL2, reverb_level2);
  433. # undef PRIVATE_UNWIND
  434. default: ATLASSERT (FALSE); break;
  435. }
  436. }
  437.  
  438. // group .
  439. void GetEffectDesc ( IDIRECTEFFECTS_POS_ pos, DSFX_desc &pp) {
  440. memcpy ( & pp , & DSFX_vec_[pos].desc, DSFX_vec_[pos].init_param->dwSize);
  441. }
  442. void SetEffectEnable (IDIRECTEFFECTS_POS_ pos, BOOL enable) {
  443. DSEFFECTDESC effect_gp[CURRENT_USE_EFFECT_TOTAL];
  444. DSFX_vec *effect_p[CURRENT_USE_EFFECT_TOTAL];
  445. DWORD dwScanSet = 0;
  446. BOOL enable_old = DSFX_vec_[pos].enable;
  447. DSFX_vec_[pos].enable = enable;
  448. ZeroMemory ( effect_gp, sizeof (effect_gp));
  449. if (enable_old == FALSE && (enable == FALSE))
  450. return ;
  451. if (enable_old != FALSE && enable != FALSE)
  452. return ;
  453.  
  454. for ( int id = 0; id != CURRENT_USE_EFFECT_TOTAL; id++) {
  455. if ( DSFX_vec_[id].enable != FALSE) {
  456. // scan into array .
  457. effect_gp[dwScanSet].dwFlags = DSFX_LOCSOFTWARE;
  458. effect_gp[dwScanSet].dwSize = sizeof (DSEFFECTDESC);
  459. memcpy ( & effect_gp[dwScanSet].guidDSFXClass,
  460. DSFX_vec_[id].init_param->GUID_object,
  461. sizeof (GUID));
  462. effect_p[dwScanSet] = & DSFX_vec_[id];
  463. dwScanSet ++;
  464. } else {
  465. // diable it.
  466. release_com<IUnknown> (DSFX_vec_[id].object.com_pointer);
  467. }
  468. }
  469. // make Unactivate
  470. HRESULT sig = m_pOutPort->Activate (FALSE);
  471. ATLASSERT (SUCCEEDED (sig));
  472. DWORD result[CURRENT_USE_EFFECT_TOTAL];
  473. if ( dwScanSet == 0) {
  474. sig = m_pDSBuf8->SetFX (0, NULL, NULL);
  475. ATLASSERT (SUCCEEDED (sig));
  476. sig = m_pOutPort->Activate (TRUE);
  477. ATLASSERT (SUCCEEDED (sig));
  478. return ;
  479. }
  480. sig = m_pDSBuf8->SetFX (dwScanSet, & effect_gp[0], & result[0]);
  481. ATLASSERT (SUCCEEDED (sig));
  482.  
  483. // GetEffectObject
  484. for ( int id = 0; id != dwScanSet; id++) {
  485. DSFX_vec *p = effect_p[id];
  486. HRESULT sig = m_pDSBuf8->GetObjectInPath (* (p->init_param->GUID_object), 0,
  487. *(p->init_param->IID_object), (void **)&p->object.common_pointer);
  488. ATLASSERT (SUCCEEDED (sig));
  489. }
  490. sig = m_pOutPort->Activate (TRUE);
  491. ATLASSERT (SUCCEEDED (sig));
  492. }
  493. void SetEffectDesc ( IDIRECTEFFECTS_POS_ pos, DSFX_desc *p) {
  494. memcpy ( & DSFX_vec_[pos].desc, p, DSFX_vec_[pos].init_param->dwSize);
  495. SetEffectEnable (pos, TRUE);
  496. SetEffectDesc_Really (pos);
  497. }
  498. void SetReverb_L2Quality (LONG i) {
  499. if ( DSFX_vec_[IDIRECTEFFECTS_POS_REVERB_LEVEL2].object.efs_reverb_level2 != NULL) {
  500. HRESULT sig = DSFX_vec_[IDIRECTEFFECTS_POS_REVERB_LEVEL2].object.efs_reverb_level2->SetQuality (i);
  501. ATLASSERT (SUCCEEDED (sig));
  502. }
  503. }
  504. void SetReverb_L2Type (DWORD type) {
  505. if ( DSFX_vec_[IDIRECTEFFECTS_POS_REVERB_LEVEL2].object.efs_reverb_level2 != NULL) {
  506. HRESULT sig = DSFX_vec_[IDIRECTEFFECTS_POS_REVERB_LEVEL2].object.efs_reverb_level2->SetPreset (type);
  507. ATLASSERT (SUCCEEDED (sig));
  508. }
  509. }
  510.  
  511. int Get_Reverb_L2 (struct DSFX_Reverb2 *eb2) {
  512. IDirectSoundFXI3DL2Reverb8 *p = DSFX_vec_[IDIRECTEFFECTS_POS_REVERB_LEVEL2].object.efs_reverb_level2;
  513. // Get base param.
  514. HRESULT sig = p->GetAllParameters (& eb2->desc);
  515. ATLASSERT (SUCCEEDED (sig));
  516. sig = p->GetQuality ((LONG *)& eb2->Quality);
  517. ATLASSERT (SUCCEEDED (sig));
  518. //sig = p->GetPreset ((DWORD *)& eb2->Type);
  519. //ATLASSERT (SUCCEEDED (sig));
  520. return 0;
  521. }
  522.  
  523. public:
  524. BOOL LoadCollectionString (TCHAR *dls_filename) {
  525. m_vecCollectionDLS.push_back ( dls_filename);
  526. }
  527. void ResetCollectionString (void) {
  528. m_vecCollectionDLS.clear ();
  529. m_vecCollectionDLS.push_back (_T("default dls"));
  530. }
  531. void DeleteCollectionString (int id) {
  532. ATLASSERT (id < m_vecCollectionDLS.size ());
  533. if ( id == 0) return ;
  534. m_vecCollectionDLS.erase (m_vecCollectionDLS.begin()+ id);
  535. }
  536. void LoadDefaultDLSCollection (void) {
  537. HRESULT sig = -1;
  538. DMUS_OBJECTDESC dmusdesc;
  539.  
  540. ReleaseInstructment ();
  541. ReleaseCollection ();
  542.  
  543. ZeroMemory(& dmusdesc, sizeof (DMUS_OBJECTDESC));
  544. dmusdesc.dwSize = sizeof (DMUS_OBJECTDESC);
  545. dmusdesc.guidClass = CLSID_DirectMusicCollection;
  546. dmusdesc.guidObject = GUID_DefaultGMCollection;
  547. dmusdesc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_OBJECT;
  548.  
  549. ATLASSERT (m_pLoader != NULL);
  550. sig = m_pLoader->GetObject (& dmusdesc, IID_IDirectMusicCollection, (void**)& m_pCollection);
  551. ATLASSERT (SUCCEEDED (sig));
  552. // send midi
  553. }
  554.  
  555. HRESULT SendMidiMsg (DWORD dwMsg) {
  556. HRESULT sig = -1;
  557. REFERENCE_TIME rt;
  558. //if ( isOutportActivate () == FALSE)
  559. // ActivateOutport ();
  560. rt = 0;
  561. sig = m_pClock->GetTime (&rt);
  562. //ATLASSERT (SUCCEEDED (sig));
  563. sig = m_pDMBuf8->PackStructured (rt, m_OutParams.dwChannelGroups, dwMsg);
  564. //ATLASSERT (SUCCEEDED (sig));
  565. sig = m_pOutPort->PlayBuffer (m_pDMBuf8);
  566. //ATLASSERT (SUCCEEDED (sig));
  567. sig = m_pDMBuf8->Flush ();
  568. //ATLASSERT (SUCCEEDED (sig));
  569.  
  570. return sig;
  571. }
  572.  
  573. // For instrument's loop note.
  574. HRESULT ClearNoise (void) {
  575. HRESULT sig = m_pOutPort->Activate (FALSE);
  576. ATLASSERT (SUCCEEDED (sig));
  577. sig = m_pOutPort->Activate (TRUE);
  578. ATLASSERT (SUCCEEDED (sig));
  579. return 0; //ewruen
  580. }
  581.  
  582. int LoadDLSCollection (int dls_id) {
  583. ATLASSERT (m_pCollection == NULL);
  584.  
  585. if (dls_id == 0) {
  586. // load default's DLS collection
  587. LoadDefaultDLSCollection ();
  588. return 0;
  589. } else {
  590. HRESULT sig = -1;
  591. DMUS_OBJECTDESC dmusdesc;
  592. // Sets to 0 the DMUS structure
  593.  
  594. ReleaseInstructment ();
  595. ReleaseCollection ();
  596.  
  597. ZeroMemory(& dmusdesc,sizeof(DMUS_OBJECTDESC));
  598.  
  599. # if defined (_UNICODE)
  600. wcscpy (dmusdesc.wszFileName, m_vecCollectionDLS[dls_id]);
  601. # else
  602. mbstowcs (dmusdesc.wszFileName, m_vecCollectionDLS[dls_id], DMUS_MAX_FILENAME);
  603. # endif
  604. dmusdesc.dwSize = sizeof(DMUS_OBJECTDESC);
  605. dmusdesc.guidClass = CLSID_DirectMusicCollection;
  606. dmusdesc.guidObject = GUID_DefaultGMCollection;
  607. dmusdesc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME | DMUS_OBJ_FULLPATH;
  608.  
  609. ATLASSERT (m_pLoader != NULL);
  610. sig = m_pLoader->GetObject (& dmusdesc, IID_IDirectMusicCollection, (LPVOID FAR *)& m_pCollection);
  611. if (SUCCEEDED (sig)) return 0;
  612. else LoadDefaultDLSCollection ();
  613. return -1;
  614. }
  615.  
  616. }
  617. // https://www.midi.org/specifications/item/table-1-summary-of-midi-message
  618. //
  619. // typedef struct DMUS_MIDI_PMSGG {
  620. // DMUS_PMSG_PART
  621. // BYTE bStatus;
  622. // BYTE bByte1;
  623. // BYTE bByte2;
  624. // BYTE bPad[1];
  625. // } DMUS_MIDI_PMSG;
  626.  
  627. DWORD EncodeMidiMessage (BYTE cmd, BYTE chan, BYTE data, BYTE data2) {
  628. DWORD msg;
  629. msg = cmd | chan;
  630. msg |= ( data << 8);
  631. msg |= (data2 << 16);
  632. return msg;
  633. }
  634. DWORD EncodeMidiMessage (BYTE status, BYTE data, BYTE data2) {
  635. DWORD msg = status;
  636. msg |= ( data << 8);
  637. msg |= (data2 << 16);
  638. return msg;
  639. }
  640. public:
  641. void ReleaseCollection (void) {
  642. if (m_pLoader && m_pCollection) {
  643. m_pLoader->ReleaseObjectByUnknown (m_pCollection);
  644. release_com<IDirectMusicCollection8> (m_pCollection);
  645. }
  646. }
  647. void ReleaseInstructment (void) {
  648. if (m_pDLSInstrument && m_pOutPort) {
  649. m_pOutPort->UnloadInstrument (m_pDLSInstrument);
  650. release_com<IDirectMusicDownloadedInstrument8> (m_pDLSInstrument);
  651. }
  652. release_com<IDirectMusicInstrument8> (m_pInstrument);
  653. }
  654. };
  655. // init root. int static private
  656. IDirectMusic *CDirectMusic2::sm_DirectMusic_root = nullptr;
  657. IDirectSound8 *CDirectMusic2::sm_DirectSound_root = nullptr;
  658. // guid settings.
  659. CDirectMusic2::DSFX_InitParam CDirectMusic2::sm_DSFX_InitParam[CURRENT_USE_EFFECT_TOTAL] = {
  660. { & IID_IDirectSoundFXChorus8, & GUID_DSFX_STANDARD_CHORUS, sizeof (DSFXChorus) },
  661. { & IID_IDirectSoundFXCompressor8, & GUID_DSFX_STANDARD_COMPRESSOR, sizeof (DSFXCompressor) },
  662. { & IID_IDirectSoundFXDistortion8, & GUID_DSFX_STANDARD_DISTORTION, sizeof (DSFXDistortion) },
  663. { & IID_IDirectSoundFXEcho8, & GUID_DSFX_STANDARD_ECHO, sizeof (DSFXEcho) },
  664. { & IID_IDirectSoundFXFlanger8, & GUID_DSFX_STANDARD_FLANGER, sizeof (DSFXFlanger) },
  665. { & IID_IDirectSoundFXGargle8, & GUID_DSFX_STANDARD_GARGLE, sizeof (DSFXGargle) },
  666. { & IID_IDirectSoundFXParamEq8, & GUID_DSFX_STANDARD_PARAMEQ, sizeof (DSFXParamEq) },
  667. { & IID_IDirectSoundFXWavesReverb8, & GUID_DSFX_WAVES_REVERB, sizeof (DSFXWavesReverb) },
  668. { & IID_IDirectSoundFXI3DL2Reverb8, & GUID_DSFX_STANDARD_I3DL2REVERB, sizeof (DSFXI3DL2Reverb) }
  669. };
  670.  
  671. # endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!