* bsebus.c:
* bsestorage.c:
* bseobject.h, bseobject.c: pass BseStorage version information on in
restore_finish() methods.

* bsecxxbase.hh, bsecxxbase.cc: introduced restore_finished() virtual
method, so C++ modules can execute version specific compat code after
after it has been restored from serialized object state.

* bse/bsecxxbase.hh:
* bse/bseengine.h:
* bse/bseitem.h: added G_GNUC_NULL_TERMINATED to function ellipsis,
patch by Stefan Westerfeld from bug #344388.

* bseproject.[hc]: removed bogus function decl.
bse_project_get_song(): new function to retrieve the first song of
a project if any. at some point this should become the sole song.

* bseproject.proc: reuse an existing song if possible when importing
MIDI files, effectively merging the import into the existing song.

* bseproject.proc:
* bsemidifile.c: removed/disabled debugging printouts.

* bsemidifile.c: Assign newly created tracks to the master bus. Fixes
#441936.

* bsecore.idl: Include ~/beast/plugins in the default plugin search
path, to make it easier for users and developers to install extra
plugins from source.

* bsemath.h: Added ln (10)/20 constant for ArtsCompressor.

* bsedatahandle-fir.cc: Fix a bug in seek() spotted by Tim: invalidate
m_input_data contents properly if a read error occurs during filling
it.

* gsldatahandle.[hc]: Implemented gsl_data_handle_volume, which
returns a volume adjustment factor ("volume" xinfo).

* gslwavechunk.[hc]: Cache the volume adjustment factor here, so that
GslWaveOsc can access it quickly.

* gslwaveosc.c (gsl_wave_osc_set_filter): Adjust volume of the chunk
according to its volume adjustment.

* bseloader-wav.c (wav_read_fmt_header): fixed byte_per_sample check.

* bse/gsldatahandle.[hc]: added scaling data handle, the scaling
factor is provided at construction time.

* bse/gsldatautils.[hc]: added gsl_data_find_min_max() to detect
min and max signal range of a data handle.

* bseloader-wav.c: support 32bit, 3byte 24bit and 4byte 24bit (with
unused upper byte) PCM-format WAV files.

* gsldatahandle.h: added GSL_WAVE_FORMAT_SIGNED_32,
GSL_WAVE_FORMAT_SIGNED_24_PAD4 and GSL_WAVE_FORMAT_SIGNED_24.

* gsldatahandle.c: read 24, 24_pad4 and 32 bit files.

* gsldatautils.h: extended to/from float/double with/without clip
conversion functions to also handle 24, 24_pad4 and 32bit data.

* bsecxxmodule.*: Added the necessary API to find out the maximum
engine block size to Bse::Effect. The new function is called
Effect::max_block_size().

* updated all licenses to GNU Lesser General Public License version 2.1
with permission from Stefan Westerfeld where required.

* bsesequencer.cc (bse_sequencer_thread_main): properly take sequencer
forerun into account when starting a song so we won't delay song start
until it's definitely too late.

* bsesequencer.cc: refined tracing information. provide more timing details.

* bsemain.h, bsemain.cc: added support for debugging channels.
added --bse-trace-sequencer.

* bsesequencer.cc: added note on/off and control event tracing.

* bseresamplerimpl.hh: Adjusted error bounds for the filter test,
because it failed sometimes although the implementation is ok. Be more
verbose when using verbose mode.

* bseenginemaster.c: commented caveats.

* bsebus.c (bse_bus_ensure_summation): use symbolic i/o channel identifiers
to avoid breakage in hardcoded channel numbers.

* bsepcmwriter.c (bse_pcm_writer_write): fixed calculation to avoid overflow.

* bsebus.c: BseSummation was recently extended to have three output
channels (a new one computing the difference), which broke make
report. This change fixes it, by adapting the hardcoded channel number
in this file to match the new summation plugin.

* bseserver.[hcp]*: added bse_server_start_recording() and
bse_server_stop_recording() functions to schedule WAV file
recording for a specific time intervall.
added bse-server-start-recording procedure.

* bsepcmwriter.[hc]: implemented time intervall
recording.

* gsloscillator.c: Take transpose factor into account for table
lookups when the oscillator frequency is constant. Fixes #387364.

* bsesong.[hc]: keep a flag around to detect the first sequencer underrun,
reset the flag when prepared.

* bsesequencer.cc (bse_sequencer_thread_main): always warn about
sequencer underruns, regardles of debugging state.

* bsebiquadfilter.c:
* bseconstant.c:
* bsestandardosc.c:
* bseladspamodule.c: Spelling fix: the unit for frequencies is spelled
"Hertz" (not "Herz").

