dlls/dmime/performance.c

   1 /* IDirectMusicPerformance Implementation
   2  *
   3  * Copyright (C) 2003-2004 Rok Mandeljc
   4  * Copyright (C) 2003-2004 Raphael Junqueira
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "dmime_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(dmime);
  24
  25 typedef struct IDirectMusicPerformance8Impl {
  26     IDirectMusicPerformance8 IDirectMusicPerformance8_iface;
  27     LONG ref;
  28     /* IDirectMusicPerformanceImpl fields */
  29     IDirectMusic8 *pDirectMusic;
  30     IDirectSound *pDirectSound;
  31     IDirectMusicGraph *pToolGraph;
  32     DMUS_AUDIOPARAMS pParams;
  33     /* global parameters */
  34     BOOL fAutoDownload;
  35     char cMasterGrooveLevel;
  36     float fMasterTempo;
  37     long lMasterVolume;
  38     /* performance channels */
  39     DMUSIC_PRIVATE_PCHANNEL PChannel[32];
  40     /* IDirectMusicPerformance8Impl fields */
  41     IDirectMusicAudioPath *pDefaultPath;
  42     HANDLE hNotification;
  43     REFERENCE_TIME rtMinimum;
  44     REFERENCE_TIME rtLatencyTime;
  45     DWORD dwBumperLength;
  46     DWORD dwPrepareTime;
  47     /** Message Processing */
  48     HANDLE procThread;
  49     DWORD procThreadId;
  50     REFERENCE_TIME procThreadStartTime;
  51     BOOL procThreadTicStarted;
  52     CRITICAL_SECTION safe;
  53     struct DMUS_PMSGItem *head;
  54     struct DMUS_PMSGItem *imm_head;
  55 } IDirectMusicPerformance8Impl;
  56
  57 typedef struct DMUS_PMSGItem DMUS_PMSGItem;
  58 struct DMUS_PMSGItem {
  59   DMUS_PMSGItem* next;
  60   DMUS_PMSGItem* prev;
  61
  62   REFERENCE_TIME rtItemTime;
  63   BOOL bInUse;
  64   DWORD cb;
  65   DMUS_PMSG pMsg;
  66 };
  67
  68 #define DMUS_PMSGToItem(pMSG)   ((DMUS_PMSGItem*) (((unsigned char*) pPMSG) -  offsetof(DMUS_PMSGItem, pMsg)))
  69 #define DMUS_ItemToPMSG(pItem)  (&(pItem->pMsg))
  70 #define DMUS_ItemRemoveFromQueue(This,pItem) \
  71 {\
  72   if (pItem->prev) pItem->prev->next = pItem->next;\
  73   if (pItem->next) pItem->next->prev = pItem->prev;\
  74   if (This->head == pItem) This->head = pItem->next;\
  75   if (This->imm_head == pItem) This->imm_head = pItem->next;\
  76   pItem->bInUse = FALSE;\
  77 }
  78
  79 #define PROCESSMSG_START           (WM_APP + 0)
  80 #define PROCESSMSG_EXIT            (WM_APP + 1)
  81 #define PROCESSMSG_REMOVE          (WM_APP + 2)
  82 #define PROCESSMSG_ADD             (WM_APP + 4)
  83
  84
  85 static DMUS_PMSGItem* ProceedMsg(IDirectMusicPerformance8Impl* This, DMUS_PMSGItem* cur) {
  86   if (cur->pMsg.dwType == DMUS_PMSGT_NOTIFICATION) {
  87     SetEvent(This->hNotification);
  88   }
  89   DMUS_ItemRemoveFromQueue(This, cur);
  90   switch (cur->pMsg.dwType) {
  91   case DMUS_PMSGT_WAVE:
  92   case DMUS_PMSGT_TEMPO:
  93   case DMUS_PMSGT_STOP:
  94   default:
  95     FIXME("Unhandled PMsg Type: 0x%x\n", cur->pMsg.dwType);
  96     break;
  97   }
  98   return cur;
  99 }
 100
 101 static DWORD WINAPI ProcessMsgThread(LPVOID lpParam) {
 102   IDirectMusicPerformance8Impl* This = lpParam;
 103   DWORD timeOut = INFINITE;
 104   MSG msg;
 105   HRESULT hr;
 106   REFERENCE_TIME rtCurTime;
 107   DMUS_PMSGItem* it = NULL;
 108   DMUS_PMSGItem* cur = NULL;
 109   DMUS_PMSGItem* it_next = NULL;
 110
 111   while (TRUE) {
 112     DWORD dwDec = This->rtLatencyTime + This->dwBumperLength;
 113
 114     if (timeOut > 0) MsgWaitForMultipleObjects(0, NULL, FALSE, timeOut, QS_POSTMESSAGE|QS_SENDMESSAGE|QS_TIMER);
 115     timeOut = INFINITE;
 116
 117     EnterCriticalSection(&This->safe);
 118     hr = IDirectMusicPerformance8_GetTime(&This->IDirectMusicPerformance8_iface, &rtCurTime, NULL);
 119     if (FAILED(hr)) {
 120       goto outrefresh;
 121     }
 122
 123     for (it = This->imm_head; NULL != it; ) {
 124       it_next = it->next;
 125       cur = ProceedMsg(This, it);
 126       HeapFree(GetProcessHeap(), 0, cur);
 127       it = it_next;
 128     }
 129
 130     for (it = This->head; NULL != it && it->rtItemTime < rtCurTime + dwDec; ) {
 131       it_next = it->next;
 132       cur = ProceedMsg(This, it);
 133       HeapFree(GetProcessHeap(), 0, cur);
 134       it = it_next;
 135     }
 136     if (NULL != it) {
 137       timeOut = ( it->rtItemTime - rtCurTime ) + This->rtLatencyTime;
 138     }
 139
 140 outrefresh:
 141     LeaveCriticalSection(&This->safe);
 142
 143     while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) {
 144       /** if hwnd we suppose that is a windows event ... */
 145       if  (NULL != msg.hwnd) {
 146         TranslateMessage(&msg);
 147         DispatchMessageA(&msg);
 148       } else {
 149         switch (msg.message) {
 150         case WM_QUIT:
 151         case PROCESSMSG_EXIT:
 152           goto outofthread;
 153         case PROCESSMSG_START:
 154           break;
 155         case PROCESSMSG_ADD:
 156           break;
 157         case PROCESSMSG_REMOVE:
 158           break;
 159         default:
 160           ERR("Unhandled message %u. Critical Path\n", msg.message);
 161           break;
 162         }
 163       }
 164     }
 165
 166     /** here we should run a little of current AudioPath */
 167
 168   }
 169
 170 outofthread:
 171   TRACE("(%p): Exiting\n", This);
 172
 173   return 0;
 174 }
 175
 176 static BOOL PostMessageToProcessMsgThread(IDirectMusicPerformance8Impl* This, UINT iMsg) {
 177   if (FALSE == This->procThreadTicStarted && PROCESSMSG_EXIT != iMsg) {
 178     BOOL res;
 179     This->procThread = CreateThread(NULL, 0, ProcessMsgThread, This, 0, &This->procThreadId);
 180     if (NULL == This->procThread) return FALSE;
 181     SetThreadPriority(This->procThread, THREAD_PRIORITY_TIME_CRITICAL);
 182     This->procThreadTicStarted = TRUE;
 183     while(1) {
 184       res = PostThreadMessageA(This->procThreadId, iMsg, 0, 0);
 185       /* Let the thread creates its message queue (with MsgWaitForMultipleObjects call) by yielding and retrying */
 186       if (!res && (GetLastError() == ERROR_INVALID_THREAD_ID))
 187         Sleep(0);
 188       else
 189         break;
 190     }
 191     return res;
 192   }
 193   return PostThreadMessageA(This->procThreadId, iMsg, 0, 0);
 194 }
 195
 196 static inline IDirectMusicPerformance8Impl *impl_from_IDirectMusicPerformance8(IDirectMusicPerformance8 *iface)
 197 {
 198     return CONTAINING_RECORD(iface, IDirectMusicPerformance8Impl, IDirectMusicPerformance8_iface);
 199 }
 200
 201 /* IDirectMusicPerformance8 IUnknown part: */
 202 static HRESULT WINAPI IDirectMusicPerformance8Impl_QueryInterface(IDirectMusicPerformance8 *iface,
 203         REFIID riid, void **ppv)
 204 {
 205   TRACE("(%p, %s,%p)\n", iface, debugstr_dmguid(riid), ppv);
 206
 207   if (IsEqualIID (riid, &IID_IUnknown) ||
 208       IsEqualIID (riid, &IID_IDirectMusicPerformance) ||
 209       IsEqualIID (riid, &IID_IDirectMusicPerformance2) ||
 210       IsEqualIID (riid, &IID_IDirectMusicPerformance8)) {
 211     *ppv = iface;
 212     IUnknown_AddRef(iface);
 213     return S_OK;
 214   }
 215
 216   WARN("(%p, %s,%p): not found\n", iface, debugstr_dmguid(riid), ppv);
 217   return E_NOINTERFACE;
 218 }
 219
 220 static ULONG WINAPI IDirectMusicPerformance8Impl_AddRef(IDirectMusicPerformance8 *iface)
 221 {
 222   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 223   ULONG ref = InterlockedIncrement(&This->ref);
 224
 225   TRACE("(%p): AddRef from %d\n", This, ref - 1);
 226
 227   DMIME_LockModule();
 228
 229   return ref;
 230 }
 231
 232 static ULONG WINAPI IDirectMusicPerformance8Impl_Release(IDirectMusicPerformance8 *iface)
 233 {
 234   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 235   ULONG ref = InterlockedDecrement(&This->ref);
 236
 237   TRACE("(%p): ReleaseRef to %d\n", This, ref);
 238
 239   if (ref == 0) {
 240     This->safe.DebugInfo->Spare[0] = 0;
 241     DeleteCriticalSection(&This->safe);
 242     HeapFree(GetProcessHeap(), 0, This);
 243   }
 244
 245   DMIME_UnlockModule();
 246
 247   return ref;
 248 }
 249
 250 /* IDirectMusicPerformanceImpl IDirectMusicPerformance Interface part: */
 251 static HRESULT WINAPI IDirectMusicPerformance8Impl_Init(IDirectMusicPerformance8 *iface,
 252         IDirectMusic **ppDirectMusic, IDirectSound *pDirectSound, HWND hWnd)
 253 {
 254         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 255
 256         FIXME("(iface = %p, dmusic = %p, dsound = %p, hwnd = %p)\n", This, ppDirectMusic, pDirectSound, hWnd);
 257         if (This->pDirectMusic || This->pDirectSound)
 258           return DMUS_E_ALREADY_INITED;
 259
 260         if (NULL == hWnd) {
 261           hWnd = GetForegroundWindow();
 262         }
 263
 264         if (NULL != pDirectSound) {
 265           This->pDirectSound = pDirectSound;
 266           IDirectSound_AddRef(This->pDirectSound);
 267         } else {
 268           DirectSoundCreate8(NULL, (LPDIRECTSOUND8*) &This->pDirectSound, NULL);
 269           if (!This->pDirectSound) return DSERR_NODRIVER;
 270
 271           if (NULL != hWnd) {
 272             IDirectSound8_SetCooperativeLevel(This->pDirectSound, hWnd, DSSCL_PRIORITY);
 273           } else {
 274             /* how to get the ForeGround window handle ? */
 275             /*IDirectSound8_SetCooperativeLevel(This->pDirectSound, hWnd, DSSCL_PRIORITY);*/
 276           }
 277         }
 278
 279         if (NULL != ppDirectMusic && NULL != *ppDirectMusic) {
 280           /* app creates its own dmusic object and gives it to performance */
 281           This->pDirectMusic = (IDirectMusic8*) *ppDirectMusic;
 282           IDirectMusic8_AddRef(This->pDirectMusic);
 283         } else {
 284         HRESULT hr;
 285         /* App enables the performance to initialize itself and needs a pointer to object */
 286         hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic8, (void**)&This->pDirectMusic);
 287         if (FAILED(hr))
 288             return hr;
 289         if (ppDirectMusic) {
 290             *ppDirectMusic = (LPDIRECTMUSIC)This->pDirectMusic;
 291             IDirectMusic8_AddRef((LPDIRECTMUSIC8)*ppDirectMusic);
 292         }
 293     }
 294
 295     return S_OK;
 296 }
 297
 298 static HRESULT WINAPI IDirectMusicPerformance8Impl_PlaySegment(IDirectMusicPerformance8 *iface,
 299         IDirectMusicSegment *pSegment, DWORD dwFlags, __int64 i64StartTime,
 300         IDirectMusicSegmentState **ppSegmentState)
 301 {
 302         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 303
 304         FIXME("(%p, %p, %d, 0x%s, %p): stub\n", This, pSegment, dwFlags,
 305             wine_dbgstr_longlong(i64StartTime), ppSegmentState);
 306         if (ppSegmentState)
 307           return create_dmsegmentstate(&IID_IDirectMusicSegmentState,(void**)ppSegmentState);
 308         return S_OK;
 309 }
 310
 311 static HRESULT WINAPI IDirectMusicPerformance8Impl_Stop(IDirectMusicPerformance8 *iface,
 312         IDirectMusicSegment *pSegment, IDirectMusicSegmentState *pSegmentState, MUSIC_TIME mtTime,
 313         DWORD dwFlags)
 314 {
 315         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 316
 317         FIXME("(%p, %p, %p, %d, %d): stub\n", This, pSegment, pSegmentState, mtTime, dwFlags);
 318         return S_OK;
 319 }
 320
 321 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetSegmentState(IDirectMusicPerformance8 *iface,
 322         IDirectMusicSegmentState **ppSegmentState, MUSIC_TIME mtTime)
 323 {
 324         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 325
 326         FIXME("(%p,%p, %d): stub\n", This, ppSegmentState, mtTime);
 327         return S_OK;
 328 }
 329
 330 static HRESULT WINAPI IDirectMusicPerformance8Impl_SetPrepareTime(IDirectMusicPerformance8 *iface,
 331         DWORD dwMilliSeconds)
 332 {
 333   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 334
 335   TRACE("(%p, %d)\n", This, dwMilliSeconds);
 336   This->dwPrepareTime = dwMilliSeconds;
 337   return S_OK;
 338 }
 339
 340 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetPrepareTime(IDirectMusicPerformance8 *iface,
 341         DWORD *pdwMilliSeconds)
 342 {
 343   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 344
 345   TRACE("(%p, %p)\n", This, pdwMilliSeconds);
 346   if (NULL == pdwMilliSeconds) {
 347     return E_POINTER;
 348   }
 349   *pdwMilliSeconds = This->dwPrepareTime;
 350   return S_OK;
 351 }
 352
 353 static HRESULT WINAPI IDirectMusicPerformance8Impl_SetBumperLength(IDirectMusicPerformance8 *iface,
 354         DWORD dwMilliSeconds)
 355 {
 356   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 357
 358   TRACE("(%p, %d)\n", This, dwMilliSeconds);
 359   This->dwBumperLength =  dwMilliSeconds;
 360   return S_OK;
 361 }
 362
 363 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetBumperLength(IDirectMusicPerformance8 *iface,
 364         DWORD *pdwMilliSeconds)
 365 {
 366   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 367
 368   TRACE("(%p, %p)\n", This, pdwMilliSeconds);
 369   if (NULL == pdwMilliSeconds) {
 370     return E_POINTER;
 371   }
 372   *pdwMilliSeconds = This->dwBumperLength;
 373   return S_OK;
 374 }
 375
 376 static HRESULT WINAPI IDirectMusicPerformance8Impl_SendPMsg(IDirectMusicPerformance8 *iface,
 377         DMUS_PMSG *pPMSG)
 378 {
 379   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 380   DMUS_PMSGItem* pItem = NULL;
 381   DMUS_PMSGItem* it = NULL;
 382   DMUS_PMSGItem* prev_it = NULL;
 383   DMUS_PMSGItem** queue = NULL;
 384
 385   FIXME("(%p, %p): stub\n", This, pPMSG);
 386
 387   if (NULL == pPMSG) {
 388     return E_POINTER;
 389   }
 390   pItem = DMUS_PMSGToItem(pPMSG);
 391   if (pItem->bInUse) {
 392     return DMUS_E_ALREADY_SENT;
 393   }
 394
 395   /* TODO: Valid Flags */
 396   /* TODO: DMUS_PMSGF_MUSICTIME */
 397   pItem->rtItemTime = pPMSG->rtTime;
 398
 399   if (pPMSG->dwFlags & DMUS_PMSGF_TOOL_IMMEDIATE) {
 400     queue = &This->imm_head;
 401   } else {
 402     queue = &This->head;
 403   }
 404
 405   EnterCriticalSection(&This->safe);
 406   for (it = *queue; NULL != it && it->rtItemTime < pItem->rtItemTime; it = it->next) {
 407     prev_it = it;
 408   }
 409   if (NULL == prev_it) {
 410     pItem->prev = NULL;
 411     if (NULL != *queue) pItem->next = (*queue)->next;
 412     /*assert( NULL == pItem->next->prev );*/
 413     if (NULL != pItem->next) pItem->next->prev = pItem;
 414     *queue = pItem;
 415   } else {
 416     pItem->prev = prev_it;
 417     pItem->next = prev_it->next;
 418     prev_it->next = pItem;
 419     if (NULL != pItem->next) pItem->next->prev = pItem;
 420   }
 421   LeaveCriticalSection(&This->safe);
 422
 423   /** now in use, prevent from stupid Frees */
 424   pItem->bInUse = TRUE;
 425   return S_OK;
 426 }
 427
 428 static HRESULT WINAPI IDirectMusicPerformance8Impl_MusicToReferenceTime(IDirectMusicPerformance8 *iface,
 429         MUSIC_TIME mtTime, REFERENCE_TIME *prtTime)
 430 {
 431         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 432
 433         FIXME("(%p, %d, %p): stub\n", This, mtTime, prtTime);
 434         return S_OK;
 435 }
 436
 437 static HRESULT WINAPI IDirectMusicPerformance8Impl_ReferenceToMusicTime(IDirectMusicPerformance8 *iface,
 438         REFERENCE_TIME rtTime, MUSIC_TIME *pmtTime)
 439 {
 440         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 441
 442         FIXME("(%p, 0x%s, %p): stub\n", This, wine_dbgstr_longlong(rtTime), pmtTime);
 443         return S_OK;
 444 }
 445
 446 static HRESULT WINAPI IDirectMusicPerformance8Impl_IsPlaying(IDirectMusicPerformance8 *iface,
 447         IDirectMusicSegment *pSegment, IDirectMusicSegmentState *pSegState)
 448 {
 449         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 450
 451         FIXME("(%p, %p, %p): stub\n", This, pSegment, pSegState);
 452         return S_FALSE;
 453 }
 454
 455 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetTime(IDirectMusicPerformance8 *iface,
 456         REFERENCE_TIME *prtNow, MUSIC_TIME *pmtNow)
 457 {
 458   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 459   HRESULT hr = S_OK;
 460   REFERENCE_TIME rtCur = 0;
 461
 462   /*TRACE("(%p, %p, %p)\n", This, prtNow, pmtNow); */
 463   if (This->procThreadTicStarted) {
 464     rtCur = ((REFERENCE_TIME) GetTickCount() * 10000) - This->procThreadStartTime;
 465   } else {
 466     /*return DMUS_E_NO_MASTER_CLOCK;*/
 467   }
 468   if (NULL != prtNow) {
 469     *prtNow = rtCur;
 470   }
 471   if (NULL != pmtNow) {
 472     hr = IDirectMusicPerformance8_ReferenceToMusicTime(iface, rtCur, pmtNow);
 473   }
 474   return hr;
 475 }
 476
 477 static HRESULT WINAPI IDirectMusicPerformance8Impl_AllocPMsg(IDirectMusicPerformance8 *iface,
 478         ULONG cb, DMUS_PMSG **ppPMSG)
 479 {
 480   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 481   DMUS_PMSGItem* pItem = NULL;
 482
 483   FIXME("(%p, %d, %p): stub\n", This, cb, ppPMSG);
 484
 485   if (sizeof(DMUS_PMSG) > cb) {
 486     return E_INVALIDARG;
 487   }
 488   if (NULL == ppPMSG) {
 489     return E_POINTER;
 490   }
 491   pItem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cb - sizeof(DMUS_PMSG)  + sizeof(DMUS_PMSGItem));
 492   if (NULL == pItem) {
 493     return E_OUTOFMEMORY;
 494   }
 495   pItem->pMsg.dwSize = cb;
 496   *ppPMSG = DMUS_ItemToPMSG(pItem);
 497   return S_OK;
 498 }
 499
 500 static HRESULT WINAPI IDirectMusicPerformance8Impl_FreePMsg(IDirectMusicPerformance8 *iface,
 501         DMUS_PMSG *pPMSG)
 502 {
 503   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 504   DMUS_PMSGItem* pItem = NULL;
 505
 506   FIXME("(%p, %p): stub\n", This, pPMSG);
 507
 508   if (NULL == pPMSG) {
 509     return E_POINTER;
 510   }
 511   pItem = DMUS_PMSGToItem(pPMSG);
 512   if (pItem->bInUse) {
 513     /** prevent for freeing PMsg in queue (ie to be processed) */
 514     return DMUS_E_CANNOT_FREE;
 515   }
 516   /** now we can remove it safely */
 517   EnterCriticalSection(&This->safe);
 518   DMUS_ItemRemoveFromQueue( This, pItem );
 519   LeaveCriticalSection(&This->safe);
 520
 521   /** TODO: see if we should Release the pItem->pMsg->punkUser and others Interfaces */
 522   HeapFree(GetProcessHeap(), 0, pItem);
 523   return S_OK;
 524 }
 525
 526 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetGraph(IDirectMusicPerformance8 *iface,
 527         IDirectMusicGraph **ppGraph)
 528 {
 529   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 530
 531   FIXME("(%p, %p): to check\n", This, ppGraph);
 532   if (NULL != This->pToolGraph) {
 533     *ppGraph = This->pToolGraph;
 534     IDirectMusicGraph_AddRef(*ppGraph);
 535   } else {
 536     return E_FAIL;
 537   }
 538   return S_OK;
 539 }
 540
 541 static HRESULT WINAPI IDirectMusicPerformance8Impl_SetGraph(IDirectMusicPerformance8 *iface,
 542         IDirectMusicGraph *pGraph)
 543 {
 544   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 545
 546   FIXME("(%p, %p): to check\n", This, pGraph);
 547
 548   if (NULL != This->pToolGraph) {
 549     /* Todo clean buffers and tools before */
 550     IDirectMusicGraph_Release(This->pToolGraph);
 551   }
 552   This->pToolGraph = pGraph;
 553   if (NULL != This->pToolGraph) {
 554     IDirectMusicGraph_AddRef(This->pToolGraph);
 555   }
 556   return S_OK;
 557 }
 558
 559 static HRESULT WINAPI IDirectMusicPerformance8Impl_SetNotificationHandle(IDirectMusicPerformance8 *iface,
 560         HANDLE hNotification, REFERENCE_TIME rtMinimum)
 561 {
 562   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 563
 564   FIXME("(%p, %p, 0x%s): stub\n", This, hNotification, wine_dbgstr_longlong(rtMinimum));
 565   This->hNotification = hNotification;
 566   if (rtMinimum) This->rtMinimum = rtMinimum;
 567   return S_OK;
 568 }
 569
 570 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetNotificationPMsg(IDirectMusicPerformance8 *iface,
 571         DMUS_NOTIFICATION_PMSG **ppNotificationPMsg)
 572 {
 573   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 574
 575   FIXME("(%p, %p): stub\n", This, ppNotificationPMsg);
 576   if (NULL == ppNotificationPMsg) {
 577     return E_POINTER;
 578   }
 579
 580
 581
 582   return S_FALSE;
 583   /*return S_OK;*/
 584 }
 585
 586 static HRESULT WINAPI IDirectMusicPerformance8Impl_AddNotificationType(IDirectMusicPerformance8 *iface,
 587         REFGUID rguidNotificationType)
 588 {
 589         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 590
 591         FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 592         return S_OK;
 593 }
 594
 595 static HRESULT WINAPI IDirectMusicPerformance8Impl_RemoveNotificationType(IDirectMusicPerformance8 *iface,
 596         REFGUID rguidNotificationType)
 597 {
 598         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 599
 600         FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 601         return S_OK;
 602 }
 603
 604 static HRESULT WINAPI IDirectMusicPerformance8Impl_AddPort(IDirectMusicPerformance8 *iface,
 605         IDirectMusicPort *pPort)
 606 {
 607         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 608         HRESULT hr = E_FAIL;
 609
 610         FIXME("(%p, %p): stub\n", This, pPort);
 611         if (!This->pDirectMusic || !This->pDirectSound) return DMUS_E_NOT_INIT;
 612         if (NULL == pPort) {
 613           GUID port_guid;
 614           IDirectMusicPort* pDefaultPort = NULL;
 615           DMUS_PORTPARAMS params;
 616           int i, j;
 617           hr = IDirectMusic8_GetDefaultPort(This->pDirectMusic, &port_guid);
 618           if (FAILED(hr)) return hr;
 619           ZeroMemory(&params, sizeof(params));
 620           params.dwSize = sizeof(params);
 621           params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS | DMUS_PORTPARAMS_SHARE;
 622           params.dwChannelGroups = 1;
 623           params.fShare = TRUE;
 624           hr = IDirectMusic8_CreatePort(This->pDirectMusic, &port_guid, &params, &pDefaultPort, NULL);
 625           if (FAILED(hr)) return hr;
 626           hr = IDirectMusicPort_Activate(pDefaultPort, TRUE);
 627           if (FAILED(hr)) { IDirectMusicPort_Release(pDefaultPort); return hr; }
 628           j = 0;
 629           for (i = 0; i < 16; ++i) {
 630             if (NULL == This->PChannel[i].port) {
 631               This->PChannel[i].port = pPort;
 632               This->PChannel[i].group = 0;
 633               This->PChannel[i].channel = j; /* FIXME: should this be assigned? */
 634               j++;
 635             }
 636           }
 637         } else {
 638           IDirectMusicPort_AddRef(pPort);
 639         }
 640         /**
 641          * We should remember added Ports (for example using a list)
 642          * and control if Port is registered for each api who use ports
 643          */
 644         return S_OK;
 645 }
 646
 647 static HRESULT WINAPI IDirectMusicPerformance8Impl_RemovePort(IDirectMusicPerformance8 *iface,
 648         IDirectMusicPort *pPort)
 649 {
 650         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 651
 652         FIXME("(%p, %p): stub\n", This, pPort);
 653         IDirectMusicPort_Release (pPort);
 654         return S_OK;
 655 }
 656
 657 static HRESULT WINAPI IDirectMusicPerformance8Impl_AssignPChannelBlock(IDirectMusicPerformance8 *iface,
 658         DWORD dwBlockNum, IDirectMusicPort *pPort, DWORD dwGroup)
 659 {
 660         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 661         int i, j, range /* min value in range */;
 662
 663         FIXME("(%p, %d, %p, %d): semi-stub\n", This, dwBlockNum, pPort, dwGroup-1);
 664         if (NULL == pPort) return E_POINTER;
 665
 666         range = 16 * dwBlockNum;
 667         j = 0;
 668         for (i = range; i < range+16; i++) {
 669                 /*TRACE("Setting PChannel[%i] to port %p, group %ld, MIDI port %i\n", i, pPort, dwGroup-1, j); */
 670                 This->PChannel[i].port = pPort;
 671                 This->PChannel[i].group = dwGroup - 1; /* first index is always zero */
 672                 This->PChannel[i].channel = j; /* FIXME: should this be assigned? */
 673                 j++;
 674         }
 675         /*if (dwGroup > 2) return S_FALSE;*/
 676
 677         return S_OK;
 678 }
 679
 680 static HRESULT WINAPI IDirectMusicPerformance8Impl_AssignPChannel(IDirectMusicPerformance8 *iface,
 681         DWORD PChannel, IDirectMusicPort *port, DWORD group, DWORD MChannel)
 682 {
 683     IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 684
 685     TRACE("(%p)->(%d, %p, %d, %d)\n", This, PChannel, port, group, MChannel);
 686
 687     if (!port)
 688         return E_POINTER;
 689
 690     This->PChannel[PChannel].port = port;
 691     This->PChannel[PChannel].group = group;
 692     This->PChannel[PChannel].channel = MChannel;
 693
 694     return S_OK;
 695 }
 696
 697 static HRESULT WINAPI IDirectMusicPerformance8Impl_PChannelInfo(IDirectMusicPerformance8 *iface,
 698         DWORD PChannel, IDirectMusicPort **port, DWORD *group, DWORD *MChannel)
 699 {
 700     IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 701     DMUS_PORTPARAMS8 port_params;
 702     GUID default_port;
 703
 704     FIXME("(%p)->(%d, %p, %p, %p): stub\n", This, PChannel, port, group, MChannel);
 705
 706     port_params.dwSize = sizeof(DMUS_PORTPARAMS8);
 707     port_params.dwValidParams = 0;
 708     IDirectMusic8_GetDefaultPort(This->pDirectMusic, &default_port);
 709     IDirectMusic8_CreatePort(This->pDirectMusic, &default_port, &port_params, port, NULL);
 710
 711     return S_OK;
 712 }
 713
 714 static HRESULT WINAPI IDirectMusicPerformance8Impl_DownloadInstrument(IDirectMusicPerformance8 *iface,
 715         IDirectMusicInstrument *pInst, DWORD dwPChannel,
 716         IDirectMusicDownloadedInstrument **ppDownInst, DMUS_NOTERANGE *pNoteRanges,
 717         DWORD dwNumNoteRanges, IDirectMusicPort **ppPort, DWORD *pdwGroup, DWORD *pdwMChannel)
 718 {
 719         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 720
 721         FIXME("(%p, %p, %d, %p, %p, %d, %p, %p, %p): stub\n", This, pInst, dwPChannel, ppDownInst, pNoteRanges, dwNumNoteRanges, ppPort, pdwGroup, pdwMChannel);
 722         return S_OK;
 723 }
 724
 725 static HRESULT WINAPI IDirectMusicPerformance8Impl_Invalidate(IDirectMusicPerformance8 *iface,
 726         MUSIC_TIME mtTime, DWORD dwFlags)
 727 {
 728         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 729
 730         FIXME("(%p, %d, %d): stub\n", This, mtTime, dwFlags);
 731         return S_OK;
 732 }
 733
 734 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetParam(IDirectMusicPerformance8 *iface,
 735         REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime,
 736         MUSIC_TIME *pmtNext, void *pParam)
 737 {
 738         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 739
 740         FIXME("(%p, %s, %d, %d, %d, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
 741         return S_OK;
 742 }
 743
 744 static HRESULT WINAPI IDirectMusicPerformance8Impl_SetParam(IDirectMusicPerformance8 *iface,
 745         REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, void *pParam)
 746 {
 747         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 748
 749         FIXME("(%p, %s, %d, %d, %d, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
 750         return S_OK;
 751 }
 752
 753 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetGlobalParam(IDirectMusicPerformance8 *iface,
 754         REFGUID rguidType, void *pParam, DWORD dwSize)
 755 {
 756         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 757
 758         TRACE("(%p, %s, %p, %d): stub\n", This, debugstr_dmguid(rguidType), pParam, dwSize);
 759
 760         if (IsEqualGUID (rguidType, &GUID_PerfAutoDownload))
 761                 memcpy(pParam, &This->fAutoDownload, sizeof(This->fAutoDownload));
 762         if (IsEqualGUID (rguidType, &GUID_PerfMasterGrooveLevel))
 763                 memcpy(pParam, &This->cMasterGrooveLevel, sizeof(This->cMasterGrooveLevel));
 764         if (IsEqualGUID (rguidType, &GUID_PerfMasterTempo))
 765                 memcpy(pParam, &This->fMasterTempo, sizeof(This->fMasterTempo));
 766         if (IsEqualGUID (rguidType, &GUID_PerfMasterVolume))
 767                 memcpy(pParam, &This->lMasterVolume, sizeof(This->lMasterVolume));
 768
 769         return S_OK;
 770 }
 771
 772 static HRESULT WINAPI IDirectMusicPerformance8Impl_SetGlobalParam(IDirectMusicPerformance8 *iface,
 773         REFGUID rguidType, void *pParam, DWORD dwSize)
 774 {
 775         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 776
 777         TRACE("(%p, %s, %p, %d)\n", This, debugstr_dmguid(rguidType), pParam, dwSize);
 778
 779         if (IsEqualGUID (rguidType, &GUID_PerfAutoDownload)) {
 780                 memcpy(&This->fAutoDownload, pParam, dwSize);
 781                 TRACE("=> AutoDownload set to %d\n", This->fAutoDownload);
 782         }
 783         if (IsEqualGUID (rguidType, &GUID_PerfMasterGrooveLevel)) {
 784                 memcpy(&This->cMasterGrooveLevel, pParam, dwSize);
 785                 TRACE("=> MasterGrooveLevel set to %i\n", This->cMasterGrooveLevel);
 786         }
 787         if (IsEqualGUID (rguidType, &GUID_PerfMasterTempo)) {
 788                 memcpy(&This->fMasterTempo, pParam, dwSize);
 789                 TRACE("=> MasterTempo set to %f\n", This->fMasterTempo);
 790         }
 791         if (IsEqualGUID (rguidType, &GUID_PerfMasterVolume)) {
 792                 memcpy(&This->lMasterVolume, pParam, dwSize);
 793                 TRACE("=> MasterVolume set to %li\n", This->lMasterVolume);
 794         }
 795
 796         return S_OK;
 797 }
 798
 799 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetLatencyTime(IDirectMusicPerformance8 *iface,
 800         REFERENCE_TIME *prtTime)
 801 {
 802         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 803
 804         TRACE("(%p, %p): stub\n", This, prtTime);
 805         *prtTime = This->rtLatencyTime;
 806         return S_OK;
 807 }
 808
 809 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetQueueTime(IDirectMusicPerformance8 *iface,
 810         REFERENCE_TIME *prtTime)
 811
 812 {
 813         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 814
 815         FIXME("(%p, %p): stub\n", This, prtTime);
 816         return S_OK;
 817 }
 818
 819 static HRESULT WINAPI IDirectMusicPerformance8Impl_AdjustTime(IDirectMusicPerformance8 *iface,
 820         REFERENCE_TIME rtAmount)
 821 {
 822         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 823
 824         FIXME("(%p, 0x%s): stub\n", This, wine_dbgstr_longlong(rtAmount));
 825         return S_OK;
 826 }
 827
 828 static HRESULT WINAPI IDirectMusicPerformance8Impl_CloseDown(IDirectMusicPerformance8 *iface)
 829 {
 830   IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 831
 832   FIXME("(%p): stub\n", This);
 833   if (PostMessageToProcessMsgThread(This, PROCESSMSG_EXIT)) {
 834     WaitForSingleObject(This->procThread, INFINITE);
 835     This->procThreadTicStarted = FALSE;
 836     CloseHandle(This->procThread);
 837   }
 838   if (NULL != This->pDirectSound) {
 839     IDirectSound_Release(This->pDirectSound);
 840     This->pDirectSound = NULL;
 841   }
 842   if (NULL != This->pDirectMusic) {
 843     IDirectMusic8_Release(This->pDirectMusic);
 844     This->pDirectMusic = NULL;
 845   }
 846   return S_OK;
 847 }
 848
 849 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetResolvedTime(IDirectMusicPerformance8 *iface,
 850         REFERENCE_TIME rtTime, REFERENCE_TIME *prtResolved, DWORD dwTimeResolveFlags)
 851 {
 852         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 853
 854         FIXME("(%p, 0x%s, %p, %d): stub\n", This, wine_dbgstr_longlong(rtTime),
 855             prtResolved, dwTimeResolveFlags);
 856         return S_OK;
 857 }
 858
 859 static HRESULT WINAPI IDirectMusicPerformance8Impl_MIDIToMusic(IDirectMusicPerformance8 *iface,
 860         BYTE bMIDIValue, DMUS_CHORD_KEY *pChord, BYTE bPlayMode, BYTE bChordLevel,
 861         WORD *pwMusicValue)
 862 {
 863         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 864
 865         FIXME("(%p, %d, %p, %d, %d, %p): stub\n", This, bMIDIValue, pChord, bPlayMode, bChordLevel, pwMusicValue);
 866         return S_OK;
 867 }
 868
 869 static HRESULT WINAPI IDirectMusicPerformance8Impl_MusicToMIDI(IDirectMusicPerformance8 *iface,
 870         WORD wMusicValue, DMUS_CHORD_KEY *pChord, BYTE bPlayMode, BYTE bChordLevel,
 871         BYTE *pbMIDIValue)
 872 {
 873         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 874
 875         FIXME("(%p, %d, %p, %d, %d, %p): stub\n", This, wMusicValue, pChord, bPlayMode, bChordLevel, pbMIDIValue);
 876         return S_OK;
 877 }
 878
 879 static HRESULT WINAPI IDirectMusicPerformance8Impl_TimeToRhythm(IDirectMusicPerformance8 *iface,
 880         MUSIC_TIME mtTime, DMUS_TIMESIGNATURE *pTimeSig, WORD *pwMeasure, BYTE *pbBeat,
 881         BYTE *pbGrid, short *pnOffset)
 882 {
 883         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 884
 885         FIXME("(%p, %d, %p, %p, %p, %p, %p): stub\n", This, mtTime, pTimeSig, pwMeasure, pbBeat, pbGrid, pnOffset);
 886         return S_OK;
 887 }
 888
 889 static HRESULT WINAPI IDirectMusicPerformance8Impl_RhythmToTime(IDirectMusicPerformance8 *iface,
 890         WORD wMeasure, BYTE bBeat, BYTE bGrid, short nOffset, DMUS_TIMESIGNATURE *pTimeSig,
 891         MUSIC_TIME *pmtTime)
 892 {
 893         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 894
 895         FIXME("(%p, %d, %d, %d, %i, %p, %p): stub\n", This, wMeasure, bBeat, bGrid, nOffset, pTimeSig, pmtTime);
 896         return S_OK;
 897 }
 898
 899 /* IDirectMusicPerformance8 Interface part follow: */
 900 static HRESULT WINAPI IDirectMusicPerformance8Impl_InitAudio(IDirectMusicPerformance8 *iface,
 901         IDirectMusic **ppDirectMusic, IDirectSound **ppDirectSound, HWND hWnd,
 902         DWORD dwDefaultPathType, DWORD dwPChannelCount, DWORD dwFlags, DMUS_AUDIOPARAMS* pParams)
 903 {
 904         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 905         IDirectSound* dsound = NULL;
 906         HRESULT hr = S_OK;
 907
 908         FIXME("(%p, %p, %p, %p, %x, %u, %x, %p): to check\n", This, ppDirectMusic, ppDirectSound, hWnd, dwDefaultPathType, dwPChannelCount, dwFlags, pParams);
 909
 910         if (This->pDirectMusic || This->pDirectSound)
 911           return DMUS_E_ALREADY_INITED;
 912
 913         if (NULL != ppDirectSound && NULL != *ppDirectSound) {
 914           dsound = *ppDirectSound;
 915         } else {
 916           hr = DirectSoundCreate8 (NULL, (LPDIRECTSOUND8*) &dsound, NULL);
 917           FIXME("return dsound(%p,%d)\n", dsound, hr);
 918           if (FAILED(hr) || !dsound)
 919             return DSERR_NODRIVER;
 920           if (ppDirectSound)
 921             *ppDirectSound = dsound;
 922         }
 923
 924         IDirectMusicPerformance8Impl_Init(iface, ppDirectMusic, dsound, hWnd);
 925
 926         /* Init increases the ref count of the dsound object. Decrement it if the app doesn't want a pointer to the object. */
 927         if (NULL == ppDirectSound) {
 928           IDirectSound_Release(This->pDirectSound);
 929         }
 930
 931         /* as seen in msdn we need params init before audio path creation */
 932         if (NULL != pParams) {
 933           This->pParams = *pParams;
 934         } else {
 935           /* TODO, how can i fill the struct as seen on msdn */
 936           memset(&This->pParams, 0, sizeof(DMUS_AUDIOPARAMS));
 937           This->pParams.dwSize = sizeof(DMUS_AUDIOPARAMS);
 938           This->pParams.fInitNow = FALSE;
 939           This->pParams.dwValidData = DMUS_AUDIOPARAMS_FEATURES | DMUS_AUDIOPARAMS_VOICES | DMUS_AUDIOPARAMS_SAMPLERATE | DMUS_AUDIOPARAMS_DEFAULTSYNTH;
 940           This->pParams.dwVoices = 64;
 941           This->pParams.dwSampleRate = (DWORD) 22.050;
 942           This->pParams.dwFeatures = dwFlags;
 943           This->pParams.clsidDefaultSynth = CLSID_DirectMusicSynthSink;
 944         }
 945         if(dwDefaultPathType != 0)
 946                 hr = IDirectMusicPerformance8_CreateStandardAudioPath(iface, dwDefaultPathType, dwPChannelCount, FALSE, &This->pDefaultPath);
 947
 948         PostMessageToProcessMsgThread(This, PROCESSMSG_START);
 949
 950         return hr;
 951 }
 952
 953 static HRESULT WINAPI IDirectMusicPerformance8Impl_PlaySegmentEx(IDirectMusicPerformance8 *iface,
 954         IUnknown *pSource, WCHAR *pwzSegmentName, IUnknown *pTransition, DWORD dwFlags,
 955         __int64 i64StartTime, IDirectMusicSegmentState **ppSegmentState, IUnknown *pFrom,
 956         IUnknown *pAudioPath)
 957 {
 958         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 959
 960         FIXME("(%p, %p, %p, %p, %d, 0x%s, %p, %p, %p): stub\n", This, pSource, pwzSegmentName,
 961             pTransition, dwFlags, wine_dbgstr_longlong(i64StartTime), ppSegmentState, pFrom, pAudioPath);
 962         if (ppSegmentState)
 963           return create_dmsegmentstate(&IID_IDirectMusicSegmentState,(void**)ppSegmentState);
 964         return S_OK;
 965 }
 966
 967 static HRESULT WINAPI IDirectMusicPerformance8Impl_StopEx(IDirectMusicPerformance8 *iface,
 968         IUnknown *pObjectToStop, __int64 i64StopTime, DWORD dwFlags)
 969 {
 970         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 971
 972         FIXME("(%p, %p, 0x%s, %d): stub\n", This, pObjectToStop,
 973             wine_dbgstr_longlong(i64StopTime), dwFlags);
 974         return S_OK;
 975 }
 976
 977 static HRESULT WINAPI IDirectMusicPerformance8Impl_ClonePMsg(IDirectMusicPerformance8 *iface,
 978         DMUS_PMSG *pSourcePMSG, DMUS_PMSG **ppCopyPMSG)
 979 {
 980         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 981
 982         FIXME("(%p, %p, %p): stub\n", This, pSourcePMSG, ppCopyPMSG);
 983         return S_OK;
 984 }
 985
 986 static HRESULT WINAPI IDirectMusicPerformance8Impl_CreateAudioPath(IDirectMusicPerformance8 *iface,
 987         IUnknown *pSourceConfig, BOOL fActivate, IDirectMusicAudioPath **ppNewPath)
 988 {
 989         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
 990         IDirectMusicAudioPathImpl *default_path;
 991         IDirectMusicAudioPath *pPath;
 992
 993         FIXME("(%p, %p, %d, %p): stub\n", This, pSourceConfig, fActivate, ppNewPath);
 994
 995         if (NULL == ppNewPath) {
 996           return E_POINTER;
 997         }
 998
 999         create_dmaudiopath(&IID_IDirectMusicAudioPath, (void**)&pPath);
1000         default_path = (IDirectMusicAudioPathImpl*)((char*)(pPath) - offsetof(IDirectMusicAudioPathImpl,AudioPathVtbl));
1001         default_path->pPerf = &This->IDirectMusicPerformance8_iface;
1002
1003         /** TODO */
1004
1005         *ppNewPath = pPath;
1006
1007         return IDirectMusicAudioPath_Activate(*ppNewPath, fActivate);
1008 }
1009
1010 static HRESULT WINAPI IDirectMusicPerformance8Impl_CreateStandardAudioPath(IDirectMusicPerformance8 *iface,
1011         DWORD dwType, DWORD dwPChannelCount, BOOL fActivate, IDirectMusicAudioPath **ppNewPath)
1012 {
1013         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
1014         IDirectMusicAudioPathImpl *default_path;
1015         IDirectMusicAudioPath *pPath;
1016         DSBUFFERDESC desc;
1017         WAVEFORMATEX format;
1018         LPDIRECTSOUNDBUFFER buffer;
1019         HRESULT hr = S_OK;
1020
1021         FIXME("(%p)->(%d, %d, %d, %p): semi-stub\n", This, dwType, dwPChannelCount, fActivate, ppNewPath);
1022
1023         if (NULL == ppNewPath) {
1024           return E_POINTER;
1025         }
1026
1027         create_dmaudiopath(&IID_IDirectMusicAudioPath, (void**)&pPath);
1028         default_path = (IDirectMusicAudioPathImpl*)((char*)(pPath) - offsetof(IDirectMusicAudioPathImpl,AudioPathVtbl));
1029         default_path->pPerf = &This->IDirectMusicPerformance8_iface;
1030
1031         /* Secondary buffer description */
1032         memset(&format, 0, sizeof(format));
1033         format.wFormatTag = WAVE_FORMAT_PCM;
1034         format.nChannels = 1;
1035         format.nSamplesPerSec = 44000;
1036         format.nAvgBytesPerSec = 44000*2;
1037         format.nBlockAlign = 2;
1038         format.wBitsPerSample = 16;
1039         format.cbSize = 0;
1040
1041         memset(&desc, 0, sizeof(desc));
1042         desc.dwSize = sizeof(desc);
1043         desc.dwFlags = DSBCAPS_CTRLFX | DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME | DSBCAPS_GLOBALFOCUS;
1044         desc.dwBufferBytes = DSBSIZE_MIN;
1045         desc.dwReserved = 0;
1046         desc.lpwfxFormat = &format;
1047         desc.guid3DAlgorithm = GUID_NULL;
1048
1049         switch(dwType) {
1050         case DMUS_APATH_DYNAMIC_3D:
1051                 desc.dwFlags |= DSBCAPS_CTRL3D | DSBCAPS_CTRLFREQUENCY | DSBCAPS_MUTE3DATMAXDISTANCE;
1052                 break;
1053         case DMUS_APATH_DYNAMIC_MONO:
1054                 desc.dwFlags |= DSBCAPS_CTRLFREQUENCY;
1055                 break;
1056         case DMUS_APATH_SHARED_STEREOPLUSREVERB:
1057                 /* normally we have to create 2 buffers (one for music other for reverb)
1058                  * in this case. See msdn
1059                  */
1060         case DMUS_APATH_DYNAMIC_STEREO:
1061                 desc.dwFlags |= DSBCAPS_CTRLFREQUENCY;
1062                 format.nChannels = 2;
1063                 format.nBlockAlign *= 2;
1064                 format.nAvgBytesPerSec *=2;
1065                 break;
1066         default:
1067                 HeapFree(GetProcessHeap(), 0, default_path);
1068                 *ppNewPath = NULL;
1069                 return E_INVALIDARG;
1070         }
1071
1072         /* FIXME: Should we create one secondary buffer for each PChannel? */
1073         hr = IDirectSound8_CreateSoundBuffer ((LPDIRECTSOUND8) This->pDirectSound, &desc, &buffer, NULL);
1074         if (FAILED(hr)) {
1075                 HeapFree(GetProcessHeap(), 0, default_path);
1076                 *ppNewPath = NULL;
1077                 return DSERR_BUFFERLOST;
1078         }
1079         default_path->pDSBuffer = buffer;
1080
1081         /* Update description for creating primary buffer */
1082         desc.dwFlags |= DSBCAPS_PRIMARYBUFFER;
1083         desc.dwBufferBytes = 0;
1084         desc.lpwfxFormat = NULL;
1085
1086         hr = IDirectSound8_CreateSoundBuffer ((LPDIRECTSOUND8) This->pDirectSound, &desc, &buffer, NULL);
1087         if (FAILED(hr)) {
1088                 IDirectSoundBuffer_Release(default_path->pDSBuffer);
1089                 HeapFree(GetProcessHeap(), 0, default_path);
1090                 *ppNewPath = NULL;
1091                 return DSERR_BUFFERLOST;
1092         }
1093         default_path->pPrimary = buffer;
1094
1095         *ppNewPath = pPath;
1096
1097         TRACE(" returning IDirectMusicAudioPath interface at %p.\n", *ppNewPath);
1098
1099         return IDirectMusicAudioPath_Activate(*ppNewPath, fActivate);
1100 }
1101
1102 static HRESULT WINAPI IDirectMusicPerformance8Impl_SetDefaultAudioPath(IDirectMusicPerformance8 *iface,
1103         IDirectMusicAudioPath *pAudioPath)
1104 {
1105         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
1106
1107         FIXME("(%p, %p): semi-stub\n", This, pAudioPath);
1108         if (NULL != This->pDefaultPath) {
1109                 IDirectMusicAudioPath_Release(This->pDefaultPath);
1110                 ((IDirectMusicAudioPathImpl*) This->pDefaultPath)->pPerf = NULL;
1111                 This->pDefaultPath = NULL;
1112         }
1113         This->pDefaultPath = pAudioPath;
1114         if (NULL != This->pDefaultPath) {
1115                 IDirectMusicAudioPath_AddRef(This->pDefaultPath);
1116                 ((IDirectMusicAudioPathImpl*)This->pDefaultPath)->pPerf = &This->IDirectMusicPerformance8_iface;
1117         }
1118
1119         return S_OK;
1120 }
1121
1122 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetDefaultAudioPath(IDirectMusicPerformance8 *iface,
1123         IDirectMusicAudioPath **ppAudioPath)
1124 {
1125         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
1126
1127         FIXME("(%p, %p): semi-stub (%p)\n", This, ppAudioPath, This->pDefaultPath);
1128
1129         if (NULL != This->pDefaultPath) {
1130           *ppAudioPath = This->pDefaultPath;
1131           IDirectMusicAudioPath_AddRef(*ppAudioPath);
1132         } else {
1133           *ppAudioPath = NULL;
1134         }
1135         return S_OK;
1136 }
1137
1138 static HRESULT WINAPI IDirectMusicPerformance8Impl_GetParamEx(IDirectMusicPerformance8 *iface,
1139         REFGUID rguidType, DWORD dwTrackID, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime,
1140         MUSIC_TIME *pmtNext, void *pParam)
1141 {
1142         IDirectMusicPerformance8Impl *This = impl_from_IDirectMusicPerformance8(iface);
1143
1144         FIXME("(%p, %s, %d, %d, %d, %d, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwTrackID, dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
1145
1146         return S_OK;
1147 }
1148
1149 static const IDirectMusicPerformance8Vtbl DirectMusicPerformance8_Vtbl = {
1150         IDirectMusicPerformance8Impl_QueryInterface,
1151         IDirectMusicPerformance8Impl_AddRef,
1152         IDirectMusicPerformance8Impl_Release,
1153         IDirectMusicPerformance8Impl_Init,
1154         IDirectMusicPerformance8Impl_PlaySegment,
1155         IDirectMusicPerformance8Impl_Stop,
1156         IDirectMusicPerformance8Impl_GetSegmentState,
1157         IDirectMusicPerformance8Impl_SetPrepareTime,
1158         IDirectMusicPerformance8Impl_GetPrepareTime,
1159         IDirectMusicPerformance8Impl_SetBumperLength,
1160         IDirectMusicPerformance8Impl_GetBumperLength,
1161         IDirectMusicPerformance8Impl_SendPMsg,
1162         IDirectMusicPerformance8Impl_MusicToReferenceTime,
1163         IDirectMusicPerformance8Impl_ReferenceToMusicTime,
1164         IDirectMusicPerformance8Impl_IsPlaying,
1165         IDirectMusicPerformance8Impl_GetTime,
1166         IDirectMusicPerformance8Impl_AllocPMsg,
1167         IDirectMusicPerformance8Impl_FreePMsg,
1168         IDirectMusicPerformance8Impl_GetGraph,
1169         IDirectMusicPerformance8Impl_SetGraph,
1170         IDirectMusicPerformance8Impl_SetNotificationHandle,
1171         IDirectMusicPerformance8Impl_GetNotificationPMsg,
1172         IDirectMusicPerformance8Impl_AddNotificationType,
1173         IDirectMusicPerformance8Impl_RemoveNotificationType,
1174         IDirectMusicPerformance8Impl_AddPort,
1175         IDirectMusicPerformance8Impl_RemovePort,
1176         IDirectMusicPerformance8Impl_AssignPChannelBlock,
1177         IDirectMusicPerformance8Impl_AssignPChannel,
1178         IDirectMusicPerformance8Impl_PChannelInfo,
1179         IDirectMusicPerformance8Impl_DownloadInstrument,
1180         IDirectMusicPerformance8Impl_Invalidate,
1181         IDirectMusicPerformance8Impl_GetParam,
1182         IDirectMusicPerformance8Impl_SetParam,
1183         IDirectMusicPerformance8Impl_GetGlobalParam,
1184         IDirectMusicPerformance8Impl_SetGlobalParam,
1185         IDirectMusicPerformance8Impl_GetLatencyTime,
1186         IDirectMusicPerformance8Impl_GetQueueTime,
1187         IDirectMusicPerformance8Impl_AdjustTime,
1188         IDirectMusicPerformance8Impl_CloseDown,
1189         IDirectMusicPerformance8Impl_GetResolvedTime,
1190         IDirectMusicPerformance8Impl_MIDIToMusic,
1191         IDirectMusicPerformance8Impl_MusicToMIDI,
1192         IDirectMusicPerformance8Impl_TimeToRhythm,
1193         IDirectMusicPerformance8Impl_RhythmToTime,
1194         IDirectMusicPerformance8Impl_InitAudio,
1195         IDirectMusicPerformance8Impl_PlaySegmentEx,
1196         IDirectMusicPerformance8Impl_StopEx,
1197         IDirectMusicPerformance8Impl_ClonePMsg,
1198         IDirectMusicPerformance8Impl_CreateAudioPath,
1199         IDirectMusicPerformance8Impl_CreateStandardAudioPath,
1200         IDirectMusicPerformance8Impl_SetDefaultAudioPath,
1201         IDirectMusicPerformance8Impl_GetDefaultAudioPath,
1202         IDirectMusicPerformance8Impl_GetParamEx
1203 };
1204
1205 /* for ClassFactory */
1206 HRESULT WINAPI create_dmperformance(REFIID lpcGUID, void **ppobj)
1207 {
1208         IDirectMusicPerformance8Impl *obj;
1209
1210         TRACE("(%p,%p)\n", lpcGUID, ppobj);
1211
1212         obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicPerformance8Impl));
1213         if (NULL == obj) {
1214                 *ppobj = NULL;
1215                 return E_OUTOFMEMORY;
1216         }
1217         obj->IDirectMusicPerformance8_iface.lpVtbl = &DirectMusicPerformance8_Vtbl;
1218         obj->ref = 0;  /* will be inited by QueryInterface */
1219         obj->pDirectMusic = NULL;
1220         obj->pDirectSound = NULL;
1221         obj->pDefaultPath = NULL;
1222         InitializeCriticalSection(&obj->safe);
1223         obj->safe.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IDirectMusicPerformance8Impl*->safe");
1224
1225         obj->rtLatencyTime  = 100;  /* 100 ms TO FIX */
1226         obj->dwBumperLength =   50; /* 50 ms default */
1227         obj->dwPrepareTime  = 1000; /* 1000 ms default */
1228         return IDirectMusicPerformance8Impl_QueryInterface(&obj->IDirectMusicPerformance8_iface,
1229                                                            lpcGUID, ppobj);
1230 }