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