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 #include "dmusic_midi.h"
  23 #include "wine/rbtree.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(dmime);
  26
  27 enum dmus_internal_message_type
  28 {
  29     DMUS_PMSGT_INTERNAL_FIRST = 0x10,
  30     DMUS_PMSGT_INTERNAL_SEGMENT_END = DMUS_PMSGT_INTERNAL_FIRST,
  31     DMUS_PMSGT_INTERNAL_SEGMENT_TICK,
  32 };
  33
  34 struct pchannel_block {
  35     DWORD block_num;   /* Block 0 is PChannels 0-15, Block 1 is PChannels 16-31, etc */
  36     struct {
  37        DWORD channel;  /* MIDI channel */
  38        DWORD group;    /* MIDI group */
  39        IDirectMusicPort *port;
  40     } pchannel[16];
  41     struct wine_rb_entry entry;
  42 };
  43
  44 struct performance
  45 {
  46     IDirectMusicPerformance8 IDirectMusicPerformance8_iface;
  47     IDirectMusicGraph IDirectMusicGraph_iface;
  48     IDirectMusicTool IDirectMusicTool_iface;
  49     LONG ref;
  50     IDirectMusic *dmusic;
  51     IDirectSound *dsound;
  52     IDirectMusicGraph *pToolGraph;
  53     BOOL fAutoDownload;
  54     char cMasterGrooveLevel;
  55     float fMasterTempo;
  56     long lMasterVolume;
  57     /* performance channels */
  58     struct wine_rb_tree pchannels;
  59
  60     BOOL audio_paths_enabled;
  61     IDirectMusicAudioPath *pDefaultPath;
  62     REFERENCE_TIME latency_offset;
  63     DWORD dwBumperLength;
  64     DWORD dwPrepareTime;
  65
  66     HANDLE message_thread;
  67     CRITICAL_SECTION safe;
  68     CONDITION_VARIABLE cond;
  69
  70     IReferenceClock *master_clock;
  71     REFERENCE_TIME init_time;
  72     struct list messages;
  73
  74     struct list notifications;
  75     REFERENCE_TIME notification_timeout;
  76     HANDLE notification_event;
  77     BOOL notification_performance;
  78     BOOL notification_segment;
  79
  80     IDirectMusicSegment *primary_segment;
  81 };
  82
  83 struct message
  84 {
  85     struct list entry;
  86     DMUS_PMSG msg;
  87 };
  88
  89 static inline struct message *message_from_DMUS_PMSG(DMUS_PMSG *msg)
  90 {
  91     return msg ? CONTAINING_RECORD(msg, struct message, msg) : NULL;
  92 }
  93
  94 static void performance_queue_message(struct performance *This, struct message *message, struct list *hint)
  95 {
  96     struct message *prev;
  97
  98     LIST_FOR_EACH_ENTRY_REV(prev, hint ? hint : &This->messages, struct message, entry)
  99     {
 100         if (&prev->entry == &This->messages) break;
 101         if (prev->msg.rtTime <= message->msg.rtTime) break;
 102     }
 103
 104     list_add_after(&prev->entry, &message->entry);
 105 }
 106
 107 static HRESULT performance_process_message(struct performance *This, DMUS_PMSG *msg, DWORD *timeout)
 108 {
 109     static const DWORD delivery_flags = DMUS_PMSGF_TOOL_IMMEDIATE | DMUS_PMSGF_TOOL_QUEUE | DMUS_PMSGF_TOOL_ATTIME;
 110     IDirectMusicPerformance *performance = (IDirectMusicPerformance *)&This->IDirectMusicPerformance8_iface;
 111     HRESULT hr;
 112
 113     do
 114     {
 115         REFERENCE_TIME latency, offset = 0;
 116         IDirectMusicTool *tool;
 117
 118         if (FAILED(hr = IDirectMusicPerformance_GetLatencyTime(performance, &latency))) return hr;
 119         if (!(tool = msg->pTool)) tool = &This->IDirectMusicTool_iface;
 120
 121         switch (msg->dwFlags & delivery_flags)
 122         {
 123         default:
 124             WARN("No delivery flag found for message %p\n", msg);
 125             /* fallthrough */
 126         case DMUS_PMSGF_TOOL_IMMEDIATE:
 127             hr = IDirectMusicTool_ProcessPMsg(tool, performance, msg);
 128             break;
 129         case DMUS_PMSGF_TOOL_QUEUE:
 130             offset = This->dwBumperLength * 10000;
 131             /* fallthrough */
 132         case DMUS_PMSGF_TOOL_ATTIME:
 133             if (msg->rtTime >= offset && msg->rtTime - offset >= latency)
 134             {
 135                 if (timeout) *timeout = (msg->rtTime - offset - latency) / 10000;
 136                 return DMUS_S_REQUEUE;
 137             }
 138
 139             hr = IDirectMusicTool_ProcessPMsg(tool, performance, msg);
 140             break;
 141         }
 142     } while (hr == DMUS_S_REQUEUE);
 143
 144     if (hr == DMUS_S_FREE) hr = IDirectMusicPerformance_FreePMsg(performance, msg);
 145     if (FAILED(hr)) WARN("Failed to process message, hr %#lx\n", hr);
 146     return hr;
 147 }
 148
 149 static DWORD WINAPI message_thread_proc(void *args)
 150 {
 151     struct performance *This = args;
 152     HRESULT hr = DMUS_S_REQUEUE;
 153     struct list *ptr;
 154
 155     TRACE("performance %p message thread\n", This);
 156     SetThreadDescription(GetCurrentThread(), L"wine_dmime_message");
 157
 158     EnterCriticalSection(&This->safe);
 159
 160     while (This->message_thread)
 161     {
 162         DWORD timeout = INFINITE;
 163
 164         while ((ptr = list_head(&This->messages)))
 165         {
 166             struct message *message = LIST_ENTRY(ptr, struct message, entry);
 167             struct list *next = ptr->next;
 168             list_remove(&message->entry);
 169             list_init(&message->entry);
 170
 171             hr = performance_process_message(This, &message->msg, &timeout);
 172             if (hr == DMUS_S_REQUEUE) performance_queue_message(This, message, next);
 173             if (hr != S_OK) break;
 174         }
 175
 176         SleepConditionVariableCS(&This->cond, &This->safe, timeout);
 177     }
 178
 179     LeaveCriticalSection(&This->safe);
 180
 181     TRACE("(%p): Exiting\n", This);
 182     return 0;
 183 }
 184
 185 static HRESULT performance_send_pmsg(struct performance *This, MUSIC_TIME music_time, DWORD flags,
 186         DWORD type, IUnknown *object)
 187 {
 188     IDirectMusicPerformance8 *performance = &This->IDirectMusicPerformance8_iface;
 189     IDirectMusicGraph *graph = &This->IDirectMusicGraph_iface;
 190     DMUS_PMSG *msg;
 191     HRESULT hr;
 192
 193     if (FAILED(hr = IDirectMusicPerformance8_AllocPMsg(performance, sizeof(*msg), &msg)))
 194         return hr;
 195
 196     msg->mtTime = music_time;
 197     msg->dwFlags = DMUS_PMSGF_MUSICTIME | flags;
 198     msg->dwType = type;
 199     if ((msg->punkUser = object)) IUnknown_AddRef(object);
 200
 201     if ((type < DMUS_PMSGT_INTERNAL_FIRST && FAILED(hr = IDirectMusicGraph_StampPMsg(graph, msg)))
 202             || FAILED(hr = IDirectMusicPerformance8_SendPMsg(performance, msg)))
 203         IDirectMusicPerformance8_FreePMsg(performance, msg);
 204
 205     return hr;
 206 }
 207
 208 static HRESULT performance_send_notification_pmsg(struct performance *This, MUSIC_TIME music_time, BOOL stamp,
 209         GUID type, DWORD option, IUnknown *object)
 210 {
 211     IDirectMusicPerformance8 *performance = &This->IDirectMusicPerformance8_iface;
 212     IDirectMusicGraph *graph = &This->IDirectMusicGraph_iface;
 213     DMUS_NOTIFICATION_PMSG *msg;
 214     HRESULT hr;
 215
 216     if (FAILED(hr = IDirectMusicPerformance8_AllocPMsg(performance, sizeof(*msg), (DMUS_PMSG **)&msg)))
 217         return hr;
 218
 219     msg->mtTime = music_time;
 220     msg->dwFlags = DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE;
 221     msg->dwType = DMUS_PMSGT_NOTIFICATION;
 222     if ((msg->punkUser = object)) IUnknown_AddRef(object);
 223     msg->guidNotificationType = type;
 224     msg->dwNotificationOption = option;
 225
 226     /* only stamp the message if notifications are enabled, otherwise send them directly to the output tool */
 227     if ((stamp && FAILED(hr = IDirectMusicGraph_StampPMsg(graph, (DMUS_PMSG *)msg)))
 228             || FAILED(hr = IDirectMusicPerformance8_SendPMsg(performance, (DMUS_PMSG *)msg)))
 229         IDirectMusicPerformance8_FreePMsg(performance, (DMUS_PMSG *)msg);
 230
 231     return hr;
 232 }
 233
 234 static int pchannel_block_compare(const void *key, const struct wine_rb_entry *entry)
 235 {
 236     const struct pchannel_block *b = WINE_RB_ENTRY_VALUE(entry, const struct pchannel_block, entry);
 237
 238     return *(DWORD *)key - b->block_num;
 239 }
 240
 241 static void pchannel_block_free(struct wine_rb_entry *entry, void *context)
 242 {
 243     struct pchannel_block *b = WINE_RB_ENTRY_VALUE(entry, struct pchannel_block, entry);
 244
 245     free(b);
 246 }
 247
 248 static struct pchannel_block *pchannel_block_set(struct wine_rb_tree *tree, DWORD block_num,
 249         IDirectMusicPort *port, DWORD group, BOOL only_set_new)
 250 {
 251     struct pchannel_block *block;
 252     struct wine_rb_entry *entry;
 253     unsigned int i;
 254
 255     entry = wine_rb_get(tree, &block_num);
 256     if (entry) {
 257         block = WINE_RB_ENTRY_VALUE(entry, struct pchannel_block, entry);
 258         if (only_set_new)
 259             return block;
 260     } else {
 261         if (!(block = malloc(sizeof(*block)))) return NULL;
 262         block->block_num = block_num;
 263     }
 264
 265     for (i = 0; i < 16; ++i) {
 266         block->pchannel[i].port = port;
 267         block->pchannel[i].group = group;
 268         block->pchannel[i].channel = i;
 269     }
 270     if (!entry)
 271         wine_rb_put(tree, &block->block_num, &block->entry);
 272
 273     return block;
 274 }
 275
 276 static inline struct performance *impl_from_IDirectMusicPerformance8(IDirectMusicPerformance8 *iface)
 277 {
 278     return CONTAINING_RECORD(iface, struct performance, IDirectMusicPerformance8_iface);
 279 }
 280
 281 HRESULT performance_send_segment_start(IDirectMusicPerformance8 *iface, MUSIC_TIME music_time,
 282         IDirectMusicSegmentState *state)
 283 {
 284     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 285     HRESULT hr;
 286
 287     if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_performance,
 288             GUID_NOTIFICATION_PERFORMANCE, DMUS_NOTIFICATION_MUSICSTARTED, NULL)))
 289         return hr;
 290     if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_segment,
 291             GUID_NOTIFICATION_SEGMENT, DMUS_NOTIFICATION_SEGSTART, (IUnknown *)state)))
 292         return hr;
 293     if (FAILED(hr = performance_send_pmsg(This, music_time, DMUS_PMSGF_TOOL_IMMEDIATE,
 294             DMUS_PMSGT_DIRTY, NULL)))
 295         return hr;
 296
 297     return S_OK;
 298 }
 299
 300 HRESULT performance_send_segment_tick(IDirectMusicPerformance8 *iface, MUSIC_TIME music_time,
 301         IDirectMusicSegmentState *state)
 302 {
 303     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 304     REFERENCE_TIME time;
 305     HRESULT hr;
 306
 307     if (FAILED(hr = IDirectMusicPerformance8_MusicToReferenceTime(iface, music_time, &time)))
 308         return hr;
 309     if (FAILED(hr = IDirectMusicPerformance8_ReferenceToMusicTime(iface, time + 2000000, &music_time)))
 310         return hr;
 311     if (FAILED(hr = performance_send_pmsg(This, music_time, DMUS_PMSGF_TOOL_QUEUE,
 312             DMUS_PMSGT_INTERNAL_SEGMENT_TICK, (IUnknown *)state)))
 313         return hr;
 314
 315     return S_OK;
 316 }
 317
 318 HRESULT performance_send_segment_end(IDirectMusicPerformance8 *iface, MUSIC_TIME music_time,
 319         IDirectMusicSegmentState *state)
 320 {
 321     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 322     HRESULT hr;
 323
 324     if (FAILED(hr = performance_send_notification_pmsg(This, music_time - 1450, This->notification_segment,
 325             GUID_NOTIFICATION_SEGMENT, DMUS_NOTIFICATION_SEGALMOSTEND, (IUnknown *)state)))
 326         return hr;
 327     if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_segment,
 328             GUID_NOTIFICATION_SEGMENT, DMUS_NOTIFICATION_SEGEND, (IUnknown *)state)))
 329         return hr;
 330     if (FAILED(hr = performance_send_pmsg(This, music_time, DMUS_PMSGF_TOOL_IMMEDIATE,
 331             DMUS_PMSGT_DIRTY, NULL)))
 332         return hr;
 333     if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_performance,
 334             GUID_NOTIFICATION_PERFORMANCE, DMUS_NOTIFICATION_MUSICSTOPPED, NULL)))
 335         return hr;
 336     if (FAILED(hr = performance_send_pmsg(This, music_time, DMUS_PMSGF_TOOL_ATTIME,
 337             DMUS_PMSGT_INTERNAL_SEGMENT_END, (IUnknown *)state)))
 338         return hr;
 339
 340     return S_OK;
 341 }
 342
 343 static void performance_set_primary_segment(struct performance *This, IDirectMusicSegment *segment)
 344 {
 345     if (This->primary_segment) IDirectMusicSegment_Release(This->primary_segment);
 346     if ((This->primary_segment = segment)) IDirectMusicSegment_AddRef(This->primary_segment);
 347 }
 348
 349 /* IDirectMusicPerformance8 IUnknown part: */
 350 static HRESULT WINAPI performance_QueryInterface(IDirectMusicPerformance8 *iface, REFIID riid, void **ret_iface)
 351 {
 352     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 353
 354     TRACE("(%p, %s, %p)\n", iface, debugstr_dmguid(riid), ret_iface);
 355
 356     if (IsEqualGUID(riid, &IID_IUnknown)
 357             || IsEqualGUID(riid, &IID_IDirectMusicPerformance)
 358             || IsEqualGUID(riid, &IID_IDirectMusicPerformance2)
 359             || IsEqualGUID(riid, &IID_IDirectMusicPerformance8))
 360     {
 361         *ret_iface = iface;
 362         IUnknown_AddRef(iface);
 363         return S_OK;
 364     }
 365
 366     if (IsEqualGUID(riid, &IID_IDirectMusicGraph))
 367     {
 368         *ret_iface = &This->IDirectMusicGraph_iface;
 369         IDirectMusicGraph_AddRef(&This->IDirectMusicGraph_iface);
 370         return S_OK;
 371     }
 372
 373     if (IsEqualGUID(riid, &IID_IDirectMusicTool))
 374     {
 375         *ret_iface = &This->IDirectMusicTool_iface;
 376         IDirectMusicTool_AddRef(&This->IDirectMusicTool_iface);
 377         return S_OK;
 378     }
 379
 380     *ret_iface = NULL;
 381     WARN("(%p, %s, %p): not found\n", iface, debugstr_dmguid(riid), ret_iface);
 382     return E_NOINTERFACE;
 383 }
 384
 385 static ULONG WINAPI performance_AddRef(IDirectMusicPerformance8 *iface)
 386 {
 387   struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 388   ULONG ref = InterlockedIncrement(&This->ref);
 389
 390   TRACE("(%p): ref=%ld\n", This, ref);
 391
 392   return ref;
 393 }
 394
 395 static ULONG WINAPI performance_Release(IDirectMusicPerformance8 *iface)
 396 {
 397   struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 398   ULONG ref = InterlockedDecrement(&This->ref);
 399
 400   TRACE("(%p): ref=%ld\n", This, ref);
 401
 402   if (ref == 0) {
 403     wine_rb_destroy(&This->pchannels, pchannel_block_free, NULL);
 404     This->safe.DebugInfo->Spare[0] = 0;
 405     DeleteCriticalSection(&This->safe);
 406     free(This);
 407   }
 408
 409   return ref;
 410 }
 411
 412 static HRESULT performance_init_dsound(struct performance *This, HWND hwnd)
 413 {
 414     IDirectSound *dsound;
 415     HRESULT hr;
 416
 417     if (FAILED(hr = DirectSoundCreate(NULL, &dsound, NULL))) return hr;
 418
 419     if (!hwnd) hwnd = GetForegroundWindow();
 420     hr = IDirectSound_SetCooperativeLevel(dsound, hwnd, DSSCL_PRIORITY);
 421
 422     if (SUCCEEDED(hr)) This->dsound = dsound;
 423     else IDirectSound_Release(dsound);
 424
 425     return hr;
 426 }
 427
 428 static HRESULT performance_init_dmusic(struct performance *This, IDirectSound *dsound)
 429 {
 430     IDirectMusic *dmusic;
 431     HRESULT hr;
 432
 433     if (FAILED(hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER,
 434             &IID_IDirectMusic8, (void **)&dmusic)))
 435         return hr;
 436
 437     hr = IDirectMusic_SetDirectSound(dmusic, dsound, NULL);
 438
 439     if (SUCCEEDED(hr)) This->dmusic = dmusic;
 440     else IDirectSound_Release(dmusic);
 441
 442     return hr;
 443 }
 444
 445 static HRESULT WINAPI performance_Init(IDirectMusicPerformance8 *iface, IDirectMusic **dmusic,
 446         IDirectSound *dsound, HWND hwnd)
 447 {
 448     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 449     HRESULT hr;
 450
 451     TRACE("(%p, %p, %p, %p)\n", iface, dmusic, dsound, hwnd);
 452
 453     if (This->dmusic) return DMUS_E_ALREADY_INITED;
 454
 455     if ((This->dsound = dsound)) IDirectMusic8_AddRef(This->dsound);
 456     else if (FAILED(hr = performance_init_dsound(This, hwnd))) return hr;
 457
 458     if (dmusic && (This->dmusic = *dmusic)) IDirectMusic_AddRef(This->dmusic);
 459     else if (FAILED(hr = performance_init_dmusic(This, This->dsound)))
 460     {
 461         IDirectMusicPerformance_CloseDown(iface);
 462         return hr;
 463     }
 464
 465     if (FAILED(hr = IDirectMusic_GetMasterClock(This->dmusic, NULL, &This->master_clock))
 466             || FAILED(hr = IDirectMusicPerformance8_GetTime(iface, &This->init_time, NULL)))
 467     {
 468         IDirectMusicPerformance_CloseDown(iface);
 469         return hr;
 470     }
 471
 472     if (!(This->message_thread = CreateThread(NULL, 0, message_thread_proc, This, 0, NULL)))
 473     {
 474         ERR("Failed to start performance message thread, error %lu\n", GetLastError());
 475         IDirectMusicPerformance_CloseDown(iface);
 476         return HRESULT_FROM_WIN32(GetLastError());
 477     }
 478
 479     if (dmusic && !*dmusic)
 480     {
 481         *dmusic = This->dmusic;
 482         IDirectMusic_AddRef(*dmusic);
 483     }
 484     return S_OK;
 485 }
 486
 487 static HRESULT WINAPI performance_PlaySegment(IDirectMusicPerformance8 *iface, IDirectMusicSegment *segment,
 488         DWORD segment_flags, INT64 start_time, IDirectMusicSegmentState **ret_state)
 489 {
 490     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 491
 492     TRACE("(%p, %p, %ld, %I64d, %p)\n", This, segment, segment_flags, start_time, ret_state);
 493
 494     return IDirectMusicPerformance8_PlaySegmentEx(iface, (IUnknown *)segment, NULL, NULL,
 495             segment_flags, start_time, ret_state, NULL, NULL);
 496 }
 497
 498 struct state_entry
 499 {
 500     struct list entry;
 501     IDirectMusicSegmentState *state;
 502 };
 503
 504 static void state_entry_destroy(struct state_entry *entry)
 505 {
 506     list_remove(&entry->entry);
 507     IDirectMusicSegmentState_Release(entry->state);
 508     free(entry);
 509 }
 510
 511 static void enum_segment_states(struct performance *This, IDirectMusicSegment *segment, struct list *list)
 512 {
 513     struct state_entry *entry;
 514     struct message *message;
 515
 516     LIST_FOR_EACH_ENTRY(message, &This->messages, struct message, entry)
 517     {
 518         IDirectMusicSegmentState *message_state;
 519
 520         if (message->msg.dwType != DMUS_PMSGT_INTERNAL_SEGMENT_TICK
 521                 && message->msg.dwType != DMUS_PMSGT_INTERNAL_SEGMENT_END)
 522             continue;
 523
 524         message_state = (IDirectMusicSegmentState *)message->msg.punkUser;
 525         if (segment && !segment_state_has_segment(message_state, segment)) continue;
 526
 527         if (!(entry = malloc(sizeof(*entry)))) return;
 528         entry->state = message_state;
 529         IDirectMusicSegmentState_AddRef(entry->state);
 530         list_add_tail(list, &entry->entry);
 531     }
 532 }
 533
 534 static HRESULT WINAPI performance_Stop(IDirectMusicPerformance8 *iface, IDirectMusicSegment *pSegment,
 535         IDirectMusicSegmentState *pSegmentState, MUSIC_TIME mtTime, DWORD dwFlags)
 536 {
 537         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 538
 539         FIXME("(%p, %p, %p, %ld, %ld): stub\n", This, pSegment, pSegmentState, mtTime, dwFlags);
 540         return S_OK;
 541 }
 542
 543 static HRESULT WINAPI performance_GetSegmentState(IDirectMusicPerformance8 *iface,
 544         IDirectMusicSegmentState **state, MUSIC_TIME time)
 545 {
 546     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 547     struct list *ptr, states = LIST_INIT(states);
 548     struct state_entry *entry, *next;
 549     HRESULT hr = S_OK;
 550
 551     TRACE("(%p, %p, %ld)\n", This, state, time);
 552
 553     if (!state) return E_POINTER;
 554
 555     EnterCriticalSection(&This->safe);
 556
 557     enum_segment_states(This, This->primary_segment, &states);
 558
 559     if (!(ptr = list_head(&states))) hr = DMUS_E_NOT_FOUND;
 560     else
 561     {
 562         entry = LIST_ENTRY(ptr, struct state_entry, entry);
 563
 564         *state = entry->state;
 565         IDirectMusicSegmentState_AddRef(entry->state);
 566
 567         LIST_FOR_EACH_ENTRY_SAFE(entry, next, &states, struct state_entry, entry)
 568             state_entry_destroy(entry);
 569     }
 570
 571     LeaveCriticalSection(&This->safe);
 572
 573     return hr;
 574 }
 575
 576 static HRESULT WINAPI performance_SetPrepareTime(IDirectMusicPerformance8 *iface, DWORD dwMilliSeconds)
 577 {
 578   struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 579
 580   TRACE("(%p, %ld)\n", This, dwMilliSeconds);
 581   This->dwPrepareTime = dwMilliSeconds;
 582   return S_OK;
 583 }
 584
 585 static HRESULT WINAPI performance_GetPrepareTime(IDirectMusicPerformance8 *iface, DWORD *pdwMilliSeconds)
 586 {
 587   struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 588
 589   TRACE("(%p, %p)\n", This, pdwMilliSeconds);
 590   if (NULL == pdwMilliSeconds) {
 591     return E_POINTER;
 592   }
 593   *pdwMilliSeconds = This->dwPrepareTime;
 594   return S_OK;
 595 }
 596
 597 static HRESULT WINAPI performance_SetBumperLength(IDirectMusicPerformance8 *iface, DWORD dwMilliSeconds)
 598 {
 599   struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 600
 601   TRACE("(%p, %ld)\n", This, dwMilliSeconds);
 602   This->dwBumperLength =  dwMilliSeconds;
 603   return S_OK;
 604 }
 605
 606 static HRESULT WINAPI performance_GetBumperLength(IDirectMusicPerformance8 *iface, DWORD *pdwMilliSeconds)
 607 {
 608   struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 609
 610   TRACE("(%p, %p)\n", This, pdwMilliSeconds);
 611   if (NULL == pdwMilliSeconds) {
 612     return E_POINTER;
 613   }
 614   *pdwMilliSeconds = This->dwBumperLength;
 615   return S_OK;
 616 }
 617
 618 static HRESULT WINAPI performance_SendPMsg(IDirectMusicPerformance8 *iface, DMUS_PMSG *msg)
 619 {
 620     const DWORD delivery_flags = DMUS_PMSGF_TOOL_IMMEDIATE | DMUS_PMSGF_TOOL_QUEUE | DMUS_PMSGF_TOOL_ATTIME;
 621     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 622     struct message *message;
 623     HRESULT hr;
 624
 625     TRACE("(%p, %p)\n", This, msg);
 626
 627     if (!(message = message_from_DMUS_PMSG(msg))) return E_POINTER;
 628     if (!This->dmusic) return DMUS_E_NO_MASTER_CLOCK;
 629     if (!(msg->dwFlags & (DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_REFTIME))) return E_INVALIDARG;
 630
 631     EnterCriticalSection(&This->safe);
 632
 633     if (!list_empty(&message->entry))
 634         hr = DMUS_E_ALREADY_SENT;
 635     else
 636     {
 637         if (!(msg->dwFlags & delivery_flags)) msg->dwFlags |= DMUS_PMSGF_TOOL_IMMEDIATE;
 638         if (!(msg->dwFlags & DMUS_PMSGF_MUSICTIME))
 639         {
 640             if (FAILED(hr = IDirectMusicPerformance8_ReferenceToMusicTime(iface,
 641                     msg->rtTime, &msg->mtTime)))
 642                 goto done;
 643             msg->dwFlags |= DMUS_PMSGF_MUSICTIME;
 644         }
 645         if (!(msg->dwFlags & DMUS_PMSGF_REFTIME))
 646         {
 647             if (FAILED(hr = IDirectMusicPerformance8_MusicToReferenceTime(iface,
 648                     msg->mtTime == -1 ? 0 : msg->mtTime, &msg->rtTime)))
 649                 goto done;
 650             msg->dwFlags |= DMUS_PMSGF_REFTIME;
 651         }
 652
 653         if (msg->dwFlags & DMUS_PMSGF_TOOL_IMMEDIATE)
 654         {
 655             hr = performance_process_message(This, &message->msg, NULL);
 656             if (hr != DMUS_S_REQUEUE) goto done;
 657         }
 658
 659         performance_queue_message(This, message, NULL);
 660         hr = S_OK;
 661     }
 662
 663 done:
 664     LeaveCriticalSection(&This->safe);
 665     if (SUCCEEDED(hr)) WakeConditionVariable(&This->cond);
 666
 667     return hr;
 668 }
 669
 670 static HRESULT WINAPI performance_MusicToReferenceTime(IDirectMusicPerformance8 *iface,
 671         MUSIC_TIME music_time, REFERENCE_TIME *time)
 672 {
 673     static int once;
 674     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 675
 676     if (!once++) FIXME("(%p, %ld, %p): semi-stub\n", This, music_time, time);
 677     else TRACE("(%p, %ld, %p)\n", This, music_time, time);
 678
 679     if (!time) return E_POINTER;
 680     *time = 0;
 681
 682     if (!This->master_clock) return DMUS_E_NO_MASTER_CLOCK;
 683
 684     /* FIXME: This should be (music_time * 60) / (DMUS_PPQ * tempo)
 685      * but it gives innacurate results */
 686     *time = This->init_time + (music_time * 6510);
 687
 688     return S_OK;
 689 }
 690
 691 static HRESULT WINAPI performance_ReferenceToMusicTime(IDirectMusicPerformance8 *iface,
 692         REFERENCE_TIME time, MUSIC_TIME *music_time)
 693 {
 694     static int once;
 695     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 696
 697     if (!once++) FIXME("(%p, %I64d, %p): semi-stub\n", This, time, music_time);
 698     else TRACE("(%p, %I64d, %p)\n", This, time, music_time);
 699
 700     if (!music_time) return E_POINTER;
 701     *music_time = 0;
 702
 703     if (!This->master_clock) return DMUS_E_NO_MASTER_CLOCK;
 704
 705     /* FIXME: This should be (time * DMUS_PPQ * tempo) / 60
 706      * but it gives innacurate results */
 707     *music_time = (time - This->init_time) / 6510;
 708
 709     return S_OK;
 710 }
 711
 712 static HRESULT WINAPI performance_IsPlaying(IDirectMusicPerformance8 *iface,
 713         IDirectMusicSegment *pSegment, IDirectMusicSegmentState *pSegState)
 714 {
 715         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 716
 717         FIXME("(%p, %p, %p): stub\n", This, pSegment, pSegState);
 718         return S_FALSE;
 719 }
 720
 721 static HRESULT WINAPI performance_GetTime(IDirectMusicPerformance8 *iface, REFERENCE_TIME *time, MUSIC_TIME *music_time)
 722 {
 723     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 724     REFERENCE_TIME now;
 725     HRESULT hr;
 726
 727     TRACE("(%p, %p, %p)\n", iface, time, music_time);
 728
 729     if (!This->master_clock) return DMUS_E_NO_MASTER_CLOCK;
 730     if (FAILED(hr = IReferenceClock_GetTime(This->master_clock, &now))) return hr;
 731
 732     if (time) *time = now;
 733     if (music_time) hr = IDirectMusicPerformance8_ReferenceToMusicTime(iface, now, music_time);
 734
 735     return hr;
 736 }
 737
 738 static HRESULT WINAPI performance_AllocPMsg(IDirectMusicPerformance8 *iface, ULONG size, DMUS_PMSG **msg)
 739 {
 740     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 741     struct message *message;
 742
 743     TRACE("(%p, %ld, %p)\n", This, size, msg);
 744
 745     if (!msg) return E_POINTER;
 746     if (size < sizeof(DMUS_PMSG)) return E_INVALIDARG;
 747
 748     if (!(message = calloc(1, size - sizeof(DMUS_PMSG) + sizeof(struct message)))) return E_OUTOFMEMORY;
 749     message->msg.dwSize = size;
 750     list_init(&message->entry);
 751     *msg = &message->msg;
 752
 753     return S_OK;
 754 }
 755
 756 static HRESULT WINAPI performance_FreePMsg(IDirectMusicPerformance8 *iface, DMUS_PMSG *msg)
 757 {
 758     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 759     struct message *message;
 760     HRESULT hr;
 761
 762     TRACE("(%p, %p)\n", This, msg);
 763
 764     if (!(message = message_from_DMUS_PMSG(msg))) return E_POINTER;
 765
 766     EnterCriticalSection(&This->safe);
 767     hr = !list_empty(&message->entry) ? DMUS_E_CANNOT_FREE : S_OK;
 768     LeaveCriticalSection(&This->safe);
 769
 770     if (SUCCEEDED(hr))
 771     {
 772         if (msg->pTool) IDirectMusicTool_Release(msg->pTool);
 773         if (msg->pGraph) IDirectMusicGraph_Release(msg->pGraph);
 774         if (msg->punkUser) IUnknown_Release(msg->punkUser);
 775         free(message);
 776     }
 777
 778     return hr;
 779 }
 780
 781 static HRESULT WINAPI performance_GetGraph(IDirectMusicPerformance8 *iface, IDirectMusicGraph **graph)
 782 {
 783     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 784
 785     TRACE("(%p, %p)\n", This, graph);
 786
 787     if (!graph)
 788         return E_POINTER;
 789
 790     *graph = This->pToolGraph;
 791     if (This->pToolGraph) {
 792         IDirectMusicGraph_AddRef(*graph);
 793     }
 794
 795     return *graph ? S_OK : DMUS_E_NOT_FOUND;
 796 }
 797
 798 static HRESULT WINAPI performance_SetGraph(IDirectMusicPerformance8 *iface, IDirectMusicGraph *pGraph)
 799 {
 800   struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 801
 802   FIXME("(%p, %p): to check\n", This, pGraph);
 803
 804   if (NULL != This->pToolGraph) {
 805     /* Todo clean buffers and tools before */
 806     IDirectMusicGraph_Release(This->pToolGraph);
 807   }
 808   This->pToolGraph = pGraph;
 809   if (NULL != This->pToolGraph) {
 810     IDirectMusicGraph_AddRef(This->pToolGraph);
 811   }
 812   return S_OK;
 813 }
 814
 815 static HRESULT WINAPI performance_SetNotificationHandle(IDirectMusicPerformance8 *iface,
 816         HANDLE notification_event, REFERENCE_TIME minimum_time)
 817 {
 818     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 819
 820     TRACE("(%p, %p, %I64d)\n", This, notification_event, minimum_time);
 821
 822     This->notification_event = notification_event;
 823     if (minimum_time)
 824         This->notification_timeout = minimum_time;
 825     else if (!This->notification_timeout)
 826         This->notification_timeout = 20000000; /* 2 seconds */
 827
 828     return S_OK;
 829 }
 830
 831 static HRESULT WINAPI performance_GetNotificationPMsg(IDirectMusicPerformance8 *iface,
 832         DMUS_NOTIFICATION_PMSG **ret_msg)
 833 {
 834     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 835     struct list *entry;
 836
 837     TRACE("(%p, %p)\n", This, ret_msg);
 838
 839     if (!ret_msg) return E_POINTER;
 840
 841     EnterCriticalSection(&This->safe);
 842     if ((entry = list_head(&This->notifications)))
 843     {
 844         struct message *message = LIST_ENTRY(entry, struct message, entry);
 845         list_remove(&message->entry);
 846         list_init(&message->entry);
 847         *ret_msg = (DMUS_NOTIFICATION_PMSG *)&message->msg;
 848     }
 849     LeaveCriticalSection(&This->safe);
 850
 851     return entry ? S_OK : S_FALSE;
 852 }
 853
 854 static HRESULT WINAPI performance_AddNotificationType(IDirectMusicPerformance8 *iface, REFGUID type)
 855 {
 856     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 857     HRESULT hr = S_OK;
 858
 859     FIXME("(%p, %s): stub\n", This, debugstr_dmguid(type));
 860
 861     if (IsEqualGUID(type, &GUID_NOTIFICATION_PERFORMANCE))
 862     {
 863         hr = This->notification_performance ? S_FALSE : S_OK;
 864         This->notification_performance = TRUE;
 865     }
 866     if (IsEqualGUID(type, &GUID_NOTIFICATION_SEGMENT))
 867     {
 868         hr = This->notification_segment ? S_FALSE : S_OK;
 869         This->notification_segment = TRUE;
 870     }
 871
 872     return hr;
 873 }
 874
 875 static HRESULT WINAPI performance_RemoveNotificationType(IDirectMusicPerformance8 *iface, REFGUID type)
 876 {
 877     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 878     HRESULT hr = S_FALSE;
 879
 880     FIXME("(%p, %s): stub\n", This, debugstr_dmguid(type));
 881
 882     if (IsEqualGUID(type, &GUID_NOTIFICATION_PERFORMANCE))
 883     {
 884         hr = This->notification_performance ? S_OK : S_FALSE;
 885         This->notification_performance = FALSE;
 886     }
 887     if (IsEqualGUID(type, &GUID_NOTIFICATION_SEGMENT))
 888     {
 889         hr = This->notification_segment ? S_OK : S_FALSE;
 890         This->notification_segment = FALSE;
 891     }
 892
 893     return hr;
 894 }
 895
 896 static void performance_update_latency_time(struct performance *This, IDirectMusicPort *port,
 897         REFERENCE_TIME *ret_time)
 898 {
 899     IDirectMusicPerformance8 *iface = &This->IDirectMusicPerformance8_iface;
 900     REFERENCE_TIME latency_time, current_time;
 901     IReferenceClock *latency_clock;
 902     HRESULT hr;
 903
 904     if (!ret_time) ret_time = &latency_time;
 905     if (SUCCEEDED(hr = IDirectMusicPort_GetLatencyClock(port, &latency_clock)))
 906     {
 907         hr = IReferenceClock_GetTime(latency_clock, ret_time);
 908         if (SUCCEEDED(hr)) hr = IDirectMusicPerformance8_GetTime(iface, &current_time, NULL);
 909         if (SUCCEEDED(hr) && This->latency_offset < (*ret_time - current_time))
 910         {
 911             TRACE("Updating performance %p latency %I64d -> %I64d\n", This,
 912                     This->latency_offset, *ret_time - current_time);
 913             This->latency_offset = *ret_time - current_time;
 914         }
 915         IReferenceClock_Release(latency_clock);
 916     }
 917
 918     if (FAILED(hr)) ERR("Failed to update performance %p latency, hr %#lx\n", This, hr);
 919 }
 920
 921 static HRESULT perf_dmport_create(struct performance *perf, DMUS_PORTPARAMS *params)
 922 {
 923     IDirectMusicPort *port;
 924     GUID guid;
 925     unsigned int i;
 926     HRESULT hr;
 927
 928     if (FAILED(hr = IDirectMusic8_GetDefaultPort(perf->dmusic, &guid)))
 929         return hr;
 930
 931     if (FAILED(hr = IDirectMusic8_CreatePort(perf->dmusic, &guid, params, &port, NULL)))
 932         return hr;
 933
 934     if (FAILED(hr = IDirectMusicPort_SetDirectSound(port, perf->dsound, NULL))
 935             || FAILED(hr = IDirectMusicPort_Activate(port, TRUE)))
 936     {
 937         IDirectMusicPort_Release(port);
 938         return hr;
 939     }
 940
 941     for (i = 0; i < params->dwChannelGroups; i++)
 942         pchannel_block_set(&perf->pchannels, i, port, i + 1, FALSE);
 943
 944     performance_update_latency_time(perf, port, NULL);
 945     return S_OK;
 946 }
 947
 948 static HRESULT WINAPI performance_AddPort(IDirectMusicPerformance8 *iface, IDirectMusicPort *port)
 949 {
 950     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 951
 952     FIXME("(%p, %p): semi-stub\n", This, port);
 953
 954     if (!This->dmusic) return DMUS_E_NOT_INIT;
 955     if (This->audio_paths_enabled) return DMUS_E_AUDIOPATHS_IN_USE;
 956
 957     if (!port) {
 958         DMUS_PORTPARAMS params = {
 959             .dwSize = sizeof(params),
 960             .dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS,
 961             .dwChannelGroups = 1
 962         };
 963
 964         return perf_dmport_create(This, &params);
 965     }
 966
 967     IDirectMusicPort_AddRef(port);
 968     /**
 969      * We should remember added Ports (for example using a list)
 970      * and control if Port is registered for each api who use ports
 971      */
 972
 973     performance_update_latency_time(This, port, NULL);
 974     return S_OK;
 975 }
 976
 977 static HRESULT WINAPI performance_RemovePort(IDirectMusicPerformance8 *iface, IDirectMusicPort *pPort)
 978 {
 979     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 980
 981     if (This->audio_paths_enabled) return DMUS_E_AUDIOPATHS_IN_USE;
 982
 983     FIXME("(%p, %p): stub\n", This, pPort);
 984     IDirectMusicPort_Release(pPort);
 985     return S_OK;
 986 }
 987
 988 static HRESULT WINAPI performance_AssignPChannelBlock(IDirectMusicPerformance8 *iface,
 989         DWORD block_num, IDirectMusicPort *port, DWORD group)
 990 {
 991     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 992
 993     FIXME("(%p, %ld, %p, %ld): semi-stub\n", This, block_num, port, group);
 994
 995     if (!port) return E_POINTER;
 996     if (block_num > MAXDWORD / 16) return E_INVALIDARG;
 997     if (This->audio_paths_enabled) return DMUS_E_AUDIOPATHS_IN_USE;
 998
 999     pchannel_block_set(&This->pchannels, block_num, port, group, FALSE);
1000
1001     return S_OK;
1002 }
1003
1004 static HRESULT WINAPI performance_AssignPChannel(IDirectMusicPerformance8 *iface, DWORD pchannel,
1005         IDirectMusicPort *port, DWORD group, DWORD channel)
1006 {
1007     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1008     struct pchannel_block *block;
1009
1010     FIXME("(%p)->(%ld, %p, %ld, %ld) semi-stub\n", This, pchannel, port, group, channel);
1011
1012     if (!port) return E_POINTER;
1013     if (This->audio_paths_enabled) return DMUS_E_AUDIOPATHS_IN_USE;
1014
1015     block = pchannel_block_set(&This->pchannels, pchannel / 16, port, 0, TRUE);
1016     if (block) {
1017         block->pchannel[pchannel % 16].group = group;
1018         block->pchannel[pchannel % 16].channel = channel;
1019     }
1020
1021     return S_OK;
1022 }
1023
1024 static HRESULT WINAPI performance_PChannelInfo(IDirectMusicPerformance8 *iface, DWORD pchannel,
1025         IDirectMusicPort **port, DWORD *group, DWORD *channel)
1026 {
1027     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1028     struct pchannel_block *block;
1029     struct wine_rb_entry *entry;
1030     DWORD block_num = pchannel / 16;
1031     unsigned int index = pchannel % 16;
1032
1033     TRACE("(%p)->(%ld, %p, %p, %p)\n", This, pchannel, port, group, channel);
1034
1035     entry = wine_rb_get(&This->pchannels, &block_num);
1036     if (!entry)
1037         return E_INVALIDARG;
1038     block = WINE_RB_ENTRY_VALUE(entry, struct pchannel_block, entry);
1039
1040     if (port) {
1041         *port = block->pchannel[index].port;
1042         IDirectMusicPort_AddRef(*port);
1043     }
1044     if (group)
1045         *group = block->pchannel[index].group;
1046     if (channel)
1047         *channel = block->pchannel[index].channel;
1048
1049     return S_OK;
1050 }
1051
1052 static HRESULT WINAPI performance_DownloadInstrument(IDirectMusicPerformance8 *iface,
1053         IDirectMusicInstrument *instrument, DWORD port_channel,
1054         IDirectMusicDownloadedInstrument **downloaded, DMUS_NOTERANGE *note_ranges,
1055         DWORD note_range_count, IDirectMusicPort **port, DWORD *group, DWORD *music_channel)
1056 {
1057     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1058     IDirectMusicPort *tmp_port = NULL;
1059     HRESULT hr;
1060
1061     TRACE("(%p, %p, %ld, %p, %p, %ld, %p, %p, %p)\n", This, instrument, port_channel, downloaded,
1062             note_ranges, note_range_count, port, group, music_channel);
1063
1064     if (!port) port = &tmp_port;
1065     if (FAILED(hr = IDirectMusicPerformance_PChannelInfo(iface, port_channel, port, group, music_channel)))
1066         return hr;
1067
1068     hr = IDirectMusicPort_DownloadInstrument(*port, instrument, downloaded, note_ranges, note_range_count);
1069     if (tmp_port) IDirectMusicPort_Release(tmp_port);
1070     return hr;
1071 }
1072
1073 static HRESULT WINAPI performance_Invalidate(IDirectMusicPerformance8 *iface, MUSIC_TIME mtTime, DWORD dwFlags)
1074 {
1075         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1076
1077         FIXME("(%p, %ld, %ld): stub\n", This, mtTime, dwFlags);
1078         return S_OK;
1079 }
1080
1081 static HRESULT WINAPI performance_GetParam(IDirectMusicPerformance8 *iface, REFGUID rguidType,
1082         DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME *pmtNext, void *pParam)
1083 {
1084         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1085
1086         FIXME("(%p, %s, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
1087         return S_OK;
1088 }
1089
1090 static HRESULT WINAPI performance_SetParam(IDirectMusicPerformance8 *iface, REFGUID rguidType,
1091         DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, void *pParam)
1092 {
1093         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1094
1095         FIXME("(%p, %s, %ld, %ld, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
1096         return S_OK;
1097 }
1098
1099 static HRESULT WINAPI performance_GetGlobalParam(IDirectMusicPerformance8 *iface, REFGUID rguidType,
1100         void *pParam, DWORD dwSize)
1101 {
1102         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1103
1104         TRACE("(%p, %s, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), pParam, dwSize);
1105
1106         if (IsEqualGUID (rguidType, &GUID_PerfAutoDownload))
1107                 memcpy(pParam, &This->fAutoDownload, sizeof(This->fAutoDownload));
1108         if (IsEqualGUID (rguidType, &GUID_PerfMasterGrooveLevel))
1109                 memcpy(pParam, &This->cMasterGrooveLevel, sizeof(This->cMasterGrooveLevel));
1110         if (IsEqualGUID (rguidType, &GUID_PerfMasterTempo))
1111                 memcpy(pParam, &This->fMasterTempo, sizeof(This->fMasterTempo));
1112         if (IsEqualGUID (rguidType, &GUID_PerfMasterVolume))
1113                 memcpy(pParam, &This->lMasterVolume, sizeof(This->lMasterVolume));
1114
1115         return S_OK;
1116 }
1117
1118 static HRESULT WINAPI performance_SetGlobalParam(IDirectMusicPerformance8 *iface, REFGUID rguidType,
1119         void *pParam, DWORD dwSize)
1120 {
1121         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1122
1123         TRACE("(%p, %s, %p, %ld)\n", This, debugstr_dmguid(rguidType), pParam, dwSize);
1124
1125         if (IsEqualGUID (rguidType, &GUID_PerfAutoDownload)) {
1126                 memcpy(&This->fAutoDownload, pParam, dwSize);
1127                 TRACE("=> AutoDownload set to %d\n", This->fAutoDownload);
1128         }
1129         if (IsEqualGUID (rguidType, &GUID_PerfMasterGrooveLevel)) {
1130                 memcpy(&This->cMasterGrooveLevel, pParam, dwSize);
1131                 TRACE("=> MasterGrooveLevel set to %i\n", This->cMasterGrooveLevel);
1132         }
1133         if (IsEqualGUID (rguidType, &GUID_PerfMasterTempo)) {
1134                 memcpy(&This->fMasterTempo, pParam, dwSize);
1135                 TRACE("=> MasterTempo set to %f\n", This->fMasterTempo);
1136         }
1137         if (IsEqualGUID (rguidType, &GUID_PerfMasterVolume)) {
1138                 memcpy(&This->lMasterVolume, pParam, dwSize);
1139                 TRACE("=> MasterVolume set to %li\n", This->lMasterVolume);
1140         }
1141
1142         return S_OK;
1143 }
1144
1145 static HRESULT WINAPI performance_GetLatencyTime(IDirectMusicPerformance8 *iface, REFERENCE_TIME *ret_time)
1146 {
1147     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1148     REFERENCE_TIME current_time;
1149     HRESULT hr;
1150
1151     TRACE("(%p, %p)\n", This, ret_time);
1152
1153     if (SUCCEEDED(hr = IDirectMusicPerformance8_GetTime(iface, &current_time, NULL)))
1154         *ret_time = current_time + This->latency_offset;
1155
1156     return hr;
1157 }
1158
1159 static HRESULT WINAPI performance_GetQueueTime(IDirectMusicPerformance8 *iface, REFERENCE_TIME *prtTime)
1160
1161 {
1162         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1163
1164         FIXME("(%p, %p): stub\n", This, prtTime);
1165         return S_OK;
1166 }
1167
1168 static HRESULT WINAPI performance_AdjustTime(IDirectMusicPerformance8 *iface, REFERENCE_TIME rtAmount)
1169 {
1170         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1171
1172         FIXME("(%p, 0x%s): stub\n", This, wine_dbgstr_longlong(rtAmount));
1173         return S_OK;
1174 }
1175
1176 static HRESULT WINAPI performance_CloseDown(IDirectMusicPerformance8 *iface)
1177 {
1178     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1179     struct message *message, *next;
1180     HANDLE message_thread;
1181     HRESULT hr;
1182
1183     FIXME("(%p): semi-stub\n", This);
1184
1185     if ((message_thread = This->message_thread))
1186     {
1187         EnterCriticalSection(&This->safe);
1188         This->message_thread = NULL;
1189         LeaveCriticalSection(&This->safe);
1190         WakeConditionVariable(&This->cond);
1191
1192         WaitForSingleObject(message_thread, INFINITE);
1193         CloseHandle(message_thread);
1194     }
1195
1196     This->notification_performance = FALSE;
1197     This->notification_segment = FALSE;
1198
1199     LIST_FOR_EACH_ENTRY_SAFE(message, next, &This->messages, struct message, entry)
1200     {
1201         list_remove(&message->entry);
1202         list_init(&message->entry);
1203
1204         if (message->msg.dwType == DMUS_PMSGT_INTERNAL_SEGMENT_END)
1205             hr = IDirectMusicTool_ProcessPMsg(&This->IDirectMusicTool_iface,
1206                     (IDirectMusicPerformance *)iface, &message->msg);
1207         else
1208             hr = DMUS_S_FREE;
1209
1210         if (hr == DMUS_S_FREE && FAILED(hr = IDirectMusicPerformance8_FreePMsg(iface, &message->msg)))
1211             WARN("Failed to free message %p, hr %#lx\n", message, hr);
1212     }
1213
1214     LIST_FOR_EACH_ENTRY_SAFE(message, next, &This->notifications, struct message, entry)
1215     {
1216         list_remove(&message->entry);
1217         list_init(&message->entry);
1218
1219         if (FAILED(hr = IDirectMusicPerformance8_FreePMsg(iface, &message->msg)))
1220             WARN("Failed to free message %p, hr %#lx\n", message, hr);
1221     }
1222
1223     performance_set_primary_segment(This, NULL);
1224
1225     if (This->master_clock)
1226     {
1227         IReferenceClock_Release(This->master_clock);
1228         This->master_clock = NULL;
1229     }
1230     if (This->dsound) {
1231         IDirectSound_Release(This->dsound);
1232         This->dsound = NULL;
1233     }
1234     if (This->dmusic) {
1235         IDirectMusic8_SetDirectSound(This->dmusic, NULL, NULL);
1236         IDirectMusic8_Release(This->dmusic);
1237         This->dmusic = NULL;
1238     }
1239     This->audio_paths_enabled = FALSE;
1240
1241     return S_OK;
1242 }
1243
1244 static HRESULT WINAPI performance_GetResolvedTime(IDirectMusicPerformance8 *iface,
1245         REFERENCE_TIME rtTime, REFERENCE_TIME *prtResolved, DWORD dwTimeResolveFlags)
1246 {
1247         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1248
1249         FIXME("(%p, 0x%s, %p, %ld): stub\n", This, wine_dbgstr_longlong(rtTime),
1250             prtResolved, dwTimeResolveFlags);
1251         return S_OK;
1252 }
1253
1254 static HRESULT WINAPI performance_MIDIToMusic(IDirectMusicPerformance8 *iface, BYTE bMIDIValue,
1255         DMUS_CHORD_KEY *pChord, BYTE bPlayMode, BYTE bChordLevel, WORD *pwMusicValue)
1256 {
1257         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1258
1259         FIXME("(%p, %d, %p, %d, %d, %p): stub\n", This, bMIDIValue, pChord, bPlayMode, bChordLevel, pwMusicValue);
1260         return S_OK;
1261 }
1262
1263 static HRESULT WINAPI performance_MusicToMIDI(IDirectMusicPerformance8 *iface, WORD wMusicValue,
1264         DMUS_CHORD_KEY *pChord, BYTE bPlayMode, BYTE bChordLevel, BYTE *pbMIDIValue)
1265 {
1266         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1267
1268         FIXME("(%p, %d, %p, %d, %d, %p): stub\n", This, wMusicValue, pChord, bPlayMode, bChordLevel, pbMIDIValue);
1269         return S_OK;
1270 }
1271
1272 static HRESULT WINAPI performance_TimeToRhythm(IDirectMusicPerformance8 *iface, MUSIC_TIME mtTime,
1273         DMUS_TIMESIGNATURE *pTimeSig, WORD *pwMeasure, BYTE *pbBeat, BYTE *pbGrid, short *pnOffset)
1274 {
1275         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1276
1277         FIXME("(%p, %ld, %p, %p, %p, %p, %p): stub\n", This, mtTime, pTimeSig, pwMeasure, pbBeat, pbGrid, pnOffset);
1278         return S_OK;
1279 }
1280
1281 static HRESULT WINAPI performance_RhythmToTime(IDirectMusicPerformance8 *iface, WORD wMeasure,
1282         BYTE bBeat, BYTE bGrid, short nOffset, DMUS_TIMESIGNATURE *pTimeSig, MUSIC_TIME *pmtTime)
1283 {
1284         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1285
1286         FIXME("(%p, %d, %d, %d, %i, %p, %p): stub\n", This, wMeasure, bBeat, bGrid, nOffset, pTimeSig, pmtTime);
1287         return S_OK;
1288 }
1289
1290 /* IDirectMusicPerformance8 Interface part follow: */
1291 static HRESULT WINAPI performance_InitAudio(IDirectMusicPerformance8 *iface, IDirectMusic **dmusic,
1292         IDirectSound **dsound, HWND hwnd, DWORD default_path_type, DWORD num_channels, DWORD flags,
1293         DMUS_AUDIOPARAMS *params)
1294 {
1295     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1296     HRESULT hr = S_OK;
1297
1298     TRACE("(%p, %p, %p, %p, %lx, %lu, %lx, %p)\n", This, dmusic, dsound, hwnd, default_path_type,
1299             num_channels, flags, params);
1300
1301     if (flags) FIXME("flags parameter not used\n");
1302     if (params) FIXME("params parameter not used\n");
1303
1304     if (FAILED(hr = IDirectMusicPerformance8_Init(iface, dmusic && *dmusic ? dmusic : NULL,
1305             dsound ? *dsound : NULL, hwnd)))
1306         return hr;
1307
1308     This->audio_paths_enabled = TRUE;
1309     if (default_path_type)
1310     {
1311         hr = IDirectMusicPerformance8_CreateStandardAudioPath(iface, default_path_type,
1312                 num_channels, FALSE, &This->pDefaultPath);
1313         if (FAILED(hr))
1314         {
1315             IDirectMusicPerformance_CloseDown(iface);
1316             return hr;
1317         }
1318     }
1319
1320     if (dsound && !*dsound) {
1321         *dsound = This->dsound;
1322         IDirectSound_AddRef(*dsound);
1323     }
1324     if (dmusic && !*dmusic) {
1325         *dmusic = (IDirectMusic *)This->dmusic;
1326         IDirectMusic_AddRef(*dmusic);
1327     }
1328
1329     return S_OK;
1330 }
1331
1332 static HRESULT WINAPI performance_PlaySegmentEx(IDirectMusicPerformance8 *iface, IUnknown *source,
1333         WCHAR *segment_name, IUnknown *transition, DWORD segment_flags, INT64 start_time,
1334         IDirectMusicSegmentState **segment_state, IUnknown *from, IUnknown *audio_path)
1335 {
1336     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1337     IDirectMusicSegmentState *state;
1338     IDirectMusicSegment *segment;
1339     MUSIC_TIME music_time;
1340     HRESULT hr;
1341
1342     FIXME("(%p, %p, %s, %p, %#lx, %I64d, %p, %p, %p): stub\n", This, source, debugstr_w(segment_name),
1343             transition, segment_flags, start_time, segment_state, from, audio_path);
1344
1345     /* NOTE: The time is in music time unless the DMUS_SEGF_REFTIME flag is set. */
1346     if (segment_flags) FIXME("flags %#lx not implemented\n", segment_flags);
1347     if (start_time) FIXME("start_time %I64d not implemented\n", start_time);
1348
1349     if (FAILED(hr = IUnknown_QueryInterface(source, &IID_IDirectMusicSegment, (void **)&segment)))
1350         return hr;
1351
1352     EnterCriticalSection(&This->safe);
1353
1354     performance_set_primary_segment(This, segment);
1355
1356     if ((!(music_time = start_time) && FAILED(hr = IDirectMusicPerformance8_GetTime(iface, NULL, &music_time)))
1357             || FAILED(hr = segment_state_create(segment, music_time, iface, &state)))
1358     {
1359         performance_set_primary_segment(This, NULL);
1360         LeaveCriticalSection(&This->safe);
1361
1362         IDirectMusicSegment_Release(segment);
1363         return hr;
1364     }
1365
1366     if (FAILED(hr = segment_state_play(state, iface)))
1367     {
1368         ERR("Failed to play segment state, hr %#lx\n", hr);
1369         performance_set_primary_segment(This, NULL);
1370     }
1371     else if (segment_state)
1372     {
1373         *segment_state = state;
1374         IDirectMusicSegmentState_AddRef(state);
1375     }
1376
1377     LeaveCriticalSection(&This->safe);
1378
1379     IDirectMusicSegmentState_Release(state);
1380     IDirectMusicSegment_Release(segment);
1381     return hr;
1382 }
1383
1384 static HRESULT WINAPI performance_StopEx(IDirectMusicPerformance8 *iface, IUnknown *pObjectToStop,
1385         __int64 i64StopTime, DWORD dwFlags)
1386 {
1387         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1388
1389         FIXME("(%p, %p, 0x%s, %ld): stub\n", This, pObjectToStop,
1390             wine_dbgstr_longlong(i64StopTime), dwFlags);
1391         return S_OK;
1392 }
1393
1394 static HRESULT WINAPI performance_ClonePMsg(IDirectMusicPerformance8 *iface, DMUS_PMSG *msg, DMUS_PMSG **clone)
1395 {
1396     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1397     HRESULT hr;
1398
1399     TRACE("(%p, %p, %p)\n", This, msg, clone);
1400
1401     if (!msg || !clone) return E_POINTER;
1402     if (FAILED(hr = IDirectMusicPerformance8_AllocPMsg(iface, msg->dwSize, clone))) return hr;
1403
1404     memcpy(*clone, msg, msg->dwSize);
1405     if (msg->pTool) IDirectMusicTool_AddRef(msg->pTool);
1406     if (msg->pGraph) IDirectMusicGraph_AddRef(msg->pGraph);
1407     if (msg->punkUser) IUnknown_AddRef(msg->punkUser);
1408
1409     return S_OK;
1410 }
1411
1412 static HRESULT WINAPI performance_CreateAudioPath(IDirectMusicPerformance8 *iface,
1413         IUnknown *pSourceConfig, BOOL fActivate, IDirectMusicAudioPath **ret_iface)
1414 {
1415     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1416     IDirectMusicAudioPath *pPath;
1417
1418     FIXME("(%p, %p, %d, %p): stub\n", This, pSourceConfig, fActivate, ret_iface);
1419
1420     if (!ret_iface) return E_POINTER;
1421     if (!This->audio_paths_enabled) return DMUS_E_AUDIOPATH_INACTIVE;
1422
1423     create_dmaudiopath(&IID_IDirectMusicAudioPath, (void **)&pPath);
1424     set_audiopath_perf_pointer(pPath, iface);
1425
1426     /** TODO */
1427     *ret_iface = pPath;
1428     return IDirectMusicAudioPath_Activate(*ret_iface, fActivate);
1429 }
1430
1431 static HRESULT WINAPI performance_CreateStandardAudioPath(IDirectMusicPerformance8 *iface,
1432         DWORD dwType, DWORD pchannel_count, BOOL fActivate, IDirectMusicAudioPath **ret_iface)
1433 {
1434     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1435     IDirectMusicAudioPath *pPath;
1436     DSBUFFERDESC desc;
1437     WAVEFORMATEX format;
1438     DMUS_PORTPARAMS params = {0};
1439     IDirectSoundBuffer *buffer, *primary_buffer;
1440     HRESULT hr = S_OK;
1441
1442     FIXME("(%p)->(%ld, %ld, %d, %p): semi-stub\n", This, dwType, pchannel_count, fActivate, ret_iface);
1443
1444     if (!ret_iface) return E_POINTER;
1445     if (!This->audio_paths_enabled) return DMUS_E_AUDIOPATH_INACTIVE;
1446
1447     *ret_iface = NULL;
1448
1449         /* Secondary buffer description */
1450         memset(&format, 0, sizeof(format));
1451         format.wFormatTag = WAVE_FORMAT_PCM;
1452         format.nChannels = 1;
1453         format.nSamplesPerSec = 44000;
1454         format.nAvgBytesPerSec = 44000*2;
1455         format.nBlockAlign = 2;
1456         format.wBitsPerSample = 16;
1457         format.cbSize = 0;
1458
1459         memset(&desc, 0, sizeof(desc));
1460         desc.dwSize = sizeof(desc);
1461         desc.dwFlags = DSBCAPS_CTRLFX | DSBCAPS_CTRLVOLUME | DSBCAPS_GLOBALFOCUS;
1462         desc.dwBufferBytes = DSBSIZE_MIN;
1463         desc.dwReserved = 0;
1464         desc.lpwfxFormat = &format;
1465         desc.guid3DAlgorithm = GUID_NULL;
1466
1467         switch(dwType) {
1468         case DMUS_APATH_DYNAMIC_3D:
1469                 desc.dwFlags |= DSBCAPS_CTRL3D | DSBCAPS_CTRLFREQUENCY | DSBCAPS_MUTE3DATMAXDISTANCE;
1470                 break;
1471         case DMUS_APATH_DYNAMIC_MONO:
1472                 desc.dwFlags |= DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
1473                 break;
1474         case DMUS_APATH_SHARED_STEREOPLUSREVERB:
1475                 /* normally we have to create 2 buffers (one for music other for reverb)
1476                  * in this case. See msdn
1477                  */
1478         case DMUS_APATH_DYNAMIC_STEREO:
1479                 desc.dwFlags |= DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
1480                 format.nChannels = 2;
1481                 format.nBlockAlign *= 2;
1482                 format.nAvgBytesPerSec *=2;
1483                 break;
1484         default:
1485                 return E_INVALIDARG;
1486         }
1487
1488         /* Create a port */
1489         params.dwSize = sizeof(params);
1490         params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS | DMUS_PORTPARAMS_AUDIOCHANNELS;
1491         params.dwChannelGroups = (pchannel_count + 15) / 16;
1492         params.dwAudioChannels = format.nChannels;
1493         if (FAILED(hr = perf_dmport_create(This, &params)))
1494                 return hr;
1495
1496         hr = IDirectSound_CreateSoundBuffer(This->dsound, &desc, &buffer, NULL);
1497         if (FAILED(hr))
1498                 return DSERR_BUFFERLOST;
1499
1500         /* Update description for creating primary buffer */
1501         desc.dwFlags |= DSBCAPS_PRIMARYBUFFER;
1502         desc.dwFlags &= ~DSBCAPS_CTRLFX;
1503         desc.dwBufferBytes = 0;
1504         desc.lpwfxFormat = NULL;
1505
1506         hr = IDirectSound_CreateSoundBuffer(This->dsound, &desc, &primary_buffer, NULL);
1507         if (FAILED(hr)) {
1508                 IDirectSoundBuffer_Release(buffer);
1509                 return DSERR_BUFFERLOST;
1510         }
1511
1512         create_dmaudiopath(&IID_IDirectMusicAudioPath, (void**)&pPath);
1513         set_audiopath_perf_pointer(pPath, iface);
1514         set_audiopath_dsound_buffer(pPath, buffer);
1515         set_audiopath_primary_dsound_buffer(pPath, primary_buffer);
1516
1517     *ret_iface = pPath;
1518     TRACE(" returning IDirectMusicAudioPath interface at %p.\n", *ret_iface);
1519     return IDirectMusicAudioPath_Activate(*ret_iface, fActivate);
1520 }
1521
1522 static HRESULT WINAPI performance_SetDefaultAudioPath(IDirectMusicPerformance8 *iface, IDirectMusicAudioPath *audio_path)
1523 {
1524     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1525
1526     FIXME("(%p, %p): semi-stub\n", This, audio_path);
1527
1528     if (!This->audio_paths_enabled) return DMUS_E_AUDIOPATH_INACTIVE;
1529
1530     if (This->pDefaultPath) IDirectMusicAudioPath_Release(This->pDefaultPath);
1531     if ((This->pDefaultPath = audio_path))
1532     {
1533         IDirectMusicAudioPath_AddRef(This->pDefaultPath);
1534         set_audiopath_perf_pointer(This->pDefaultPath, iface);
1535     }
1536
1537     return S_OK;
1538 }
1539
1540 static HRESULT WINAPI performance_GetDefaultAudioPath(IDirectMusicPerformance8 *iface,
1541         IDirectMusicAudioPath **ret_iface)
1542 {
1543     struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1544
1545     FIXME("(%p, %p): semi-stub (%p)\n", This, ret_iface, This->pDefaultPath);
1546
1547     if (!ret_iface) return E_POINTER;
1548     if (!This->audio_paths_enabled) return DMUS_E_AUDIOPATH_INACTIVE;
1549
1550     if ((*ret_iface = This->pDefaultPath)) IDirectMusicAudioPath_AddRef(*ret_iface);
1551
1552     return S_OK;
1553 }
1554
1555 static HRESULT WINAPI performance_GetParamEx(IDirectMusicPerformance8 *iface, REFGUID rguidType, DWORD dwTrackID,
1556         DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME *pmtNext, void *pParam)
1557 {
1558         struct performance *This = impl_from_IDirectMusicPerformance8(iface);
1559
1560         FIXME("(%p, %s, %ld, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwTrackID, dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
1561
1562         return S_OK;
1563 }
1564
1565 static const IDirectMusicPerformance8Vtbl performance_vtbl =
1566 {
1567     performance_QueryInterface,
1568     performance_AddRef,
1569     performance_Release,
1570     performance_Init,
1571     performance_PlaySegment,
1572     performance_Stop,
1573     performance_GetSegmentState,
1574     performance_SetPrepareTime,
1575     performance_GetPrepareTime,
1576     performance_SetBumperLength,
1577     performance_GetBumperLength,
1578     performance_SendPMsg,
1579     performance_MusicToReferenceTime,
1580     performance_ReferenceToMusicTime,
1581     performance_IsPlaying,
1582     performance_GetTime,
1583     performance_AllocPMsg,
1584     performance_FreePMsg,
1585     performance_GetGraph,
1586     performance_SetGraph,
1587     performance_SetNotificationHandle,
1588     performance_GetNotificationPMsg,
1589     performance_AddNotificationType,
1590     performance_RemoveNotificationType,
1591     performance_AddPort,
1592     performance_RemovePort,
1593     performance_AssignPChannelBlock,
1594     performance_AssignPChannel,
1595     performance_PChannelInfo,
1596     performance_DownloadInstrument,
1597     performance_Invalidate,
1598     performance_GetParam,
1599     performance_SetParam,
1600     performance_GetGlobalParam,
1601     performance_SetGlobalParam,
1602     performance_GetLatencyTime,
1603     performance_GetQueueTime,
1604     performance_AdjustTime,
1605     performance_CloseDown,
1606     performance_GetResolvedTime,
1607     performance_MIDIToMusic,
1608     performance_MusicToMIDI,
1609     performance_TimeToRhythm,
1610     performance_RhythmToTime,
1611     performance_InitAudio,
1612     performance_PlaySegmentEx,
1613     performance_StopEx,
1614     performance_ClonePMsg,
1615     performance_CreateAudioPath,
1616     performance_CreateStandardAudioPath,
1617     performance_SetDefaultAudioPath,
1618     performance_GetDefaultAudioPath,
1619     performance_GetParamEx,
1620 };
1621
1622 static inline struct performance *impl_from_IDirectMusicGraph(IDirectMusicGraph *iface)
1623 {
1624     return CONTAINING_RECORD(iface, struct performance, IDirectMusicGraph_iface);
1625 }
1626
1627 static HRESULT WINAPI performance_graph_QueryInterface(IDirectMusicGraph *iface, REFIID riid, void **ret_iface)
1628 {
1629     struct performance *This = impl_from_IDirectMusicGraph(iface);
1630     return IDirectMusicPerformance8_QueryInterface(&This->IDirectMusicPerformance8_iface, riid, ret_iface);
1631 }
1632
1633 static ULONG WINAPI performance_graph_AddRef(IDirectMusicGraph *iface)
1634 {
1635     struct performance *This = impl_from_IDirectMusicGraph(iface);
1636     return IDirectMusicPerformance8_AddRef(&This->IDirectMusicPerformance8_iface);
1637 }
1638
1639 static ULONG WINAPI performance_graph_Release(IDirectMusicGraph *iface)
1640 {
1641     struct performance *This = impl_from_IDirectMusicGraph(iface);
1642     return IDirectMusicPerformance8_Release(&This->IDirectMusicPerformance8_iface);
1643 }
1644
1645 static HRESULT WINAPI performance_graph_StampPMsg(IDirectMusicGraph *iface, DMUS_PMSG *msg)
1646 {
1647     struct performance *This = impl_from_IDirectMusicGraph(iface);
1648     HRESULT hr;
1649
1650     TRACE("(%p, %p)\n", This, msg);
1651
1652     if (!msg) return E_POINTER;
1653
1654     /* FIXME: Implement segment and audio path graphs support */
1655     if (!This->pToolGraph) hr = DMUS_S_LAST_TOOL;
1656     else if (FAILED(hr = IDirectMusicGraph_StampPMsg(This->pToolGraph, msg))) return hr;
1657
1658     if (msg->pGraph)
1659     {
1660         IDirectMusicTool_Release(msg->pGraph);
1661         msg->pGraph = NULL;
1662     }
1663
1664     if (hr == DMUS_S_LAST_TOOL)
1665     {
1666         const DWORD delivery_flags = DMUS_PMSGF_TOOL_IMMEDIATE | DMUS_PMSGF_TOOL_QUEUE | DMUS_PMSGF_TOOL_ATTIME;
1667         msg->dwFlags &= ~delivery_flags;
1668         msg->dwFlags |= DMUS_PMSGF_TOOL_QUEUE;
1669
1670         if (msg->pTool) IDirectMusicTool_Release(msg->pTool);
1671         msg->pTool = &This->IDirectMusicTool_iface;
1672         IDirectMusicTool_AddRef(msg->pTool);
1673         return S_OK;
1674     }
1675
1676     if (SUCCEEDED(hr))
1677     {
1678         msg->pGraph = &This->IDirectMusicGraph_iface;
1679         IDirectMusicTool_AddRef(msg->pGraph);
1680     }
1681
1682     return hr;
1683 }
1684
1685 static HRESULT WINAPI performance_graph_InsertTool(IDirectMusicGraph *iface, IDirectMusicTool *tool,
1686         DWORD *channels, DWORD channels_count, LONG index)
1687 {
1688     struct performance *This = impl_from_IDirectMusicGraph(iface);
1689     TRACE("(%p, %p, %p, %lu, %ld)\n", This, tool, channels, channels_count, index);
1690     return E_NOTIMPL;
1691 }
1692
1693 static HRESULT WINAPI performance_graph_GetTool(IDirectMusicGraph *iface, DWORD index, IDirectMusicTool **tool)
1694 {
1695     struct performance *This = impl_from_IDirectMusicGraph(iface);
1696     TRACE("(%p, %lu, %p)\n", This, index, tool);
1697     return E_NOTIMPL;
1698 }
1699
1700 static HRESULT WINAPI performance_graph_RemoveTool(IDirectMusicGraph *iface, IDirectMusicTool *tool)
1701 {
1702     struct performance *This = impl_from_IDirectMusicGraph(iface);
1703     TRACE("(%p, %p)\n", This, tool);
1704     return E_NOTIMPL;
1705 }
1706
1707 static const IDirectMusicGraphVtbl performance_graph_vtbl =
1708 {
1709     performance_graph_QueryInterface,
1710     performance_graph_AddRef,
1711     performance_graph_Release,
1712     performance_graph_StampPMsg,
1713     performance_graph_InsertTool,
1714     performance_graph_GetTool,
1715     performance_graph_RemoveTool,
1716 };
1717
1718 static inline struct performance *impl_from_IDirectMusicTool(IDirectMusicTool *iface)
1719 {
1720     return CONTAINING_RECORD(iface, struct performance, IDirectMusicTool_iface);
1721 }
1722
1723 static HRESULT WINAPI performance_tool_QueryInterface(IDirectMusicTool *iface, REFIID riid, void **ret_iface)
1724 {
1725     struct performance *This = impl_from_IDirectMusicTool(iface);
1726     return IDirectMusicPerformance8_QueryInterface(&This->IDirectMusicPerformance8_iface, riid, ret_iface);
1727 }
1728
1729 static ULONG WINAPI performance_tool_AddRef(IDirectMusicTool *iface)
1730 {
1731     struct performance *This = impl_from_IDirectMusicTool(iface);
1732     return IDirectMusicPerformance8_AddRef(&This->IDirectMusicPerformance8_iface);
1733 }
1734
1735 static ULONG WINAPI performance_tool_Release(IDirectMusicTool *iface)
1736 {
1737     struct performance *This = impl_from_IDirectMusicTool(iface);
1738     return IDirectMusicPerformance8_Release(&This->IDirectMusicPerformance8_iface);
1739 }
1740
1741 static HRESULT WINAPI performance_tool_Init(IDirectMusicTool *iface, IDirectMusicGraph *graph)
1742 {
1743     struct performance *This = impl_from_IDirectMusicTool(iface);
1744     TRACE("(%p, %p)\n", This, graph);
1745     return E_NOTIMPL;
1746 }
1747
1748 static HRESULT WINAPI performance_tool_GetMsgDeliveryType(IDirectMusicTool *iface, DWORD *type)
1749 {
1750     struct performance *This = impl_from_IDirectMusicTool(iface);
1751     TRACE("(%p, %p)\n", This, type);
1752     *type = DMUS_PMSGF_TOOL_IMMEDIATE;
1753     return S_OK;
1754 }
1755
1756 static HRESULT WINAPI performance_tool_GetMediaTypeArraySize(IDirectMusicTool *iface, DWORD *size)
1757 {
1758     struct performance *This = impl_from_IDirectMusicTool(iface);
1759     TRACE("(%p, %p)\n", This, size);
1760     *size = 0;
1761     return S_OK;
1762 }
1763
1764 static HRESULT WINAPI performance_tool_GetMediaTypes(IDirectMusicTool *iface, DWORD **types, DWORD size)
1765 {
1766     struct performance *This = impl_from_IDirectMusicTool(iface);
1767     TRACE("(%p, %p, %lu)\n", This, types, size);
1768     return E_NOTIMPL;
1769 }
1770
1771 static HRESULT performance_send_midi_pmsg(struct performance *This, DMUS_PMSG *msg, UINT flags,
1772         BYTE status, BYTE byte1, BYTE byte2)
1773 {
1774     IDirectMusicPerformance8 *performance = &This->IDirectMusicPerformance8_iface;
1775     DMUS_MIDI_PMSG *midi;
1776     HRESULT hr;
1777
1778     if (FAILED(hr = IDirectMusicPerformance8_AllocPMsg(performance, sizeof(*midi),
1779             (DMUS_PMSG **)&midi)))
1780         return hr;
1781
1782     if (flags & DMUS_PMSGF_REFTIME) midi->rtTime = msg->rtTime;
1783     if (flags & DMUS_PMSGF_MUSICTIME) midi->mtTime = msg->mtTime;
1784     midi->dwFlags = flags;
1785     midi->dwPChannel = msg->dwPChannel;
1786     midi->dwVirtualTrackID = msg->dwVirtualTrackID;
1787     midi->dwVoiceID = msg->dwVoiceID;
1788     midi->dwGroupID = msg->dwGroupID;
1789     midi->dwType = DMUS_PMSGT_MIDI;
1790     midi->bStatus = status;
1791     midi->bByte1 = byte1;
1792     midi->bByte2 = byte2;
1793
1794     if (FAILED(hr = IDirectMusicPerformance8_SendPMsg(performance, (DMUS_PMSG *)midi)))
1795         IDirectMusicPerformance8_FreePMsg(performance, (DMUS_PMSG *)midi);
1796
1797     return hr;
1798 }
1799
1800 static HRESULT WINAPI performance_tool_ProcessPMsg(IDirectMusicTool *iface,
1801         IDirectMusicPerformance *performance, DMUS_PMSG *msg)
1802 {
1803     struct performance *This = impl_from_IDirectMusicTool(iface);
1804     struct message *message = message_from_DMUS_PMSG(msg);
1805     HRESULT hr;
1806
1807     TRACE("(%p, %p, %p)\n", This, performance, msg);
1808
1809     switch (msg->dwType)
1810     {
1811     case DMUS_PMSGT_MIDI:
1812     {
1813         static const UINT event_size = sizeof(DMUS_EVENTHEADER) + sizeof(DWORD);
1814         DMUS_BUFFERDESC desc = {.dwSize = sizeof(desc), .cbBuffer = 2 * event_size};
1815         DMUS_MIDI_PMSG *midi = (DMUS_MIDI_PMSG *)msg;
1816         REFERENCE_TIME latency_time;
1817         IDirectMusicBuffer *buffer;
1818         IDirectMusicPort *port;
1819         DWORD group, channel;
1820         UINT value = 0;
1821
1822         if (FAILED(hr = IDirectMusicPerformance_PChannelInfo(performance, msg->dwPChannel,
1823                 &port, &group, &channel)))
1824         {
1825             WARN("Failed to get message port, hr %#lx\n", hr);
1826             return DMUS_S_FREE;
1827         }
1828         performance_update_latency_time(This, port, &latency_time);
1829
1830         value |= channel;
1831         value |= (UINT)midi->bStatus;
1832         value |= (UINT)midi->bByte1 << 8;
1833         value |= (UINT)midi->bByte2 << 16;
1834
1835         if (SUCCEEDED(hr = IDirectMusic_CreateMusicBuffer(This->dmusic, &desc, &buffer, NULL)))
1836         {
1837             if (msg->rtTime == -1) msg->rtTime = latency_time;
1838             hr = IDirectMusicBuffer_PackStructured(buffer, msg->rtTime, group, value);
1839             if (SUCCEEDED(hr)) hr = IDirectMusicPort_PlayBuffer(port, buffer);
1840             IDirectMusicBuffer_Release(buffer);
1841         }
1842
1843         IDirectMusicPort_Release(port);
1844         break;
1845     }
1846
1847     case DMUS_PMSGT_NOTE:
1848     {
1849         DMUS_NOTE_PMSG *note = (DMUS_NOTE_PMSG *)msg;
1850
1851         msg->mtTime += note->nOffset;
1852         if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
1853                 MIDI_NOTE_ON, note->bMidiValue, note->bVelocity)))
1854             WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
1855
1856         msg->mtTime += note->mtDuration;
1857         if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_QUEUE,
1858                 MIDI_NOTE_OFF, note->bMidiValue, 0)))
1859             WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
1860
1861         break;
1862     }
1863
1864     case DMUS_PMSGT_CURVE:
1865     {
1866         DMUS_CURVE_PMSG *curve = (DMUS_CURVE_PMSG *)msg;
1867
1868         msg->mtTime += curve->nOffset;
1869         switch (curve->dwType)
1870         {
1871         case DMUS_CURVET_CCCURVE:
1872             if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
1873                     MIDI_CONTROL_CHANGE, curve->bCCData, curve->nStartValue)))
1874                 WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
1875             break;
1876         case DMUS_CURVET_RPNCURVE:
1877         case DMUS_CURVET_NRPNCURVE:
1878             FIXME("Unhandled curve type %#lx\n", curve->dwType);
1879             break;
1880         }
1881
1882         break;
1883     }
1884
1885     case DMUS_PMSGT_PATCH:
1886     {
1887         DMUS_PATCH_PMSG *patch = (DMUS_PATCH_PMSG *)msg;
1888
1889         if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_REFTIME | DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
1890                 MIDI_CONTROL_CHANGE, MIDI_CC_BANK_MSB, patch->byMSB)))
1891             WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
1892
1893         if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_REFTIME | DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
1894                 MIDI_CONTROL_CHANGE, MIDI_CC_BANK_LSB, patch->byLSB)))
1895             WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
1896
1897         if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_REFTIME | DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
1898                 MIDI_PROGRAM_CHANGE, patch->byInstrument, 0)))
1899             WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
1900
1901         break;
1902     }
1903
1904     case DMUS_PMSGT_NOTIFICATION:
1905     {
1906         DMUS_NOTIFICATION_PMSG *notif = (DMUS_NOTIFICATION_PMSG *)msg;
1907         struct message *previous;
1908         BOOL enabled = FALSE;
1909
1910         if (IsEqualGUID(&notif->guidNotificationType, &GUID_NOTIFICATION_PERFORMANCE))
1911             enabled = This->notification_performance;
1912         if (IsEqualGUID(&notif->guidNotificationType, &GUID_NOTIFICATION_SEGMENT))
1913             enabled = This->notification_segment;
1914         if (!enabled) return DMUS_S_FREE;
1915
1916         if (msg->dwFlags & DMUS_PMSGF_TOOL_IMMEDIATE)
1917         {
1918             /* re-send the message for queueing at the expected time */
1919             msg->dwFlags &= ~DMUS_PMSGF_TOOL_IMMEDIATE;
1920             msg->dwFlags |= DMUS_PMSGF_TOOL_ATTIME;
1921
1922             if (FAILED(hr = IDirectMusicPerformance8_SendPMsg(performance, (DMUS_PMSG *)msg)))
1923             {
1924                 ERR("Failed to send notification message, hr %#lx\n", hr);
1925                 return DMUS_S_FREE;
1926             }
1927
1928             return S_OK;
1929         }
1930
1931         list_add_tail(&This->notifications, &message->entry);
1932
1933         /* discard old notification messages */
1934         do
1935         {
1936             previous = LIST_ENTRY(list_head(&This->notifications), struct message, entry);
1937             if (This->notification_timeout <= 0) break; /* negative values may be used to keep everything */
1938             if (message->msg.rtTime - previous->msg.rtTime <= This->notification_timeout) break;
1939             list_remove(&previous->entry);
1940             list_init(&previous->entry);
1941         } while (SUCCEEDED(hr = IDirectMusicPerformance_FreePMsg(performance, &previous->msg)));
1942
1943         SetEvent(This->notification_event);
1944         return S_OK;
1945     }
1946
1947     case DMUS_PMSGT_WAVE:
1948         if (FAILED(hr = IDirectSoundBuffer_Play((IDirectSoundBuffer *)msg->punkUser, 0, 0, 0)))
1949             WARN("Failed to play wave buffer, hr %#lx\n", hr);
1950         break;
1951
1952     case DMUS_PMSGT_INTERNAL_SEGMENT_TICK:
1953         msg->rtTime += 10000000;
1954         msg->dwFlags &= ~DMUS_PMSGF_MUSICTIME;
1955
1956         /* re-send the tick message until segment_state_tick returns S_FALSE */
1957         if (FAILED(hr = segment_state_tick((IDirectMusicSegmentState *)msg->punkUser,
1958                 (IDirectMusicPerformance8 *)performance)))
1959             ERR("Failed to tick segment state %p, hr %#lx\n", msg->punkUser, hr);
1960         else if (hr == S_FALSE)
1961             return DMUS_S_FREE; /* done ticking */
1962         else if (FAILED(hr = IDirectMusicPerformance_SendPMsg(performance, msg)))
1963             ERR("Failed to queue tick for segment state %p, hr %#lx\n", msg->punkUser, hr);
1964
1965         return S_OK;
1966
1967     case DMUS_PMSGT_INTERNAL_SEGMENT_END:
1968         if (FAILED(hr = segment_state_end_play((IDirectMusicSegmentState *)msg->punkUser,
1969                 (IDirectMusicPerformance8 *)performance)))
1970             WARN("Failed to end segment state %p, hr %#lx\n", msg->punkUser, hr);
1971         break;
1972
1973     default:
1974         FIXME("Unhandled message type %#lx\n", msg->dwType);
1975         break;
1976     }
1977
1978     return DMUS_S_FREE;
1979 }
1980
1981 static HRESULT WINAPI performance_tool_Flush(IDirectMusicTool *iface,
1982         IDirectMusicPerformance *performance, DMUS_PMSG *msg, REFERENCE_TIME time)
1983 {
1984     struct performance *This = impl_from_IDirectMusicTool(iface);
1985     FIXME("(%p, %p, %p, %I64d): stub\n", This, performance, msg, time);
1986     return E_NOTIMPL;
1987 }
1988
1989 static const IDirectMusicToolVtbl performance_tool_vtbl =
1990 {
1991     performance_tool_QueryInterface,
1992     performance_tool_AddRef,
1993     performance_tool_Release,
1994     performance_tool_Init,
1995     performance_tool_GetMsgDeliveryType,
1996     performance_tool_GetMediaTypeArraySize,
1997     performance_tool_GetMediaTypes,
1998     performance_tool_ProcessPMsg,
1999     performance_tool_Flush,
2000 };
2001
2002 /* for ClassFactory */
2003 HRESULT create_dmperformance(REFIID iid, void **ret_iface)
2004 {
2005     struct performance *obj;
2006     HRESULT hr;
2007
2008     TRACE("(%s, %p)\n", debugstr_guid(iid), ret_iface);
2009
2010     *ret_iface = NULL;
2011     if (!(obj = calloc(1, sizeof(*obj)))) return E_OUTOFMEMORY;
2012     obj->IDirectMusicPerformance8_iface.lpVtbl = &performance_vtbl;
2013     obj->IDirectMusicGraph_iface.lpVtbl = &performance_graph_vtbl;
2014     obj->IDirectMusicTool_iface.lpVtbl = &performance_tool_vtbl;
2015     obj->ref = 1;
2016
2017     obj->pDefaultPath = NULL;
2018     InitializeCriticalSection(&obj->safe);
2019     obj->safe.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": performance->safe");
2020     wine_rb_init(&obj->pchannels, pchannel_block_compare);
2021
2022     list_init(&obj->messages);
2023     list_init(&obj->notifications);
2024
2025     obj->latency_offset = 50;
2026     obj->dwBumperLength =   50; /* 50 ms default */
2027     obj->dwPrepareTime  = 1000; /* 1000 ms default */
2028
2029     hr = IDirectMusicPerformance8_QueryInterface(&obj->IDirectMusicPerformance8_iface, iid, ret_iface);
2030     IDirectMusicPerformance_Release(&obj->IDirectMusicPerformance8_iface);
2031     return hr;
2032 }
2033
2034 static inline struct performance *unsafe_impl_from_IDirectMusicPerformance8(IDirectMusicPerformance8 *iface)
2035 {
2036     if (iface->lpVtbl != &performance_vtbl) return NULL;
2037     return CONTAINING_RECORD(iface, struct performance, IDirectMusicPerformance8_iface);
2038 }
2039
2040 HRESULT performance_get_dsound(IDirectMusicPerformance8 *iface, IDirectSound **dsound)
2041 {
2042     struct performance *This = unsafe_impl_from_IDirectMusicPerformance8(iface);
2043     if (!This || !(*dsound = This->dsound)) return E_FAIL;
2044     IDirectSound_AddRef(*dsound);
2045     return S_OK;
2046 }