dmime: Parse note on/off events and generate a seqtrack.

Author: Yuxuan Shui

dlls/dmime/dmime_private.h

@@ -89,6 +89,8 @@ extern BOOL segment_state_has_track(IDirectMusicSegmentState *iface, DWORD track
 extern HRESULT wave_track_create_from_chunk(IStream *stream, struct chunk_entry *parent,
         IDirectMusicTrack8 **ret_iface);
 
+extern void sequence_track_set_items(IDirectMusicTrack8 *track, DMUS_IO_SEQ_ITEM *items, unsigned int count);
+
 extern HRESULT performance_get_dsound(IDirectMusicPerformance8 *iface, IDirectSound **dsound);
 extern HRESULT performance_send_segment_start(IDirectMusicPerformance8 *iface, MUSIC_TIME music_time,
         IDirectMusicSegmentState *state);

dlls/dmime/midi.c

@@ -49,8 +49,20 @@ struct midi_event
     };
 };
 
+struct midi_seqtrack_item
+{
+    struct list entry;
+    DMUS_IO_SEQ_ITEM item;
+};
+
 struct midi_parser
 {
+    IDirectMusicTrack8 *seqtrack;
+    ULONG seqtrack_items_count;
+    struct list seqtrack_items;
+    /* Track the initial note on event generated for a note that is currently on. NULL if the note is off. */
+    struct midi_seqtrack_item *note_states[128 * 16];
+
     IDirectMusicTrack *chordtrack;
     IDirectMusicTrack *bandtrack;
     IDirectMusicTrack *tempotrack;
@@ -174,17 +186,22 @@ static HRESULT read_midi_event(IStream *stream, struct midi_event *event, BYTE *
     }
 
     status_type = event->status & 0xf0;
+    event->data[0] = byte;
     if (status_type == MIDI_PROGRAM_CHANGE)
     {
-        event->data[0] = byte;
         TRACE("MIDI program change event status %#02x, data: %#02x, time +%lu\n", event->status,
                 event->data[0], delta_time);
     }
     else
     {
         if (status_type != MIDI_CHANNEL_PRESSURE && (hr = stream_read_at_most(stream, &byte, 1, bytes_left)) != S_OK)
             return hr;
-        FIXME("MIDI event status %#02x, time +%lu, not supported\n", event->status, delta_time);
+        event->data[1] = byte;
+        if (status_type == MIDI_NOTE_ON || status_type == MIDI_NOTE_OFF)
+            TRACE("MIDI note event status %#02x, data: %#02x, %#02x, time +%lu\n", event->status,
+                    event->data[0], event->data[1], delta_time);
+        else
+            FIXME("MIDI event status %#02x, time +%lu, not supported\n", event->status, delta_time);
     }
 
     return S_OK;
@@ -234,11 +251,71 @@ static HRESULT midi_parser_handle_program_change(struct midi_parser *parser, str
     return hr;
 }
 
+static HRESULT midi_parser_handle_note_on_off(struct midi_parser *parser, struct midi_event *event)
+{
+    BYTE new_velocity = (event->status & 0xf0) == MIDI_NOTE_OFF ? 0 : event->data[1]; /* DirectMusic doesn't have noteoff velocity */
+    BYTE note = event->data[0], channel = event->status & 0xf;
+    DWORD index = (DWORD)channel * 128 + note;
+    MUSIC_TIME dmusic_time;
+    struct midi_seqtrack_item *note_state = parser->note_states[index];
+    DMUS_IO_SEQ_ITEM *seq_item;
+    struct midi_seqtrack_item *item;
+
+    /* Testing shows there are 2 cases to deal with here:
+     *
+     * 1. Got note on when the note is already on, generate a NOTE event with
+     *    new velocity and duration 1.
+     * 2. Got note on when the note is off, generate a NOTE event that lasts
+     *    until the next note off event, intervening note on event doesn't matter.
+     */
+    if (new_velocity)
+    {
+        TRACE("Adding note event at time %lu, note %u, velocity %u\n", parser->time, note, new_velocity);
+
+        dmusic_time = (ULONGLONG)parser->time * DMUS_PPQ / parser->division;
+
+        item = calloc(1, sizeof(struct midi_seqtrack_item));
+        if (!item) return E_OUTOFMEMORY;
+
+        seq_item = &item->item;
+        seq_item->mtTime = dmusic_time;
+        seq_item->mtDuration = 1;
+        seq_item->dwPChannel = channel;
+        seq_item->bStatus = MIDI_NOTE_ON;
+        seq_item->bByte1 = note;
+        seq_item->bByte2 = new_velocity;
+        list_add_tail(&parser->seqtrack_items, &item->entry);
+        parser->seqtrack_items_count++;
+
+        if (!note_state) parser->note_states[index] = item;
+    }
+    else if (note_state)
+    {
+        note_state->item.mtDuration = (ULONGLONG)parser->time * DMUS_PPQ / parser->division -
+                                      note_state->item.mtTime;
+        if (note_state->item.mtDuration == 0) note_state->item.mtDuration = 1;
+
+        TRACE("Note off at time %lu, note %u, duration %ld\n", parser->time, note, note_state->item.mtDuration);
+
+        parser->note_states[index] = NULL;
+    }
+
+    return S_OK;
+}
+
+static int midi_seqtrack_item_compare(const void *a, const void *b)
+{
+    const DMUS_IO_SEQ_ITEM *item_a = a, *item_b = b;
+    return item_a->mtTime - item_b->mtTime;
+}
+
 static HRESULT midi_parser_parse(struct midi_parser *parser, IDirectMusicSegment8 *segment)
 {
     WORD i = 0;
     HRESULT hr;
     MUSIC_TIME music_length = 0;
+    DMUS_IO_SEQ_ITEM *seq_items = NULL;
+    struct midi_seqtrack_item *item;
 
     TRACE("(%p, %p): semi-stub\n", parser, segment);
 
@@ -266,35 +343,70 @@ static HRESULT midi_parser_parse(struct midi_parser *parser, IDirectMusicSegment
             parser->time += event.delta_time;
             if (event.status == 0xff && event.meta_type == MIDI_META_SET_TEMPO)
                 hr = midi_parser_handle_set_tempo(parser, &event);
-            else if ((event.status & 0xf0) == MIDI_PROGRAM_CHANGE)
-                hr = midi_parser_handle_program_change(parser, &event);
+            else
+            {
+                switch (event.status & 0xf0)
+                {
+                case MIDI_NOTE_ON:
+                case MIDI_NOTE_OFF:
+                    hr = midi_parser_handle_note_on_off(parser, &event);
+                    break;
+                case MIDI_PROGRAM_CHANGE:
+                    hr = midi_parser_handle_program_change(parser, &event);
+                    break;
+                default:
+                    FIXME("Unhandled MIDI event type %#02x at time +%lu\n", event.status, parser->time);
+                    break;
+                }
+            }
             if (FAILED(hr)) break;
         }
 
         if (FAILED(hr)) break;
+
         TRACE("End of track %u\n", i);
         if (parser->time > music_length) music_length = parser->time;
         parser->time = 0;
+        memset(parser->note_states, 0, sizeof(parser->note_states));
     }
+    if (FAILED(hr)) return hr;
 
     TRACE("End of file\n");
 
+    if ((seq_items = calloc(parser->seqtrack_items_count, sizeof(DMUS_IO_SEQ_ITEM))) == NULL)
+        return E_OUTOFMEMORY;
+
+    i = 0;
+    LIST_FOR_EACH_ENTRY(item, &parser->seqtrack_items, struct midi_seqtrack_item, entry)
+        seq_items[i++] = item->item;
+    sequence_track_set_items(parser->seqtrack, seq_items, parser->seqtrack_items_count);
+    qsort(seq_items, parser->seqtrack_items_count, sizeof(DMUS_IO_SEQ_ITEM), midi_seqtrack_item_compare);
+
     music_length = (ULONGLONG)music_length * DMUS_PPQ / parser->division + 1;
     if (SUCCEEDED(hr)) hr = IDirectMusicSegment8_SetLength(segment, music_length);
     if (SUCCEEDED(hr)) hr = IDirectMusicSegment8_InsertTrack(segment, parser->bandtrack, 0xffff);
     if (SUCCEEDED(hr)) hr = IDirectMusicSegment8_InsertTrack(segment, parser->chordtrack, 0xffff);
     if (SUCCEEDED(hr) && parser->tempotrack)
         hr = IDirectMusicSegment8_InsertTrack(segment, parser->tempotrack, 0xffff);
+    if (SUCCEEDED(hr))
+        hr = IDirectMusicSegment8_InsertTrack(segment, (IDirectMusicTrack *)parser->seqtrack, 0xffff);
 
     return hr;
 }
 
 static void midi_parser_destroy(struct midi_parser *parser)
 {
+    struct midi_seqtrack_item *item, *next_item;
     IStream_Release(parser->stream);
     if (parser->bandtrack) IDirectMusicTrack_Release(parser->bandtrack);
     if (parser->chordtrack) IDirectMusicTrack_Release(parser->chordtrack);
     if (parser->tempotrack) IDirectMusicTrack_Release(parser->tempotrack);
+    if (parser->seqtrack) IDirectMusicTrack_Release(parser->seqtrack);
+    LIST_FOR_EACH_ENTRY_SAFE(item, next_item, &parser->seqtrack_items, struct midi_seqtrack_item, entry)
+    {
+        list_remove(&item->entry);
+        free(item);
+    }
     free(parser);
 }
 
