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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/******************************************/
/*
duplex.cpp
by Gary P. Scavone, 2006-2019.
This program opens a duplex stream and passes
input directly through to the output.
*/
/******************************************/
#include "RtAudio.h"
#include <iostream>
#include <cstdlib>
#include <cstring>
/*
typedef char MY_TYPE;
#define FORMAT RTAUDIO_SINT8
*/
typedef signed short MY_TYPE;
#define FORMAT RTAUDIO_SINT16
/*
typedef S24 MY_TYPE;
#define FORMAT RTAUDIO_SINT24
typedef signed long MY_TYPE;
#define FORMAT RTAUDIO_SINT32
typedef float MY_TYPE;
#define FORMAT RTAUDIO_FLOAT32
typedef double MY_TYPE;
#define FORMAT RTAUDIO_FLOAT64
*/
void usage( void ) {
// Error function in case of incorrect command-line
// argument specifications
std::cout << "\nuseage: duplex N fs <iDevice> <oDevice> <iChannelOffset> <oChannelOffset>\n";
std::cout << " where N = number of channels,\n";
std::cout << " fs = the sample rate,\n";
std::cout << " iDevice = optional input device index to use (default = 0),\n";
std::cout << " oDevice = optional output device index to use (default = 0),\n";
std::cout << " iChannelOffset = an optional input channel offset (default = 0),\n";
std::cout << " and oChannelOffset = optional output channel offset (default = 0).\n\n";
exit( 0 );
}
unsigned int getDeviceIndex( std::vector<std::string> deviceNames, bool isInput = false )
{
unsigned int i;
std::string keyHit;
std::cout << '\n';
for ( i=0; i<deviceNames.size(); i++ )
std::cout << " Device #" << i << ": " << deviceNames[i] << '\n';
do {
if ( isInput )
std::cout << "\nChoose an input device #: ";
else
std::cout << "\nChoose an output device #: ";
std::cin >> i;
} while ( i >= deviceNames.size() );
std::getline( std::cin, keyHit ); // used to clear out stdin
return i;
}
double streamTimePrintIncrement = 1.0; // seconds
double streamTimePrintTime = 1.0; // seconds
int inout( void *outputBuffer, void *inputBuffer, unsigned int /*nBufferFrames*/,
double streamTime, RtAudioStreamStatus status, void *data )
{
// Since the number of input and output channels is equal, we can do
// a simple buffer copy operation here.
if ( status ) std::cout << "Stream over/underflow detected." << std::endl;
if ( streamTime >= streamTimePrintTime ) {
std::cout << "streamTime = " << streamTime << std::endl;
streamTimePrintTime += streamTimePrintIncrement;
}
unsigned int *bytes = (unsigned int *) data;
memcpy( outputBuffer, inputBuffer, *bytes );
return 0;
}
int main( int argc, char *argv[] )
{
unsigned int channels, fs, bufferBytes, oDevice = 0, iDevice = 0, iOffset = 0, oOffset = 0;
// Minimal command-line checking
if (argc < 3 || argc > 7 ) usage();
RtAudio adac;
std::vector<unsigned int> deviceIds = adac.getDeviceIds();
if ( deviceIds.size() < 1 ) {
std::cout << "\nNo audio devices found!\n";
exit( 1 );
}
channels = (unsigned int) atoi(argv[1]);
fs = (unsigned int) atoi(argv[2]);
if ( argc > 3 )
iDevice = (unsigned int) atoi(argv[3]);
if ( argc > 4 )
oDevice = (unsigned int) atoi(argv[4]);
if ( argc > 5 )
iOffset = (unsigned int) atoi(argv[5]);
if ( argc > 6 )
oOffset = (unsigned int) atoi(argv[6]);
// Let RtAudio print messages to stderr.
adac.showWarnings( true );
// Set the same number of channels for both input and output.
unsigned int bufferFrames = 512;
RtAudio::StreamParameters iParams, oParams;
iParams.nChannels = channels;
iParams.firstChannel = iOffset;
oParams.nChannels = channels;
oParams.firstChannel = oOffset;
if ( iDevice == 0 )
iParams.deviceId = adac.getDefaultInputDevice();
else {
if ( iDevice >= deviceIds.size() )
iDevice = getDeviceIndex( adac.getDeviceNames(), true );
iParams.deviceId = deviceIds[iDevice];
}
if ( oDevice == 0 )
oParams.deviceId = adac.getDefaultOutputDevice();
else {
if ( oDevice >= deviceIds.size() )
oDevice = getDeviceIndex( adac.getDeviceNames() );
oParams.deviceId = deviceIds[oDevice];
}
RtAudio::StreamOptions options;
//options.flags |= RTAUDIO_NONINTERLEAVED;
bufferBytes = bufferFrames * channels * sizeof( MY_TYPE );
if ( adac.openStream( &oParams, &iParams, FORMAT, fs, &bufferFrames, &inout, (void *)&bufferBytes, &options ) ) {
goto cleanup;
}
if ( adac.isStreamOpen() == false ) goto cleanup;
// Test RtAudio functionality for reporting latency.
std::cout << "\nStream latency = " << adac.getStreamLatency() << " frames" << std::endl;
if ( adac.startStream() ) goto cleanup;
char input;
std::cout << "\nRunning ... press <enter> to quit (buffer frames = " << bufferFrames << ").\n";
std::cin.get(input);
// Stop the stream.
if ( adac.isStreamRunning() )
adac.stopStream();
cleanup:
if ( adac.isStreamOpen() ) adac.closeStream();
return 0;
}
|
