Mercurial > mplayer.hg
annotate libao2/ao_alsa.c @ 17574:9c90977d9f50
Remove a call to snd_pcm_prepare() because snd_pcm_hw_params() does it
automatically, and remove a call to snd_pcm_drop() because
snd_pcm_close() does it automatically.
author | cladisch |
---|---|
date | Fri, 10 Feb 2006 09:26:11 +0000 |
parents | 8921544f4114 |
children | 9972b744fd98 |
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> | |
18 #include <math.h> | |
19 #include <string.h> | |
20 #include <sys/poll.h> | |
21 | |
14123 | 22 #include "config.h" |
14328 | 23 #include "subopt-helper.h" |
14123 | 24 #include "mixer.h" |
25 #include "mp_msg.h" | |
12465 | 26 |
27 #define ALSA_PCM_NEW_HW_PARAMS_API | |
28 #define ALSA_PCM_NEW_SW_PARAMS_API | |
29 | |
30 #if HAVE_SYS_ASOUNDLIB_H | |
31 #include <sys/asoundlib.h> | |
32 #elif HAVE_ALSA_ASOUNDLIB_H | |
33 #include <alsa/asoundlib.h> | |
34 #else | |
35 #error "asoundlib.h is not in sys/ or alsa/ - please bugreport" | |
36 #endif | |
37 | |
38 | |
39 #include "audio_out.h" | |
40 #include "audio_out_internal.h" | |
14245 | 41 #include "libaf/af_format.h" |
12465 | 42 |
43 static ao_info_t info = | |
44 { | |
45 "ALSA-0.9.x-1.x audio output", | |
46 "alsa", | |
47 "Alex Beregszaszi, Zsolt Barat <joy@streamminister.de>", | |
48 "under developement" | |
49 }; | |
50 | |
51 LIBAO_EXTERN(alsa) | |
52 | |
53 static snd_pcm_t *alsa_handler; | |
54 static snd_pcm_format_t alsa_format; | |
55 static snd_pcm_hw_params_t *alsa_hwparams; | |
56 static snd_pcm_sw_params_t *alsa_swparams; | |
57 | |
58 /* possible 4096, original 8192 | |
59 * was only needed for calculating chunksize? */ | |
60 static int alsa_fragsize = 4096; | |
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; | |
65 static snd_pcm_uframes_t chunk_size = 1024;//is alsa_fragsize / 4 | |
66 | |
67 static size_t bits_per_sample, bytes_per_sample, bits_per_frame; | |
68 static size_t chunk_bytes; | |
69 | |
70 int ao_mmap = 0; | |
71 int ao_noblock = 0; | |
72 int first = 1; | |
73 | |
74 static int open_mode; | |
75 static int set_block_mode; | |
76 static int alsa_can_pause = 0; | |
77 | |
12747 | 78 #define ALSA_DEVICE_SIZE 256 |
12465 | 79 |
80 #undef BUFFERTIME | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
81 #define SET_CHUNKSIZE |
12465 | 82 #undef USE_POLL |
83 | |
84 /* to set/get/query special features/parameters */ | |
85 static int control(int cmd, void *arg) | |
86 { | |
87 switch(cmd) { | |
88 case AOCONTROL_QUERY_FORMAT: | |
89 return CONTROL_TRUE; | |
90 #ifndef WORDS_BIGENDIAN | |
91 case AOCONTROL_GET_VOLUME: | |
92 case AOCONTROL_SET_VOLUME: | |
93 { | |
94 ao_control_vol_t *vol = (ao_control_vol_t *)arg; | |
95 | |
96 int err; | |
97 snd_mixer_t *handle; | |
98 snd_mixer_elem_t *elem; | |
99 snd_mixer_selem_id_t *sid; | |
100 | |
12747 | 101 static char *mix_name = "PCM"; |
102 static char *card = "default"; | |
13434 | 103 static int mix_index = 0; |
12465 | 104 |
105 long pmin, pmax; | |
106 long get_vol, set_vol; | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
107 float f_multi; |
12465 | 108 |
13434 | 109 if(mixer_channel) { |
110 char *test_mix_index; | |
111 | |
112 mix_name = strdup(mixer_channel); | |
17097 | 113 if ((test_mix_index = strchr(mix_name, ','))){ |
13434 | 114 *test_mix_index = 0; |
115 test_mix_index++; | |
116 mix_index = strtol(test_mix_index, &test_mix_index, 0); | |
117 | |
118 if (*test_mix_index){ | |
119 mp_msg(MSGT_AO,MSGL_ERR, | |
120 "alsa-control: invalid mixer index. Defaulting to 0\n"); | |
121 mix_index = 0 ; | |
122 } | |
123 } | |
124 } | |
12747 | 125 if(mixer_device) card = mixer_device; |
12465 | 126 |
14245 | 127 if(ao_data.format == AF_FORMAT_AC3) |
12465 | 128 return CONTROL_TRUE; |
129 | |
130 //allocate simple id | |
131 snd_mixer_selem_id_alloca(&sid); | |
132 | |
133 //sets simple-mixer index and name | |
13434 | 134 snd_mixer_selem_id_set_index(sid, mix_index); |
12465 | 135 snd_mixer_selem_id_set_name(sid, mix_name); |
136 | |
13434 | 137 if (mixer_channel) { |
138 free(mix_name); | |
139 mix_name = NULL; | |
140 } | |
141 | |
12465 | 142 if ((err = snd_mixer_open(&handle, 0)) < 0) { |
143 mp_msg(MSGT_AO,MSGL_ERR,"alsa-control: mixer open error: %s\n", snd_strerror(err)); | |
144 return CONTROL_ERROR; | |
145 } | |
146 | |
147 if ((err = snd_mixer_attach(handle, card)) < 0) { | |
148 mp_msg(MSGT_AO,MSGL_ERR,"alsa-control: mixer attach %s error: %s\n", | |
149 card, snd_strerror(err)); | |
150 snd_mixer_close(handle); | |
151 return CONTROL_ERROR; | |
152 } | |
153 | |
154 if ((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0) { | |
155 mp_msg(MSGT_AO,MSGL_ERR,"alsa-control: mixer register error: %s\n", snd_strerror(err)); | |
156 snd_mixer_close(handle); | |
157 return CONTROL_ERROR; | |
158 } | |
159 err = snd_mixer_load(handle); | |
160 if (err < 0) { | |
161 mp_msg(MSGT_AO,MSGL_ERR,"alsa-control: mixer load error: %s\n", snd_strerror(err)); | |
162 snd_mixer_close(handle); | |
163 return CONTROL_ERROR; | |
164 } | |
165 | |
166 elem = snd_mixer_find_selem(handle, sid); | |
167 if (!elem) { | |
168 mp_msg(MSGT_AO,MSGL_ERR,"alsa-control: unable to find simple control '%s',%i\n", | |
169 snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid)); | |
170 snd_mixer_close(handle); | |
171 return CONTROL_ERROR; | |
172 } | |
173 | |
174 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
|
175 f_multi = (100 / (float)(pmax - pmin)); |
12465 | 176 |
177 if (cmd == AOCONTROL_SET_VOLUME) { | |
178 | |
12811
d5f8efddac6c
volume calc fixes for mixer, by reimar dffinger, 10l reverse by me
joyping
parents:
12805
diff
changeset
|
179 set_vol = vol->left / f_multi + pmin + 0.5; |
12465 | 180 |
181 //setting channels | |
182 if ((err = snd_mixer_selem_set_playback_volume(elem, 0, set_vol)) < 0) { | |
183 mp_msg(MSGT_AO,MSGL_ERR,"alsa-control: error setting left channel, %s\n", | |
184 snd_strerror(err)); | |
185 return CONTROL_ERROR; | |
186 } | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
187 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
|
188 |
12811
d5f8efddac6c
volume calc fixes for mixer, by reimar dffinger, 10l reverse by me
joyping
parents:
12805
diff
changeset
|
189 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
|
190 |
12465 | 191 if ((err = snd_mixer_selem_set_playback_volume(elem, 1, set_vol)) < 0) { |
192 mp_msg(MSGT_AO,MSGL_ERR,"alsa-control: error setting right channel, %s\n", | |
193 snd_strerror(err)); | |
194 return CONTROL_ERROR; | |
195 } | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
196 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
|
197 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
|
198 |
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
|
199 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
|
200 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
|
201 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
|
202 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
|
203 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
|
204 } 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
|
205 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
|
206 } |
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
|
207 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
|
208 } |
12465 | 209 } |
210 else { | |
211 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
|
212 vol->left = (get_vol - pmin) * f_multi; |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
213 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
|
214 vol->right = (get_vol - pmin) * f_multi; |
12465 | 215 |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
216 mp_msg(MSGT_AO,MSGL_DBG2,"left=%f, right=%f\n",vol->left,vol->right); |
12465 | 217 } |
218 snd_mixer_close(handle); | |
219 return CONTROL_OK; | |
220 } | |
221 #endif | |
222 | |
223 } //end switch | |
224 return(CONTROL_UNKNOWN); | |
225 } | |
226 | |
14328 | 227 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
|
228 { |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
229 char *tmp; |
14328 | 230 memmove(dest, src, len); |
231 dest[len] = 0; | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
232 while ((tmp = strrchr(dest, '.'))) |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
233 tmp[0] = ','; |
12919
aba44b58dea7
Use = instead if # in ALSA device name, as # irritates our config-parser.
reimar
parents:
12819
diff
changeset
|
234 while ((tmp = strrchr(dest, '='))) |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
235 tmp[0] = ':'; |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
236 } |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
237 |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
238 static void print_help (void) |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
239 { |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
240 mp_msg (MSGT_AO, MSGL_FATAL, |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
241 "\n-ao alsa commandline help:\n" |
12919
aba44b58dea7
Use = instead if # in ALSA device name, as # irritates our config-parser.
reimar
parents:
12819
diff
changeset
|
242 "Example: mplayer -ao alsa:mmap:device=hw=0.3\n" |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
243 " sets mmap-mode and first card fourth device\n" |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
244 "\nOptions:\n" |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
245 " mmap\n" |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
246 " Set memory-mapped mode, experimental\n" |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
247 " noblock\n" |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
248 " Sets non-blocking mode\n" |
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
249 " device=<device-name>\n" |
12919
aba44b58dea7
Use = instead if # in ALSA device name, as # irritates our config-parser.
reimar
parents:
12819
diff
changeset
|
250 " Sets device (change , to . and : to =)\n"); |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
251 } |
12465 | 252 |
14328 | 253 static int str_maxlen(strarg_t *str) { |
254 if (str->len > ALSA_DEVICE_SIZE) | |
255 return 0; | |
256 return 1; | |
257 } | |
258 | |
12465 | 259 /* |
260 open & setup audio device | |
261 return: 1=success 0=fail | |
262 */ | |
263 static int init(int rate_hz, int channels, int format, int flags) | |
264 { | |
265 int err; | |
266 int cards = -1; | |
267 snd_pcm_info_t *alsa_info; | |
268 char *str_block_mode; | |
269 int dir = 0; | |
14328 | 270 int block; |
271 strarg_t device; | |
12465 | 272 snd_pcm_uframes_t bufsize; |
14328 | 273 opt_t subopts[] = { |
274 {"mmap", OPT_ARG_BOOL, &ao_mmap, NULL}, | |
275 {"block", OPT_ARG_BOOL, &block, NULL}, | |
276 {"device", OPT_ARG_STR, &device, (opt_test_f)str_maxlen}, | |
277 {NULL} | |
278 }; | |
279 | |
12747 | 280 char alsa_device[ALSA_DEVICE_SIZE + 1]; |
281 // make sure alsa_device is null-terminated even when using strncpy etc. | |
282 memset(alsa_device, 0, ALSA_DEVICE_SIZE + 1); | |
12465 | 283 |
14249 | 284 mp_msg(MSGT_AO,MSGL_V,"alsa-init: requested format: %d Hz, %d channels, %x\n", rate_hz, |
285 channels, format); | |
12465 | 286 alsa_handler = NULL; |
287 mp_msg(MSGT_AO,MSGL_V,"alsa-init: compiled for ALSA-%s\n", SND_LIB_VERSION_STR); | |
288 | |
289 if ((err = snd_card_next(&cards)) < 0 || cards < 0) | |
290 { | |
291 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: no soundcards found: %s\n", snd_strerror(err)); | |
292 return(0); | |
293 } | |
294 | |
295 ao_data.samplerate = rate_hz; | |
296 ao_data.format = format; | |
297 ao_data.channels = channels; | |
298 ao_data.outburst = OUTBURST; | |
299 | |
300 switch (format) | |
301 { | |
14245 | 302 case AF_FORMAT_S8: |
12465 | 303 alsa_format = SND_PCM_FORMAT_S8; |
304 break; | |
14245 | 305 case AF_FORMAT_U8: |
12465 | 306 alsa_format = SND_PCM_FORMAT_U8; |
307 break; | |
14245 | 308 case AF_FORMAT_U16_LE: |
12465 | 309 alsa_format = SND_PCM_FORMAT_U16_LE; |
310 break; | |
14245 | 311 case AF_FORMAT_U16_BE: |
12465 | 312 alsa_format = SND_PCM_FORMAT_U16_BE; |
313 break; | |
314 #ifndef WORDS_BIGENDIAN | |
14245 | 315 case AF_FORMAT_AC3: |
12465 | 316 #endif |
14245 | 317 case AF_FORMAT_S16_LE: |
12465 | 318 alsa_format = SND_PCM_FORMAT_S16_LE; |
319 break; | |
320 #ifdef WORDS_BIGENDIAN | |
14245 | 321 case AF_FORMAT_AC3: |
12465 | 322 #endif |
14245 | 323 case AF_FORMAT_S16_BE: |
12465 | 324 alsa_format = SND_PCM_FORMAT_S16_BE; |
325 break; | |
17571
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
326 case AF_FORMAT_U32_LE: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
327 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
|
328 break; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
329 case AF_FORMAT_U32_BE: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
330 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
|
331 break; |
14245 | 332 case AF_FORMAT_S32_LE: |
12465 | 333 alsa_format = SND_PCM_FORMAT_S32_LE; |
334 break; | |
14245 | 335 case AF_FORMAT_S32_BE: |
12465 | 336 alsa_format = SND_PCM_FORMAT_S32_BE; |
337 break; | |
14245 | 338 case AF_FORMAT_FLOAT_LE: |
12570 | 339 alsa_format = SND_PCM_FORMAT_FLOAT_LE; |
340 break; | |
17571
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
341 case AF_FORMAT_FLOAT_BE: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
342 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
|
343 break; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
344 case AF_FORMAT_MU_LAW: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
345 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
|
346 break; |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
347 case AF_FORMAT_A_LAW: |
e476a1d38087
This adds support for more sample formats (U32, float BE, mu/A-law).
cladisch
parents:
17570
diff
changeset
|
348 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
|
349 break; |
12465 | 350 |
351 default: | |
14251 | 352 alsa_format = SND_PCM_FORMAT_MPEG; //? default should be -1 |
12465 | 353 break; |
354 } | |
355 | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
356 //subdevice parsing |
14328 | 357 // set defaults |
358 ao_mmap = 0; | |
359 block = 1; | |
12465 | 360 /* switch for spdif |
361 * sets opening sequence for SPDIF | |
362 * sets also the playback and other switches 'on the fly' | |
363 * while opening the abstract alias for the spdif subdevice | |
364 * 'iec958' | |
365 */ | |
14245 | 366 if (format == AF_FORMAT_AC3) { |
12465 | 367 unsigned char s[4]; |
368 | |
369 s[0] = IEC958_AES0_NONAUDIO | | |
370 IEC958_AES0_CON_EMPHASIS_NONE; | |
371 s[1] = IEC958_AES1_CON_ORIGINAL | | |
372 IEC958_AES1_CON_PCM_CODER; | |
373 s[2] = 0; | |
374 s[3] = IEC958_AES3_CON_FS_48000; | |
375 | |
12747 | 376 snprintf(alsa_device, ALSA_DEVICE_SIZE, |
14612 | 377 "iec958:{CARD 0 AES0 0x%02x AES1 0x%02x AES2 0x%02x AES3 0x%02x}", |
12747 | 378 s[0], s[1], s[2], s[3]); |
14328 | 379 device.str = alsa_device; |
12465 | 380 |
12747 | 381 mp_msg(MSGT_AO,MSGL_V,"alsa-spdif-init: playing AC3, %i channels\n", channels); |
12465 | 382 } |
13661
07dc40f25068
Only use S/PDIF output when no other alsa device is set, allows to use
reimar
parents:
13434
diff
changeset
|
383 else |
14328 | 384 /* in any case for multichannel playback we should select |
385 * appropriate device | |
386 */ | |
387 switch (channels) { | |
388 case 1: | |
389 case 2: | |
390 device.str = "default"; | |
391 mp_msg(MSGT_AO,MSGL_V,"alsa-init: setup for 1/2 channel(s)\n"); | |
392 break; | |
393 case 4: | |
394 if (alsa_format == SND_PCM_FORMAT_FLOAT_LE) | |
395 // hack - use the converter plugin | |
396 device.str = "plug:surround40"; | |
397 else | |
398 device.str = "surround40"; | |
399 mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround40\n"); | |
400 break; | |
401 case 6: | |
402 if (alsa_format == SND_PCM_FORMAT_FLOAT_LE) | |
403 device.str = "plug:surround51"; | |
404 else | |
405 device.str = "surround51"; | |
406 mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround51\n"); | |
407 break; | |
408 default: | |
409 device.str = "default"; | |
410 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: %d channels are not supported\n",channels); | |
411 } | |
412 device.len = strlen(device.str); | |
413 if (subopt_parse(ao_subdevice, subopts) != 0) { | |
414 print_help(); | |
415 return 0; | |
416 } | |
417 ao_noblock = !block; | |
418 parse_device(alsa_device, device.str, device.len); | |
12465 | 419 |
420 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: %d soundcard%s found, using: %s\n", cards+1,(cards >= 0) ? "" : "s", alsa_device); | |
421 | |
422 //setting modes for block or nonblock-mode | |
423 if (ao_noblock) { | |
424 open_mode = SND_PCM_NONBLOCK; | |
425 set_block_mode = 1; | |
426 str_block_mode = "nonblock-mode"; | |
427 } | |
428 else { | |
429 open_mode = 0; | |
430 set_block_mode = 0; | |
431 str_block_mode = "block-mode"; | |
432 } | |
433 | |
434 //sets buff/chunksize if its set manually | |
435 if (ao_data.buffersize) { | |
436 switch (ao_data.buffersize) | |
437 { | |
438 case 1: | |
439 alsa_fragcount = 16; | |
440 chunk_size = 512; | |
441 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 8192\n"); | |
442 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 512\n"); | |
443 break; | |
444 case 2: | |
445 alsa_fragcount = 8; | |
446 chunk_size = 1024; | |
447 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 8192\n"); | |
448 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 1024\n"); | |
449 break; | |
450 case 3: | |
451 alsa_fragcount = 32; | |
452 chunk_size = 512; | |
453 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 16384\n"); | |
454 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 512\n"); | |
455 break; | |
456 case 4: | |
457 alsa_fragcount = 16; | |
458 chunk_size = 1024; | |
459 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 16384\n"); | |
460 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 1024\n"); | |
461 break; | |
462 default: | |
463 alsa_fragcount = 16; | |
464 if (ao_mmap) | |
465 chunk_size = 512; | |
466 else | |
467 chunk_size = 1024; | |
468 break; | |
469 } | |
470 } | |
471 | |
472 if (!alsa_handler) { | |
473 //modes = 0, SND_PCM_NONBLOCK, SND_PCM_ASYNC | |
474 if ((err = snd_pcm_open(&alsa_handler, alsa_device, SND_PCM_STREAM_PLAYBACK, open_mode)) < 0) | |
475 { | |
476 if (err != -EBUSY && ao_noblock) { | |
477 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: open in nonblock-mode failed, trying to open in block-mode\n"); | |
478 if ((err = snd_pcm_open(&alsa_handler, alsa_device, SND_PCM_STREAM_PLAYBACK, 0)) < 0) { | |
479 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: playback open error: %s\n", snd_strerror(err)); | |
480 return(0); | |
481 } else { | |
482 set_block_mode = 0; | |
483 str_block_mode = "block-mode"; | |
484 } | |
485 } else { | |
486 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: playback open error: %s\n", snd_strerror(err)); | |
487 return(0); | |
488 } | |
489 } | |
490 | |
491 if ((err = snd_pcm_nonblock(alsa_handler, set_block_mode)) < 0) { | |
492 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: error set block-mode %s\n", snd_strerror(err)); | |
493 } else { | |
494 mp_msg(MSGT_AO,MSGL_V,"alsa-init: pcm opend in %s\n", str_block_mode); | |
495 } | |
496 | |
497 snd_pcm_hw_params_alloca(&alsa_hwparams); | |
498 snd_pcm_sw_params_alloca(&alsa_swparams); | |
499 | |
500 // setting hw-parameters | |
501 if ((err = snd_pcm_hw_params_any(alsa_handler, alsa_hwparams)) < 0) | |
502 { | |
503 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to get initial parameters: %s\n", | |
504 snd_strerror(err)); | |
505 return(0); | |
506 } | |
507 | |
508 if (ao_mmap) { | |
509 snd_pcm_access_mask_t *mask = alloca(snd_pcm_access_mask_sizeof()); | |
510 snd_pcm_access_mask_none(mask); | |
511 snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); | |
512 snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); | |
513 snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_COMPLEX); | |
514 err = snd_pcm_hw_params_set_access_mask(alsa_handler, alsa_hwparams, mask); | |
515 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: mmap set\n"); | |
516 } else { | |
517 err = snd_pcm_hw_params_set_access(alsa_handler, alsa_hwparams, | |
518 SND_PCM_ACCESS_RW_INTERLEAVED); | |
519 } | |
520 if (err < 0) { | |
521 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set access type: %s\n", | |
522 snd_strerror(err)); | |
523 return (0); | |
524 } | |
525 | |
526 /* workaround for nonsupported formats | |
527 sets default format to S16_LE if the given formats aren't supported */ | |
528 if ((err = snd_pcm_hw_params_test_format(alsa_handler, alsa_hwparams, | |
529 alsa_format)) < 0) | |
530 { | |
531 mp_msg(MSGT_AO,MSGL_INFO, | |
14264 | 532 "alsa-init: format %s are not supported by hardware, trying default\n", af_fmt2str_short(format)); |
12465 | 533 alsa_format = SND_PCM_FORMAT_S16_LE; |
14245 | 534 ao_data.format = AF_FORMAT_S16_LE; |
12465 | 535 } |
536 | |
537 if ((err = snd_pcm_hw_params_set_format(alsa_handler, alsa_hwparams, | |
538 alsa_format)) < 0) | |
539 { | |
540 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set format: %s\n", | |
541 snd_strerror(err)); | |
16308
41278ab73e9b
set the nearest number of channels, return(0) upon errors
henry
parents:
14849
diff
changeset
|
542 return(0); |
12465 | 543 } |
544 | |
16308
41278ab73e9b
set the nearest number of channels, return(0) upon errors
henry
parents:
14849
diff
changeset
|
545 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
|
546 &ao_data.channels)) < 0) |
12465 | 547 { |
548 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set channels: %s\n", | |
549 snd_strerror(err)); | |
16308
41278ab73e9b
set the nearest number of channels, return(0) upon errors
henry
parents:
14849
diff
changeset
|
550 return(0); |
12465 | 551 } |
552 | |
553 if ((err = snd_pcm_hw_params_set_rate_near(alsa_handler, alsa_hwparams, | |
554 &ao_data.samplerate, &dir)) < 0) | |
555 { | |
556 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set samplerate-2: %s\n", | |
557 snd_strerror(err)); | |
558 return(0); | |
559 } | |
560 | |
17570
401521ec0d61
This replaces the hardcoded numbers for the sample format widths with a
cladisch
parents:
17566
diff
changeset
|
561 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
|
562 bytes_per_sample *= ao_data.channels; |
401521ec0d61
This replaces the hardcoded numbers for the sample format widths with a
cladisch
parents:
17566
diff
changeset
|
563 ao_data.bps = ao_data.samplerate * bytes_per_sample; |
16309 | 564 |
12465 | 565 #ifdef BUFFERTIME |
566 { | |
567 int alsa_buffer_time = 500000; /* original 60 */ | |
568 int alsa_period_time; | |
569 alsa_period_time = alsa_buffer_time/4; | |
570 if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa_handler, alsa_hwparams, | |
571 &alsa_buffer_time, &dir)) < 0) | |
572 { | |
573 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set buffer time near: %s\n", | |
574 snd_strerror(err)); | |
575 return(0); | |
576 } else | |
577 alsa_buffer_time = err; | |
578 | |
579 if ((err = snd_pcm_hw_params_set_period_time_near(alsa_handler, alsa_hwparams, | |
580 &alsa_period_time, &dir)) < 0) | |
581 /* original: alsa_buffer_time/ao_data.bps */ | |
582 { | |
583 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set period time: %s\n", | |
584 snd_strerror(err)); | |
585 } | |
586 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: buffer_time: %d, period_time :%d\n", | |
587 alsa_buffer_time, err); | |
588 } | |
589 #endif//end SET_BUFFERTIME | |
590 | |
591 #ifdef SET_CHUNKSIZE | |
592 { | |
593 //set chunksize | |
594 dir=0; | |
595 if ((err = snd_pcm_hw_params_set_period_size_near(alsa_handler, alsa_hwparams, | |
596 &chunk_size, &dir)) < 0) | |
597 { | |
17366 | 598 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set periodsize(%ld): %s\n", |
12465 | 599 chunk_size, snd_strerror(err)); |
600 } | |
601 else { | |
17366 | 602 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set to %li\n", chunk_size); |
12465 | 603 } |
604 if ((err = snd_pcm_hw_params_set_periods_near(alsa_handler, alsa_hwparams, | |
605 &alsa_fragcount, &dir)) < 0) { | |
606 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set periods: %s\n", | |
607 snd_strerror(err)); | |
608 } | |
609 else { | |
610 mp_msg(MSGT_AO,MSGL_V,"alsa-init: fragcount=%i\n", alsa_fragcount); | |
611 } | |
612 } | |
613 #endif//end SET_CHUNKSIZE | |
614 | |
615 /* finally install hardware parameters */ | |
616 if ((err = snd_pcm_hw_params(alsa_handler, alsa_hwparams)) < 0) | |
617 { | |
618 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set hw-parameters: %s\n", | |
619 snd_strerror(err)); | |
620 } | |
621 // end setting hw-params | |
622 | |
623 | |
624 // gets buffersize for control | |
625 if ((err = snd_pcm_hw_params_get_buffer_size(alsa_hwparams, &bufsize)) < 0) | |
626 { | |
627 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to get buffersize: %s\n", snd_strerror(err)); | |
628 } | |
629 else { | |
630 ao_data.buffersize = bufsize * bytes_per_sample; | |
631 mp_msg(MSGT_AO,MSGL_V,"alsa-init: got buffersize=%i\n", ao_data.buffersize); | |
632 } | |
633 | |
634 // setting sw-params (only avail-min) if noblocking mode was choosed | |
635 if (ao_noblock) | |
636 { | |
637 | |
638 if ((err = snd_pcm_sw_params_current(alsa_handler, alsa_swparams)) < 0) | |
639 { | |
640 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to get parameters: %s\n", | |
641 snd_strerror(err)); | |
642 | |
643 } | |
644 | |
645 //set min available frames to consider pcm ready (4) | |
646 //increased for nonblock-mode should be set dynamically later | |
647 if ((err = snd_pcm_sw_params_set_avail_min(alsa_handler, alsa_swparams, 4)) < 0) | |
648 { | |
649 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set avail_min %s\n", | |
650 snd_strerror(err)); | |
651 } | |
652 | |
653 if ((err = snd_pcm_sw_params(alsa_handler, alsa_swparams)) < 0) | |
654 { | |
655 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to install sw-params\n"); | |
656 } | |
657 | |
658 bits_per_sample = snd_pcm_format_physical_width(alsa_format); | |
16309 | 659 bits_per_frame = bits_per_sample * ao_data.channels; |
12465 | 660 chunk_bytes = chunk_size * bits_per_frame / 8; |
661 | |
662 mp_msg(MSGT_AO,MSGL_V,"alsa-init: bits per sample (bps)=%i, bits per frame (bpf)=%i, chunk_bytes=%i\n",bits_per_sample,bits_per_frame,chunk_bytes);} | |
663 //end swparams | |
664 | |
665 mp_msg(MSGT_AO,MSGL_INFO,"alsa: %d Hz/%d channels/%d bpf/%d bytes buffer/%s\n", | |
666 ao_data.samplerate, ao_data.channels, bytes_per_sample, ao_data.buffersize, | |
667 snd_pcm_format_description(alsa_format)); | |
668 | |
669 } // end switch alsa_handler (spdif) | |
670 alsa_can_pause = snd_pcm_hw_params_can_pause(alsa_hwparams); | |
671 return(1); | |
672 } // end init | |
673 | |
674 | |
675 /* close audio device */ | |
676 static void uninit(int immed) | |
677 { | |
678 | |
679 if (alsa_handler) { | |
680 int err; | |
681 | |
14849
d313f591d1a4
aos should respect the immed uninit flag (quit immediatly vs waiting till file
reimar
parents:
14612
diff
changeset
|
682 if (!immed) |
d313f591d1a4
aos should respect the immed uninit flag (quit immediatly vs waiting till file
reimar
parents:
14612
diff
changeset
|
683 snd_pcm_drain(alsa_handler); |
d313f591d1a4
aos should respect the immed uninit flag (quit immediatly vs waiting till file
reimar
parents:
14612
diff
changeset
|
684 |
12465 | 685 if ((err = snd_pcm_close(alsa_handler)) < 0) |
686 { | |
687 mp_msg(MSGT_AO,MSGL_ERR,"alsa-uninit: pcm close error: %s\n", snd_strerror(err)); | |
688 return; | |
689 } | |
690 else { | |
691 alsa_handler = NULL; | |
692 mp_msg(MSGT_AO,MSGL_INFO,"alsa-uninit: pcm closed\n"); | |
693 } | |
694 } | |
695 else { | |
696 mp_msg(MSGT_AO,MSGL_ERR,"alsa-uninit: no handler defined!\n"); | |
697 } | |
698 } | |
699 | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
700 static void audio_pause(void) |
12465 | 701 { |
702 int err; | |
703 | |
704 if (alsa_can_pause) { | |
705 if ((err = snd_pcm_pause(alsa_handler, 1)) < 0) | |
706 { | |
707 mp_msg(MSGT_AO,MSGL_ERR,"alsa-pause: pcm pause error: %s\n", snd_strerror(err)); | |
708 return; | |
709 } | |
710 mp_msg(MSGT_AO,MSGL_V,"alsa-pause: pause supported by hardware\n"); | |
711 } else { | |
712 if ((err = snd_pcm_drop(alsa_handler)) < 0) | |
713 { | |
714 mp_msg(MSGT_AO,MSGL_ERR,"alsa-pause: pcm drop error: %s\n", snd_strerror(err)); | |
715 return; | |
716 } | |
717 } | |
718 } | |
719 | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
720 static void audio_resume(void) |
12465 | 721 { |
722 int err; | |
723 | |
724 if (alsa_can_pause) { | |
725 if ((err = snd_pcm_pause(alsa_handler, 0)) < 0) | |
726 { | |
727 mp_msg(MSGT_AO,MSGL_ERR,"alsa-resume: pcm resume error: %s\n", snd_strerror(err)); | |
728 return; | |
729 } | |
730 mp_msg(MSGT_AO,MSGL_V,"alsa-resume: resume supported by hardware\n"); | |
731 } else { | |
732 if ((err = snd_pcm_prepare(alsa_handler)) < 0) | |
733 { | |
734 mp_msg(MSGT_AO,MSGL_ERR,"alsa-resume: pcm prepare error: %s\n", snd_strerror(err)); | |
735 return; | |
736 } | |
737 } | |
738 } | |
739 | |
740 /* stop playing and empty buffers (for seeking/pause) */ | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
741 static void reset(void) |
12465 | 742 { |
743 int err; | |
744 | |
745 if ((err = snd_pcm_drop(alsa_handler)) < 0) | |
746 { | |
747 mp_msg(MSGT_AO,MSGL_ERR,"alsa-reset: pcm drop error: %s\n", snd_strerror(err)); | |
748 return; | |
749 } | |
750 if ((err = snd_pcm_prepare(alsa_handler)) < 0) | |
751 { | |
752 mp_msg(MSGT_AO,MSGL_ERR,"alsa-reset: pcm prepare error: %s\n", snd_strerror(err)); | |
753 return; | |
754 } | |
755 return; | |
756 } | |
757 | |
758 #ifdef USE_POLL | |
759 static int wait_for_poll(snd_pcm_t *handle, struct pollfd *ufds, unsigned int count) | |
760 { | |
761 unsigned short revents; | |
762 | |
763 while (1) { | |
764 poll(ufds, count, -1); | |
765 snd_pcm_poll_descriptors_revents(handle, ufds, count, &revents); | |
766 if (revents & POLLERR) | |
767 return -EIO; | |
768 if (revents & POLLOUT) | |
769 return 0; | |
770 } | |
771 } | |
772 #endif | |
773 | |
774 #ifndef timersub | |
775 #define timersub(a, b, result) \ | |
776 do { \ | |
777 (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ | |
778 (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \ | |
779 if ((result)->tv_usec < 0) { \ | |
780 --(result)->tv_sec; \ | |
781 (result)->tv_usec += 1000000; \ | |
782 } \ | |
783 } while (0) | |
784 #endif | |
785 | |
786 /* I/O error handler */ | |
787 static int xrun(u_char *str_mode) | |
788 { | |
789 int err; | |
790 snd_pcm_status_t *status; | |
791 | |
792 snd_pcm_status_alloca(&status); | |
793 | |
794 if ((err = snd_pcm_status(alsa_handler, status))<0) { | |
795 mp_msg(MSGT_AO,MSGL_ERR,"status error: %s", snd_strerror(err)); | |
796 return(0); | |
797 } | |
798 | |
799 if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) { | |
800 struct timeval now, diff, tstamp; | |
801 gettimeofday(&now, 0); | |
802 snd_pcm_status_get_trigger_tstamp(status, &tstamp); | |
803 timersub(&now, &tstamp, &diff); | |
804 mp_msg(MSGT_AO,MSGL_INFO,"alsa-%s: xrun of at least %.3f msecs. resetting stream\n", | |
805 str_mode, | |
806 diff.tv_sec * 1000 + diff.tv_usec / 1000.0); | |
807 } | |
808 | |
809 if ((err = snd_pcm_prepare(alsa_handler))<0) { | |
810 mp_msg(MSGT_AO,MSGL_ERR,"xrun: prepare error: %s", snd_strerror(err)); | |
811 return(0); | |
812 } | |
813 | |
814 return(1); /* ok, data should be accepted again */ | |
815 } | |
816 | |
817 static int play_normal(void* data, int len); | |
818 static int play_mmap(void* data, int len); | |
819 | |
820 static int play(void* data, int len, int flags) | |
821 { | |
822 int result; | |
823 if (ao_mmap) | |
824 result = play_mmap(data, len); | |
825 else | |
826 result = play_normal(data, len); | |
827 | |
828 return result; | |
829 } | |
830 | |
831 /* | |
832 plays 'len' bytes of 'data' | |
833 returns: number of bytes played | |
834 modified last at 29.06.02 by jp | |
835 thanxs for marius <marius@rospot.com> for giving us the light ;) | |
836 */ | |
837 | |
838 static int play_normal(void* data, int len) | |
839 { | |
840 | |
841 //bytes_per_sample is always 4 for 2 chn S16_LE | |
842 int num_frames = len / bytes_per_sample; | |
843 char *output_samples = (char *)data; | |
844 snd_pcm_sframes_t res = 0; | |
845 | |
846 //mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: frames=%i, len=%i\n",num_frames,len); | |
847 | |
848 if (!alsa_handler) { | |
849 mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: device configuration error"); | |
850 return 0; | |
851 } | |
852 | |
853 while (num_frames > 0) { | |
854 | |
855 res = snd_pcm_writei(alsa_handler, (void *)output_samples, num_frames); | |
856 | |
857 if (res == -EAGAIN) { | |
858 snd_pcm_wait(alsa_handler, 1000); | |
859 } | |
860 else if (res == -EPIPE) { /* underrun */ | |
861 if (xrun("play") <= 0) { | |
862 mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: xrun reset error"); | |
863 return(0); | |
864 } | |
865 } | |
866 else if (res == -ESTRPIPE) { /* suspend */ | |
867 mp_msg(MSGT_AO,MSGL_INFO,"alsa-play: pcm in suspend mode. trying to resume\n"); | |
868 while ((res = snd_pcm_resume(alsa_handler)) == -EAGAIN) | |
869 sleep(1); | |
870 } | |
871 else if (res < 0) { | |
872 mp_msg(MSGT_AO,MSGL_INFO,"alsa-play: unknown status, trying to reset soundcard\n"); | |
873 if ((res = snd_pcm_prepare(alsa_handler)) < 0) { | |
874 mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: snd prepare error"); | |
875 return(0); | |
876 break; | |
877 } | |
878 } | |
879 | |
880 if (res > 0) { | |
881 | |
882 /* output_samples += ao_data.channels * res; */ | |
883 output_samples += res * bytes_per_sample; | |
884 | |
885 num_frames -= res; | |
886 } | |
887 | |
888 } //end while | |
889 | |
890 if (res < 0) { | |
891 mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: write error %s", snd_strerror(res)); | |
892 return 0; | |
893 } | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
894 return len - len % bytes_per_sample; |
12465 | 895 } |
896 | |
897 /* mmap-mode mainly based on descriptions by Joshua Haberman <joshua@haberman.com> | |
898 * 'An overview of the ALSA API' http://people.debian.org/~joshua/x66.html | |
899 * and some help by Paul Davis <pbd@op.net> */ | |
900 | |
901 static int play_mmap(void* data, int len) | |
902 { | |
903 snd_pcm_sframes_t commitres, frames_available; | |
904 snd_pcm_uframes_t frames_transmit, size, offset; | |
905 const snd_pcm_channel_area_t *area; | |
906 void *outbuffer; | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
907 int result; |
12465 | 908 |
909 #ifdef USE_POLL //seems not really be needed | |
910 struct pollfd *ufds; | |
911 int count; | |
912 | |
913 count = snd_pcm_poll_descriptors_count (alsa_handler); | |
914 ufds = malloc(sizeof(struct pollfd) * count); | |
915 snd_pcm_poll_descriptors(alsa_handler, ufds, count); | |
916 | |
917 //first wait_for_poll | |
918 if (err = (wait_for_poll(alsa_handler, ufds, count) < 0)) { | |
919 if (snd_pcm_state(alsa_handler) == SND_PCM_STATE_XRUN || | |
920 snd_pcm_state(alsa_handler) == SND_PCM_STATE_SUSPENDED) { | |
921 xrun("play"); | |
922 } | |
923 } | |
924 #endif | |
925 | |
926 outbuffer = alloca(ao_data.buffersize); | |
927 | |
928 //don't trust get_space() ;) | |
929 frames_available = snd_pcm_avail_update(alsa_handler) * bytes_per_sample; | |
930 if (frames_available < 0) | |
931 xrun("play"); | |
932 | |
933 if (frames_available < 4) { | |
934 if (first) { | |
935 first = 0; | |
936 snd_pcm_start(alsa_handler); | |
937 } | |
938 else { //FIXME should break and return 0? | |
939 snd_pcm_wait(alsa_handler, -1); | |
940 first = 1; | |
941 } | |
942 } | |
943 | |
944 /* len is simply the available bufferspace got by get_space() | |
945 * but real avail_buffer in frames is ab/bytes_per_sample */ | |
946 size = len / bytes_per_sample; | |
947 | |
948 //mp_msg(MSGT_AO,MSGL_V,"len: %i size %i, f_avail %i, bps %i ...\n", len, size, frames_available, bytes_per_sample); | |
949 | |
950 frames_transmit = size; | |
951 | |
952 /* prepare areas and set sw-pointers | |
953 * frames_transmit returns the real available buffer-size | |
954 * sometimes != frames_available cause of ringbuffer 'emulation' */ | |
955 snd_pcm_mmap_begin(alsa_handler, &area, &offset, &frames_transmit); | |
956 | |
957 /* this is specific to interleaved streams (or non-interleaved | |
958 * streams with only one channel) */ | |
959 outbuffer = ((char *) area->addr + (area->first + area->step * offset) / 8); //8 | |
960 | |
961 //write data | |
962 memcpy(outbuffer, data, (frames_transmit * bytes_per_sample)); | |
963 | |
964 commitres = snd_pcm_mmap_commit(alsa_handler, offset, frames_transmit); | |
965 | |
966 if (commitres < 0 || commitres != frames_transmit) { | |
967 if (snd_pcm_state(alsa_handler) == SND_PCM_STATE_XRUN || | |
968 snd_pcm_state(alsa_handler) == SND_PCM_STATE_SUSPENDED) { | |
969 xrun("play"); | |
970 } | |
971 } | |
972 | |
973 //mp_msg(MSGT_AO,MSGL_V,"mmap ft: %i, cres: %i\n", frames_transmit, commitres); | |
974 | |
975 /* err = snd_pcm_area_copy(&area, offset, &data, offset, len, alsa_format); */ | |
976 /* if (err < 0) { */ | |
977 /* mp_msg(MSGT_AO,MSGL_ERR,"area-copy-error\n"); */ | |
978 /* return 0; */ | |
979 /* } */ | |
980 | |
981 | |
982 //calculate written frames! | |
983 result = commitres * bytes_per_sample; | |
984 | |
985 | |
986 /* if (verbose) { */ | |
987 /* if (len == result) */ | |
988 /* mp_msg(MSGT_AO,MSGL_V,"result: %i, frames written: %i ...\n", result, frames_transmit); */ | |
989 /* else */ | |
990 /* mp_msg(MSGT_AO,MSGL_V,"result: %i, frames written: %i, result != len ...\n", result, frames_transmit); */ | |
991 /* } */ | |
992 | |
993 //mplayer doesn't like -result | |
994 if (result < 0) | |
995 result = 0; | |
996 | |
997 #ifdef USE_POLL | |
998 free(ufds); | |
999 #endif | |
1000 | |
1001 return result; | |
1002 } | |
1003 | |
1004 /* how many byes are free in the buffer */ | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
1005 static int get_space(void) |
12465 | 1006 { |
1007 snd_pcm_status_t *status; | |
1008 int ret; | |
1009 | |
12747 | 1010 snd_pcm_status_alloca(&status); |
12465 | 1011 |
1012 if ((ret = snd_pcm_status(alsa_handler, status)) < 0) | |
1013 { | |
1014 mp_msg(MSGT_AO,MSGL_ERR,"alsa-space: cannot get pcm status: %s\n", snd_strerror(ret)); | |
1015 return(0); | |
1016 } | |
1017 | |
17572
580dc69d69bf
Fix get_space(): we don't need to differentiate between the various PCM
cladisch
parents:
17571
diff
changeset
|
1018 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
|
1019 if (ret > MAX_OUTBURST) |
580dc69d69bf
Fix get_space(): we don't need to differentiate between the various PCM
cladisch
parents:
17571
diff
changeset
|
1020 ret = MAX_OUTBURST; |
12465 | 1021 return(ret); |
1022 } | |
1023 | |
1024 /* delay in seconds between first and last sample in buffer */ | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
1025 static float get_delay(void) |
12465 | 1026 { |
1027 if (alsa_handler) { | |
17573
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
1028 snd_pcm_sframes_t delay; |
12465 | 1029 |
17573
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
1030 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
|
1031 return 0; |
12465 | 1032 |
17573
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
1033 if (delay < 0) { |
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
1034 /* 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
|
1035 #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
|
1036 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
|
1037 #endif |
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
1038 delay = 0; |
12465 | 1039 } |
17573
8921544f4114
Simplify get_delay(): we don't need to get the complete PCM status but
cladisch
parents:
17572
diff
changeset
|
1040 return (float)delay / (float)ao_data.samplerate; |
12465 | 1041 } else { |
1042 return(0); | |
1043 } | |
1044 } |