processor.h

Go to the documentation of this file.

/*
 *   NiCMidi - A C++ Class Library for MIDI
 *
 *   Copyright (C) 2004  J.D. Koftinoff Software, Ltd.
 *   www.jdkoftinoff.com jeffk@jdkoftinoff.com
 *   Copyright (C) 2021, 2022  Nicola Cassetta
 *   https://github.com/ncassetta/NiCMidi
 *
 *   This file is part of NiCMidi.
 *
 *   NiCMidi is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation, either version 3 of
 *   the License, or (at your option) any later version.
 *
 *   NiCMidi 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 Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with NiCMidi. If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 
 
#ifndef _NICMIDI_PROCESSOR_H
#define _NICMIDI_PROCESSOR_H
 
#include "msg.h"
 
#include <iostream>
#include <vector>
 
 
class MIDIProcessor {
    public:
                                        MIDIProcessor() {}
        virtual                         ~MIDIProcessor() {}
        virtual void                    Reset() = 0;
        virtual bool                    Process(MIDITimedMessage *msg) = 0;
};
 
 
class MIDIMultiProcessor : public MIDIProcessor {
    public:
 
                                        MIDIMultiProcessor() : process_mode(MODE_CONTINUE) {}
        virtual void                    Reset();
        MIDIProcessor*                  GetProcessor(unsigned int pos)          { return processors[pos]; }
        const MIDIProcessor*            GetProcessor(unsigned int pos) const    { return processors[pos]; }
        int                             GetProcessMode() const                  { return process_mode; }
        void                            SetProcessor(MIDIProcessor* proc, int pos = -1);
        void                            RemoveProcessor(unsigned int pos);
        void                            RemoveProcessor(const MIDIProcessor* proc);
        void                            SetProcessMode(int mode)        { process_mode = mode; }
        virtual bool                    Process(MIDITimedMessage *msg);
        enum { MODE_IGNORE, MODE_CONTINUE, MODE_STOP };
 
    protected:
        std::vector<MIDIProcessor*>     processors;     // The array of processor pointers
        int                             process_mode;   // The process mode parameter
};
 
 
class MIDIProcessorTransposer : public MIDIProcessor {
    public:
                                        MIDIProcessorTransposer();
        virtual void                    Reset();
        int                             GetChannelTranspose (int chan) const        { return trans_amount[chan]; }
        void                            SetChannelTranspose (int chan, int trans)   { trans_amount[chan] = trans; }
        void                            SetAllTranspose (int trans);
        virtual bool                    Process (MIDITimedMessage *msg);
 
    protected:
        int                             trans_amount[16];   // The transposing amount
};
 
class MIDIProcessorRechannelizer : public MIDIProcessor {
    public:
                                        MIDIProcessorRechannelizer();
 
        void                            Reset();
        int                             GetRechanMap (int src_chan) const           { return rechan_map[src_chan]; }
        void                            SetRechanMap (int src_chan, int dest_chan)  { rechan_map[src_chan] = dest_chan; }
        void                            SetAllRechan (int dest_chan);
        virtual bool                    Process(MIDITimedMessage *msg);
 
    protected:
        int                             rechan_map[16];         // The rechannel map
};
 
 
class MIDIProcessorPrinter : public MIDIProcessor {
    public:
                                        MIDIProcessorPrinter(std::ostream& stream = std::cout, unsigned char from_1 = 0) :
                                                             print_on(true), chan_from_1(from_1 != 0), ost(stream) {}
        virtual void                    Reset()                                     { print_on = true; }
        int                             GetChanFrom() const                         { return chan_from_1; }
        bool                            GetPrint() const                            { return print_on; }
        void                            SetChanFrom(unsigned char c)                { chan_from_1 = (c != 0); }
        void                            SetPrint(bool on_off)                       { print_on = on_off; }
        virtual bool                    Process(MIDITimedMessage *msg);
 
    protected:
        bool                            print_on;           // The on/off printing flag
        unsigned char                   chan_from_1;        // Starting number for MIDI channels (0 or 1)
        std::ostream&                   ost;                // The out stream
};
 
 
#endif