performance.c File Reference

#include "dmime_private.h"
#include "dmusic_midi.h"
#include "wine/rbtree.h"
#include <math.h>

Include dependency graph for performance.c:

Go to the source code of this file.

Classes
struct	channel
struct	channel_block
struct	performance
struct	message
struct	state_entry

Enumerations
enum	dmus_internal_message_type { DMUS_PMSGT_INTERNAL_FIRST = 0x10 , DMUS_PMSGT_INTERNAL_SEGMENT_END = DMUS_PMSGT_INTERNAL_FIRST , DMUS_PMSGT_INTERNAL_SEGMENT_TICK }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dmime)
static struct message *	message_from_DMUS_PMSG (DMUS_PMSG *msg)
static struct message *	performance_get_message (struct performance *This, DWORD *timeout)
static HRESULT	performance_process_message (struct performance *This, DMUS_PMSG *msg)
static HRESULT	performance_queue_message (struct performance *This, struct message *message)
static DWORD WINAPI	message_thread_proc (void *args)
static HRESULT	performance_send_pmsg (struct performance *This, MUSIC_TIME music_time, DWORD flags, DWORD type, IUnknown *object)
static HRESULT	performance_send_notification_pmsg (struct performance *This, MUSIC_TIME music_time, BOOL stamp, GUID type, DWORD option, IUnknown *object)
static int	channel_block_compare (const void *key, const struct wine_rb_entry *entry)
static void	channel_block_free (struct wine_rb_entry *entry, void *context)
static struct channel *	performance_get_channel (struct performance *This, DWORD channel_num)
static HRESULT	channel_block_init (struct performance *This, DWORD block_num, IDirectMusicPort *port, DWORD midi_group)
static struct performance *	impl_from_IDirectMusicPerformance8 (IDirectMusicPerformance8 *iface)
HRESULT	performance_send_segment_start (IDirectMusicPerformance8 *iface, MUSIC_TIME music_time, IDirectMusicSegmentState *state)
HRESULT	performance_send_segment_tick (IDirectMusicPerformance8 *iface, MUSIC_TIME music_time, IDirectMusicSegmentState *state)
HRESULT	performance_send_segment_end (IDirectMusicPerformance8 *iface, MUSIC_TIME music_time, IDirectMusicSegmentState *state, BOOL abort)
static void	performance_set_primary_segment (struct performance *This, IDirectMusicSegment *segment)
static void	performance_set_control_segment (struct performance *This, IDirectMusicSegment *segment)
static HRESULT WINAPI	performance_QueryInterface (IDirectMusicPerformance8 *iface, REFIID riid, void **ret_iface)
static ULONG WINAPI	performance_AddRef (IDirectMusicPerformance8 *iface)
static ULONG WINAPI	performance_Release (IDirectMusicPerformance8 *iface)
static HRESULT	performance_init_dsound (struct performance *This, HWND hwnd)
static HRESULT	performance_init_dmusic (struct performance *This, IDirectSound *dsound)
static HRESULT	performance_send_midi_pmsg (struct performance *This, DMUS_PMSG *msg, UINT flags, BYTE status, BYTE byte1, BYTE byte2)
static HRESULT WINAPI	performance_Init (IDirectMusicPerformance8 *iface, IDirectMusic **dmusic, IDirectSound *dsound, HWND hwnd)
static HRESULT WINAPI	performance_PlaySegment (IDirectMusicPerformance8 *iface, IDirectMusicSegment *segment, DWORD segment_flags, INT64 start_time, IDirectMusicSegmentState **ret_state)
static void	state_entry_destroy (struct state_entry *entry)
static void	enum_segment_states (struct performance *This, IDirectMusicSegment *segment, struct list *list)
static BOOL	message_needs_flushing (struct message *message, IDirectMusicSegmentState *state)
static void	performance_flush_messages (struct performance *This, IDirectMusicSegmentState *state)
static HRESULT WINAPI	performance_Stop (IDirectMusicPerformance8 *iface, IDirectMusicSegment *segment, IDirectMusicSegmentState *state, MUSIC_TIME music_time, DWORD flags)
static HRESULT WINAPI	performance_GetSegmentState (IDirectMusicPerformance8 *iface, IDirectMusicSegmentState **state, MUSIC_TIME time)
static HRESULT WINAPI	performance_SetPrepareTime (IDirectMusicPerformance8 *iface, DWORD dwMilliSeconds)
static HRESULT WINAPI	performance_GetPrepareTime (IDirectMusicPerformance8 *iface, DWORD *pdwMilliSeconds)
static HRESULT WINAPI	performance_SetBumperLength (IDirectMusicPerformance8 *iface, DWORD dwMilliSeconds)
static HRESULT WINAPI	performance_GetBumperLength (IDirectMusicPerformance8 *iface, DWORD *pdwMilliSeconds)
static HRESULT WINAPI	performance_SendPMsg (IDirectMusicPerformance8 *iface, DMUS_PMSG *msg)
static HRESULT WINAPI	performance_MusicToReferenceTime (IDirectMusicPerformance8 *iface, MUSIC_TIME music_time, REFERENCE_TIME *time)
static HRESULT WINAPI	performance_ReferenceToMusicTime (IDirectMusicPerformance8 *iface, REFERENCE_TIME time, MUSIC_TIME *music_time)
static HRESULT WINAPI	performance_IsPlaying (IDirectMusicPerformance8 *iface, IDirectMusicSegment *pSegment, IDirectMusicSegmentState *pSegState)
static HRESULT WINAPI	performance_GetTime (IDirectMusicPerformance8 *iface, REFERENCE_TIME *time, MUSIC_TIME *music_time)
static HRESULT WINAPI	performance_AllocPMsg (IDirectMusicPerformance8 *iface, ULONG size, DMUS_PMSG **msg)
static HRESULT WINAPI	performance_FreePMsg (IDirectMusicPerformance8 *iface, DMUS_PMSG *msg)
static HRESULT WINAPI	performance_GetGraph (IDirectMusicPerformance8 *iface, IDirectMusicGraph **graph)
static HRESULT WINAPI	performance_SetGraph (IDirectMusicPerformance8 *iface, IDirectMusicGraph *pGraph)
static HRESULT WINAPI	performance_SetNotificationHandle (IDirectMusicPerformance8 *iface, HANDLE notification_event, REFERENCE_TIME minimum_time)
static HRESULT WINAPI	performance_GetNotificationPMsg (IDirectMusicPerformance8 *iface, DMUS_NOTIFICATION_PMSG **ret_msg)
static HRESULT WINAPI	performance_AddNotificationType (IDirectMusicPerformance8 *iface, REFGUID type)
static HRESULT WINAPI	performance_RemoveNotificationType (IDirectMusicPerformance8 *iface, REFGUID type)
static void	performance_update_latency_time (struct performance *This, IDirectMusicPort *port, REFERENCE_TIME *ret_time)
static HRESULT	perf_dmport_create (struct performance *perf, DMUS_PORTPARAMS *params)
static HRESULT WINAPI	performance_AddPort (IDirectMusicPerformance8 *iface, IDirectMusicPort *port)
static HRESULT WINAPI	performance_RemovePort (IDirectMusicPerformance8 *iface, IDirectMusicPort *pPort)
static HRESULT WINAPI	performance_AssignPChannelBlock (IDirectMusicPerformance8 *iface, DWORD block_num, IDirectMusicPort *port, DWORD midi_group)
static HRESULT WINAPI	performance_AssignPChannel (IDirectMusicPerformance8 *iface, DWORD channel_num, IDirectMusicPort *port, DWORD midi_group, DWORD midi_channel)
static HRESULT WINAPI	performance_PChannelInfo (IDirectMusicPerformance8 *iface, DWORD channel_num, IDirectMusicPort **port, DWORD *midi_group, DWORD *midi_channel)
static HRESULT WINAPI	performance_DownloadInstrument (IDirectMusicPerformance8 *iface, IDirectMusicInstrument *instrument, DWORD port_channel, IDirectMusicDownloadedInstrument **downloaded, DMUS_NOTERANGE *note_ranges, DWORD note_range_count, IDirectMusicPort **port, DWORD *group, DWORD *music_channel)
static HRESULT WINAPI	performance_Invalidate (IDirectMusicPerformance8 *iface, MUSIC_TIME mtTime, DWORD dwFlags)
static HRESULT WINAPI	performance_GetParam (IDirectMusicPerformance8 *iface, REFGUID type, DWORD group, DWORD index, MUSIC_TIME music_time, MUSIC_TIME *next_time, void *param)
static HRESULT WINAPI	performance_SetParam (IDirectMusicPerformance8 *iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, void *pParam)
static HRESULT WINAPI	performance_GetGlobalParam (IDirectMusicPerformance8 *iface, REFGUID rguidType, void *pParam, DWORD dwSize)
static HRESULT WINAPI	performance_SetGlobalParam (IDirectMusicPerformance8 *iface, REFGUID rguidType, void *pParam, DWORD dwSize)
static HRESULT WINAPI	performance_GetLatencyTime (IDirectMusicPerformance8 *iface, REFERENCE_TIME *ret_time)
static HRESULT WINAPI	performance_GetQueueTime (IDirectMusicPerformance8 *iface, REFERENCE_TIME *prtTime)
static HRESULT WINAPI	performance_AdjustTime (IDirectMusicPerformance8 *iface, REFERENCE_TIME rtAmount)
static HRESULT WINAPI	performance_CloseDown (IDirectMusicPerformance8 *iface)
static HRESULT WINAPI	performance_GetResolvedTime (IDirectMusicPerformance8 *iface, REFERENCE_TIME rtTime, REFERENCE_TIME *prtResolved, DWORD dwTimeResolveFlags)
static HRESULT WINAPI	performance_MIDIToMusic (IDirectMusicPerformance8 *iface, BYTE bMIDIValue, DMUS_CHORD_KEY *pChord, BYTE bPlayMode, BYTE bChordLevel, WORD *pwMusicValue)
static HRESULT WINAPI	performance_MusicToMIDI (IDirectMusicPerformance8 *iface, WORD wMusicValue, DMUS_CHORD_KEY *pChord, BYTE bPlayMode, BYTE bChordLevel, BYTE *pbMIDIValue)
static HRESULT WINAPI	performance_TimeToRhythm (IDirectMusicPerformance8 *iface, MUSIC_TIME mtTime, DMUS_TIMESIGNATURE *pTimeSig, WORD *pwMeasure, BYTE *pbBeat, BYTE *pbGrid, short *pnOffset)
static HRESULT WINAPI	performance_RhythmToTime (IDirectMusicPerformance8 *iface, WORD wMeasure, BYTE bBeat, BYTE bGrid, short nOffset, DMUS_TIMESIGNATURE *pTimeSig, MUSIC_TIME *pmtTime)
static HRESULT WINAPI	performance_InitAudio (IDirectMusicPerformance8 *iface, IDirectMusic **dmusic, IDirectSound **dsound, HWND hwnd, DWORD default_path_type, DWORD num_channels, DWORD flags, DMUS_AUDIOPARAMS *params)
static HRESULT WINAPI	performance_PlaySegmentEx (IDirectMusicPerformance8 *iface, IUnknown *source, WCHAR *segment_name, IUnknown *transition, DWORD segment_flags, INT64 start_time, IDirectMusicSegmentState **segment_state, IUnknown *from, IUnknown *audio_path)
static HRESULT WINAPI	performance_StopEx (IDirectMusicPerformance8 *iface, IUnknown *pObjectToStop, __int64 i64StopTime, DWORD dwFlags)
static HRESULT WINAPI	performance_ClonePMsg (IDirectMusicPerformance8 *iface, DMUS_PMSG *msg, DMUS_PMSG **clone)
static HRESULT WINAPI	performance_CreateAudioPath (IDirectMusicPerformance8 *iface, IUnknown *pSourceConfig, BOOL fActivate, IDirectMusicAudioPath **ret_iface)
static HRESULT WINAPI	performance_CreateStandardAudioPath (IDirectMusicPerformance8 *iface, DWORD dwType, DWORD pchannel_count, BOOL fActivate, IDirectMusicAudioPath **ret_iface)
static HRESULT WINAPI	performance_SetDefaultAudioPath (IDirectMusicPerformance8 *iface, IDirectMusicAudioPath *audio_path)
static HRESULT WINAPI	performance_GetDefaultAudioPath (IDirectMusicPerformance8 *iface, IDirectMusicAudioPath **ret_iface)
static HRESULT WINAPI	performance_GetParamEx (IDirectMusicPerformance8 *iface, REFGUID rguidType, DWORD dwTrackID, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME *pmtNext, void *pParam)
static struct performance *	impl_from_IDirectMusicGraph (IDirectMusicGraph *iface)
static HRESULT WINAPI	performance_graph_QueryInterface (IDirectMusicGraph *iface, REFIID riid, void **ret_iface)
static ULONG WINAPI	performance_graph_AddRef (IDirectMusicGraph *iface)
static ULONG WINAPI	performance_graph_Release (IDirectMusicGraph *iface)
static HRESULT WINAPI	performance_graph_StampPMsg (IDirectMusicGraph *iface, DMUS_PMSG *msg)
static HRESULT WINAPI	performance_graph_InsertTool (IDirectMusicGraph *iface, IDirectMusicTool *tool, DWORD *channels, DWORD channels_count, LONG index)
static HRESULT WINAPI	performance_graph_GetTool (IDirectMusicGraph *iface, DWORD index, IDirectMusicTool **tool)
static HRESULT WINAPI	performance_graph_RemoveTool (IDirectMusicGraph *iface, IDirectMusicTool *tool)
static struct performance *	impl_from_IDirectMusicTool (IDirectMusicTool *iface)
static HRESULT WINAPI	performance_tool_QueryInterface (IDirectMusicTool *iface, REFIID riid, void **ret_iface)
static ULONG WINAPI	performance_tool_AddRef (IDirectMusicTool *iface)
static ULONG WINAPI	performance_tool_Release (IDirectMusicTool *iface)
static HRESULT WINAPI	performance_tool_Init (IDirectMusicTool *iface, IDirectMusicGraph *graph)
static HRESULT WINAPI	performance_tool_GetMsgDeliveryType (IDirectMusicTool *iface, DWORD *type)
static HRESULT WINAPI	performance_tool_GetMediaTypeArraySize (IDirectMusicTool *iface, DWORD *size)
static HRESULT WINAPI	performance_tool_GetMediaTypes (IDirectMusicTool *iface, DWORD **types, DWORD size)
static HRESULT WINAPI	performance_tool_ProcessPMsg (IDirectMusicTool *iface, IDirectMusicPerformance *performance, DMUS_PMSG *msg)
static HRESULT WINAPI	performance_tool_Flush (IDirectMusicTool *iface, IDirectMusicPerformance *performance, DMUS_PMSG *msg, REFERENCE_TIME time)
HRESULT	create_dmperformance (REFIID iid, void **ret_iface)
static struct performance *	unsafe_impl_from_IDirectMusicPerformance8 (IDirectMusicPerformance8 *iface)
HRESULT	performance_get_dsound (IDirectMusicPerformance8 *iface, IDirectSound **dsound)

