Summary of results¶

• Summary of results
  • What we're looking at
  • Speed
    • Implementations by decimation factor
      • Factor 2
      • Factor 4
      • Factor 8
      • Factor 16
      • Factor 32
      • Factor 64
    • Decimation factors by implementation
      • Implementation zoh
      • Implementation decimate
      • Implementation decimate_b
      • Implementation resample_hq
      • Implementation resample_mq
      • Implementation resample_lq
      • Implementation src
    • Resampler filter lengths

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 implementation in the qm-dsp library, which uses an IIR lowpass filter (perhaps an elliptical filter?) with 8 coefficient pairs;

• decimate_b: the DecimatorB class in the qm-dsp library, which uses a Butterworth IIR lowpass filter of order 6;

• resample_hq, resample_mq, resample_lq: the Resampler implementation in the qm-dsp library, which uses a lengthy Kaiser-windowed sinc filter, at three different quality settings;

• src: the sndfile-resample program which uses libsamplerate, 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.

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).

Implementations by decimation factor¶

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

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

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

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

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

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

Decimation factors by implementation¶

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

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

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

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

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

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

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

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