TnbMidi.h

[詳解]

#pragma once
#include "TnbSync.h"
#include "TnbMciPlayer.h"
#include <mmsystem.h>
#pragma comment(lib, "winmm.lib")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CMidiMessage : CCopyImpossible
{
public:
 
    CMidiMessage(void) : m_hMidi(NULL), m_lastError(MMSYSERR_NOERROR)
    {
    }
 
    ~CMidiMessage(void)
    {
        Close();
    }
 
    void Close(void)
    {
        if ( m_hMidi != NULL )
        {
            ::midiOutClose(m_hMidi);
            m_hMidi = NULL;
        }
    }
 
    bool Open(UINT dev = MIDI_MAPPER)
    {
        Close();
        return m_Rst(::midiOutOpen(&m_hMidi, dev, NULL, 0, CALLBACK_NULL));
    }
 
    bool IsOpened(void) const
    {
        return m_hMidi != NULL;
    }
 
    bool ProgramChange(BYTE channel, BYTE programNumber)
    {
        return m_Rst(channel, TParam(Midi_ProgramChange, channel, programNumber));
    }
 
    bool BankSelect(BYTE channel, BYTE msb, BYTE lsb)
    {
        CWorkMemT<TParam> vp(2);
        vp[0] = TParam(CCC_BackSelectMsb, channel, msb);
        vp[1] = TParam(CCC_BackSelectLsb, channel, lsb);
        return m_Rst(channel, vp);
    }
 
    bool Modulation(BYTE channel, BYTE modulation)
    {
        ASSERT ( modulation <= 127 );
        return m_Rst(channel, TParam(CCC_Modulation, channel, modulation));
    }
 
    bool Volume(BYTE channel, int volume)
    {
        ASSERT ( volume >= 0 && volume <= 127 );
        return m_Rst(channel, TParam(CCC_Volume, channel, down_cast<BYTE>(volume)));
    }
 
    bool Panpot(BYTE channel, int pan)
    {
        if ( pan < -63 )
        {
            pan = -63;
        }
        else if ( pan > 63 )
        {
            pan = 63;
        }
        return m_Rst(channel, TParam(CCC_Panpot, channel, down_cast<BYTE>(pan + 64)));
    }
 
    bool Expression(BYTE channel, int volume)
    {
        ASSERT ( volume >= 0 && volume <= 127 );
        return m_Rst(channel, TParam(CCC_Expression, channel, down_cast<BYTE>(volume)));
    }
 
    bool ReverbSendLevel(BYTE channel, int level)
    {
        ASSERT ( level >= 0 && level <= 127 );
        return m_Rst(channel, TParam(CCC_ReverbSendLevel, channel, down_cast<BYTE>(level)));
    }
 
    bool ChorusSendLevel(BYTE channel, int level)
    {
        ASSERT ( level >= 0 && level <= 127 );
        return m_Rst(channel, TParam(CCC_ChorusSendLevel, channel, down_cast<BYTE>(level)));
    }
 
    bool ControlSendLevel(BYTE channel, BYTE controlNo, int level)
    {
        ASSERT ( level >= 0 && level <= 127 );
        return m_Rst(channel, TParam(ECtrlChangeCode(controlNo), channel, down_cast<BYTE>(level)));
    }
 
    bool NoteOn(BYTE channel, BYTE note, BYTE velocity = 0)
    {
        ASSERT ( velocity <= 127 );
        return m_Rst(channel, TParam(Midi_NoteOn, channel, note, velocity));
    }
 
    bool NoteOff(BYTE channel, BYTE note, BYTE velocity = 0)
    {
        ASSERT ( velocity <= 127 );
        return m_Rst(channel, TParam(Midi_NoteOff, channel, note));
    }
 
    bool PitchBendChange(BYTE channel, int pitchBend = 0)
    {
        if ( pitchBend < -8192 )
        {
            pitchBend = -8192;
        }
        else if ( pitchBend > 8181 )
        {
            pitchBend = 8181;
        }
        int b = pitchBend + 8192;
        BYTE msb = down_cast<BYTE>((b >> 7) & 0x7F);
        BYTE lsb = down_cast<BYTE>((b     ) & 0x7F);
        return m_Rst(channel, TParam(Midi_PitchBendChange, channel, lsb, msb));
    }
 
    bool PitchBendSensitivity(BYTE channel, BYTE v)
    {
        ASSERT ( v <= 127 );
        CWorkMemT<TParam> vp(6);
        // ピッチベンドセンシビティ
        vp[0] = TParam(CCC_RpnMsb, channel, 0);
        vp[1] = TParam(CCC_RpnLsb, channel, 0);
        // データエントリ
        vp[2] = TParam(CCC_DataEntryMsb, channel, v);
        vp[3] = TParam(CCC_DataEntryLsb, channel, 0);
        vp[4] = TParam(CCC_RpnMsb, channel, 0x7F);
        vp[5] = TParam(CCC_RpnLsb, channel, 0x7F);
        return m_Rst(channel, vp);
    }
 
#if 0
    bool OutMessage(size_t len, LPCVOID pMessage)
    {
        MIDIHDR hdr = { 0 };
        CWorkMemT<char> mm;
        mm.Reset(len, static_cast<const char*>(pMessage));
        hdr.lpData = mm;
        hdr.dwBufferLength = len;
        hdr.dwBytesRecorded = len;
        if ( ! m_Rst(::midiOutPrepareHeader(m_hMidi, &hdr, sizeof(MIDIHDR))) )
        {
            return false;
        }
        if ( ! m_Rst(::midiOutLongMsg(m_hMidi, &hdr, sizeof(MIDIHDR))) )
        {
            return false;
        }
        /* GMリセット完了待機 */
        while ( (hdr.dwFlags & MHDR_DONE) == 0 )
        {
            ::Sleep(0);
        }
        return m_Rst(::midiOutUnprepareHeader(m_hMidi, &hdr, sizeof(MIDIHDR)));
    }
#endif
 
    DWORD GetLastError(void) const
    {
        return m_lastError;
    }
 
    void SetLastError(DWORD e)
    {
        m_lastError = e;
    }
 
    static UINT GetDeviceCount(void)
    {
        return ::midiOutGetNumDevs();
    }
 
    static CStr GetErrorString(DWORD e)
    {
        CStr s;
        if ( e != MMSYSERR_NOERROR )
        {
            ::midiOutGetErrorText(e, s.GetBuffer(1000), 1000);
            s.ReleaseBuffer();
        }
        return s;
    }
 
private:
 
    enum EMidiMessageKind
    {
        Midi_NoteOn             = 0x9,  
        Midi_NoteOff            = 0x8,  
        Midi_KeyPressure        = 0xA,  
        Midi_CtrlChange         = 0xB,  
        Midi_ProgramChange      = 0xC,  
        Midi_ChannelPressure    = 0xD,  
        Midi_PitchBendChange    = 0xE,  
    };
 
    enum ECtrlChangeCode
    {
        CCC_BackSelectMsb       = 0x00, 
        CCC_BackSelectLsb       = 0x20, 
        CCC_Modulation          = 0x01, 
        CCC_Volume              = 0x07, 
        CCC_Panpot              = 0x0A, 
        CCC_Expression          = 0x0B, 
        CCC_DataEntryMsb        = 0x06, 
        CCC_DataEntryLsb        = 0x26, 
        CCC_RpnMsb              = 0x65, 
        CCC_RpnLsb              = 0x64, 
        CCC_ReverbSendLevel     = 0x5B, 
        CCC_TremoloDepth        = 0x5C, 
        CCC_ChorusSendLevel     = 0x5D, 
        CCC_VarSendLevel        = 0x5E, 
    };
 
    struct TParam
    {
        union {
            struct {
                union {
                    struct {
                        BYTE    channel:4;  
                        BYTE    kind:4;     
                    };
                    BYTE    state;          
                };
                BYTE    data1;              
                BYTE    data2;              
                BYTE    padding;            
            };
            DWORD msg;                      
        };
        TParam(EMidiMessageKind k, BYTE ch = 0, BYTE d1 = 0, BYTE d2 = 0)
            : padding(0), kind(down_cast<BYTE>(k)), channel(ch), data1(d1), data2(d2)
        {
        }
        TParam(ECtrlChangeCode ccc, BYTE ch = 0, BYTE d = 0)
            : padding(0), kind(down_cast<BYTE>(Midi_CtrlChange)), channel(ch), data1(down_cast<BYTE>(ccc)), data2(d)
        {
        }
        TParam(void) : msg(0)
        {
        }
    };
    friend struct CMidiMessage::TParam;
    C_ASSERT( sizeof(TParam) == sizeof(DWORD) );
    bool m_RstFx(MMRESULT r)
    {
        m_lastError = r;
        return r == MMSYSERR_NOERROR;
    }
    bool m_Rst(MMRESULT r)
    {
        m_lastError = r;
        if ( r != MMSYSERR_NOERROR )
        {
            TRACE2("MMRESULT = %d[%s]\n", r, GetErrorString(r));
        }
        return r == MMSYSERR_NOERROR;
    }
    bool m_Rst(BYTE channel, const TParam& p)
    {
        if ( channel > 15 )
        {
            return m_RstFx(MMSYSERR_BADERRNUM);
        }
        TTRACE3( "MIDI msg = %02X %02X %02X\n", p.state, p.data1, p.data2 );
        return m_Rst(::midiOutShortMsg(m_hMidi, p.msg));
    }
    bool m_Rst(BYTE channel, const CWorkMemT<TParam>& vp)
    {
        loop ( i, vp.GetSize() )
        {
            if ( ! m_Rst(channel, vp[i]) )
            {
                return false;
            }
        }
        return true;
    }
    HMIDIOUT            m_hMidi;        
    mutable MMRESULT    m_lastError;    
};
 
 
 
}; //TNB