1 /** 2 * Copyright (c) 2006-2019 LOVE Development Team 3 * 4 * This software is provided 'as-is', without any express or implied 5 * warranty. In no event will the authors be held liable for any damages 6 * arising from the use of this software. 7 * 8 * Permission is granted to anyone to use this software for any purpose, 9 * including commercial applications, and to alter it and redistribute it 10 * freely, subject to the following restrictions: 11 * 12 * 1. The origin of this software must not be misrepresented; you must not 13 * claim that you wrote the original software. If you use this software 14 * in a product, an acknowledgment in the product documentation would be 15 * appreciated but is not required. 16 * 2. Altered source versions must be plainly marked as such, and must not be 17 * misrepresented as being the original software. 18 * 3. This notice may not be removed or altered from any source distribution. 19 **/ 20 21 #ifndef LOVE_AUDIO_FILTERS_H 22 #define LOVE_AUDIO_FILTERS_H 23 24 #include "common/Object.h" 25 #include "common/StringMap.h" 26 #include <map> 27 28 template<typename T> 29 class LazierAndSlowerButEasilyArrayableStringMap2 30 { 31 public: 32 struct Entry 33 { 34 const char *key; 35 T value; 36 }; LazierAndSlowerButEasilyArrayableStringMap2()37 LazierAndSlowerButEasilyArrayableStringMap2() 38 { 39 } 40 LazierAndSlowerButEasilyArrayableStringMap2(const std::vector<Entry> & entries)41 LazierAndSlowerButEasilyArrayableStringMap2(const std::vector<Entry> &entries) 42 { 43 for (auto entry : entries) 44 { 45 forward[entry.key] = entry.value; 46 reverse[entry.value] = entry.key; 47 } 48 } 49 find(const char * key,T & t)50 bool find(const char *key, T &t) 51 { 52 if (forward.find(key) == forward.end()) 53 return false; 54 t = forward[key]; 55 return true; 56 } 57 find(T key,const char * & str)58 bool find(T key, const char *&str) 59 { 60 if (reverse.find(key) == reverse.end()) 61 return false; 62 str = reverse[key]; 63 return true; 64 } 65 66 private: 67 std::map<std::string, T> forward; 68 std::map<T, const char*> reverse; 69 }; 70 71 namespace love 72 { 73 namespace audio 74 { 75 76 class Filter 77 { 78 public: 79 enum Type 80 { 81 TYPE_BASIC, 82 TYPE_LOWPASS, 83 TYPE_HIGHPASS, 84 TYPE_BANDPASS, 85 TYPE_MAX_ENUM 86 }; 87 88 enum Parameter 89 { 90 FILTER_TYPE, 91 FILTER_VOLUME, 92 93 FILTER_LOWGAIN, 94 FILTER_HIGHGAIN, 95 96 FILTER_MAX_ENUM 97 }; 98 99 enum ParameterType 100 { 101 PARAM_TYPE, 102 PARAM_FLOAT, 103 PARAM_MAX_ENUM 104 }; 105 106 Filter(); 107 virtual ~Filter(); 108 Type getType() const; 109 110 static bool getConstant(const char *in, Type &out); 111 static bool getConstant(Type in, const char *&out); 112 static std::vector<std::string> getConstants(Type); 113 static bool getConstant(const char *in, Parameter &out, Type t); 114 static bool getConstant(Parameter in, const char *&out, Type t); 115 static ParameterType getParameterType(Parameter in); 116 117 protected: 118 Type type; 119 120 private: 121 static StringMap<Type, TYPE_MAX_ENUM>::Entry typeEntries[]; 122 static StringMap<Type, TYPE_MAX_ENUM> types; 123 #define StringMap LazierAndSlowerButEasilyArrayableStringMap2 124 static std::vector<StringMap<Filter::Parameter>::Entry> basicParameters; 125 static std::vector<StringMap<Filter::Parameter>::Entry> lowpassParameters; 126 static std::vector<StringMap<Filter::Parameter>::Entry> highpassParameters; 127 static std::vector<StringMap<Filter::Parameter>::Entry> bandpassParameters; 128 static std::map<Type, StringMap<Parameter>> parameterNames; 129 #undef StringMap 130 static std::map<Parameter, ParameterType> parameterTypes; 131 }; 132 133 } //audio 134 } //love 135 136 #endif //LOVE_AUDIO_FILTERS_H 137