src/engines/FxSend.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005, 2006 Christian Schoenebeck                        *
 *                                                                         *
 *   This library 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 library 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 library; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#include "FxSend.h"

#include "../drivers/audio/AudioOutputDevice.h"

#include <map>

namespace LinuxSampler {

    /*
       FIXME: we create fx send indeces globally for now, although we might
       want them to be an individual sequence per sampler channel, beside that
       we don't handle the cases yet where __indexer overflows back to 0
    */
    static uint __indexer = 0;

    FxSend::FxSend(EngineChannel* pEngineChannel, uint8_t MidiCtrl, String Name) {
        this->pEngineChannel = pEngineChannel;
        AudioOutputDevice* pDevice = pEngineChannel->GetAudioOutputDevice();
        const int iChanOffset = (pDevice) ? pDevice->ChannelCount() - pEngineChannel->Channels() : 0;
        for (int i = 0; i < pEngineChannel->Channels(); i++) {
            const int iDestination = iChanOffset + i;
            Routing.push_back(iDestination);
        }
        MidiFxSendController = MidiCtrl;
        sName = Name;
        iId = __indexer;
        __indexer++;
        fLevel = 0.3f; // default FX send level
    }

    int FxSend::DestinationChannel(int SrcChan) {
        if (SrcChan >= pEngineChannel->Channels()) return -1;
        return Routing[SrcChan];
    }

    void FxSend::SetDestinationChannel(int SrcChan, int DstChan) throw (Exception) {
        if (SrcChan < 0 || SrcChan >= pEngineChannel->Channels())
            throw Exception("Cannot alter FxSend routing, source channel out of bounds");
        AudioOutputDevice* pDevice = pEngineChannel->GetAudioOutputDevice();
        if (pDevice) {
            if (DstChan < 0 || DstChan >= pDevice->ChannelCount())
                throw Exception("Cannot alter FxSend routing, destination channel out of bounds");
        } else { // no audio device assigned yet
            if (DstChan < 0 || DstChan >= pEngineChannel->Channels())
                throw Exception(
                    "there is no audio device yet, so you cannot set a "
                    "FxSend destination channel higher than the engine "
                    "channel's amount of channels"
                );
        }
        Routing[SrcChan] = DstChan;
    }

    void FxSend::UpdateChannels() {
        if (Routing.size() > pEngineChannel->Channels()) {
            // add routings with default destinations
            AudioOutputDevice* pDevice = pEngineChannel->GetAudioOutputDevice();
            const int iChanOffset = (pDevice) ? pDevice->ChannelCount() - pEngineChannel->Channels() : 0;
            for (int i = Routing.size(); i < pEngineChannel->Channels(); i++) {
                const int iDestination = iChanOffset + i;
                Routing.push_back(iDestination);
            }
        } else if (Routing.size() < pEngineChannel->Channels()) {
            // shrink routing vector
            Routing.resize(pEngineChannel->Channels());
        }
    }

    float FxSend::Level() {
        return fLevel;
    }

    void FxSend::SetLevel(float f) {
        fLevel = f;
    }

    void FxSend::SetLevel(uint8_t iMidiValue) {
        fLevel = float(iMidiValue & 0x7f) / 127.0f;
    }

    uint8_t FxSend::MidiController() {
        return MidiFxSendController;
    }

    void FxSend::SetMidiController(uint8_t MidiCtrl) throw (Exception) {
        if (MidiCtrl & 0x7f)
            throw Exception("Invalid MIDI controller");
        MidiFxSendController = MidiCtrl;
    }

    String FxSend::Name() {
        return sName;
    }