Variables
static const IDirectMusicPerformance8Vtbl	performance_vtbl
static const IDirectMusicGraphVtbl	performance_graph_vtbl
static const IDirectMusicToolVtbl	performance_tool_vtbl

Enumeration Type Documentation

dmus_internal_message_type

enum dmus_internal_message_type

Enumerator
DMUS_PMSGT_INTERNAL_FIRST
DMUS_PMSGT_INTERNAL_SEGMENT_END
DMUS_PMSGT_INTERNAL_SEGMENT_TICK

Definition at line 28 of file performance.c.

{
    DMUS_PMSGT_INTERNAL_FIRST = 0x10,
    DMUS_PMSGT_INTERNAL_SEGMENT_END = DMUS_PMSGT_INTERNAL_FIRST,
    DMUS_PMSGT_INTERNAL_SEGMENT_TICK,
};

Function Documentation

channel_block_compare()

static int channel_block_compare ( const void *  key, const struct wine_rb_entry *  entry  )

static

Definition at line 257 of file performance.c.

{
    const struct channel_block *b = WINE_RB_ENTRY_VALUE(entry, const struct channel_block, entry);
    return *(DWORD *)key - b->block_num;
}

Referenced by create_dmperformance().

channel_block_free()

static void channel_block_free ( struct wine_rb_entry *  entry, void *  context  )

static

Definition at line 263 of file performance.c.

{
    struct channel_block *block = WINE_RB_ENTRY_VALUE(entry, struct channel_block, entry);
    UINT i;
 
    for (i = 0; i < ARRAY_SIZE(block->channels); i++)
    {
        struct channel *channel = block->channels + i;
        if (channel->port) IDirectMusicPort_Release(channel->port);
    }
 
    free(block);
}

Referenced by perf_dmport_create(), and performance_Release().

channel_block_init()

static HRESULT channel_block_init ( struct performance *  This, DWORD  block_num, IDirectMusicPort *  port, DWORD  midi_group  )

static

Definition at line 285 of file performance.c.

{
    struct channel_block *block;
    struct wine_rb_entry *entry;
    UINT i;
 
    if ((entry = wine_rb_get(&This->channel_blocks, &block_num)))
        block = WINE_RB_ENTRY_VALUE(entry, struct channel_block, entry);
    else
    {
        if (!(block = calloc(1, sizeof(*block)))) return E_OUTOFMEMORY;
        block->block_num = block_num;
        wine_rb_put(&This->channel_blocks, &block_num, &block->entry);
    }
 
    for (i = 0; i < ARRAY_SIZE(block->channels); ++i)
    {
        struct channel *channel = block->channels + i;
        channel->midi_group = midi_group;
        channel->midi_channel = i;
        if (channel->port) IDirectMusicPort_Release(channel->port);
        if ((channel->port = port)) IDirectMusicPort_AddRef(channel->port);
    }
 
    return S_OK;
}

Referenced by perf_dmport_create(), and performance_AssignPChannelBlock().

create_dmperformance()

HRESULT create_dmperformance	(	REFIID	iid,
		void **	ret_iface
	)

Definition at line 2279 of file performance.c.

{
    struct performance *obj;
    HRESULT hr;
 
    TRACE("(%s, %p)\n", debugstr_guid(iid), ret_iface);
 
    *ret_iface = NULL;
    if (!(obj = calloc(1, sizeof(*obj)))) return E_OUTOFMEMORY;
    obj->IDirectMusicPerformance8_iface.lpVtbl = &performance_vtbl;
    obj->IDirectMusicGraph_iface.lpVtbl = &performance_graph_vtbl;
    obj->IDirectMusicTool_iface.lpVtbl = &performance_tool_vtbl;
    obj->ref = 1;
 
    obj->pDefaultPath = NULL;
    InitializeCriticalSectionEx(&obj->safe, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    obj->safe.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": performance->safe");
    wine_rb_init(&obj->channel_blocks, channel_block_compare);
 
    list_init(&obj->messages);
    list_init(&obj->notifications);
 
    obj->latency_offset = 50;
    obj->dwBumperLength =   50; /* 50 ms default */
    obj->dwPrepareTime  = 1000; /* 1000 ms default */
 
    hr = IDirectMusicPerformance8_QueryInterface(&obj->IDirectMusicPerformance8_iface, iid, ret_iface);
    IDirectMusicPerformance_Release(&obj->IDirectMusicPerformance8_iface);
    return hr;
}

enum_segment_states()

static void enum_segment_states ( struct performance *  This, IDirectMusicSegment *  segment, struct list *  list  )

static

Definition at line 587 of file performance.c.

{
    struct state_entry *entry;
    struct message *message;
 
    LIST_FOR_EACH_ENTRY(message, &This->messages, struct message, entry)
    {
        IDirectMusicSegmentState *message_state;
 
        if (message->msg.dwType != DMUS_PMSGT_INTERNAL_SEGMENT_TICK
                && message->msg.dwType != DMUS_PMSGT_INTERNAL_SEGMENT_END)
            continue;
 
        message_state = (IDirectMusicSegmentState *)message->msg.punkUser;
        if (segment && !segment_state_has_segment(message_state, segment)) continue;
 
        if (!(entry = malloc(sizeof(*entry)))) return;
        entry->state = message_state;
        IDirectMusicSegmentState_AddRef(entry->state);
        list_add_tail(list, &entry->entry);
    }
}

Referenced by performance_CloseDown(), performance_GetSegmentState(), and performance_Stop().

impl_from_IDirectMusicGraph()

static struct performance * impl_from_IDirectMusicGraph ( IDirectMusicGraph *  iface )

inlinestatic

Definition at line 1908 of file performance.c.

{
    return CONTAINING_RECORD(iface, struct performance, IDirectMusicGraph_iface);
}

Referenced by performance_graph_AddRef(), performance_graph_GetTool(), performance_graph_InsertTool(), performance_graph_QueryInterface(), performance_graph_Release(), performance_graph_RemoveTool(), and performance_graph_StampPMsg().

impl_from_IDirectMusicPerformance8()

static struct performance * impl_from_IDirectMusicPerformance8 ( IDirectMusicPerformance8 *  iface )

inlinestatic

Definition at line 313 of file performance.c.

{
    return CONTAINING_RECORD(iface, struct performance, IDirectMusicPerformance8_iface);
}

Referenced by performance_AddNotificationType(), performance_AddPort(), performance_AddRef(), performance_AdjustTime(), performance_AllocPMsg(), performance_AssignPChannel(), performance_AssignPChannelBlock(), performance_ClonePMsg(), performance_CloseDown(), performance_CreateAudioPath(), performance_CreateStandardAudioPath(), performance_DownloadInstrument(), performance_FreePMsg(), performance_GetBumperLength(), performance_GetDefaultAudioPath(), performance_GetGlobalParam(), performance_GetGraph(), performance_GetLatencyTime(), performance_GetNotificationPMsg(), performance_GetParam(), performance_GetParamEx(), performance_GetPrepareTime(), performance_GetQueueTime(), performance_GetResolvedTime(), performance_GetSegmentState(), performance_GetTime(), performance_Init(), performance_InitAudio(), performance_Invalidate(), performance_IsPlaying(), performance_MIDIToMusic(), performance_MusicToMIDI(), performance_MusicToReferenceTime(), performance_PChannelInfo(), performance_PlaySegment(), performance_PlaySegmentEx(), performance_QueryInterface(), performance_ReferenceToMusicTime(), performance_Release(), performance_RemoveNotificationType(), performance_RemovePort(), performance_RhythmToTime(), performance_send_segment_end(), performance_send_segment_start(), performance_send_segment_tick(), performance_SendPMsg(), performance_SetBumperLength(), performance_SetDefaultAudioPath(), performance_SetGlobalParam(), performance_SetGraph(), performance_SetNotificationHandle(), performance_SetParam(), performance_SetPrepareTime(), performance_Stop(), performance_StopEx(), and performance_TimeToRhythm().

impl_from_IDirectMusicTool()

static struct performance * impl_from_IDirectMusicTool ( IDirectMusicTool *  iface )

inlinestatic

Definition at line 2004 of file performance.c.

{
    return CONTAINING_RECORD(iface, struct performance, IDirectMusicTool_iface);
}

Referenced by performance_tool_AddRef(), performance_tool_Flush(), performance_tool_GetMediaTypeArraySize(), performance_tool_GetMediaTypes(), performance_tool_GetMsgDeliveryType(), performance_tool_Init(), performance_tool_ProcessPMsg(), performance_tool_QueryInterface(), and performance_tool_Release().

message_from_DMUS_PMSG()

static struct message * message_from_DMUS_PMSG ( DMUS_PMSG *  msg )

inlinestatic

Definition at line 95 of file performance.c.

{
    return msg ? CONTAINING_RECORD(msg, struct message, msg) : NULL;
}

Referenced by performance_FreePMsg(), performance_SendPMsg(), and performance_tool_ProcessPMsg().

message_needs_flushing()

static BOOL message_needs_flushing ( struct message *  message, IDirectMusicSegmentState *  state  )

static

Definition at line 610 of file performance.c.

{
    if (!state) return TRUE;
 
    switch (message->msg.dwType)
    {
    case DMUS_PMSGT_MIDI:
    case DMUS_PMSGT_NOTE:
    case DMUS_PMSGT_CURVE:
    case DMUS_PMSGT_PATCH:
    case DMUS_PMSGT_WAVE:
        if (!segment_state_has_track(state, message->msg.dwVirtualTrackID)) return FALSE;
        break;
 
    case DMUS_PMSGT_NOTIFICATION:
    {
        DMUS_NOTIFICATION_PMSG *notif = (DMUS_NOTIFICATION_PMSG *)&message->msg;
        if (!IsEqualGUID(&notif->guidNotificationType, &GUID_NOTIFICATION_SEGMENT)) return FALSE;
        if ((IDirectMusicSegmentState *)message->msg.punkUser != state) return FALSE;
        break;
    }
 
    case DMUS_PMSGT_INTERNAL_SEGMENT_TICK:
    case DMUS_PMSGT_INTERNAL_SEGMENT_END:
        if ((IDirectMusicSegmentState *)message->msg.punkUser != state) return FALSE;
        break;
 
    default:
        FIXME("Unhandled message type %#lx\n", message->msg.dwType);
        break;
    }
 
    return TRUE;
}

Referenced by performance_flush_messages().

message_thread_proc()

static DWORD WINAPI message_thread_proc ( void *  args )

static

Definition at line 174 of file performance.c.

{
    struct performance *This = args;
    HRESULT hr;
 
    TRACE("performance %p message thread\n", This);
    SetThreadDescription(GetCurrentThread(), L"wine_dmime_message");
 
    EnterCriticalSection(&This->safe);
 
    while (This->message_thread)
    {
        DWORD timeout = INFINITE;
        struct message *message;
 
        if (!(message = performance_get_message(This, &timeout)))
        {
            SleepConditionVariableCS(&This->cond, &This->safe, timeout);
            continue;
        }
 
        list_remove(&message->entry);
        list_init(&message->entry);
 
        hr = performance_process_message(This, &message->msg);
        if (hr == DMUS_S_REQUEUE) performance_queue_message(This, message);
    }
 
    LeaveCriticalSection(&This->safe);
 
    TRACE("(%p): Exiting\n", This);
    return 0;
}

Referenced by performance_Init().

perf_dmport_create()

static HRESULT perf_dmport_create ( struct performance *  perf, DMUS_PORTPARAMS *  params  )

static

Definition at line 1140 of file performance.c.

{
    IDirectMusicPort *port;
    GUID guid;
    unsigned int i;
    HRESULT hr;
 
    if (FAILED(hr = IDirectMusic8_GetDefaultPort(perf->dmusic, &guid)))
        return hr;
 
    if (FAILED(hr = IDirectMusic8_CreatePort(perf->dmusic, &guid, params, &port, NULL)))
        return hr;
 
    if (FAILED(hr = IDirectMusicPort_SetDirectSound(port, perf->dsound, NULL))
            || FAILED(hr = IDirectMusicPort_Activate(port, TRUE)))
    {
        IDirectMusicPort_Release(port);
        return hr;
    }
 
    wine_rb_destroy(&perf->channel_blocks, channel_block_free, NULL);
 
    for (i = 0; i < params->dwChannelGroups; i++)
    {
        if (FAILED(hr = channel_block_init(perf, i, port, i + 1)))
            ERR("Failed to init channel block, hr %#lx\n", hr);
    }
 
    performance_update_latency_time(perf, port, NULL);
    IDirectMusicPort_Release(port);
    return S_OK;
}

