Mercurial > mplayer.hg
annotate libao2/ao_alsa.c @ 13519:6bf63a7524d8
Sync with 1.759:
Documentation of x264 3-pass mode, and fixes on lavc's *_mask
options, pointed out by Jiri Heryan
author | gpoirier |
---|---|
date | Fri, 01 Oct 2004 15:53:09 +0000 |
parents | 2df414ae2d2a |
children | 07dc40f25068 |
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 | |
408 /* switch for spdif | |
409 * sets opening sequence for SPDIF | |
410 * sets also the playback and other switches 'on the fly' | |
411 * while opening the abstract alias for the spdif subdevice | |
412 * 'iec958' | |
413 */ | |
414 if (format == AFMT_AC3) { | |
415 unsigned char s[4]; | |
416 | |
417 switch (channels) { | |
418 case 1: | |
419 case 2: | |
420 | |
421 s[0] = IEC958_AES0_NONAUDIO | | |
422 IEC958_AES0_CON_EMPHASIS_NONE; | |
423 s[1] = IEC958_AES1_CON_ORIGINAL | | |
424 IEC958_AES1_CON_PCM_CODER; | |
425 s[2] = 0; | |
426 s[3] = IEC958_AES3_CON_FS_48000; | |
427 | |
12747 | 428 snprintf(alsa_device, ALSA_DEVICE_SIZE, |
429 "iec958:AES0=0x%x,AES1=0x%x,AES2=0x%x,AES3=0x%x", | |
430 s[0], s[1], s[2], s[3]); | |
12465 | 431 |
12747 | 432 mp_msg(MSGT_AO,MSGL_V,"alsa-spdif-init: playing AC3, %i channels\n", channels); |
433 device_set = 1; | |
12465 | 434 break; |
435 case 4: | |
12747 | 436 strncpy(alsa_device, "surround40", ALSA_DEVICE_SIZE); |
437 device_set = 1; | |
12465 | 438 break; |
439 | |
440 case 6: | |
12747 | 441 strncpy(alsa_device, "surround51", ALSA_DEVICE_SIZE); |
442 device_set = 1; | |
12465 | 443 break; |
444 | |
445 default: | |
446 mp_msg(MSGT_AO,MSGL_ERR,"alsa-spdif-init: %d channels are not supported\n", channels); | |
447 } | |
448 } | |
449 | |
12747 | 450 if (!device_set) |
12465 | 451 { |
452 int tmp_device, tmp_subdevice, err; | |
453 | |
12747 | 454 snd_pcm_info_alloca(&alsa_info); |
12465 | 455 |
456 if ((tmp_device = snd_pcm_info_get_device(alsa_info)) < 0) | |
457 { | |
458 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: can't get device\n"); | |
459 } | |
460 | |
461 if ((tmp_subdevice = snd_pcm_info_get_subdevice(alsa_info)) < 0) | |
462 { | |
463 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: can't get subdevice\n"); | |
464 } | |
465 | |
466 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: got device=%i, subdevice=%i\n", | |
467 tmp_device, tmp_subdevice); | |
468 | |
469 //we are setting here device to default cause it could be configured by the user | |
470 //if its not set by the user, it defaults to hw:0,0 | |
471 if ((err = snprintf(alsa_device, ALSA_DEVICE_SIZE, "default")) <= 0) | |
472 { | |
473 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: can't write device-id\n"); | |
474 } | |
475 | |
476 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: %d soundcard%s found, using: %s\n", cards+1,(cards >= 0) ? "" : "s", alsa_device); | |
477 } else { | |
478 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: soundcard set to %s\n", alsa_device); | |
479 } | |
480 | |
481 //setting modes for block or nonblock-mode | |
482 if (ao_noblock) { | |
483 open_mode = SND_PCM_NONBLOCK; | |
484 set_block_mode = 1; | |
485 str_block_mode = "nonblock-mode"; | |
486 } | |
487 else { | |
488 open_mode = 0; | |
489 set_block_mode = 0; | |
490 str_block_mode = "block-mode"; | |
491 } | |
492 | |
493 //sets buff/chunksize if its set manually | |
494 if (ao_data.buffersize) { | |
495 switch (ao_data.buffersize) | |
496 { | |
497 case 1: | |
498 alsa_fragcount = 16; | |
499 chunk_size = 512; | |
500 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 8192\n"); | |
501 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 512\n"); | |
502 break; | |
503 case 2: | |
504 alsa_fragcount = 8; | |
505 chunk_size = 1024; | |
506 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 8192\n"); | |
507 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 1024\n"); | |
508 break; | |
509 case 3: | |
510 alsa_fragcount = 32; | |
511 chunk_size = 512; | |
512 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 16384\n"); | |
513 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 512\n"); | |
514 break; | |
515 case 4: | |
516 alsa_fragcount = 16; | |
517 chunk_size = 1024; | |
518 mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 16384\n"); | |
519 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 1024\n"); | |
520 break; | |
521 default: | |
522 alsa_fragcount = 16; | |
523 if (ao_mmap) | |
524 chunk_size = 512; | |
525 else | |
526 chunk_size = 1024; | |
527 break; | |
528 } | |
529 } | |
530 | |
531 if (!alsa_handler) { | |
532 //modes = 0, SND_PCM_NONBLOCK, SND_PCM_ASYNC | |
533 if ((err = snd_pcm_open(&alsa_handler, alsa_device, SND_PCM_STREAM_PLAYBACK, open_mode)) < 0) | |
534 { | |
535 if (err != -EBUSY && ao_noblock) { | |
536 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: open in nonblock-mode failed, trying to open in block-mode\n"); | |
537 if ((err = snd_pcm_open(&alsa_handler, alsa_device, SND_PCM_STREAM_PLAYBACK, 0)) < 0) { | |
538 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: playback open error: %s\n", snd_strerror(err)); | |
539 return(0); | |
540 } else { | |
541 set_block_mode = 0; | |
542 str_block_mode = "block-mode"; | |
543 } | |
544 } else { | |
545 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: playback open error: %s\n", snd_strerror(err)); | |
546 return(0); | |
547 } | |
548 } | |
549 | |
550 if ((err = snd_pcm_nonblock(alsa_handler, set_block_mode)) < 0) { | |
551 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: error set block-mode %s\n", snd_strerror(err)); | |
552 } else { | |
553 mp_msg(MSGT_AO,MSGL_V,"alsa-init: pcm opend in %s\n", str_block_mode); | |
554 } | |
555 | |
556 snd_pcm_hw_params_alloca(&alsa_hwparams); | |
557 snd_pcm_sw_params_alloca(&alsa_swparams); | |
558 | |
559 // setting hw-parameters | |
560 if ((err = snd_pcm_hw_params_any(alsa_handler, alsa_hwparams)) < 0) | |
561 { | |
562 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to get initial parameters: %s\n", | |
563 snd_strerror(err)); | |
564 return(0); | |
565 } | |
566 | |
567 if (ao_mmap) { | |
568 snd_pcm_access_mask_t *mask = alloca(snd_pcm_access_mask_sizeof()); | |
569 snd_pcm_access_mask_none(mask); | |
570 snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); | |
571 snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); | |
572 snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_COMPLEX); | |
573 err = snd_pcm_hw_params_set_access_mask(alsa_handler, alsa_hwparams, mask); | |
574 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: mmap set\n"); | |
575 } else { | |
576 err = snd_pcm_hw_params_set_access(alsa_handler, alsa_hwparams, | |
577 SND_PCM_ACCESS_RW_INTERLEAVED); | |
578 } | |
579 if (err < 0) { | |
580 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set access type: %s\n", | |
581 snd_strerror(err)); | |
582 return (0); | |
583 } | |
584 | |
585 /* workaround for nonsupported formats | |
586 sets default format to S16_LE if the given formats aren't supported */ | |
587 if ((err = snd_pcm_hw_params_test_format(alsa_handler, alsa_hwparams, | |
588 alsa_format)) < 0) | |
589 { | |
590 mp_msg(MSGT_AO,MSGL_INFO, | |
591 "alsa-init: format %s are not supported by hardware, trying default\n", | |
592 audio_out_format_name(format)); | |
593 alsa_format = SND_PCM_FORMAT_S16_LE; | |
594 ao_data.format = AFMT_S16_LE; | |
595 ao_data.bps = channels * rate_hz * 2; | |
596 } | |
597 | |
598 bytes_per_sample = ao_data.bps / ao_data.samplerate; //it should be here | |
599 | |
600 | |
601 if ((err = snd_pcm_hw_params_set_format(alsa_handler, alsa_hwparams, | |
602 alsa_format)) < 0) | |
603 { | |
604 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set format: %s\n", | |
605 snd_strerror(err)); | |
606 } | |
607 | |
608 if ((err = snd_pcm_hw_params_set_channels(alsa_handler, alsa_hwparams, | |
609 ao_data.channels)) < 0) | |
610 { | |
611 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set channels: %s\n", | |
612 snd_strerror(err)); | |
613 } | |
614 | |
615 if ((err = snd_pcm_hw_params_set_rate_near(alsa_handler, alsa_hwparams, | |
616 &ao_data.samplerate, &dir)) < 0) | |
617 { | |
618 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set samplerate-2: %s\n", | |
619 snd_strerror(err)); | |
620 return(0); | |
621 } | |
622 | |
623 #ifdef BUFFERTIME | |
624 { | |
625 int alsa_buffer_time = 500000; /* original 60 */ | |
626 int alsa_period_time; | |
627 alsa_period_time = alsa_buffer_time/4; | |
628 if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa_handler, alsa_hwparams, | |
629 &alsa_buffer_time, &dir)) < 0) | |
630 { | |
631 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set buffer time near: %s\n", | |
632 snd_strerror(err)); | |
633 return(0); | |
634 } else | |
635 alsa_buffer_time = err; | |
636 | |
637 if ((err = snd_pcm_hw_params_set_period_time_near(alsa_handler, alsa_hwparams, | |
638 &alsa_period_time, &dir)) < 0) | |
639 /* original: alsa_buffer_time/ao_data.bps */ | |
640 { | |
641 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set period time: %s\n", | |
642 snd_strerror(err)); | |
643 } | |
644 mp_msg(MSGT_AO,MSGL_INFO,"alsa-init: buffer_time: %d, period_time :%d\n", | |
645 alsa_buffer_time, err); | |
646 } | |
647 #endif//end SET_BUFFERTIME | |
648 | |
649 #ifdef SET_CHUNKSIZE | |
650 { | |
651 //set chunksize | |
652 dir=0; | |
653 if ((err = snd_pcm_hw_params_set_period_size_near(alsa_handler, alsa_hwparams, | |
654 &chunk_size, &dir)) < 0) | |
655 { | |
656 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set periodsize(%d): %s\n", | |
657 chunk_size, snd_strerror(err)); | |
658 } | |
659 else { | |
660 mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set to %i\n", chunk_size); | |
661 } | |
662 if ((err = snd_pcm_hw_params_set_periods_near(alsa_handler, alsa_hwparams, | |
663 &alsa_fragcount, &dir)) < 0) { | |
664 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set periods: %s\n", | |
665 snd_strerror(err)); | |
666 } | |
667 else { | |
668 mp_msg(MSGT_AO,MSGL_V,"alsa-init: fragcount=%i\n", alsa_fragcount); | |
669 } | |
670 } | |
671 #endif//end SET_CHUNKSIZE | |
672 | |
673 /* finally install hardware parameters */ | |
674 if ((err = snd_pcm_hw_params(alsa_handler, alsa_hwparams)) < 0) | |
675 { | |
676 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set hw-parameters: %s\n", | |
677 snd_strerror(err)); | |
678 } | |
679 // end setting hw-params | |
680 | |
681 | |
682 // gets buffersize for control | |
683 if ((err = snd_pcm_hw_params_get_buffer_size(alsa_hwparams, &bufsize)) < 0) | |
684 { | |
685 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to get buffersize: %s\n", snd_strerror(err)); | |
686 } | |
687 else { | |
688 ao_data.buffersize = bufsize * bytes_per_sample; | |
689 mp_msg(MSGT_AO,MSGL_V,"alsa-init: got buffersize=%i\n", ao_data.buffersize); | |
690 } | |
691 | |
692 // setting sw-params (only avail-min) if noblocking mode was choosed | |
693 if (ao_noblock) | |
694 { | |
695 | |
696 if ((err = snd_pcm_sw_params_current(alsa_handler, alsa_swparams)) < 0) | |
697 { | |
698 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to get parameters: %s\n", | |
699 snd_strerror(err)); | |
700 | |
701 } | |
702 | |
703 //set min available frames to consider pcm ready (4) | |
704 //increased for nonblock-mode should be set dynamically later | |
705 if ((err = snd_pcm_sw_params_set_avail_min(alsa_handler, alsa_swparams, 4)) < 0) | |
706 { | |
707 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set avail_min %s\n", | |
708 snd_strerror(err)); | |
709 } | |
710 | |
711 if ((err = snd_pcm_sw_params(alsa_handler, alsa_swparams)) < 0) | |
712 { | |
713 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to install sw-params\n"); | |
714 } | |
715 | |
716 bits_per_sample = snd_pcm_format_physical_width(alsa_format); | |
717 bits_per_frame = bits_per_sample * channels; | |
718 chunk_bytes = chunk_size * bits_per_frame / 8; | |
719 | |
720 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);} | |
721 //end swparams | |
722 | |
723 if ((err = snd_pcm_prepare(alsa_handler)) < 0) | |
724 { | |
725 mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: pcm prepare error: %s\n", snd_strerror(err)); | |
726 } | |
727 | |
728 mp_msg(MSGT_AO,MSGL_INFO,"alsa: %d Hz/%d channels/%d bpf/%d bytes buffer/%s\n", | |
729 ao_data.samplerate, ao_data.channels, bytes_per_sample, ao_data.buffersize, | |
730 snd_pcm_format_description(alsa_format)); | |
731 | |
732 } // end switch alsa_handler (spdif) | |
733 alsa_can_pause = snd_pcm_hw_params_can_pause(alsa_hwparams); | |
734 return(1); | |
735 } // end init | |
736 | |
737 | |
738 /* close audio device */ | |
739 static void uninit(int immed) | |
740 { | |
741 | |
742 if (alsa_handler) { | |
743 int err; | |
744 | |
745 if (!ao_noblock) { | |
746 if ((err = snd_pcm_drop(alsa_handler)) < 0) | |
747 { | |
748 mp_msg(MSGT_AO,MSGL_ERR,"alsa-uninit: pcm drop error: %s\n", snd_strerror(err)); | |
749 return; | |
750 } | |
751 } | |
752 | |
753 if ((err = snd_pcm_close(alsa_handler)) < 0) | |
754 { | |
755 mp_msg(MSGT_AO,MSGL_ERR,"alsa-uninit: pcm close error: %s\n", snd_strerror(err)); | |
756 return; | |
757 } | |
758 else { | |
759 alsa_handler = NULL; | |
760 mp_msg(MSGT_AO,MSGL_INFO,"alsa-uninit: pcm closed\n"); | |
761 } | |
762 } | |
763 else { | |
764 mp_msg(MSGT_AO,MSGL_ERR,"alsa-uninit: no handler defined!\n"); | |
765 } | |
766 } | |
767 | |
768 static void audio_pause() | |
769 { | |
770 int err; | |
771 | |
772 if (alsa_can_pause) { | |
773 if ((err = snd_pcm_pause(alsa_handler, 1)) < 0) | |
774 { | |
775 mp_msg(MSGT_AO,MSGL_ERR,"alsa-pause: pcm pause error: %s\n", snd_strerror(err)); | |
776 return; | |
777 } | |
778 mp_msg(MSGT_AO,MSGL_V,"alsa-pause: pause supported by hardware\n"); | |
779 } else { | |
780 if ((err = snd_pcm_drop(alsa_handler)) < 0) | |
781 { | |
782 mp_msg(MSGT_AO,MSGL_ERR,"alsa-pause: pcm drop error: %s\n", snd_strerror(err)); | |
783 return; | |
784 } | |
785 } | |
786 } | |
787 | |
788 static void audio_resume() | |
789 { | |
790 int err; | |
791 | |
792 if (alsa_can_pause) { | |
793 if ((err = snd_pcm_pause(alsa_handler, 0)) < 0) | |
794 { | |
795 mp_msg(MSGT_AO,MSGL_ERR,"alsa-resume: pcm resume error: %s\n", snd_strerror(err)); | |
796 return; | |
797 } | |
798 mp_msg(MSGT_AO,MSGL_V,"alsa-resume: resume supported by hardware\n"); | |
799 } else { | |
800 if ((err = snd_pcm_prepare(alsa_handler)) < 0) | |
801 { | |
802 mp_msg(MSGT_AO,MSGL_ERR,"alsa-resume: pcm prepare error: %s\n", snd_strerror(err)); | |
803 return; | |
804 } | |
805 } | |
806 } | |
807 | |
808 /* stop playing and empty buffers (for seeking/pause) */ | |
809 static void reset() | |
810 { | |
811 int err; | |
812 | |
813 if ((err = snd_pcm_drop(alsa_handler)) < 0) | |
814 { | |
815 mp_msg(MSGT_AO,MSGL_ERR,"alsa-reset: pcm drop error: %s\n", snd_strerror(err)); | |
816 return; | |
817 } | |
818 if ((err = snd_pcm_prepare(alsa_handler)) < 0) | |
819 { | |
820 mp_msg(MSGT_AO,MSGL_ERR,"alsa-reset: pcm prepare error: %s\n", snd_strerror(err)); | |
821 return; | |
822 } | |
823 return; | |
824 } | |
825 | |
826 #ifdef USE_POLL | |
827 static int wait_for_poll(snd_pcm_t *handle, struct pollfd *ufds, unsigned int count) | |
828 { | |
829 unsigned short revents; | |
830 | |
831 while (1) { | |
832 poll(ufds, count, -1); | |
833 snd_pcm_poll_descriptors_revents(handle, ufds, count, &revents); | |
834 if (revents & POLLERR) | |
835 return -EIO; | |
836 if (revents & POLLOUT) | |
837 return 0; | |
838 } | |
839 } | |
840 #endif | |
841 | |
842 #ifndef timersub | |
843 #define timersub(a, b, result) \ | |
844 do { \ | |
845 (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ | |
846 (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \ | |
847 if ((result)->tv_usec < 0) { \ | |
848 --(result)->tv_sec; \ | |
849 (result)->tv_usec += 1000000; \ | |
850 } \ | |
851 } while (0) | |
852 #endif | |
853 | |
854 /* I/O error handler */ | |
855 static int xrun(u_char *str_mode) | |
856 { | |
857 int err; | |
858 snd_pcm_status_t *status; | |
859 | |
860 snd_pcm_status_alloca(&status); | |
861 | |
862 if ((err = snd_pcm_status(alsa_handler, status))<0) { | |
863 mp_msg(MSGT_AO,MSGL_ERR,"status error: %s", snd_strerror(err)); | |
864 return(0); | |
865 } | |
866 | |
867 if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) { | |
868 struct timeval now, diff, tstamp; | |
869 gettimeofday(&now, 0); | |
870 snd_pcm_status_get_trigger_tstamp(status, &tstamp); | |
871 timersub(&now, &tstamp, &diff); | |
872 mp_msg(MSGT_AO,MSGL_INFO,"alsa-%s: xrun of at least %.3f msecs. resetting stream\n", | |
873 str_mode, | |
874 diff.tv_sec * 1000 + diff.tv_usec / 1000.0); | |
875 } | |
876 | |
877 if ((err = snd_pcm_prepare(alsa_handler))<0) { | |
878 mp_msg(MSGT_AO,MSGL_ERR,"xrun: prepare error: %s", snd_strerror(err)); | |
879 return(0); | |
880 } | |
881 | |
882 return(1); /* ok, data should be accepted again */ | |
883 } | |
884 | |
885 static int play_normal(void* data, int len); | |
886 static int play_mmap(void* data, int len); | |
887 | |
888 static int play(void* data, int len, int flags) | |
889 { | |
890 int result; | |
891 if (ao_mmap) | |
892 result = play_mmap(data, len); | |
893 else | |
894 result = play_normal(data, len); | |
895 | |
896 return result; | |
897 } | |
898 | |
899 /* | |
900 plays 'len' bytes of 'data' | |
901 returns: number of bytes played | |
902 modified last at 29.06.02 by jp | |
903 thanxs for marius <marius@rospot.com> for giving us the light ;) | |
904 */ | |
905 | |
906 static int play_normal(void* data, int len) | |
907 { | |
908 | |
909 //bytes_per_sample is always 4 for 2 chn S16_LE | |
910 int num_frames = len / bytes_per_sample; | |
911 char *output_samples = (char *)data; | |
912 snd_pcm_sframes_t res = 0; | |
913 | |
914 //mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: frames=%i, len=%i\n",num_frames,len); | |
915 | |
916 if (!alsa_handler) { | |
917 mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: device configuration error"); | |
918 return 0; | |
919 } | |
920 | |
921 while (num_frames > 0) { | |
922 | |
923 res = snd_pcm_writei(alsa_handler, (void *)output_samples, num_frames); | |
924 | |
925 if (res == -EAGAIN) { | |
926 snd_pcm_wait(alsa_handler, 1000); | |
927 } | |
928 else if (res == -EPIPE) { /* underrun */ | |
929 if (xrun("play") <= 0) { | |
930 mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: xrun reset error"); | |
931 return(0); | |
932 } | |
933 } | |
934 else if (res == -ESTRPIPE) { /* suspend */ | |
935 mp_msg(MSGT_AO,MSGL_INFO,"alsa-play: pcm in suspend mode. trying to resume\n"); | |
936 while ((res = snd_pcm_resume(alsa_handler)) == -EAGAIN) | |
937 sleep(1); | |
938 } | |
939 else if (res < 0) { | |
940 mp_msg(MSGT_AO,MSGL_INFO,"alsa-play: unknown status, trying to reset soundcard\n"); | |
941 if ((res = snd_pcm_prepare(alsa_handler)) < 0) { | |
942 mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: snd prepare error"); | |
943 return(0); | |
944 break; | |
945 } | |
946 } | |
947 | |
948 if (res > 0) { | |
949 | |
950 /* output_samples += ao_data.channels * res; */ | |
951 output_samples += res * bytes_per_sample; | |
952 | |
953 num_frames -= res; | |
954 } | |
955 | |
956 } //end while | |
957 | |
958 if (res < 0) { | |
959 mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: write error %s", snd_strerror(res)); | |
960 return 0; | |
961 } | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
962 return len - len % bytes_per_sample; |
12465 | 963 } |
964 | |
965 /* mmap-mode mainly based on descriptions by Joshua Haberman <joshua@haberman.com> | |
966 * 'An overview of the ALSA API' http://people.debian.org/~joshua/x66.html | |
967 * and some help by Paul Davis <pbd@op.net> */ | |
968 | |
969 static int play_mmap(void* data, int len) | |
970 { | |
971 snd_pcm_sframes_t commitres, frames_available; | |
972 snd_pcm_uframes_t frames_transmit, size, offset; | |
973 const snd_pcm_channel_area_t *area; | |
974 void *outbuffer; | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
975 int result; |
12465 | 976 |
977 #ifdef USE_POLL //seems not really be needed | |
978 struct pollfd *ufds; | |
979 int count; | |
980 | |
981 count = snd_pcm_poll_descriptors_count (alsa_handler); | |
982 ufds = malloc(sizeof(struct pollfd) * count); | |
983 snd_pcm_poll_descriptors(alsa_handler, ufds, count); | |
984 | |
985 //first wait_for_poll | |
986 if (err = (wait_for_poll(alsa_handler, ufds, count) < 0)) { | |
987 if (snd_pcm_state(alsa_handler) == SND_PCM_STATE_XRUN || | |
988 snd_pcm_state(alsa_handler) == SND_PCM_STATE_SUSPENDED) { | |
989 xrun("play"); | |
990 } | |
991 } | |
992 #endif | |
993 | |
994 outbuffer = alloca(ao_data.buffersize); | |
995 | |
996 //don't trust get_space() ;) | |
997 frames_available = snd_pcm_avail_update(alsa_handler) * bytes_per_sample; | |
998 if (frames_available < 0) | |
999 xrun("play"); | |
1000 | |
1001 if (frames_available < 4) { | |
1002 if (first) { | |
1003 first = 0; | |
1004 snd_pcm_start(alsa_handler); | |
1005 } | |
1006 else { //FIXME should break and return 0? | |
1007 snd_pcm_wait(alsa_handler, -1); | |
1008 first = 1; | |
1009 } | |
1010 } | |
1011 | |
1012 /* len is simply the available bufferspace got by get_space() | |
1013 * but real avail_buffer in frames is ab/bytes_per_sample */ | |
1014 size = len / bytes_per_sample; | |
1015 | |
1016 //mp_msg(MSGT_AO,MSGL_V,"len: %i size %i, f_avail %i, bps %i ...\n", len, size, frames_available, bytes_per_sample); | |
1017 | |
1018 frames_transmit = size; | |
1019 | |
1020 /* prepare areas and set sw-pointers | |
1021 * frames_transmit returns the real available buffer-size | |
1022 * sometimes != frames_available cause of ringbuffer 'emulation' */ | |
1023 snd_pcm_mmap_begin(alsa_handler, &area, &offset, &frames_transmit); | |
1024 | |
1025 /* this is specific to interleaved streams (or non-interleaved | |
1026 * streams with only one channel) */ | |
1027 outbuffer = ((char *) area->addr + (area->first + area->step * offset) / 8); //8 | |
1028 | |
1029 //write data | |
1030 memcpy(outbuffer, data, (frames_transmit * bytes_per_sample)); | |
1031 | |
1032 commitres = snd_pcm_mmap_commit(alsa_handler, offset, frames_transmit); | |
1033 | |
1034 if (commitres < 0 || commitres != frames_transmit) { | |
1035 if (snd_pcm_state(alsa_handler) == SND_PCM_STATE_XRUN || | |
1036 snd_pcm_state(alsa_handler) == SND_PCM_STATE_SUSPENDED) { | |
1037 xrun("play"); | |
1038 } | |
1039 } | |
1040 | |
1041 //mp_msg(MSGT_AO,MSGL_V,"mmap ft: %i, cres: %i\n", frames_transmit, commitres); | |
1042 | |
1043 /* err = snd_pcm_area_copy(&area, offset, &data, offset, len, alsa_format); */ | |
1044 /* if (err < 0) { */ | |
1045 /* mp_msg(MSGT_AO,MSGL_ERR,"area-copy-error\n"); */ | |
1046 /* return 0; */ | |
1047 /* } */ | |
1048 | |
1049 | |
1050 //calculate written frames! | |
1051 result = commitres * bytes_per_sample; | |
1052 | |
1053 | |
1054 /* if (verbose) { */ | |
1055 /* if (len == result) */ | |
1056 /* mp_msg(MSGT_AO,MSGL_V,"result: %i, frames written: %i ...\n", result, frames_transmit); */ | |
1057 /* else */ | |
1058 /* mp_msg(MSGT_AO,MSGL_V,"result: %i, frames written: %i, result != len ...\n", result, frames_transmit); */ | |
1059 /* } */ | |
1060 | |
1061 //mplayer doesn't like -result | |
1062 if (result < 0) | |
1063 result = 0; | |
1064 | |
1065 #ifdef USE_POLL | |
1066 free(ufds); | |
1067 #endif | |
1068 | |
1069 return result; | |
1070 } | |
1071 | |
1072 /* how many byes are free in the buffer */ | |
1073 static int get_space() | |
1074 { | |
1075 snd_pcm_status_t *status; | |
1076 int ret; | |
1077 char *str_status; | |
1078 | |
1079 //snd_pcm_sframes_t avail_frames = 0; | |
1080 | |
12747 | 1081 snd_pcm_status_alloca(&status); |
12465 | 1082 |
1083 if ((ret = snd_pcm_status(alsa_handler, status)) < 0) | |
1084 { | |
1085 mp_msg(MSGT_AO,MSGL_ERR,"alsa-space: cannot get pcm status: %s\n", snd_strerror(ret)); | |
1086 return(0); | |
1087 } | |
1088 | |
1089 switch(snd_pcm_status_get_state(status)) | |
1090 { | |
1091 case SND_PCM_STATE_OPEN: | |
1092 str_status = "open"; | |
12805
0b154063a3ca
fixes provided by reimar drfinger. mixer, subdevice parsing, alsa#help,
joyping
parents:
12747
diff
changeset
|
1093 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
|
1094 break; |
12465 | 1095 case SND_PCM_STATE_PREPARED: |
1096 str_status = "prepared"; | |
1097 first = 1; | |
1098 ret = snd_pcm_status_get_avail(status) * bytes_per_sample; | |
1099 if (ret == 0) //ugly workaround for hang in mmap-mode | |
1100 ret = 10; | |
1101 break; | |
1102 case SND_PCM_STATE_RUNNING: | |
1103 ret = snd_pcm_status_get_avail(status) * bytes_per_sample; | |
1104 //avail_frames = snd_pcm_avail_update(alsa_handler) * bytes_per_sample; | |
1105 if (str_status != "open" && str_status != "prepared") | |
1106 str_status = "running"; | |
1107 break; | |
1108 case SND_PCM_STATE_PAUSED: | |
1109 mp_msg(MSGT_AO,MSGL_V,"alsa-space: paused"); | |
1110 str_status = "paused"; | |
1111 ret = 0; | |
1112 break; | |
1113 case SND_PCM_STATE_XRUN: | |
1114 xrun("space"); | |
1115 str_status = "xrun"; | |
1116 first = 1; | |
1117 ret = 0; | |
1118 break; | |
1119 default: | |
1120 str_status = "undefined"; | |
1121 ret = snd_pcm_status_get_avail(status) * bytes_per_sample; | |
1122 if (ret <= 0) { | |
1123 xrun("space"); | |
1124 } | |
1125 } | |
1126 | |
12811
d5f8efddac6c
volume calc fixes for mixer, by reimar dffinger, 10l reverse by me
joyping
parents:
12805
diff
changeset
|
1127 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
|
1128 mp_msg(MSGT_AO,MSGL_V,"alsa-space: free space = %i, %s --\n", ret, str_status); |
12465 | 1129 |
1130 if (ret < 0) { | |
1131 mp_msg(MSGT_AO,MSGL_ERR,"negative value!!\n"); | |
1132 ret = 0; | |
1133 } | |
1134 | |
1135 // workaround for too small value returned | |
1136 if (ret < MIN_CHUNK_SIZE) | |
1137 ret = 0; | |
1138 | |
1139 return(ret); | |
1140 } | |
1141 | |
1142 /* delay in seconds between first and last sample in buffer */ | |
1143 static float get_delay() | |
1144 { | |
1145 | |
1146 if (alsa_handler) { | |
1147 | |
1148 snd_pcm_status_t *status; | |
1149 float ret; | |
1150 | |
12747 | 1151 snd_pcm_status_alloca(&status); |
12465 | 1152 |
1153 if ((ret = snd_pcm_status(alsa_handler, status)) < 0) | |
1154 { | |
1155 mp_msg(MSGT_AO,MSGL_ERR,"alsa-delay: cannot get pcm status: %s\n", snd_strerror(ret)); | |
1156 } | |
1157 | |
1158 switch(snd_pcm_status_get_state(status)) | |
1159 { | |
1160 case SND_PCM_STATE_OPEN: | |
1161 case SND_PCM_STATE_PREPARED: | |
1162 case SND_PCM_STATE_RUNNING: | |
1163 ret = (float)snd_pcm_status_get_delay(status)/(float)ao_data.samplerate; | |
1164 break; | |
1165 default: | |
1166 ret = 0; | |
1167 } | |
1168 | |
1169 | |
1170 if (ret < 0) | |
1171 ret = 0; | |
1172 return(ret); | |
1173 | |
1174 } else { | |
1175 return(0); | |
1176 } | |
1177 } |