* bsestandardosc.c (bse_standard_osc_update_modules): added missing
update of the transpose factor to update_modules(), fixes #386862.

* gslcommon.c (gsl_error_from_errno): special case ENODATA, which is not
available on GNU/kFreeBSD, reported by Petr Salinger <Petr.Salinger@seznam.cz>.

* gsldatahandle-vorbis.c (gsl_vorbis1_handle_read): use EIO in unclear
error cases, because GNU/kFreeBSD lacks ENODATA.

* tests/filtertest.cc (generic_filter_tests): added missing stopband
damping check for LOWPASS filters, caught by Stefan.

* bseenginemaster.c (master_process_locked_node): set buffer start
fragments to zero for nodes that are partially suspended and have
pending probe jobs, so probes don't contain outdated junk data.

* bseenginemaster.c (master_take_probes): fixup ostreams[].value
pointers before returning a probe, since those may have been altered
by process() routines.

* bseprobe.cc: added debugging field and a few assertions.

* bseundostack.c: fix possible flat copies of pointers to deeply
nested object structures. in particular, this fixes potential GSList
node corruptions.

* bsecore.idl, bsemathsignal.c: added musical tuning system tables
submitted by Hanno Behrens <pebbles@schattenlauf.de>:
12-TET, 7-TET, 5-TET, DIATONIC_SCALE, INDIAN_SCALE, PYTHAGOREAN_TUNING,
PENTATONIC_5_LIMIT, PENTATONIC_BLUES, PENTATONIC_GOGO,
QUARTER_COMMA_MEANTONE, SILBERMANN_SORGE, WERCKMEISTER_3,
WERCKMEISTER_4, WERCKMEISTER_5, WERCKMEISTER_6, KIRNBERGER_3
and YOUNG.

* bsesong.[hc]: added musical_tuning property.

* bseutils.h, bseutils.c:
* bsenote.h, bsenote.c, bsenote.cc: converted bsenote to C++. added musical
tuning argument to all note/freq API functions and adapted internal logic
to cope with different tunings. removed unused BSE_FREQ*() macros.

* bsecore.idl: introduce Bse::MusicalTuningType. added musical_tuning
field to NoteDescription.

* bseserver.proc:
* bseprocedure.proc: added musical tuning arguments to various note
related procedures, moved note procedures from bseserver.proc to
bseprocedure.proc and got rid of their BseServer argument.

* bsemathsignal.h, bsemathsignal.c: made semitone and transpose tables
musical tuning sensitive.

* bsepart.[hc]: allow per-part semitone tables, and changed macros so that
part notes are converted to frequencies according to the musical tuning
specific to a part.

* bseitem.[hc]: provide bse_item_current_musical_tuning() and document
its caveats.

* bsesource.[hc]: added bse_source_prepared_musical_tuning() which
provides musical tuning setting for a source if and only if the
source is prepared. the tuning stays constant while the source is prepared.

* bsesequencer.cc: perform part specific note->freq conversion.

* bsemidifile.[hc]: added musical_tuning to use the new note API,
defaulting to equal temperament.

* bsemididecoder.c: hard code musical tuning to equal temperament,
since we have to provide notes to frequencies for MIDI events up front.

* bseconstant.c:
* bsestandardosc.c:
* bseladspamodule.c:
* bsebiquadfilter.c: adapt to new tuning relative note API, add a
warning to tooltips that informs about the musical tuning specific
interpretation of note properties.

* gsloscillator*.[hc]: changed configuration to contain a transpose_factor
and not a transpose index which needs to be looked up in conjunction with
a specific musical tuning.

* bseglobals.h: removed unused macros.

* bseinfo.c: adapt to new note API by defaulting to to equal temperament.

* tests/misctests.cc: test various musical tuning system properties and
note<->freq conversions.

* tests/firhandle.cc: Added seek test.

* gsldatahandle.h:
* bsedatahandle-fir.cc: Added a function which computes the filter
response in dB, given a FIR handle and a frequency.

* tests/firhandle.cc: Test that theoretical filter response (computed
by bse_data_handle_fir_response_db) and scanned response match.

* gslvorbis-enc.h, gslvorbis-enc.c: added gsl_vorbis_encoder_version()
which has to go through some hoops to query the library version (encode
and decode a dummy file), but manages to return a version string.

* bseserver.proc: provide bse_server_get_vorbis_version().

* bseexports.h: changed plugin mechanism to skip per-plugin names and
to provide feature flag masks to check plugin requirements (to check
for MMX/SSE support).