Referenced by performance_AddPort(), performance_CreateAudioPath(), and performance_CreateStandardAudioPath().

performance_AddNotificationType()

static HRESULT WINAPI performance_AddNotificationType ( IDirectMusicPerformance8 *  iface, REFGUID  type  )

static

Definition at line 1073 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    HRESULT hr = S_OK;
 
    FIXME("(%p, %s): stub\n", This, debugstr_dmguid(type));
 
    if (IsEqualGUID(type, &GUID_NOTIFICATION_PERFORMANCE))
    {
        hr = This->notification_performance ? S_FALSE : S_OK;
        This->notification_performance = TRUE;
    }
    if (IsEqualGUID(type, &GUID_NOTIFICATION_SEGMENT))
    {
        hr = This->notification_segment ? S_FALSE : S_OK;
        This->notification_segment = TRUE;
    }
 
    return hr;
}

performance_AddPort()

static HRESULT WINAPI performance_AddPort ( IDirectMusicPerformance8 *  iface, IDirectMusicPort *  port  )

static

We should remember added Ports (for example using a list) and control if Port is registered for each api who use ports

Definition at line 1173 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %p): semi-stub\n", This, port);
 
    if (!This->dmusic) return DMUS_E_NOT_INIT;
    if (This->audio_paths_enabled) return DMUS_E_AUDIOPATHS_IN_USE;
 
    if (!port) {
        DMUS_PORTPARAMS params = {
            .dwSize = sizeof(params),
            .dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS,
            .dwChannelGroups = 1
        };
 
        return perf_dmport_create(This, &params);
    }
 
    IDirectMusicPort_AddRef(port);
    performance_update_latency_time(This, port, NULL);
    return S_OK;
}

performance_AddRef()

static ULONG WINAPI performance_AddRef ( IDirectMusicPerformance8 *  iface )

static

Definition at line 432 of file performance.c.

{
  struct performance *This = impl_from_IDirectMusicPerformance8(iface);
  ULONG ref = InterlockedIncrement(&This->ref);
 
  TRACE("(%p): ref=%ld\n", This, ref);
 
  return ref;
}

performance_AdjustTime()

static HRESULT WINAPI performance_AdjustTime ( IDirectMusicPerformance8 *  iface, REFERENCE_TIME  rtAmount  )

static

Definition at line 1405 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, 0x%s): stub\n", This, wine_dbgstr_longlong(rtAmount));
    return S_OK;
}

performance_AllocPMsg()

static HRESULT WINAPI performance_AllocPMsg ( IDirectMusicPerformance8 *  iface, ULONG  size, DMUS_PMSG **  msg  )

static

Definition at line 957 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct message *message;
 
    TRACE("(%p, %ld, %p)\n", This, size, msg);
 
    if (!msg) return E_POINTER;
    if (size < sizeof(DMUS_PMSG)) return E_INVALIDARG;
 
    if (!(message = calloc(1, size - sizeof(DMUS_PMSG) + sizeof(struct message)))) return E_OUTOFMEMORY;
    message->msg.dwSize = size;
    list_init(&message->entry);
    *msg = &message->msg;
 
    return S_OK;
}

performance_AssignPChannel()

static HRESULT WINAPI performance_AssignPChannel ( IDirectMusicPerformance8 *  iface, DWORD  channel_num, IDirectMusicPort *  port, DWORD  midi_group, DWORD  midi_channel  )

static

Definition at line 1227 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct channel *channel;
    HRESULT hr;
 
    FIXME("(%p)->(%ld, %p, %ld, %ld) semi-stub\n", This, channel_num, port, midi_group, midi_channel);
 
    if (!port) return E_POINTER;
    if (This->audio_paths_enabled) return DMUS_E_AUDIOPATHS_IN_USE;
 
    if (!(channel = performance_get_channel(This, channel_num)))
    {
        if (FAILED(hr = IDirectMusicPerformance8_AssignPChannelBlock(iface,
                channel_num / 16, port, 0)))
            return hr;
        if (!(channel = performance_get_channel(This, channel_num)))
            return DMUS_E_NOT_FOUND;
    }
 
    channel->midi_group = midi_group;
    channel->midi_channel = midi_channel;
    if (channel->port) IDirectMusicPort_Release(channel->port);
    if ((channel->port = port)) IDirectMusicPort_AddRef(channel->port);
 
    return S_OK;
}

performance_AssignPChannelBlock()

static HRESULT WINAPI performance_AssignPChannelBlock ( IDirectMusicPerformance8 *  iface, DWORD  block_num, IDirectMusicPort *  port, DWORD  midi_group  )

static

Definition at line 1213 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %ld, %p, %ld): semi-stub\n", This, block_num, port, midi_group);
 
    if (!port) return E_POINTER;
    if (block_num > MAXDWORD / 16) return E_INVALIDARG;
    if (This->audio_paths_enabled) return DMUS_E_AUDIOPATHS_IN_USE;
 
    return channel_block_init(This, block_num, port, midi_group);
}

performance_ClonePMsg()

static HRESULT WINAPI performance_ClonePMsg ( IDirectMusicPerformance8 *  iface, DMUS_PMSG *  msg, DMUS_PMSG **  clone  )

static

Definition at line 1631 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", This, msg, clone);
 
    if (!msg || !clone) return E_POINTER;
    if (FAILED(hr = IDirectMusicPerformance8_AllocPMsg(iface, msg->dwSize, clone))) return hr;
 
    memcpy(*clone, msg, msg->dwSize);
    if (msg->pTool) IDirectMusicTool_AddRef(msg->pTool);
    if (msg->pGraph) IDirectMusicGraph_AddRef(msg->pGraph);
    if (msg->punkUser) IUnknown_AddRef(msg->punkUser);
 
    return S_OK;
}

performance_CloseDown()

static HRESULT WINAPI performance_CloseDown ( IDirectMusicPerformance8 *  iface )

static

Definition at line 1413 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct list states = LIST_INIT(states);
    struct state_entry *entry, *next;
    DMUS_PMSG msg = {.mtTime = -1};
    HANDLE message_thread;
    HRESULT hr;
 
    FIXME("(%p): semi-stub\n", This);
 
    if ((message_thread = This->message_thread))
    {
        EnterCriticalSection(&This->safe);
        This->message_thread = NULL;
        LeaveCriticalSection(&This->safe);
        WakeConditionVariable(&This->cond);
 
        WaitForSingleObject(message_thread, INFINITE);
        CloseHandle(message_thread);
    }
 
    This->notification_performance = FALSE;
    This->notification_segment = FALSE;
 
    enum_segment_states(This, NULL, &states);
    performance_flush_messages(This, NULL);
 
    LIST_FOR_EACH_ENTRY_SAFE(entry, next, &states, struct state_entry, entry)
    {
        if (FAILED(hr = segment_state_end_play(entry->state, iface)))
            ERR("Failed to stop segment state, hr %#lx\n", hr);
 
        IDirectMusicSegmentState_Release(entry->state);
        list_remove(&entry->entry);
        free(entry);
    }
 
    if (FAILED(hr = performance_send_midi_pmsg(This, &msg, DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
            MIDI_SYSTEM_RESET, 0, 0)))
        ERR("Failed to send MIDI_SYSTEM_RESET message, hr %#lx\n", hr);
 
    performance_set_primary_segment(This, NULL);
    performance_set_control_segment(This, NULL);
 
    if (This->master_clock)
    {
        IReferenceClock_Release(This->master_clock);
        This->master_clock = NULL;
    }
    if (This->dsound) {
        IDirectSound_Release(This->dsound);
        This->dsound = NULL;
    }
    if (This->dmusic) {
        IDirectMusic8_SetDirectSound(This->dmusic, NULL, NULL);
        IDirectMusic8_Release(This->dmusic);
        This->dmusic = NULL;
    }
    This->audio_paths_enabled = FALSE;
 
    return S_OK;
}

performance_CreateAudioPath()

static HRESULT WINAPI performance_CreateAudioPath ( IDirectMusicPerformance8 *  iface, IUnknown *  pSourceConfig, BOOL  fActivate, IDirectMusicAudioPath **  ret_iface  )

static

Definition at line 1649 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    IDirectMusicAudioPath *pPath;
    IDirectMusicObject *dmo;
    IDirectSoundBuffer *buffer, *primary_buffer;
    DMUS_OBJECTDESC objDesc;
    DMUS_PORTPARAMS8 port_params;
    HRESULT hr;
    WAVEFORMATEX format;
    DSBUFFERDESC desc;
 
    FIXME("(%p, %p, %d, %p): semi-stub\n", This, pSourceConfig, fActivate, ret_iface);
 
    if (!ret_iface || !pSourceConfig) return E_POINTER;
    if (!This->audio_paths_enabled) return DMUS_E_AUDIOPATH_INACTIVE;
 
    hr = IUnknown_QueryInterface(pSourceConfig, &IID_IDirectMusicObject, (void **)&dmo);
    if (FAILED(hr))
        return hr;
 
    hr = IDirectMusicObject_GetDescriptor(dmo, &objDesc);
    IDirectMusicObject_Release(dmo);
    if (FAILED(hr))
        return hr;
 
    if (!IsEqualCLSID(&objDesc.guidClass, &CLSID_DirectMusicAudioPathConfig))
    {
        ERR("Unexpected object class %s for source config.\n", debugstr_dmguid(&objDesc.guidClass));
        return E_INVALIDARG;
    }
 
    hr = path_config_get_audio_path_params(pSourceConfig, &format, &desc, &port_params);
    if (FAILED(hr))
        return hr;
 
    hr = perf_dmport_create(This, &port_params);
    if (FAILED(hr))
        return hr;
 
    hr = IDirectSound_CreateSoundBuffer(This->dsound, &desc, &buffer, NULL);
    if (FAILED(hr))
        return DSERR_BUFFERLOST;
 
    /* Update description for creating primary buffer */
    desc.dwFlags |= DSBCAPS_PRIMARYBUFFER;
    desc.dwFlags &= ~DSBCAPS_CTRLFX;
    desc.dwBufferBytes = 0;
    desc.lpwfxFormat = NULL;
 
    hr = IDirectSound_CreateSoundBuffer(This->dsound, &desc, &primary_buffer, NULL);
    if (FAILED(hr))
    {
        IDirectSoundBuffer_Release(buffer);
        return DSERR_BUFFERLOST;
    }
 
    create_dmaudiopath(&IID_IDirectMusicAudioPath, (void **)&pPath);
    set_audiopath_perf_pointer(pPath, iface);
    set_audiopath_dsound_buffer(pPath, buffer);
    set_audiopath_primary_dsound_buffer(pPath, primary_buffer);
    TRACE(" returning IDirectMusicAudioPath interface at %p.\n", *ret_iface);
 
    *ret_iface = pPath;
    return IDirectMusicAudioPath_Activate(*ret_iface, fActivate);
}

performance_CreateStandardAudioPath()

static HRESULT WINAPI performance_CreateStandardAudioPath ( IDirectMusicPerformance8 *  iface, DWORD  dwType, DWORD  pchannel_count, BOOL  fActivate, IDirectMusicAudioPath **  ret_iface  )

static

Definition at line 1717 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    IDirectMusicAudioPath *pPath;
    DSBUFFERDESC desc;
    WAVEFORMATEX format;
    DMUS_PORTPARAMS params = {0};
    IDirectSoundBuffer *buffer, *primary_buffer;
    HRESULT hr = S_OK;
 
    FIXME("(%p)->(%ld, %ld, %d, %p): semi-stub\n", This, dwType, pchannel_count, fActivate, ret_iface);
 
    if (!ret_iface) return E_POINTER;
    if (!This->audio_paths_enabled) return DMUS_E_AUDIOPATH_INACTIVE;
 
    *ret_iface = NULL;
 
    /* Secondary buffer description */
    memset(&format, 0, sizeof(format));
    format.wFormatTag = WAVE_FORMAT_PCM;
    format.nChannels = 1;
    format.nSamplesPerSec = 44000;
    format.nAvgBytesPerSec = 44000*2;
    format.nBlockAlign = 2;
    format.wBitsPerSample = 16;
    format.cbSize = 0;
    
    memset(&desc, 0, sizeof(desc));
    desc.dwSize = sizeof(desc);
        desc.dwFlags = DSBCAPS_CTRLFX | DSBCAPS_CTRLVOLUME | DSBCAPS_GLOBALFOCUS;
    desc.dwBufferBytes = DSBSIZE_MIN;
    desc.dwReserved = 0;
    desc.lpwfxFormat = &format;
    desc.guid3DAlgorithm = GUID_NULL;
    
    switch(dwType) {
    case DMUS_APATH_DYNAMIC_3D:
                desc.dwFlags |= DSBCAPS_CTRL3D | DSBCAPS_CTRLFREQUENCY | DSBCAPS_MUTE3DATMAXDISTANCE;
        break;
    case DMUS_APATH_DYNAMIC_MONO:
                desc.dwFlags |= DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
        break;
    case DMUS_APATH_SHARED_STEREOPLUSREVERB:
            /* normally we have to create 2 buffers (one for music other for reverb)
         * in this case. See msdn
                 */
    case DMUS_APATH_DYNAMIC_STEREO:
                desc.dwFlags |= DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
        format.nChannels = 2;
        format.nBlockAlign *= 2;
        format.nAvgBytesPerSec *=2;
        break;
    default:
            return E_INVALIDARG;
    }
 
        /* Create a port */
        params.dwSize = sizeof(params);
        params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS | DMUS_PORTPARAMS_AUDIOCHANNELS;
        params.dwChannelGroups = (pchannel_count + 15) / 16;
        params.dwAudioChannels = format.nChannels;
        if (FAILED(hr = perf_dmport_create(This, &params)))
                return hr;
 
        hr = IDirectSound_CreateSoundBuffer(This->dsound, &desc, &buffer, NULL);
    if (FAILED(hr))
            return DSERR_BUFFERLOST;
 
    /* Update description for creating primary buffer */
    desc.dwFlags |= DSBCAPS_PRIMARYBUFFER;
    desc.dwFlags &= ~DSBCAPS_CTRLFX;
    desc.dwBufferBytes = 0;
    desc.lpwfxFormat = NULL;
 
        hr = IDirectSound_CreateSoundBuffer(This->dsound, &desc, &primary_buffer, NULL);
    if (FAILED(hr)) {
                IDirectSoundBuffer_Release(buffer);
            return DSERR_BUFFERLOST;
    }
 
    create_dmaudiopath(&IID_IDirectMusicAudioPath, (void**)&pPath);
    set_audiopath_perf_pointer(pPath, iface);
    set_audiopath_dsound_buffer(pPath, buffer);
    set_audiopath_primary_dsound_buffer(pPath, primary_buffer);
 
    *ret_iface = pPath;
    TRACE(" returning IDirectMusicAudioPath interface at %p.\n", *ret_iface);
    return IDirectMusicAudioPath_Activate(*ret_iface, fActivate);
}

