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