* bsecxxplugin.hh, bsecxxplugin.cc: changed symbol export mechanism to
use Bse::ExportTypeKeeper constructor and destructor instead of single
symbols. use bse_exports__add_node() and bse_exports__del_node() to
register/unregister the type nodes. this allows compilation of multiple
C++ plugin types into the same .so binary.

* bseplugin.h, bseplugin.c: rewrote plugin symbol lookup and type node
exports to support load time registration via bse_exports__add_node()
and bse_exports__del_node().

* bsedatahandle-fir.cc: Made state size computation work correctly.
Added lowpass handle.

* tests/firhandle.cc: Extended tests to cover both, the highpass and
the lowpass handle.

* tests/Makefile.am:
* tests/firhandle.cc: Added a test for the highpass performance.

* bsedatahandle-fir.cc: Optimized performance of the highpass handle.
It is plain FPU code (not SSE), though.

* tests/firhandle.cc: Added a highpass test for multichannel signals.

* bsedatahandle-fir.cc: Fixed the code for n_channels != 1. Minor
code cleanups.

* bsedatahandle-fir.cc: Some optimizations, more to come.

* bsedatahandle-fir.cc:
* gsldatahandle.h:
* tests/firhandle.cc: Move highpass handle from gsl to bse namespace.

* bsedatahandle-fir.cc: Implement a "real" data handle. It is not yet
performance optimized, though.

* gsldatahandle.[hc]: Added new gsl_data_handle_get_state_length
function for datahandles, with a corresponding vtable entry. For
filtering datahandles (such as lowpass handles), which are usually
stateful, it returns the filter state length.

* gsldatahandle-vorbis.c:
* gsldatahandle-mad.c:
* bsedatahandle-resample.cc:
* tests/loophandle.c: Implement the get_state_length datahandle
method.

* tests/resamplehandle.cc: Test the resampler get_state_length
function.

* tests/firhandle.cc: Check that the filter is zero phase in the
passband (== no delay).

* tests/Makefile.am:
* tests/firhandle.cc: Created test for the fir highpass handle.

* bsedatahandle-fir.cc: Fixed parameters passed to coefficient design
function. Filters have the right cutoff frequency now.

* Makefile.am: Added bsedatahandle-fir.cc.

* gsldatahandle.h:
* bsedatahandle-fir.cc: Moved highpass handle here from
../tools/bseloopfuncs.[hc].

* bsedatahandle-fir.cc: svn copy from ../tools/bseloopfuncs.c: prepare
for moving highpass handle here.

* bseladspa.cc: made messages about ladspa compatibility debugging
messages. improved message clarity, supressed messages about plugin
registration. added missing 'extern "C"'.

* bseladspa.cc: ported bseladspa.c to C++. use BIRNET_MAY_ALIAS to
work around strict aliasing warnings. load LADSPA modules with local
symbol bindings.

* bseladspa.h: fixed structure layout for C++.

* bsetype.h: use EXTERN_C in code generating macros, to account for
macro usage in C++.

* bsemain.cc: ported bsemain.c to C++, use C++ Msg API.

* bsemain.h: API adaptions due to bsemain.cc porting.

* bsecore.idl:
* bsejanitor.proc:
* bseserver.c: ported to new sfi_msg_* API.

* bsesequencer.cc: use bse_message_setup_thread_handler().

* bseenginemaster.c: use bse_message_setup_thread_handler() and
BIRNET_STATIC_ASSERT().

* ldscript.map: restrict typeinfo symbol exports to Sfi/Bse/Birnet
symbols. export vtable symbols to allow plugin building withou tlibtool.

* bseresampler.[hc]*: Added Resampler2::find_precision_for_bits to the
API, and an precision enum -> string conversion function.

* bsedatahandle-resample.cc: Use find_precision_for_bits.

* bseresamplerimpl.hh: Removed unnecessary delay. The stream delay for
both, upsampling and downsampling should be truely minimal now.

* bseresampler.hh: The guarantee that the upsampler delay is even was
removed from the API. The reason is that we can have a shorter stream
delay when the upsampler delay is odd.

* bsedatahandle-resample.cc: Introduced additional delay compensation
code, because compensating an odd upsampler delay wasn't necessary
when this code was initially written.

* bseresampler.[hc]* bseresamplerimpl.hh: Added coefficient set for
linear interpolation. It will probably sound bad, but its useful for
testing.

* tests/filtertest.cc (random_filter_tests): extended fixed orders to 32
and random orders to 64. cut the requested order for band filters in
half, because it's doubled upon design.

* bsefilter-ellf.c: removed ellf-behavior special casing. switched
to higher precision constants. substituted bsemath.h constants.

