XMidiSequence.h

Go to the documentation of this file.

/*
Copyright (C) 2003  The Pentagram Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef XMIDISEQUENCE_H_INCLUDED
#define XMIDISEQUENCE_H_INCLUDED

#include "XMidiSequenceHandler.h"
#include "XMidiEvent.h"
#include "XMidiEventList.h"
#include "XMidiNoteStack.h"

class XMidiSequence
{
public:

        XMidiSequence(XMidiSequenceHandler *handler, uint16 sequence_id, XMidiEventList *events, 
                                                bool repeat, int volume, int branch);

        ~XMidiSequence();

        int                                     playEvent();

        sint32                          timeTillNext();

    void                                setVolume(int new_vol);

        int                                     getVolume() { return vol_multi; }

        void                            setSpeed(int new_speed) { speed = new_speed; }

        void                            loseChannel(int c);

        void                            gainChannel(int c);

        void                            applyShadow(int c);

        uint16                          getChanMask() { return evntlist->chan_mask; }

        void                            pause();

        void                            unpause();

        bool                            isPaused() { return paused; }

        int                                     countNotesOn(int chan);

private:

        XMidiSequenceHandler    *handler;               
        uint16                                  sequence_id;    
        XMidiEventList                  *evntlist;              
        XMidiEvent                              *event;                 
        bool                                    repeat;                 
        XMidiNoteStack                  notes_on;               
        uint32                                  last_tick;              
        uint32                                  start;                  
        int                                             loop_num;               
        int                                             vol_multi;              
        bool                                    paused;                 
        int                                             speed;                  

        XMidiEvent *                    loop_event[XMIDI_MAX_FOR_LOOP_COUNT];

        int                                             loop_count[XMIDI_MAX_FOR_LOOP_COUNT];

        struct ChannelShadow {
                static const uint16     centre_value;
                static const uint8      fine_value;
                static const uint8      coarse_value;
                static const uint16     combined_value;

        int             pitchWheel;
                int             program;

                // Controllers
                int             bank[2];                // 0
                int             modWheel[2];    // 1
                int             footpedal[2];   // 4
                int             volumes[2];             // 7
                int             pan[2];                 // 9
                int             balance[2];             // 10
                int             expression[2];  // 11
                int             sustain;                // 64
                int             effects;                // 91
                int             chorus;                 // 93

                int             xbank;
                void reset();
        } shadows[16];

        void                    sendEvent();

        void                    updateShadowForEvent(XMidiEvent *event);

        inline void initClock ()
        { start = handler->getTickCount(sequence_id)+24; }

        inline void addOffset (uint32 offset)
        { start += offset; }

        inline uint32 getTime ()
        { return handler->getTickCount(sequence_id) - start; }

        inline uint32 getStart ()
        { return start; }

        inline uint32 getRealTime ()
        { return handler->getTickCount(sequence_id); }
};

#endif //XMIDISEQUENCE_H_INCLUDED

---