Multimedia — MIDI, MCI & Timers

[midi] WARNING: No SoundFont found. Music will be silent.
Set FREE_API_SOUNDFONT=/path/to/file.sf2 or place default.sf2
in assets/soundfont/ or soundfont/.

# One-shot
FREE_API_SOUNDFONT=/usr/share/sounds/sf2/FluidR3_GM.sf2 ./MyGame

# Or export for the session
export FREE_API_SOUNDFONT=/usr/share/sounds/sf2/FluidR3_GM.sf2
./MyGame
      

// Must be called before the first MCI_OPEN for it to take effect
SetEnvironmentVariableA("FREE_API_SOUNDFONT",
    "/usr/share/sounds/sf2/FluidR3_GM.sf2");
      

typedef struct _MCI_OPEN_PARMSA {
    DWORD_PTR  dwCallback;      // notification window (ignored for MCI_OPEN)
    MCIDEVICEID wDeviceID;      // filled by Free API on MCI_OPEN success
    LPCSTR     lpstrDeviceType; // "sequencer" for MIDI files
    LPCSTR     lpstrElementName;// path to the MIDI file
    LPCSTR     lpstrAlias;      // optional alias (ignored)
} MCI_OPEN_PARMSA;
typedef MCI_OPEN_PARMSA MCI_OPEN_PARMS;
      

typedef struct _MCI_PLAY_PARMS {
    DWORD_PTR dwCallback; // HWND to receive MM_MCINOTIFY when song ends
    DWORD_PTR dwFrom;     // start position (ignored — always starts from 0)
    DWORD_PTR dwTo;       // end position (ignored)
} MCI_PLAY_PARMS;
      

typedef struct _MCI_SET_PARMS {
    DWORD_PTR dwCallback;   // ignored
    DWORD     dwTimeFormat; // ignored (no-op)
    DWORD     dwAudio;      // ignored
} MCI_SET_PARMS;
      

MCIERROR WINAPI mciSendCommandA(
    MCIDEVICEID mciId,      // 0 for MCI_OPEN
    UINT        uMsg,       // MCI_OPEN
    DWORD_PTR   fdwCommand, // flags: MCI_OPEN_TYPE | MCI_OPEN_ELEMENT
    DWORD_PTR   dwParam     // pointer to MCI_OPEN_PARMS
);
// #define mciSendCommand mciSendCommandA
      

#include <windows.h>   // includes mmsystem.h

MCIDEVICEID g_musicId = 0;

BOOL OpenMidiFile(const char* path)
{
    // Close any previously open track
    if (g_musicId) {
        mciSendCommand(g_musicId, MCI_CLOSE, 0, 0);
        g_musicId = 0;
    }

    MCI_OPEN_PARMS op = {};
    op.lpstrDeviceType  = "sequencer";
    op.lpstrElementName = path;

    MCIERROR err = mciSendCommand(0, MCI_OPEN,
        MCI_OPEN_TYPE | MCI_OPEN_ELEMENT,
        (DWORD_PTR)&op);

    if (err != MMSYSERR_NOERROR) {
        char msg[256];
        mciGetErrorString(err, msg, sizeof(msg));
        OutputDebugString(msg);
        return FALSE;
    }

    g_musicId = op.wDeviceID;
    return TRUE;
}
      

void PlayMusic(HWND hWndNotify)
{
    MCI_PLAY_PARMS pp = {};
    pp.dwCallback = (DWORD_PTR)hWndNotify;

    mciSendCommand(g_musicId, MCI_PLAY, MCI_NOTIFY, (DWORD_PTR)&pp);
}

// In WNDPROC — handle end-of-song notification:
case MM_MCINOTIFY:
    if (wParam == MCI_NOTIFY_SUCCESSFUL && g_musicId) {
        // Song finished — restart for looping
        MCI_PLAY_PARMS pp = { (DWORD_PTR)hWnd };
        mciSendCommand(g_musicId, MCI_PLAY, MCI_NOTIFY, (DWORD_PTR)&pp);
    }
    return 0;
      

