1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/*
Copyright (C) 2001 Paul Davis
Copyright (C) 2004 Grame
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __JackAlsaDriver__
#define __JackAlsaDriver__
#include "JackAudioDriver.h"
#include "JackThreadedDriver.h"
#include "JackTime.h"
#include "alsa_driver.h"
namespace Jack
{
/*!
\brief The ALSA driver.
*/
class JackAlsaDriver : public JackAudioDriver
{
private:
jack_driver_t* fDriver;
jack_time_t fDelayedUst;
void alsa_driver_release_channel_dependent_memory (alsa_driver_t *driver);
int alsa_driver_check_capabilities (alsa_driver_t *driver);
int alsa_driver_check_card_type (alsa_driver_t *driver);
int alsa_driver_hammerfall_hardware (alsa_driver_t *driver);
int alsa_driver_hdsp_hardware (alsa_driver_t *driver);
int alsa_driver_ice1712_hardware (alsa_driver_t *driver);
int alsa_driver_usx2y_hardware (alsa_driver_t *driver);
int alsa_driver_generic_hardware (alsa_driver_t *driver);
int alsa_driver_hw_specific (alsa_driver_t *driver, int hw_monitoring,
int hw_metering);
void alsa_driver_setup_io_function_pointers (alsa_driver_t *driver);
int alsa_driver_configure_stream (alsa_driver_t *driver, char *device_name,
const char *stream_name,
snd_pcm_t *handle,
snd_pcm_hw_params_t *hw_params,
snd_pcm_sw_params_t *sw_params,
unsigned int *nperiodsp,
unsigned long *nchns,
unsigned long sample_width);
int alsa_driver_set_parameters (alsa_driver_t *driver,
jack_nframes_t frames_per_cycle,
jack_nframes_t user_nperiods,
jack_nframes_t rate);
int alsa_driver_reset_parameters (alsa_driver_t *driver,
jack_nframes_t frames_per_cycle,
jack_nframes_t user_nperiods,
jack_nframes_t rate);
int alsa_driver_get_channel_addresses (alsa_driver_t *driver,
snd_pcm_uframes_t *capture_avail,
snd_pcm_uframes_t *playback_avail,
snd_pcm_uframes_t *capture_offset,
snd_pcm_uframes_t *playback_offset);
jack_driver_t * alsa_driver_new(const char *name, char *playback_alsa_device,
char *capture_alsa_device,
jack_client_t *client,
jack_nframes_t frames_per_cycle,
jack_nframes_t user_nperiods,
jack_nframes_t rate,
int hw_monitoring,
int hw_metering,
int capturing,
int playing,
DitherAlgorithm dither,
int soft_mode,
int monitor,
int user_capture_nchnls,
int user_playback_nchnls,
int shorts_first,
jack_nframes_t capture_latency,
jack_nframes_t playback_latency,
alsa_midi_t *midi
);
void alsa_driver_delete(alsa_driver_t *driver);
int alsa_driver_start(alsa_driver_t *driver);
int alsa_driver_stop(alsa_driver_t *driver);
int alsa_driver_read(alsa_driver_t *driver, jack_nframes_t nframes);
int alsa_driver_write(alsa_driver_t *driver, jack_nframes_t nframes);
jack_nframes_t alsa_driver_wait (alsa_driver_t *driver, int extra_fd, int *status, float
*delayed_usecs);
void alsa_driver_silence_untouched_channels (alsa_driver_t *driver,
jack_nframes_t nframes);
int alsa_driver_restart (alsa_driver_t *driver);
int alsa_driver_xrun_recovery (alsa_driver_t *driver, float *delayed_usecs);
void jack_driver_init (jack_driver_t *driver);
void jack_driver_nt_init (jack_driver_nt_t * driver);
public:
JackAlsaDriver(const char* name, JackEngine* engine, JackSynchro** table): JackAudioDriver(name, engine, table)
{}
virtual ~JackAlsaDriver()
{}
int Open(jack_nframes_t nframes,
jack_nframes_t user_nperiods,
jack_nframes_t samplerate,
bool hw_monitoring,
bool hw_metering,
bool capturing,
bool playing,
DitherAlgorithm dither,
bool soft_mode,
bool monitor,
int inchannels,
int outchannels,
bool shorts_first,
const char* capture_driver_name,
const char* playback_driver_name,
jack_nframes_t capture_latency,
jack_nframes_t playback_latency,
const char* midi_driver_name);
int Close();
int Attach();
int Detach();
int Start();
int Stop();
int Read();
int Write();
int SetBufferSize(jack_nframes_t nframes);
// jack api emulation for the midi driver
int is_realtime() const;
int create_thread(pthread_t *thread, int prio, int rt, void *(*start_func)(void*), void *arg);
int port_register(const char *port_name, const char *port_type, unsigned long flags, unsigned long buf_size);
int port_unregister(int port);
void* port_get_buffer(int port, jack_nframes_t nframes);
int port_set_alias(int port, const char* name);
jack_nframes_t get_sample_rate() const;
jack_nframes_t frame_time() const;
jack_nframes_t last_frame_time() const;
};
} // end of namespace
#endif
|