* bsemath.h: provide ln(4), decibel10 and decibel20 factors.

* bsefilter-ellf.c: replaced all ellf specific complex number
arithmetic by bse_complex*() calls.

* bsemath.h: provide BSE_COMPLEX_ONE for convenience.

* gslmathtest.c: removed, this has been ported to bsemathtest and
is long unused.

* bsemath.h: don't include neither of the C++ <complex> or the C99
<complex.h> header files. removed compat typedefs. we'll simply resort
to using BseComplex in headers and use <complex> in C++ files.

* bsefilter.h: use BseComplex for complex numbers in header files.

* bsefilter.cc: adaptions to BseComplex.

* bsefilter-ellf.c: use BseComplex instead of C99 complex.

* tests/filtertest.cc: adaptions to BseComplex. fixed elliptic filter
test to really use stopband_edges, not stopband_db.

* bsefilter.h, bsefilter.cc: removed transfer function nominator and
denominator from public API, because they are useless for higher
order filters. added center-frequency to public API, which is the
middle frequency for band filters (used to evaluate gain ot stopband).

* bsefilter-ellf.c: provide BseIIRFilterDesign.center_frequency.
made some slight precision improvements for cgam evaluations.

* tests/filtertest.cc: special cased lengthy routines as slowtest.
removed any code (check, eval) related to filter transfer functions.
did some test split ups. added random filter tests for butterworth,
chebyshev1, elliptic. extended generic filter test to test passband
min/max from both sides. added some stopband tests.

* tests/filtercatalog.cc: random filter catalog generated with bse-ellf.

* bsefilter-ellf.c: z_plane_zeros_poles_to_numerator_denomerator():
reimplemented gain calculation by evaluating the pole and zero
polinomials. this eliminates the precision artefacts which caused
gain miscalculations for high order filters.

* bsemath.c: temporary fix against ring buffer overflow.

* bsefilter-ellf.c: replaced overly verbose debugging function
implementation by simple printf like macros. moved ellf compat
constant definitions.

* bsefilter.cc: cosmetic changes to bse_iir_filter_request_string().

* tests/filtertest.cc: compare filter zero/pole coefficients
instead of filter transfer function coefficients which are useless
for high order filters. zero/pole pairs for comparsion are
determined through nearest-neighbour searches.
use TABORT_HANDLER() to hook up print_filter_on_abort(), to print
out mismatching filters when tests fail. use T*_CMP() test macros
for more informative printouts. extended generic filter test to
cover more filter properties.
added predesigned filters where ellf miscalculates gain.

* tests/filtertest.cc: Raise coefficient comparision epsilon ceps
8e-13 for Chebychev filters, as recommended by Tim, so that "make
check" on AMD64 passes again.

* tests/resamplehandle.cc: Use BseResampler delay compensation C API
where appropriate, instead of computing the delay from the filter
order.

* tests/filtertest.cc: added brute_coefficient_tests() which can be
used to test massive amounts of test filters against the library
design algorithm.

* tests/filtertest.cc: applied some corrections suggested by Stefan.
fixed frequency range loops to test both frequency bounds.
extended exit_with_iir_filter_gnuplot() to print the filter design.
assert allmost 0-gain for all filters. simplified tests somewhat.
added low/high pass and band stop/pass chebyshev1 filters.

* tests/filtertest.cc: new test for the new IIR filter design API.
currently covers Butterworth low pass, high pass, band stop and
band pass filter tests. tests are based on coefficient comparisons,
filter transfer function analysis, and zero + pole function
analysis. for debugging purposes, provided the possibility to
prematurely abort filter tests and provide a gnuplot dump.

* bsefilter.cc: implement bse_iir_filter_kind_string(),
bse_iir_filter_type_string(), bse_iir_filter_request_string(),
bse_iir_filter_design_string(). implemented bse_iir_filter_design()
as a thin wrapper around _bse_filter_design_ellf().

* bsemath.h: include complex.h or complex, depending on C / C++.
provide ComplexFloat, ComplexDouble, ComplexLongDouble and
Complex as alias for ComplexDouble.

* bsefilter.h: new header for offering a unified IIR filter API.

* bsefilter-ellf.c: define _GNU_SOURCE instead of _ISOC99_SOURCE before
including any headers. this gets us the C99 API *and* GNU features
(i.e. the uint typedef).
split up the implementation so that the current stand-alone behavior
is preserved if ELLF_BEHAVIOR is defined and so that the necessary
contents from bseellipticfilter.h are inlined otherwise.
moved EllfDesignState here (from bseellipticfilter.h). renamed
EllfComplex.
_bse_filter_design_ellf(): implemented library function prototyped
in bsefilter.h to design butterworth, chebychev1 and elliptic filters.