performance_DownloadInstrument()

static HRESULT WINAPI performance_DownloadInstrument ( IDirectMusicPerformance8 *  iface, IDirectMusicInstrument *  instrument, DWORD  port_channel, IDirectMusicDownloadedInstrument **  downloaded, DMUS_NOTERANGE *  note_ranges, DWORD  note_range_count, IDirectMusicPort **  port, DWORD *  group, DWORD *  music_channel  )

static

Definition at line 1276 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    IDirectMusicPort *tmp_port = NULL;
    HRESULT hr;
 
    TRACE("(%p, %p, %ld, %p, %p, %ld, %p, %p, %p)\n", This, instrument, port_channel, downloaded,
            note_ranges, note_range_count, port, group, music_channel);
 
    if (!port) port = &tmp_port;
    if (FAILED(hr = IDirectMusicPerformance_PChannelInfo(iface, port_channel, port, group, music_channel)))
        return hr;
 
    hr = IDirectMusicPort_DownloadInstrument(*port, instrument, downloaded, note_ranges, note_range_count);
    if (tmp_port) IDirectMusicPort_Release(tmp_port);
    return hr;
}

performance_flush_messages()

static void performance_flush_messages ( struct performance *  This, IDirectMusicSegmentState *  state  )

static

Definition at line 645 of file performance.c.

{
    IDirectMusicPerformance *iface = (IDirectMusicPerformance *)&This->IDirectMusicPerformance8_iface;
    struct message *message, *next;
    HRESULT hr;
 
    LIST_FOR_EACH_ENTRY_SAFE(message, next, &This->messages, struct message, entry)
    {
        if (!message_needs_flushing(message, state)) continue;
 
        list_remove(&message->entry);
        list_init(&message->entry);
 
        if (FAILED(hr = IDirectMusicPerformance8_FreePMsg(iface, &message->msg)))
            ERR("Failed to free message %p, hr %#lx\n", message, hr);
    }
 
    LIST_FOR_EACH_ENTRY_SAFE(message, next, &This->notifications, struct message, entry)
    {
        if (!message_needs_flushing(message, state)) continue;
 
        list_remove(&message->entry);
        list_init(&message->entry);
 
        if (FAILED(hr = IDirectMusicPerformance8_FreePMsg(iface, &message->msg)))
            ERR("Failed to free message %p, hr %#lx\n", message, hr);
    }
}

Referenced by performance_CloseDown(), and performance_Stop().

performance_FreePMsg()

static HRESULT WINAPI performance_FreePMsg ( IDirectMusicPerformance8 *  iface, DMUS_PMSG *  msg  )

static

Definition at line 975 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct message *message;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", This, msg);
 
    if (!(message = message_from_DMUS_PMSG(msg))) return E_POINTER;
 
    EnterCriticalSection(&This->safe);
    hr = !list_empty(&message->entry) ? DMUS_E_CANNOT_FREE : S_OK;
    LeaveCriticalSection(&This->safe);
 
    if (SUCCEEDED(hr))
    {
        if (msg->pTool) IDirectMusicTool_Release(msg->pTool);
        if (msg->pGraph) IDirectMusicGraph_Release(msg->pGraph);
        if (msg->punkUser) IUnknown_Release(msg->punkUser);
        free(message);
    }
 
    return hr;
}

performance_get_channel()

static struct channel * performance_get_channel ( struct performance *  This, DWORD  channel_num  )

static

Definition at line 277 of file performance.c.

{
    DWORD block_num = channel_num / 16;
    struct wine_rb_entry *entry;
    if (!(entry = wine_rb_get(&This->channel_blocks, &block_num))) return NULL;
    return WINE_RB_ENTRY_VALUE(entry, struct channel_block, entry)->channels + channel_num % 16;
}

Referenced by performance_AssignPChannel(), and performance_PChannelInfo().

performance_get_dsound()

HRESULT performance_get_dsound	(	IDirectMusicPerformance8 *	iface,
		IDirectSound **	dsound
	)

Definition at line 2316 of file performance.c.

{
    struct performance *This = unsafe_impl_from_IDirectMusicPerformance8(iface);
    if (!This || !(*dsound = This->dsound)) return E_FAIL;
    IDirectSound_AddRef(*dsound);
    return S_OK;
}

Referenced by wave_track_SetParam().

performance_get_message()

static struct message * performance_get_message ( struct performance *  This, DWORD *  timeout  )

static

Definition at line 100 of file performance.c.

{
    static const DWORD delivery_flags = DMUS_PMSGF_TOOL_IMMEDIATE | DMUS_PMSGF_TOOL_QUEUE | DMUS_PMSGF_TOOL_ATTIME;
    IDirectMusicPerformance *performance = (IDirectMusicPerformance *)&This->IDirectMusicPerformance8_iface;
    REFERENCE_TIME latency, offset = 0;
    struct message *message;
    struct list *ptr;
 
    if (!(ptr = list_head(&This->messages)))
        return NULL;
    message = LIST_ENTRY(ptr, struct message, entry);
 
    if (FAILED(IDirectMusicPerformance_GetLatencyTime(performance, &latency)))
        return NULL;
 
    switch (message->msg.dwFlags & delivery_flags)
    {
    default:
        WARN("No delivery flag found for message %p\n", &message->msg);
        break;
    case DMUS_PMSGF_TOOL_QUEUE:
        offset = This->dwBumperLength * 10000;
        /* fallthrough */
    case DMUS_PMSGF_TOOL_ATTIME:
        if (message->msg.rtTime >= offset && message->msg.rtTime - offset >= latency)
        {
            *timeout = (message->msg.rtTime - offset - latency) / 10000;
            return NULL;
        }
        break;
    }
 
    return message;
}

Referenced by message_thread_proc().

performance_GetBumperLength()

static HRESULT WINAPI performance_GetBumperLength ( IDirectMusicPerformance8 *  iface, DWORD *  pdwMilliSeconds  )

static

Definition at line 795 of file performance.c.

{
  struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
  TRACE("(%p, %p)\n", This, pdwMilliSeconds);
  if (NULL == pdwMilliSeconds) {
    return E_POINTER;
  }
  *pdwMilliSeconds = This->dwBumperLength;
  return S_OK;
}

performance_GetDefaultAudioPath()

static HRESULT WINAPI performance_GetDefaultAudioPath ( IDirectMusicPerformance8 *  iface, IDirectMusicAudioPath **  ret_iface  )

static

Definition at line 1826 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %p): semi-stub (%p)\n", This, ret_iface, This->pDefaultPath);
 
    if (!ret_iface) return E_POINTER;
    if (!This->audio_paths_enabled) return DMUS_E_AUDIOPATH_INACTIVE;
 
    if ((*ret_iface = This->pDefaultPath)) IDirectMusicAudioPath_AddRef(*ret_iface);
 
    return S_OK;
}

performance_GetGlobalParam()

static HRESULT WINAPI performance_GetGlobalParam ( IDirectMusicPerformance8 *  iface, REFGUID  rguidType, void *  pParam, DWORD  dwSize  )

static

Definition at line 1336 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    TRACE("(%p, %s, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), pParam, dwSize);
 
    if (IsEqualGUID (rguidType, &GUID_PerfAutoDownload))
        memcpy(pParam, &This->fAutoDownload, sizeof(This->fAutoDownload));
    if (IsEqualGUID (rguidType, &GUID_PerfMasterGrooveLevel))
        memcpy(pParam, &This->cMasterGrooveLevel, sizeof(This->cMasterGrooveLevel));
    if (IsEqualGUID (rguidType, &GUID_PerfMasterTempo))
        memcpy(pParam, &This->fMasterTempo, sizeof(This->fMasterTempo));
    if (IsEqualGUID (rguidType, &GUID_PerfMasterVolume))
        memcpy(pParam, &This->lMasterVolume, sizeof(This->lMasterVolume));
 
    return S_OK;
}

performance_GetGraph()

static HRESULT WINAPI performance_GetGraph ( IDirectMusicPerformance8 *  iface, IDirectMusicGraph **  graph  )

static

Definition at line 1000 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    TRACE("(%p, %p)\n", This, graph);
 
    if (!graph)
        return E_POINTER;
 
    *graph = This->pToolGraph;
    if (This->pToolGraph) {
        IDirectMusicGraph_AddRef(*graph);
    }
 
    return *graph ? S_OK : DMUS_E_NOT_FOUND;
}

performance_GetLatencyTime()

static HRESULT WINAPI performance_GetLatencyTime ( IDirectMusicPerformance8 *  iface, REFERENCE_TIME *  ret_time  )

static

Definition at line 1382 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    REFERENCE_TIME current_time;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", This, ret_time);
 
    if (SUCCEEDED(hr = IDirectMusicPerformance8_GetTime(iface, &current_time, NULL)))
        *ret_time = current_time + This->latency_offset;
 
    return hr;
}

performance_GetNotificationPMsg()

static HRESULT WINAPI performance_GetNotificationPMsg ( IDirectMusicPerformance8 *  iface, DMUS_NOTIFICATION_PMSG **  ret_msg  )

static

Definition at line 1050 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct list *entry;
 
    TRACE("(%p, %p)\n", This, ret_msg);
 
    if (!ret_msg) return E_POINTER;
 
    EnterCriticalSection(&This->safe);
    if ((entry = list_head(&This->notifications)))
    {
        struct message *message = LIST_ENTRY(entry, struct message, entry);
        list_remove(&message->entry);
        list_init(&message->entry);
        *ret_msg = (DMUS_NOTIFICATION_PMSG *)&message->msg;
    }
    LeaveCriticalSection(&This->safe);
 
    return entry ? S_OK : S_FALSE;
}

performance_GetParam()

static HRESULT WINAPI performance_GetParam ( IDirectMusicPerformance8 *  iface, REFGUID  type, DWORD  group, DWORD  index, MUSIC_TIME  music_time, MUSIC_TIME *  next_time, void *  param  )

static

Definition at line 1305 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    HRESULT hr;
 
    TRACE("(%p, %s, %ld, %ld, %ld, %p, %p)\n", This, debugstr_dmguid(type), group, index, music_time, next_time, param);
 
    if (next_time) *next_time = 0;
 
    if (!This->control_segment) hr = DMUS_E_NOT_FOUND;
    else hr = IDirectMusicSegment_GetParam(This->control_segment, type, group, index, music_time, next_time, param);
 
    if (FAILED(hr))
    {
        if (!This->primary_segment) hr = DMUS_E_NOT_FOUND;
        else hr = IDirectMusicSegment_GetParam(This->primary_segment, type, group, index, music_time, next_time, param);
    }
 
    return hr;
}

performance_GetParamEx()

static HRESULT WINAPI performance_GetParamEx ( IDirectMusicPerformance8 *  iface, REFGUID  rguidType, DWORD  dwTrackID, DWORD  dwGroupBits, DWORD  dwIndex, MUSIC_TIME  mtTime, MUSIC_TIME *  pmtNext, void *  pParam  )

static

Definition at line 1841 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %s, %ld, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwTrackID, dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
 
    return S_OK;
}

performance_GetPrepareTime()

static HRESULT WINAPI performance_GetPrepareTime ( IDirectMusicPerformance8 *  iface, DWORD *  pdwMilliSeconds  )

static

Definition at line 774 of file performance.c.

{
  struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
  TRACE("(%p, %p)\n", This, pdwMilliSeconds);
  if (NULL == pdwMilliSeconds) {
    return E_POINTER;
  }
  *pdwMilliSeconds = This->dwPrepareTime;
  return S_OK;
}

performance_GetQueueTime()

static HRESULT WINAPI performance_GetQueueTime ( IDirectMusicPerformance8 *  iface, REFERENCE_TIME *  prtTime  )

static

Definition at line 1396 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %p): stub\n", This, prtTime);
    return S_OK;
}

performance_GetResolvedTime()

static HRESULT WINAPI performance_GetResolvedTime ( IDirectMusicPerformance8 *  iface, REFERENCE_TIME  rtTime, REFERENCE_TIME *  prtResolved, DWORD  dwTimeResolveFlags  )

static

Definition at line 1477 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, 0x%s, %p, %ld): stub\n", This, wine_dbgstr_longlong(rtTime),
        prtResolved, dwTimeResolveFlags);
    return S_OK;
}

performance_GetSegmentState()

static HRESULT WINAPI performance_GetSegmentState ( IDirectMusicPerformance8 *  iface, IDirectMusicSegmentState **  state, MUSIC_TIME  time  )

static

