First commit, full plugin upload
This commit is contained in:
falkTX
commit
29ba76c73d
|
|
@ -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 $@
|
||||
|
||||
# --------------------------------------------------------------
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -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
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 49 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 60 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.0 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 43 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 359 B |
Binary file not shown.
|
After Width: | Height: | Size: 354 B |
Binary file not shown.
|
After Width: | Height: | Size: 2.9 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 383 B |
Binary file not shown.
|
After Width: | Height: | Size: 370 B |
Binary file not shown.
|
After Width: | Height: | Size: 383 B |
Binary file not shown.
|
After Width: | Height: | Size: 369 B |
Binary file not shown.
|
After Width: | Height: | Size: 375 B |
Binary file not shown.
|
After Width: | Height: | Size: 348 B |
Binary file not shown.
|
After Width: | Height: | Size: 347 B |
Binary file not shown.
|
After Width: | Height: | Size: 4.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 353 B |
File diff suppressed because it is too large
Load Diff
|
|
@ -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;
|
||||
}
|
||||
Loading…
Reference in New Issue