Mercurial > octave
annotate libinterp/dldfcn/audiodevinfo.cc @ 19517:22e2f11424b3
avoid more warnings in audio code
* audiodevinfo.cc: Avoid unnecessary use of this-> and eliminate
shadowed variable warnings. Use initialization in class
constructors. Pass octave_value and matrix objects by const reference
instead of by value.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Fri, 02 Jan 2015 12:05:14 -0500 |
parents | fc85d9026bb6 |
children | 572b9bd43e92 |
rev | line source |
---|---|
19500
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
1 /* |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
2 |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
3 Copyright (C) 2013 Vytautas JanĨauskas |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
4 |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
5 This file is part of Octave. |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
6 |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
7 Octave is free software; you can redistribute it and/or modify it |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
8 under the terms of the GNU General Public License as published by the |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
9 Free Software Foundation; either version 3 of the License, or (at your |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
10 option) any later version. |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
11 |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
12 Octave is distributed in the hope that it will be useful, but WITHOUT |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
15 for more details. |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
16 |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
17 You should have received a copy of the GNU General Public License |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
18 along with Octave; see the file COPYING. If not, see |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
19 <http://www.gnu.org/licenses/>. |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
20 |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
21 */ |
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
22 |
19501
1f551d169db2
Include config.h in audio project source files
Mike Miller <mtmiller@ieee.org>
parents:
19500
diff
changeset
|
23 #ifdef HAVE_CONFIG_H |
1f551d169db2
Include config.h in audio project source files
Mike Miller <mtmiller@ieee.org>
parents:
19500
diff
changeset
|
24 #include <config.h> |
1f551d169db2
Include config.h in audio project source files
Mike Miller <mtmiller@ieee.org>
parents:
19500
diff
changeset
|
25 #endif |
1f551d169db2
Include config.h in audio project source files
Mike Miller <mtmiller@ieee.org>
parents:
19500
diff
changeset
|
26 |
19510 | 27 // <cstdint> requires c++11 |
28 #include <stdint.h> | |
29 | |
30 #include <string> | |
31 #include <vector> | |
32 | |
19511
19f75d156ffe
don't include oct.h in Octave source files
John W. Eaton <jwe@octave.org>
parents:
19510
diff
changeset
|
33 #include "defun-dld.h" |
19f75d156ffe
don't include oct.h in Octave source files
John W. Eaton <jwe@octave.org>
parents:
19510
diff
changeset
|
34 #include "error.h" |
19f75d156ffe
don't include oct.h in Octave source files
John W. Eaton <jwe@octave.org>
parents:
19510
diff
changeset
|
35 #include "gripes.h" |
19f75d156ffe
don't include oct.h in Octave source files
John W. Eaton <jwe@octave.org>
parents:
19510
diff
changeset
|
36 #include "oct-obj.h" |
19510 | 37 #include "ov.h" |
19511
19f75d156ffe
don't include oct.h in Octave source files
John W. Eaton <jwe@octave.org>
parents:
19510
diff
changeset
|
38 #include "ov-int32.h" |
19472
c2031ad6dbe7
Fix octave header includes in audiodevinfo
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19469
diff
changeset
|
39 #include "ov-struct.h" |
19510 | 40 #include "parse.h" |
41 | |
42 #if defined (HAVE_PORTAUDIO) | |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
43 #include <portaudio.h> |
19510 | 44 #endif |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
45 |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
46 PaSampleFormat |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
47 bits_to_format (int bits) |
19473
2e174b5e7703
Fix audiodevinfo, audioinfo, audioread and audiowrite build process
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19472
diff
changeset
|
48 { |
2e174b5e7703
Fix audiodevinfo, audioinfo, audioread and audiowrite build process
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19472
diff
changeset
|
49 if (bits == 8) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
50 return paInt8; |
19473
2e174b5e7703
Fix audiodevinfo, audioinfo, audioread and audiowrite build process
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19472
diff
changeset
|
51 else if (bits == 16) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
52 return paInt16; |
19473
2e174b5e7703
Fix audiodevinfo, audioinfo, audioread and audiowrite build process
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19472
diff
changeset
|
53 else if (bits == 24) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
54 return paInt24; |
19473
2e174b5e7703
Fix audiodevinfo, audioinfo, audioread and audiowrite build process
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19472
diff
changeset
|
55 else if (bits == 32) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
56 return paInt32; |
19473
2e174b5e7703
Fix audiodevinfo, audioinfo, audioread and audiowrite build process
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19472
diff
changeset
|
57 else if (bits == -1) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
58 return paFloat32; |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
59 else |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
60 return 0; |
19473
2e174b5e7703
Fix audiodevinfo, audioinfo, audioread and audiowrite build process
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19472
diff
changeset
|
61 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
62 |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
63 DEFUN_DLD (audiodevinfo, args, , |
19505
ce02743b6f2a
Fix texinfo docstring syntax for all audio functions
Mike Miller <mtmiller@ieee.org>
parents:
19503
diff
changeset
|
64 "-*- texinfo -*-\n\ |
ce02743b6f2a
Fix texinfo docstring syntax for all audio functions
Mike Miller <mtmiller@ieee.org>
parents:
19503
diff
changeset
|
65 @deftypefn {Loadable Function} {@var{devinfo} =} audiodevinfo ()\n\ |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
66 \n\ |
19516
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
67 @deftypefnx {Loadable Function} {@var{devs} =} audiodevinfo (@var{io})\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
68 @deftypefnx {Loadable Function} {@var{name} =} audiodevinfo (@var{io}, @var{id})\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
69 @deftypefnx {Loadable Function} {@var{id} =} audiodevinfo (@var{io}, @var{name})\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
70 @deftypefnx {Loadable Function} {@var{id} =} audiodevinfo (@var{io}, @var{rate}, @var{bits}, @var{chans})\n\ |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
71 \n\ |
19516
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
72 @deftypefnx {Loadable Function} {@var{supports} =} audiodevinfo (@var{io}, @var{id}, @var{rate}, @var{bits}, @var{chans})\n\ |
19498
0ac6a4e7369b
change docstrings in audio defundld cc files to work with new texinfo
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19483
diff
changeset
|
73 \n\ |
19516
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
74 Return a structure with fields \"input\" and \"output\".\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
75 The value of each field is a structure array with fields\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
76 \"Name\", \"DriverVersion\" and \"ID\" describing an audio device.\n\ |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
77 \n\ |
19498
0ac6a4e7369b
change docstrings in audio defundld cc files to work with new texinfo
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19483
diff
changeset
|
78 \n\ |
19516
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
79 If the optional argument @var{io} is 1, return information about input\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
80 devices only. If it is 0, return information about output devices only.\n\ |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
81 \n\ |
19516
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
82 If the optional argument @var{id} is provided, return information about\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
83 corresponding device.\n\ |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
84 \n\ |
19516
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
85 If the optional argument @var{name} is provided, return the id of the\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
86 named device.\n\ |
19498
0ac6a4e7369b
change docstrings in audio defundld cc files to work with new texinfo
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19483
diff
changeset
|
87 \n\ |
19516
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
88 Given a sampling rate, bits per sample, and number of channels for\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
89 an input or output device, return the ID of the first device that\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
90 supports playback or recording using the specified parameters.\n\ |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
91 \n\ |
19516
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
92 If also given a device ID, return true if the device supports playback\n\ |
fc85d9026bb6
doc fixes for audio functions
John W. Eaton <jwe@octave.org>
parents:
19515
diff
changeset
|
93 or recording using those parameters.\n\ |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
94 @end deftypefn") |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
95 { |
19483
abde714a4f88
let audiodevinfo be built even when PortAudio is not present
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19473
diff
changeset
|
96 octave_value retval; |
abde714a4f88
let audiodevinfo be built even when PortAudio is not present
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19473
diff
changeset
|
97 #ifdef HAVE_PORTAUDIO |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
98 int nargin = args.length (); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
99 PaError err; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
100 octave_scalar_map devinfo; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
101 octave_value_list input; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
102 octave_value_list output; |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
103 |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
104 err = Pa_Initialize (); |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
105 if (err != paNoError) |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
106 { |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
107 error ("audiodevinfo: cannot initialize PortAudio"); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
108 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
109 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
110 |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
111 int num_devices = Pa_GetDeviceCount (); |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
112 if (num_devices < 0) |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
113 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
114 error ("audiodevinfo: no audio device found"); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
115 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
116 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
117 |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
118 octave_idx_type numinput = 0, numoutput = 0; |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
119 for (int i = 0; i < num_devices; i++) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
120 { |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
121 const PaDeviceInfo *device_info = Pa_GetDeviceInfo (i); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
122 if (device_info->maxInputChannels != 0) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
123 numinput++; |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
124 if (device_info->maxOutputChannels != 0) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
125 numoutput++; |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
126 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
127 |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
128 Cell input_name (dim_vector (1, numinput)); |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
129 Cell input_driver_version (dim_vector (1, numinput)); |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
130 Cell input_id (dim_vector (1, numinput)); |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
131 Cell output_name (dim_vector (1, numoutput)); |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
132 Cell output_driver_version (dim_vector (1, numoutput)); |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
133 Cell output_id (dim_vector (1, numoutput)); |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
134 |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
135 octave_idx_type idx_i = 0, idx_o = 0; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
136 for (int i = 0; i < num_devices; i++) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
137 { |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
138 const PaDeviceInfo *device_info = Pa_GetDeviceInfo (i); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
139 const char *driver; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
140 char name[128]; |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
141 driver = Pa_GetHostApiInfo (device_info->hostApi)->name; |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
142 sprintf (name, "%s (%s)", device_info->name, driver); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
143 |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
144 if (device_info->maxInputChannels != 0) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
145 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
146 input_name(idx_i) = name; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
147 input_driver_version(idx_i) = driver; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
148 input_id(idx_i) = i; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
149 idx_i++; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
150 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
151 |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
152 if (device_info->maxOutputChannels != 0) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
153 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
154 output_name(idx_o) = name; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
155 output_driver_version(idx_o) = driver; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
156 output_id(idx_o) = i; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
157 idx_o++; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
158 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
159 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
160 |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
161 octave_map inputdev, outputdev; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
162 inputdev.setfield ("Name", input_name); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
163 inputdev.setfield ("DriverVersion", input_driver_version); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
164 inputdev.setfield ("ID", input_id); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
165 outputdev.setfield ("Name", output_name); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
166 outputdev.setfield ("DriverVersion", output_driver_version); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
167 outputdev.setfield ("ID", output_id); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
168 devinfo.setfield ("input", inputdev); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
169 devinfo.setfield ("output", outputdev); |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
170 |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
171 // Return information about input and output audio devices and |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
172 // their properties. |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
173 if (nargin == 0) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
174 retval = devinfo; |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
175 // Return the number of input or output devices |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
176 else if (nargin == 1) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
177 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
178 if (args(0).int_value () == 0) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
179 retval = octave_value (numoutput); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
180 else if (args(0).int_value () == 1) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
181 retval = octave_value (numinput); |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
182 else |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
183 { |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
184 error ("audiodevinfo: please specify 0 for output and 1 for input devices"); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
185 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
186 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
187 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
188 // Return device name when given id or id when given device name. |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
189 else if (nargin == 2) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
190 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
191 bool found = false; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
192 int outin = args(0).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
193 if (args(1).is_string ()) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
194 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
195 if (outin == 0) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
196 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
197 for (int i = 0; i < numoutput; i++) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
198 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
199 if (output_name(i).string_value () == args(1).string_value ()) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
200 { |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
201 retval = output_id(i); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
202 found = true; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
203 break; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
204 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
205 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
206 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
207 else if (outin == 1) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
208 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
209 for (int i = 0; i < numinput; i++) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
210 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
211 if (input_name(i).string_value () == args(1).string_value ()) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
212 { |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
213 retval = input_id(i); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
214 found = true; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
215 break; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
216 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
217 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
218 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
219 else |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
220 { |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
221 error ("audiodevinfo: please specify 0 for output and 1 for input devices"); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
222 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
223 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
224 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
225 else |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
226 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
227 if (outin == 0) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
228 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
229 for (int i = 0; i < numoutput; i++) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
230 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
231 if (output_id(i).int_value () == args(1).int_value ()) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
232 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
233 retval = output_name(i); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
234 found = true; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
235 break; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
236 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
237 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
238 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
239 else if (outin == 1) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
240 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
241 for (int i = 0; i < numinput; i++) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
242 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
243 if (input_id(i).int_value () == args(1).int_value ()) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
244 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
245 retval = input_name(i); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
246 found = true; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
247 break; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
248 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
249 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
250 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
251 else |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
252 { |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
253 error ("audiodevinfo: please specify 0 for output and 1 for input devices"); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
254 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
255 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
256 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
257 if (not found) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
258 error ("audiodevinfo: no device meeting the specified criteria found"); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
259 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
260 else if (nargin == 3) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
261 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
262 // |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
263 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
264 // Return the id of the first device meeting specified criteria. |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
265 else if (nargin == 4) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
266 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
267 int io = args(0).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
268 int rate = args(1).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
269 int bits = args(2).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
270 int chans = args(3).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
271 for (int i = 0; i < num_devices; i++) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
272 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
273 PaStreamParameters stream_parameters; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
274 stream_parameters.device = i; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
275 stream_parameters.channelCount = chans; |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
276 PaSampleFormat format = bits_to_format (bits); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
277 if (format != 0) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
278 stream_parameters.sampleFormat = format; |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
279 else |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
280 { |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
281 error ("audiodevinfo: no such bits per sample format"); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
282 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
283 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
284 stream_parameters.suggestedLatency = |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
285 Pa_GetDeviceInfo (i)->defaultLowInputLatency; |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
286 stream_parameters.hostApiSpecificStreamInfo = NULL; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
287 if (io == 0) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
288 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
289 if (Pa_GetDeviceInfo (i)->maxOutputChannels < chans) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
290 continue; |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
291 |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
292 err = Pa_IsFormatSupported (NULL, &stream_parameters, rate); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
293 if (err == paFormatIsSupported) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
294 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
295 retval = i; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
296 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
297 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
298 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
299 else if (io == 1) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
300 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
301 if (Pa_GetDeviceInfo (i)->maxInputChannels < chans) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
302 continue; |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
303 |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
304 err = Pa_IsFormatSupported (&stream_parameters, NULL, rate); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
305 if (err == paFormatIsSupported) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
306 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
307 retval = i; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
308 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
309 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
310 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
311 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
312 retval = -1; |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
313 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
314 // Check if given device supports specified playback or recording modes. |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
315 else if (nargin == 5) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
316 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
317 int io = args(0).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
318 int id = args(1).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
319 int rate = args(2).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
320 int bits = args(3).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
321 int chans = args(4).int_value (); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
322 PaStreamParameters stream_parameters; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
323 stream_parameters.device = id; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
324 stream_parameters.channelCount = chans; |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
325 PaSampleFormat format = bits_to_format (bits); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
326 if (format != 0) |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
327 stream_parameters.sampleFormat = format; |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
328 else |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
329 { |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
330 error ("audiodevinfo: no such bits per sample format"); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
331 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
332 } |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
333 stream_parameters.suggestedLatency = |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
334 Pa_GetDeviceInfo (id)->defaultLowInputLatency; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
335 stream_parameters.hostApiSpecificStreamInfo = NULL; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
336 if (io == 0) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
337 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
338 if (Pa_GetDeviceInfo (id)->maxOutputChannels < chans) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
339 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
340 retval = 0; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
341 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
342 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
343 err = Pa_IsFormatSupported (NULL, &stream_parameters, rate); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
344 if (err == paFormatIsSupported) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
345 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
346 retval = 1; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
347 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
348 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
349 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
350 else if (io == 1) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
351 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
352 if (Pa_GetDeviceInfo (id)->maxInputChannels < chans) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
353 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
354 retval = 0; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
355 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
356 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
357 err = Pa_IsFormatSupported (&stream_parameters, NULL, rate); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
358 if (err == paFormatIsSupported) |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
359 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
360 retval = 1; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
361 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
362 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
363 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
364 else |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
365 { |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
366 error ("audiodevinfo: please specify 0 for output and 1 for input devices"); |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
367 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
368 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
369 retval = 0; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
370 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
371 else |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
372 { |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
373 error ("audiodevinfo: wrong number of arguments"); |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
374 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
375 } |
19483
abde714a4f88
let audiodevinfo be built even when PortAudio is not present
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19473
diff
changeset
|
376 #else |
abde714a4f88
let audiodevinfo be built even when PortAudio is not present
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19473
diff
changeset
|
377 error ("portaudio not found on your system and thus audio functionality is not present"); |
abde714a4f88
let audiodevinfo be built even when PortAudio is not present
Vytautas Jančauskas <unaudio@gmail.com>
parents:
19473
diff
changeset
|
378 #endif |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
379 return retval; |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
380 } |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
381 |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
382 /* |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
383 %!test |
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
384 %! devinfo = audiodevinfo; |
19509 | 385 %! assert (rows (devinfo.input), 1); |
386 %! assert (rows (devinfo.output), 1); | |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
387 |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
388 %!test |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
389 %! devinfo = audiodevinfo; |
19509 | 390 %! nout = audiodevinfo (0); |
391 %! nin = audiodevinfo (1); | |
392 %! assert (columns (devinfo.output), nout); | |
393 %! assert (columns (devinfo.input), nin); | |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
394 |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
395 %!test |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
396 %! devinfo = audiodevinfo; |
19509 | 397 %! nout = audiodevinfo (0); |
398 %! nin = audiodevinfo (1); | |
399 %! for i = 1:nout, | |
400 %! assert (devinfo.output(i).Name, audiodevinfo (0, devinfo.output(i).ID)) | |
401 %! endfor | |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
402 %! for i=1:nin, |
19509 | 403 %! assert (devinfo.input(i).Name, audiodevinfo (1, devinfo.input(i).ID)) |
404 %! endfor | |
19469
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
405 |
ea5c156aa804
audiodevinfo.cc: new file
Vytautas Jančauskas <unaudio@gmail.com>
parents:
diff
changeset
|
406 %!test |
19503
36a26a131209
Apply Octave coding style to audio project additions
Mike Miller <mtmiller@ieee.org>
parents:
19501
diff
changeset
|
407 %! devinfo = audiodevinfo; |
19509 | 408 %! nout = audiodevinfo (0); |
409 %! nin = audiodevinfo (1); | |
410 %! for i = 1:nout, | |
411 %! assert (devinfo.output(i).ID, audiodevinfo (0, devinfo.output(i).Name)) | |
412 %! endfor | |
413 %! for i = 1:nin, | |
414 %! assert (devinfo.input(i).ID, audiodevinfo (1, devinfo.input(i).Name)) | |
415 %! endfor | |
19500
8bb399569393
Add Octave copyright header block to audio project files
Mike Miller <mtmiller@ieee.org>
parents:
19498
diff
changeset
|
416 */ |
19510 | 417 |
418 enum audio_type { INT8, UINT8, INT16, DOUBLE }; | |
419 | |
420 class audioplayer : public octave_base_value | |
421 { | |
422 public: | |
423 audioplayer (void); | |
424 ~audioplayer (void) {}; | |
425 | |
426 // Overloaded base functions | |
427 double player_value (void) const { return 0; } | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
428 virtual double scalar_value (bool = false) const { return 0; } |
19510 | 429 void print (std::ostream& os, bool pr_as_read_syntax = false) const; |
430 void print_raw (std::ostream& os, bool pr_as_read_syntax) const; | |
431 | |
432 // Properties | |
433 bool is_constant (void) const { return true; } | |
434 bool is_defined (void) const { return true; } | |
435 bool print_as_scalar (void) const { return true; } | |
436 | |
437 void init (void); | |
438 void init_fn (void); | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
439 void set_y (const octave_value& y); |
19510 | 440 void set_y (octave_function *fn); |
441 void set_y (std::string fn); | |
442 Matrix& get_y (void); | |
443 RowVector *get_left (void); | |
444 RowVector *get_right (void); | |
445 void set_fs (int fs); | |
446 int get_fs (void); | |
447 void set_nbits (int nbits); | |
448 int get_nbits (void); | |
449 void set_id (int id); | |
450 int get_id (void); | |
451 int get_channels (void); | |
452 audio_type get_type (void); | |
453 | |
454 void set_sample_number (unsigned int sample); | |
455 unsigned int get_sample_number (void); | |
456 unsigned int get_total_samples (void); | |
457 void set_end_sample (unsigned int sample); | |
458 unsigned int get_end_sample (void); | |
459 void reset_end_sample (void); | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
460 void set_tag (const charMatrix& tag); |
19510 | 461 charMatrix get_tag (void); |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
462 void set_userdata (const octave_value& userdata); |
19510 | 463 octave_value get_userdata (void); |
464 PaStream *get_stream (void); | |
465 | |
466 void playblocking (void); | |
467 void play (void); | |
468 void pause (void); | |
469 void resume (void); | |
470 void stop (void); | |
471 bool isplaying (void); | |
472 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
473 octave_function *octave_callback_function; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
474 |
19510 | 475 private: |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
476 int id; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
477 int fs; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
478 int nbits; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
479 int channels; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
480 unsigned int sample_number; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
481 unsigned int end_sample; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
482 charMatrix tag; |
19510 | 483 Matrix y; |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
484 octave_value userdata; |
19510 | 485 RowVector left; |
486 RowVector right; | |
487 PaStream *stream; | |
488 PaStreamParameters output_parameters; | |
489 audio_type type; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
490 |
19510 | 491 DECLARE_OCTAVE_ALLOCATOR |
492 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA | |
493 }; | |
494 | |
495 #define BUFFER_SIZE 512 | |
496 | |
497 DEFINE_OCTAVE_ALLOCATOR (audioplayer); | |
498 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (audioplayer, "audioplayer", "audioplayer"); | |
499 | |
500 int | |
501 is_big_endian (void) | |
502 { | |
503 union | |
504 { | |
505 uint32_t i; | |
506 char c[4]; | |
507 } bint = { 0x01020304 }; | |
508 return bint.c[0] == 1; | |
509 } | |
510 | |
511 static int | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
512 octave_play_callback (const void *, void *output, unsigned long frames, |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
513 const PaStreamCallbackTimeInfo *, |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
514 PaStreamCallbackFlags, void *data) |
19510 | 515 { |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
516 audioplayer *player = static_cast<audioplayer *> (data); |
19510 | 517 int big_endian = is_big_endian (); |
518 octave_value_list args, retval; | |
519 args(0) = frames; | |
520 retval = feval (player->octave_callback_function, args, 1); | |
521 RowVector sound_l, sound_r; | |
522 Matrix sound = retval(0).matrix_value (); | |
523 int return_status = retval(1).int_value (); | |
524 sound_l.resize (frames); | |
525 sound_r.resize (frames); | |
526 if (sound.cols () == 1) | |
527 { | |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
528 for (unsigned long i = 0; i < frames; i++) |
19510 | 529 { |
530 sound_l(i) = sound(i, 0); | |
531 sound_r(i) = sound(i, 0); | |
532 } | |
533 } | |
534 else if (sound.cols () == 2) | |
535 { | |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
536 for (unsigned long i = 0; i < frames; i++) |
19510 | 537 { |
538 sound_l(i) = sound(i, 0); | |
539 sound_r(i) = sound(i, 1); | |
540 } | |
541 } | |
542 else | |
543 return paAbort; | |
544 | |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
545 for (unsigned long i = 0; i < frames; i++) |
19510 | 546 { |
547 if (player->get_nbits () == 8) | |
548 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
549 int8_t *buffer = static_cast<int8_t *> (output); |
19510 | 550 buffer[2 * i] = sound_l.elem (i) * (pow (2.0, 7) - 1); |
551 buffer[2 * i + 1] = sound_r.elem (i) * (pow (2.0, 7) - 1); | |
552 } | |
553 else if (player->get_nbits () == 16) | |
554 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
555 int16_t *buffer = static_cast<int16_t *> (output); |
19510 | 556 buffer[2 * i] = sound_l.elem (i) * (pow (2.0, 15) - 1); |
557 buffer[2 * i + 1] = sound_r.elem (i) * (pow (2.0, 15) - 1); | |
558 } | |
559 else if (player->get_nbits () == 24) | |
560 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
561 uint8_t *buffer = static_cast<uint8_t *> (output); |
19510 | 562 int32_t sample_l = sound_l.elem (i) * (pow (2.0, 23) - 1); |
563 int32_t sample_r = sound_r.elem (i) * (pow (2.0, 23) - 1); | |
564 sample_l &= 0x00ffffff; | |
565 sample_r &= 0x00ffffff; | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
566 // FIXME: Would a mask work better? |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
567 uint8_t *_sample_l = reinterpret_cast<uint8_t *> (&sample_l); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
568 uint8_t *_sample_r = reinterpret_cast<uint8_t *> (&sample_r); |
19510 | 569 buffer[i * 6 + 0] = _sample_l[0 + big_endian]; |
570 buffer[i * 6 + 1] = _sample_l[1 + big_endian]; | |
571 buffer[i * 6 + 2] = _sample_l[2 + big_endian]; | |
572 buffer[i * 6 + 3] = _sample_r[0 + big_endian]; | |
573 buffer[i * 6 + 4] = _sample_r[1 + big_endian]; | |
574 buffer[i * 6 + 5] = _sample_r[2 + big_endian]; | |
575 } | |
576 } | |
577 return return_status; | |
578 } | |
579 | |
580 static int | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
581 portaudio_play_callback (const void *, void *output, unsigned long frames, |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
582 const PaStreamCallbackTimeInfo*, |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
583 PaStreamCallbackFlags, void *data) |
19510 | 584 { |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
585 audioplayer *player = static_cast<audioplayer *> (data); |
19510 | 586 int big_endian = is_big_endian (); |
587 int channels = player->get_channels (); | |
588 RowVector *sound_l = player->get_left (); | |
589 RowVector *sound_r; | |
590 | |
591 if (channels > 1) | |
592 sound_r = player->get_right (); | |
593 else | |
594 sound_r = sound_l; | |
595 | |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
596 for (unsigned long j = 0, k = 0; j < frames; j++, k += 2) |
19510 | 597 { |
598 unsigned int sample_number = player->get_sample_number (); | |
599 if (sample_number > player->get_end_sample ()) | |
600 return paAbort; | |
601 | |
602 if (player->get_type () == DOUBLE) | |
603 { | |
604 if (player->get_nbits () == 8) | |
605 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
606 int8_t *buffer = static_cast<int8_t *> (output); |
19510 | 607 buffer[k] = sound_l->elem (sample_number) * (pow (2.0, 7) - 1); |
608 buffer[k + 1] = sound_r->elem (sample_number) * (pow (2.0, 7) - 1); | |
609 } | |
610 else if (player->get_nbits () == 16) | |
611 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
612 int16_t *buffer = static_cast<int16_t *> (output); |
19510 | 613 buffer[k] = sound_l->elem (sample_number) * (pow (2.0, 15) - 1); |
614 buffer[k + 1] = sound_r->elem (sample_number) * (pow (2.0, 15) - 1); | |
615 } | |
616 else if (player->get_nbits () == 24) | |
617 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
618 uint8_t *buffer = static_cast<uint8_t *> (output); |
19510 | 619 int32_t sample_l = sound_l->elem (sample_number) * (pow (2.0, 23) - 1); |
620 int32_t sample_r = sound_r->elem (sample_number) * (pow (2.0, 23) - 1); | |
621 sample_l &= 0x00ffffff; | |
622 sample_r &= 0x00ffffff; | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
623 // FIXME: Would a mask work better? |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
624 uint8_t *_sample_l = reinterpret_cast<uint8_t *> (&sample_l); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
625 uint8_t *_sample_r = reinterpret_cast<uint8_t *> (&sample_r); |
19510 | 626 buffer[j * 6 + 0] = _sample_l[0 + big_endian]; |
627 buffer[j * 6 + 1] = _sample_l[1 + big_endian]; | |
628 buffer[j * 6 + 2] = _sample_l[2 + big_endian]; | |
629 buffer[j * 6 + 3] = _sample_r[0 + big_endian]; | |
630 buffer[j * 6 + 4] = _sample_r[1 + big_endian]; | |
631 buffer[j * 6 + 5] = _sample_r[2 + big_endian]; | |
632 } | |
633 } | |
634 else if (player->get_type () == INT8) | |
635 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
636 int8_t *buffer = static_cast<int8_t *> (output); |
19510 | 637 buffer[k] = sound_l->elem (sample_number); |
638 buffer[k + 1] = sound_r->elem (sample_number); | |
639 } | |
640 else if (player->get_type () == UINT8) | |
641 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
642 uint8_t *buffer = static_cast<uint8_t *> (output); |
19510 | 643 buffer[k] = sound_l->elem (sample_number); |
644 buffer[k + 1] = sound_r->elem (sample_number); | |
645 } | |
646 else if (player->get_type () == INT16) | |
647 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
648 int16_t *buffer = static_cast<int16_t *> (output); |
19510 | 649 buffer[k] = sound_l->elem (sample_number); |
650 buffer[k + 1] = sound_r->elem (sample_number); | |
651 } | |
652 player->set_sample_number (sample_number + 1); | |
653 } | |
654 return paContinue; | |
655 } | |
656 | |
657 audioplayer::audioplayer (void) | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
658 : octave_callback_function (0), |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
659 id (-1), fs (0), nbits (16), channels (0), sample_number (0), |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
660 end_sample (-1), tag (""), y (), userdata (Matrix ()), |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
661 left (), right (), stream (0), output_parameters (), type () |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
662 { } |
19510 | 663 |
664 void | |
665 audioplayer::print (std::ostream& os, bool pr_as_read_syntax) const | |
666 { | |
667 print_raw (os, pr_as_read_syntax); | |
668 newline (os); | |
669 } | |
670 | |
671 void | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
672 audioplayer::print_raw (std::ostream& os, bool) const |
19510 | 673 { |
674 os << 0; | |
675 } | |
676 | |
677 void | |
678 audioplayer::init_fn (void) | |
679 { | |
680 PaError err; | |
681 int device; | |
682 | |
683 err = Pa_Initialize (); | |
684 if (err != paNoError) | |
685 { | |
686 error ("audioplayer: Initialization error!"); | |
687 return; | |
688 } | |
689 | |
690 int numDevices = Pa_GetDeviceCount (); | |
691 if (numDevices < 0) | |
692 { | |
693 error ("audioplayer: No audio devices found!"); | |
694 return; | |
695 } | |
696 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
697 if (get_id () == -1) |
19510 | 698 device = Pa_GetDefaultOutputDevice (); |
699 else | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
700 device = get_id (); |
19510 | 701 |
702 output_parameters.device = device; | |
703 output_parameters.channelCount = 2; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
704 output_parameters.sampleFormat = bits_to_format (get_nbits ()); |
19510 | 705 output_parameters.suggestedLatency = Pa_GetDeviceInfo (device)->defaultHighOutputLatency; |
706 output_parameters.hostApiSpecificStreamInfo = NULL; | |
707 } | |
708 | |
709 void | |
710 audioplayer::init (void) | |
711 { | |
712 PaError err; | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
713 |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
714 // Both of these variables are unused. Should they be |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
715 // eliminated or is something not yet implemented? |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
716 // |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
717 // int channels = y.rows (); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
718 // RowVector *sound_l = get_left (); |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
719 |
19510 | 720 int device; |
721 | |
722 err = Pa_Initialize (); | |
723 if (err != paNoError) | |
724 { | |
725 error ("audioplayer: Initialization error!"); | |
726 return; | |
727 } | |
728 | |
729 int numDevices = Pa_GetDeviceCount (); | |
730 if (numDevices < 0) | |
731 { | |
732 error ("audioplayer: No audio devices found!"); | |
733 return; | |
734 } | |
735 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
736 if (get_id () == -1) |
19510 | 737 device = Pa_GetDefaultOutputDevice (); |
738 else | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
739 device = get_id (); |
19510 | 740 |
741 output_parameters.device = device; | |
742 output_parameters.channelCount = 2; | |
743 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
744 if (type == DOUBLE) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
745 output_parameters.sampleFormat = bits_to_format (get_nbits ()); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
746 else if (type == INT8) |
19510 | 747 output_parameters.sampleFormat = paInt8; |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
748 else if (type == UINT8) |
19510 | 749 output_parameters.sampleFormat = paUInt8; |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
750 else if (type == INT16) |
19510 | 751 output_parameters.sampleFormat = paInt16; |
752 | |
753 output_parameters.suggestedLatency = Pa_GetDeviceInfo (device)->defaultHighOutputLatency; | |
754 output_parameters.hostApiSpecificStreamInfo = NULL; | |
755 } | |
756 | |
757 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
758 audioplayer::set_y (const octave_value& y_arg) |
19510 | 759 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
760 if (y_arg.is_int8_type ()) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
761 type = INT8; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
762 else if (y_arg.is_uint8_type ()) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
763 type = UINT8; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
764 else if (y_arg.is_int16_type ()) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
765 type = INT16; |
19510 | 766 else |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
767 type = DOUBLE; |
19510 | 768 |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
769 y = y_arg.matrix_value (); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
770 |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
771 if (y.rows () > 2) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
772 y = y.transpose (); |
19510 | 773 |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
774 channels = y.rows (); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
775 left = y.row (0); |
19510 | 776 |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
777 if (channels == 2) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
778 right = y.row (1); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
779 |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
780 reset_end_sample (); |
19510 | 781 } |
782 | |
783 void | |
784 audioplayer::set_y (octave_function *fn) | |
785 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
786 octave_callback_function = fn; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
787 channels = 2; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
788 reset_end_sample (); |
19510 | 789 } |
790 | |
791 Matrix& | |
792 audioplayer::get_y (void) | |
793 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
794 return y; |
19510 | 795 } |
796 | |
797 RowVector * | |
798 audioplayer::get_left (void) | |
799 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
800 return &(left); |
19510 | 801 } |
802 | |
803 RowVector * | |
804 audioplayer::get_right (void) | |
805 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
806 return &(right); |
19510 | 807 } |
808 | |
809 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
810 audioplayer::set_fs (int fs_arg) |
19510 | 811 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
812 fs = fs_arg; |
19510 | 813 } |
814 | |
815 int | |
816 audioplayer::get_fs (void) | |
817 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
818 return fs; |
19510 | 819 } |
820 | |
821 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
822 audioplayer::set_nbits (int nbits_arg) |
19510 | 823 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
824 nbits = nbits_arg; |
19510 | 825 } |
826 | |
827 int | |
828 audioplayer::get_nbits (void) | |
829 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
830 return nbits; |
19510 | 831 } |
832 | |
833 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
834 audioplayer::set_id (int id_arg) |
19510 | 835 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
836 id = id_arg; |
19510 | 837 } |
838 | |
839 int | |
840 audioplayer::get_id (void) | |
841 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
842 return id; |
19510 | 843 } |
844 | |
845 int | |
846 audioplayer::get_channels (void) | |
847 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
848 return channels; |
19510 | 849 } |
850 | |
851 audio_type | |
852 audioplayer::get_type (void) | |
853 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
854 return type; |
19510 | 855 } |
856 | |
857 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
858 audioplayer::set_sample_number (unsigned int sample_number_arg) |
19510 | 859 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
860 sample_number = sample_number_arg; |
19510 | 861 } |
862 | |
863 unsigned int | |
864 audioplayer::get_sample_number (void) | |
865 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
866 return sample_number; |
19510 | 867 } |
868 | |
869 unsigned int | |
870 audioplayer::get_total_samples (void) | |
871 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
872 return left.length (); |
19510 | 873 } |
874 | |
875 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
876 audioplayer::set_end_sample (unsigned int end_sample_arg) |
19510 | 877 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
878 end_sample = end_sample_arg; |
19510 | 879 } |
880 | |
881 unsigned int | |
882 audioplayer::get_end_sample (void) | |
883 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
884 return end_sample; |
19510 | 885 } |
886 | |
887 void | |
888 audioplayer::reset_end_sample (void) | |
889 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
890 set_end_sample (left.length ()); |
19510 | 891 } |
892 | |
893 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
894 audioplayer::set_tag (const charMatrix& tag_arg) |
19510 | 895 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
896 tag = tag_arg; |
19510 | 897 } |
898 | |
899 charMatrix | |
900 audioplayer::get_tag (void) | |
901 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
902 return tag; |
19510 | 903 } |
904 | |
905 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
906 audioplayer::set_userdata (const octave_value& userdata_arg) |
19510 | 907 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
908 userdata = userdata_arg; |
19510 | 909 } |
910 | |
911 octave_value | |
912 audioplayer::get_userdata (void) | |
913 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
914 return userdata; |
19510 | 915 } |
916 | |
917 void | |
918 audioplayer::playblocking (void) | |
919 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
920 if (get_stream ()) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
921 stop (); |
19510 | 922 |
923 PaError err; | |
924 uint32_t buffer[BUFFER_SIZE * 2]; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
925 err = Pa_OpenStream (&stream, NULL, &(output_parameters), get_fs (), BUFFER_SIZE, paClipOff, NULL, NULL); |
19510 | 926 if (err != paNoError) |
927 { | |
928 error ("audioplayer: Error opening audio playback stream"); | |
929 return; | |
930 } | |
931 | |
932 err = Pa_StartStream (stream); | |
933 if (err != paNoError) | |
934 { | |
935 error ("audioplayer: Error starting audio playback stream"); | |
936 return; | |
937 } | |
938 | |
939 unsigned int start, end; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
940 start = get_sample_number (); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
941 end = get_end_sample (); |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
942 for (unsigned int i = start; i < end; i += BUFFER_SIZE) |
19510 | 943 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
944 if (octave_callback_function != 0) |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
945 octave_play_callback (0, buffer, BUFFER_SIZE, 0, 0, this); |
19510 | 946 else |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
947 portaudio_play_callback (0, buffer, BUFFER_SIZE, 0, 0, this); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
948 |
19510 | 949 err = Pa_WriteStream (stream, buffer, BUFFER_SIZE); |
950 } | |
951 | |
952 err = Pa_StopStream (stream); | |
953 if (err != paNoError) | |
954 { | |
955 error ("audioplayer: Error stoping audio playback stream"); | |
956 return; | |
957 } | |
958 | |
959 err = Pa_CloseStream (stream); | |
960 if (err != paNoError) | |
961 { | |
962 error ("audioplayer: Error closing audio playback stream"); | |
963 return; | |
964 } | |
965 | |
966 stream = 0; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
967 set_sample_number (0); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
968 reset_end_sample (); |
19510 | 969 } |
970 | |
971 void | |
972 audioplayer::play (void) | |
973 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
974 if (get_stream ()) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
975 stop (); |
19510 | 976 |
977 PaError err; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
978 if (octave_callback_function != 0) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
979 err = Pa_OpenStream (&stream, NULL, &(output_parameters), |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
980 get_fs (), BUFFER_SIZE, paClipOff, |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
981 octave_play_callback, this); |
19510 | 982 else |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
983 err = Pa_OpenStream (&stream, NULL, &(output_parameters), |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
984 get_fs (), BUFFER_SIZE, paClipOff, |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
985 portaudio_play_callback, this); |
19510 | 986 |
987 if (err != paNoError) | |
988 { | |
989 error ("audioplayer: Error opening audio playback stream"); | |
990 return; | |
991 } | |
992 | |
993 err = Pa_StartStream (stream); | |
994 if (err != paNoError) | |
995 { | |
996 error ("audioplayer: Error starting audio playback stream"); | |
997 return; | |
998 } | |
999 } | |
1000 | |
1001 void | |
1002 audioplayer::pause (void) | |
1003 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1004 if (get_stream () == 0) |
19510 | 1005 return; |
1006 | |
1007 PaError err; | |
1008 err = Pa_StopStream (stream); | |
1009 if (err != paNoError) | |
1010 { | |
1011 error ("audiorecorder: Error stoping audio recording stream"); | |
1012 return; | |
1013 } | |
1014 } | |
1015 | |
1016 void | |
1017 audioplayer::resume (void) | |
1018 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1019 if (get_stream () == 0) |
19510 | 1020 return; |
1021 | |
1022 PaError err; | |
1023 err = Pa_StartStream (stream); | |
1024 if (err != paNoError) | |
1025 { | |
1026 error ("audiorecorder: Error starting audio recording stream"); | |
1027 return; | |
1028 } | |
1029 } | |
1030 | |
1031 PaStream * | |
1032 audioplayer::get_stream (void) | |
1033 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1034 return stream; |
19510 | 1035 } |
1036 | |
1037 void | |
1038 audioplayer::stop (void) | |
1039 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1040 if (get_stream () == 0) |
19510 | 1041 return; |
1042 | |
1043 PaError err; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1044 set_sample_number (0); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1045 reset_end_sample (); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1046 if (not Pa_IsStreamStopped (get_stream ())) |
19510 | 1047 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1048 err = Pa_AbortStream (get_stream ()); |
19510 | 1049 if (err != paNoError) |
1050 { | |
1051 error ("audioplayer: Error stopping audio playback stream"); | |
1052 return; | |
1053 } | |
1054 } | |
1055 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1056 err = Pa_CloseStream (get_stream ()); |
19510 | 1057 if (err != paNoError) |
1058 { | |
1059 error ("audioplayer: Error closing audio playback stream"); | |
1060 return; | |
1061 } | |
1062 | |
1063 stream = 0; | |
1064 } | |
1065 | |
1066 bool | |
1067 audioplayer::isplaying (void) | |
1068 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1069 if (get_stream () == 0) |
19510 | 1070 return false; |
1071 | |
1072 PaError err; | |
1073 err = Pa_IsStreamActive (stream); | |
19515
0f7788e2d677
* audiodevinfo.cc: Use "||" and "&&", not "or" and "and".
John W. Eaton <jwe@octave.org>
parents:
19514
diff
changeset
|
1074 if (err != 0 && err != 1) |
19510 | 1075 { |
1076 error ("audiorecorder: Error checking stream activity status"); | |
1077 return false; | |
1078 } | |
1079 | |
1080 return (err == 1); | |
1081 } | |
1082 | |
1083 class audiorecorder : public octave_base_value | |
1084 { | |
1085 public: | |
1086 audiorecorder (void); | |
1087 ~audiorecorder (void) {}; | |
1088 | |
1089 // Overloaded base functions | |
1090 double player_value (void) const { return 0; } | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
1091 virtual double scalar_value (bool = false) const { return 0; } |
19510 | 1092 void print (std::ostream& os, bool pr_as_read_syntax = false) const; |
1093 void print_raw (std::ostream& os, bool pr_as_read_syntax) const; | |
1094 | |
1095 // Properties | |
1096 bool is_constant (void) const { return true; } | |
1097 bool is_defined (void) const { return true; } | |
1098 bool print_as_scalar (void) const { return true; } | |
1099 | |
1100 void init (void); | |
1101 void set_fs (int fs); | |
1102 int get_fs (void); | |
1103 void set_nbits (int nbits); | |
1104 int get_nbits (void); | |
1105 void set_id (int id); | |
1106 int get_id (void); | |
1107 void set_channels (int channels); | |
1108 int get_channels (void); | |
1109 audio_type get_type (void); | |
1110 | |
1111 void set_sample_number (unsigned int sample); | |
1112 unsigned int get_sample_number (void); | |
1113 unsigned int get_total_samples (void); | |
1114 void set_end_sample (unsigned int sample); | |
1115 unsigned int get_end_sample (void); | |
1116 void reset_end_sample (void); | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1117 void set_tag (const charMatrix& tag); |
19510 | 1118 charMatrix get_tag (void); |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1119 void set_userdata (const octave_value& userdata); |
19510 | 1120 octave_value get_userdata (void); |
1121 PaStream *get_stream (void); | |
1122 | |
1123 octave_value getaudiodata (void); | |
1124 audioplayer *getplayer (void); | |
1125 bool isrecording (void); | |
1126 audioplayer play (void); | |
1127 void record (void); | |
1128 void recordblocking (float seconds); | |
1129 void pause (void); | |
1130 void resume (void); | |
1131 void stop (void); | |
1132 void append (float sample_l, float sample_r); | |
1133 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1134 octave_function *octave_callback_function; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1135 |
19510 | 1136 private: |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1137 int id; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1138 int fs; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1139 int nbits; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1140 int channels; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1141 unsigned int sample_number; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1142 unsigned int end_sample; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1143 charMatrix tag; |
19510 | 1144 Matrix y; |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1145 octave_value userdata; |
19510 | 1146 std::vector<float> left; |
1147 std::vector<float> right; | |
1148 PaStream *stream; | |
1149 PaStreamParameters input_parameters; | |
1150 audio_type type; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1151 |
19510 | 1152 DECLARE_OCTAVE_ALLOCATOR |
1153 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA | |
1154 }; | |
1155 | |
1156 DEFINE_OCTAVE_ALLOCATOR (audiorecorder); | |
1157 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (audiorecorder, "audiorecorder", "audiorecorder"); | |
1158 | |
1159 static int | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
1160 octave_record_callback (const void *input, void *, unsigned long frames, |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
1161 const PaStreamCallbackTimeInfo *, |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
1162 PaStreamCallbackFlags, void *data) |
19510 | 1163 { |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1164 audiorecorder *recorder = static_cast<audiorecorder *> (data); |
19510 | 1165 int channels = recorder->get_channels (); |
1166 float sample_l, sample_r; | |
1167 Matrix sound; | |
1168 sound.resize (frames, 2); | |
1169 if (recorder->get_nbits () == 8) | |
1170 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1171 const int8_t *input8 = static_cast<const int8_t *> (input); |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
1172 for (unsigned long i = 0; i < frames; i++) |
19510 | 1173 { |
1174 sample_l = input8[i * channels] / (pow (2.0, 7) - 1.0); | |
1175 sample_r = input8[i * channels + (channels - 1)] / (pow (2.0, 7) - 1.0); | |
1176 sound(i, 0) = sample_l; | |
1177 sound(i, 1) = sample_r; | |
1178 } | |
1179 } | |
1180 else if (recorder->get_nbits () == 16) | |
1181 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1182 const int16_t *input16 = static_cast<const int16_t *> (input); |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
1183 for (unsigned long i = 0; i < frames; i++) |
19510 | 1184 { |
1185 sample_l = input16[i * channels] / (pow (2.0, 15) - 1.0); | |
1186 sample_r = input16[i * channels + (channels - 1)] / (pow (2.0, 15) - 1.0); | |
1187 sound(i, 0) = sample_l; | |
1188 sound(i, 1) = sample_r; | |
1189 } | |
1190 } | |
1191 else if (recorder->get_nbits () == 24) | |
1192 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1193 // FIXME: Is there a better way? |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1194 const uint8_t *input24 = static_cast<const uint8_t *> (input); |
19510 | 1195 int32_t sample_l32, sample_r32; |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1196 uint8_t *_sample_l = reinterpret_cast<uint8_t *> (&sample_l); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1197 uint8_t *_sample_r = reinterpret_cast<uint8_t *> (&sample_r); |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
1198 for (unsigned long i = 0; i < frames; i++) |
19510 | 1199 { |
1200 for (int j = 0; j < 3; j++) | |
1201 { | |
1202 _sample_l[j] = input24[i * channels * 3 + j]; | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1203 _sample_r[j] = input24[i * channels * 3 + (channels - 1) * 3 + j]; |
19510 | 1204 } |
1205 if (sample_l32 & 0x00800000) | |
1206 sample_l32 |= 0xff000000; | |
1207 if (sample_r32 & 0x00800000) | |
1208 sample_r32 |= 0xff000000; | |
1209 sound(i, 0) = sample_l32 / pow (2.0, 23); | |
1210 sound(i, 1) = sample_r32 / pow (2.0, 23); | |
1211 } | |
1212 } | |
1213 | |
1214 octave_value_list args, retval; | |
1215 args(0) = sound; | |
1216 retval = feval (recorder->octave_callback_function, args, 1); | |
1217 return retval(0).int_value (); | |
1218 } | |
1219 | |
1220 static int | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
1221 portaudio_record_callback (const void *input, void *, unsigned long frames, |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
1222 const PaStreamCallbackTimeInfo *, |
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
1223 PaStreamCallbackFlags, void *data) |
19510 | 1224 { |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1225 audiorecorder *recorder = static_cast<audiorecorder *> (data); |
19510 | 1226 int channels = recorder->get_channels (); |
1227 float sample_l, sample_r; | |
1228 if (recorder->get_nbits () == 8) | |
1229 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1230 const int8_t *input8 = static_cast<const int8_t *> (input); |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
1231 for (unsigned long i = 0; i < frames; i++) |
19510 | 1232 { |
1233 sample_l = input8[i * channels] / (pow (2.0, 7) - 1.0); | |
1234 sample_r = input8[i * channels + (channels - 1)] / (pow (2.0, 7) - 1.0); | |
1235 recorder->append (sample_l, sample_r); | |
1236 } | |
1237 } | |
1238 else if (recorder->get_nbits () == 16) | |
1239 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1240 const int16_t *input16 = static_cast<const int16_t *> (input); |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
1241 for (unsigned long i = 0; i < frames; i++) |
19510 | 1242 { |
1243 sample_l = input16[i * channels] / (pow (2.0, 15) - 1.0); | |
1244 sample_r = input16[i * channels + (channels - 1)] / (pow (2.0, 15) - 1.0); | |
1245 recorder->append (sample_l, sample_r); | |
1246 } | |
1247 } | |
1248 else if (recorder->get_nbits () == 24) | |
1249 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1250 // FIXME: Is there a better way? |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1251 const uint8_t *input24 = static_cast<const uint8_t *> (input); |
19510 | 1252 int32_t sample_l32, sample_r32; |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1253 uint8_t *_sample_l = reinterpret_cast<uint8_t *> (&sample_l); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1254 uint8_t *_sample_r = reinterpret_cast<uint8_t *> (&sample_r); |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
1255 for (unsigned long i = 0; i < frames; i++) |
19510 | 1256 { |
1257 for (int j = 0; j < 3; j++) | |
1258 { | |
1259 _sample_l[j] = input24[i * channels * 3 + j]; | |
1260 _sample_r[j] = input24[i * channels * 3 + (channels - 1) * 3 + j]; | |
1261 } | |
1262 if (sample_l32 & 0x00800000) | |
1263 sample_l32 |= 0xff000000; | |
1264 if (sample_r32 & 0x00800000) | |
1265 sample_r32 |= 0xff000000; | |
1266 recorder->append (sample_l32 / pow (2.0, 23), sample_r32 / pow (2.0, 23)); | |
1267 } | |
1268 } | |
1269 | |
1270 if (recorder->get_sample_number () > recorder->get_end_sample ()) | |
1271 return paComplete; | |
1272 | |
1273 return paContinue; | |
1274 } | |
1275 | |
1276 audiorecorder::audiorecorder (void) | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1277 : octave_callback_function (0), |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1278 id (-1), fs (44100), nbits (16), channels (2), sample_number (0), |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1279 end_sample (-1), tag (""), y (), userdata (Matrix ()), |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1280 left (), right (), stream (0), input_parameters (), type () |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1281 { } |
19510 | 1282 |
1283 void | |
1284 audiorecorder::print (std::ostream& os, bool pr_as_read_syntax) const | |
1285 { | |
1286 print_raw (os, pr_as_read_syntax); | |
1287 newline (os); | |
1288 } | |
1289 | |
1290 void | |
19512
a5eb03a7e2a5
eliminate unused variable and parameter warnings
John W. Eaton <jwe@octave.org>
parents:
19511
diff
changeset
|
1291 audiorecorder::print_raw (std::ostream& os, bool) const |
19510 | 1292 { |
1293 os << 0; | |
1294 } | |
1295 | |
1296 void | |
1297 audiorecorder::init (void) | |
1298 { | |
1299 PaError err; | |
1300 int device; | |
1301 err = Pa_Initialize (); | |
1302 if (err != paNoError) | |
1303 { | |
1304 error ("audiorecorder: Initialization error!"); | |
1305 return; | |
1306 } | |
1307 | |
1308 int numDevices = Pa_GetDeviceCount (); | |
1309 if (numDevices < 0) | |
1310 { | |
1311 error ("audiorecorder: No audio devices found!"); | |
1312 return; | |
1313 } | |
1314 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1315 if (get_id () == -1) |
19510 | 1316 device = Pa_GetDefaultInputDevice (); |
1317 else | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1318 device = get_id (); |
19510 | 1319 |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1320 input_parameters.device = device; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1321 input_parameters.channelCount = get_channels (); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1322 input_parameters.sampleFormat = bits_to_format (get_nbits ()); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1323 input_parameters.suggestedLatency = Pa_GetDeviceInfo (device)->defaultHighInputLatency; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1324 input_parameters.hostApiSpecificStreamInfo = NULL; |
19510 | 1325 } |
1326 | |
1327 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1328 audiorecorder::set_fs (int fs_arg) |
19510 | 1329 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1330 fs = fs_arg; |
19510 | 1331 } |
1332 | |
1333 int | |
1334 audiorecorder::get_fs (void) | |
1335 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1336 return fs; |
19510 | 1337 } |
1338 | |
1339 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1340 audiorecorder::set_nbits (int nbits_arg) |
19510 | 1341 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1342 nbits = nbits_arg; |
19510 | 1343 } |
1344 | |
1345 int | |
1346 audiorecorder::get_nbits (void) | |
1347 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1348 return nbits; |
19510 | 1349 } |
1350 | |
1351 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1352 audiorecorder::set_id (int id_arg) |
19510 | 1353 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1354 id = id_arg; |
19510 | 1355 } |
1356 | |
1357 int | |
1358 audiorecorder::get_id (void) | |
1359 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1360 return id; |
19510 | 1361 } |
1362 | |
1363 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1364 audiorecorder::set_channels (int channels_arg) |
19510 | 1365 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1366 assert (channels_arg == 1 || channels_arg == 2); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1367 channels = channels_arg; |
19510 | 1368 } |
1369 | |
1370 int | |
1371 audiorecorder::get_channels (void) | |
1372 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1373 return channels; |
19510 | 1374 } |
1375 | |
1376 audio_type | |
1377 audiorecorder::get_type (void) | |
1378 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1379 return type; |
19510 | 1380 } |
1381 | |
1382 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1383 audiorecorder::set_sample_number (unsigned int sample_number_arg) |
19510 | 1384 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1385 sample_number = sample_number_arg; |
19510 | 1386 } |
1387 | |
1388 unsigned int | |
1389 audiorecorder::get_sample_number (void) | |
1390 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1391 return sample_number; |
19510 | 1392 } |
1393 | |
1394 unsigned int | |
1395 audiorecorder::get_total_samples (void) | |
1396 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1397 return left.size (); |
19510 | 1398 } |
1399 | |
1400 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1401 audiorecorder::set_end_sample (unsigned int end_sample_arg) |
19510 | 1402 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1403 end_sample = end_sample_arg; |
19510 | 1404 } |
1405 | |
1406 unsigned int | |
1407 audiorecorder::get_end_sample (void) | |
1408 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1409 return end_sample; |
19510 | 1410 } |
1411 | |
1412 void | |
1413 audiorecorder::reset_end_sample (void) | |
1414 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1415 set_end_sample (left.size ()); |
19510 | 1416 } |
1417 | |
1418 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1419 audiorecorder::set_tag (const charMatrix& tag_arg) |
19510 | 1420 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1421 tag = tag_arg; |
19510 | 1422 } |
1423 | |
1424 charMatrix | |
1425 audiorecorder::get_tag (void) | |
1426 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1427 return tag; |
19510 | 1428 } |
1429 | |
1430 void | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1431 audiorecorder::set_userdata (const octave_value& userdata_arg) |
19510 | 1432 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1433 userdata = userdata_arg; |
19510 | 1434 } |
1435 | |
1436 octave_value | |
1437 audiorecorder::get_userdata (void) | |
1438 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1439 return userdata; |
19510 | 1440 } |
1441 | |
1442 octave_value | |
1443 audiorecorder::getaudiodata (void) | |
1444 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1445 Matrix audio (2, left.size ()); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1446 for (unsigned int i = 0; i < left.size (); i++) |
19510 | 1447 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1448 audio(0, i) = left[i]; |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1449 audio(1, i) = right[i]; |
19510 | 1450 } |
1451 return octave_value (audio); | |
1452 } | |
1453 | |
1454 audioplayer * | |
1455 audiorecorder::getplayer (void) | |
1456 { | |
1457 audioplayer *player = new audioplayer (); | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1458 player->set_y (getaudiodata ()); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1459 player->set_fs (get_fs ()); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1460 player->set_nbits (get_nbits ()); |
19510 | 1461 player->init (); |
1462 return player; | |
1463 } | |
1464 | |
1465 bool | |
1466 audiorecorder::isrecording (void) | |
1467 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1468 if (get_stream () == 0) |
19510 | 1469 return false; |
1470 | |
1471 PaError err; | |
1472 err = Pa_IsStreamActive (stream); | |
19515
0f7788e2d677
* audiodevinfo.cc: Use "||" and "&&", not "or" and "and".
John W. Eaton <jwe@octave.org>
parents:
19514
diff
changeset
|
1473 if (err != 0 && err != 1) |
19510 | 1474 { |
1475 error ("audiorecorder: Error checking stream activity status"); | |
1476 return false; | |
1477 } | |
1478 | |
1479 return (err == 1); | |
1480 } | |
1481 | |
1482 void | |
1483 audiorecorder::record (void) | |
1484 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1485 if (get_stream ()) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1486 stop (); |
19510 | 1487 |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1488 left.clear (); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1489 right.clear (); |
19510 | 1490 PaError err; |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1491 if (octave_callback_function != 0) |
19510 | 1492 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1493 err = Pa_OpenStream (&stream, &(input_parameters), NULL, |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1494 get_fs (), BUFFER_SIZE, paClipOff, |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1495 octave_record_callback, this); |
19510 | 1496 } |
1497 else | |
1498 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1499 err = Pa_OpenStream (&stream, &(input_parameters), NULL, |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1500 get_fs (), BUFFER_SIZE, paClipOff, |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1501 portaudio_record_callback, this); |
19510 | 1502 } |
1503 if (err != paNoError) | |
1504 { | |
1505 error ("audiorecorder: Error opening audio recording stream"); | |
1506 return; | |
1507 } | |
1508 err = Pa_StartStream (stream); | |
1509 if (err != paNoError) | |
1510 { | |
1511 error ("audiorecorder: Error starting audio recording stream"); | |
1512 return; | |
1513 } | |
1514 } | |
1515 | |
1516 void | |
1517 audiorecorder::recordblocking (float seconds) | |
1518 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1519 if (get_stream ()) |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1520 stop (); |
19510 | 1521 |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1522 left.clear (); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1523 right.clear (); |
19510 | 1524 |
1525 PaError err; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1526 err = Pa_OpenStream (&stream, &(input_parameters), NULL, |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1527 get_fs (), BUFFER_SIZE, paClipOff, NULL, this); |
19510 | 1528 if (err != paNoError) |
1529 { | |
1530 error ("audiorecorder: Error opening audio recording stream"); | |
1531 return; | |
1532 } | |
1533 | |
1534 err = Pa_StartStream (stream); | |
1535 if (err != paNoError) | |
1536 { | |
1537 error ("audiorecorder: Error starting audio recording stream"); | |
1538 return; | |
1539 } | |
1540 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1541 unsigned int frames = seconds * get_fs (); |
19510 | 1542 uint8_t buffer[BUFFER_SIZE * 2 * 3]; |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
1543 for (unsigned long i = 0; i < frames / BUFFER_SIZE; i++) |
19510 | 1544 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1545 Pa_ReadStream (get_stream (), buffer, BUFFER_SIZE); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1546 if (octave_callback_function != 0) |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1547 octave_record_callback (buffer, NULL, BUFFER_SIZE, 0, 0, this); |
19510 | 1548 else |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1549 portaudio_record_callback (buffer, NULL, BUFFER_SIZE, 0, 0, this); |
19510 | 1550 } |
1551 } | |
1552 | |
1553 void | |
1554 audiorecorder::pause (void) | |
1555 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1556 if (get_stream () == 0) |
19510 | 1557 return; |
1558 | |
1559 PaError err; | |
1560 err = Pa_StopStream (stream); | |
1561 if (err != paNoError) | |
1562 { | |
1563 error ("audiorecorder: Error stoping audio recording stream"); | |
1564 return; | |
1565 } | |
1566 } | |
1567 | |
1568 void | |
1569 audiorecorder::resume (void) | |
1570 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1571 if (get_stream () == 0) |
19510 | 1572 return; |
1573 | |
1574 PaError err; | |
1575 err = Pa_StartStream (stream); | |
1576 if (err != paNoError) | |
1577 { | |
1578 error ("audiorecorder: Error starting audio recording stream"); | |
1579 return; | |
1580 } | |
1581 } | |
1582 | |
1583 void | |
1584 audiorecorder::stop (void) | |
1585 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1586 if (get_stream () == 0) |
19510 | 1587 return; |
1588 | |
1589 PaError err; | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1590 if (not Pa_IsStreamStopped (get_stream ())) |
19510 | 1591 { |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1592 err = Pa_AbortStream (get_stream ()); |
19510 | 1593 if (err != paNoError) |
1594 { | |
1595 error ("audioplayer: Error stopping audio playback stream"); | |
1596 return; | |
1597 } | |
1598 } | |
1599 | |
1600 err = Pa_CloseStream (stream); | |
1601 if (err != paNoError) | |
1602 { | |
1603 error ("audiorecorder: Error closing audio recording stream"); | |
1604 return; | |
1605 } | |
1606 | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1607 set_sample_number (0); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1608 reset_end_sample (); |
19510 | 1609 stream = 0; |
1610 } | |
1611 | |
1612 void | |
1613 audiorecorder::append (float sample_l, float sample_r) | |
1614 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1615 left.push_back (sample_l); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1616 right.push_back (sample_r); |
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1617 set_sample_number (get_sample_number () + 1); |
19510 | 1618 } |
1619 | |
1620 PaStream * | |
1621 audiorecorder::get_stream (void) | |
1622 { | |
19517
22e2f11424b3
avoid more warnings in audio code
John W. Eaton <jwe@octave.org>
parents:
19516
diff
changeset
|
1623 return stream; |
19510 | 1624 } |
1625 | |
1626 DEFUN_DLD (__recorder_audiorecorder__, args, , | |
1627 "-*- texinfo -*-\n\ | |
1628 @deftypefn {Loadable Function} {@var{recorder} =} __recorder_audiorecorder__ (@var{fs}, @var{nbits}, @var{channels})\n\ | |
1629 @deftypefnx {Loadable Function} {@var{recorder} =} __recorder_audiorecorder__ (@var{fs}, @var{nbits}, @var{channels}, @var{id})\n\ | |
1630 @deftypefnx {Loadable Function} {@var{recorder} =} __recorder_audiorecorder__ (@var{fcn}, @dots{})\n\ | |
1631 Undocumented internal function.\n\ | |
1632 @end deftypefn") | |
1633 { | |
1634 #ifdef HAVE_PORTAUDIO | |
1635 int nargin = args.length (); | |
1636 audiorecorder* retval = new audiorecorder (); | |
1637 int offset = 0; | |
1638 if (nargin > 0) | |
1639 { | |
1640 bool is_function = args(0).is_string () || args(0).is_function_handle () || args(0).is_inline_function (); | |
1641 if (is_function) | |
1642 { | |
1643 retval->octave_callback_function = args(0).function_value (); | |
1644 offset = 1; | |
1645 } | |
1646 } | |
1647 switch (nargin - offset) | |
1648 { | |
1649 case 3: | |
1650 retval->set_fs (args(0 + offset).int_value ()); | |
1651 retval->set_nbits (args(1 + offset).int_value ()); | |
1652 retval->set_channels (args(2 + offset).int_value ()); | |
1653 break; | |
1654 case 4: | |
1655 retval->set_fs (args(0 + offset).int_value ()); | |
1656 retval->set_nbits (args(1 + offset).int_value ()); | |
1657 retval->set_channels (args(2 + offset).int_value ()); | |
1658 retval->set_id (args(3 + offset).int_value ()); | |
1659 break; | |
1660 } | |
1661 retval->init (); | |
1662 return octave_value (retval); | |
1663 #else | |
1664 octave_value retval; | |
1665 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1666 return retval; | |
1667 #endif | |
1668 } | |
1669 | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1670 static audiorecorder * |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1671 get_recorder (const octave_value& ov) |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1672 { |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1673 const octave_base_value& rep = ov.get_rep (); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1674 |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1675 octave_base_value *ncrep = const_cast<octave_base_value *> (&rep); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1676 |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1677 return dynamic_cast<audiorecorder *> (ncrep); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1678 } |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1679 |
19510 | 1680 DEFUN_DLD (__recorder_getaudiodata__, args, , |
1681 "-*- texinfo -*-\n\ | |
1682 @deftypefn {Loadable Function} {@var{data}} __recorder_getaudiodata__ (@var{recorder})\n\ | |
1683 Undocumented internal function.\n\ | |
1684 @end deftypefn") | |
1685 { | |
1686 octave_value retval; | |
1687 #ifdef HAVE_PORTAUDIO | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1688 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1689 retval = octave_value (recorder->getaudiodata ()); |
1690 #else | |
1691 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1692 #endif | |
1693 return retval; | |
1694 } | |
1695 | |
1696 DEFUN_DLD (__recorder_get_channels__, args, , | |
1697 "-*- texinfo -*-\n\ | |
1698 @deftypefn {Loadable Function} {@var{n} =} __recorder_get_channels__ (@var{recorder})\n\ | |
1699 Undocumented internal function.\n\ | |
1700 @end deftypefn") | |
1701 { | |
1702 octave_value retval; | |
1703 #ifdef HAVE_PORTAUDIO | |
1704 int nargin = args.length (); | |
1705 if (nargin == 1) | |
1706 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1707 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1708 retval = octave_value (recorder->get_channels ()); |
1709 } | |
1710 #else | |
1711 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1712 #endif | |
1713 return retval; | |
1714 } | |
1715 | |
1716 DEFUN_DLD (__recorder_get_fs__, args, , | |
1717 "-*- texinfo -*-\n\ | |
1718 @deftypefn {Loadable Function} {@var{fs} =} __recorder_get_fs__ (@var{recorder})\n\ | |
1719 Undocumented internal function.\n\ | |
1720 @end deftypefn") | |
1721 { | |
1722 octave_value retval; | |
1723 #ifdef HAVE_PORTAUDIO | |
1724 int nargin = args.length (); | |
1725 if (nargin == 1) | |
1726 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1727 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1728 retval = octave_value (recorder->get_fs ()); |
1729 } | |
1730 #else | |
1731 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1732 #endif | |
1733 return retval; | |
1734 } | |
1735 | |
1736 DEFUN_DLD (__recorder_get_id__, args, , | |
1737 "-*- texinfo -*-\n\ | |
1738 @deftypefn {Loadable Function} {@var{id} =} __recorder_get_id__ (@var{recorder})\n\ | |
1739 Undocumented internal function.\n\ | |
1740 @end deftypefn") | |
1741 { | |
1742 octave_value retval; | |
1743 #ifdef HAVE_PORTAUDIO | |
1744 int nargin = args.length (); | |
1745 if (nargin == 1) | |
1746 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1747 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1748 retval = octave_value (recorder->get_id ()); |
1749 } | |
1750 #else | |
1751 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1752 #endif | |
1753 return retval; | |
1754 } | |
1755 | |
1756 DEFUN_DLD (__recorder_get_nbits__, args, , | |
1757 "-*- texinfo -*-\n\ | |
1758 @deftypefn {Loadable Function} {@var{nbits} =} __recorder_get_nbits__ (@var{recorder})\n\ | |
1759 Undocumented internal function.\n\ | |
1760 @end deftypefn") | |
1761 { | |
1762 octave_value retval; | |
1763 #ifdef HAVE_PORTAUDIO | |
1764 int nargin = args.length (); | |
1765 if (nargin == 1) | |
1766 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1767 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1768 retval = octave_value (recorder->get_nbits ()); |
1769 } | |
1770 #else | |
1771 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1772 #endif | |
1773 return retval; | |
1774 } | |
1775 | |
1776 DEFUN_DLD (__recorder_get_sample_number__, args, , | |
1777 "-*- texinfo -*-\n\ | |
1778 @deftypefn {Loadable Function} {@var{n} =} __recorder_get_sample_number__ (@var{recorder})\n\ | |
1779 Undocumented internal function.\n\ | |
1780 @end deftypefn") | |
1781 { | |
1782 octave_value retval; | |
1783 #ifdef HAVE_PORTAUDIO | |
1784 int nargin = args.length (); | |
1785 if (nargin == 1) | |
1786 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1787 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1788 retval = octave_value (recorder->get_sample_number ()); |
1789 } | |
1790 #else | |
1791 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1792 #endif | |
1793 return retval; | |
1794 } | |
1795 | |
1796 DEFUN_DLD (__recorder_get_tag__, args, , | |
1797 "-*- texinfo -*-\n\ | |
1798 @deftypefn {Loadable Function} {@var{tag} =} __recorder_get_tag__ (@var{recorder})\n\ | |
1799 Undocumented internal function.\n\ | |
1800 @end deftypefn") | |
1801 { | |
1802 octave_value retval; | |
1803 #ifdef HAVE_PORTAUDIO | |
1804 int nargin = args.length (); | |
1805 if (nargin == 1) | |
1806 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1807 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1808 retval = octave_value (recorder->get_tag ()); |
1809 } | |
1810 #else | |
1811 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1812 #endif | |
1813 return retval; | |
1814 } | |
1815 | |
1816 DEFUN_DLD (__recorder_get_total_samples__, args, , | |
1817 "-*- texinfo -*-\n\ | |
1818 @deftypefn {Loadable Function} {@var{n} =} __recorder_get_total_samples__ (@var{recorder})\n\ | |
1819 Undocumented internal function.\n\ | |
1820 @end deftypefn") | |
1821 { | |
1822 octave_value retval; | |
1823 #ifdef HAVE_PORTAUDIO | |
1824 int nargin = args.length (); | |
1825 if (nargin == 1) | |
1826 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1827 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1828 retval = octave_value (recorder->get_total_samples ()); |
1829 } | |
1830 #else | |
1831 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1832 #endif | |
1833 return retval; | |
1834 } | |
1835 | |
1836 DEFUN_DLD (__recorder_get_userdata__, args, , | |
1837 "-*- texinfo -*-\n\ | |
1838 @deftypefn {Loadable Function} {@var{data} =} __recorder_get_userdata__ (@var{recorder})\n\ | |
1839 Undocumented internal function.\n\ | |
1840 @end deftypefn") | |
1841 { | |
1842 octave_value retval; | |
1843 #ifdef HAVE_PORTAUDIO | |
1844 int nargin = args.length (); | |
1845 if (nargin == 1) | |
1846 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1847 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1848 retval = recorder->get_userdata (); |
1849 } | |
1850 #else | |
1851 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1852 #endif | |
1853 return retval; | |
1854 } | |
1855 | |
1856 DEFUN_DLD (__recorder_isrecording__, args, , | |
1857 "-*- texinfo -*-\n\ | |
1858 @deftypefn {Loadable Function} {} __recorder_isrecording__ (@var{recorder})\n\ | |
1859 Undocumented internal function.\n\ | |
1860 @end deftypefn") | |
1861 { | |
1862 octave_value retval; | |
1863 #ifdef HAVE_PORTAUDIO | |
1864 int nargin = args.length (); | |
1865 if (nargin == 1) | |
1866 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1867 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1868 if (recorder->isrecording ()) |
1869 return octave_value (1); | |
1870 else | |
1871 return octave_value (0); | |
1872 } | |
1873 #else | |
1874 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1875 #endif | |
1876 return retval; | |
1877 } | |
1878 | |
1879 DEFUN_DLD (__recorder_pause__, args, , | |
1880 "-*- texinfo -*-\n\ | |
1881 @deftypefn {Loadable Function} {} __recorder_pause__ (@var{recorder})\n\ | |
1882 Undocumented internal function.\n\ | |
1883 @end deftypefn") | |
1884 { | |
1885 octave_value retval; | |
1886 #ifdef HAVE_PORTAUDIO | |
1887 int nargin = args.length (); | |
1888 if (nargin == 1) | |
1889 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1890 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1891 recorder->pause (); |
1892 } | |
1893 #else | |
1894 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1895 #endif | |
1896 return retval; | |
1897 } | |
1898 | |
1899 DEFUN_DLD (__recorder_recordblocking__, args, , | |
1900 "-*- texinfo -*-\n\ | |
1901 @deftypefn {Loadable Function} {} __recorder_recordblocking__ (@var{recorder}, @var{seconds})\n\ | |
1902 Undocumented internal function.\n\ | |
1903 @end deftypefn") | |
1904 { | |
1905 octave_value retval; | |
1906 #ifdef HAVE_PORTAUDIO | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1907 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1908 recorder->recordblocking (args(1).float_value ()); |
1909 #else | |
1910 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1911 #endif | |
1912 return retval; | |
1913 } | |
1914 | |
1915 DEFUN_DLD (__recorder_record__, args, , | |
1916 "-*- texinfo -*-\n\ | |
1917 @deftypefn {Loadable Function} {} __recorder_record__ (@var{recorder})\n\ | |
1918 @deftypefnx {Loadable Function} {} __recorder_record__ (@var{recorder}, @var{seconds})\n\ | |
1919 Undocumented internal function.\n\ | |
1920 @end deftypefn") | |
1921 { | |
1922 octave_value retval; | |
1923 #ifdef HAVE_PORTAUDIO | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1924 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1925 if (args.length () == 1) |
1926 { | |
1927 recorder->record (); | |
1928 } | |
1929 else if (args.length () == 2) | |
1930 { | |
1931 recorder->set_end_sample (args(1).int_value () * recorder->get_fs ()); | |
1932 recorder->record (); | |
1933 } | |
1934 else | |
1935 { | |
1936 error ("audiorecorder: wrong number of arguments passed to record"); | |
1937 } | |
1938 #else | |
1939 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1940 #endif | |
1941 return retval; | |
1942 } | |
1943 | |
1944 DEFUN_DLD (__recorder_resume__, args, , | |
1945 "-*- texinfo -*-\n\ | |
1946 @deftypefn {Loadable Function} {} __recorder_resume__ (@var{recorder})\n\ | |
1947 Undocumented internal function.\n\ | |
1948 @end deftypefn") | |
1949 { | |
1950 octave_value retval; | |
1951 #ifdef HAVE_PORTAUDIO | |
1952 int nargin = args.length (); | |
1953 if (nargin == 1) | |
1954 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1955 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1956 recorder->resume (); |
1957 } | |
1958 #else | |
1959 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1960 #endif | |
1961 return retval; | |
1962 } | |
1963 | |
1964 DEFUN_DLD (__recorder_set_fs__, args, , | |
1965 "-*- texinfo -*-\n\ | |
1966 @deftypefn {Loadable Function} {} __recorder_set_fs__ (@var{recorder}, @var{fs})\n\ | |
1967 Undocumented internal function.\n\ | |
1968 @end deftypefn") | |
1969 { | |
1970 octave_value retval; | |
1971 #ifdef HAVE_PORTAUDIO | |
1972 int nargin = args.length (); | |
1973 if (nargin == 2) | |
1974 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1975 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1976 recorder->set_fs (args(1).int_value ()); |
1977 } | |
1978 #else | |
1979 error ("portaudio not found on your system and thus audio functionality is not present"); | |
1980 #endif | |
1981 return retval; | |
1982 } | |
1983 | |
1984 DEFUN_DLD (__recorder_set_tag__, args, , | |
1985 "-*- texinfo -*-\n\ | |
1986 @deftypefn {Loadable Function} {} __recorder_set_tag__ (@var{recorder}, @var{tag})\n\ | |
1987 Undocumented internal function.\n\ | |
1988 @end deftypefn") | |
1989 { | |
1990 octave_value retval; | |
1991 #ifdef HAVE_PORTAUDIO | |
1992 int nargin = args.length (); | |
1993 if (nargin == 2) | |
1994 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
1995 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 1996 recorder->set_tag (args(1).char_matrix_value ()); |
1997 } | |
1998 #else | |
1999 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2000 #endif | |
2001 return retval; | |
2002 } | |
2003 | |
2004 DEFUN_DLD (__recorder_set_userdata__, args, , | |
2005 "-*- texinfo -*-\n\ | |
2006 @deftypefn {Loadable Function} {} __recorder_set_userdata__ (@var{recorder}, @var{data})\n\ | |
2007 Undocumented internal function.\n\ | |
2008 @end deftypefn") | |
2009 { | |
2010 octave_value retval; | |
2011 #ifdef HAVE_PORTAUDIO | |
2012 int nargin = args.length (); | |
2013 if (nargin == 2) | |
2014 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2015 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 2016 recorder->set_userdata (args(1)); |
2017 } | |
2018 #else | |
2019 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2020 #endif | |
2021 return retval; | |
2022 } | |
2023 | |
2024 DEFUN_DLD (__recorder_stop__, args, , | |
2025 "-*- texinfo -*-\n\ | |
2026 @deftypefn {Loadable Function} {} __recorder_stop__ (@var{recorder})\n\ | |
2027 Undocumented internal function.\n\ | |
2028 @end deftypefn") | |
2029 { | |
2030 octave_value retval; | |
2031 #ifdef HAVE_PORTAUDIO | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2032 audiorecorder *recorder = get_recorder (args(0)); |
19510 | 2033 recorder->stop (); |
2034 #else | |
2035 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2036 #endif | |
2037 return retval; | |
2038 } | |
2039 | |
2040 DEFUN_DLD (__player_audioplayer__, args, , | |
2041 "-*- texinfo -*-\n\ | |
2042 @deftypefn {Loadable Function} {@var{player} =} __player_audioplayer__ (@var{y}, @var{fs})\n\ | |
2043 @deftypefnx {Loadable Function} {@var{player} =} __player_audioplayer__ (@var{y}, @var{fs}, @var{nbits})\n\ | |
2044 @deftypefnx {Loadable Function} {@var{player} =} __player_audioplayer__ (@var{y}, @var{fs}, @var{nbits}, @var{id})\n\ | |
2045 Undocumented internal function.\n\ | |
2046 @end deftypefn") | |
2047 { | |
2048 #ifdef HAVE_PORTAUDIO | |
2049 int nargin = args.length (); | |
2050 audioplayer* retval = new audioplayer (); | |
2051 bool is_function = args(0).is_string () || args(0).is_function_handle () || args(0).is_inline_function (); | |
2052 if (is_function) | |
2053 retval->set_y (args(0).function_value ()); | |
2054 else | |
2055 retval->set_y (args(0)); | |
2056 retval->set_fs (args(1).int_value ()); | |
2057 switch (nargin) | |
2058 { | |
2059 case 3: | |
2060 retval->set_nbits (args(2).int_value ()); | |
2061 break; | |
2062 case 4: | |
2063 retval->set_nbits (args(2).int_value ()); | |
2064 retval->set_id (args(3).int_value ()); | |
2065 break; | |
2066 } | |
2067 if (is_function) | |
2068 retval->init_fn (); | |
2069 else | |
2070 retval->init (); | |
2071 return octave_value (retval); | |
2072 #else | |
2073 octave_value retval; | |
2074 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2075 return retval; | |
2076 #endif | |
2077 } | |
2078 | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2079 static audioplayer * |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2080 get_player (const octave_value& ov) |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2081 { |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2082 const octave_base_value& rep = ov.get_rep (); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2083 |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2084 octave_base_value *ncrep = const_cast<octave_base_value *> (&rep); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2085 |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2086 return dynamic_cast<audioplayer *> (ncrep); |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2087 } |
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2088 |
19510 | 2089 DEFUN_DLD (__player_get_channels__, args, , |
2090 "-*- texinfo -*-\n\ | |
2091 @deftypefn {Loadable Function} {@var{n} =} __player_get_channels__ (@var{player})\n\ | |
2092 Undocumented internal function.\n\ | |
2093 @end deftypefn") | |
2094 { | |
2095 octave_value retval; | |
2096 #ifdef HAVE_PORTAUDIO | |
2097 int nargin = args.length (); | |
2098 if (nargin == 1) | |
2099 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2100 audioplayer *player = get_player (args(0)); |
19510 | 2101 retval = octave_value (player->get_channels ()); |
2102 } | |
2103 #else | |
2104 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2105 #endif | |
2106 return retval; | |
2107 } | |
2108 | |
2109 DEFUN_DLD (__player_get_fs__, args, , | |
2110 "-*- texinfo -*-\n\ | |
2111 @deftypefn {Loadable Function} {@var{fs} =} __player_get_fs__ (@var{player})\n\ | |
2112 Undocumented internal function.\n\ | |
2113 @end deftypefn") | |
2114 { | |
2115 octave_value retval; | |
2116 #ifdef HAVE_PORTAUDIO | |
2117 int nargin = args.length (); | |
2118 if (nargin == 1) | |
2119 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2120 audioplayer *player = get_player (args(0)); |
19510 | 2121 retval = octave_value (player->get_fs ()); |
2122 } | |
2123 #else | |
2124 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2125 #endif | |
2126 return retval; | |
2127 } | |
2128 | |
2129 DEFUN_DLD (__player_get_id__, args, , | |
2130 "-*- texinfo -*-\n\ | |
2131 @deftypefn {Loadable Function} {@var{id} =} __player_get_id__ (@var{player})\n\ | |
2132 Undocumented internal function.\n\ | |
2133 @end deftypefn") | |
2134 { | |
2135 octave_value retval; | |
2136 #ifdef HAVE_PORTAUDIO | |
2137 int nargin = args.length (); | |
2138 if (nargin == 1) | |
2139 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2140 audioplayer *player = get_player (args(0)); |
19510 | 2141 retval = octave_value (player->get_id ()); |
2142 } | |
2143 #else | |
2144 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2145 #endif | |
2146 return retval; | |
2147 } | |
2148 | |
2149 DEFUN_DLD (__player_get_nbits__, args, , | |
2150 "-*- texinfo -*-\n\ | |
2151 @deftypefn {Loadable Function} {@var{nbits} =} __player_get_nbits__ (@var{player})\n\ | |
2152 Undocumented internal function.\n\ | |
2153 @end deftypefn") | |
2154 { | |
2155 octave_value retval; | |
2156 #ifdef HAVE_PORTAUDIO | |
2157 int nargin = args.length (); | |
2158 if (nargin == 1) | |
2159 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2160 audioplayer *player = get_player (args(0)); |
19510 | 2161 retval = octave_value (player->get_nbits ()); |
2162 } | |
2163 #else | |
2164 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2165 #endif | |
2166 return retval; | |
2167 } | |
2168 | |
2169 DEFUN_DLD (__player_get_sample_number__, args, , | |
2170 "-*- texinfo -*-\n\ | |
2171 @deftypefn {Loadable Function} {@var{n} =} __player_get_sample_number__ (@var{player})\n\ | |
2172 Undocumented internal function.\n\ | |
2173 @end deftypefn") | |
2174 { | |
2175 octave_value retval; | |
2176 #ifdef HAVE_PORTAUDIO | |
2177 int nargin = args.length (); | |
2178 if (nargin == 1) | |
2179 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2180 audioplayer *player = get_player (args(0)); |
19510 | 2181 retval = octave_value (player->get_sample_number ()); |
2182 } | |
2183 #else | |
2184 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2185 #endif | |
2186 return retval; | |
2187 } | |
2188 | |
2189 DEFUN_DLD (__player_get_tag__, args, , | |
2190 "-*- texinfo -*-\n\ | |
2191 @deftypefn {Loadable Function} {@var{tag} =} __player_get_tag__ (@var{player})\n\ | |
2192 Undocumented internal function.\n\ | |
2193 @end deftypefn") | |
2194 { | |
2195 octave_value retval; | |
2196 #ifdef HAVE_PORTAUDIO | |
2197 int nargin = args.length (); | |
2198 if (nargin == 1) | |
2199 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2200 audioplayer *player = get_player (args(0)); |
19510 | 2201 retval = octave_value (player->get_tag ()); |
2202 } | |
2203 #else | |
2204 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2205 #endif | |
2206 return retval; | |
2207 } | |
2208 | |
2209 DEFUN_DLD (__player_get_total_samples__, args, , | |
2210 "-*- texinfo -*-\n\ | |
2211 @deftypefn {Loadable Function} {@var{n} =} __player_get_total_samples__ (@var{player})\n\ | |
2212 Undocumented internal function.\n\ | |
2213 @end deftypefn") | |
2214 { | |
2215 octave_value retval; | |
2216 #ifdef HAVE_PORTAUDIO | |
2217 int nargin = args.length (); | |
2218 if (nargin == 1) | |
2219 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2220 audioplayer *player = get_player (args(0)); |
19510 | 2221 retval = octave_value (player->get_total_samples ()); |
2222 } | |
2223 #else | |
2224 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2225 #endif | |
2226 return retval; | |
2227 } | |
2228 | |
2229 DEFUN_DLD (__player_get_userdata__, args, , | |
2230 "-*- texinfo -*-\n\ | |
2231 @deftypefn {Loadable Function} {@var{data} =} __player_get_userdata__ (@var{player})\n\ | |
2232 Undocumented internal function.\n\ | |
2233 @end deftypefn") | |
2234 { | |
2235 octave_value retval; | |
2236 #ifdef HAVE_PORTAUDIO | |
2237 int nargin = args.length (); | |
2238 if (nargin == 1) | |
2239 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2240 audioplayer *player = get_player (args(0)); |
19510 | 2241 retval = player->get_userdata (); |
2242 } | |
2243 #else | |
2244 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2245 #endif | |
2246 return retval; | |
2247 } | |
2248 | |
2249 DEFUN_DLD (__player_isplaying__, args, , | |
2250 "-*- texinfo -*-\n\ | |
2251 @deftypefn {Loadable Function} {} __player_isplaying__ (@var{player})\n\ | |
2252 Undocumented internal function.\n\ | |
2253 @end deftypefn") | |
2254 { | |
2255 octave_value retval; | |
2256 #ifdef HAVE_PORTAUDIO | |
2257 int nargin = args.length (); | |
2258 if (nargin == 1) | |
2259 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2260 audioplayer *player = get_player (args(0)); |
19510 | 2261 if (player->isplaying ()) |
2262 return octave_value (1); | |
2263 else | |
2264 return octave_value (0); | |
2265 } | |
2266 #else | |
2267 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2268 #endif | |
2269 return retval; | |
2270 } | |
2271 | |
2272 DEFUN_DLD (__player_pause__, args, , | |
2273 "-*- texinfo -*-\n\ | |
2274 @deftypefn {Loadable Function} {} __player_pause__ (@var{player})\n\ | |
2275 Undocumented internal function.\n\ | |
2276 @end deftypefn") | |
2277 { | |
2278 octave_value retval; | |
2279 #ifdef HAVE_PORTAUDIO | |
2280 int nargin = args.length (); | |
2281 if (nargin == 1) | |
2282 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2283 audioplayer *player = get_player (args(0)); |
19510 | 2284 player->pause (); |
2285 } | |
2286 #else | |
2287 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2288 #endif | |
2289 return retval; | |
2290 } | |
2291 | |
2292 DEFUN_DLD (__player_playblocking__, args, , | |
2293 "-*- texinfo -*-\n\ | |
2294 @deftypefn {Loadable Function} {} __player_playblocking__ (@var{player})\n\ | |
2295 @deftypefnx {Loadable Function} {} __player_playblocking__ (@var{player}, @var{start})\n\ | |
2296 @deftypefnx {Loadable Function} {} __player_playblocking__ (@var{player}, [@var{start}, @var{end}])\n\ | |
2297 Undocumented internal function.\n\ | |
2298 @end deftypefn") | |
2299 { | |
2300 octave_value retval; | |
2301 #ifdef HAVE_PORTAUDIO | |
2302 int nargin = args.length (); | |
2303 if (nargin == 1) | |
2304 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2305 audioplayer *player = get_player (args(0)); |
19510 | 2306 player->playblocking (); |
2307 } | |
2308 else | |
2309 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2310 audioplayer *player = get_player (args(0)); |
19510 | 2311 if (args(1).is_matrix_type ()) |
2312 { | |
2313 unsigned int start, end; | |
2314 RowVector range = args(1).row_vector_value (); | |
2315 start = range.elem (0) - 1; | |
2316 end = range.elem (1) - 1; | |
19515
0f7788e2d677
* audiodevinfo.cc: Use "||" and "&&", not "or" and "and".
John W. Eaton <jwe@octave.org>
parents:
19514
diff
changeset
|
2317 if (start > player->get_total_samples () |
0f7788e2d677
* audiodevinfo.cc: Use "||" and "&&", not "or" and "and".
John W. Eaton <jwe@octave.org>
parents:
19514
diff
changeset
|
2318 || start > end || end > player->get_total_samples ()) |
19510 | 2319 error ("audioplayer: invalid range specified for playback"); |
2320 player->set_sample_number (start); | |
2321 player->set_end_sample (end); | |
2322 } | |
2323 else | |
2324 { | |
2325 unsigned int start; | |
2326 start = args(1).int_value () - 1; | |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
2327 if (start > player->get_total_samples ()) |
19510 | 2328 error ("audioplayer: invalid range specified for playback"); |
2329 player->set_sample_number (start); | |
2330 } | |
2331 player->playblocking (); | |
2332 } | |
2333 #else | |
2334 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2335 #endif | |
2336 return retval; | |
2337 } | |
2338 | |
2339 DEFUN_DLD (__player_play__, args, , | |
2340 "-*- texinfo -*-\n\ | |
2341 @deftypefn {Loadable Function} {} __player_play__ (@var{player})\n\ | |
2342 @deftypefnx {Loadable Function} {} __player_play__ (@var{player}, @var{start})\n\ | |
2343 @deftypefnx {Loadable Function} {} __player_play__ (@var{player}, [@var{start}, @var{end}])\n\ | |
2344 Undocumented internal function.\n\ | |
2345 @end deftypefn") | |
2346 { | |
2347 octave_value retval; | |
2348 #ifdef HAVE_PORTAUDIO | |
2349 int nargin = args.length (); | |
2350 if (nargin == 1) | |
2351 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2352 audioplayer *player = get_player (args(0)); |
19510 | 2353 player->play (); |
2354 } | |
2355 else | |
2356 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2357 audioplayer *player = get_player (args(0)); |
19510 | 2358 if (args(1).is_matrix_type ()) |
2359 { | |
2360 unsigned int start, end; | |
2361 RowVector range = args(1).row_vector_value (); | |
2362 start = range.elem (0) - 1; | |
2363 end = range.elem (1) - 1; | |
19515
0f7788e2d677
* audiodevinfo.cc: Use "||" and "&&", not "or" and "and".
John W. Eaton <jwe@octave.org>
parents:
19514
diff
changeset
|
2364 if (start > player->get_total_samples () |
0f7788e2d677
* audiodevinfo.cc: Use "||" and "&&", not "or" and "and".
John W. Eaton <jwe@octave.org>
parents:
19514
diff
changeset
|
2365 || start > end || end > player->get_total_samples ()) |
19510 | 2366 error ("audioplayer: invalid range specified for playback"); |
2367 player->set_sample_number (start); | |
2368 player->set_end_sample (end); | |
2369 } | |
2370 else | |
2371 { | |
2372 unsigned int start; | |
2373 start = args(1).int_value () - 1; | |
19514
ef6875adb053
* audiodevinfo.cc: Avoid warnings about comparision operations.
John W. Eaton <jwe@octave.org>
parents:
19513
diff
changeset
|
2374 if (start > player->get_total_samples ()) |
19510 | 2375 error ("audioplayer: invalid range specified for playback"); |
2376 player->set_sample_number (start); | |
2377 } | |
2378 player->play (); | |
2379 } | |
2380 #else | |
2381 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2382 #endif | |
2383 return retval; | |
2384 } | |
2385 | |
2386 DEFUN_DLD (__player_resume__, args, , | |
2387 "-*- texinfo -*-\n\ | |
2388 @deftypefn {Loadable Function} {} __player_resume__ (@var{player})\n\ | |
2389 Undocumented internal function.\n\ | |
2390 @end deftypefn") | |
2391 { | |
2392 octave_value retval; | |
2393 #ifdef HAVE_PORTAUDIO | |
2394 int nargin = args.length (); | |
2395 if (nargin == 1) | |
2396 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2397 audioplayer *player = get_player (args(0)); |
19510 | 2398 player->resume (); |
2399 } | |
2400 #else | |
2401 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2402 #endif | |
2403 return retval; | |
2404 } | |
2405 | |
2406 DEFUN_DLD (__player_set_fs__, args, , | |
2407 "-*- texinfo -*-\n\ | |
2408 @deftypefn {Loadable Function} {} __player_set_fs__ (@var{player}, @var{fs})\n\ | |
2409 Undocumented internal function.\n\ | |
2410 @end deftypefn") | |
2411 { | |
2412 octave_value retval; | |
2413 #ifdef HAVE_PORTAUDIO | |
2414 int nargin = args.length (); | |
2415 if (nargin == 2) | |
2416 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2417 audioplayer *player = get_player (args(0)); |
19510 | 2418 player->set_fs (args(1).int_value ()); |
2419 } | |
2420 #else | |
2421 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2422 #endif | |
2423 return retval; | |
2424 } | |
2425 | |
2426 DEFUN_DLD (__player_set_tag__, args, , | |
2427 "-*- texinfo -*-\n\ | |
2428 @deftypefn {Loadable Function} {} __player_set_tag__ (@var{player}, @var{tag})\n\ | |
2429 Undocumented internal function.\n\ | |
2430 @end deftypefn") | |
2431 { | |
2432 octave_value retval; | |
2433 #ifdef HAVE_PORTAUDIO | |
2434 int nargin = args.length (); | |
2435 if (nargin == 2) | |
2436 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2437 audioplayer *player = get_player (args(0)); |
19510 | 2438 player->set_tag (args(1).char_matrix_value ()); |
2439 } | |
2440 #else | |
2441 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2442 #endif | |
2443 return retval; | |
2444 } | |
2445 | |
2446 DEFUN_DLD (__player_set_userdata__, args, , | |
2447 "-*- texinfo -*-\n\ | |
2448 @deftypefn {Loadable Function} {} __player_set_userdata__ (@var{player}, @var{data})\n\ | |
2449 Undocumented internal function.\n\ | |
2450 @end deftypefn") | |
2451 { | |
2452 octave_value retval; | |
2453 #ifdef HAVE_PORTAUDIO | |
2454 int nargin = args.length (); | |
2455 if (nargin == 2) | |
2456 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2457 audioplayer *player = get_player (args(0)); |
19510 | 2458 player->set_userdata (args(1)); |
2459 } | |
2460 #else | |
2461 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2462 #endif | |
2463 return retval; | |
2464 } | |
2465 | |
2466 DEFUN_DLD (__player_stop__, args, , | |
2467 "-*- texinfo -*-\n\ | |
2468 @deftypefn {Loadable Function} {} __player_stop__ (@var{player})\n\ | |
2469 Undocumented internal function.\n\ | |
2470 @end deftypefn") | |
2471 { | |
2472 octave_value retval; | |
2473 #ifdef HAVE_PORTAUDIO | |
2474 int nargin = args.length (); | |
2475 if (nargin == 1) | |
2476 { | |
19513
4cb4210bd392
use C++ style casts in audio code
John W. Eaton <jwe@octave.org>
parents:
19512
diff
changeset
|
2477 audioplayer *player = get_player (args (0)); |
19510 | 2478 player->stop (); |
2479 } | |
2480 #else | |
2481 error ("portaudio not found on your system and thus audio functionality is not present"); | |
2482 #endif | |
2483 return retval; | |
2484 } |