Definition at line 732 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct list *ptr, states = LIST_INIT(states);
    struct state_entry *entry, *next;
    HRESULT hr = S_OK;
 
    TRACE("(%p, %p, %ld)\n", This, state, time);
 
    if (!state) return E_POINTER;
 
    EnterCriticalSection(&This->safe);
 
    enum_segment_states(This, This->primary_segment, &states);
 
    if (!(ptr = list_head(&states))) hr = DMUS_E_NOT_FOUND;
    else
    {
        entry = LIST_ENTRY(ptr, struct state_entry, entry);
 
        *state = entry->state;
        IDirectMusicSegmentState_AddRef(entry->state);
 
        LIST_FOR_EACH_ENTRY_SAFE(entry, next, &states, struct state_entry, entry)
            state_entry_destroy(entry);
    }
 
    LeaveCriticalSection(&This->safe);
 
    return hr;
}

performance_GetTime()

static HRESULT WINAPI performance_GetTime ( IDirectMusicPerformance8 *  iface, REFERENCE_TIME *  time, MUSIC_TIME *  music_time  )

static

Definition at line 940 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    REFERENCE_TIME now;
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", iface, time, music_time);
 
    if (!This->master_clock) return DMUS_E_NO_MASTER_CLOCK;
    if (FAILED(hr = IReferenceClock_GetTime(This->master_clock, &now))) return hr;
 
    if (time) *time = now;
    if (music_time) hr = IDirectMusicPerformance8_ReferenceToMusicTime(iface, now, music_time);
 
    return hr;
}

performance_graph_AddRef()

static ULONG WINAPI performance_graph_AddRef ( IDirectMusicGraph *  iface )

static

Definition at line 1919 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicGraph(iface);
    return IDirectMusicPerformance8_AddRef(&This->IDirectMusicPerformance8_iface);
}

performance_graph_GetTool()

static HRESULT WINAPI performance_graph_GetTool ( IDirectMusicGraph *  iface, DWORD  index, IDirectMusicTool **  tool  )

static

Definition at line 1979 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicGraph(iface);
    TRACE("(%p, %lu, %p)\n", This, index, tool);
    return E_NOTIMPL;
}

performance_graph_InsertTool()

static HRESULT WINAPI performance_graph_InsertTool ( IDirectMusicGraph *  iface, IDirectMusicTool *  tool, DWORD *  channels, DWORD  channels_count, LONG  index  )

static

Definition at line 1971 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicGraph(iface);
    TRACE("(%p, %p, %p, %lu, %ld)\n", This, tool, channels, channels_count, index);
    return E_NOTIMPL;
}

performance_graph_QueryInterface()

static HRESULT WINAPI performance_graph_QueryInterface ( IDirectMusicGraph *  iface, REFIID  riid, void **  ret_iface  )

static

Definition at line 1913 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicGraph(iface);
    return IDirectMusicPerformance8_QueryInterface(&This->IDirectMusicPerformance8_iface, riid, ret_iface);
}

performance_graph_Release()

static ULONG WINAPI performance_graph_Release ( IDirectMusicGraph *  iface )

static

Definition at line 1925 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicGraph(iface);
    return IDirectMusicPerformance8_Release(&This->IDirectMusicPerformance8_iface);
}

performance_graph_RemoveTool()

static HRESULT WINAPI performance_graph_RemoveTool ( IDirectMusicGraph *  iface, IDirectMusicTool *  tool  )

static

Definition at line 1986 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicGraph(iface);
    TRACE("(%p, %p)\n", This, tool);
    return E_NOTIMPL;
}

performance_graph_StampPMsg()

static HRESULT WINAPI performance_graph_StampPMsg ( IDirectMusicGraph *  iface, DMUS_PMSG *  msg  )

static

Definition at line 1931 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicGraph(iface);
    HRESULT hr;
 
    TRACE("(%p, %p)\n", This, msg);
 
    if (!msg) return E_POINTER;
 
    /* FIXME: Implement segment and audio path graphs support */
    if (!This->pToolGraph) hr = DMUS_S_LAST_TOOL;
    else if (FAILED(hr = IDirectMusicGraph_StampPMsg(This->pToolGraph, msg))) return hr;
 
    if (msg->pGraph)
    {
        IDirectMusicTool_Release(msg->pGraph);
        msg->pGraph = NULL;
    }
 
    if (hr == DMUS_S_LAST_TOOL)
    {
        const DWORD delivery_flags = DMUS_PMSGF_TOOL_IMMEDIATE | DMUS_PMSGF_TOOL_QUEUE | DMUS_PMSGF_TOOL_ATTIME;
        msg->dwFlags &= ~delivery_flags;
        msg->dwFlags |= DMUS_PMSGF_TOOL_QUEUE;
 
        if (msg->pTool) IDirectMusicTool_Release(msg->pTool);
        msg->pTool = &This->IDirectMusicTool_iface;
        IDirectMusicTool_AddRef(msg->pTool);
        return S_OK;
    }
 
    if (SUCCEEDED(hr))
    {
        msg->pGraph = &This->IDirectMusicGraph_iface;
        IDirectMusicTool_AddRef(msg->pGraph);
    }
 
    return hr;
}

performance_Init()

static HRESULT WINAPI performance_Init ( IDirectMusicPerformance8 *  iface, IDirectMusic **  dmusic, IDirectSound *  dsound, HWND  hwnd  )

static

Definition at line 521 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    HRESULT hr;
 
    TRACE("(%p, %p, %p, %p)\n", iface, dmusic, dsound, hwnd);
 
    if (This->dmusic) return DMUS_E_ALREADY_INITED;
 
    if ((This->dsound = dsound)) IDirectMusic8_AddRef(This->dsound);
    else if (FAILED(hr = performance_init_dsound(This, hwnd))) return hr;
 
    if (dmusic && (This->dmusic = *dmusic)) IDirectMusic_AddRef(This->dmusic);
    else if (FAILED(hr = performance_init_dmusic(This, This->dsound)))
    {
        IDirectMusicPerformance_CloseDown(iface);
        return hr;
    }
 
    if (FAILED(hr = IDirectMusic_GetMasterClock(This->dmusic, NULL, &This->master_clock))
            || FAILED(hr = IDirectMusicPerformance8_GetTime(iface, &This->init_time, NULL)))
    {
        IDirectMusicPerformance_CloseDown(iface);
        return hr;
    }
 
    if (!(This->message_thread = CreateThread(NULL, 0, message_thread_proc, This, 0, NULL)))
    {
        ERR("Failed to start performance message thread, error %lu\n", GetLastError());
        IDirectMusicPerformance_CloseDown(iface);
        return HRESULT_FROM_WIN32(GetLastError());
    }
 
    if (dmusic && !*dmusic)
    {
        *dmusic = This->dmusic;
        IDirectMusic_AddRef(*dmusic);
    }
    return S_OK;
}

performance_init_dmusic()

static HRESULT performance_init_dmusic ( struct performance *  This, IDirectSound *  dsound  )

static

Definition at line 475 of file performance.c.

{
    IDirectMusic *dmusic;
    HRESULT hr;
 
    if (FAILED(hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER,
            &IID_IDirectMusic8, (void **)&dmusic)))
        return hr;
 
    hr = IDirectMusic_SetDirectSound(dmusic, dsound, NULL);
 
    if (SUCCEEDED(hr)) This->dmusic = dmusic;
    else IDirectSound_Release(dmusic);
 
    return hr;
}

Referenced by performance_Init().

performance_init_dsound()

static HRESULT performance_init_dsound ( struct performance *  This, HWND  hwnd  )

static

Definition at line 459 of file performance.c.

{
    IDirectSound *dsound;
    HRESULT hr;
 
    if (FAILED(hr = DirectSoundCreate(NULL, &dsound, NULL))) return hr;
 
    if (!hwnd) hwnd = GetForegroundWindow();
    hr = IDirectSound_SetCooperativeLevel(dsound, hwnd, DSSCL_PRIORITY);
 
    if (SUCCEEDED(hr)) This->dsound = dsound;
    else IDirectSound_Release(dsound);
 
    return hr;
}

Referenced by performance_Init().

performance_InitAudio()

static HRESULT WINAPI performance_InitAudio ( IDirectMusicPerformance8 *  iface, IDirectMusic **  dmusic, IDirectSound **  dsound, HWND  hwnd, DWORD  default_path_type, DWORD  num_channels, DWORD  flags, DMUS_AUDIOPARAMS *  params  )

static

Definition at line 1524 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    HRESULT hr = S_OK;
 
    TRACE("(%p, %p, %p, %p, %lx, %lu, %lx, %p)\n", This, dmusic, dsound, hwnd, default_path_type,
            num_channels, flags, params);
 
    if (flags) FIXME("flags parameter not used\n");
    if (params) FIXME("params parameter not used\n");
 
    if (FAILED(hr = IDirectMusicPerformance8_Init(iface, dmusic && *dmusic ? dmusic : NULL,
            dsound ? *dsound : NULL, hwnd)))
        return hr;
 
    This->audio_paths_enabled = TRUE;
    if (default_path_type)
    {
        hr = IDirectMusicPerformance8_CreateStandardAudioPath(iface, default_path_type,
                num_channels, FALSE, &This->pDefaultPath);
        if (FAILED(hr))
        {
            IDirectMusicPerformance_CloseDown(iface);
            return hr;
        }
    }
 
    if (dsound && !*dsound) {
        *dsound = This->dsound;
        IDirectSound_AddRef(*dsound);
    }
    if (dmusic && !*dmusic) {
        *dmusic = This->dmusic;
        IDirectMusic_AddRef(*dmusic);
    }
 
    return S_OK;
}

performance_Invalidate()

static HRESULT WINAPI performance_Invalidate ( IDirectMusicPerformance8 *  iface, MUSIC_TIME  mtTime, DWORD  dwFlags  )

static

Definition at line 1297 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %ld, %ld): stub\n", This, mtTime, dwFlags);
    return S_OK;
}

performance_IsPlaying()

static HRESULT WINAPI performance_IsPlaying ( IDirectMusicPerformance8 *  iface, IDirectMusicSegment *  pSegment, IDirectMusicSegmentState *  pSegState  )

static

Definition at line 931 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %p, %p): stub\n", This, pSegment, pSegState);
    return S_FALSE;
}

performance_MIDIToMusic()

static HRESULT WINAPI performance_MIDIToMusic ( IDirectMusicPerformance8 *  iface, BYTE  bMIDIValue, DMUS_CHORD_KEY *  pChord, BYTE  bPlayMode, BYTE  bChordLevel, WORD *  pwMusicValue  )

static

Definition at line 1487 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %d, %p, %d, %d, %p): stub\n", This, bMIDIValue, pChord, bPlayMode, bChordLevel, pwMusicValue);
    return S_OK;
}

performance_MusicToMIDI()

static HRESULT WINAPI performance_MusicToMIDI ( IDirectMusicPerformance8 *  iface, WORD  wMusicValue, DMUS_CHORD_KEY *  pChord, BYTE  bPlayMode, BYTE  bChordLevel, BYTE *  pbMIDIValue  )

static

Definition at line 1496 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %d, %p, %d, %d, %p): stub\n", This, wMusicValue, pChord, bPlayMode, bChordLevel, pbMIDIValue);
    return S_OK;
}

performance_MusicToReferenceTime()

static HRESULT WINAPI performance_MusicToReferenceTime ( IDirectMusicPerformance8 *  iface, MUSIC_TIME  music_time, REFERENCE_TIME *  time  )

static

Definition at line 852 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    MUSIC_TIME tempo_time, next = 0;
    DMUS_TEMPO_PARAM param;
    double tempo, duration;
    HRESULT hr;
 
    TRACE("(%p, %ld, %p)\n", This, music_time, time);
 
    if (!time) return E_POINTER;
    *time = 0;
 
    if (!This->master_clock) return DMUS_E_NO_MASTER_CLOCK;
 
    EnterCriticalSection(&This->safe);
 
    for (tempo = 120.0, duration = tempo_time = 0; music_time > 0; tempo_time += next)
    {
        if (FAILED(hr = IDirectMusicPerformance_GetParam(iface, &GUID_TempoParam, -1, DMUS_SEG_ALLTRACKS,
                tempo_time, &next, &param)))
            break;
 
        if (!next) next = music_time;
        else next = min(next, music_time);
 
        if (param.mtTime <= 0) tempo = param.dblTempo;
        duration += (600000000.0 * next) / (tempo * DMUS_PPQ);
        music_time -= next;
    }
 
    duration += (600000000.0 * music_time) / (tempo * DMUS_PPQ);
    *time = This->init_time + duration;
 
    LeaveCriticalSection(&This->safe);
 
    return S_OK;
}

performance_PChannelInfo()

static HRESULT WINAPI performance_PChannelInfo ( IDirectMusicPerformance8 *  iface, DWORD  channel_num, IDirectMusicPort **  port, DWORD *  midi_group, DWORD *  midi_channel  )

static

Definition at line 1256 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct channel *channel;
 
    TRACE("(%p)->(%ld, %p, %p, %p)\n", This, channel_num, port, midi_group, midi_channel);
 
    if (!(channel = performance_get_channel(This, channel_num))) return E_INVALIDARG;
    if (port)
    {
        *port = channel->port;
        IDirectMusicPort_AddRef(*port);
    }
    if (midi_group) *midi_group = channel->midi_group;
    if (midi_channel) *midi_channel = channel->midi_channel;
 
    return S_OK;
}

performance_PlaySegment()

static HRESULT WINAPI performance_PlaySegment ( IDirectMusicPerformance8 *  iface, IDirectMusicSegment *  segment, DWORD  segment_flags, INT64  start_time, IDirectMusicSegmentState **  ret_state  )

static

Definition at line 563 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    TRACE("(%p, %p, %ld, %I64d, %p)\n", This, segment, segment_flags, start_time, ret_state);
 
    return IDirectMusicPerformance8_PlaySegmentEx(iface, (IUnknown *)segment, NULL, NULL,
            segment_flags, start_time, ret_state, NULL, NULL);
}

performance_PlaySegmentEx()