* bseellipticfilter.h, bseellipticfilter.c: removed.

* bsefilter-ellf.c: copied from bseellipticfilter.c.

* bseellipticfilter.h: extended BseIIRFilterKind, renamed
* bseellipticfilter.c: extended BseIIRFilterKind, renamed
BseIIRFilterRequest, BSE_IIR_MAX_ORDER and BSE_IIR_CARRAY_SIZE.
added BseIIRFilterDesign structure which is the intended future
output API. renamed some DesignState fields to match BseIIRFilterDesign
more closely.

* gslfilter.c (gsl_filter_sine_scan): More comments.

* bseblockutils.hh, bseblockutils.cc: provide a blockutils
implementation name. usually "FPU" or "SSE".

* bsemain.c: add block utils implementaiton name as suffix to
the treport_*() CPU name.

* tests/Makefile.am:
* tests/blocktests.cc: conditionalized benchmarks, use treport_*().

* tests/blocktests.cc, tests/resamplehandle.cc: CPU name fixups.

* bsemain.c: let allow_randomization default to TRUE, added
--bse-disable-randomization and --bse-enable-randomization args.

* bsemain.h: added allow_randomization to BseMainArgs to configure
deterministic vs. non-deterministic behavor. mostly interesting
for physical modelling plugins.

* tests/resamplehandle.cc: Improved comment.

* tests/resamplehandle.cc: reworked to split performance tests from
ordinary tests. speed up ordinary tests if --test-slow was not
specified. fixed test program to use TASSERT() instead of silent exit
or return_if_fail on errors.

* tests/subnormals.cc: refactored a bit, split up performance tests.

* gslfilter.c (gsl_filter_sine_scan): Fixed a small bug in block
volume computation.

* gslfilter.[hc] (gsl_filter_sine_scan): Changed the API and
implementation of the sine scanning function to figure out how long to
scan by computing the volume for 0.1 second blocks, and waiting until
the volume doesn't change anymore.

* bsedatahandle-resample.cc: Fixed my last commit. Sorry.

* tests/resamplehandle.cc:
* bseresampler.hh: Improved comments on delay compensation.

* bsedatahandle-resample.cc: Reorganized delay compensation code in
open() a bit, improved comments.

* bseellipticfilter.c: cosmetics, fixed constants.

* bseellipticfilter.h:
* bseellipticfilter.c: turned remaining global variables into local
variables or structure members.

* bseellipticfilter.h, bseellipticfilter.c: moved elliptic integral
values, chebyshev/elliptic phi and gain into the filter state structure.
eliminated other global variables by declaring them in local scopes.

* bseellipticfilter.h: define MAX_ORDER and MAX_COEFFICIENT_ARRAY_SIZE.
added array for s-plane poles and zeros to DesignState.

* bseellipticfilter.c: added -ffloat-store to the compilation option to
keep compatibility with math.h-enabled ellf.c. resolved non-local double
variable fixmes. store s-plane zeros and poles as ds->zs. changed to use
MAX_COEFFICIENT_ARRAY_SIZE as array bound.

* bseellipticfilter.c: changed static y[] array into local scope
variables/arrays.

* bseellipticfilter.c: removed remaining static integers by using
either local variables or by using ds->z_counter. minor whitespace
fixups.

* bseellipticfilter.h: added and documented z_counter.

* bseellipticfilter.c: whitespace and paranthese fixes.

* bseellipticfilter.h, bseellipticfilter.c: white space fixups,
changed static zord to ds->n_solved_poles.

* bseellipticfilter.h:
* bseellipticfilter.c: include math.h instead of declaring standard
math.h functions. print debugging/informative output through an
extra function. beefed up ARRSIZ once more for high order filters.
added custom function to print the transfer function coefficients
for debugging. fixed reading from stdin to use fgets().
reverted granularity changes in filter table printing. renamed all
complex functions to not clash with complex.h.
added some workarounds with fixme marks to stay value (error)
compatible with former versions of the ellf program, these can be
removed once we have filter tests in place. removed unecessary
comments, streamlined others. removed obsolete configuration
logic and other unecessary preprocessor cruft. removed unused
declarations, moved many variable and constant declarations into
an inner scope. renamed heavily abbreviated functions. renamed
and recoded main() into iir_filter_design() which does read all
design parameters from a structure. added a new main with simply
stdin-read logic to call iir_filter_design().
for the moment, moved structure declarations for filter design
parameters and filter calculation state into bseellipticfilter.h.

