@@ -0,0 +1,13 @@ | |||
*.a | |||
*.o | |||
*.exe | |||
*.dll | |||
*.dylib | |||
*.so | |||
.kdev_include_paths | |||
.kdev4/ | |||
bin/*-dssi/ | |||
bin/*.lv2/ |
@@ -0,0 +1,3 @@ | |||
[submodule "dpf"] | |||
path = dpf | |||
url = git://github.com/DISTRHO/DPF |
@@ -0,0 +1,280 @@ | |||
GNU GENERAL PUBLIC LICENSE | |||
Version 2, June 1991 | |||
Copyright (C) 1989, 1991 Free Software Foundation, Inc., | |||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |||
Everyone is permitted to copy and distribute verbatim copies | |||
of this license document, but changing it is not allowed. | |||
Preamble | |||
The licenses for most software are designed to take away your | |||
freedom to share and change it. By contrast, the GNU General Public | |||
License is intended to guarantee your freedom to share and change free | |||
software--to make sure the software is free for all its users. This | |||
General Public License applies to most of the Free Software | |||
Foundation's software and to any other program whose authors commit to | |||
using it. (Some other Free Software Foundation software is covered by | |||
the GNU Lesser General Public License instead.) You can apply it to | |||
your programs, too. | |||
When we speak of free software, we are referring to freedom, not | |||
price. Our General Public Licenses are designed to make sure that you | |||
have the freedom to distribute copies of free software (and charge for | |||
this service if you wish), that you receive source code or can get it | |||
if you want it, that you can change the software or use pieces of it | |||
in new free programs; and that you know you can do these things. | |||
To protect your rights, we need to make restrictions that forbid | |||
anyone to deny you these rights or to ask you to surrender the rights. | |||
These restrictions translate to certain responsibilities for you if you | |||
distribute copies of the software, or if you modify it. | |||
For example, if you distribute copies of such a program, whether | |||
gratis or for a fee, you must give the recipients all the rights that | |||
you have. You must make sure that they, too, receive or can get the | |||
source code. And you must show them these terms so they know their | |||
rights. | |||
We protect your rights with two steps: (1) copyright the software, and | |||
(2) offer you this license which gives you legal permission to copy, | |||
distribute and/or modify the software. | |||
Also, for each author's protection and ours, we want to make certain | |||
that everyone understands that there is no warranty for this free | |||
software. If the software is modified by someone else and passed on, we | |||
want its recipients to know that what they have is not the original, so | |||
that any problems introduced by others will not reflect on the original | |||
authors' reputations. | |||
Finally, any free program is threatened constantly by software | |||
patents. We wish to avoid the danger that redistributors of a free | |||
program will individually obtain patent licenses, in effect making the | |||
program proprietary. To prevent this, we have made it clear that any | |||
patent must be licensed for everyone's free use or not licensed at all. | |||
The precise terms and conditions for copying, distribution and | |||
modification follow. | |||
GNU GENERAL PUBLIC LICENSE | |||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION | |||
0. This License applies to any program or other work which contains | |||
a notice placed by the copyright holder saying it may be distributed | |||
under the terms of this General Public License. The "Program", below, | |||
refers to any such program or work, and a "work based on the Program" | |||
means either the Program or any derivative work under copyright law: | |||
that is to say, a work containing the Program or a portion of it, | |||
either verbatim or with modifications and/or translated into another | |||
language. (Hereinafter, translation is included without limitation in | |||
the term "modification".) Each licensee is addressed as "you". | |||
Activities other than copying, distribution and modification are not | |||
covered by this License; they are outside its scope. The act of | |||
running the Program is not restricted, and the output from the Program | |||
is covered only if its contents constitute a work based on the | |||
Program (independent of having been made by running the Program). | |||
Whether that is true depends on what the Program does. | |||
1. You may copy and distribute verbatim copies of the Program's | |||
source code as you receive it, in any medium, provided that you | |||
conspicuously and appropriately publish on each copy an appropriate | |||
copyright notice and disclaimer of warranty; keep intact all the | |||
notices that refer to this License and to the absence of any warranty; | |||
and give any other recipients of the Program a copy of this License | |||
along with the Program. | |||
You may charge a fee for the physical act of transferring a copy, and | |||
you may at your option offer warranty protection in exchange for a fee. | |||
2. You may modify your copy or copies of the Program or any portion | |||
of it, thus forming a work based on the Program, and copy and | |||
distribute such modifications or work under the terms of Section 1 | |||
above, provided that you also meet all of these conditions: | |||
a) You must cause the modified files to carry prominent notices | |||
stating that you changed the files and the date of any change. | |||
b) You must cause any work that you distribute or publish, that in | |||
whole or in part contains or is derived from the Program or any | |||
part thereof, to be licensed as a whole at no charge to all third | |||
parties under the terms of this License. | |||
c) If the modified program normally reads commands interactively | |||
when run, you must cause it, when started running for such | |||
interactive use in the most ordinary way, to print or display an | |||
announcement including an appropriate copyright notice and a | |||
notice that there is no warranty (or else, saying that you provide | |||
a warranty) and that users may redistribute the program under | |||
these conditions, and telling the user how to view a copy of this | |||
License. (Exception: if the Program itself is interactive but | |||
does not normally print such an announcement, your work based on | |||
the Program is not required to print an announcement.) | |||
These requirements apply to the modified work as a whole. If | |||
identifiable sections of that work are not derived from the Program, | |||
and can be reasonably considered independent and separate works in | |||
themselves, then this License, and its terms, do not apply to those | |||
sections when you distribute them as separate works. But when you | |||
distribute the same sections as part of a whole which is a work based | |||
on the Program, the distribution of the whole must be on the terms of | |||
this License, whose permissions for other licensees extend to the | |||
entire whole, and thus to each and every part regardless of who wrote it. | |||
Thus, it is not the intent of this section to claim rights or contest | |||
your rights to work written entirely by you; rather, the intent is to | |||
exercise the right to control the distribution of derivative or | |||
collective works based on the Program. | |||
In addition, mere aggregation of another work not based on the Program | |||
with the Program (or with a work based on the Program) on a volume of | |||
a storage or distribution medium does not bring the other work under | |||
the scope of this License. | |||
3. You may copy and distribute the Program (or a work based on it, | |||
under Section 2) in object code or executable form under the terms of | |||
Sections 1 and 2 above provided that you also do one of the following: | |||
a) Accompany it with the complete corresponding machine-readable | |||
source code, which must be distributed under the terms of Sections | |||
1 and 2 above on a medium customarily used for software interchange; or, | |||
b) Accompany it with a written offer, valid for at least three | |||
years, to give any third party, for a charge no more than your | |||
cost of physically performing source distribution, a complete | |||
machine-readable copy of the corresponding source code, to be | |||
distributed under the terms of Sections 1 and 2 above on a medium | |||
customarily used for software interchange; or, | |||
c) Accompany it with the information you received as to the offer | |||
to distribute corresponding source code. (This alternative is | |||
allowed only for noncommercial distribution and only if you | |||
received the program in object code or executable form with such | |||
an offer, in accord with Subsection b above.) | |||
The source code for a work means the preferred form of the work for | |||
making modifications to it. For an executable work, complete source | |||
code means all the source code for all modules it contains, plus any | |||
associated interface definition files, plus the scripts used to | |||
control compilation and installation of the executable. However, as a | |||
special exception, the source code distributed need not include | |||
anything that is normally distributed (in either source or binary | |||
form) with the major components (compiler, kernel, and so on) of the | |||
operating system on which the executable runs, unless that component | |||
itself accompanies the executable. | |||
If distribution of executable or object code is made by offering | |||
access to copy from a designated place, then offering equivalent | |||
access to copy the source code from the same place counts as | |||
distribution of the source code, even though third parties are not | |||
compelled to copy the source along with the object code. | |||
4. You may not copy, modify, sublicense, or distribute the Program | |||
except as expressly provided under this License. Any attempt | |||
otherwise to copy, modify, sublicense or distribute the Program is | |||
void, and will automatically terminate your rights under this License. | |||
However, parties who have received copies, or rights, from you under | |||
this License will not have their licenses terminated so long as such | |||
parties remain in full compliance. | |||
5. You are not required to accept this License, since you have not | |||
signed it. However, nothing else grants you permission to modify or | |||
distribute the Program or its derivative works. These actions are | |||
prohibited by law if you do not accept this License. Therefore, by | |||
modifying or distributing the Program (or any work based on the | |||
Program), you indicate your acceptance of this License to do so, and | |||
all its terms and conditions for copying, distributing or modifying | |||
the Program or works based on it. | |||
6. Each time you redistribute the Program (or any work based on the | |||
Program), the recipient automatically receives a license from the | |||
original licensor to copy, distribute or modify the Program subject to | |||
these terms and conditions. You may not impose any further | |||
restrictions on the recipients' exercise of the rights granted herein. | |||
You are not responsible for enforcing compliance by third parties to | |||
this License. | |||
7. If, as a consequence of a court judgment or allegation of patent | |||
infringement or for any other reason (not limited to patent issues), | |||
conditions are imposed on you (whether by court order, agreement or | |||
otherwise) that contradict the conditions of this License, they do not | |||
excuse you from the conditions of this License. If you cannot | |||
distribute so as to satisfy simultaneously your obligations under this | |||
License and any other pertinent obligations, then as a consequence you | |||
may not distribute the Program at all. For example, if a patent | |||
license would not permit royalty-free redistribution of the Program by | |||
all those who receive copies directly or indirectly through you, then | |||
the only way you could satisfy both it and this License would be to | |||
refrain entirely from distribution of the Program. | |||
If any portion of this section is held invalid or unenforceable under | |||
any particular circumstance, the balance of the section is intended to | |||
apply and the section as a whole is intended to apply in other | |||
circumstances. | |||
It is not the purpose of this section to induce you to infringe any | |||
patents or other property right claims or to contest validity of any | |||
such claims; this section has the sole purpose of protecting the | |||
integrity of the free software distribution system, which is | |||
implemented by public license practices. Many people have made | |||
generous contributions to the wide range of software distributed | |||
through that system in reliance on consistent application of that | |||
system; it is up to the author/donor to decide if he or she is willing | |||
to distribute software through any other system and a licensee cannot | |||
impose that choice. | |||
This section is intended to make thoroughly clear what is believed to | |||
be a consequence of the rest of this License. | |||
8. If the distribution and/or use of the Program is restricted in | |||
certain countries either by patents or by copyrighted interfaces, the | |||
original copyright holder who places the Program under this License | |||
may add an explicit geographical distribution limitation excluding | |||
those countries, so that distribution is permitted only in or among | |||
countries not thus excluded. In such case, this License incorporates | |||
the limitation as if written in the body of this License. | |||
9. The Free Software Foundation may publish revised and/or new versions | |||
of the General Public License from time to time. Such new versions will | |||
be similar in spirit to the present version, but may differ in detail to | |||
address new problems or concerns. | |||
Each version is given a distinguishing version number. If the Program | |||
specifies a version number of this License which applies to it and "any | |||
later version", you have the option of following the terms and conditions | |||
either of that version or of any later version published by the Free | |||
Software Foundation. If the Program does not specify a version number of | |||
this License, you may choose any version ever published by the Free Software | |||
Foundation. | |||
10. If you wish to incorporate parts of the Program into other free | |||
programs whose distribution conditions are different, write to the author | |||
to ask for permission. For software which is copyrighted by the Free | |||
Software Foundation, write to the Free Software Foundation; we sometimes | |||
make exceptions for this. Our decision will be guided by the two goals | |||
of preserving the free status of all derivatives of our free software and | |||
of promoting the sharing and reuse of software generally. | |||
NO WARRANTY | |||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY | |||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN | |||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES | |||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED | |||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS | |||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE | |||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, | |||
REPAIR OR CORRECTION. | |||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING | |||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR | |||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, | |||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING | |||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED | |||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY | |||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER | |||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE | |||
POSSIBILITY OF SUCH DAMAGES. | |||
END OF TERMS AND CONDITIONS |
@@ -0,0 +1,32 @@ | |||
#!/usr/bin/make -f | |||
# Makefile for DISTRHO Plugins # | |||
# ---------------------------- # | |||
# Created by falkTX | |||
# | |||
all: libs plugins gen | |||
# -------------------------------------------------------------- | |||
libs: | |||
$(MAKE) -C dpf/dgl | |||
plugins: libs | |||
$(MAKE) -C plugins/Nekobi | |||
gen: plugins dpf/utils/lv2_ttl_generator | |||
@$(CURDIR)/dpf/utils/generate-ttl.sh | |||
dpf/utils/lv2_ttl_generator: | |||
$(MAKE) -C dpf/utils/lv2-ttl-generator | |||
# -------------------------------------------------------------- | |||
clean: | |||
$(MAKE) clean -C dpf/dgl | |||
$(MAKE) clean -C dpf/utils/lv2-ttl-generator | |||
$(MAKE) clean -C plugins/Nekobi | |||
# -------------------------------------------------------------- | |||
.PHONY: libs plugins |
@@ -0,0 +1,113 @@ | |||
#!/usr/bin/make -f | |||
# Makefile for DISTRHO Plugins # | |||
# ---------------------------- # | |||
# Created by falkTX | |||
# | |||
CC ?= gcc | |||
CXX ?= g++ | |||
# -------------------------------------------------------------- | |||
# Fallback to Linux if no other OS defined | |||
ifneq ($(HAIKU),true) | |||
ifneq ($(MACOS),true) | |||
ifneq ($(WIN32),true) | |||
LINUX=true | |||
endif | |||
endif | |||
endif | |||
# -------------------------------------------------------------- | |||
# Common build and link flags | |||
BASE_FLAGS = -Wall -Wextra -pipe | |||
BASE_OPTS = -O2 -ffast-math -mtune=generic -msse -msse2 -mfpmath=sse -fdata-sections -ffunction-sections | |||
LINK_OPTS = -fdata-sections -ffunction-sections -Wl,-O1 -Wl,--as-needed -Wl,--gc-sections -Wl,--strip-all | |||
ifeq ($(MACOS),true) | |||
# MacOS linker flags | |||
LINK_OPTS = -fdata-sections -ffunction-sections -Wl,-dead_strip -Wl,-dead_strip_dylibs | |||
endif | |||
ifeq ($(RASPPI),true) | |||
# Raspberry-Pi optimization flags | |||
BASE_OPTS = -O2 -ffast-math -march=armv6 -mfpu=vfp -mfloat-abi=hard | |||
LINK_OPTS = -Wl,-O1 -Wl,--as-needed -Wl,--strip-all | |||
endif | |||
ifneq ($(WIN32),true) | |||
# not needed for Windows | |||
BASE_FLAGS += -fPIC -DPIC | |||
endif | |||
ifeq ($(DEBUG),true) | |||
BASE_FLAGS += -DDEBUG -O0 -g | |||
LINK_OPTS = | |||
else | |||
BASE_FLAGS += -DNDEBUG $(BASE_OPTS) -fvisibility=hidden | |||
CXXFLAGS += -fvisibility-inlines-hidden | |||
LINK_OPTS += -Wl,--strip-all | |||
endif | |||
BUILD_C_FLAGS = $(BASE_FLAGS) -std=c99 -std=gnu99 $(CFLAGS) | |||
BUILD_CXX_FLAGS = $(BASE_FLAGS) -std=c++0x -std=gnu++0x $(CXXFLAGS) | |||
LINK_FLAGS = $(LINK_OPTS) -Wl,--no-undefined $(LDFLAGS) | |||
ifeq ($(MACOS),true) | |||
# No C++11 support | |||
BUILD_CXX_FLAGS = $(BASE_FLAGS) $(CXXFLAGS) | |||
LINK_FLAGS = $(LINK_OPTS) $(LDFLAGS) | |||
endif | |||
# -------------------------------------------------------------- | |||
# Check for required libs | |||
ifeq ($(LINUX),true) | |||
ifneq ($(shell pkg-config --exists gl && echo true),true) | |||
$(error OpenGL missing, cannot continue) | |||
endif | |||
ifneq ($(shell pkg-config --exists x11 && echo true),true) | |||
$(error X11 missing, cannot continue) | |||
endif | |||
endif | |||
# -------------------------------------------------------------- | |||
# Set libs stuff | |||
ifeq ($(LINUX),true) | |||
DGL_FLAGS = $(shell pkg-config --cflags gl x11) | |||
DGL_LIBS = $(shell pkg-config --libs gl x11) | |||
endif | |||
ifeq ($(MACOS),true) | |||
DGL_LIBS = -framework OpenGL -framework Cocoa | |||
endif | |||
ifeq ($(WIN32),true) | |||
DGL_LIBS = -lopengl32 -lgdi32 | |||
endif | |||
# -------------------------------------------------------------- | |||
# Set extension | |||
EXT = so | |||
ifeq ($(MACOS),true) | |||
EXT = dylib | |||
endif | |||
ifeq ($(WIN32),true) | |||
EXT = dll | |||
endif | |||
# -------------------------------------------------------------- | |||
# Set shared library CLI arg | |||
SHARED = -shared | |||
ifeq ($(MACOS),true) | |||
SHARED = -dynamiclib | |||
endif | |||
# -------------------------------------------------------------- |
@@ -0,0 +1,6 @@ | |||
# DISTRHO Nekobi | |||
TODO... | |||
## Screenshot | |||
<br/> |
@@ -0,0 +1,3 @@ | |||
All final plugin builds will be placed in this folder. | |||
There is no "make install" process, simply copy those files to their appropriate place. |
@@ -0,0 +1 @@ | |||
Subproject commit 642b7866dd97429bfa2c2ddb1da57c4902fc40eb |
@@ -0,0 +1,105 @@ | |||
#!/usr/bin/make -f | |||
# Makefile for DISTRHO Plugins # | |||
# ---------------------------- # | |||
# Created by falkTX | |||
# | |||
# NAME, OBJS_DSP and OBJS_UI have been defined before | |||
include ../../Makefile.mk | |||
# -------------------------------------------------------------- | |||
# Basic setup | |||
TARGET_DIR = ../../bin | |||
BUILD_C_FLAGS += -I. | |||
BUILD_CXX_FLAGS += -I. -I../../dpf/distrho -I../../dpf/dgl | |||
# -------------------------------------------------------------- | |||
# Enable all possible plugin types | |||
all: dssi lv2 vst | |||
# -------------------------------------------------------------- | |||
# Set plugin binary file targets | |||
ladspa_dsp = $(TARGET_DIR)/$(NAME)-ladspa.$(EXT) | |||
dssi_dsp = $(TARGET_DIR)/$(NAME)-dssi.$(EXT) | |||
dssi_ui = $(TARGET_DIR)/$(NAME)-dssi/$(NAME)_ui | |||
lv2_dsp = $(TARGET_DIR)/$(NAME).lv2/$(NAME).$(EXT) | |||
lv2_ui = $(TARGET_DIR)/$(NAME).lv2/$(NAME)_ui.$(EXT) | |||
vst = $(TARGET_DIR)/$(NAME)-vst.$(EXT) | |||
ifeq ($(WIN32),true) | |||
dssi_ui += .exe | |||
endif | |||
# TODO: MacOS VST bundle | |||
# -------------------------------------------------------------- | |||
# Set distrho code files | |||
DISTRHO_PLUGIN_FILES = ../../dpf/distrho/DistrhoPluginMain.cpp | |||
DISTRHO_UI_FILES = ../../dpf/distrho/DistrhoUIMain.cpp ../../dpf/libdgl.a | |||
# -------------------------------------------------------------- | |||
# Handle plugins without UI | |||
ifeq ($(TARGET_NOUI),true) | |||
dssi_ui = | |||
lv2_ui = | |||
DISTRHO_UI_FILES = | |||
DGL_LIBS = | |||
OBJS_UI = | |||
endif | |||
# -------------------------------------------------------------- | |||
# Common | |||
%.c.o: %.c | |||
$(CC) $< $(BUILD_C_FLAGS) -c -o $@ | |||
%.cpp.o: %.cpp | |||
$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@ | |||
clean: | |||
rm -f *.o | |||
rm -rf $(TARGET_DIR)/$(NAME)-* $(TARGET_DIR)/$(NAME).lv2/ | |||
# -------------------------------------------------------------- | |||
# DSSI | |||
dssi: $(dssi_dsp) $(dssi_ui) | |||
$(dssi_dsp): $(OBJS_DSP) $(DISTRHO_PLUGIN_FILES) | |||
mkdir -p $(shell dirname $@) | |||
$(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) -lpthread $(SHARED) -DDISTRHO_PLUGIN_TARGET_DSSI -o $@ | |||
$(dssi_ui): $(OBJS_UI) $(DISTRHO_UI_FILES) | |||
mkdir -p $(shell dirname $@) | |||
$(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) $(DGL_LIBS) $(shell pkg-config --cflags --libs liblo) -DDISTRHO_PLUGIN_TARGET_DSSI -o $@ | |||
# -------------------------------------------------------------- | |||
# LV2 | |||
lv2: $(lv2_dsp) $(lv2_ui) | |||
$(lv2_dsp): $(OBJS_DSP) $(DISTRHO_PLUGIN_FILES) | |||
mkdir -p $(shell dirname $@) | |||
$(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) -lpthread $(SHARED) -DDISTRHO_PLUGIN_TARGET_LV2 -o $@ | |||
$(lv2_ui): $(OBJS_UI) $(DISTRHO_UI_FILES) | |||
mkdir -p $(shell dirname $@) | |||
$(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) $(DGL_LIBS) $(SHARED) -DDISTRHO_PLUGIN_TARGET_LV2 -o $@ | |||
# -------------------------------------------------------------- | |||
# VST | |||
vst: $(vst) | |||
$(vst): $(OBJS_DSP) $(OBJS_UI) $(DISTRHO_PLUGIN_FILES) $(DISTRHO_UI_FILES) | |||
mkdir -p $(shell dirname $@) | |||
$(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) $(DGL_LIBS) -lpthread $(SHARED) -DDISTRHO_PLUGIN_TARGET_VST -o $@ | |||
# -------------------------------------------------------------- |
@@ -0,0 +1,90 @@ | |||
/* (Auto-generated binary data file). */ | |||
#ifndef BINARY_DISTRHOARTWORKNEKOBI_HPP | |||
#define BINARY_DISTRHOARTWORKNEKOBI_HPP | |||
namespace DistrhoArtworkNekobi | |||
{ | |||
extern const char* aboutData; | |||
const unsigned int aboutDataSize = 172710; | |||
const unsigned int aboutWidth = 303; | |||
const unsigned int aboutHeight = 190; | |||
extern const char* aboutButtonHoverData; | |||
const unsigned int aboutButtonHoverDataSize = 5888; | |||
const unsigned int aboutButtonHoverWidth = 92; | |||
const unsigned int aboutButtonHoverHeight = 16; | |||
extern const char* aboutButtonNormalData; | |||
const unsigned int aboutButtonNormalDataSize = 5888; | |||
const unsigned int aboutButtonNormalWidth = 92; | |||
const unsigned int aboutButtonNormalHeight = 16; | |||
extern const char* backgroundData; | |||
const unsigned int backgroundDataSize = 206064; | |||
const unsigned int backgroundWidth = 636; | |||
const unsigned int backgroundHeight = 108; | |||
extern const char* claw1Data; | |||
const unsigned int claw1DataSize = 4096; | |||
const unsigned int claw1Width = 32; | |||
const unsigned int claw1Height = 32; | |||
extern const char* claw2Data; | |||
const unsigned int claw2DataSize = 4096; | |||
const unsigned int claw2Width = 32; | |||
const unsigned int claw2Height = 32; | |||
extern const char* knobData; | |||
const unsigned int knobDataSize = 10000; | |||
const unsigned int knobWidth = 50; | |||
const unsigned int knobHeight = 50; | |||
extern const char* run1Data; | |||
const unsigned int run1DataSize = 4096; | |||
const unsigned int run1Width = 32; | |||
const unsigned int run1Height = 32; | |||
extern const char* run2Data; | |||
const unsigned int run2DataSize = 4096; | |||
const unsigned int run2Width = 32; | |||
const unsigned int run2Height = 32; | |||
extern const char* run3Data; | |||
const unsigned int run3DataSize = 4096; | |||
const unsigned int run3Width = 32; | |||
const unsigned int run3Height = 32; | |||
extern const char* run4Data; | |||
const unsigned int run4DataSize = 4096; | |||
const unsigned int run4Width = 32; | |||
const unsigned int run4Height = 32; | |||
extern const char* scratch1Data; | |||
const unsigned int scratch1DataSize = 4096; | |||
const unsigned int scratch1Width = 32; | |||
const unsigned int scratch1Height = 32; | |||
extern const char* scratch2Data; | |||
const unsigned int scratch2DataSize = 4096; | |||
const unsigned int scratch2Width = 32; | |||
const unsigned int scratch2Height = 32; | |||
extern const char* sitData; | |||
const unsigned int sitDataSize = 4096; | |||
const unsigned int sitWidth = 32; | |||
const unsigned int sitHeight = 32; | |||
extern const char* sliderData; | |||
const unsigned int sliderDataSize = 6084; | |||
const unsigned int sliderWidth = 39; | |||
const unsigned int sliderHeight = 39; | |||
extern const char* tailData; | |||
const unsigned int tailDataSize = 4096; | |||
const unsigned int tailWidth = 32; | |||
const unsigned int tailHeight = 32; | |||
} | |||
#endif // BINARY_DISTRHOARTWORKNEKOBI_HPP | |||
@@ -0,0 +1,36 @@ | |||
/* | |||
* DISTRHO Nekobi Plugin, based on Nekobee by Sean Bolton and others. | |||
* Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com> | |||
* | |||
* 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 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. | |||
* | |||
* For a full copy of the GNU General Public License see the LICENSE file. | |||
*/ | |||
#ifndef DISTRHO_PLUGIN_INFO_H_INCLUDED | |||
#define DISTRHO_PLUGIN_INFO_H_INCLUDED | |||
#define DISTRHO_PLUGIN_NAME "Nekobi" | |||
#define DISTRHO_PLUGIN_HAS_UI 1 | |||
#define DISTRHO_PLUGIN_IS_SYNTH 1 | |||
#define DISTRHO_PLUGIN_NUM_INPUTS 0 | |||
#define DISTRHO_PLUGIN_NUM_OUTPUTS 1 | |||
#define DISTRHO_PLUGIN_WANT_LATENCY 0 | |||
#define DISTRHO_PLUGIN_WANT_PROGRAMS 0 | |||
#define DISTRHO_PLUGIN_WANT_STATE 0 | |||
#define DISTRHO_PLUGIN_WANT_TIMEPOS 0 | |||
#define DISTRHO_PLUGIN_URI "http://distrho.sf.net/plugins/Nekobi" | |||
#endif // DISTRHO_PLUGIN_INFO_H_INCLUDED |
@@ -0,0 +1,401 @@ | |||
/* | |||
* DISTRHO Nekobi Plugin, based on Nekobee by Sean Bolton and others. | |||
* Copyright (C) 2004 Sean Bolton and others | |||
* Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com> | |||
* | |||
* 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 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. | |||
* | |||
* For a full copy of the GNU General Public License see the LICENSE file. | |||
*/ | |||
#include "DistrhoPluginNekobi.hpp" | |||
extern "C" { | |||
#include "nekobee-src/nekobee_synth.c" | |||
#include "nekobee-src/nekobee_voice.c" | |||
#include "nekobee-src/nekobee_voice_render.c" | |||
#include "nekobee-src/minblep_tables.c" | |||
// ----------------------------------------------------------------------- | |||
// mutual exclusion | |||
bool dssp_voicelist_mutex_trylock(nekobee_synth_t* const synth) | |||
{ | |||
/* Attempt the mutex lock */ | |||
if (pthread_mutex_trylock(&synth->voicelist_mutex) != 0) | |||
{ | |||
synth->voicelist_mutex_grab_failed = 1; | |||
return false; | |||
} | |||
/* Clean up if a previous mutex grab failed */ | |||
if (synth->voicelist_mutex_grab_failed) | |||
{ | |||
nekobee_synth_all_voices_off(synth); | |||
synth->voicelist_mutex_grab_failed = 0; | |||
} | |||
return true; | |||
} | |||
bool dssp_voicelist_mutex_lock(nekobee_synth_t* const synth) | |||
{ | |||
return (pthread_mutex_lock(&synth->voicelist_mutex) == 0); | |||
} | |||
bool dssp_voicelist_mutex_unlock(nekobee_synth_t* const synth) | |||
{ | |||
return (pthread_mutex_unlock(&synth->voicelist_mutex) == 0); | |||
} | |||
// ----------------------------------------------------------------------- | |||
// nekobee_handle_raw_event | |||
void nekobee_handle_raw_event(nekobee_synth_t* const synth, const uint8_t size, const uint8_t* const data) | |||
{ | |||
if (size != 3) | |||
return; | |||
switch (data[0] & 0xf0) | |||
{ | |||
case 0x80: | |||
nekobee_synth_note_off(synth, data[1], data[2]); | |||
break; | |||
case 0x90: | |||
if (data[2] > 0) | |||
nekobee_synth_note_on(synth, data[1], data[2]); | |||
else | |||
nekobee_synth_note_off(synth, data[1], 64); /* shouldn't happen, but... */ | |||
break; | |||
case 0xB0: | |||
nekobee_synth_control_change(synth, data[1], data[2]); | |||
break; | |||
default: | |||
break; | |||
} | |||
} | |||
} /* extern "C" */ | |||
START_NAMESPACE_DISTRHO | |||
// ----------------------------------------------------------------------- | |||
DistrhoPluginNekobi::DistrhoPluginNekobi() | |||
: Plugin(paramCount, 0, 0) // 0 programs, 0 states | |||
{ | |||
nekobee_init_tables(); | |||
// init synth | |||
fSynth.sample_rate = d_getSampleRate(); | |||
fSynth.deltat = 1.0f / (float)d_getSampleRate(); | |||
fSynth.nugget_remains = 0; | |||
fSynth.note_id = 0; | |||
fSynth.polyphony = XSYNTH_DEFAULT_POLYPHONY; | |||
fSynth.voices = XSYNTH_DEFAULT_POLYPHONY; | |||
fSynth.monophonic = XSYNTH_MONO_MODE_ONCE; | |||
fSynth.glide = 0; | |||
fSynth.last_noteon_pitch = 0.0f; | |||
fSynth.vcf_accent = 0.0f; | |||
fSynth.vca_accent = 0.0f; | |||
for (int i=0; i<8; ++i) | |||
fSynth.held_keys[i] = -1; | |||
fSynth.voice = nekobee_voice_new(); | |||
fSynth.voicelist_mutex_grab_failed = 0; | |||
pthread_mutex_init(&fSynth.voicelist_mutex, nullptr); | |||
fSynth.channel_pressure = 0; | |||
fSynth.pitch_wheel_sensitivity = 0; | |||
fSynth.pitch_wheel = 0; | |||
for (int i=0; i<128; ++i) | |||
{ | |||
fSynth.key_pressure[i] = 0; | |||
fSynth.cc[i] = 0; | |||
} | |||
fSynth.cc[7] = 127; // full volume | |||
fSynth.mod_wheel = 1.0f; | |||
fSynth.pitch_bend = 1.0f; | |||
fSynth.cc_volume = 1.0f; | |||
// Default values | |||
fParams.waveform = 0.0f; | |||
fParams.tuning = 0.0f; | |||
fParams.cutoff = 25.0f; | |||
fParams.resonance = 25.0f; | |||
fParams.envMod = 50.0f; | |||
fParams.decay = 75.0f; | |||
fParams.accent = 25.0f; | |||
fParams.volume = 75.0f; | |||
// Internal stuff | |||
fSynth.waveform = 0.0f; | |||
fSynth.tuning = 1.0f; | |||
fSynth.cutoff = 5.0f; | |||
fSynth.resonance = 0.8f; | |||
fSynth.envmod = 0.3f; | |||
fSynth.decay = 0.0002f; | |||
fSynth.accent = 0.3f; | |||
fSynth.volume = 0.75f; | |||
// reset | |||
d_deactivate(); | |||
} | |||
DistrhoPluginNekobi::~DistrhoPluginNekobi() | |||
{ | |||
std::free(fSynth.voice); | |||
} | |||
// ----------------------------------------------------------------------- | |||
// Init | |||
void DistrhoPluginNekobi::d_initParameter(uint32_t index, Parameter& parameter) | |||
{ | |||
switch (index) | |||
{ | |||
case paramWaveform: | |||
parameter.hints = PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN; | |||
parameter.name = "Waveform"; | |||
parameter.symbol = "waveform"; | |||
parameter.ranges.def = 0.0f; | |||
parameter.ranges.min = 0.0f; | |||
parameter.ranges.max = 1.0f; | |||
break; | |||
case paramTuning: | |||
parameter.hints = PARAMETER_IS_AUTOMABLE; // was 0.5 <-> 2.0, log | |||
parameter.name = "Tuning"; | |||
parameter.symbol = "tuning"; | |||
parameter.ranges.def = 0.0f; | |||
parameter.ranges.min = -12.0f; | |||
parameter.ranges.max = 12.0f; | |||
break; | |||
case paramCutoff: | |||
parameter.hints = PARAMETER_IS_AUTOMABLE; // modified x2.5 | |||
parameter.name = "Cutoff"; | |||
parameter.symbol = "cutoff"; | |||
parameter.unit = "%"; | |||
parameter.ranges.def = 25.0f; | |||
parameter.ranges.min = 0.0f; | |||
parameter.ranges.max = 100.0f; | |||
break; | |||
case paramResonance: | |||
parameter.hints = PARAMETER_IS_AUTOMABLE; // modified x100 | |||
parameter.name = "VCF Resonance"; | |||
parameter.symbol = "resonance"; | |||
parameter.unit = "%"; | |||
parameter.ranges.def = 25.0f; | |||
parameter.ranges.min = 0.0f; | |||
parameter.ranges.max = 95.0f; | |||
break; | |||
case paramEnvMod: | |||
parameter.hints = PARAMETER_IS_AUTOMABLE; // modified x100 | |||
parameter.name = "Env Mod"; | |||
parameter.symbol = "env_mod"; | |||
parameter.unit = "%"; | |||
parameter.ranges.def = 50.0f; | |||
parameter.ranges.min = 0.0f; | |||
parameter.ranges.max = 100.0f; | |||
break; | |||
case paramDecay: | |||
parameter.hints = PARAMETER_IS_AUTOMABLE; // was 0.000009 <-> 0.0005, log | |||
parameter.name = "Decay"; | |||
parameter.symbol = "decay"; | |||
parameter.unit = "%"; | |||
parameter.ranges.def = 75.0f; | |||
parameter.ranges.min = 0.0f; | |||
parameter.ranges.max = 100.0f; | |||
break; | |||
case paramAccent: | |||
parameter.hints = PARAMETER_IS_AUTOMABLE; // modified x100 | |||
parameter.name = "Accent"; | |||
parameter.symbol = "accent"; | |||
parameter.unit = "%"; | |||
parameter.ranges.def = 25.0f; | |||
parameter.ranges.min = 0.0f; | |||
parameter.ranges.max = 100.0f; | |||
break; | |||
case paramVolume: | |||
parameter.hints = PARAMETER_IS_AUTOMABLE; // modified x100 | |||
parameter.name = "Volume"; | |||
parameter.symbol = "volume"; | |||
parameter.unit = "%"; | |||
parameter.ranges.def = 75.0f; | |||
parameter.ranges.min = 0.0f; | |||
parameter.ranges.max = 100.0f; | |||
break; | |||
} | |||
} | |||
// ----------------------------------------------------------------------- | |||
// Internal data | |||
float DistrhoPluginNekobi::d_getParameterValue(uint32_t index) const | |||
{ | |||
switch (index) | |||
{ | |||
case paramWaveform: | |||
return fParams.waveform; | |||
case paramTuning: | |||
return fParams.tuning; | |||
case paramCutoff: | |||
return fParams.cutoff; | |||
case paramResonance: | |||
return fParams.resonance; | |||
case paramEnvMod: | |||
return fParams.envMod; | |||
case paramDecay: | |||
return fParams.decay; | |||
case paramAccent: | |||
return fParams.accent; | |||
case paramVolume: | |||
return fParams.volume; | |||
} | |||
return 0.0f; | |||
} | |||
void DistrhoPluginNekobi::d_setParameterValue(uint32_t index, float value) | |||
{ | |||
switch (index) | |||
{ | |||
case paramWaveform: | |||
fParams.waveform = value; | |||
fSynth.waveform = value; | |||
DISTRHO_SAFE_ASSERT(fSynth.waveform == 0.0f || fSynth.waveform == 1.0f); | |||
break; | |||
case paramTuning: | |||
fParams.tuning = value; | |||
fSynth.tuning = (value+12.0f)/24.0f * 1.5 + 0.5f; // FIXME: log? | |||
DISTRHO_SAFE_ASSERT(fSynth.tuning >= 0.5f && fSynth.tuning <= 2.0f); | |||
break; | |||
case paramCutoff: | |||
fParams.cutoff = value; | |||
fSynth.cutoff = value/2.5f; | |||
DISTRHO_SAFE_ASSERT(fSynth.cutoff >= 0.0f && fSynth.cutoff <= 40.0f); | |||
break; | |||
case paramResonance: | |||
fParams.resonance = value; | |||
fSynth.resonance = value/100.0f; | |||
DISTRHO_SAFE_ASSERT(fSynth.resonance >= 0.0f && fSynth.resonance <= 0.95f); | |||
break; | |||
case paramEnvMod: | |||
fParams.envMod = value; | |||
fSynth.envmod = value/100.0f; | |||
DISTRHO_SAFE_ASSERT(fSynth.envmod >= 0.0f && fSynth.envmod <= 1.0f); | |||
break; | |||
case paramDecay: | |||
fParams.decay = value; | |||
fSynth.decay = value/100.0f * 0.000491f + 0.000009f; // FIXME: log? | |||
DISTRHO_SAFE_ASSERT(fSynth.decay >= 0.000009f && fSynth.decay <= 0.0005f); | |||
break; | |||
case paramAccent: | |||
fParams.accent = value; | |||
fSynth.accent = value/100.0f; | |||
DISTRHO_SAFE_ASSERT(fSynth.accent >= 0.0f && fSynth.accent <= 1.0f); | |||
break; | |||
case paramVolume: | |||
fParams.volume = value; | |||
fSynth.volume = value/100.0f; | |||
DISTRHO_SAFE_ASSERT(fSynth.volume >= 0.0f && fSynth.volume <= 1.0f); | |||
break; | |||
} | |||
} | |||
// ----------------------------------------------------------------------- | |||
// Process | |||
void DistrhoPluginNekobi::d_activate() | |||
{ | |||
fSynth.nugget_remains = 0; | |||
fSynth.note_id = 0; | |||
if (fSynth.voice != nullptr) | |||
nekobee_synth_all_voices_off(&fSynth); | |||
} | |||
void DistrhoPluginNekobi::d_deactivate() | |||
{ | |||
if (fSynth.voice != nullptr) | |||
nekobee_synth_all_voices_off(&fSynth); | |||
} | |||
void DistrhoPluginNekobi::d_run(const float**, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount) | |||
{ | |||
uint32_t framesDone = 0; | |||
uint32_t curEventIndex = 0; | |||
uint32_t burstSize; | |||
float* out = outputs[0]; | |||
if (fSynth.voice == nullptr || ! dssp_voicelist_mutex_trylock(&fSynth)) | |||
{ | |||
std::memset(out, 0, sizeof(float)*frames); | |||
return; | |||
} | |||
while (framesDone < frames) | |||
{ | |||
if (fSynth.nugget_remains == 0) | |||
fSynth.nugget_remains = XSYNTH_NUGGET_SIZE; | |||
/* process any ready events */ | |||
while (curEventIndex < midiEventCount && framesDone == midiEvents[curEventIndex].frame) | |||
{ | |||
nekobee_handle_raw_event(&fSynth, midiEvents[curEventIndex].size, midiEvents[curEventIndex].buf); | |||
curEventIndex++; | |||
} | |||
/* calculate the sample count (burstSize) for the next nekobee_voice_render() call to be the smallest of: | |||
* - control calculation quantization size (XSYNTH_NUGGET_SIZE, in samples) | |||
* - the number of samples remaining in an already-begun nugget (synth->nugget_remains) | |||
* - the number of samples until the next event is ready | |||
* - the number of samples left in this run | |||
*/ | |||
burstSize = XSYNTH_NUGGET_SIZE; | |||
/* we're still in the middle of a nugget, so reduce the burst size | |||
* to end when the nugget ends */ | |||
if (fSynth.nugget_remains < burstSize) | |||
burstSize = fSynth.nugget_remains; | |||
/* reduce burst size to end when next event is ready */ | |||
if (curEventIndex < midiEventCount && midiEvents[curEventIndex].frame - framesDone < burstSize) | |||
burstSize = midiEvents[curEventIndex].frame - framesDone; | |||
/* reduce burst size to end at end of this run */ | |||
if (frames - framesDone < burstSize) | |||
burstSize = frames - framesDone; | |||
/* render the burst */ | |||
nekobee_synth_render_voices(&fSynth, out + framesDone, burstSize, (burstSize == fSynth.nugget_remains)); | |||
framesDone += burstSize; | |||
fSynth.nugget_remains -= burstSize; | |||
} | |||
dssp_voicelist_mutex_unlock(&fSynth); | |||
} | |||
// ----------------------------------------------------------------------- | |||
Plugin* createPlugin() | |||
{ | |||
return new DistrhoPluginNekobi(); | |||
} | |||
// ----------------------------------------------------------------------- | |||
END_NAMESPACE_DISTRHO |
@@ -0,0 +1,121 @@ | |||
/* | |||
* DISTRHO Nekobi Plugin, based on Nekobee by Sean Bolton and others. | |||
* Copyright (C) 2004 Sean Bolton and others | |||
* Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com> | |||
* | |||
* 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 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. | |||
* | |||
* For a full copy of the GNU General Public License see the LICENSE file. | |||
*/ | |||
#ifndef DISTRHO_PLUGIN_NEKOBI_HPP_INCLUDED | |||
#define DISTRHO_PLUGIN_NEKOBI_HPP_INCLUDED | |||
#include "DistrhoPlugin.hpp" | |||
extern "C" { | |||
#include "nekobee-src/nekobee_synth.h" | |||
} | |||
START_NAMESPACE_DISTRHO | |||
// ----------------------------------------------------------------------- | |||
class DistrhoPluginNekobi : public Plugin | |||
{ | |||
public: | |||
enum Parameters | |||
{ | |||
paramWaveform = 0, | |||
paramTuning, | |||
paramCutoff, | |||
paramResonance, | |||
paramEnvMod, | |||
paramDecay, | |||
paramAccent, | |||
paramVolume, | |||
paramCount | |||
}; | |||
DistrhoPluginNekobi(); | |||
~DistrhoPluginNekobi() override; | |||
protected: | |||
// ------------------------------------------------------------------- | |||
// Information | |||
const char* d_getLabel() const noexcept override | |||
{ | |||
return "Nekobi"; | |||
} | |||
const char* d_getMaker() const noexcept override | |||
{ | |||
return "DISTRHO"; | |||
} | |||
const char* d_getLicense() const noexcept override | |||
{ | |||
return "GPL v2+"; | |||
} | |||
uint32_t d_getVersion() const noexcept override | |||
{ | |||
return 0x1000; | |||
} | |||
long d_getUniqueId() const noexcept override | |||
{ | |||
return d_cconst('D', 'N', 'e', 'k'); | |||
} | |||
// ------------------------------------------------------------------- | |||
// Init | |||
void d_initParameter(uint32_t index, Parameter& parameter) override; | |||
// ------------------------------------------------------------------- | |||
// Internal data | |||
float d_getParameterValue(uint32_t index) const override; | |||
void d_setParameterValue(uint32_t index, float value) override; | |||
// ------------------------------------------------------------------- | |||
// Process | |||
void d_activate() override; | |||
void d_deactivate() override; | |||
void d_run(const float**, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount) override; | |||
// ------------------------------------------------------------------- | |||
private: | |||
struct ParamValues { | |||
float waveform; | |||
float tuning; | |||
float cutoff; | |||
float resonance; | |||
float envMod; | |||
float decay; | |||
float accent; | |||
float volume; | |||
} fParams; | |||
nekobee_synth_t fSynth; | |||
DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(DistrhoPluginNekobi) | |||
}; | |||
// ----------------------------------------------------------------------- | |||
END_NAMESPACE_DISTRHO | |||
#endif // DISTRHO_PLUGIN_NEKOBI_HPP_INCLUDED |
@@ -0,0 +1,265 @@ | |||
/* | |||
* DISTRHO Nekobi Plugin, based on Nekobee by Sean Bolton and others. | |||
* Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com> | |||
* | |||
* 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 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. | |||
* | |||
* For a full copy of the GNU General Public License see the LICENSE file. | |||
*/ | |||
#include "DistrhoPluginNekobi.hpp" | |||
#include "DistrhoUINekobi.hpp" | |||
using DGL::Point; | |||
START_NAMESPACE_DISTRHO | |||
// ----------------------------------------------------------------------- | |||
DistrhoUINekobi::DistrhoUINekobi() | |||
: UI(), | |||
fAboutWindow(this) | |||
{ | |||
// FIXME | |||
fNeko.setTimerSpeed(4); | |||
// background | |||
fImgBackground = Image(DistrhoArtworkNekobi::backgroundData, DistrhoArtworkNekobi::backgroundWidth, DistrhoArtworkNekobi::backgroundHeight, GL_BGR); | |||
Image aboutImage(DistrhoArtworkNekobi::aboutData, DistrhoArtworkNekobi::aboutWidth, DistrhoArtworkNekobi::aboutHeight, GL_BGR); | |||
fAboutWindow.setImage(aboutImage); | |||
// slider | |||
Image sliderImage(DistrhoArtworkNekobi::sliderData, DistrhoArtworkNekobi::sliderWidth, DistrhoArtworkNekobi::sliderHeight); | |||
fSliderWaveform = new ImageSlider(this, sliderImage); | |||
fSliderWaveform->setStartPos(133, 40); | |||
fSliderWaveform->setEndPos(133, 60); | |||
fSliderWaveform->setRange(0.0f, 1.0f); | |||
fSliderWaveform->setStep(1.0f); | |||
fSliderWaveform->setValue(0.0f); | |||
fSliderWaveform->setCallback(this); | |||
// knobs | |||
Image knobImage(DistrhoArtworkNekobi::knobData, DistrhoArtworkNekobi::knobWidth, DistrhoArtworkNekobi::knobHeight); | |||
// knob Tuning | |||
fKnobTuning = new ImageKnob(this, knobImage); | |||
fKnobTuning->setPos(41, 43); | |||
fKnobTuning->setRange(-12.0f, 12.0f); | |||
fKnobTuning->setValue(0.0f); | |||
fKnobTuning->setRotationAngle(305); | |||
fKnobTuning->setCallback(this); | |||
// knob Cutoff | |||
fKnobCutoff = new ImageKnob(this, knobImage); | |||
fKnobCutoff->setPos(185, 43); | |||
fKnobCutoff->setRange(0.0f, 100.0f); | |||
fKnobCutoff->setValue(25.0f); | |||
fKnobCutoff->setRotationAngle(305); | |||
fKnobCutoff->setCallback(this); | |||
// knob Resonance | |||
fKnobResonance = new ImageKnob(this, knobImage); | |||
fKnobResonance->setPos(257, 43); | |||
fKnobResonance->setRange(0.0f, 95.0f); | |||
fKnobResonance->setValue(25.0f); | |||
fKnobResonance->setRotationAngle(305); | |||
fKnobResonance->setCallback(this); | |||
// knob Env Mod | |||
fKnobEnvMod = new ImageKnob(this, knobImage); | |||
fKnobEnvMod->setPos(329, 43); | |||
fKnobEnvMod->setRange(0.0f, 100.0f); | |||
fKnobEnvMod->setValue(50.0f); | |||
fKnobEnvMod->setRotationAngle(305); | |||
fKnobEnvMod->setCallback(this); | |||
// knob Decay | |||
fKnobDecay = new ImageKnob(this, knobImage); | |||
fKnobDecay->setPos(400, 43); | |||
fKnobDecay->setRange(0.0f, 100.0f); | |||
fKnobDecay->setValue(75.0f); | |||
fKnobDecay->setRotationAngle(305); | |||
fKnobDecay->setCallback(this); | |||
// knob Accent | |||
fKnobAccent = new ImageKnob(this, knobImage); | |||
fKnobAccent->setPos(473, 43); | |||
fKnobAccent->setRange(0.0f, 100.0f); | |||
fKnobAccent->setValue(25.0f); | |||
fKnobAccent->setRotationAngle(305); | |||
fKnobAccent->setCallback(this); | |||
// knob Volume | |||
fKnobVolume = new ImageKnob(this, knobImage); | |||
fKnobVolume->setPos(545, 43); | |||
fKnobVolume->setRange(0.0f, 100.0f); | |||
fKnobVolume->setValue(75.0f); | |||
fKnobVolume->setRotationAngle(305); | |||
fKnobVolume->setCallback(this); | |||
// about button | |||
Image aboutImageNormal(DistrhoArtworkNekobi::aboutButtonNormalData, DistrhoArtworkNekobi::aboutButtonNormalWidth, DistrhoArtworkNekobi::aboutButtonNormalHeight); | |||
Image aboutImageHover(DistrhoArtworkNekobi::aboutButtonHoverData, DistrhoArtworkNekobi::aboutButtonHoverWidth, DistrhoArtworkNekobi::aboutButtonHoverHeight); | |||
fButtonAbout = new ImageButton(this, aboutImageNormal, aboutImageHover, aboutImageHover); | |||
fButtonAbout->setPos(505, 5); | |||
fButtonAbout->setCallback(this); | |||
} | |||
// ----------------------------------------------------------------------- | |||
// DSP Callbacks | |||
void DistrhoUINekobi::d_parameterChanged(uint32_t index, float value) | |||
{ | |||
switch (index) | |||
{ | |||
case DistrhoPluginNekobi::paramTuning: | |||
fKnobTuning->setValue(value); | |||
break; | |||
case DistrhoPluginNekobi::paramWaveform: | |||
fSliderWaveform->setValue(value); | |||
break; | |||
case DistrhoPluginNekobi::paramCutoff: | |||
fKnobCutoff->setValue(value); | |||
break; | |||
case DistrhoPluginNekobi::paramResonance: | |||
fKnobResonance->setValue(value); | |||
break; | |||
case DistrhoPluginNekobi::paramEnvMod: | |||
fKnobEnvMod->setValue(value); | |||
break; | |||
case DistrhoPluginNekobi::paramDecay: | |||
fKnobDecay->setValue(value); | |||
break; | |||
case DistrhoPluginNekobi::paramAccent: | |||
fKnobAccent->setValue(value); | |||
break; | |||
case DistrhoPluginNekobi::paramVolume: | |||
fKnobVolume->setValue(value); | |||
break; | |||
} | |||
} | |||
// ----------------------------------------------------------------------- | |||
// UI Callbacks | |||
void DistrhoUINekobi::d_uiIdle() | |||
{ | |||
if (fNeko.idle()) | |||
repaint(); | |||
} | |||
// ----------------------------------------------------------------------- | |||
// Widget Callbacks | |||
void DistrhoUINekobi::imageButtonClicked(ImageButton* button, int) | |||
{ | |||
if (button != fButtonAbout) | |||
return; | |||
fAboutWindow.exec(); | |||
} | |||
void DistrhoUINekobi::imageKnobDragStarted(ImageKnob* knob) | |||
{ | |||
if (knob == fKnobTuning) | |||
d_editParameter(DistrhoPluginNekobi::paramTuning, true); | |||
else if (knob == fKnobCutoff) | |||
d_editParameter(DistrhoPluginNekobi::paramCutoff, true); | |||
else if (knob == fKnobResonance) | |||
d_editParameter(DistrhoPluginNekobi::paramResonance, true); | |||
else if (knob == fKnobEnvMod) | |||
d_editParameter(DistrhoPluginNekobi::paramEnvMod, true); | |||
else if (knob == fKnobDecay) | |||
d_editParameter(DistrhoPluginNekobi::paramDecay, true); | |||
else if (knob == fKnobAccent) | |||
d_editParameter(DistrhoPluginNekobi::paramAccent, true); | |||
else if (knob == fKnobVolume) | |||
d_editParameter(DistrhoPluginNekobi::paramVolume, true); | |||
} | |||
void DistrhoUINekobi::imageKnobDragFinished(ImageKnob* knob) | |||
{ | |||
if (knob == fKnobTuning) | |||
d_editParameter(DistrhoPluginNekobi::paramTuning, false); | |||
else if (knob == fKnobCutoff) | |||
d_editParameter(DistrhoPluginNekobi::paramCutoff, false); | |||
else if (knob == fKnobResonance) | |||
d_editParameter(DistrhoPluginNekobi::paramResonance, false); | |||
else if (knob == fKnobEnvMod) | |||
d_editParameter(DistrhoPluginNekobi::paramEnvMod, false); | |||
else if (knob == fKnobDecay) | |||
d_editParameter(DistrhoPluginNekobi::paramDecay, false); | |||
else if (knob == fKnobAccent) | |||
d_editParameter(DistrhoPluginNekobi::paramAccent, false); | |||
else if (knob == fKnobVolume) | |||
d_editParameter(DistrhoPluginNekobi::paramVolume, false); | |||
} | |||
void DistrhoUINekobi::imageKnobValueChanged(ImageKnob* knob, float value) | |||
{ | |||
if (knob == fKnobTuning) | |||
d_setParameterValue(DistrhoPluginNekobi::paramTuning, value); | |||
else if (knob == fKnobCutoff) | |||
d_setParameterValue(DistrhoPluginNekobi::paramCutoff, value); | |||
else if (knob == fKnobResonance) | |||
d_setParameterValue(DistrhoPluginNekobi::paramResonance, value); | |||
else if (knob == fKnobEnvMod) | |||
d_setParameterValue(DistrhoPluginNekobi::paramEnvMod, value); | |||
else if (knob == fKnobDecay) | |||
d_setParameterValue(DistrhoPluginNekobi::paramDecay, value); | |||
else if (knob == fKnobAccent) | |||
d_setParameterValue(DistrhoPluginNekobi::paramAccent, value); | |||
else if (knob == fKnobVolume) | |||
d_setParameterValue(DistrhoPluginNekobi::paramVolume, value); | |||
} | |||
void DistrhoUINekobi::imageSliderDragStarted(ImageSlider* slider) | |||
{ | |||
if (slider != fSliderWaveform) | |||
return; | |||
d_editParameter(DistrhoPluginNekobi::paramWaveform, true); | |||
} | |||
void DistrhoUINekobi::imageSliderDragFinished(ImageSlider* slider) | |||
{ | |||
if (slider != fSliderWaveform) | |||
return; | |||
d_editParameter(DistrhoPluginNekobi::paramWaveform, false); | |||
} | |||
void DistrhoUINekobi::imageSliderValueChanged(ImageSlider* slider, float value) | |||
{ | |||
if (slider != fSliderWaveform) | |||
return; | |||
d_setParameterValue(DistrhoPluginNekobi::paramWaveform, value); | |||
} | |||
void DistrhoUINekobi::onDisplay() | |||
{ | |||
fImgBackground.draw(); | |||
fNeko.draw(); | |||
} | |||
// ----------------------------------------------------------------------- | |||
UI* createUI() | |||
{ | |||
return new DistrhoUINekobi(); | |||
} | |||
// ----------------------------------------------------------------------- | |||
END_NAMESPACE_DISTRHO |
@@ -0,0 +1,102 @@ | |||
/* | |||
* DISTRHO Nekobi Plugin, based on Nekobee by Sean Bolton and others. | |||
* Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com> | |||
* | |||
* 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 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. | |||
* | |||
* For a full copy of the GNU General Public License see the LICENSE file. | |||
*/ | |||
#ifndef DISTRHO_UI_NEKOBI_HPP_INCLUDED | |||
#define DISTRHO_UI_NEKOBI_HPP_INCLUDED | |||
#include "DistrhoUI.hpp" | |||
#include "ImageAboutWindow.hpp" | |||
#include "ImageButton.hpp" | |||
#include "ImageKnob.hpp" | |||
#include "ImageSlider.hpp" | |||
#include "DistrhoArtworkNekobi.hpp" | |||
#include "NekoWidget.hpp" | |||
using DGL::ImageAboutWindow; | |||
using DGL::ImageButton; | |||
using DGL::ImageKnob; | |||
using DGL::ImageSlider; | |||
START_NAMESPACE_DISTRHO | |||
// ----------------------------------------------------------------------- | |||
class DistrhoUINekobi : public UI, | |||
public ImageButton::Callback, | |||
public ImageKnob::Callback, | |||
public ImageSlider::Callback | |||
{ | |||
public: | |||
DistrhoUINekobi(); | |||
protected: | |||
// ------------------------------------------------------------------- | |||
// Information | |||
uint d_getWidth() const noexcept override | |||
{ | |||
return DistrhoArtworkNekobi::backgroundWidth; | |||
} | |||
uint d_getHeight() const noexcept override | |||
{ | |||
return DistrhoArtworkNekobi::backgroundHeight; | |||
} | |||
// ------------------------------------------------------------------- | |||
// DSP Callbacks | |||
void d_parameterChanged(uint32_t index, float value) override; | |||
// ------------------------------------------------------------------- | |||
// UI Callbacks | |||
void d_uiIdle() override; | |||
// ------------------------------------------------------------------- | |||
// Widget Callbacks | |||
void imageButtonClicked(ImageButton* button, int) override; | |||
void imageKnobDragStarted(ImageKnob* knob) override; | |||
void imageKnobDragFinished(ImageKnob* knob) override; | |||
void imageKnobValueChanged(ImageKnob* knob, float value) override; | |||
void imageSliderDragStarted(ImageSlider* slider) override; | |||
void imageSliderDragFinished(ImageSlider* slider) override; | |||
void imageSliderValueChanged(ImageSlider* slider, float value) override; | |||
void onDisplay() override; | |||
private: | |||
Image fImgBackground; | |||
ImageAboutWindow fAboutWindow; | |||
NekoWidget fNeko; | |||
ScopedPointer<ImageButton> fButtonAbout; | |||
ScopedPointer<ImageSlider> fSliderWaveform; | |||
ScopedPointer<ImageKnob> fKnobTuning, fKnobCutoff, fKnobResonance; | |||
ScopedPointer<ImageKnob> fKnobEnvMod, fKnobDecay, fKnobAccent, fKnobVolume; | |||
DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(DistrhoUINekobi) | |||
}; | |||
// ----------------------------------------------------------------------- | |||
END_NAMESPACE_DISTRHO | |||
#endif // DISTRHO_UI_NEKOBI_HPP_INCLUDED |
@@ -0,0 +1,27 @@ | |||
#!/usr/bin/make -f | |||
# Makefile for DISTRHO Plugins # | |||
# ---------------------------- # | |||
# Created by falkTX | |||
# | |||
# -------------------------------------------------------------- | |||
# Project name, used for binaries | |||
NAME = Nekobi | |||
# -------------------------------------------------------------- | |||
# Files to build | |||
OBJS_DSP = \ | |||
DistrhoPluginNekobi.cpp.o | |||
OBJS_UI = \ | |||
DistrhoArtworkNekobi.cpp.o \ | |||
DistrhoUINekobi.cpp.o | |||
# -------------------------------------------------------------- | |||
# Do some magic | |||
include ../Makefile.mk | |||
# -------------------------------------------------------------- |
@@ -0,0 +1,202 @@ | |||
/* | |||
* Neko widget animation | |||
* Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com> | |||
* | |||
* 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 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. | |||
* | |||
* For a full copy of the GNU General Public License see the LICENSE file. | |||
*/ | |||
#ifndef NEKO_WIDGET_HPP_INCLUDED | |||
#define NEKO_WIDGET_HPP_INCLUDED | |||
#include "DistrhoArtworkNekobi.hpp" | |||
#include "Image.hpp" | |||
#include "Widget.hpp" | |||
#include <cstdlib> // rand | |||
using DGL::Image; | |||
// ----------------------------------------------------------------------- | |||
class NekoWidget | |||
{ | |||
public: | |||
NekoWidget() | |||
: fPos(0), | |||
fTimer(0), | |||
fTimerSpeed(20), | |||
fCurAction(kActionNone), | |||
fCurImage(&fImages.sit) | |||
{ | |||
// load images | |||
{ | |||
using namespace DistrhoArtworkNekobi; | |||
#define JOIN(a, b) a ## b | |||
#define LOAD_IMAGE(NAME) fImages.NAME.loadFromMemory(JOIN(NAME, Data), JOIN(NAME, Width), JOIN(NAME, Height)); | |||
LOAD_IMAGE(sit) | |||
LOAD_IMAGE(tail) | |||
LOAD_IMAGE(claw1) | |||
LOAD_IMAGE(claw2) | |||
LOAD_IMAGE(scratch1) | |||
LOAD_IMAGE(scratch2) | |||
LOAD_IMAGE(run1) | |||
LOAD_IMAGE(run2) | |||
LOAD_IMAGE(run3) | |||
LOAD_IMAGE(run4) | |||
#undef JOIN | |||
#undef LOAD_IMAGE | |||
} | |||
} | |||
void draw() | |||
{ | |||
int x = fPos+108; | |||
int y = -2; | |||
if (fCurImage == &fImages.claw1 || fCurImage == &fImages.claw2) | |||
{ | |||
x += 2; | |||
y += 12; | |||
} | |||
fCurImage->drawAt(x, y); | |||
} | |||
// returns true if needs repaint | |||
bool idle() | |||
{ | |||
if (++fTimer % fTimerSpeed != 0) // target is 20ms | |||
return false; | |||
if (fTimer == fTimerSpeed*9) | |||
{ | |||
if (fCurAction == kActionNone) | |||
fCurAction = static_cast<Action>(std::rand() % kActionCount); | |||
else | |||
fCurAction = kActionNone; | |||
fTimer = 0; | |||
} | |||
switch (fCurAction) | |||
{ | |||
case kActionNone: | |||
if (fCurImage == &fImages.sit) | |||
fCurImage = &fImages.tail; | |||
else | |||
fCurImage = &fImages.sit; | |||
break; | |||
case kActionClaw: | |||
if (fCurImage == &fImages.claw1) | |||
fCurImage = &fImages.claw2; | |||
else | |||
fCurImage = &fImages.claw1; | |||
break; | |||
case kActionScratch: | |||
if (fCurImage == &fImages.scratch1) | |||
fCurImage = &fImages.scratch2; | |||
else | |||
fCurImage = &fImages.scratch1; | |||
break; | |||
case kActionRunRight: | |||
if (fTimer == 0 && fPos > 20*9) | |||
{ | |||
// run the other way | |||
--fTimer; | |||
fCurAction = kActionRunLeft; | |||
idle(); | |||
break; | |||
} | |||
fPos += 20; | |||
if (fCurImage == &fImages.run1) | |||
fCurImage = &fImages.run2; | |||
else | |||
fCurImage = &fImages.run1; | |||
break; | |||
case kActionRunLeft: | |||
if (fTimer == 0 && fPos < 20*9) | |||
{ | |||
// run the other way | |||
--fTimer; | |||
fCurAction = kActionRunRight; | |||
idle(); | |||
break; | |||
} | |||
fPos -= 20; | |||
if (fCurImage == &fImages.run3) | |||
fCurImage = &fImages.run4; | |||
else | |||
fCurImage = &fImages.run3; | |||
break; | |||
case kActionCount: | |||
break; | |||
} | |||
return true; | |||
} | |||
void setTimerSpeed(int speed) | |||
{ | |||
fTimer = 0; | |||
fTimerSpeed = speed; | |||
} | |||
// ------------------------------------------------------------------- | |||
private: | |||
enum Action { | |||
kActionNone, // bounce tail | |||
kActionClaw, | |||
kActionScratch, | |||
kActionRunRight, | |||
kActionRunLeft, | |||
kActionCount | |||
}; | |||
struct Images { | |||
Image sit; | |||
Image tail; | |||
Image claw1; | |||
Image claw2; | |||
Image scratch1; | |||
Image scratch2; | |||
Image run1; | |||
Image run2; | |||
Image run3; | |||
Image run4; | |||
} fImages; | |||
int fPos; | |||
int fTimer; | |||
int fTimerSpeed; | |||
Action fCurAction; | |||
Image* fCurImage; | |||
}; | |||
// ----------------------------------------------------------------------- | |||
#endif // NEKO_WIDGET_HPP_INCLUDED |
@@ -0,0 +1,77 @@ | |||
/* nekobee DSSI software synthesizer plugin | |||
* | |||
* Copyright (C) 2004 Sean Bolton and others. | |||
* | |||
* Portions of this file may have come from Chris Cannam and Steve | |||
* Harris's public domain DSSI example code. | |||
* | |||
* 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 _XSYNTH_H | |||
#define _XSYNTH_H | |||
/* ==== debugging ==== */ | |||
/* XSYNTH_DEBUG bits */ | |||
#define XDB_DSSI 1 /* DSSI interface */ | |||
#define XDB_AUDIO 2 /* audio output */ | |||
#define XDB_NOTE 4 /* note on/off, voice allocation */ | |||
#define XDB_DATA 8 /* plugin patchbank handling */ | |||
#define GDB_MAIN 16 /* GUI main program flow */ | |||
#define GDB_OSC 32 /* GUI OSC handling */ | |||
#define GDB_IO 64 /* GUI patch file input/output */ | |||
#define GDB_GUI 128 /* GUI GUI callbacks, updating, etc. */ | |||
/* If you want debug information, define XSYNTH_DEBUG to the XDB_* bits you're | |||
* interested in getting debug information about, bitwise-ORed together. | |||
* Otherwise, leave it undefined. */ | |||
// #define XSYNTH_DEBUG (1+8+16+32+64) | |||
//#define XSYNTH_DEBUG GDB_GUI + GDB_OSC | |||
// #define XSYNTH_DEBUG XDB_DSSI | |||
#ifdef XSYNTH_DEBUG | |||
#include <stdio.h> | |||
#define XSYNTH_DEBUG_INIT(x) | |||
#define XDB_MESSAGE(type, fmt...) { if (XSYNTH_DEBUG & type) fprintf(stderr, "nekobee-dssi.so" fmt); } | |||
#define GDB_MESSAGE(type, fmt...) { if (XSYNTH_DEBUG & type) fprintf(stderr, "nekobee_gtk" fmt); } | |||
// -FIX-: | |||
// #include "message_buffer.h" | |||
// #define XSYNTH_DEBUG_INIT(x) mb_init(x) | |||
// #define XDB_MESSAGE(type, fmt...) { \- | |||
// if (XSYNTH_DEBUG & type) { \- | |||
// char _m[256]; \- | |||
// snprintf(_m, 255, fmt); \- | |||
// add_message(_m); \- | |||
// } \- | |||
// } | |||
#else /* !XSYNTH_DEBUG */ | |||
#define XDB_MESSAGE(type, fmt...) | |||
#define GDB_MESSAGE(type, fmt...) | |||
#define XSYNTH_DEBUG_INIT(x) | |||
#endif /* XSYNTH_DEBUG */ | |||
/* ==== end of debugging ==== */ | |||
#define XSYNTH_MAX_POLYPHONY 1 | |||
#define XSYNTH_DEFAULT_POLYPHONY 1 | |||
#endif /* _XSYNTH_H */ |
@@ -0,0 +1,237 @@ | |||
/* nekobee DSSI software synthesizer plugin | |||
* | |||
* Copyright (C) 2004 Sean Bolton and others. | |||
* | |||
* Portions of this file may have come from Steve Brookes' | |||
* nekobee, copyright (C) 1999 S. J. Brookes. | |||
* Portions of this file may have come from Peter Hanappe's | |||
* Fluidsynth, copyright (C) 2003 Peter Hanappe and others. | |||
* Portions of this file may have come from Chris Cannam and Steve | |||
* Harris's public domain DSSI example code. | |||
* | |||
* 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. | |||
*/ | |||
#include <stdlib.h> | |||
#include <stdio.h> | |||
#include <string.h> | |||
#include <math.h> | |||
#include <pthread.h> | |||
#include "nekobee.h" | |||
#include "nekobee_synth.h" | |||
#include "nekobee_voice.h" | |||
/* | |||
* nekobee_synth_all_voices_off | |||
* | |||
* stop processing all notes immediately | |||
*/ | |||
void | |||
nekobee_synth_all_voices_off(nekobee_synth_t *synth) | |||
{ | |||
int i; | |||
nekobee_voice_t *voice; | |||
for (i = 0; i < synth->voices; i++) { | |||
//voice = synth->voice[i]; | |||
voice = synth->voice; | |||
if (_PLAYING(voice)) { | |||
nekobee_voice_off(voice); | |||
} | |||
} | |||
for (i = 0; i < 8; i++) synth->held_keys[i] = -1; | |||
} | |||
/* | |||
* nekobee_synth_note_off | |||
* | |||
* handle a note off message | |||
*/ | |||
void | |||
nekobee_synth_note_off(nekobee_synth_t *synth, unsigned char key, unsigned char rvelocity) | |||
{ | |||
int i, count = 0; | |||
nekobee_voice_t *voice; | |||
for (i = 0; i < synth->voices; i++) { | |||
voice = synth->voice; | |||
if (_PLAYING(voice)) { | |||
XDB_MESSAGE(XDB_NOTE, " nekobee_synth_note_off: key %d rvel %d voice %d note id %d\n", key, rvelocity, i, voice->note_id); | |||
nekobee_voice_note_off(synth, voice, key, 64); | |||
count++; | |||
} | |||
} | |||
if (!count) | |||
nekobee_voice_remove_held_key(synth, key); | |||
return; | |||
(void)rvelocity; | |||
} | |||
/* | |||
* nekobee_synth_all_notes_off | |||
* | |||
* put all notes into the released state | |||
*/ | |||
void | |||
nekobee_synth_all_notes_off(nekobee_synth_t* synth) | |||
{ | |||
int i; | |||
nekobee_voice_t *voice; | |||
/* reset the sustain controller */ | |||
synth->cc[MIDI_CTL_SUSTAIN] = 0; | |||
for (i = 0; i < synth->voices; i++) { | |||
//voice = synth->voice[i]; | |||
voice = synth->voice; | |||
if (_ON(voice) || _SUSTAINED(voice)) { | |||
nekobee_voice_release_note(synth, voice); | |||
} | |||
} | |||
} | |||
/* | |||
* nekobee_synth_note_on | |||
*/ | |||
void | |||
nekobee_synth_note_on(nekobee_synth_t *synth, unsigned char key, unsigned char velocity) | |||
{ | |||
nekobee_voice_t* voice; | |||
voice = synth->voice; | |||
if (_PLAYING(synth->voice)) { | |||
XDB_MESSAGE(XDB_NOTE, " nekobee_synth_note_on: retriggering mono voice on new key %d\n", key); | |||
} | |||
voice->note_id = synth->note_id++; | |||
nekobee_voice_note_on(synth, voice, key, velocity); | |||
} | |||
/* | |||
* nekobee_synth_update_volume | |||
*/ | |||
void | |||
nekobee_synth_update_volume(nekobee_synth_t* synth) | |||
{ | |||
synth->cc_volume = (float)(synth->cc[MIDI_CTL_MSB_MAIN_VOLUME] * 128 + | |||
synth->cc[MIDI_CTL_LSB_MAIN_VOLUME]) / 16256.0f; | |||
if (synth->cc_volume > 1.0f) | |||
synth->cc_volume = 1.0f; | |||
/* don't need to check if any playing voices need updating, because it's global */ | |||
} | |||
/* | |||
* nekobee_synth_control_change | |||
*/ | |||
void | |||
nekobee_synth_control_change(nekobee_synth_t *synth, unsigned int param, signed int value) | |||
{ | |||
synth->cc[param] = value; | |||
switch (param) { | |||
case MIDI_CTL_MSB_MAIN_VOLUME: | |||
case MIDI_CTL_LSB_MAIN_VOLUME: | |||
nekobee_synth_update_volume(synth); | |||
break; | |||
case MIDI_CTL_ALL_SOUNDS_OFF: | |||
nekobee_synth_all_voices_off(synth); | |||
break; | |||
case MIDI_CTL_RESET_CONTROLLERS: | |||
nekobee_synth_init_controls(synth); | |||
break; | |||
case MIDI_CTL_ALL_NOTES_OFF: | |||
nekobee_synth_all_notes_off(synth); | |||
break; | |||
/* what others should we respond to? */ | |||
/* these we ignore (let the host handle): | |||
* BANK_SELECT_MSB | |||
* BANK_SELECT_LSB | |||
* DATA_ENTRY_MSB | |||
* NRPN_MSB | |||
* NRPN_LSB | |||
* RPN_MSB | |||
* RPN_LSB | |||
* -FIX- no! we need RPN (0, 0) Pitch Bend Sensitivity! | |||
*/ | |||
} | |||
} | |||
/* | |||
* nekobee_synth_init_controls | |||
*/ | |||
void | |||
nekobee_synth_init_controls(nekobee_synth_t *synth) | |||
{ | |||
int i; | |||
for (i = 0; i < 128; i++) { | |||
synth->cc[i] = 0; | |||
} | |||
synth->cc[7] = 127; /* full volume */ | |||
nekobee_synth_update_volume(synth); | |||
} | |||
/* | |||
* nekobee_synth_render_voices | |||
*/ | |||
void | |||
nekobee_synth_render_voices(nekobee_synth_t *synth, float *out, unsigned long sample_count, | |||
int do_control_update) | |||
{ | |||
unsigned long i; | |||
float res, wow; | |||
/* clear the buffer */ | |||
for (i = 0; i < sample_count; i++) | |||
out[i] = 0.0f; | |||
// we can do anything that must be updated all the time here | |||
// this is called even when a voice isn't playing | |||
// approximate a log scale | |||
res = 1-synth->resonance; | |||
wow = res*res; | |||
wow = wow/10.0f; | |||
// as the resonance is increased, "wow" slows down the accent attack | |||
if ((synth->voice->velocity>90) && (synth->vcf_accent < synth->voice->vcf_eg)) { | |||
synth->vcf_accent=(0.985-wow)*synth->vcf_accent+(0.015+wow)*synth->voice->vcf_eg; | |||
} else { | |||
synth->vcf_accent=(0.985-wow)*synth->vcf_accent; // or just decay | |||
} | |||
if (synth->voice->velocity>90) { | |||
synth->vca_accent=0.95*synth->vca_accent+0.05; // ramp up accent on with a time constant | |||
} else { | |||
synth->vca_accent=0.95*synth->vca_accent; // accent off with time constant | |||
} | |||
#if defined(XSYNTH_DEBUG) && (XSYNTH_DEBUG & XDB_AUDIO) | |||
out[0] += 0.10f; /* add a 'buzz' to output so there's something audible even when quiescent */ | |||
#endif /* defined(XSYNTH_DEBUG) && (XSYNTH_DEBUG & XDB_AUDIO) */ | |||
if (_PLAYING(synth->voice)) { | |||
nekobee_voice_render(synth, synth->voice, out, sample_count, do_control_update); | |||
} | |||
} |
@@ -0,0 +1,132 @@ | |||
/* nekobee DSSI software synthesizer plugin | |||
* | |||
* Copyright (C) 2004 Sean Bolton and others. | |||
* | |||
* Portions of this file may have come from Peter Hanappe's | |||
* Fluidsynth, copyright (C) 2003 Peter Hanappe and others. | |||
* Portions of this file may have come from alsa-lib, copyright | |||
* and licensed under the LGPL v2.1. | |||
* | |||
* 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 _XSYNTH_SYNTH_H | |||
#define _XSYNTH_SYNTH_H | |||
#include <pthread.h> | |||
#include "nekobee.h" | |||
#include "nekobee_types.h" | |||
#define XSYNTH_MONO_MODE_OFF 0 | |||
#define XSYNTH_MONO_MODE_ON 1 | |||
#define XSYNTH_MONO_MODE_ONCE 2 | |||
#define XSYNTH_MONO_MODE_BOTH 3 | |||
#define XSYNTH_GLIDE_MODE_LEGATO 0 | |||
#define XSYNTH_GLIDE_MODE_INITIAL 1 | |||
#define XSYNTH_GLIDE_MODE_ALWAYS 2 | |||
#define XSYNTH_GLIDE_MODE_LEFTOVER 3 | |||
#define XSYNTH_GLIDE_MODE_OFF 4 | |||
/* | |||
* nekobee_synth_t | |||
*/ | |||
struct _nekobee_synth_t { | |||
/* output */ | |||
unsigned long sample_rate; | |||
float deltat; /* 1 / sample_rate */ | |||
unsigned long nugget_remains; | |||
/* voice tracking and data */ | |||
unsigned int note_id; /* incremented for every new note, used for voice-stealing prioritization */ | |||
int polyphony; /* requested polyphony, must be <= XSYNTH_MAX_POLYPHONY */ | |||
int voices; /* current polyphony, either requested polyphony above or 1 while in monophonic mode */ | |||
int monophonic; /* true if operating in monophonic mode */ | |||
int glide; /* current glide mode */ | |||
float last_noteon_pitch; /* glide start pitch for non-legato modes */ | |||
signed char held_keys[8]; /* for monophonic key tracking, an array of note-ons, most recently received first */ | |||
float vcf_accent; /* used to emulate the circuit that sweeps the vcf at full resonance */ | |||
float vca_accent; /* used to smooth the accent pulse, removing the click */ | |||
//nekobee_voice_t *voice[XSYNTH_MAX_POLYPHONY]; | |||
nekobee_voice_t *voice; | |||
pthread_mutex_t voicelist_mutex; | |||
int voicelist_mutex_grab_failed; | |||
/* current non-paramter-mapped controller values */ | |||
unsigned char key_pressure[128]; | |||
unsigned char cc[128]; /* controller values */ | |||
unsigned char channel_pressure; | |||
unsigned char pitch_wheel_sensitivity; /* in semitones */ | |||
int pitch_wheel; /* range is -8192 - 8191 */ | |||
/* translated controller values */ | |||
float mod_wheel; /* filter cutoff multiplier, off = 1.0, full on = 0.0 */ | |||
float pitch_bend; /* frequency multiplier, product of wheel setting and sensitivity, center = 1.0 */ | |||
float cc_volume; /* volume multiplier, 0.0 to 1.0 */ | |||
/* patch parameters */ | |||
float tuning; | |||
float waveform; | |||
float cutoff; | |||
float resonance; | |||
float envmod; | |||
float decay; | |||
float accent; | |||
float volume; | |||
}; | |||
void nekobee_synth_all_voices_off(nekobee_synth_t *synth); | |||
void nekobee_synth_note_off(nekobee_synth_t *synth, unsigned char key, | |||
unsigned char rvelocity); | |||
void nekobee_synth_all_notes_off(nekobee_synth_t *synth); | |||
void nekobee_synth_note_on(nekobee_synth_t *synth, unsigned char key, | |||
unsigned char velocity); | |||
void nekobee_synth_control_change(nekobee_synth_t *synth, unsigned int param, | |||
signed int value); | |||
void nekobee_synth_init_controls(nekobee_synth_t *synth); | |||
void nekobee_synth_render_voices(nekobee_synth_t *synth, float *out, | |||
unsigned long sample_count, | |||
int do_control_update); | |||
/* these come right out of alsa/asoundef.h */ | |||
#define MIDI_CTL_MSB_MODWHEEL 0x01 /**< Modulation */ | |||
#define MIDI_CTL_MSB_PORTAMENTO_TIME 0x05 /**< Portamento time */ | |||
#define MIDI_CTL_MSB_MAIN_VOLUME 0x07 /**< Main volume */ | |||
#define MIDI_CTL_MSB_BALANCE 0x08 /**< Balance */ | |||
#define MIDI_CTL_LSB_MODWHEEL 0x21 /**< Modulation */ | |||
#define MIDI_CTL_LSB_PORTAMENTO_TIME 0x25 /**< Portamento time */ | |||
#define MIDI_CTL_LSB_MAIN_VOLUME 0x27 /**< Main volume */ | |||
#define MIDI_CTL_LSB_BALANCE 0x28 /**< Balance */ | |||
#define MIDI_CTL_SUSTAIN 0x40 /**< Sustain pedal */ | |||
// nekobee defines | |||
#define MIDI_CTL_TUNING 0x4b // impossible | |||
#define MIDI_CTL_WAVEFORM 0x46 // select waveform | |||
#define MIDI_CTL_CUTOFF 0x4a // VCF Cutoff | |||
#define MIDI_CTL_RESONANCE 0x47 // VCF Resonance | |||
#define MIDI_CTL_ENVMOD 0x01 // cheat and use modwheel | |||
#define MIDI_CTL_DECAY 0x48 // Decay time (well release really) | |||
#define MIDI_CTL_ACCENT 0x4c // impossible | |||
#define MIDI_CTL_ALL_SOUNDS_OFF 0x78 /**< All sounds off */ | |||
#define MIDI_CTL_RESET_CONTROLLERS 0x79 /**< Reset Controllers */ | |||
#define MIDI_CTL_ALL_NOTES_OFF 0x7b /**< All notes off */ | |||
#define XSYNTH_SYNTH_SUSTAINED(_s) ((_s)->cc[MIDI_CTL_SUSTAIN] >= 64) | |||
#endif /* _XSYNTH_SYNTH_H */ |
@@ -0,0 +1,30 @@ | |||
/* nekobee DSSI software synthesizer plugin | |||
* | |||
* Copyright (C) 2004 Sean Bolton and others. | |||
* | |||
* 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 library; if not, write to the Free | |||
* Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |||
* MA 02111-1307, USA. | |||
*/ | |||
#ifndef _XSYNTH_TYPES_H | |||
#define _XSYNTH_TYPES_H | |||
#include <stddef.h> | |||
typedef struct _nekobee_synth_t nekobee_synth_t; | |||
typedef struct _nekobee_voice_t nekobee_voice_t; | |||
typedef struct _nekobee_patch_t nekobee_patch_t; | |||
#endif /* _XSYNTH_TYPES_H */ |
@@ -0,0 +1,256 @@ | |||
/* nekobee DSSI software synthesizer plugin | |||
* | |||
* Copyright (C) 2004 Sean Bolton and others. | |||
* | |||
* Portions of this file may have come from Steve Brookes' | |||
* nekobee, copyright (C) 1999 S. J. Brookes. | |||
* Portions of this file may have come from Peter Hanappe's | |||
* Fluidsynth, copyright (C) 2003 Peter Hanappe and others. | |||
* | |||
* 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. | |||
*/ | |||
#define _BSD_SOURCE 1 | |||
#define _SVID_SOURCE 1 | |||
#define _ISOC99_SOURCE 1 | |||
#include <stdlib.h> | |||
#include "nekobee_types.h" | |||
#include "nekobee.h" | |||
#include "nekobee_synth.h" | |||
#include "nekobee_voice.h" | |||
/* | |||
* nekobee_voice_new | |||
*/ | |||
nekobee_voice_t * | |||
nekobee_voice_new() | |||
{ | |||
nekobee_voice_t *voice; | |||
voice = (nekobee_voice_t *)calloc(sizeof(nekobee_voice_t), 1); | |||
if (voice) { | |||
voice->status = XSYNTH_VOICE_OFF; | |||
} | |||
return voice; | |||
} | |||
/* | |||
* nekobee_voice_note_on | |||
*/ | |||
void | |||
nekobee_voice_note_on(nekobee_synth_t *synth, nekobee_voice_t *voice, | |||
unsigned char key, unsigned char velocity) | |||
{ | |||
int i; | |||
voice->key = key; | |||
voice->velocity = velocity; | |||
if (!synth->monophonic || !(_ON(voice) || _SUSTAINED(voice))) { | |||
// brand-new voice, or monophonic voice in release phase; set everything up | |||
XDB_MESSAGE(XDB_NOTE, " nekobee_voice_note_on in polyphonic/new section: key %d, mono %d, old status %d\n", key, synth->monophonic, voice->status); | |||
voice->target_pitch = nekobee_pitch[key]; | |||
if (synth->held_keys[0] >= 0) { | |||
voice->prev_pitch = nekobee_pitch[synth->held_keys[0]]; | |||
} else { | |||
voice->prev_pitch = voice->target_pitch; | |||
} | |||
if (!_PLAYING(voice)) { | |||
voice->lfo_pos = 0.0f; | |||
voice->vca_eg = 0.0f; | |||
voice->vcf_eg = 0.0f; | |||
voice->delay1 = 0.0f; | |||
voice->delay2 = 0.0f; | |||
voice->delay3 = 0.0f; | |||
voice->delay4 = 0.0f; | |||
voice->c5 = 0.0f; | |||
voice->osc_index = 0; | |||
voice->osc1.last_waveform = -1; | |||
voice->osc1.pos = 0.0f; | |||
} | |||
voice->vca_eg_phase = 0; | |||
voice->vcf_eg_phase = 0; | |||
// nekobee_voice_update_pressure_mod(synth, voice); | |||
} else { | |||
/* synth is monophonic, and we're modifying a playing voice */ | |||
XDB_MESSAGE(XDB_NOTE, " nekobee_voice_note_on in monophonic section: old key %d => new key %d\n", synth->held_keys[0], key); | |||
/* set new pitch */ | |||
voice->target_pitch = nekobee_pitch[key]; | |||
if (synth->glide == XSYNTH_GLIDE_MODE_INITIAL || | |||
synth->glide == XSYNTH_GLIDE_MODE_OFF) | |||
voice->prev_pitch = voice->target_pitch; | |||
/* if in 'on' or 'both' modes, and key has changed, then re-trigger EGs */ | |||
if ((synth->monophonic == XSYNTH_MONO_MODE_ON || | |||
synth->monophonic == XSYNTH_MONO_MODE_BOTH) && | |||
(synth->held_keys[0] < 0 || synth->held_keys[0] != key)) { | |||
voice->vca_eg_phase = 0; | |||
voice->vcf_eg_phase = 0; | |||
} | |||
/* all other variables stay what they are */ | |||
} | |||
synth->last_noteon_pitch = voice->target_pitch; | |||
/* add new key to the list of held keys */ | |||
/* check if new key is already in the list; if so, move it to the | |||
* top of the list, otherwise shift the other keys down and add it | |||
* to the top of the list. */ | |||
for (i = 0; i < 7; i++) { | |||
if (synth->held_keys[i] == key) | |||
break; | |||
} | |||
for (; i > 0; i--) { | |||
synth->held_keys[i] = synth->held_keys[i - 1]; | |||
} | |||
synth->held_keys[0] = key; | |||
if (!_PLAYING(voice)) { | |||
nekobee_voice_start_voice(voice); | |||
} else if (!_ON(voice)) { /* must be XSYNTH_VOICE_SUSTAINED or XSYNTH_VOICE_RELEASED */ | |||
voice->status = XSYNTH_VOICE_ON; | |||
} | |||
} | |||
/* | |||
* nekobee_voice_set_release_phase | |||
*/ | |||
static inline void | |||
nekobee_voice_set_release_phase(nekobee_voice_t *voice) | |||
{ | |||
voice->vca_eg_phase = 2; | |||
voice->vcf_eg_phase = 2; | |||
} | |||
/* | |||
* nekobee_voice_remove_held_key | |||
*/ | |||
inline void | |||
nekobee_voice_remove_held_key(nekobee_synth_t *synth, unsigned char key) | |||
{ | |||
int i; | |||
/* check if this key is in list of held keys; if so, remove it and | |||
* shift the other keys up */ | |||
for (i = 7; i >= 0; i--) { | |||
if (synth->held_keys[i] == key) | |||
break; | |||
} | |||
if (i >= 0) { | |||
for (; i < 7; i++) { | |||
synth->held_keys[i] = synth->held_keys[i + 1]; | |||
} | |||
synth->held_keys[7] = -1; | |||
} | |||
} | |||
/* | |||
* nekobee_voice_note_off | |||
*/ | |||
void | |||
nekobee_voice_note_off(nekobee_synth_t *synth, nekobee_voice_t *voice, | |||
unsigned char key, unsigned char rvelocity) | |||
{ | |||
unsigned char previous_top_key; | |||
XDB_MESSAGE(XDB_NOTE, " nekobee_set_note_off: called for voice %p, key %d\n", voice, key); | |||
/* save release velocity */ | |||
voice->velocity = rvelocity; | |||
previous_top_key = synth->held_keys[0]; | |||
/* remove this key from list of held keys */ | |||
nekobee_voice_remove_held_key(synth, key); | |||
if (synth->held_keys[0] >= 0) { | |||
/* still some keys held */ | |||
if (synth->held_keys[0] != previous_top_key) { | |||
/* most-recently-played key has changed */ | |||
voice->key = synth->held_keys[0]; | |||
XDB_MESSAGE(XDB_NOTE, " note-off in monophonic section: changing pitch to %d\n", voice->key); | |||
voice->target_pitch = nekobee_pitch[voice->key]; | |||
if (synth->glide == XSYNTH_GLIDE_MODE_INITIAL || | |||
synth->glide == XSYNTH_GLIDE_MODE_OFF) | |||
voice->prev_pitch = voice->target_pitch; | |||
/* if mono mode is 'both', re-trigger EGs */ | |||
if (synth->monophonic == XSYNTH_MONO_MODE_BOTH && !_RELEASED(voice)) { | |||
voice->vca_eg_phase = 0; | |||
voice->vcf_eg_phase = 0; | |||
} | |||
} | |||
} else { /* no keys still held */ | |||
if (XSYNTH_SYNTH_SUSTAINED(synth)) { | |||
/* no more keys in list, but we're sustained */ | |||
XDB_MESSAGE(XDB_NOTE, " note-off in monophonic section: sustained with no held keys\n"); | |||
if (!_RELEASED(voice)) | |||
voice->status = XSYNTH_VOICE_SUSTAINED; | |||
} else { /* not sustained */ | |||
/* no more keys in list, so turn off note */ | |||
XDB_MESSAGE(XDB_NOTE, " note-off in monophonic section: turning off voice %p\n", voice); | |||
nekobee_voice_set_release_phase(voice); | |||
voice->status = XSYNTH_VOICE_RELEASED; | |||
} | |||
} | |||
} | |||
/* | |||
* nekobee_voice_release_note | |||
*/ | |||
void | |||
nekobee_voice_release_note(nekobee_synth_t *synth, nekobee_voice_t *voice) | |||
{ | |||
XDB_MESSAGE(XDB_NOTE, " nekobee_voice_release_note: turning off voice %p\n", voice); | |||
if (_ON(voice)) { | |||
/* dummy up a release velocity */ | |||
voice->rvelocity = 64; | |||
} | |||
nekobee_voice_set_release_phase(voice); | |||
voice->status = XSYNTH_VOICE_RELEASED; | |||
return; | |||
(void)synth; | |||
} |
@@ -0,0 +1,183 @@ | |||
/* nekobee DSSI software synthesizer plugin | |||
* | |||
* Copyright (C) 2004 Sean Bolton and others. | |||
* | |||
* Portions of this file may have come from Steve Brookes' | |||
* nekobee, copyright (C) 1999 S. J. Brookes. | |||
* Portions of this file may have come from Peter Hanappe's | |||
* Fluidsynth, copyright (C) 2003 Peter Hanappe and others. | |||
* | |||
* 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 _XSYNTH_VOICE_H | |||
#define _XSYNTH_VOICE_H | |||
#include <string.h> | |||
#include "nekobee_types.h" | |||
/* maximum size of a rendering burst */ | |||
#define XSYNTH_NUGGET_SIZE 64 | |||
/* minBLEP constants */ | |||
/* minBLEP table oversampling factor (must be a power of two): */ | |||
#define MINBLEP_PHASES 64 | |||
/* MINBLEP_PHASES minus one: */ | |||
#define MINBLEP_PHASE_MASK 63 | |||
/* length in samples of (truncated) step discontinuity delta: */ | |||
#define STEP_DD_PULSE_LENGTH 72 | |||
/* length in samples of (truncated) slope discontinuity delta: */ | |||
#define SLOPE_DD_PULSE_LENGTH 71 | |||
/* the longer of the two above: */ | |||
#define LONGEST_DD_PULSE_LENGTH STEP_DD_PULSE_LENGTH | |||
/* MINBLEP_BUFFER_LENGTH must be at least XSYNTH_NUGGET_SIZE plus | |||
* LONGEST_DD_PULSE_LENGTH, and not less than twice LONGEST_DD_PULSE_LENGTH: */ | |||
#define MINBLEP_BUFFER_LENGTH 512 | |||
/* delay between start of DD pulse and the discontinuity, in samples: */ | |||
#define DD_SAMPLE_DELAY 4 | |||
struct _nekobee_patch_t | |||
{ | |||
float tuning; | |||
unsigned char waveform; | |||
float cutoff; | |||
float resonance; | |||
float envmod; | |||
float decay; | |||
float accent; | |||
float volume; | |||
}; | |||
enum nekobee_voice_status | |||
{ | |||
XSYNTH_VOICE_OFF, /* silent: is not processed by render loop */ | |||
XSYNTH_VOICE_ON, /* has not received a note off event */ | |||
XSYNTH_VOICE_SUSTAINED, /* has received note off, but sustain controller is on */ | |||
XSYNTH_VOICE_RELEASED /* had note off, not sustained, in final decay phase of envelopes */ | |||
}; | |||
struct blosc | |||
{ | |||
int last_waveform, /* persistent */ | |||
waveform, /* comes from LADSPA port each cycle */ | |||
bp_high; /* persistent */ | |||
float pos, /* persistent */ | |||
pw; /* comes from LADSPA port each cycle */ | |||
}; | |||
/* | |||
* nekobee_voice_t | |||
*/ | |||
struct _nekobee_voice_t | |||
{ | |||
unsigned int note_id; | |||
unsigned char status; | |||
unsigned char key; | |||
unsigned char velocity; | |||
unsigned char rvelocity; /* the note-off velocity */ | |||
/* translated controller values */ | |||
float pressure; /* filter resonance multiplier, off = 1.0, full on = 0.0 */ | |||
/* persistent voice state */ | |||
float prev_pitch, | |||
target_pitch, | |||
lfo_pos; | |||
struct blosc osc1; | |||
float vca_eg, | |||
vcf_eg, | |||
accent_slug, | |||
delay1, | |||
delay2, | |||
delay3, | |||
delay4, | |||
c5; | |||
unsigned char vca_eg_phase, | |||
vcf_eg_phase; | |||
int osc_index; /* shared index into osc_audio */ | |||
float osc_audio[MINBLEP_BUFFER_LENGTH]; | |||
float freqcut_buf[XSYNTH_NUGGET_SIZE]; | |||
float vca_buf[XSYNTH_NUGGET_SIZE]; | |||
}; | |||
#define _PLAYING(voice) ((voice)->status != XSYNTH_VOICE_OFF) | |||
#define _ON(voice) ((voice)->status == XSYNTH_VOICE_ON) | |||
#define _SUSTAINED(voice) ((voice)->status == XSYNTH_VOICE_SUSTAINED) | |||
#define _RELEASED(voice) ((voice)->status == XSYNTH_VOICE_RELEASED) | |||
#define _AVAILABLE(voice) ((voice)->status == XSYNTH_VOICE_OFF) | |||
extern float nekobee_pitch[128]; | |||
typedef struct { float value, delta; } float_value_delta; | |||
extern float_value_delta step_dd_table[]; | |||
extern float slope_dd_table[]; | |||
/* nekobee_voice.c */ | |||
nekobee_voice_t *nekobee_voice_new(); | |||
void nekobee_voice_note_on(nekobee_synth_t *synth, | |||
nekobee_voice_t *voice, | |||
unsigned char key, | |||
unsigned char velocity); | |||
void nekobee_voice_remove_held_key(nekobee_synth_t *synth, | |||
unsigned char key); | |||
void nekobee_voice_note_off(nekobee_synth_t *synth, | |||
nekobee_voice_t *voice, | |||
unsigned char key, | |||
unsigned char rvelocity); | |||
void nekobee_voice_release_note(nekobee_synth_t *synth, | |||
nekobee_voice_t *voice); | |||
void nekobee_voice_set_ports(nekobee_synth_t *synth, | |||
nekobee_patch_t *patch); | |||
void nekobee_voice_update_pressure_mod(nekobee_synth_t *synth, | |||
nekobee_voice_t *voice); | |||
/* nekobee_voice_render.c */ | |||
void nekobee_init_tables(void); | |||
void nekobee_voice_render(nekobee_synth_t *synth, nekobee_voice_t *voice, | |||
float *out, unsigned long sample_count, | |||
int do_control_update); | |||
/* inline functions */ | |||
/* | |||
* nekobee_voice_off | |||
* | |||
* Purpose: Turns off a voice immediately, meaning that it is not processed | |||
* anymore by the render loop. | |||
*/ | |||
static inline void | |||
nekobee_voice_off(nekobee_voice_t* voice) | |||
{ | |||
voice->status = XSYNTH_VOICE_OFF; | |||
/* silence the oscillator buffer for the next use */ | |||
memset(voice->osc_audio, 0, MINBLEP_BUFFER_LENGTH * sizeof(float)); | |||
/* -FIX- decrement active voice count? */ | |||
} | |||
/* | |||
* nekobee_voice_start_voice | |||
*/ | |||
static inline void | |||
nekobee_voice_start_voice(nekobee_voice_t *voice) | |||
{ | |||
voice->status = XSYNTH_VOICE_ON; | |||
/* -FIX- increment active voice count? */ | |||
} | |||
#endif /* _XSYNTH_VOICE_H */ |
@@ -0,0 +1,414 @@ | |||
/* nekobee DSSI software synthesizer plugin | |||
*/ | |||
#define _BSD_SOURCE 1 | |||
#define _SVID_SOURCE 1 | |||
#define _ISOC99_SOURCE 1 | |||
#include <math.h> | |||
#include "nekobee.h" | |||
#include "nekobee_synth.h" | |||
#include "nekobee_voice.h" | |||
#ifndef M_PI | |||
#define M_PI 3.14159265358979323846 | |||
#endif | |||
#define M_2PI_F (2.0f * (float)M_PI) | |||
#define M_PI_F (float)M_PI | |||
#define VCF_FREQ_MAX (0.825f) /* original filters only stable to this frequency */ | |||
static int tables_initialized = 0; | |||
float nekobee_pitch[128]; | |||
#define pitch_ref_note 69 | |||
#define volume_to_amplitude_scale 128 | |||
static float volume_to_amplitude_table[4 + volume_to_amplitude_scale + 2]; | |||
static float velocity_to_attenuation[128]; | |||
static float qdB_to_amplitude_table[4 + 256 + 0]; | |||
void | |||
nekobee_init_tables(void) | |||
{ | |||
int i; | |||
float pexp; | |||
float volume, volume_exponent; | |||
float ol, amp; | |||
if (tables_initialized) | |||
return; | |||
/* MIDI note to pitch */ | |||
for (i = 0; i < 128; ++i) { | |||
pexp = (float)(i - pitch_ref_note) / 12.0f; | |||
nekobee_pitch[i] = powf(2.0f, pexp); | |||
} | |||
/* volume to amplitude | |||
* | |||
* This generates a curve which is: | |||
* volume_to_amplitude_table[128 + 4] = 0.25 * 3.16... ~= -2dB | |||
* volume_to_amplitude_table[64 + 4] = 0.25 * 1.0 ~= -12dB | |||
* volume_to_amplitude_table[32 + 4] = 0.25 * 0.316... ~= -22dB | |||
* volume_to_amplitude_table[16 + 4] = 0.25 * 0.1 ~= -32dB | |||
* etc. | |||
*/ | |||
volume_exponent = 1.0f / (2.0f * log10f(2.0f)); | |||
for (i = 0; i <= volume_to_amplitude_scale; i++) { | |||
volume = (float)i / (float)volume_to_amplitude_scale; | |||
volume_to_amplitude_table[i + 4] = powf(2.0f * volume, volume_exponent) / 4.0f; | |||
} | |||
volume_to_amplitude_table[ -1 + 4] = 0.0f; | |||
volume_to_amplitude_table[129 + 4] = volume_to_amplitude_table[128 + 4]; | |||
/* velocity to attenuation | |||
* | |||
* Creates the velocity to attenuation lookup table, for converting | |||
* velocities [1, 127] to full-velocity-sensitivity attenuation in | |||
* quarter decibels. Modeled after my TX-7's velocity response.*/ | |||
velocity_to_attenuation[0] = 253.9999f; | |||
for (i = 1; i < 127; i++) { | |||
if (i >= 10) { | |||
ol = (powf(((float)i / 127.0f), 0.32f) - 1.0f) * 100.0f; | |||
amp = powf(2.0f, ol / 8.0f); | |||
} else { | |||
ol = (powf(((float)10 / 127.0f), 0.32f) - 1.0f) * 100.0f; | |||
amp = powf(2.0f, ol / 8.0f) * (float)i / 10.0f; | |||
} | |||
velocity_to_attenuation[i] = log10f(amp) * -80.0f; | |||
} | |||
velocity_to_attenuation[127] = 0.0f; | |||
/* quarter-decibel attenuation to amplitude */ | |||
qdB_to_amplitude_table[-1 + 4] = 1.0f; | |||
for (i = 0; i <= 255; i++) { | |||
qdB_to_amplitude_table[i + 4] = powf(10.0f, (float)i / -80.0f); | |||
} | |||
tables_initialized = 1; | |||
} | |||
static inline float | |||
volume(float level) | |||
{ | |||
unsigned char segment; | |||
float fract; | |||
level *= (float)volume_to_amplitude_scale; | |||
segment = lrintf(level - 0.5f); | |||
fract = level - (float)segment; | |||
return volume_to_amplitude_table[segment + 4] + fract * | |||
(volume_to_amplitude_table[segment + 5] - | |||
volume_to_amplitude_table[segment + 4]); | |||
} | |||
static inline float | |||
qdB_to_amplitude(float qdB) | |||
{ | |||
int i = lrintf(qdB - 0.5f); | |||
float f = qdB - (float)i; | |||
return qdB_to_amplitude_table[i + 4] + f * | |||
(qdB_to_amplitude_table[i + 5] - | |||
qdB_to_amplitude_table[i + 4]); | |||
} | |||
void blosc_place_step_dd(float *buffer, int index, float phase, float w, float scale){ | |||
float r; | |||
int i; | |||
r = MINBLEP_PHASES * phase / w; | |||
i = lrintf(r - 0.5f); | |||
r -= (float)i; | |||
i &= MINBLEP_PHASE_MASK; /* port changes can cause i to be out-of-range */ | |||
/* This would be better than the above, but more expensive: | |||
* while (i < 0) { | |||
* i += MINBLEP_PHASES; | |||
* index++; | |||
* } | |||
*/ | |||
while (i < MINBLEP_PHASES * STEP_DD_PULSE_LENGTH) { | |||
buffer[index] += scale * (step_dd_table[i].value + r * step_dd_table[i].delta); | |||
i += MINBLEP_PHASES; | |||
index++; | |||
} | |||
} | |||
void vco(unsigned long sample_count, nekobee_voice_t *voice, struct blosc *osc, | |||
int index, float w) | |||
{ | |||
unsigned long sample; | |||
float pos = osc->pos; | |||
float pw, gain, halfgain, out; | |||
pw=0.46f; | |||
gain=1.0f; | |||
halfgain=gain*0.5f; | |||
int bp_high = osc->bp_high; | |||
out=(bp_high ? halfgain : -halfgain); | |||
switch (osc->waveform) | |||
{ | |||
default: | |||
case 0: { | |||
for (sample = 0; sample < sample_count; sample++) { | |||
pos += w; | |||
if (bp_high) { | |||
if (pos >= pw) { | |||
blosc_place_step_dd(voice->osc_audio, index, pos - pw, w, -gain); | |||
bp_high = 0; | |||
out = -halfgain; | |||
} | |||
if (pos >= 1.0f) { | |||
pos -= 1.0f; | |||
blosc_place_step_dd(voice->osc_audio, index, pos, w, gain); | |||
bp_high = 1; | |||
out = halfgain; | |||
} | |||
} else { | |||
if (pos >= 1.0f) { | |||
pos -= 1.0f; | |||
blosc_place_step_dd(voice->osc_audio, index, pos, w, gain); | |||
bp_high = 1; | |||
out = halfgain; | |||
} | |||
if (bp_high && pos >= pw) { | |||
blosc_place_step_dd(voice->osc_audio, index, pos - pw, w, -gain); | |||
bp_high = 0; | |||
out = -halfgain; | |||
} | |||
} | |||
voice->osc_audio[index + DD_SAMPLE_DELAY] += out; | |||
index++; | |||
} | |||
osc->pos = pos; | |||
osc->bp_high = bp_high; | |||
break; | |||
} | |||
case 1: // sawtooth wave | |||
{ | |||
for (sample=0; sample < sample_count; sample++) { | |||
pos += w; | |||
if (pos >= 1.0f) { | |||
pos -= 1.0f; | |||
blosc_place_step_dd(voice->osc_audio, index, pos, w, gain); | |||
} | |||
voice->osc_audio[index + DD_SAMPLE_DELAY] += gain * (0.5f - pos); | |||
index++; | |||
} | |||
break; | |||
} | |||
} | |||
osc->pos=pos; | |||
} | |||
static inline void | |||
vcf_4pole(nekobee_voice_t *voice, unsigned long sample_count, | |||
float *in, float *out, float *cutoff, float qres, float *amp) | |||
{ | |||
unsigned long sample; | |||
float freqcut, freqcut2, highpass, | |||
delay1 = voice->delay1, | |||
delay2 = voice->delay2, | |||
delay3 = voice->delay3, | |||
delay4 = voice->delay4; | |||
qres = 2.0f - qres * 1.995f; | |||
for (sample = 0; sample < sample_count; sample++) { | |||
/* Hal Chamberlin's state variable filter */ | |||
freqcut = cutoff[sample] * 2.0f; | |||
freqcut2 = cutoff[sample] * 4.0f; | |||
if (freqcut > VCF_FREQ_MAX) freqcut = VCF_FREQ_MAX; | |||
if (freqcut2 > VCF_FREQ_MAX) freqcut2 = VCF_FREQ_MAX; | |||
delay2 = delay2 + freqcut * delay1; /* delay2/4 = lowpass output */ | |||
highpass = in[sample] - delay2 - qres * delay1; | |||
delay1 = freqcut * highpass + delay1; /* delay1/3 = bandpass output */ | |||
delay4 = delay4 + freqcut2 * delay3; | |||
highpass = delay2 - delay4 - qres * delay3; | |||
delay3 = freqcut2 * highpass + delay3; | |||
/* mix filter output into output buffer */ | |||
out[sample] += 0.1*atan(3*delay4 * amp[sample]); | |||
} | |||
voice->delay1 = delay1; | |||
voice->delay2 = delay2; | |||
voice->delay3 = delay3; | |||
voice->delay4 = delay4; | |||
voice->c5 = 0.0f; | |||
} | |||
/* | |||
* nekobee_voice_render | |||
* | |||
* generate the actual sound data for this voice | |||
*/ | |||
void | |||
nekobee_voice_render(nekobee_synth_t *synth, nekobee_voice_t *voice, | |||
float *out, unsigned long sample_count, | |||
int do_control_update) | |||
{ | |||
unsigned long sample; | |||
/* state variables saved in voice */ | |||
float lfo_pos = voice->lfo_pos, | |||
vca_eg = voice->vca_eg, | |||
vcf_eg = voice->vcf_eg; | |||
unsigned char vca_eg_phase = voice->vca_eg_phase, | |||
vcf_eg_phase = voice->vcf_eg_phase; | |||
int osc_index = voice->osc_index; | |||
/* temporary variables used in calculating voice */ | |||
float fund_pitch; | |||
float deltat = synth->deltat; | |||
float freq, cutoff, vcf_amt; | |||
float vcf_acc_amt; | |||
/* set up synthesis variables from patch */ | |||
float omega; | |||
float vca_eg_amp = qdB_to_amplitude(velocity_to_attenuation[voice->velocity] * 0); | |||
float vca_eg_rate_level[3], vca_eg_one_rate[3]; | |||
float vcf_eg_amp = qdB_to_amplitude(velocity_to_attenuation[voice->velocity] * 0); | |||
float vcf_eg_rate_level[3], vcf_eg_one_rate[3]; | |||
float qres = synth->resonance; | |||
float vol_out = volume(synth->volume); | |||
float velocity = (voice->velocity); | |||
float vcf_egdecay = synth->decay; | |||
fund_pitch = 0.1f*voice->target_pitch +0.9 * voice->prev_pitch; /* glide */ | |||
if (do_control_update) { | |||
voice->prev_pitch = fund_pitch; /* save pitch for next time */ | |||
} | |||
fund_pitch *= 440.0f; | |||
omega = synth->tuning * fund_pitch; | |||
// if we have triggered ACCENT | |||
// we need a shorter decay | |||
// we should probably have something like this in the note on code | |||
// that could trigger an ACCENT light | |||
if (velocity>90) { | |||
vcf_egdecay=.0005; | |||
} | |||
// VCA - In a real 303, it is set for around 2 seconds | |||
vca_eg_rate_level[0] = 0.1f * vca_eg_amp; // instant on attack | |||
vca_eg_one_rate[0] = 0.9f; // very fast | |||
vca_eg_rate_level[1] = 0.0f; // sustain is zero | |||
vca_eg_one_rate[1] = 1.0f - 0.00001f; // decay time is very slow | |||
vca_eg_rate_level[2] = 0.0f; // decays to zero | |||
vca_eg_one_rate[2] = 0.975f; // very fast release | |||
// VCF - funny things go on with the accent | |||
vcf_eg_rate_level[0] = 0.1f * vcf_eg_amp; | |||
vcf_eg_one_rate[0] = 1-0.1f; //0.9f; | |||
vcf_eg_rate_level[1] = 0.0f; // vcf_egdecay * *(synth->vcf_eg_sustain_level) * vcf_eg_amp; | |||
vcf_eg_one_rate[1] = 1.0f - vcf_egdecay; | |||
vcf_eg_rate_level[2] = 0.0f; | |||
vcf_eg_one_rate[2] = 0.9995f; // 1.0f - *(synth->vcf_eg_release_time); | |||
vca_eg_amp *= 0.99f; | |||
vcf_eg_amp *= 0.99f; | |||
freq = M_PI_F * deltat * fund_pitch * synth->mod_wheel; /* now (0 to 1) * pi */ | |||
cutoff = 0.008f * synth->cutoff; | |||
// 303 always has slight VCF mod | |||
vcf_amt = 0.05f+(synth->envmod*0.75); | |||
/* copy some things so oscillator functions can see them */ | |||
voice->osc1.waveform = lrintf(synth->waveform); | |||
// work out how much the accent will affect the filter | |||
vcf_acc_amt=.333f+ (synth->resonance/1.5f); | |||
for (sample = 0; sample < sample_count; sample++) { | |||
vca_eg = vca_eg_rate_level[vca_eg_phase] + vca_eg_one_rate[vca_eg_phase] * vca_eg; | |||
vcf_eg = vcf_eg_rate_level[vcf_eg_phase] + vcf_eg_one_rate[vcf_eg_phase] * vcf_eg; | |||
voice->freqcut_buf[sample] = (cutoff + (vcf_amt * vcf_eg/2.0f) + (synth->vcf_accent * synth->accent*0.5f)); | |||
voice->vca_buf[sample] = vca_eg * vol_out*(1.0f + synth->accent*synth->vca_accent); | |||
if (!vca_eg_phase && vca_eg > vca_eg_amp) vca_eg_phase = 1; /* flip from attack to decay */ | |||
if (!vcf_eg_phase && vcf_eg > vcf_eg_amp) vcf_eg_phase = 1; /* flip from attack to decay */ | |||
} | |||
// oscillator | |||
vco(sample_count, voice, &voice->osc1, osc_index, deltat * omega); | |||
// VCF and VCA | |||
vcf_4pole(voice, sample_count, voice->osc_audio + osc_index, out, voice->freqcut_buf, qres, voice->vca_buf); | |||
osc_index += sample_count; | |||
if (do_control_update) { | |||
/* do those things should be done only once per control-calculation | |||
* interval ("nugget"), such as voice check-for-dead, pitch envelope | |||
* calculations, volume envelope phase transition checks, etc. */ | |||
/* check if we've decayed to nothing, turn off voice if so */ | |||
if (vca_eg_phase == 2 && voice->vca_buf[sample_count - 1] < 6.26e-6f) { | |||
// sound has completed its release phase (>96dB below volume '5' max) | |||
XDB_MESSAGE(XDB_NOTE, " nekobee_voice_render check for dead: killing note id %d\n", voice->note_id); | |||
nekobee_voice_off(voice); | |||
return; // we're dead now, so return | |||
} | |||
/* already saved prev_pitch above */ | |||
/* check oscillator audio buffer index, shift buffer if necessary */ | |||
if (osc_index > MINBLEP_BUFFER_LENGTH - (XSYNTH_NUGGET_SIZE + LONGEST_DD_PULSE_LENGTH)) { | |||
memcpy(voice->osc_audio, voice->osc_audio + osc_index, | |||
LONGEST_DD_PULSE_LENGTH * sizeof (float)); | |||
memset(voice->osc_audio + LONGEST_DD_PULSE_LENGTH, 0, | |||
(MINBLEP_BUFFER_LENGTH - LONGEST_DD_PULSE_LENGTH) * sizeof (float)); | |||
osc_index = 0; | |||
} | |||
} | |||
/* save things for next time around */ | |||
voice->lfo_pos = lfo_pos; | |||
voice->vca_eg = vca_eg; | |||
voice->vca_eg_phase = vca_eg_phase; | |||
voice->vcf_eg = vcf_eg; | |||
voice->vcf_eg_phase = vcf_eg_phase; | |||
voice->osc_index = osc_index; | |||
return; | |||
(void)freq; | |||
(void)vcf_acc_amt; | |||
} |