static HRESULT WINAPI performance_PlaySegmentEx ( IDirectMusicPerformance8 *  iface, IUnknown *  source, WCHAR *  segment_name, IUnknown *  transition, DWORD  segment_flags, INT64  start_time, IDirectMusicSegmentState **  segment_state, IUnknown *  from, IUnknown *  audio_path  )

static

Definition at line 1565 of file performance.c.

{
    BOOL primary = !(segment_flags & DMUS_SEGF_SECONDARY), control = (segment_flags & DMUS_SEGF_CONTROL);
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    IDirectMusicSegmentState *state;
    IDirectMusicSegment *segment;
    MUSIC_TIME music_time;
    HRESULT hr;
 
    FIXME("(%p, %p, %s, %p, %#lx, %I64d, %p, %p, %p): stub\n", This, source, debugstr_w(segment_name),
            transition, segment_flags, start_time, segment_state, from, audio_path);
 
    /* NOTE: The time is in music time unless the DMUS_SEGF_REFTIME flag is set. */
    if (segment_flags) FIXME("flags %#lx not implemented\n", segment_flags);
    if (start_time) FIXME("start_time %I64d not implemented\n", start_time);
 
    if (FAILED(hr = IUnknown_QueryInterface(source, &IID_IDirectMusicSegment, (void **)&segment)))
        return hr;
 
    EnterCriticalSection(&This->safe);
 
    if (primary) performance_set_primary_segment(This, segment);
    if (control) performance_set_control_segment(This, segment);
 
    if ((!(music_time = start_time) && FAILED(hr = IDirectMusicPerformance8_GetTime(iface, NULL, &music_time)))
            || FAILED(hr = segment_state_create(segment, music_time, iface, &state)))
    {
        if (primary) performance_set_primary_segment(This, NULL);
        if (control) performance_set_control_segment(This, NULL);
        LeaveCriticalSection(&This->safe);
 
        IDirectMusicSegment_Release(segment);
        return hr;
    }
 
    if (FAILED(hr = segment_state_play(state, iface)))
    {
        ERR("Failed to play segment state, hr %#lx\n", hr);
        if (primary) performance_set_primary_segment(This, NULL);
        if (control) performance_set_control_segment(This, NULL);
    }
    else if (segment_state)
    {
        *segment_state = state;
        IDirectMusicSegmentState_AddRef(state);
    }
 
    LeaveCriticalSection(&This->safe);
 
    IDirectMusicSegmentState_Release(state);
    IDirectMusicSegment_Release(segment);
    return hr;
}

performance_process_message()

static HRESULT performance_process_message ( struct performance *  This, DMUS_PMSG *  msg  )

static

Definition at line 135 of file performance.c.

{
    IDirectMusicPerformance *performance = (IDirectMusicPerformance *)&This->IDirectMusicPerformance8_iface;
    IDirectMusicTool *tool;
    HRESULT hr;
 
    if (!(tool = msg->pTool)) tool = &This->IDirectMusicTool_iface;
 
    hr = IDirectMusicTool_ProcessPMsg(tool, performance, msg);
 
    if (hr == DMUS_S_FREE) hr = IDirectMusicPerformance_FreePMsg(performance, msg);
    if (FAILED(hr)) WARN("Failed to process message, hr %#lx\n", hr);
    return hr;
}

Referenced by message_thread_proc(), and performance_queue_message().

performance_QueryInterface()

static HRESULT WINAPI performance_QueryInterface ( IDirectMusicPerformance8 *  iface, REFIID  riid, void **  ret_iface  )

static

Definition at line 397 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    TRACE("(%p, %s, %p)\n", iface, debugstr_dmguid(riid), ret_iface);
 
    if (IsEqualGUID(riid, &IID_IUnknown)
            || IsEqualGUID(riid, &IID_IDirectMusicPerformance)
            || IsEqualGUID(riid, &IID_IDirectMusicPerformance2)
            || IsEqualGUID(riid, &IID_IDirectMusicPerformance8))
    {
        *ret_iface = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
 
    if (IsEqualGUID(riid, &IID_IDirectMusicGraph))
    {
        *ret_iface = &This->IDirectMusicGraph_iface;
        IDirectMusicGraph_AddRef(&This->IDirectMusicGraph_iface);
        return S_OK;
    }
 
    if (IsEqualGUID(riid, &IID_IDirectMusicTool))
    {
        *ret_iface = &This->IDirectMusicTool_iface;
        IDirectMusicTool_AddRef(&This->IDirectMusicTool_iface);
        return S_OK;
    }
 
    *ret_iface = NULL;
    WARN("(%p, %s, %p): not found\n", iface, debugstr_dmguid(riid), ret_iface);
    return E_NOINTERFACE;
}

performance_queue_message()

static HRESULT performance_queue_message ( struct performance *  This, struct message *  message  )

static

Definition at line 150 of file performance.c.

{
    static const DWORD delivery_flags = DMUS_PMSGF_TOOL_IMMEDIATE | DMUS_PMSGF_TOOL_QUEUE | DMUS_PMSGF_TOOL_ATTIME;
    struct message *prev;
    HRESULT hr;
 
    while ((message->msg.dwFlags & delivery_flags) == DMUS_PMSGF_TOOL_IMMEDIATE)
    {
        hr = performance_process_message(This, &message->msg);
        if (hr != DMUS_S_REQUEUE)
            return hr;
    }
 
    LIST_FOR_EACH_ENTRY_REV(prev, &This->messages, struct message, entry)
    {
        if (&prev->entry == &This->messages) break;
        if (prev->msg.rtTime <= message->msg.rtTime) break;
    }
 
    list_add_after(&prev->entry, &message->entry);
 
    return S_OK;
}

Referenced by message_thread_proc(), and performance_SendPMsg().

performance_ReferenceToMusicTime()

static HRESULT WINAPI performance_ReferenceToMusicTime ( IDirectMusicPerformance8 *  iface, REFERENCE_TIME  time, MUSIC_TIME *  music_time  )

static

Definition at line 892 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    MUSIC_TIME tempo_time, next = 0;
    double tempo, duration, step;
    DMUS_TEMPO_PARAM param;
    HRESULT hr;
 
    TRACE("(%p, %I64d, %p)\n", This, time, music_time);
 
    if (!music_time) return E_POINTER;
    *music_time = 0;
 
    if (!This->master_clock) return DMUS_E_NO_MASTER_CLOCK;
 
    EnterCriticalSection(&This->safe);
 
    duration = time - This->init_time;
 
    for (tempo = 120.0, tempo_time = 0; duration > 0; tempo_time += next, duration -= step)
    {
        if (FAILED(hr = IDirectMusicPerformance_GetParam(iface, &GUID_TempoParam, -1, DMUS_SEG_ALLTRACKS,
                tempo_time, &next, &param)))
            break;
 
        if (param.mtTime <= 0) tempo = param.dblTempo;
        step = (600000000.0 * next) / (tempo * DMUS_PPQ);
        if (!next || duration < step) break;
        *music_time = *music_time + next;
    }
 
    *music_time = *music_time + round((duration * tempo * DMUS_PPQ) / 600000000.0);
 
    LeaveCriticalSection(&This->safe);
 
    return S_OK;
}

performance_Release()

static ULONG WINAPI performance_Release ( IDirectMusicPerformance8 *  iface )

static

Definition at line 442 of file performance.c.

{
  struct performance *This = impl_from_IDirectMusicPerformance8(iface);
  ULONG ref = InterlockedDecrement(&This->ref);
 
  TRACE("(%p): ref=%ld\n", This, ref);
  
  if (ref == 0) {
    wine_rb_destroy(&This->channel_blocks, channel_block_free, NULL);
    This->safe.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&This->safe);
    free(This);
  }
 
  return ref;
}

performance_RemoveNotificationType()

static HRESULT WINAPI performance_RemoveNotificationType ( IDirectMusicPerformance8 *  iface, REFGUID  type  )

static

Definition at line 1094 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    HRESULT hr = S_FALSE;
 
    FIXME("(%p, %s): stub\n", This, debugstr_dmguid(type));
 
    if (IsEqualGUID(type, &GUID_NOTIFICATION_PERFORMANCE))
    {
        hr = This->notification_performance ? S_OK : S_FALSE;
        This->notification_performance = FALSE;
    }
    if (IsEqualGUID(type, &GUID_NOTIFICATION_SEGMENT))
    {
        hr = This->notification_segment ? S_OK : S_FALSE;
        This->notification_segment = FALSE;
    }
 
    return hr;
}

performance_RemovePort()

static HRESULT WINAPI performance_RemovePort ( IDirectMusicPerformance8 *  iface, IDirectMusicPort *  pPort  )

static

Definition at line 1202 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    if (This->audio_paths_enabled) return DMUS_E_AUDIOPATHS_IN_USE;
 
    FIXME("(%p, %p): stub\n", This, pPort);
    IDirectMusicPort_Release(pPort);
    return S_OK;
}

performance_RhythmToTime()

static HRESULT WINAPI performance_RhythmToTime ( IDirectMusicPerformance8 *  iface, WORD  wMeasure, BYTE  bBeat, BYTE  bGrid, short  nOffset, DMUS_TIMESIGNATURE *  pTimeSig, MUSIC_TIME *  pmtTime  )

static

Definition at line 1514 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %d, %d, %d, %i, %p, %p): stub\n", This, wMeasure, bBeat, bGrid, nOffset, pTimeSig, pmtTime);
    return S_OK;
}

performance_send_midi_pmsg()

static HRESULT performance_send_midi_pmsg ( struct performance *  This, DMUS_PMSG *  msg, UINT  flags, BYTE  status, BYTE  byte1, BYTE  byte2  )

static

Definition at line 492 of file performance.c.

{
    IDirectMusicPerformance8 *performance = &This->IDirectMusicPerformance8_iface;
    DMUS_MIDI_PMSG *midi;
    HRESULT hr;
 
    if (FAILED(hr = IDirectMusicPerformance8_AllocPMsg(performance, sizeof(*midi),
            (DMUS_PMSG **)&midi)))
        return hr;
 
    if (flags & DMUS_PMSGF_REFTIME) midi->rtTime = msg->rtTime;
    if (flags & DMUS_PMSGF_MUSICTIME) midi->mtTime = msg->mtTime;
    midi->dwFlags = flags;
    midi->dwPChannel = msg->dwPChannel;
    midi->dwVirtualTrackID = msg->dwVirtualTrackID;
    midi->dwVoiceID = msg->dwVoiceID;
    midi->dwGroupID = msg->dwGroupID;
    midi->dwType = DMUS_PMSGT_MIDI;
    midi->bStatus = status;
    midi->bByte1 = byte1;
    midi->bByte2 = byte2;
 
    if (FAILED(hr = IDirectMusicPerformance8_SendPMsg(performance, (DMUS_PMSG *)midi)))
        IDirectMusicPerformance8_FreePMsg(performance, (DMUS_PMSG *)midi);
 
    return hr;
}

Referenced by performance_CloseDown(), performance_Stop(), and performance_tool_ProcessPMsg().

performance_send_notification_pmsg()

static HRESULT performance_send_notification_pmsg ( struct performance *  This, MUSIC_TIME  music_time, BOOL  stamp, GUID  type, DWORD  option, IUnknown *  object  )

static

Definition at line 231 of file performance.c.

{
    IDirectMusicPerformance8 *performance = &This->IDirectMusicPerformance8_iface;
    IDirectMusicGraph *graph = &This->IDirectMusicGraph_iface;
    DMUS_NOTIFICATION_PMSG *msg;
    HRESULT hr;
 
    if (FAILED(hr = IDirectMusicPerformance8_AllocPMsg(performance, sizeof(*msg), (DMUS_PMSG **)&msg)))
        return hr;
 
    msg->mtTime = music_time;
    msg->dwFlags = DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE;
    msg->dwType = DMUS_PMSGT_NOTIFICATION;
    if ((msg->punkUser = object)) IUnknown_AddRef(object);
    msg->guidNotificationType = type;
    msg->dwNotificationOption = option;
 
    /* only stamp the message if notifications are enabled, otherwise send them directly to the output tool */
    if ((stamp && FAILED(hr = IDirectMusicGraph_StampPMsg(graph, (DMUS_PMSG *)msg)))
            || FAILED(hr = IDirectMusicPerformance8_SendPMsg(performance, (DMUS_PMSG *)msg)))
        IDirectMusicPerformance8_FreePMsg(performance, (DMUS_PMSG *)msg);
 
    return hr;
}

Referenced by performance_send_segment_end(), performance_send_segment_start(), and performance_Stop().

performance_send_pmsg()

static HRESULT performance_send_pmsg ( struct performance *  This, MUSIC_TIME  music_time, DWORD  flags, DWORD  type, IUnknown *  object  )

static

Definition at line 208 of file performance.c.

{
    IDirectMusicPerformance8 *performance = &This->IDirectMusicPerformance8_iface;
    IDirectMusicGraph *graph = &This->IDirectMusicGraph_iface;
    DMUS_PMSG *msg;
    HRESULT hr;
 
    if (FAILED(hr = IDirectMusicPerformance8_AllocPMsg(performance, sizeof(*msg), &msg)))
        return hr;
 
    msg->mtTime = music_time;
    msg->dwFlags = DMUS_PMSGF_MUSICTIME | flags;
    msg->dwType = type;
    if ((msg->punkUser = object)) IUnknown_AddRef(object);
 
    if ((type < DMUS_PMSGT_INTERNAL_FIRST && FAILED(hr = IDirectMusicGraph_StampPMsg(graph, msg)))
            || FAILED(hr = IDirectMusicPerformance8_SendPMsg(performance, msg)))
        IDirectMusicPerformance8_FreePMsg(performance, msg);
 
    return hr;
}

Referenced by performance_send_segment_end(), performance_send_segment_start(), and performance_send_segment_tick().

performance_send_segment_end()

HRESULT performance_send_segment_end	(	IDirectMusicPerformance8 *	iface,
		MUSIC_TIME	music_time,
		IDirectMusicSegmentState *	state,
		BOOL	abort
	)

