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