engines/sfz/LookupTable.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2010 Andreas Persson                                    *
 *                                                                         *
 *   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., 51 Franklin St, Fifth Floor, Boston,                *
 *   MA  02110-1301  USA                                                   *
 ***************************************************************************/

#ifndef SFZ_LOOKUPTABLE_H
#define SFZ_LOOKUPTABLE_H

#include <vector>

#include "sfz.h"
#include "../../common/ArrayList.h"

namespace sfz {

    /**
     * Lookup table for fast access to regions in an sfz instrument.
     *
     * The table is organized in two levels. First, the values of the
     * dimensions actually in use by the instrument (could be key,
     * velocity, controller values, etc) are used as indexes in a set
     * of integer arrays. The resulting integers are then added
     * together and the sum is used as an index in an array of lists
     * of regions.
     *
     * The first level is used to make the second array smaller. An
     * instrument with three key zones and two velocity zones will
     * have two integer arrays, each of size 128, one for key number,
     * one for velocity. The region array only needs to be six items
     * big, as there are only 2 * 3 possible zone variations.
     */
    class LookupTable {
    public:
        /**
         * Constructs a lookup table for the instrument. If triggercc
         * is specified, the lookup table is made for regions
         * triggered by the MIDI controller, otherwise the table is
         * made for ordinary note-on triggered regions.
         *
         * @param instrument - instrument
         * @param triggercc - controller number or -1
         */
        LookupTable(const Instrument* instrument, int triggercc = -1);

        ~LookupTable();

        /**
         * Performs a lookup in the table of regions.
         *
         * @param q - query with constraints on key, velocity, etc.
         * @returns list of regions matching the query
         */
        LinuxSampler::ArrayList<Region*>& query(const Query& q) const;

    private:
        struct DimDef;

        static const DimDef dimDefs[]; // list of possible dimensions
        std::vector<int> dims; // dimensions used by the instrument

        // control change dimensions used by the instrument
        std::vector<int> ccs;

        // arrays mapping dimension values to regionArr offsets
        int** mapArr;

        // second level array with lists of regions
        LinuxSampler::ArrayList<Region*>* regionArr;

        // pointers to used dimension arguments in the Query object
        const uint8_t Query::** qargs;

        // array with CCs used by the instrument
        int* ccargs;


        // helper functions for the constructor
        static int fillMapArr(const std::vector<Region*>& regions,
                              const int Definition::* lo,
                              const int Definition::* hi,
                              int min, int max, int* a);
        static int fillMapArr(const std::vector<Region*>& regions,
                              int cc, int* a, int triggercc);
        void fillRegionArr(const int* len, Region* region,
                           std::vector<int>::size_type dim, int j,
                           int triggercc);
    };
}

#endif
1	persson	2106	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2010 Andreas Persson *
6			* *
7			* This program is free software; you can redistribute it and/or modify *
8			* it under the terms of the GNU General Public License as published by *
9			* the Free Software Foundation; either version 2 of the License, or *
10			* (at your option) any later version. *
11			* *
12			* This program is distributed in the hope that it will be useful, *
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15			* GNU General Public License for more details. *
16			* *
17			* You should have received a copy of the GNU General Public License *
18			* along with this program; if not, write to the Free Software *
19			* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
20			* MA 02110-1301 USA *
21			***************************************************************************/
22
23			#ifndef SFZ_LOOKUPTABLE_H
24			#define SFZ_LOOKUPTABLE_H
25
26			#include <vector>
27
28			#include "sfz.h"
29			#include "../../common/ArrayList.h"
30
31			namespace sfz {
32
33			/**
34			* Lookup table for fast access to regions in an sfz instrument.
35			*
36			* The table is organized in two levels. First, the values of the
37			* dimensions actually in use by the instrument (could be key,
38			* velocity, controller values, etc) are used as indexes in a set
39			* of integer arrays. The resulting integers are then added
40			* together and the sum is used as an index in an array of lists
41			* of regions.
42			*
43			* The first level is used to make the second array smaller. An
44			* instrument with three key zones and two velocity zones will
45			* have two integer arrays, each of size 128, one for key number,
46			* one for velocity. The region array only needs to be six items
47			* big, as there are only 2 * 3 possible zone variations.
48			*/
49			class LookupTable {
50			public:
51	persson	2115	/**
52			* Constructs a lookup table for the instrument. If triggercc
53			* is specified, the lookup table is made for regions
54			* triggered by the MIDI controller, otherwise the table is
55			* made for ordinary note-on triggered regions.
56			*
57			* @param instrument - instrument
58			* @param triggercc - controller number or -1
59			*/
60			LookupTable(const Instrument* instrument, int triggercc = -1);
61
62	persson	2106	~LookupTable();
63
64			/**
65			* Performs a lookup in the table of regions.
66			*
67			* @param q - query with constraints on key, velocity, etc.
68			* @returns list of regions matching the query
69			*/
70			LinuxSampler::ArrayList<Region*>& query(const Query& q) const;
71
72			private:
73			struct DimDef;
74
75			static const DimDef dimDefs[]; // list of possible dimensions
76			std::vector<int> dims; // dimensions used by the instrument
77
78			// control change dimensions used by the instrument
79			std::vector<int> ccs;
80
81			// arrays mapping dimension values to regionArr offsets
82			int** mapArr;
83
84			// second level array with lists of regions
85			LinuxSampler::ArrayList<Region> regionArr;
86
87			// pointers to used dimension arguments in the Query object
88			const uint8_t Query::** qargs;
89
90			// array with CCs used by the instrument
91			int* ccargs;
92
93
94			// helper functions for the constructor
95			static int fillMapArr(const std::vector<Region*>& regions,
96			const int Definition::* lo,
97			const int Definition::* hi,
98			int min, int max, int* a);
99			static int fillMapArr(const std::vector<Region*>& regions,
100	persson	2115	int cc, int* a, int triggercc);
101	persson	2106	void fillRegionArr(const int* len, Region* region,
102	persson	2115	std::vector<int>::size_type dim, int j,
103			int triggercc);
104	persson	2106	};
105			}
106
107			#endif