@@ -334,6 +446,7 @@ static HRESULT midi_parser_new(IStream *stream, struct midi_parser **out_parser)
 
     parser = calloc(1, sizeof(struct midi_parser));
     if (!parser) return E_OUTOFMEMORY;
+    list_init(&parser->seqtrack_items);
     IStream_AddRef(stream);
     parser->stream = stream;
     parser->division = division;
@@ -342,6 +455,10 @@ static HRESULT midi_parser_new(IStream *stream, struct midi_parser **out_parser)
     if (SUCCEEDED(hr))
         hr = CoCreateInstance(&CLSID_DirectMusicChordTrack, NULL, CLSCTX_INPROC_SERVER,
                 &IID_IDirectMusicTrack, (void **)&parser->chordtrack);
+    if (SUCCEEDED(hr))
+        hr = CoCreateInstance(&CLSID_DirectMusicSeqTrack, NULL, CLSCTX_INPROC_SERVER,
+                &IID_IDirectMusicTrack, (void **)&parser->seqtrack);
+
     if (FAILED(hr)) midi_parser_destroy(parser);
     else *out_parser = parser;
     return hr;

dlls/dmime/seqtrack.c

@@ -483,3 +483,11 @@ HRESULT create_dmseqtrack(REFIID lpcGUID, void **ppobj)
 
     return hr;
 }
+
+void sequence_track_set_items(IDirectMusicTrack8 *track, DMUS_IO_SEQ_ITEM *items, unsigned int count)
+{
+    struct sequence_track *This = impl_from_IDirectMusicTrack8(track);
+    free(This->items);
+    This->items = items;
+    This->count = count;
+}