Mercurial > mplayer.hg
annotate libao2/ao_alsa.c @ 24900:9079c9745ff9
A/V sync: take audio filter buffers into account
Substract the delay caused by filter buffering when calculating
currently playing audio position. This matters for af_scaletempo which
buffers significant and varying amounts of data. For other current
filters the effect is normally insignificant.
Instead of the old time-based filter delay field (which was ignored)
this version stores the per-filter delay in units of bytes input read
without corresponding output. This allows the current scaletempo
behavior where other filters before and after it can see the same
nominal samplerate even though the real duration of the data varies;
in this case the other filters can not know the delay they're causing
in terms of real time.
author | uau |
---|---|
date | Thu, 01 Nov 2007 06:52:50 +0000 |
parents | 2c238fa777ff |
children | 0fdf04b07ecb |
rev | line source |
---|---|
12465 | 1 /* |
2 ao_alsa9/1.x - ALSA-0.9.x-1.x output plugin for MPlayer | |
3 | |
4 (C) Alex Beregszaszi | |
5 | |
6 modified for real alsa-0.9.0-support by Zsolt Barat <joy@streamminister.de> | |
7 additional AC3 passthrough support by Andy Lo A Foe <andy@alsaplayer.org> | |
8 08/22/2002 iec958-init rewritten and merged with common init, zsolt | |
9 04/13/2004 merged with ao_alsa1.x, fixes provided by Jindrich Makovicka | |
10 04/25/2004 printfs converted to mp_msg, Zsolt. | |
11 | |
12 Any bugreports regarding to this driver are welcome. | |
13 */ | |
14 | |
15 #include <errno.h> | |
16 #include <sys/time.h> | |
17 #include <stdlib.h> | |
17691
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
18 #include <stdarg.h> |
22166
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
19 #include <ctype.h> |
12465 | 20 #include <math.h> |
21 #include <string.h> | |
22 | |
14123 | 23 #include "config.h" |
14328 | 24 #include "subopt-helper.h" |
14123 | 25 #include "mixer.h" |
26 #include "mp_msg.h" | |
20764 | 27 #include "help_mp.h" |
12465 | 28 |
29 #define ALSA_PCM_NEW_HW_PARAMS_API | |
30 #define ALSA_PCM_NEW_SW_PARAMS_API | |
31 | |
32 #if HAVE_SYS_ASOUNDLIB_H | |
33 #include <sys/asoundlib.h> | |
34 #elif HAVE_ALSA_ASOUNDLIB_H | |
35 #include <alsa/asoundlib.h> | |
36 #else | |
37 #error "asoundlib.h is not in sys/ or alsa/ - please bugreport" | |
38 #endif | |
39 | |
40 | |
41 #include "audio_out.h" | |
42 #include "audio_out_internal.h" | |
14245 | 43 #include "libaf/af_format.h" |
12465 | 44 |
45 static ao_info_t info = | |
46 { | |
47 "ALSA-0.9.x-1.x audio output", | |
48 "alsa", | |
49 "Alex Beregszaszi, Zsolt Barat <joy@streamminister.de>", | |
50 "under developement" | |
51 }; | |
52 | |
53 LIBAO_EXTERN(alsa) | |
54 | |
55 static snd_pcm_t *alsa_handler; | |
56 static snd_pcm_format_t alsa_format; | |
57 static snd_pcm_hw_params_t *alsa_hwparams; | |
58 static snd_pcm_sw_params_t *alsa_swparams; | |
59 | |
60 /* 16 sets buffersize to 16 * chunksize is as default 1024 | |
61 * which seems to be good avarge for most situations | |
62 * so buffersize is 16384 frames by default */ | |
63 static int alsa_fragcount = 16; | |
17575
9972b744fd98
Small fixes: make all global variables static, remove some unused
cladisch
parents:
17574
diff
changeset
|
64 static snd_pcm_uframes_t chunk_size = 1024; |
12465 | 65 |
17619
9b619133f11a
Using non-blocking writes makes sense when the program wants to do other
cladisch
parents:
17618
diff
changeset
|
66 static size_t bytes_per_sample; |
12465 | 67 |
17575
9972b744fd98
Small fixes: make all global variables static, remove some unused
cladisch
parents:
17574
diff
changeset
|
68 static int ao_noblock = 0; |
12465 | 69 |
70 static int open_mode; | |
71 static int alsa_can_pause = 0; | |
72 | |
12747 | 73 #define ALSA_DEVICE_SIZE 256 |
12465 | 74 |
75 #undef BUFFERTIME | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
76 #define SET_CHUNKSIZE |
12465 | 77 |
17691
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
78 static void alsa_error_handler(const char *file, int line, const char *function, |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
79 int err, const char *format, ...) |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
80 { |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
81 char tmp[0xc00]; |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
82 va_list va; |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
83 |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
84 va_start(va, format); |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
85 vsnprintf(tmp, sizeof tmp, format, va); |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
86 va_end(va); |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
87 tmp[sizeof tmp - 1] = '\0'; |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
88 |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
89 if (err) |
20764 | 90 mp_msg(MSGT_AO, MSGL_ERR, "[AO_ALSA] alsa-lib: %s:%i:(%s) %s: %s\n", |
17691
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
91 file, line, function, tmp, snd_strerror(err)); |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
92 else |
20764 | 93 mp_msg(MSGT_AO, MSGL_ERR, "[AO_ALSA] alsa-lib: %s:%i:(%s) %s\n", |
17691
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
94 file, line, function, tmp); |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
95 } |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
96 |
12465 | 97 /* to set/get/query special features/parameters */ |
98 static int control(int cmd, void *arg) | |
99 { | |
100 switch(cmd) { | |
101 case AOCONTROL_QUERY_FORMAT: | |
102 return CONTROL_TRUE; | |
103 case AOCONTROL_GET_VOLUME: | |
104 case AOCONTROL_SET_VOLUME: | |
105 { | |
106 ao_control_vol_t *vol = (ao_control_vol_t *)arg; | |
107 | |
108 int err; | |
109 snd_mixer_t *handle; | |
110 snd_mixer_elem_t *elem; | |
111 snd_mixer_selem_id_t *sid; | |
112 | |
12747 | 113 static char *mix_name = "PCM"; |
114 static char *card = "default"; | |
13434 | 115 static int mix_index = 0; |
12465 | 116 |
117 long pmin, pmax; | |
118 long get_vol, set_vol; | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
119 float f_multi; |
12465 | 120 |
13434 | 121 if(mixer_channel) { |
122 char *test_mix_index; | |
123 | |
124 mix_name = strdup(mixer_channel); | |
17097 | 125 if ((test_mix_index = strchr(mix_name, ','))){ |
13434 | 126 *test_mix_index = 0; |
127 test_mix_index++; | |
128 mix_index = strtol(test_mix_index, &test_mix_index, 0); | |
129 | |
130 if (*test_mix_index){ | |
131 mp_msg(MSGT_AO,MSGL_ERR, | |
20764 | 132 MSGTR_AO_ALSA_InvalidMixerIndexDefaultingToZero); |
13434 | 133 mix_index = 0 ; |
134 } | |
135 } | |
136 } | |
12747 | 137 if(mixer_device) card = mixer_device; |
12465 | 138 |
14245 | 139 if(ao_data.format == AF_FORMAT_AC3) |
12465 | 140 return CONTROL_TRUE; |
141 | |
142 //allocate simple id | |
143 snd_mixer_selem_id_alloca(&sid); | |
144 | |
145 //sets simple-mixer index and name | |
13434 | 146 snd_mixer_selem_id_set_index(sid, mix_index); |
12465 | 147 snd_mixer_selem_id_set_name(sid, mix_name); |
148 | |
13434 | 149 if (mixer_channel) { |
150 free(mix_name); | |
151 mix_name = NULL; | |
152 } | |
153 | |
12465 | 154 if ((err = snd_mixer_open(&handle, 0)) < 0) { |
20764 | 155 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_MixerOpenError, snd_strerror(err)); |
12465 | 156 return CONTROL_ERROR; |
157 } | |
158 | |
159 if ((err = snd_mixer_attach(handle, card)) < 0) { | |
20764 | 160 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_MixerAttachError, |
12465 | 161 card, snd_strerror(err)); |
162 snd_mixer_close(handle); | |
163 return CONTROL_ERROR; | |
164 } | |
165 | |
166 if ((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0) { | |
20764 | 167 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_MixerRegisterError, snd_strerror(err)); |
12465 | 168 snd_mixer_close(handle); |
169 return CONTROL_ERROR; | |
170 } | |
171 err = snd_mixer_load(handle); | |
172 if (err < 0) { | |
20764 | 173 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_MixerLoadError, snd_strerror(err)); |
12465 | 174 snd_mixer_close(handle); |
175 return CONTROL_ERROR; | |
176 } | |
177 | |
178 elem = snd_mixer_find_selem(handle, sid); | |
179 if (!elem) { | |
20764 | 180 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToFindSimpleControl, |
12465 | 181 snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid)); |
182 snd_mixer_close(handle); | |
183 return CONTROL_ERROR; | |
184 } | |
185 | |
186 snd_mixer_selem_get_playback_volume_range(elem,&pmin,&pmax); | |
12811
d5f8efddac6c
volume calc fixes for mixer, by reimar dffinger, 10l reverse by me
joyping
parents:
12805
diff
changeset
|
187 f_multi = (100 / (float)(pmax - pmin)); |
12465 | 188 |
189 if (cmd == AOCONTROL_SET_VOLUME) { | |
190 | |
12811
d5f8efddac6c
volume calc fixes for mixer, by reimar dffinger, 10l reverse by me
joyping
parents:
12805
diff
changeset
|
191 set_vol = vol->left / f_multi + pmin + 0.5; |
12465 | 192 |
193 //setting channels | |
194 if ((err = snd_mixer_selem_set_playback_volume(elem, 0, set_vol)) < 0) { | |
20764 | 195 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ErrorSettingLeftChannel, |
12465 | 196 snd_strerror(err)); |
197 return CONTROL_ERROR; | |
198 } | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
199 mp_msg(MSGT_AO,MSGL_DBG2,"left=%li, ", set_vol); |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
200 |
12811
d5f8efddac6c
volume calc fixes for mixer, by reimar dffinger, 10l reverse by me
joyping
parents:
12805
diff
changeset
|
201 set_vol = vol->right / f_multi + pmin + 0.5; |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
202 |
12465 | 203 if ((err = snd_mixer_selem_set_playback_volume(elem, 1, set_vol)) < 0) { |
20764 | 204 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ErrorSettingRightChannel, |
12465 | 205 snd_strerror(err)); |
206 return CONTROL_ERROR; | |
207 } | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
208 mp_msg(MSGT_AO,MSGL_DBG2,"right=%li, pmin=%li, pmax=%li, mult=%f\n", |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
209 set_vol, pmin, pmax, f_multi); |
17194
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
210 |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
211 if (snd_mixer_selem_has_playback_switch(elem)) { |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
212 int lmute = (vol->left == 0.0); |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
213 int rmute = (vol->right == 0.0); |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
214 if (snd_mixer_selem_has_playback_switch_joined(elem)) { |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
215 lmute = rmute = lmute && rmute; |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
216 } else { |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
217 snd_mixer_selem_set_playback_switch(elem, SND_MIXER_SCHN_FRONT_RIGHT, !rmute); |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
218 } |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
219 snd_mixer_selem_set_playback_switch(elem, SND_MIXER_SCHN_FRONT_LEFT, !lmute); |
cd527e59d128
use snd_mixer_selem_set_playback_switch when muting ALSA, patch by Matthias Lederhofer <matled -at- gmx dot net>
wanderer
parents:
17097
diff
changeset
|
220 } |
12465 | 221 } |
222 else { | |
223 snd_mixer_selem_get_playback_volume(elem, 0, &get_vol); | |
12811
d5f8efddac6c
volume calc fixes for mixer, by reimar dffinger, 10l reverse by me
joyping
parents:
12805
diff
changeset
|
224 vol->left = (get_vol - pmin) * f_multi; |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
225 snd_mixer_selem_get_playback_volume(elem, 1, &get_vol); |
12811
d5f8efddac6c
volume calc fixes for mixer, by reimar dffinger, 10l reverse by me
joyping
parents:
12805
diff
changeset
|
226 vol->right = (get_vol - pmin) * f_multi; |
12465 | 227 |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
228 mp_msg(MSGT_AO,MSGL_DBG2,"left=%f, right=%f\n",vol->left,vol->right); |
12465 | 229 } |
230 snd_mixer_close(handle); | |
231 return CONTROL_OK; | |
232 } | |
233 | |
234 } //end switch | |
235 return(CONTROL_UNKNOWN); | |
236 } | |
237 | |
14328 | 238 static void parse_device (char *dest, const char *src, int len) |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
239 { |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
240 char *tmp; |
14328 | 241 memmove(dest, src, len); |
242 dest[len] = 0; | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
243 while ((tmp = strrchr(dest, '.'))) |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
244 tmp[0] = ','; |
12919
aba44b58dea7
Use = instead if # in ALSA device name, as # irritates our config-parser.
reimar
parents:
12819
diff
changeset
|
245 while ((tmp = strrchr(dest, '='))) |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
246 tmp[0] = ':'; |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
247 } |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
248 |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
249 static void print_help (void) |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
250 { |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
251 mp_msg (MSGT_AO, MSGL_FATAL, |
20764 | 252 MSGTR_AO_ALSA_CommandlineHelp); |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
253 } |
12465 | 254 |
14328 | 255 static int str_maxlen(strarg_t *str) { |
256 if (str->len > ALSA_DEVICE_SIZE) | |
257 return 0; | |
258 return 1; | |
259 } | |
260 | |
22166
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
261 static int try_open_device(const char *device, int open_mode, int try_ac3) |
19889
d4bb39d65f87
When the hardware sample format is AC3, do not force using an hardcoded
cladisch
parents:
19887
diff
changeset
|
262 { |
22166
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
263 int err, len; |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
264 char *ac3_device, *args; |
19889
d4bb39d65f87
When the hardware sample format is AC3, do not force using an hardcoded
cladisch
parents:
19887
diff
changeset
|
265 |
22166
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
266 if (try_ac3) { |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
267 /* to set the non-audio bit, use AES0=6 */ |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
268 len = strlen(device); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
269 ac3_device = malloc(len + 7 + 1); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
270 if (!ac3_device) |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
271 return -ENOMEM; |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
272 strcpy(ac3_device, device); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
273 args = strchr(ac3_device, ':'); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
274 if (!args) { |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
275 /* no existing parameters: add it behind device name */ |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
276 strcat(ac3_device, ":AES0=6"); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
277 } else { |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
278 do |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
279 ++args; |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
280 while (isspace(*args)); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
281 if (*args == '\0') { |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
282 /* ":" but no parameters */ |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
283 strcat(ac3_device, "AES0=6"); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
284 } else if (*args != '{') { |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
285 /* a simple list of parameters: add it at the end of the list */ |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
286 strcat(ac3_device, ",AES0=6"); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
287 } else { |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
288 /* parameters in config syntax: add it inside the { } block */ |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
289 do |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
290 --len; |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
291 while (len > 0 && isspace(ac3_device[len])); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
292 if (ac3_device[len] == '}') |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
293 strcpy(ac3_device + len, " AES0=6}"); |
19889
d4bb39d65f87
When the hardware sample format is AC3, do not force using an hardcoded
cladisch
parents:
19887
diff
changeset
|
294 } |
d4bb39d65f87
When the hardware sample format is AC3, do not force using an hardcoded
cladisch
parents:
19887
diff
changeset
|
295 } |
22166
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
296 err = snd_pcm_open(&alsa_handler, ac3_device, SND_PCM_STREAM_PLAYBACK, |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
297 open_mode); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
298 free(ac3_device); |
19889
d4bb39d65f87
When the hardware sample format is AC3, do not force using an hardcoded
cladisch
parents:
19887
diff
changeset
|
299 } |
22166
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
300 if (!try_ac3 || err < 0) |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
301 err = snd_pcm_open(&alsa_handler, device, SND_PCM_STREAM_PLAYBACK, |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
302 open_mode); |
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
303 return err; |
19889
d4bb39d65f87
When the hardware sample format is AC3, do not force using an hardcoded
cladisch
parents:
19887
diff
changeset
|
304 } |
d4bb39d65f87
When the hardware sample format is AC3, do not force using an hardcoded
cladisch
parents:
19887
diff
changeset
|
305 |
12465 | 306 /* |
307 open & setup audio device | |
308 return: 1=success 0=fail | |
309 */ | |
310 static int init(int rate_hz, int channels, int format, int flags) | |
311 { | |
312 int err; | |
14328 | 313 int block; |
314 strarg_t device; | |
12465 | 315 snd_pcm_uframes_t bufsize; |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
316 snd_pcm_uframes_t boundary; |
14328 | 317 opt_t subopts[] = { |
318 {"block", OPT_ARG_BOOL, &block, NULL}, | |
319 {"device", OPT_ARG_STR, &device, (opt_test_f)str_maxlen}, | |
320 {NULL} | |
321 }; | |
322 | |
12747 | 323 char alsa_device[ALSA_DEVICE_SIZE + 1]; |
324 // make sure alsa_device is null-terminated even when using strncpy etc. | |
325 memset(alsa_device, 0, ALSA_DEVICE_SIZE + 1); | |
12465 | 326 |
14249 | 327 mp_msg(MSGT_AO,MSGL_V,"alsa-init: requested format: %d Hz, %d channels, %x\n", rate_hz, |
328 channels, format); | |
12465 | 329 alsa_handler = NULL; |
17690
9ca95aee8449
Show the actual ALSA version instead of the version mplayer was compiled
cladisch
parents:
17621
diff
changeset
|
330 #if SND_LIB_VERSION >= 0x010005 |
9ca95aee8449
Show the actual ALSA version instead of the version mplayer was compiled
cladisch
parents:
17621
diff
changeset
|
331 mp_msg(MSGT_AO,MSGL_V,"alsa-init: using ALSA %s\n", snd_asoundlib_version()); |
9ca95aee8449
Show the actual ALSA version instead of the version mplayer was compiled
cladisch
parents:
17621
diff
changeset
|
332 #else |
12465 | 333 mp_msg(MSGT_AO,MSGL_V,"alsa-init: compiled for ALSA-%s\n", SND_LIB_VERSION_STR); |
17690
9ca95aee8449
Show the actual ALSA version instead of the version mplayer was compiled
cladisch
parents:
17621
diff
changeset
|
334 #endif |
17691
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
335 |
b73103a82416
Output error messages from the ALSA library through mp_msg() instead of
cladisch
parents:
17690
diff
changeset
|
336 snd_lib_error_set_handler(alsa_error_handler); |
12465 | 337 |
338 ao_data.samplerate = rate_hz; | |
339 ao_data.format = format; | |
340 ao_data.channels = channels; | |
341 | |
342 switch (format) | |
343 { | |
14245 | 344 case AF_FORMAT_S8: |
12465 | 345 alsa_format = SND_PCM_FORMAT_S8; |
346 break; | |
14245 | 347 case AF_FORMAT_U8: |
12465 | 348 alsa_format = SND_PCM_FORMAT_U8; |
349 break; | |
14245 | 350 case AF_FORMAT_U16_LE: |
12465 | 351 alsa_format = SND_PCM_FORMAT_U16_LE; |
352 break; | |
14245 | 353 case AF_FORMAT_U16_BE: |
12465 | 354 alsa_format = SND_PCM_FORMAT_U16_BE; |
355 break; | |
356 #ifndef WORDS_BIGENDIAN | |
14245 | 357 case AF_FORMAT_AC3: |
12465 | 358 #endif |
14245 | 359 case AF_FORMAT_S16_LE: |
12465 | 360 alsa_format = SND_PCM_FORMAT_S16_LE; |
361 break; | |
362 #ifdef WORDS_BIGENDIAN | |
14245 | 363 case AF_FORMAT_AC3: |
12465 | 364 #endif |
14245 | 365 case AF_FORMAT_S16_BE: |
12465 | 366 alsa_format = SND_PCM_FORMAT_S16_BE; |
367 break; | |
17571
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
368 case AF_FORMAT_U32_LE: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
369 alsa_format = SND_PCM_FORMAT_U32_LE; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
370 break; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
371 case AF_FORMAT_U32_BE: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
372 alsa_format = SND_PCM_FORMAT_U32_BE; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
373 break; |
14245 | 374 case AF_FORMAT_S32_LE: |
12465 | 375 alsa_format = SND_PCM_FORMAT_S32_LE; |
376 break; | |
14245 | 377 case AF_FORMAT_S32_BE: |
12465 | 378 alsa_format = SND_PCM_FORMAT_S32_BE; |
379 break; | |
14245 | 380 case AF_FORMAT_FLOAT_LE: |
12570 | 381 alsa_format = SND_PCM_FORMAT_FLOAT_LE; |
382 break; | |
17571
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
383 case AF_FORMAT_FLOAT_BE: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
384 alsa_format = SND_PCM_FORMAT_FLOAT_BE; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
385 break; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
386 case AF_FORMAT_MU_LAW: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
387 alsa_format = SND_PCM_FORMAT_MU_LAW; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
388 break; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
389 case AF_FORMAT_A_LAW: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
390 alsa_format = SND_PCM_FORMAT_A_LAW; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
391 break; |
12465 | 392 |
393 default: | |
14251 | 394 alsa_format = SND_PCM_FORMAT_MPEG; //? default should be -1 |
12465 | 395 break; |
396 } | |
397 | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
398 //subdevice parsing |
14328 | 399 // set defaults |
400 block = 1; | |
12465 | 401 /* switch for spdif |
402 * sets opening sequence for SPDIF | |
403 * sets also the playback and other switches 'on the fly' | |
404 * while opening the abstract alias for the spdif subdevice | |
405 * 'iec958' | |
406 */ | |
14245 | 407 if (format == AF_FORMAT_AC3) { |
19889
d4bb39d65f87
When the hardware sample format is AC3, do not force using an hardcoded
cladisch
parents:
19887
diff
changeset
|
408 device.str = "iec958"; |
12747 | 409 mp_msg(MSGT_AO,MSGL_V,"alsa-spdif-init: playing AC3, %i channels\n", channels); |
12465 | 410 } |
13661
07dc40f25068
Only use S/PDIF output when no other alsa device is set, allows to use
reimar
parents:
13434
diff
changeset
|
411 else |
14328 | 412 /* in any case for multichannel playback we should select |
413 * appropriate device | |
414 */ | |
415 switch (channels) { | |
416 case 1: | |
417 case 2: | |
418 device.str = "default"; | |
419 mp_msg(MSGT_AO,MSGL_V,"alsa-init: setup for 1/2 channel(s)\n"); | |
420 break; | |
421 case 4: | |
422 if (alsa_format == SND_PCM_FORMAT_FLOAT_LE) | |
423 // hack - use the converter plugin | |
424 device.str = "plug:surround40"; | |
425 else | |
426 device.str = "surround40"; | |
427 mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround40\n"); | |
428 break; | |
429 case 6: | |
430 if (alsa_format == SND_PCM_FORMAT_FLOAT_LE) | |
431 device.str = "plug:surround51"; | |
432 else | |
433 device.str = "surround51"; | |
434 mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround51\n"); | |
435 break; | |
436 default: | |
437 device.str = "default"; | |
20764 | 438 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ChannelsNotSupported,channels); |
14328 | 439 } |
440 device.len = strlen(device.str); | |
441 if (subopt_parse(ao_subdevice, subopts) != 0) { | |
442 print_help(); | |
443 return 0; | |
444 } | |
445 ao_noblock = !block; | |
446 parse_device(alsa_device, device.str, device.len); | |
12465 | 447 |
20185 | 448 mp_msg(MSGT_AO,MSGL_V,"alsa-init: using device %s\n", alsa_device); |
12465 | 449 |
450 //setting modes for block or nonblock-mode | |
451 if (ao_noblock) { | |
452 open_mode = SND_PCM_NONBLOCK; | |
453 } | |
454 else { | |
455 open_mode = 0; | |
456 } | |
457 | |
458 //sets buff/chunksize if its set manually | |
459 if (ao_data.buffersize) { | |
460 switch (ao_data.buffersize) | |
461 { | |
462 case 1: | |
463 alsa_fragcount = 16; | |
464 chunk_size = 512; | |
465 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 8192\n"); | |
466 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 512\n"); | |
467 break; | |
468 case 2: | |
469 alsa_fragcount = 8; | |
470 chunk_size = 1024; | |
471 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 8192\n"); | |
472 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 1024\n"); | |
473 break; | |
474 case 3: | |
475 alsa_fragcount = 32; | |
476 chunk_size = 512; | |
477 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 16384\n"); | |
478 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 512\n"); | |
479 break; | |
480 case 4: | |
481 alsa_fragcount = 16; | |
482 chunk_size = 1024; | |
483 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 16384\n"); | |
484 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 1024\n"); | |
485 break; | |
486 default: | |
487 alsa_fragcount = 16; | |
17616
92431bc3d014
This patch removes mmap support because it doesn't have any benefit.
cladisch
parents:
17575
diff
changeset
|
488 chunk_size = 1024; |
12465 | 489 break; |
490 } | |
491 } | |
492 | |
493 if (!alsa_handler) { | |
494 //modes = 0, SND_PCM_NONBLOCK, SND_PCM_ASYNC | |
22166
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
495 if ((err = try_open_device(alsa_device, open_mode, format == AF_FORMAT_AC3)) < 0) |
12465 | 496 { |
497 if (err != -EBUSY && ao_noblock) { | |
20764 | 498 mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_OpenInNonblockModeFailed); |
22166
68dceb30bbcf
When setting the non-audio bit for hwac3 output, just try to set the
cladisch
parents:
20764
diff
changeset
|
499 if ((err = try_open_device(alsa_device, 0, format == AF_FORMAT_AC3)) < 0) { |
20764 | 500 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PlaybackOpenError, snd_strerror(err)); |
12465 | 501 return(0); |
502 } | |
503 } else { | |
20764 | 504 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PlaybackOpenError, snd_strerror(err)); |
12465 | 505 return(0); |
506 } | |
507 } | |
508 | |
17619
9b619133f11a
Using non-blocking writes makes sense when the program wants to do other
cladisch
parents:
17618
diff
changeset
|
509 if ((err = snd_pcm_nonblock(alsa_handler, 0)) < 0) { |
20764 | 510 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ErrorSetBlockMode, snd_strerror(err)); |
12465 | 511 } else { |
20743 | 512 mp_msg(MSGT_AO,MSGL_V,"alsa-init: pcm opened in blocking mode\n"); |
12465 | 513 } |
514 | |
515 snd_pcm_hw_params_alloca(&alsa_hwparams); | |
516 snd_pcm_sw_params_alloca(&alsa_swparams); | |
517 | |
518 // setting hw-parameters | |
519 if ((err = snd_pcm_hw_params_any(alsa_handler, alsa_hwparams)) < 0) | |
520 { | |
20764 | 521 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetInitialParameters, |
12465 | 522 snd_strerror(err)); |
523 return(0); | |
524 } | |
525 | |
17616
92431bc3d014
This patch removes mmap support because it doesn't have any benefit.
cladisch
parents:
17575
diff
changeset
|
526 err = snd_pcm_hw_params_set_access(alsa_handler, alsa_hwparams, |
92431bc3d014
This patch removes mmap support because it doesn't have any benefit.
cladisch
parents:
17575
diff
changeset
|
527 SND_PCM_ACCESS_RW_INTERLEAVED); |
12465 | 528 if (err < 0) { |
20764 | 529 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetAccessType, |
12465 | 530 snd_strerror(err)); |
531 return (0); | |
532 } | |
533 | |
534 /* workaround for nonsupported formats | |
535 sets default format to S16_LE if the given formats aren't supported */ | |
536 if ((err = snd_pcm_hw_params_test_format(alsa_handler, alsa_hwparams, | |
537 alsa_format)) < 0) | |
538 { | |
539 mp_msg(MSGT_AO,MSGL_INFO, | |
20764 | 540 MSGTR_AO_ALSA_FormatNotSupportedByHardware, af_fmt2str_short(format)); |
12465 | 541 alsa_format = SND_PCM_FORMAT_S16_LE; |
14245 | 542 ao_data.format = AF_FORMAT_S16_LE; |
12465 | 543 } |
544 | |
545 if ((err = snd_pcm_hw_params_set_format(alsa_handler, alsa_hwparams, | |
546 alsa_format)) < 0) | |
547 { | |
20764 | 548 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetFormat, |
12465 | 549 snd_strerror(err)); |
16308
41278ab73e9b
set the nearest number of channels, return(0) upon errors
henry
parents:
14849
diff
changeset
|
550 return(0); |
12465 | 551 } |
552 | |
16308
41278ab73e9b
set the nearest number of channels, return(0) upon errors
henry
parents:
14849
diff
changeset
|
553 if ((err = snd_pcm_hw_params_set_channels_near(alsa_handler, alsa_hwparams, |
41278ab73e9b
set the nearest number of channels, return(0) upon errors
henry
parents:
14849
diff
changeset
|
554 &ao_data.channels)) < 0) |
12465 | 555 { |
20764 | 556 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetChannels, |
12465 | 557 snd_strerror(err)); |
16308
41278ab73e9b
set the nearest number of channels, return(0) upon errors
henry
parents:
14849
diff
changeset
|
558 return(0); |
12465 | 559 } |
560 | |
17849
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
561 /* workaround for buggy rate plugin (should be fixed in ALSA 1.0.11) |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
562 prefer our own resampler */ |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
563 #if SND_LIB_VERSION >= 0x010009 |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
564 if ((err = snd_pcm_hw_params_set_rate_resample(alsa_handler, alsa_hwparams, |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
565 0)) < 0) |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
566 { |
20764 | 567 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToDisableResampling, |
17849
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
568 snd_strerror(err)); |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
569 return(0); |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
570 } |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
571 #endif |
ebebe97331af
To avoid a bug in ALSA's rate plugin that causes spurious overruns, try
cladisch
parents:
17848
diff
changeset
|
572 |
12465 | 573 if ((err = snd_pcm_hw_params_set_rate_near(alsa_handler, alsa_hwparams, |
17575
9972b744fd98
Small fixes: make all global variables static, remove some unused
cladisch
parents:
17574
diff
changeset
|
574 &ao_data.samplerate, NULL)) < 0) |
12465 | 575 { |
20764 | 576 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSamplerate2, |
12465 | 577 snd_strerror(err)); |
578 return(0); | |
579 } | |
580 | |
17570
401521ec0d61
This replaces the hardcoded numbers for the sample format widths with a
cladisch
parents:
17566
diff
changeset
|
581 bytes_per_sample = snd_pcm_format_physical_width(alsa_format) / 8; |
401521ec0d61
This replaces the hardcoded numbers for the sample format widths with a
cladisch
parents:
17566
diff
changeset
|
582 bytes_per_sample *= ao_data.channels; |
401521ec0d61
This replaces the hardcoded numbers for the sample format widths with a
cladisch
parents:
17566
diff
changeset
|
583 ao_data.bps = ao_data.samplerate * bytes_per_sample; |
16309 | 584 |
12465 | 585 #ifdef BUFFERTIME |
586 { | |
587 int alsa_buffer_time = 500000; /* original 60 */ | |
588 int alsa_period_time; | |
589 alsa_period_time = alsa_buffer_time/4; | |
590 if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa_handler, alsa_hwparams, | |
17575
9972b744fd98
Small fixes: make all global variables static, remove some unused
cladisch
parents:
17574
diff
changeset
|
591 &alsa_buffer_time, NULL)) < 0) |
12465 | 592 { |
20764 | 593 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetBufferTimeNear, |
12465 | 594 snd_strerror(err)); |
595 return(0); | |
596 } else | |
597 alsa_buffer_time = err; | |
598 | |
599 if ((err = snd_pcm_hw_params_set_period_time_near(alsa_handler, alsa_hwparams, | |
17575
9972b744fd98
Small fixes: make all global variables static, remove some unused
cladisch
parents:
17574
diff
changeset
|
600 &alsa_period_time, NULL)) < 0) |
12465 | 601 /* original: alsa_buffer_time/ao_data.bps */ |
602 { | |
20764 | 603 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriodTime, |
12465 | 604 snd_strerror(err)); |
19887
1259d6add8e6
When one of the PCM configuration function in init() fails, abort
cladisch
parents:
18009
diff
changeset
|
605 return 0; |
12465 | 606 } |
20764 | 607 mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_BufferTimePeriodTime, |
12465 | 608 alsa_buffer_time, err); |
609 } | |
610 #endif//end SET_BUFFERTIME | |
611 | |
612 #ifdef SET_CHUNKSIZE | |
613 { | |
614 //set chunksize | |
615 if ((err = snd_pcm_hw_params_set_period_size_near(alsa_handler, alsa_hwparams, | |
17575
9972b744fd98
Small fixes: make all global variables static, remove some unused
cladisch
parents:
17574
diff
changeset
|
616 &chunk_size, NULL)) < 0) |
12465 | 617 { |
20764 | 618 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriodSize, |
12465 | 619 chunk_size, snd_strerror(err)); |
19887
1259d6add8e6
When one of the PCM configuration function in init() fails, abort
cladisch
parents:
18009
diff
changeset
|
620 return 0; |
12465 | 621 } |
622 else { | |
17366 | 623 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set to %li\n", chunk_size); |
12465 | 624 } |
625 if ((err = snd_pcm_hw_params_set_periods_near(alsa_handler, alsa_hwparams, | |
17575
9972b744fd98
Small fixes: make all global variables static, remove some unused
cladisch
parents:
17574
diff
changeset
|
626 &alsa_fragcount, NULL)) < 0) { |
20764 | 627 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriods, |
12465 | 628 snd_strerror(err)); |
19887
1259d6add8e6
When one of the PCM configuration function in init() fails, abort
cladisch
parents:
18009
diff
changeset
|
629 return 0; |
12465 | 630 } |
631 else { | |
632 mp_msg(MSGT_AO,MSGL_V,"alsa-init: fragcount=%i\n", alsa_fragcount); | |
633 } | |
634 } | |
635 #endif//end SET_CHUNKSIZE | |
636 | |
637 /* finally install hardware parameters */ | |
638 if ((err = snd_pcm_hw_params(alsa_handler, alsa_hwparams)) < 0) | |
639 { | |
20764 | 640 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetHwParameters, |
12465 | 641 snd_strerror(err)); |
19887
1259d6add8e6
When one of the PCM configuration function in init() fails, abort
cladisch
parents:
18009
diff
changeset
|
642 return 0; |
12465 | 643 } |
644 // end setting hw-params | |
645 | |
646 | |
647 // gets buffersize for control | |
648 if ((err = snd_pcm_hw_params_get_buffer_size(alsa_hwparams, &bufsize)) < 0) | |
649 { | |
20764 | 650 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBufferSize, snd_strerror(err)); |
19887
1259d6add8e6
When one of the PCM configuration function in init() fails, abort
cladisch
parents:
18009
diff
changeset
|
651 return 0; |
12465 | 652 } |
653 else { | |
654 ao_data.buffersize = bufsize * bytes_per_sample; | |
655 mp_msg(MSGT_AO,MSGL_V,"alsa-init: got buffersize=%i\n", ao_data.buffersize); | |
656 } | |
657 | |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
658 if ((err = snd_pcm_hw_params_get_period_size(alsa_hwparams, &chunk_size, NULL)) < 0) { |
20764 | 659 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetPeriodSize, snd_strerror(err)); |
19887
1259d6add8e6
When one of the PCM configuration function in init() fails, abort
cladisch
parents:
18009
diff
changeset
|
660 return 0; |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
661 } else { |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
662 mp_msg(MSGT_AO,MSGL_V,"alsa-init: got period size %li\n", chunk_size); |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
663 } |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
664 ao_data.outburst = chunk_size * bytes_per_sample; |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
665 |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
666 /* setting software parameters */ |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
667 if ((err = snd_pcm_sw_params_current(alsa_handler, alsa_swparams)) < 0) { |
20764 | 668 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters, |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
669 snd_strerror(err)); |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
670 return 0; |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
671 } |
18009
fb7888812f13
Add workarounds for old prerelease versions of alsa-lib 0.9.0 that did
cladisch
parents:
17849
diff
changeset
|
672 #if SND_LIB_VERSION >= 0x000901 |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
673 if ((err = snd_pcm_sw_params_get_boundary(alsa_swparams, &boundary)) < 0) { |
20764 | 674 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBoundary, |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
675 snd_strerror(err)); |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
676 return 0; |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
677 } |
18009
fb7888812f13
Add workarounds for old prerelease versions of alsa-lib 0.9.0 that did
cladisch
parents:
17849
diff
changeset
|
678 #else |
fb7888812f13
Add workarounds for old prerelease versions of alsa-lib 0.9.0 that did
cladisch
parents:
17849
diff
changeset
|
679 boundary = 0x7fffffff; |
fb7888812f13
Add workarounds for old prerelease versions of alsa-lib 0.9.0 that did
cladisch
parents:
17849
diff
changeset
|
680 #endif |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
681 /* start playing when one period has been written */ |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
682 if ((err = snd_pcm_sw_params_set_start_threshold(alsa_handler, alsa_swparams, chunk_size)) < 0) { |
20764 | 683 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStartThreshold, |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
684 snd_strerror(err)); |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
685 return 0; |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
686 } |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
687 /* disable underrun reporting */ |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
688 if ((err = snd_pcm_sw_params_set_stop_threshold(alsa_handler, alsa_swparams, boundary)) < 0) { |
20764 | 689 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStopThreshold, |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
690 snd_strerror(err)); |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
691 return 0; |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
692 } |
18009
fb7888812f13
Add workarounds for old prerelease versions of alsa-lib 0.9.0 that did
cladisch
parents:
17849
diff
changeset
|
693 #if SND_LIB_VERSION >= 0x000901 |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
694 /* play silence when there is an underrun */ |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
695 if ((err = snd_pcm_sw_params_set_silence_size(alsa_handler, alsa_swparams, boundary)) < 0) { |
20764 | 696 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSilenceSize, |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
697 snd_strerror(err)); |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
698 return 0; |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
699 } |
18009
fb7888812f13
Add workarounds for old prerelease versions of alsa-lib 0.9.0 that did
cladisch
parents:
17849
diff
changeset
|
700 #endif |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
701 if ((err = snd_pcm_sw_params(alsa_handler, alsa_swparams)) < 0) { |
20764 | 702 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters, |
17620
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
703 snd_strerror(err)); |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
704 return 0; |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
705 } |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
706 /* end setting sw-params */ |
dd4db8c43d92
This changes the software parameters to be more compatible with the
cladisch
parents:
17619
diff
changeset
|
707 |
20185 | 708 mp_msg(MSGT_AO,MSGL_V,"alsa: %d Hz/%d channels/%d bpf/%d bytes buffer/%s\n", |
12465 | 709 ao_data.samplerate, ao_data.channels, bytes_per_sample, ao_data.buffersize, |
710 snd_pcm_format_description(alsa_format)); | |
711 | |
712 } // end switch alsa_handler (spdif) | |
713 alsa_can_pause = snd_pcm_hw_params_can_pause(alsa_hwparams); | |
714 return(1); | |
715 } // end init | |
716 | |
717 | |
718 /* close audio device */ | |
719 static void uninit(int immed) | |
720 { | |
721 | |
722 if (alsa_handler) { | |
723 int err; | |
724 | |
14849
d313f591d1a4
aos should respect the immed uninit flag (quit immediatly vs waiting till file
reimar
parents:
14612
diff
changeset
|
725 if (!immed) |
d313f591d1a4
aos should respect the immed uninit flag (quit immediatly vs waiting till file
reimar
parents:
14612
diff
changeset
|
726 snd_pcm_drain(alsa_handler); |
d313f591d1a4
aos should respect the immed uninit flag (quit immediatly vs waiting till file
reimar
parents:
14612
diff
changeset
|
727 |
12465 | 728 if ((err = snd_pcm_close(alsa_handler)) < 0) |
729 { | |
20764 | 730 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmCloseError, snd_strerror(err)); |
12465 | 731 return; |
732 } | |
733 else { | |
734 alsa_handler = NULL; | |
20185 | 735 mp_msg(MSGT_AO,MSGL_V,"alsa-uninit: pcm closed\n"); |
12465 | 736 } |
737 } | |
738 else { | |
20764 | 739 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_NoHandlerDefined); |
12465 | 740 } |
741 } | |
742 | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
743 static void audio_pause(void) |
12465 | 744 { |
745 int err; | |
746 | |
747 if (alsa_can_pause) { | |
748 if ((err = snd_pcm_pause(alsa_handler, 1)) < 0) | |
749 { | |
20764 | 750 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPauseError, snd_strerror(err)); |
12465 | 751 return; |
752 } | |
753 mp_msg(MSGT_AO,MSGL_V,"alsa-pause: pause supported by hardware\n"); | |
754 } else { | |
755 if ((err = snd_pcm_drop(alsa_handler)) < 0) | |
756 { | |
20764 | 757 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmDropError, snd_strerror(err)); |
12465 | 758 return; |
759 } | |
760 } | |
761 } | |
762 | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
763 static void audio_resume(void) |
12465 | 764 { |
765 int err; | |
766 | |
767 if (alsa_can_pause) { | |
768 if ((err = snd_pcm_pause(alsa_handler, 0)) < 0) | |
769 { | |
20764 | 770 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmResumeError, snd_strerror(err)); |
12465 | 771 return; |
772 } | |
773 mp_msg(MSGT_AO,MSGL_V,"alsa-resume: resume supported by hardware\n"); | |
774 } else { | |
775 if ((err = snd_pcm_prepare(alsa_handler)) < 0) | |
776 { | |
20764 | 777 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPrepareError, snd_strerror(err)); |
12465 | 778 return; |
779 } | |
780 } | |
781 } | |
782 | |
783 /* stop playing and empty buffers (for seeking/pause) */ | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
784 static void reset(void) |
12465 | 785 { |
786 int err; | |
787 | |
788 if ((err = snd_pcm_drop(alsa_handler)) < 0) | |
789 { | |
20764 | 790 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPrepareError, snd_strerror(err)); |
12465 | 791 return; |
792 } | |
793 if ((err = snd_pcm_prepare(alsa_handler)) < 0) | |
794 { | |
20764 | 795 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPrepareError, snd_strerror(err)); |
12465 | 796 return; |
797 } | |
798 return; | |
799 } | |
800 | |
801 /* | |
802 plays 'len' bytes of 'data' | |
803 returns: number of bytes played | |
804 modified last at 29.06.02 by jp | |
805 thanxs for marius <marius@rospot.com> for giving us the light ;) | |
806 */ | |
807 | |
17617
adfab82139c0
After removing play_mmap(), the play() function just unconditionally
cladisch
parents:
17616
diff
changeset
|
808 static int play(void* data, int len, int flags) |
12465 | 809 { |
810 int num_frames = len / bytes_per_sample; | |
811 snd_pcm_sframes_t res = 0; | |
812 | |
813 //mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: frames=%i, len=%i\n",num_frames,len); | |
814 | |
815 if (!alsa_handler) { | |
20764 | 816 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_DeviceConfigurationError); |
12465 | 817 return 0; |
818 } | |
819 | |
17621
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
820 if (num_frames == 0) |
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
821 return 0; |
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
822 |
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
823 do { |
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
824 res = snd_pcm_writei(alsa_handler, data, num_frames); |
12465 | 825 |
17621
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
826 if (res == -EINTR) { |
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
827 /* nothing to do */ |
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
828 res = 0; |
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
829 } |
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
830 else if (res == -ESTRPIPE) { /* suspend */ |
20764 | 831 mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_PcmInSuspendModeTryingResume); |
12465 | 832 while ((res = snd_pcm_resume(alsa_handler)) == -EAGAIN) |
833 sleep(1); | |
834 } | |
17621
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
835 if (res < 0) { |
20764 | 836 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_WriteError, snd_strerror(res)); |
837 mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_TryingToResetSoundcard); | |
12465 | 838 if ((res = snd_pcm_prepare(alsa_handler)) < 0) { |
20764 | 839 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPrepareError, snd_strerror(res)); |
12465 | 840 return(0); |
841 break; | |
842 } | |
843 } | |
17621
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
844 } while (res == 0); |
12465 | 845 |
17621
d9c518932302
Fix the error handling in the play() function: add a handler for EINTR,
cladisch
parents:
17620
diff
changeset
|
846 return res < 0 ? res : res * bytes_per_sample; |
12465 | 847 } |
848 | |
849 /* how many byes are free in the buffer */ | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
850 static int get_space(void) |
12465 | 851 { |
852 snd_pcm_status_t *status; | |
853 int ret; | |
854 | |
12747 | 855 snd_pcm_status_alloca(&status); |
12465 | 856 |
857 if ((ret = snd_pcm_status(alsa_handler, status)) < 0) | |
858 { | |
20764 | 859 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_CannotGetPcmStatus, snd_strerror(ret)); |
12465 | 860 return(0); |
861 } | |
862 | |
17572
580dc69d69bf
Fix get_space(): we don't need to differentiate between the various PCM
cladisch
parents:
17571
diff
changeset
|
863 ret = snd_pcm_status_get_avail(status) * bytes_per_sample; |
24590
2c238fa777ff
ao_alsa: Fix get_space() return values larger than buffersize
uau
parents:
22166
diff
changeset
|
864 if (ret > ao_data.buffersize) // Buffer underrun? |
2c238fa777ff
ao_alsa: Fix get_space() return values larger than buffersize
uau
parents:
22166
diff
changeset
|
865 ret = ao_data.buffersize; |
12465 | 866 return(ret); |
867 } | |
868 | |
869 /* delay in seconds between first and last sample in buffer */ | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
870 static float get_delay(void) |
12465 | 871 { |
872 if (alsa_handler) { | |
17573
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
873 snd_pcm_sframes_t delay; |
12465 | 874 |
17573
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
875 if (snd_pcm_delay(alsa_handler, &delay) < 0) |
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
876 return 0; |
12465 | 877 |
17573
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
878 if (delay < 0) { |
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
879 /* underrun - move the application pointer forward to catch up */ |
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
880 #if SND_LIB_VERSION >= 0x000901 /* snd_pcm_forward() exists since 0.9.0rc8 */ |
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
881 snd_pcm_forward(alsa_handler, -delay); |
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
882 #endif |
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
883 delay = 0; |
12465 | 884 } |
17573
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
885 return (float)delay / (float)ao_data.samplerate; |
12465 | 886 } else { |
887 return(0); | |
888 } | |
889 } |