* bseellipticfilter.h, bseellipticfilter.c: renamed from bseiirfilter.*.

* bseieee754.h: added BSE_DOUBLE_EPSILON and BSE_FLOAT_EPSILON,
constants for the round-off error at 1.0.

* gslfilter.c: Made implementation of gsl_filter_sine_scan() more
reliable by using two phase shifted signals (see comment in the
implementation).

* bsedatahandle-resample.cc: Use the newly introduced
Resampler2::delay().

* bseresampler.hh:
* bseresampler.cc:
* bseresamplerimpl.hh: Added a virtual function Resampler2::delay(),
which can be used for compensation of the resampler introduced delay.
Provide C API wrapper for the function: bse_resampler2_delay().

* tests/resamplehandle.cc: Test the delay compensation function.
Fix a buglet in another test (comparing signals needs fabs()).

* gslfft.h: Improved documentation on FFT normalization.

* bseiirfilter.c: Added some comments.

* bseiirfilter.c: enlarged ARRSIZ so order 16 filters can be calculated.
renamed and reworked print_filter_table() to print the filter table with
much finer granularity.

* bseiirfilter.c: more unused section removal. auto-fixed indentation.

* bseiirfilter.c: streamlined first comment section. got rid of useless
definitions and preprocessor special cases.

* bseiirfilter.c: streamlined some comments, fixed includes and
prototypes and constant tables to compile into a test program.

* bseiirfilter.c: since the ellf program is shipped standalone and as
part of the cephes math library, with no copying restrictions, this
code is now put under an "AS IS" NO-WARRANTY license, properly
attributing Stephen L. Moshier.

* bseiirfilter.c: added concatenated source code of the ellf filter
design program by Stephen L. Moshier. program homepage is:
http://www.moshier.net/ellfdoc.html

* bseiirfilter.h: new empty header file.

* tests/resamplehandle.cc: Lessen the thresholds for downsampling
datahandle 24bit test, because AMD64, due to its -mfpmath=sse default,
doesn't get as good results as i386 machines do. With the new
thresholds, make check passes on AMD64, too.

* gsldatahandle.h:
* bsedatahandle-resample.cc: Implemented factor 2 downsampling
datahandle. Moved common code into a base class for both datahandles.

* tests/resamplehandle.cc: Test downsampling datahandle.

* bseautodoc.c: fixed -p and -s not taking effect.

* bseblockutils.cc:
* bseblockutils.hh:
* bseresamplerimpl.hh: Only optionally produce output during the
filter implementation test.

* bsedatahandle-resample.cc: Fixes and cleanups. Upsampling Datahandle
class Members are now prefixed with m_, all code that could possibly
be moved into the class - such as the C vtable - is now present as
static functions within the class, the destructor was made private
- because reference counting is supposed to be used.
Finally the class uses C style inheritance, by embedding m_dhandle.

* tests/Makefile.am:
* tests/testresampler.cc: Moved testresampler.cc from bse/tests to
slowtests, to prepare it for automatic accuracy testing. Excessive
automatic testing will be quite slow, thus it needs to be in this
directory.

* tests/testresampler.cc: Allow using --fpu instead of
--bse-force-fpu, because that means less typing.
In the accuracy test, print out the threshold given by the user, if
any (that way, it becomes easier to validate the "safety margin"
between the specified and the actual threshold)

* bseblockutils.cc bseblockutils.hh: Provide hook for testing the
resampler2 implementation.

* tests/testresampler.cc bseresamplerimpl.hh: Moved SSE filter
implementation test to the new function fir_test_filter_sse, which
can then be properly compiled using -msse within the bseblockutils
plugin for the SSE case.

* tests/testresampler.cc: Make resampler more user friendly, by using
more long options, explicit command names and improving the usage. For
instance testresampler ad becomes testresampler accuracy --down.
We also leave it up to bse to determine whether to use the SSE or FPU
variant; bse's decision can be influenced by --bse-force-fpu.
Print usage() to stdout, to make it less'able.

* tests/testresampler.cc: Minor fix in usage() function.

* tests/testresampler.cc: Added option parsing, to be able to specify
a lot more details on what test should be performed and how.
Use bse to instantiate the upsampler and downsampler; this allows us
to use bse's automatic SSE detection features, and bse's coefficient
sets. Added --precision option to select coefficient set.
Added --freq-scan option, to test accuracy of an entire frequency
range with one single call of the program.
Added --precision-assert-db option, which allows the test program to
be used in automated tests. If the accuracy is less than the specified
minimum precision, an assertion is triggered.