Definition at line 355 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    HRESULT hr;
 
    if (!abort)
    {
        if (FAILED(hr = performance_send_notification_pmsg(This, music_time - 1450, This->notification_segment,
                GUID_NOTIFICATION_SEGMENT, DMUS_NOTIFICATION_SEGALMOSTEND, (IUnknown *)state)))
            return hr;
        if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_segment,
                GUID_NOTIFICATION_SEGMENT, DMUS_NOTIFICATION_SEGEND, (IUnknown *)state)))
            return hr;
    }
 
    if (FAILED(hr = performance_send_pmsg(This, music_time, DMUS_PMSGF_TOOL_IMMEDIATE,
            DMUS_PMSGT_DIRTY, NULL)))
        return hr;
    if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_performance,
            GUID_NOTIFICATION_PERFORMANCE, DMUS_NOTIFICATION_MUSICSTOPPED, NULL)))
        return hr;
    if (FAILED(hr = performance_send_pmsg(This, music_time, abort ? DMUS_PMSGF_TOOL_IMMEDIATE : DMUS_PMSGF_TOOL_ATTIME,
            DMUS_PMSGT_INTERNAL_SEGMENT_END, (IUnknown *)state)))
        return hr;
 
    return S_OK;
}

Referenced by segment_state_play_chunk(), and segment_state_stop().

performance_send_segment_start()

HRESULT performance_send_segment_start	(	IDirectMusicPerformance8 *	iface,
		MUSIC_TIME	music_time,
		IDirectMusicSegmentState *	state
	)

Definition at line 318 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    HRESULT hr;
 
    if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_performance,
            GUID_NOTIFICATION_PERFORMANCE, DMUS_NOTIFICATION_MUSICSTARTED, NULL)))
        return hr;
    if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_segment,
            GUID_NOTIFICATION_SEGMENT, DMUS_NOTIFICATION_SEGSTART, (IUnknown *)state)))
        return hr;
    if (FAILED(hr = performance_send_pmsg(This, music_time, DMUS_PMSGF_TOOL_IMMEDIATE,
            DMUS_PMSGT_DIRTY, NULL)))
        return hr;
 
    return S_OK;
}

Referenced by segment_state_play().

performance_send_segment_tick()

HRESULT performance_send_segment_tick	(	IDirectMusicPerformance8 *	iface,
		MUSIC_TIME	music_time,
		IDirectMusicSegmentState *	state
	)

Definition at line 337 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    REFERENCE_TIME time;
    HRESULT hr;
 
    if (FAILED(hr = IDirectMusicPerformance8_MusicToReferenceTime(iface, music_time, &time)))
        return hr;
    if (FAILED(hr = IDirectMusicPerformance8_ReferenceToMusicTime(iface, time + 2000000, &music_time)))
        return hr;
    if (FAILED(hr = performance_send_pmsg(This, music_time, DMUS_PMSGF_TOOL_QUEUE,
            DMUS_PMSGT_INTERNAL_SEGMENT_TICK, (IUnknown *)state)))
        return hr;
 
    return S_OK;
}

Referenced by segment_state_play().

performance_SendPMsg()

static HRESULT WINAPI performance_SendPMsg ( IDirectMusicPerformance8 *  iface, DMUS_PMSG *  msg  )

static

Definition at line 807 of file performance.c.

{
    const DWORD delivery_flags = DMUS_PMSGF_TOOL_IMMEDIATE | DMUS_PMSGF_TOOL_QUEUE | DMUS_PMSGF_TOOL_ATTIME;
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct message *message;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", This, msg);
 
    if (!(message = message_from_DMUS_PMSG(msg))) return E_POINTER;
    if (!This->dmusic) return DMUS_E_NO_MASTER_CLOCK;
    if (!(msg->dwFlags & (DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_REFTIME))) return E_INVALIDARG;
 
    EnterCriticalSection(&This->safe);
 
    if (!list_empty(&message->entry))
        hr = DMUS_E_ALREADY_SENT;
    else
    {
        if (!(msg->dwFlags & delivery_flags)) msg->dwFlags |= DMUS_PMSGF_TOOL_IMMEDIATE;
        if (!(msg->dwFlags & DMUS_PMSGF_MUSICTIME))
        {
            if (FAILED(hr = IDirectMusicPerformance8_ReferenceToMusicTime(iface,
                    msg->rtTime, &msg->mtTime)))
                goto done;
            msg->dwFlags |= DMUS_PMSGF_MUSICTIME;
        }
        if (!(msg->dwFlags & DMUS_PMSGF_REFTIME))
        {
            if (FAILED(hr = IDirectMusicPerformance8_MusicToReferenceTime(iface,
                    msg->mtTime == -1 ? 0 : msg->mtTime, &msg->rtTime)))
                goto done;
            msg->dwFlags |= DMUS_PMSGF_REFTIME;
        }
 
        hr = performance_queue_message(This, message);
    }
 
done:
    LeaveCriticalSection(&This->safe);
    if (SUCCEEDED(hr)) WakeConditionVariable(&This->cond);
 
    return hr;
}

performance_set_control_segment()

static void performance_set_control_segment ( struct performance *  This, IDirectMusicSegment *  segment  )

static

Definition at line 390 of file performance.c.

{
    if (This->control_segment) IDirectMusicSegment_Release(This->control_segment);
    if ((This->control_segment = segment)) IDirectMusicSegment_AddRef(This->control_segment);
}

Referenced by performance_CloseDown(), and performance_PlaySegmentEx().

performance_set_primary_segment()

static void performance_set_primary_segment ( struct performance *  This, IDirectMusicSegment *  segment  )

static

Definition at line 384 of file performance.c.

{
    if (This->primary_segment) IDirectMusicSegment_Release(This->primary_segment);
    if ((This->primary_segment = segment)) IDirectMusicSegment_AddRef(This->primary_segment);
}

Referenced by performance_CloseDown(), and performance_PlaySegmentEx().

performance_SetBumperLength()

static HRESULT WINAPI performance_SetBumperLength ( IDirectMusicPerformance8 *  iface, DWORD  dwMilliSeconds  )

static

Definition at line 786 of file performance.c.

{
  struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
  TRACE("(%p, %ld)\n", This, dwMilliSeconds);
  This->dwBumperLength =  dwMilliSeconds;
  return S_OK;
}

performance_SetDefaultAudioPath()

static HRESULT WINAPI performance_SetDefaultAudioPath ( IDirectMusicPerformance8 *  iface, IDirectMusicAudioPath *  audio_path  )

static

Definition at line 1808 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %p): semi-stub\n", This, audio_path);
 
    if (!This->audio_paths_enabled) return DMUS_E_AUDIOPATH_INACTIVE;
 
    if (This->pDefaultPath) IDirectMusicAudioPath_Release(This->pDefaultPath);
    if ((This->pDefaultPath = audio_path))
    {
        IDirectMusicAudioPath_AddRef(This->pDefaultPath);
        set_audiopath_perf_pointer(This->pDefaultPath, iface);
    }
 
    return S_OK;
}

performance_SetGlobalParam()

static HRESULT WINAPI performance_SetGlobalParam ( IDirectMusicPerformance8 *  iface, REFGUID  rguidType, void *  pParam, DWORD  dwSize  )

static

Definition at line 1355 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    TRACE("(%p, %s, %p, %ld)\n", This, debugstr_dmguid(rguidType), pParam, dwSize);
 
    if (IsEqualGUID (rguidType, &GUID_PerfAutoDownload)) {
        memcpy(&This->fAutoDownload, pParam, dwSize);
        TRACE("=> AutoDownload set to %d\n", This->fAutoDownload);
    }
    if (IsEqualGUID (rguidType, &GUID_PerfMasterGrooveLevel)) {
        memcpy(&This->cMasterGrooveLevel, pParam, dwSize);
        TRACE("=> MasterGrooveLevel set to %i\n", This->cMasterGrooveLevel);
    }
    if (IsEqualGUID (rguidType, &GUID_PerfMasterTempo)) {
        memcpy(&This->fMasterTempo, pParam, dwSize);
        TRACE("=> MasterTempo set to %f\n", This->fMasterTempo);
    }
    if (IsEqualGUID (rguidType, &GUID_PerfMasterVolume)) {
        memcpy(&This->lMasterVolume, pParam, dwSize);
        TRACE("=> MasterVolume set to %li\n", This->lMasterVolume);
    }
 
    return S_OK;
}

performance_SetGraph()

static HRESULT WINAPI performance_SetGraph ( IDirectMusicPerformance8 *  iface, IDirectMusicGraph *  pGraph  )

static

Definition at line 1017 of file performance.c.

{
  struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
  FIXME("(%p, %p): to check\n", This, pGraph);
  
  if (NULL != This->pToolGraph) {
    /* Todo clean buffers and tools before */
    IDirectMusicGraph_Release(This->pToolGraph);
  }
  This->pToolGraph = pGraph;
  if (NULL != This->pToolGraph) {
    IDirectMusicGraph_AddRef(This->pToolGraph);
  }
  return S_OK;
}

performance_SetNotificationHandle()

static HRESULT WINAPI performance_SetNotificationHandle ( IDirectMusicPerformance8 *  iface, HANDLE  notification_event, REFERENCE_TIME  minimum_time  )

static

Definition at line 1034 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    TRACE("(%p, %p, %I64d)\n", This, notification_event, minimum_time);
 
    This->notification_event = notification_event;
    if (minimum_time)
        This->notification_timeout = minimum_time;
    else if (!This->notification_timeout)
        This->notification_timeout = 20000000; /* 2 seconds */
 
    return S_OK;
}

performance_SetParam()

static HRESULT WINAPI performance_SetParam ( IDirectMusicPerformance8 *  iface, REFGUID  rguidType, DWORD  dwGroupBits, DWORD  dwIndex, MUSIC_TIME  mtTime, void *  pParam  )

static

Definition at line 1327 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %s, %ld, %ld, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
    return S_OK;
}

performance_SetPrepareTime()

static HRESULT WINAPI performance_SetPrepareTime ( IDirectMusicPerformance8 *  iface, DWORD  dwMilliSeconds  )

static

Definition at line 765 of file performance.c.

{
  struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
  TRACE("(%p, %ld)\n", This, dwMilliSeconds);
  This->dwPrepareTime = dwMilliSeconds;
  return S_OK;
}

performance_Stop()

static HRESULT WINAPI performance_Stop ( IDirectMusicPerformance8 *  iface, IDirectMusicSegment *  segment, IDirectMusicSegmentState *  state, MUSIC_TIME  music_time, DWORD  flags  )

static

Definition at line 674 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicPerformance8(iface);
    struct list states = LIST_INIT(states);
    struct state_entry *entry, *next;
    DMUS_PMSG msg = {.mtTime = -1};
    HRESULT hr;
 
    FIXME("(%p, %p, %p, %ld, %ld): semi-stub\n", This, segment, state, music_time, flags);
 
    if (music_time) FIXME("time parameter %lu not implemented\n", music_time);
    if (flags != DMUS_SEGF_DEFAULT) FIXME("flags parameter %#lx not implemented\n", flags);
 
    if (!music_time && FAILED(hr = IDirectMusicPerformance8_GetTime(iface, NULL, &music_time)))
        return hr;
 
    EnterCriticalSection(&This->safe);
 
    if (!state)
        enum_segment_states(This, segment, &states);
    else if ((entry = malloc(sizeof(*entry))))
    {
        entry->state = state;
        IDirectMusicSegmentState_AddRef(entry->state);
        list_add_tail(&states, &entry->entry);
    }
 
    if (!segment && !state)
        performance_flush_messages(This, NULL);
    else LIST_FOR_EACH_ENTRY(entry, &states, struct state_entry, entry)
        performance_flush_messages(This, entry->state);
 
    LIST_FOR_EACH_ENTRY_SAFE(entry, next, &states, struct state_entry, entry)
    {
        if (FAILED(hr = performance_send_notification_pmsg(This, music_time, This->notification_segment,
                GUID_NOTIFICATION_SEGMENT, DMUS_NOTIFICATION_SEGABORT, (IUnknown *)entry->state)))
            ERR("Failed to send DMUS_NOTIFICATION_SEGABORT, hr %#lx\n", hr);
        if (FAILED(hr = segment_state_stop(entry->state, iface)))
            ERR("Failed to stop segment state, hr %#lx\n", hr);
 
        IDirectMusicSegmentState_Release(entry->state);
        list_remove(&entry->entry);
        free(entry);
    }
 
    if (!state && !segment)
    {
        if (FAILED(hr = performance_send_midi_pmsg(This, &msg, DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
                MIDI_SYSTEM_RESET, 0, 0)))
            ERR("Failed to send MIDI_SYSTEM_RESET message, hr %#lx\n", hr);
    }
 
    LeaveCriticalSection(&This->safe);
 
    return S_OK;
}

performance_StopEx()

static HRESULT WINAPI performance_StopEx ( IDirectMusicPerformance8 *  iface, IUnknown *  pObjectToStop, __int64  i64StopTime, DWORD  dwFlags  )

static

Definition at line 1621 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %p, 0x%s, %ld): stub\n", This, pObjectToStop,
        wine_dbgstr_longlong(i64StopTime), dwFlags);
    return S_OK;
}

performance_TimeToRhythm()

static HRESULT WINAPI performance_TimeToRhythm ( IDirectMusicPerformance8 *  iface, MUSIC_TIME  mtTime, DMUS_TIMESIGNATURE *  pTimeSig, WORD *  pwMeasure, BYTE *  pbBeat, BYTE *  pbGrid, short *  pnOffset  )

static

Definition at line 1505 of file performance.c.

{
        struct performance *This = impl_from_IDirectMusicPerformance8(iface);
 
    FIXME("(%p, %ld, %p, %p, %p, %p, %p): stub\n", This, mtTime, pTimeSig, pwMeasure, pbBeat, pbGrid, pnOffset);
    return S_OK;
}