    uint FxSend::Id() {
        return iId;
    }

} // namespace LinuxSampler
1	schoenebeck	1001	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6			* Copyright (C) 2005, 2006 Christian Schoenebeck *
7			* *
8			* This library is free software; you can redistribute it and/or modify *
9			* it under the terms of the GNU General Public License as published by *
10			* the Free Software Foundation; either version 2 of the License, or *
11			* (at your option) any later version. *
12			* *
13			* This library is distributed in the hope that it will be useful, *
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16			* GNU General Public License for more details. *
17			* *
18			* You should have received a copy of the GNU General Public License *
19			* along with this library; if not, write to the Free Software *
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21			* MA 02111-1307 USA *
22			***************************************************************************/
23
24			#include "FxSend.h"
25
26			#include "../drivers/audio/AudioOutputDevice.h"
27
28			#include <map>
29
30			namespace LinuxSampler {
31
32			/*
33			FIXME: we create fx send indeces globally for now, although we might
34			want them to be an individual sequence per sampler channel, beside that
35			we don't handle the cases yet where __indexer overflows back to 0
36			*/
37			static uint __indexer = 0;
38
39			FxSend::FxSend(EngineChannel* pEngineChannel, uint8_t MidiCtrl, String Name) {
40			this->pEngineChannel = pEngineChannel;
41			AudioOutputDevice* pDevice = pEngineChannel->GetAudioOutputDevice();
42			const int iChanOffset = (pDevice) ? pDevice->ChannelCount() - pEngineChannel->Channels() : 0;
43			for (int i = 0; i < pEngineChannel->Channels(); i++) {
44			const int iDestination = iChanOffset + i;
45			Routing.push_back(iDestination);
46			}
47			MidiFxSendController = MidiCtrl;
48			sName = Name;
49			iId = __indexer;
50			__indexer++;
51			fLevel = 0.3f; // default FX send level
52			}
53
54			int FxSend::DestinationChannel(int SrcChan) {
55			if (SrcChan >= pEngineChannel->Channels()) return -1;
56			return Routing[SrcChan];
57			}
58
59			void FxSend::SetDestinationChannel(int SrcChan, int DstChan) throw (Exception) {
60			if (SrcChan < 0 \|\| SrcChan >= pEngineChannel->Channels())
61			throw Exception("Cannot alter FxSend routing, source channel out of bounds");
62			AudioOutputDevice* pDevice = pEngineChannel->GetAudioOutputDevice();
63			if (pDevice) {
64			if (DstChan < 0 \|\| DstChan >= pDevice->ChannelCount())
65			throw Exception("Cannot alter FxSend routing, destination channel out of bounds");
66			} else { // no audio device assigned yet
67			if (DstChan < 0 \|\| DstChan >= pEngineChannel->Channels())
68			throw Exception(
69			"there is no audio device yet, so you cannot set a "
70			"FxSend destination channel higher than the engine "
71			"channel's amount of channels"
72			);
73			}
74			Routing[SrcChan] = DstChan;
75			}
76
77			void FxSend::UpdateChannels() {
78			if (Routing.size() > pEngineChannel->Channels()) {
79			// add routings with default destinations
80			AudioOutputDevice* pDevice = pEngineChannel->GetAudioOutputDevice();
81			const int iChanOffset = (pDevice) ? pDevice->ChannelCount() - pEngineChannel->Channels() : 0;
82			for (int i = Routing.size(); i < pEngineChannel->Channels(); i++) {
83			const int iDestination = iChanOffset + i;
84			Routing.push_back(iDestination);
85			}
86			} else if (Routing.size() < pEngineChannel->Channels()) {
87			// shrink routing vector
88			Routing.resize(pEngineChannel->Channels());
89			}
90			}
91
92			float FxSend::Level() {
93			return fLevel;
94			}
95
96			void FxSend::SetLevel(float f) {
97			fLevel = f;
98			}
99
100			void FxSend::SetLevel(uint8_t iMidiValue) {
101			fLevel = float(iMidiValue & 0x7f) / 127.0f;
102			}
103
104			uint8_t FxSend::MidiController() {
105			return MidiFxSendController;
106			}
107
108			void FxSend::SetMidiController(uint8_t MidiCtrl) throw (Exception) {
109			if (MidiCtrl & 0x7f)
110			throw Exception("Invalid MIDI controller");
111			MidiFxSendController = MidiCtrl;
112			}
113
114			String FxSend::Name() {
115			return sName;
116			}
117
118			uint FxSend::Id() {
119			return iId;
120			}
121
122			} // namespace LinuxSampler