void StopMusic()
{
    if (g_musicId) {
        mciSendCommand(g_musicId, MCI_CLOSE, 0, 0);
        g_musicId = 0;
    }
}

// Always close in WM_DESTROY:
case WM_DESTROY:
    StopMusic();
    PostQuitMessage(0);
    return 0;
      

void SetMusicVolume(int percent)  // 0-100
{
    if (midiOutGetNumDevs() == 0) return;

    HMIDIOUT hmo;
    if (midiOutOpen(&hmo, 0, 0, 0, 0) != MMSYSERR_NOERROR) return;

    // Scale 0-100% to 0x0000-0xFFFF
    WORD vol = (WORD)((percent * 0xFFFF) / 100);
    DWORD packed = (DWORD)vol | ((DWORD)vol << 16);  // same for L and R

    midiOutSetVolume(hmo, packed);
    midiOutClose(hmo);
}

// Examples:
SetMusicVolume(100);   // full volume
SetMusicVolume(50);    // half volume
SetMusicVolume(0);     // muted
      

BOOL WINAPI mciGetErrorStringA(MCIERROR mcierr, LPSTR pszText, UINT cchText);
// #define mciGetErrorString mciGetErrorStringA
      

MCIERROR err = mciSendCommand(0, MCI_OPEN,
    MCI_OPEN_TYPE | MCI_OPEN_ELEMENT,
    (DWORD_PTR)&op);

if (err != MMSYSERR_NOERROR) {
    char errorMsg[256];
    mciGetErrorString(err, errorMsg, sizeof(errorMsg));

    char fullMsg[512];
    snprintf(fullMsg, sizeof(fullMsg),
        "MCI error %lu: %s\n", (unsigned long)err, errorMsg);
    OutputDebugString(fullMsg);
    return FALSE;
}
      

MMRESULT WINAPI timeSetEvent(
    UINT           uDelay,      // interval in milliseconds (minimum ~1 ms)
    UINT           uResolution, // timer resolution request (0 = as accurate as possible)
    LPTIMECALLBACK lpTimeProc,  // function called at each interval
    DWORD_PTR      dwUser,      // user data passed to callback
    UINT           fuEvent      // must be TIME_PERIODIC
);
// Returns timer ID (non-zero) on success, 0 on failure.

MMRESULT WINAPI timeKillEvent(UINT uTimerID);
// Returns MMSYSERR_NOERROR on success.
      

void CALLBACK TimerCallback(
    UINT      uTimerID,  // same ID returned by timeSetEvent
    UINT      uMsg,      // reserved (0)
    DWORD_PTR dwUser,    // your dwUser value
    DWORD_PTR dw1,       // reserved (0)
    DWORD_PTR dw2        // reserved (0)
);
      

#include <windows.h>

UINT g_timerId = 0;

// Callback fires every 50 ms on a private SDL timer thread
void CALLBACK GameTimerCallback(UINT id, UINT msg,
    DWORD_PTR user, DWORD_PTR dw1, DWORD_PTR dw2)
{
    HWND hWnd = (HWND)user;

    // Safe to PostMessage from a timer thread
    PostMessage(hWnd, WM_USER + 1, 0, 0);
}

void StartGameLoop(HWND hWnd)
{
    g_timerId = timeSetEvent(
        50,                    // 50 ms = 20 ticks/second
        1,                     // 1 ms resolution
        GameTimerCallback,
        (DWORD_PTR)hWnd,
        TIME_PERIODIC
    );
    if (!g_timerId)
        OutputDebugString("timeSetEvent failed\n");
}

void StopGameLoop()
{
    if (g_timerId) {
        timeKillEvent(g_timerId);
        g_timerId = 0;
    }
}

// In WNDPROC — handle the tick message posted by the callback:
case WM_USER + 1:
    GameUpdate();  // runs on the main (message loop) thread
    GameRender();
    return 0;
      

FREE_API_DEBUG_MIDI=1 ./MyGame