* tests/testresamplercoeffs.h: Remove this file, because the new
testresampler code uses the coefficients defined in bseresampler.cc.

* tests/resamplehandle.cc: merged with resamplercapi.c. made internal
functions "static". fixed TSTART() usages. cleaned up main().

* tests/Makefile.am, tests/resamplercapi.c: removed resamplercapi.c.

* bseresamplerimpl.hh: renamed bseresampler.tcc to bseresamplerimpl.hh
to match beast naming conventions, and because it effectively implements
parts of bseresampler.hh.

* bseblockutils.cc: access Resampler2::create_impl() via derivation.

* bseresampler.tcc: whitespace fixups. fixed includes. fixed
unconditional use of __m128. renamed AlignedMem to AlignedArray because
this class implements aligned array accesses instead of a memory
allocator. adapted callers.

* bsedatahandle-resample.cc:
* bseresampler.cc, gsldatahandle.h: whitespace and comment fixups.

* bse/bseresampler.hh: whitespace fixups. made create_impl() non-public,
it can be accessed by blockutil implementations via derivation.

* bseresampler.tcc bseresampler.cc bseresampler.hh: Added factor 2
resampling code (up- and downsampling), which can use SSE instructions
when available. The implementation was tuned for speed.

* gsldatahandle.h bsedatahandle-resample.cc: Provide a datahandle,
which does factor 2 upsampling.

* bseblockutils.cc bseblockutils.hh: Provide factory method for the
resampler, so that bse can automatically use the SSE version when SSE
instructions are available.

* tests/testresamplercoeffs.h tests/testresampler.cc: Standalone
interactive test code for the resampler.

* tests/resamplercapi.c tests/resamplehandle.cc: Tests for the
resampler C API and the resampler data handle.

* Makefile.am: Adapted Makefile rules for the new resampler sources.

* tests/Makefile.am: Adapted Makefile rules for the new resampler
tests. Fixed subnormals_CXXFLAGS, which now includes AM_CXXFLAGS.

* gsldatautils.h, gsldatautils.c: added bse_wave_file_from_fbuffer() and
bse_wave_file_from_dbuffer() to easily save WAV files from memory.

* gslwaveosc-aux.c: use doubles instead of floats to store temporary
filter state. this avoids artefacts for larger pitch values.

* bsebiquadfilter.c (bse_biquad_filter_class_init):
disabled ::norm_type property because chenging it to something
non-default drives the filter unstable too easily.

* bseautodoc.c: pass through --bse-rcfile to bse.

* renamed the guile based bsesh to bsescm. adapted related build rules,
variable names, function names and documentation.

* renamed bse_engine_garbage_collect() to bse_engine_user_thread_collect().

* zintern/gus-patch.bse:
* bse/zintern/wave-mono.bse: updated to beast 0.7.0, clarified license.

* gslcommon.c:
* bsepcmdevice-oss.c:
* bsemididevice-oss.c: use birnet_file_equals() and
birnet_file_check().

* zintern/Makefile.am: use birnet-zintern.

* zintern/zintern.c: rmeoved.

* bsestorage.c: type fixup.

* bseitem.h(bse_item_undo_open): Added G_GNUC_PRINTF printf format
attribute.

* bsecxxutils.hh: got rid of TEMPLATE_ERROR::* which is provided
by Birnet now.

* bsecxxarg.hh: use Birnet::TEMPLATE_ERROR::invalid_type().

* bsecxxutils.hh: removed binary lookup templates which are
in Birnet now.

* bseproject.c bse_project_restore(): force dirty project flag
after restoring/merging.

* gslfft.h: fixed documentation.

* tests/testfft.c: added resynthesis tests.

* bseengine.c (bse_trans_merge): docu fixups.

* gslfft.h: document that gsl_power2_fftsr() scales the output data
by 1.0/n_values.

* bsesuper.c (super_compat_setup): added compat code for "license" and
"author" fields, loaded from BSE files < 0.7.0.

* bse.h:
* bsemain.[hc]: merged config data from gsl into BSE config data. make
use of BirnetInitValue to allow non-argc/argv configuraiton upon initilaization.
removed bse_init_intern(). added bse_init_inprocess() and bse_init_test().
adapted dependent code.

* gslcommon.[hc]: removed config and initialization logica that moved to BSE.

* bseserver.c: prevent rcfile loading if
birnet_init_settings->stand_alone is true.

* bseobject.c: fixup "blurb" parameter handling, default to the
empty string and skip default when saving.

* bsesuper.c: fix up "license" and "author" defaults to empty strings.

