summaryrefslogtreecommitdiff
path: root/libs/ardour/test/dsp_load_calculator_test.cc
blob: 12f063f165a75e2cca8d0bd6a8527c67c096a717 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <iostream>

#include "ardour/dsp_load_calculator.h"

#include "dsp_load_calculator_test.h"

CPPUNIT_TEST_SUITE_REGISTRATION (DSPLoadCalculatorTest);

using namespace std;
using namespace ARDOUR;

void
DSPLoadCalculatorTest::basicTest ()
{
	DSPLoadCalculator dsp_calc;

	dsp_calc.set_max_time(48000, 512);
	int64_t dsp_100_pc_48k_us = 10666;

	CPPUNIT_ASSERT(dsp_calc.get_max_time_us() == dsp_100_pc_48k_us);

	// test equivalent of 10% load
	dsp_calc.set_start_timestamp_us(0);
	dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us/10);
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() <= 0.1f);

	// test equivalent of 50% load and check that the load jumps to 50 percent
	dsp_calc.set_start_timestamp_us(0);
	dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us/2);
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() <= 0.5f);

	// test equivalent of 100% load
	dsp_calc.set_start_timestamp_us(0);
	dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us);
	CPPUNIT_ASSERT(dsp_calc.elapsed_time_us() == dsp_100_pc_48k_us);
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() <= 1.0f);

	// test setting the equivalent of 100% twice doesn't lead to a dsp value > 1.0
	dsp_calc.set_start_timestamp_us(dsp_100_pc_48k_us);
	dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us * 2);
	CPPUNIT_ASSERT(dsp_calc.elapsed_time_us() == dsp_100_pc_48k_us);
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() <= 1.0f);

	// test setting the equivalent of 200% clamps the value to 1.0
	dsp_calc.set_start_timestamp_us(dsp_100_pc_48k_us);
	dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us * 3);
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() == 1.0f);

	// test setting the an stop timestamp before the start timestamp is ignored
	// and the previous dsp value is returned
	dsp_calc.set_start_timestamp_us(dsp_100_pc_48k_us * 2);
	dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us);
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() == 1.0f);

	float dsp_load = dsp_calc.get_dsp_load();

	// test setting the equivalent of beyond the max_timer_error_us is ignored and
	// the previous dsp value is returned
	dsp_calc.set_start_timestamp_us (0);
	dsp_calc.set_stop_timestamp_us (dsp_100_pc_48k_us*10);
	CPPUNIT_ASSERT(dsp_calc.elapsed_time_us() > dsp_calc.max_timer_error_us());
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() == dsp_load);

	std::cout << std::endl;

	// test the rate of rolloff of the LPF from 100% with load at constant 50%
	// over the equivalent of 1 second
	for (int i = 0; i < 1e6 / dsp_100_pc_48k_us; ++i) {
		dsp_calc.set_start_timestamp_us(0);
		dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us / 2);
		CPPUNIT_ASSERT(dsp_calc.elapsed_time_us() == 5333);
		std::cout << "DSP 50% load value = " << dsp_calc.get_dsp_load() << std::endl;
	}

	// test that the LPF is still working after one second of values
	// TODO need to work out what is required in terms of responsiveness etc
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() > 0.5f);

	// compare 96k to 48k
	DSPLoadCalculator dsp_calc_96k;
	dsp_calc_96k.set_max_time(96000, 512);
	int64_t dsp_100_pc_96k_us = 5333;

	// reset both to 100%
	dsp_calc.set_start_timestamp_us(dsp_100_pc_48k_us);
	dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us * 2);
	CPPUNIT_ASSERT(dsp_calc.elapsed_time_us() == dsp_100_pc_48k_us);
	CPPUNIT_ASSERT(dsp_calc.get_dsp_load() <= 1.0f);
	dsp_calc_96k.set_start_timestamp_us(dsp_100_pc_96k_us);
	dsp_calc_96k.set_stop_timestamp_us(dsp_100_pc_96k_us * 2);
	CPPUNIT_ASSERT(dsp_calc_96k.elapsed_time_us() == dsp_100_pc_96k_us);
	CPPUNIT_ASSERT(dsp_calc_96k.get_dsp_load() <= 1.0f);

	// test the rate of rolloff of the LPF from 100% with load at constant 50%
	// over the equivalent of 1 second for 48k and 96k and test for ~equality
	for (int i = 0; i < 1e6 / dsp_100_pc_96k_us; ++i) {
		dsp_calc_96k.set_start_timestamp_us(0);
		dsp_calc_96k.set_stop_timestamp_us(dsp_100_pc_96k_us / 2);
		if (i % 2 == 0) {
			dsp_calc.set_start_timestamp_us(0);
			dsp_calc.set_stop_timestamp_us(dsp_100_pc_48k_us / 2);

			std::cout << "DSP 50% load value 48k = " << dsp_calc.get_dsp_load()
			          << std::endl;
			std::cout << "DSP 50% load value 96k = " << dsp_calc_96k.get_dsp_load()
			          << std::endl;
			CPPUNIT_ASSERT_DOUBLES_EQUAL(dsp_calc.get_dsp_load(),
			                             dsp_calc_96k.get_dsp_load(), 0.001);
		}
	}

}