performance_tool_AddRef()

static ULONG WINAPI performance_tool_AddRef ( IDirectMusicTool *  iface )

static

Definition at line 2015 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    return IDirectMusicPerformance8_AddRef(&This->IDirectMusicPerformance8_iface);
}

performance_tool_Flush()

static HRESULT WINAPI performance_tool_Flush ( IDirectMusicTool *  iface, IDirectMusicPerformance *  performance, DMUS_PMSG *  msg, REFERENCE_TIME  time  )

static

Definition at line 2257 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    FIXME("(%p, %p, %p, %I64d): stub\n", This, performance, msg, time);
    return E_NOTIMPL;
}

performance_tool_GetMediaTypeArraySize()

static HRESULT WINAPI performance_tool_GetMediaTypeArraySize ( IDirectMusicTool *  iface, DWORD *  size  )

static

Definition at line 2042 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    TRACE("(%p, %p)\n", This, size);
    *size = 0;
    return S_OK;
}

performance_tool_GetMediaTypes()

static HRESULT WINAPI performance_tool_GetMediaTypes ( IDirectMusicTool *  iface, DWORD **  types, DWORD  size  )

static

Definition at line 2050 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    TRACE("(%p, %p, %lu)\n", This, types, size);
    return E_NOTIMPL;
}

performance_tool_GetMsgDeliveryType()

static HRESULT WINAPI performance_tool_GetMsgDeliveryType ( IDirectMusicTool *  iface, DWORD *  type  )

static

Definition at line 2034 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    TRACE("(%p, %p)\n", This, type);
    *type = DMUS_PMSGF_TOOL_IMMEDIATE;
    return S_OK;
}

performance_tool_Init()

static HRESULT WINAPI performance_tool_Init ( IDirectMusicTool *  iface, IDirectMusicGraph *  graph  )

static

Definition at line 2027 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    TRACE("(%p, %p)\n", This, graph);
    return E_NOTIMPL;
}

performance_tool_ProcessPMsg()

static HRESULT WINAPI performance_tool_ProcessPMsg ( IDirectMusicTool *  iface, IDirectMusicPerformance *  performance, DMUS_PMSG *  msg  )

static

Definition at line 2057 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    struct message *message = message_from_DMUS_PMSG(msg);
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", This, performance, msg);
 
    switch (msg->dwType)
    {
    case DMUS_PMSGT_MIDI:
    {
        static const UINT event_size = sizeof(DMUS_EVENTHEADER) + sizeof(DWORD);
        DMUS_BUFFERDESC desc = {.dwSize = sizeof(desc), .cbBuffer = 2 * event_size};
        DMUS_MIDI_PMSG *midi = (DMUS_MIDI_PMSG *)msg;
        REFERENCE_TIME latency_time;
        IDirectMusicBuffer *buffer;
        IDirectMusicPort *port;
        DWORD group, channel;
        UINT value = 0;
 
        if (FAILED(hr = IDirectMusicPerformance_PChannelInfo(performance, msg->dwPChannel,
                &port, &group, &channel)))
        {
            WARN("Failed to get message port, hr %#lx\n", hr);
            return DMUS_S_FREE;
        }
        performance_update_latency_time(This, port, &latency_time);
 
        value |= channel;
        value |= (UINT)midi->bStatus;
        value |= (UINT)midi->bByte1 << 8;
        value |= (UINT)midi->bByte2 << 16;
 
        if (SUCCEEDED(hr = IDirectMusic_CreateMusicBuffer(This->dmusic, &desc, &buffer, NULL)))
        {
            if (msg->rtTime == -1) msg->rtTime = latency_time;
            hr = IDirectMusicBuffer_PackStructured(buffer, msg->rtTime, group, value);
            if (SUCCEEDED(hr)) hr = IDirectMusicPort_PlayBuffer(port, buffer);
            IDirectMusicBuffer_Release(buffer);
        }
 
        IDirectMusicPort_Release(port);
        break;
    }
 
    case DMUS_PMSGT_NOTE:
    {
        DMUS_NOTE_PMSG *note = (DMUS_NOTE_PMSG *)msg;
 
        msg->mtTime += note->nOffset;
 
        if (note->bFlags & DMUS_NOTEF_NOTEON)
        {
            if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
                    MIDI_NOTE_ON, note->bMidiValue, note->bVelocity)))
                WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
 
            if (note->mtDuration)
            {
                msg->mtTime -= note->nOffset;
                msg->mtTime += max(1, note->mtDuration - 1);
                if (FAILED(hr = IDirectMusicPerformance8_MusicToReferenceTime(performance, msg->mtTime, &msg->rtTime)))
                    return hr;
                note->bFlags &= ~DMUS_NOTEF_NOTEON;
                return DMUS_S_REQUEUE;
            }
        }
 
        if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
                MIDI_NOTE_OFF, note->bMidiValue, 0)))
            WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
 
        break;
    }
 
    case DMUS_PMSGT_CURVE:
    {
        DMUS_CURVE_PMSG *curve = (DMUS_CURVE_PMSG *)msg;
 
        msg->mtTime += curve->nOffset;
        switch (curve->bType)
        {
        case DMUS_CURVET_CCCURVE:
            if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
                    MIDI_CONTROL_CHANGE, curve->bCCData, curve->nStartValue)))
                WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
            break;
        case DMUS_CURVET_RPNCURVE:
        case DMUS_CURVET_NRPNCURVE:
        case DMUS_CURVET_MATCURVE:
        case DMUS_CURVET_PATCURVE:
        case DMUS_CURVET_PBCURVE:
            FIXME("Unhandled curve type %#x\n", curve->bType);
            break;
        default:
            WARN("Invalid curve type %#x\n", curve->bType);
            break;
        }
 
        break;
    }
 
    case DMUS_PMSGT_PATCH:
    {
        DMUS_PATCH_PMSG *patch = (DMUS_PATCH_PMSG *)msg;
 
        if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_REFTIME | DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
                MIDI_CONTROL_CHANGE, MIDI_CC_BANK_MSB, patch->byMSB)))
            WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
 
        if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_REFTIME | DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
                MIDI_CONTROL_CHANGE, MIDI_CC_BANK_LSB, patch->byLSB)))
            WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
 
        if (FAILED(hr = performance_send_midi_pmsg(This, msg, DMUS_PMSGF_REFTIME | DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_IMMEDIATE,
                MIDI_PROGRAM_CHANGE, patch->byInstrument, 0)))
            WARN("Failed to translate message to MIDI, hr %#lx\n", hr);
 
        break;
    }
 
    case DMUS_PMSGT_NOTIFICATION:
    {
        DMUS_NOTIFICATION_PMSG *notif = (DMUS_NOTIFICATION_PMSG *)msg;
        struct message *previous;
        BOOL enabled = FALSE;
 
        if (IsEqualGUID(&notif->guidNotificationType, &GUID_NOTIFICATION_PERFORMANCE))
            enabled = This->notification_performance;
        if (IsEqualGUID(&notif->guidNotificationType, &GUID_NOTIFICATION_SEGMENT))
            enabled = This->notification_segment;
        if (!enabled) return DMUS_S_FREE;
 
        if (msg->dwFlags & DMUS_PMSGF_TOOL_IMMEDIATE)
        {
            /* re-send the message for queueing at the expected time */
            msg->dwFlags &= ~DMUS_PMSGF_TOOL_IMMEDIATE;
            msg->dwFlags |= DMUS_PMSGF_TOOL_ATTIME;
 
            if (FAILED(hr = IDirectMusicPerformance8_SendPMsg(performance, msg)))
            {
                ERR("Failed to send notification message, hr %#lx\n", hr);
                return DMUS_S_FREE;
            }
 
            return S_OK;
        }
 
        list_add_tail(&This->notifications, &message->entry);
 
        /* discard old notification messages */
        do
        {
            previous = LIST_ENTRY(list_head(&This->notifications), struct message, entry);
            if (This->notification_timeout <= 0) break; /* negative values may be used to keep everything */
            if (message->msg.rtTime - previous->msg.rtTime <= This->notification_timeout) break;
            list_remove(&previous->entry);
            list_init(&previous->entry);
        } while (SUCCEEDED(hr = IDirectMusicPerformance_FreePMsg(performance, &previous->msg)));
 
        SetEvent(This->notification_event);
        return S_OK;
    }
 
    case DMUS_PMSGT_WAVE:
        if (FAILED(hr = IDirectSoundBuffer_Play((IDirectSoundBuffer *)msg->punkUser, 0, 0, 0)))
            WARN("Failed to play wave buffer, hr %#lx\n", hr);
        break;
 
    case DMUS_PMSGT_INTERNAL_SEGMENT_TICK:
        msg->rtTime += 10000000;
        msg->dwFlags &= ~DMUS_PMSGF_MUSICTIME;
 
        /* re-send the tick message until segment_state_tick returns S_FALSE */
        if (FAILED(hr = segment_state_tick((IDirectMusicSegmentState *)msg->punkUser,
                (IDirectMusicPerformance8 *)performance)))
            ERR("Failed to tick segment state %p, hr %#lx\n", msg->punkUser, hr);
        else if (hr == S_FALSE)
            return DMUS_S_FREE; /* done ticking */
        else if (FAILED(hr = IDirectMusicPerformance_SendPMsg(performance, msg)))
            ERR("Failed to queue tick for segment state %p, hr %#lx\n", msg->punkUser, hr);
 
        return S_OK;
 
    case DMUS_PMSGT_INTERNAL_SEGMENT_END:
        if (FAILED(hr = segment_state_end_play((IDirectMusicSegmentState *)msg->punkUser,
                (IDirectMusicPerformance8 *)performance)))
            WARN("Failed to end segment state %p, hr %#lx\n", msg->punkUser, hr);
        break;
 
    default:
        FIXME("Unhandled message type %#lx\n", msg->dwType);
        break;
    }
 
    return DMUS_S_FREE;
}

performance_tool_QueryInterface()

static HRESULT WINAPI performance_tool_QueryInterface ( IDirectMusicTool *  iface, REFIID  riid, void **  ret_iface  )

static

Definition at line 2009 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    return IDirectMusicPerformance8_QueryInterface(&This->IDirectMusicPerformance8_iface, riid, ret_iface);
}

performance_tool_Release()

static ULONG WINAPI performance_tool_Release ( IDirectMusicTool *  iface )

static

Definition at line 2021 of file performance.c.

{
    struct performance *This = impl_from_IDirectMusicTool(iface);
    return IDirectMusicPerformance8_Release(&This->IDirectMusicPerformance8_iface);
}

performance_update_latency_time()

static void performance_update_latency_time ( struct performance *  This, IDirectMusicPort *  port, REFERENCE_TIME *  ret_time  )

static

Definition at line 1115 of file performance.c.

{
    IDirectMusicPerformance8 *iface = &This->IDirectMusicPerformance8_iface;
    REFERENCE_TIME latency_time, current_time;
    IReferenceClock *latency_clock;
    HRESULT hr;
 
    if (!ret_time) ret_time = &latency_time;
    if (SUCCEEDED(hr = IDirectMusicPort_GetLatencyClock(port, &latency_clock)))
    {
        hr = IReferenceClock_GetTime(latency_clock, ret_time);
        if (SUCCEEDED(hr)) hr = IDirectMusicPerformance8_GetTime(iface, &current_time, NULL);
        if (SUCCEEDED(hr) && This->latency_offset < (*ret_time - current_time))
        {
            TRACE("Updating performance %p latency %I64d -> %I64d\n", This,
                    This->latency_offset, *ret_time - current_time);
            This->latency_offset = *ret_time - current_time;
        }
        IReferenceClock_Release(latency_clock);
    }
 
    if (FAILED(hr)) ERR("Failed to update performance %p latency, hr %#lx\n", This, hr);
}

Referenced by perf_dmport_create(), performance_AddPort(), and performance_tool_ProcessPMsg().

state_entry_destroy()

static void state_entry_destroy ( struct state_entry *  entry )

static

Definition at line 580 of file performance.c.

{
    list_remove(&entry->entry);
    IDirectMusicSegmentState_Release(entry->state);
    free(entry);
}

Referenced by performance_GetSegmentState().

unsafe_impl_from_IDirectMusicPerformance8()

static struct performance * unsafe_impl_from_IDirectMusicPerformance8 ( IDirectMusicPerformance8 *  iface )

inlinestatic

Definition at line 2310 of file performance.c.

{
    if (iface->lpVtbl != &performance_vtbl) return NULL;
    return CONTAINING_RECORD(iface, struct performance, IDirectMusicPerformance8_iface);
}

Referenced by performance_get_dsound().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dmime

)

Variable Documentation

performance_graph_vtbl

const IDirectMusicGraphVtbl performance_graph_vtbl

static

Initial value:

=
{
    performance_graph_QueryInterface,
    performance_graph_AddRef,
    performance_graph_Release,
    performance_graph_StampPMsg,
    performance_graph_InsertTool,
    performance_graph_GetTool,
    performance_graph_RemoveTool,
}

Definition at line 1993 of file performance.c.

Referenced by create_dmperformance().

performance_tool_vtbl

const IDirectMusicToolVtbl performance_tool_vtbl

static

Initial value:

=
{
    performance_tool_QueryInterface,
    performance_tool_AddRef,
    performance_tool_Release,
    performance_tool_Init,
    performance_tool_GetMsgDeliveryType,
    performance_tool_GetMediaTypeArraySize,
    performance_tool_GetMediaTypes,
    performance_tool_ProcessPMsg,
    performance_tool_Flush,
}

Definition at line 2265 of file performance.c.

Referenced by create_dmperformance().

performance_vtbl

const IDirectMusicPerformance8Vtbl performance_vtbl

static

Definition at line 1851 of file performance.c.

Referenced by create_dmperformance(), and unsafe_impl_from_IDirectMusicPerformance8().