* bsesuper.c: pre-initialize authors and license field when
creating objects.

* bsecore.idl: added configurable defaults for author and license fields.
removed "Stepping Rates" config section. adapted dependent code.

* bseutils.[hc]: provide initial default author and license values.

* bseserver.c:
* bsemain.[hc]: permit specification of an rcfile via --bse-rcfile.

* bseplugin.c: fixed SSE vs. FPU filtering to also affect drivers.

* bseengine.c: document that probe jobs may be freely reordered.

* bseenginemaster.c: simply prepend probe jobs to a node's probe
job list, compared to appending, this has O(1) instead of O(n^2)
complexity which makes a huge different for some scenarios that
trigger long probe job queues.
also, collect probe jobs unconditionally after probes have been
taken, since probing is not parallelized anymore.

* bseglobals.[hc]: introduced new (idle handler) priority
BSE_PRIORITY_NEXT. this essentially takes over the prio of the
previous "now" stage which now got bumped up to the topmost
priority. change bse_idle_next() and bse_idle_now() functions
and their callers accordingly.

* bseprobe.cc: shortened queue length to 3, so usually 3 client side
probe requests will be handled including notification in a row.
after 3 requests, the client should have managed to request new
probes if it can process them this fast.
fixed up low level job queueing to occour asyncronously with highest
priority, so it essentially happens immediately but still allowes
for aggregation of multiple probe requests. also fixed up queue length
handling which was previously buggy in requesting only partial queue
lengths which resulted in very short probe job queues on the engine
modules and lots of unerruns during probe evaluation. added assertions.

* tests/blocktests.cc: Add benchmarks for fill and copy.

* tests/blocktests.cc: Make testing different block sizes easier by
adding a const int for the block size.

* bseblockutils.hh: Minor formatting fix.

* bseprobe.cc:
* bseengineutils.c:
* bseladspamodule.c:
* bsecontextmerger.c: use bseblockutils.hh functions to increase performance.

* bsemain.c (bse_init_core): Removed random generator seed
initialization for rand(), since it is now done by birnet_init.

* bseblockutils.*: Added new block functions for subtracting and
multiplying blocks, as well as calculating square sum (useful for
determining the block energy) and minimum/maximum values.

* tests/blocktests.cc: Test newly added functions.

* bseconstant.h: reduce the number of supported output channels to 4.

* bseplugin.h: allow type option specification for BSE_REGISTER_OBJECT*.

* icons/Makefile.am:
* icons/summation.png, icons/summation.xcf:
* Makefile.am:
* bsesummation.idl, bsesummation.cc: removed BseSummation which now
resides in plugins/.

* bsesong.c: abort with g_error() if BseSummation can't be loaded.

* icons/Makefile.am:
* icons/ampctrl.png, icons/ampctrl.xcf:
* Makefile.am:
* bse.idl:
* bseamplifier.idl, bseamplifier.cc: removed BseAmplifier which now
resides in plugins/.

* tests/testcxx.cc: create a BseBusModule as test object since
BseAmplifier is not part of the BSE core anymore.

* tests/subnormals.cc: added bench test for the float-cancellation macros
used by BSE.

* tests/Makefile.am: compile subnormals.cc with -ffast-match because this
affects the subnormal cancellation benchmarks and because this option is
used when compiling plugins.

* bseprobe.hh, bseprobe.cc: allmost complete rewrite to fix lots of
bugs and experimental code portions. several probe queues exist per
BseSource now, one for each output channel / block-size combination.
underruns in probe calculation are now detected and are zeroed out
where neccessary (e.g. in ffts). optimized quite some block copies,
fills and loops. for min/max and energie calculation loops, SIMD
variants are still needed. optimized probing logic for coalescing of
signal emissions. added "idle"-probing, i.e. continuous probe result
notification is now supported for unprepared sources without modules.
syncronized simulataneous probe requests on multiple sources.

* bseenginemaster.[hc]:
* bseenginenode.[hc]:
* bseengine.[hc]: reworked probing so probe jobs now simply replace
the BseOStream array of a node when probing. creation of probe jobs
and the probe callback was adapted accordingly. the user may take
over memory management for the resulting BseOStream array, release
then happens via the newly added bse_engine_free_ostreams(). fixed
lots of buglets on the way, made use of bseblockutils.hh.

* bseengine.[hc]: export bse_engine_const_zeros() to access a block
of 0 floats at least as big as any engine block.

* bsecxxmodule.hh:
* bsecxxmodule.cc: got rid of istreams, jstreams and ostreams
fields which just duplicated BseModule pointers for no good. since
bseengine.h is deliberately not includ