← Back to branch summary

~ubuntu-branches/ubuntu/quantal/libsamplerate/quantal

« back to all changes in this revision

Viewing changes to tests/multichan_throughput_test.c

  • Committer: Bazaar Package Importer
  • Author(s): Samuel Mimram
  • Date: 2009-02-17 23:35:15 UTC
  • mfrom: (1.1.5 upstream) (4.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090217233515-vblyud7n95kj76u5
Tags: 0.1.7-2
http://bugs.debian.org/515658
Added callback_test.dpatch to correct rounding error in callback test,
closes: #515658.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/multichan_throughput_test.c
 
1
/*
 
2
** Copyright (C) 2008 Erik de Castro Lopo <erikd@mega-nerd.com>
 
3
**
 
4
** This program is free software; you can redistribute it and/or modify
 
5
** it under the terms of the GNU General Public License as published by
 
6
** the Free Software Foundation; either version 2 of the License, or
 
7
** (at your option) any later version.
 
8
**
 
9
** This program is distributed in the hope that it will be useful,
 
10
** but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
** GNU General Public License for more details.
 
13
**
 
14
** You should have received a copy of the GNU General Public License
 
15
** along with this program; if not, write to the Free Software
 
16
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 
17
*/
 
18
 
 
19
#include <stdio.h>
 
20
#include <stdlib.h>
 
21
#include <string.h>
 
22
#include <time.h>
 
23
#include <unistd.h>
 
24
 
 
25
#include <samplerate.h>
 
26
 
 
27
#include "config.h"
 
28
 
 
29
#include "util.h"
 
30
#include "float_cast.h"
 
31
 
 
32
#define BUFFER_LEN      (1<<17)
 
33
 
 
34
static float input [BUFFER_LEN] ;
 
35
static float output [BUFFER_LEN] ;
 
36
 
 
37
static long
 
38
throughput_test (int converter, int channels, long best_throughput)
 
39
{       SRC_DATA src_data ;
 
40
        clock_t start_time, clock_time ;
 
41
        double duration ;
 
42
        long total_frames = 0, throughput ;
 
43
        int error ;
 
44
 
 
45
        printf ("    %-30s     %2d         ", src_get_name (converter), channels) ;
 
46
        fflush (stdout) ;
 
47
 
 
48
        src_data.data_in = input ;
 
49
        src_data.input_frames = ARRAY_LEN (input) / channels ;
 
50
 
 
51
        src_data.data_out = output ;
 
52
        src_data.output_frames = ARRAY_LEN (output) / channels ;
 
53
 
 
54
        src_data.src_ratio = 0.99 ;
 
55
 
 
56
        sleep (2) ;
 
57
 
 
58
        start_time = clock () ;
 
59
 
 
60
        do
 
61
        {
 
62
                if ((error = src_simple (&src_data, converter, channels)) != 0)
 
63
                {       puts (src_strerror (error)) ;
 
64
                        exit (1) ;
 
65
                        } ;
 
66
 
 
67
                total_frames += src_data.output_frames_gen ;
 
68
 
 
69
                clock_time = clock () - start_time ;
 
70
                duration = (1.0 * clock_time) / CLOCKS_PER_SEC ;
 
71
        }
 
72
        while (duration < 5.0) ;
 
73
 
 
74
        if (src_data.input_frames_used != src_data.input_frames)
 
75
        {       printf ("\n\nLine %d : input frames used %ld should be %ld\n", __LINE__, src_data.input_frames_used, src_data.input_frames) ;
 
76
                exit (1) ;
 
77
                } ;
 
78
 
 
79
        if (fabs (src_data.src_ratio * src_data.input_frames_used - src_data.output_frames_gen) > 2)
 
80
        {       printf ("\n\nLine %d : input / output length mismatch.\n\n", __LINE__) ;
 
81
                printf ("    input len  : %d\n", ARRAY_LEN (input) / channels) ;
 
82
                printf ("    output len : %ld (should be %g +/- 2)\n\n", src_data.output_frames_gen,
 
83
                                floor (0.5 + src_data.src_ratio * src_data.input_frames_used)) ;
 
84
                exit (1) ;
 
85
                } ;
 
86
 
 
87
        throughput = lrint (floor (total_frames / duration)) ;
 
88
 
 
89
        if (best_throughput == 0)
 
90
        {       best_throughput = MAX (throughput, best_throughput) ;
 
91
                printf ("%5.2f      %10ld\n", duration, throughput) ;
 
92
                }
 
93
        else
 
94
        {       best_throughput = MAX (throughput, best_throughput) ;
 
95
                printf ("%5.2f      %10ld       %10ld\n", duration, throughput, best_throughput) ;
 
96
                }
 
97
 
 
98
        return best_throughput ;
 
99
} /* throughput_test */
 
100
 
 
101
static void
 
102
single_run (void)
 
103
{       const int max_channels = 10 ;
 
104
        int k ;
 
105
 
 
106
        printf ("\n    CPU : ") ;
 
107
        print_cpu_name () ;
 
108
 
 
109
        puts (
 
110
                "\n"
 
111
                "    Converter                        Channels    Duration      Throughput\n"
 
112
                "    ---------------------------------------------------------------------"
 
113
                ) ;
 
114
 
 
115
        for (k = 1 ; k <= max_channels / 2 ; k++)
 
116
                throughput_test (SRC_SINC_FASTEST, k, 0) ;
 
117
 
 
118
        puts ("") ;
 
119
        for (k = 1 ; k <= max_channels / 2 ; k++)
 
120
                throughput_test (SRC_SINC_MEDIUM_QUALITY, k, 0) ;
 
121
 
 
122
        puts ("") ;
 
123
        for (k = 1 ; k <= max_channels ; k++)
 
124
                throughput_test (SRC_SINC_BEST_QUALITY, k, 0) ;
 
125
 
 
126
        puts ("") ;
 
127
        return ;
 
128
} /* single_run */
 
129
 
 
130
static void
 
131
multi_run (int run_count)
 
132
{       int k, ch ;
 
133
 
 
134
        printf ("\n    CPU name : ") ;
 
135
        print_cpu_name () ;
 
136
 
 
137
        puts (
 
138
                "\n"
 
139
                "    Converter                        Channels    Duration      Throughput    Best Throughput\n"
 
140
                "    ----------------------------------------------------------------------------------------"
 
141
                ) ;
 
142
 
 
143
        for (ch = 1 ; ch <= 5 ; ch++)
 
144
        {       long sinc_fastest = 0, sinc_medium = 0, sinc_best = 0 ;
 
145
 
 
146
                for (k = 0 ; k < run_count ; k++)
 
147
                {       sinc_fastest =          throughput_test (SRC_SINC_FASTEST, ch, sinc_fastest) ;
 
148
                        sinc_medium =           throughput_test (SRC_SINC_MEDIUM_QUALITY, ch, sinc_medium) ;
 
149
                        sinc_best =                     throughput_test (SRC_SINC_BEST_QUALITY, ch, sinc_best) ;
 
150
 
 
151
                        puts ("") ;
 
152
 
 
153
                        /* Let the CPU cool down. We might be running on a laptop. */
 
154
                        sleep (10) ;
 
155
                        } ;
 
156
 
 
157
                puts (
 
158
                        "\n"
 
159
                        "    Converter                        Best Throughput\n"
 
160
                        "    ------------------------------------------------"
 
161
                        ) ;
 
162
 
 
163
                printf ("    %-30s    %10ld\n", src_get_name (SRC_SINC_FASTEST), sinc_fastest) ;
 
164
                printf ("    %-30s    %10ld\n", src_get_name (SRC_SINC_MEDIUM_QUALITY), sinc_medium) ;
 
165
                printf ("    %-30s    %10ld\n", src_get_name (SRC_SINC_BEST_QUALITY), sinc_best) ;
 
166
                } ;
 
167
 
 
168
        puts ("") ;
 
169
} /* multi_run */
 
170
 
 
171
static void
 
172
usage_exit (const char * argv0)
 
173
{       const char * cptr ;
 
174
 
 
175
        if ((cptr = strrchr (argv0, '/')) != NULL)
 
176
                argv0 = cptr ;
 
177
 
 
178
        printf (
 
179
                "Usage :\n"
 
180
                "    %s                 - Single run of the throughput test.\n"
 
181
                "    %s --best-of N     - Do N runs of test a print bext result.\n"
 
182
                "\n",
 
183
                argv0, argv0) ;
 
184
 
 
185
        exit (0) ;
 
186
} /* usage_exit */
 
187
 
 
188
int
 
189
main (int argc, char ** argv)
 
190
{       double freq ;
 
191
 
 
192
        memset (input, 0, sizeof (input)) ;
 
193
        freq = 0.01 ;
 
194
        gen_windowed_sines (1, &freq, 1.0, input, BUFFER_LEN) ;
 
195
 
 
196
        if (argc == 1)
 
197
                single_run () ;
 
198
        else if (argc == 3 && strcmp (argv [1], "--best-of") == 0)
 
199
        {       int run_count = atoi (argv [2]) ;
 
200
 
 
201
                if (run_count < 1 || run_count > 20)
 
202
                {       printf ("Please be sensible. Run count should be in range (1, 10].\n") ;
 
203
                        exit (1) ;
 
204
                        } ;
 
205
 
 
206
                multi_run (run_count) ;
 
207
                }
 
208
        else
 
209
                usage_exit (argv [0]) ;
 
210
 
 
211
        puts (
 
212
                "            Duration is in seconds.\n"
 
213
                "            Throughput is in frames/sec (more is better).\n"
 
214
                ) ;
 
215
 
 
216
        return 0 ;
 
217
} /* main */
 
218