Decimation

h1. Summary of results

{{>toc}}

h2. What we're looking at

Here we're only looking at causal methods, so no forward/backward filtering. The question in my head is really whether faster IIR filters are still so much faster as to be worth using in preference to linear-phase methods with better (?) theoretical quality. Of course that would always depend on the application, but it's interesting to compare. 

We compared

 * @decimate@: the "Decimator":http://code.soundsoftware.ac.uk/projects/qm-dsp/embedded/classDecimator.html implementation in the "qm-dsp":/projects/qm-dsp library, which uses an IIR lowpass filter (perhaps an elliptical filter?) with 8 coefficient pairs;

 * @decimate_b@: the "DecimatorB":http://code.soundsoftware.ac.uk/projects/qm-dsp/embedded/classDecimatorB.html class in the "qm-dsp":/projects/qm-dsp library, which uses a Butterworth IIR lowpass filter of order 6;

 * @resample_hq@, @resample_mq@, @resample_lq@: the "Resampler":http://code.soundsoftware.ac.uk/projects/qm-dsp/embedded/classResampler.html implementation in the "qm-dsp":/projects/qm-dsp library, which uses a lengthy Kaiser-windowed sinc filter, at three different quality settings;

 * @src@: the sndfile-resample program which uses "libsamplerate":http://mega-nerd.com/SRC/, a well trusted resampler also using a Kaiser-windowed sinc implementation, at its default quality setting;

 * @zoh@: the sndfile-resample zero-order hold resampler, which just takes every Nth sample without any filtering, serving as a baseline.

h2. Speed

For 5292000 input frames on a Core i3-3229Y low-voltage CPU. (Frames-per-second values are for input frames.)

All code is 64-bit. The qm-dsp implementations (resample_* and decimate) were compiled with -O3 -ffast-math while the libsamplerate implementations (src and zoh) were standard Ubuntu packages, so probably -O2. This is likely to make a very significant difference, so these results are more useful for comparison among the qm-dsp implementations than between qm-dsp and libsamplerate.

The decimate implementation supports factors up to 8 only, so 16x, 32x and 64x are handled in two passes.

All implementations use libsndfile for audio file I/O, so that should not be a factor in overall speed.

These frames-per-second figures look terribly precise, but I imagine there's a good 10% margin of error (run to run or whatever).

h3. Implementations by decimation factor

h4. Factor 2

|Frames per second|Clock time|Implementation|

|  14225806|0.372|decimate|

|  14187667|0.373|decimate_b|

|   8939189|0.592|zoh|

|   3732016|1.418|resample_lq|

|   1856842|2.850|resample_mq|

|    989158|5.350|resample_hq|

|    516141|10.253|src|

h4. Factor 4

|Frames per second|Clock time|Implementation|

|17070967|0.310|zoh|

|14659279|0.361|decimate|

|13465648|0.393|decimate_b|

| 4285020|1.235|resample_lq|

| 2186776|2.420|resample_mq|

| 1056287|5.010|resample_hq|

|  610099|8.674|src|

h4. Factor 8

|Frames per second|Clock time|Implementation|

|26328358|0.201|zoh|

|13926315|0.380|decimate|

|12027272|0.440|decimate_b|

| 4895467|1.081|resample_lq|

| 2470588|2.142|resample_mq|

| 1166409|4.537|resample_hq|

|  614919|8.606|src|

h4. Factor 16

|Frames per second|Clock time|Implementation|

|33493670|0.158|zoh|

|12721153|0.416|decimate|

|11141052|0.475|decimate_b|

| 5093358|1.039|resample_lq|

| 2515209|2.104|resample_mq|

| 1182041|4.477|resample_hq|

|  668857|7.912|src|

h4. Factor 32

|Frames per second|Clock time|Implementation|

|41669291|0.127|zoh|

|14498630|0.365|decimate|

|12540284|0.422|decimate_b|

| 5318592|0.995|resample_lq|

| 2312937|2.288|resample_mq|

| 1148936|4.606|resample_hq|

|  670467|7.893|src|

h4. Factor 64

|Frames per second|Clock time|Implementation|

|42000000|0.126|zoh|

|13397468|0.395|decimate|

|11972850|0.442|decimate_b|

| 5040000|1.050|resample_lq|

| 2365668|2.237|resample_mq|

| 1232704|4.293|resample_hq|

|  636057|8.320|src|

h3. Decimation factors by implementation

h4. Implementation zoh

|Frames per second|Clock time|Factor|

|42000000|0.126|factor 64|

|41669291|0.127|factor 32|

|33493670|0.158|factor 16|

|26328358|0.201|factor 8|

|17070967|0.310|factor 4|

| 8939189|0.592|factor 2|

h4. Implementation decimate

|Frames per second|Clock time|Factor|

|14659279|0.361|factor 4|

|14498630|0.365|factor 32|

|14225806|0.372|factor 2|

|13926315|0.380|factor 8|

|13397468|0.395|factor 64|

|12721153|0.416|factor 16|

h4. Implementation decimate_b

|Frames per second|Clock time|Factor|

|14187667|0.373|factor 2|

|13465648|0.393|factor 4|

|12540284|0.422|factor 32|

|12027272|0.440|factor 8|

|11972850|0.442|factor 64|

|11141052|0.475|factor 16|

h4. Implementation resample_hq

|Frames per second|Clock time|Factor|

| 1232704|4.293|factor 64|

| 1182041|4.477|factor 16|

| 1166409|4.537|factor 8|

| 1148936|4.606|factor 32|

| 1056287|5.010|factor 4|

|  989158|5.350|factor 2|

h4. Implementation resample_mq

|Frames per second|Clock time|Factor|

| 2515209|2.104|factor 16|

| 2470588|2.142|factor 8|

| 2365668|2.237|factor 64|

| 2312937|2.288|factor 32|

| 2186776|2.420|factor 4|

| 1856842|2.850|factor 2|

h4. Implementation resample_lq

|Frames per second|Clock time|Factor|

| 5318592|0.995|factor 32|

| 5093358|1.039|factor 16|

| 5040000|1.050|factor 64|

| 4895467|1.081|factor 8|

| 4285020|1.235|factor 4|

| 3732016|1.418|factor 2|

h4. Implementation src

|Frames per second|Clock time|Factor|

|  670467|7.893|factor 32|

|  668857|7.912|factor 16|

|  636057|8.320|factor 64|

|  614919|8.606|factor 8|

|  610099|8.674|factor 4|

|  516141|10.253|factor 2|

h3. Resampler filter lengths

Filter lengths the qm-dsp Resamplers decided to use:

|Factor|Length (hq)|Length (mq)|Length (lq)|

|2|643|291|119|

|4|1285|579|237|

|8|2567|1155|471|

|16|5131|2307|939|

|32|10261|4613|1877|

|64|20519|9223|3751|