VirtualBox

source: vbox/trunk/src/VBox/Devices/Audio/winaudio.c@ 400

Last change on this file since 400 was 1, checked in by vboxsync, 55 years ago

import
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.5 KB
Line 
1/** @file
2 *
3 * VBox audio device:
4 * Windows audio driver
5 */
6
7/*
8 * Copyright (C) 2006 InnoTek Systemberatung GmbH
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License as published by the Free Software Foundation,
14 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
15 * distribution. VirtualBox OSE is distributed in the hope that it will
16 * be useful, but WITHOUT ANY WARRANTY of any kind.
17 *
18 * If you received this file as part of a commercial VirtualBox
19 * distribution, then only the terms of your commercial VirtualBox
20 * license agreement apply instead of the previous paragraph.
21 */
22
23#include <Windows.h>
24#include <mmsystem.h>
25
26#include <VBox/pdm.h>
27#include <VBox/err.h>
28
29#define LOG_GROUP LOG_GROUP_DEV_AC97
30#include <VBox/log.h>
31#include <iprt/assert.h>
32#include <iprt/uuid.h>
33#include <iprt/string.h>
34#include <iprt/alloc.h>
35
36#include "Builtins.h"
37#include "../../vl_vbox.h"
38
39#include "audio.h"
40#include "audio_int.h"
41
42#define WINMM_BUFFER_SIZE 4096
43#define WINMM_NUMBER_BUFFERS 32
44
45typedef struct OSSVoiceOut {
46 HWVoiceOut hw;
47 void *pcm_buf;
48 int fd;
49 int nfrags;
50 int fragsize;
51 int old_optr;
52 int default_bufsize;
53
54 int fStart;
55 LPWAVEHDR lpwh;
56 int cBuffers;
57 int idxBuffer;
58 HWAVEOUT hStream;
59} OSSVoiceOut;
60
61typedef struct OSSVoiceIn {
62 HWVoiceIn hw;
63 void *pcm_buf;
64 int fd;
65 int nfrags;
66 int fragsize;
67 int old_optr;
68
69 WAVEHDR wh;
70 HWAVEIN hStream;
71} OSSVoiceIn;
72
73
74static int winmm_write (SWVoiceOut *sw, void *buf, int len)
75{
76 Log(("winmm_write: %08x %x\n", buf, len));
77 return pcm_sw_write (sw, buf, len);
78}
79
80
81static void winmm_run_out (HWVoiceOut *hw)
82{
83 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
84 int err, rpos, live, decr;
85 int samples;
86 uint8_t *dst;
87 st_sample_t *src;
88 MMTIME mmtime;
89
90 live = pcm_hw_get_live (hw, NULL);
91 Log(("winmm_run_out live=%x\n", live));
92 if (live <= 0)
93 return;
94
95 mmtime.wType = TIME_SAMPLES;
96 err = waveOutGetPosition(oss->hStream, &mmtime, sizeof(mmtime));
97 if (err != MMSYSERR_NOERROR) {
98 Log( ("WINMMAUD: waveOutGetPosition failed with %d\n", err));
99 return;
100 }
101 if (mmtime.u.sample > 0 && mmtime.u.sample == oss->old_optr) {
102 if (abs (hw->samples - live) < 64)
103 Log( ("winmmaudio: overrun\n"));
104 return;
105 }
106
107 samples = oss->default_bufsize >> hw->info.shift;
108
109 decr = audio_MIN (samples, live);
110
111 Log(("winmm_run_out: current pos %08X room left=%08X, decr=%08x\n", mmtime.u.sample, samples, decr));
112
113 samples = decr;
114 rpos = hw->rpos;
115 while (samples)
116 {
117 int rc;
118 int left_till_end_samples = hw->samples - rpos;
119 int convert_samples = audio_MIN (samples, left_till_end_samples);
120
121 Assert(oss->lpwh[oss->idxBuffer].dwFlags & WHDR_PREPARED);
122 Assert( (oss->lpwh[oss->idxBuffer].dwFlags & WHDR_DONE) ||
123 !(oss->lpwh[oss->idxBuffer].dwFlags & WHDR_INQUEUE));
124
125 if (!(oss->lpwh[oss->idxBuffer].dwFlags & WHDR_DONE) && (oss->lpwh[oss->idxBuffer].dwFlags & WHDR_INQUEUE))
126 {
127 Log(("winmm: buffer overrun -> current buffer=%d!!\n", oss->idxBuffer));
128 break;
129 }
130
131 src = advance (hw->mix_buf, rpos * sizeof (st_sample_t));
132 dst = oss->lpwh[oss->idxBuffer].lpData;
133
134 Log(("winmm_run_out: buffer=%d dst=%08x src=%08x convert_samples %08X\n", oss->idxBuffer, dst, src, convert_samples));
135
136 hw->clip (dst, src, convert_samples);
137 sniffer_run_out (hw, dst, convert_samples);
138
139 /* Update the size of the buffer */
140 oss->lpwh[oss->idxBuffer].dwBufferLength = convert_samples << hw->info.shift;
141 rc = waveOutWrite(oss->hStream, &oss->lpwh[oss->idxBuffer], sizeof(oss->lpwh[oss->idxBuffer]));
142 if (rc != MMSYSERR_NOERROR)
143 {
144 Log( ("WINMMAUD: waveOutWrite failed with %d\n", rc));
145 break;
146 }
147
148 memset (src, 0, convert_samples * sizeof (st_sample_t));
149
150 rpos = (rpos + convert_samples) % hw->samples;
151 samples -= convert_samples;
152
153 oss->idxBuffer++;
154 if (oss->idxBuffer >= oss->cBuffers)
155 oss->idxBuffer = 0;
156 }
157
158 pcm_hw_dec_live (hw, decr);
159 hw->rpos = rpos;
160 oss->old_optr = mmtime.u.sample;
161}
162
163static void winmm_fini_out (HWVoiceOut *hw)
164{
165 MMRESULT err;
166 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
167
168 Log( ("WINMMAUD: winmm_fini_out\n"));
169 waveOutReset(oss->hStream);
170 err = waveOutClose(oss->hStream);
171 if (err != MMSYSERR_NOERROR) {
172 Log( ("WINMMAUD: Failed to close OSS descriptor %d\n", err));
173 }
174 oss->fd = -1;
175
176 if (oss->pcm_buf) {
177 RTMemFree(oss->pcm_buf);
178 oss->pcm_buf = NULL;
179 }
180}
181
182#ifdef DEBUG
183void CALLBACK winmmBufferDone(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, DWORD dwParam1, DWORD dwParam2)
184{
185 if (uMsg == WOM_DONE)
186 {
187 LPWAVEHDR lpwh = (LPWAVEHDR)dwParam1;
188 OSSVoiceOut *oss = (OSSVoiceOut *)dwInstance;
189 int bufidx;
190
191 bufidx = (dwParam1 - (DWORD)oss->lpwh) / sizeof(WAVEHDR);
192 Log(("winmm: WOM_DONE %08X %08X index=%d\n", lpwh->lpData, lpwh->dwBufferLength, bufidx));
193 }
194 return;
195}
196
197#endif
198
199static int winmm_init_out (HWVoiceOut *hw, int freq, int nchannels, audfmt_e fmt)
200{
201 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
202 MMRESULT rc;
203 WAVEFORMATEX waveInfo;
204 int i;
205
206 Log(("winmm_init_out %x freq=%d nchannels=%d\n", hw, freq, nchannels));
207
208 waveInfo.cbSize = sizeof(WAVEFORMATEX);
209 waveInfo.nChannels = nchannels;
210 waveInfo.nSamplesPerSec = freq;
211 waveInfo.wFormatTag = WAVE_FORMAT_PCM;
212
213 switch (fmt)
214 {
215 case AUD_FMT_U8:
216 case AUD_FMT_S8:
217 waveInfo.wBitsPerSample = 8;
218 break;
219 case AUD_FMT_U16:
220 case AUD_FMT_S16:
221 waveInfo.wBitsPerSample = 16;
222 break;
223 default:
224 AssertFailed();
225 return -1;
226 }
227 waveInfo.nBlockAlign = waveInfo.wBitsPerSample*waveInfo.nSamplesPerSec/8;
228 waveInfo.nAvgBytesPerSec = waveInfo.wBitsPerSample*waveInfo.nSamplesPerSec;
229
230#ifdef DEBUG
231 rc = waveOutOpen(&oss->hStream, WAVE_MAPPER, &waveInfo, &winmmBufferDone, oss, CALLBACK_FUNCTION);
232#else
233 rc = waveOutOpen(&oss->hStream, WAVE_MAPPER, &waveInfo, 0, 0, CALLBACK_NULL);
234#endif
235 if (rc != MMSYSERR_NOERROR)
236 {
237 AssertMsgFailed(("waveOutOpen failed with %d\n", rc));
238 return -1;
239 }
240
241 pcm_init_info (&hw->info, freq, nchannels, fmt);
242 hw->bufsize = WINMM_NUMBER_BUFFERS * WINMM_BUFFER_SIZE;
243
244 oss->pcm_buf = RTMemAllocZ (hw->bufsize);
245 if (!oss->pcm_buf)
246 {
247 AssertFailed();
248 rc = waveOutClose (oss->hStream);
249 oss->hStream = (HWAVEOUT)-1;
250 return -1;
251 }
252
253 Log(("PCM buffer %08X size %d\n", oss->pcm_buf, hw->bufsize));
254 oss->cBuffers = hw->bufsize / WINMM_BUFFER_SIZE;
255 oss->lpwh = RTMemAllocZ (oss->cBuffers * sizeof(*oss->lpwh));
256 if (!oss->lpwh)
257 {
258 RTMemFree(oss->pcm_buf);
259 AssertFailed();
260 rc = waveOutClose (oss->hStream);
261 oss->hStream = (HWAVEOUT)-1;
262 return -1;
263 }
264
265 for (i=0;i<oss->cBuffers;i++)
266 {
267 oss->lpwh[i].lpData = (char *)oss->pcm_buf + i*WINMM_BUFFER_SIZE;
268 oss->lpwh[i].dwBufferLength = WINMM_BUFFER_SIZE;
269
270 rc = waveOutPrepareHeader(oss->hStream, &oss->lpwh[i], sizeof(oss->lpwh[i]));
271 if (rc != MMSYSERR_NOERROR)
272 {
273 AssertMsgFailed(("waveOutPrepareHeader failed with %d\n", rc));
274 return -1;
275 }
276 }
277
278 oss->default_bufsize = WINMM_BUFFER_SIZE;
279
280 waveOutSetVolume(oss->hStream, 0xffffffff);
281 return 0;
282}
283
284static int winmm_ctl_out (HWVoiceOut *hw, int cmd, ...)
285{
286 OSSVoiceOut *oss = (OSSVoiceOut *) hw;
287 MMRESULT rc;
288
289 switch (cmd) {
290 case VOICE_SETBUFSIZE:
291 {
292 int buflen, i;
293
294 va_list ap;
295 va_start (ap, cmd);
296 buflen = va_arg (ap, int);
297 va_end (ap);
298
299 Assert(buflen);
300
301 Log(("winmm_ctl_out: setbufsize to %x\n", buflen));
302
303 if (buflen > oss->default_bufsize)
304 {
305 oss->default_bufsize = buflen;
306 oss->cBuffers = hw->bufsize / buflen;
307
308 for (i=0;i<oss->cBuffers;i++)
309 {
310 rc = waveOutUnprepareHeader(oss->hStream, &oss->lpwh[i], sizeof(oss->lpwh[i]));
311 if (rc != MMSYSERR_NOERROR)
312 {
313 AssertMsgFailed(("waveOutPrepareHeader failed with %d\n", rc));
314 return -1;
315 }
316 }
317
318 for (i=0;i<oss->cBuffers;i++)
319 {
320 oss->lpwh[i].lpData = (char *)oss->pcm_buf + i*oss->default_bufsize;
321 oss->lpwh[i].dwBufferLength = oss->default_bufsize;
322
323 rc = waveOutPrepareHeader(oss->hStream, &oss->lpwh[i], sizeof(oss->lpwh[i]));
324 if (rc != MMSYSERR_NOERROR)
325 {
326 AssertMsgFailed(("waveOutPrepareHeader failed with %d\n", rc));
327 return -1;
328 }
329 }
330 }
331 break;
332 }
333
334 case VOICE_ENABLE:
335 {
336 Log( ("WINMMAUD: enabling voice\n"));
337 oss->old_optr = 0;
338 oss->idxBuffer = 0;
339 oss->fStart = 1;
340 pcm_info_clear (&hw->info, oss->pcm_buf, hw->samples);
341 break;
342 }
343
344 case VOICE_DISABLE:
345 Log( ("WINMMAUD: disabling voice\n"));
346 rc = waveOutReset(oss->hStream);
347 if (rc != MMSYSERR_NOERROR) {
348 Log( ("WINMMAUD: waveOutPause failed with %d\n", rc));
349 return -1;
350 }
351 break;
352 }
353 return 0;
354}
355
356static int winmm_init_in (HWVoiceIn *hw,
357 int freq, int nchannels, audfmt_e fmt)
358{
359 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
360 MMRESULT rc;
361 WAVEFORMATEX waveInfo;
362
363 return -1;
364
365 waveInfo.cbSize = sizeof(WAVEFORMATEX);
366 waveInfo.nChannels = nchannels;
367 waveInfo.nSamplesPerSec = freq;
368 waveInfo.wFormatTag = WAVE_FORMAT_PCM;
369
370 switch (fmt)
371 {
372 case AUD_FMT_U8:
373 case AUD_FMT_S8:
374 waveInfo.wBitsPerSample = 8;
375 break;
376 case AUD_FMT_U16:
377 case AUD_FMT_S16:
378 waveInfo.wBitsPerSample = 16;
379 break;
380 default:
381 AssertFailed();
382 return -1;
383 }
384 waveInfo.nBlockAlign = waveInfo.wBitsPerSample*waveInfo.nSamplesPerSec/8;
385 waveInfo.nAvgBytesPerSec = waveInfo.wBitsPerSample*waveInfo.nSamplesPerSec;
386
387 rc = waveInOpen(&oss->hStream, WAVE_MAPPER, &waveInfo, 0, 0, CALLBACK_NULL);
388 if (rc != MMSYSERR_NOERROR)
389 {
390 Log(("waveInOpen failed with %d\n", rc));
391 return -1;
392 }
393
394 pcm_init_info (&hw->info, freq, nchannels, fmt);
395 hw->bufsize = waveInfo.nAvgBytesPerSec/2;
396
397 oss->pcm_buf = RTMemAllocZ (hw->bufsize);
398 if (!oss->pcm_buf) {
399 rc = waveInClose(oss->hStream);
400 oss->hStream = (HWAVEIN)-1;
401 return -1;
402 }
403
404 return 0;
405}
406
407static void winmm_fini_in (HWVoiceIn *hw)
408{
409 MMRESULT err;
410 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
411 err = waveInClose(oss->hStream);
412 if (err) {
413 Log( ("WINMMAUD: waveInClose failed with %d\n", err));
414 }
415 oss->fd = -1;
416 if (oss->pcm_buf) {
417 RTMemFree(oss->pcm_buf);
418 oss->pcm_buf = NULL;
419 }
420}
421
422static void winmm_run_in (HWVoiceIn *hw)
423{
424#if 0
425 OSSVoiceIn *oss = (OSSVoiceIn *) hw;
426 int hwshift = hw->info.shift;
427 int i;
428 int live = hw->total_samples_acquired - pcm_hw_find_min_samples_in (hw);
429 int dead = hw->samples - live;
430 size_t read_samples = 0;
431 struct {
432 int add;
433 int len;
434 } bufs[2] = {
435 { hw->wpos },
436 { 0, 0 }
437 };
438
439 if (!dead) {
440 Log( ("WINMMAUD: empty tot=%d min=%d\n",
441 hw->total_samples_acquired, pcm_hw_find_min_samples_in (hw)));
442 return;
443 }
444
445 if (hw->wpos + dead > hw->samples) {
446 bufs[0].len = (hw->samples - hw->wpos) << hwshift;
447 bufs[1].len = (dead - (hw->samples - hw->wpos)) << hwshift;
448 }
449 else {
450 bufs[0].len = dead << hwshift;
451 }
452
453
454 for (i = 0; i < 2; ++i) {
455 ssize_t nread;
456
457 if (bufs[i].len) {
458 void *p = advance (oss->pcm_buf, bufs[i].add << hwshift);
459 nread = read (oss->fd, p, bufs[i].len);
460
461 if (nread > 0) {
462 if (nread & hw->info.align) {
463 Log( ("WINMMAUD: Unaligned read %d\n", nread));
464 }
465 read_samples += nread >> hwshift;
466 hw->conv (hw->conv_buf + bufs[i].add, p, nread >> hwshift,
467 &nominal_volume);
468 }
469
470 if (bufs[i].len - nread) {
471 if (nread == -1) {
472 switch (errno) {
473 case EINTR:
474 case EAGAIN:
475 break;
476 default:
477 Log( ("WINMMAUD: Failed to read %d bytes (to %p): %s\n",
478 bufs[i].len, p, errstr ()));
479 }
480 }
481 break;
482 }
483 }
484 }
485 hw->total_samples_acquired += read_samples;
486 hw->wpos = (hw->wpos + read_samples) % hw->samples;
487#endif
488}
489
490static int winmm_read (SWVoiceIn *sw, void *buf, int size)
491{
492 return pcm_sw_read (sw, buf, size);
493}
494
495static int winmm_ctl_in (HWVoiceIn *hw, int cmd, ...)
496{
497 (void) hw;
498 (void) cmd;
499 return 0;
500}
501
502#if 0
503static int winmm_read_recsrc (int fd)
504{
505 int recsrc;
506 int err = ioctl (fd, SOUND_MIXER_READ_RECSRC, &recsrc);
507 if (err) {
508 Log( ("WINMMAUD: Failed to read record source mask\nReason: %s\n",
509 errstr ()));
510 return -1;
511 }
512 return recsrc;
513}
514
515static int winmm_write_recsrc (int fd, int *recsrc)
516{
517 int err = ioctl (fd, SOUND_MIXER_READ_RECSRC, &recsrc);
518 if (err) {
519 Log( ("WINMMAUD: Failed to write record source mask\nReason: %s\n",
520 errstr ()));
521 return -1;
522 }
523 return 0;
524}
525
526static const char *winmm_mixer_names[] = SOUND_DEVICE_NAMES;
527
528static int winmm_read_volume (int fd, int ctl)
529{
530 int vol;
531 MMRESULT err;
532 DWORD dwVolume;
533
534 err = waveOutGetVolume(oss->hStream, &dwVolume);
535 if (err) {
536 Log( ("WINMMAUD: Failed to read %s volume\nReason: %s\n",
537 winmm_mixer_names[ctl], errstr ()));
538 return -1;
539 }
540 return (int) (((dwVolume & 0xFFFF) * 100) / 0xFFFF);
541}
542
543static int winmm_write_volume (int fd, int ctl, int *vol)
544{
545 DWORD dwVolume;
546
547 dwVolume = (vol * 0xFFFF / 100);
548 dwVolume = dwVolume | (dwVolume << 16);
549
550 err = waveOutSetVolume(oss->hStream, dwVolume);
551 if (err) {
552 Log( ("WINMMAUD: Failed to write %s volume\nReason: %s\n",
553 winmm_mixer_names[ctl], errstr ()));
554 return -1;
555 }
556 return 0;
557}
558#endif
559
560static void *winmm_audio_init (void)
561{
562#if 0
563 int fd, err, i;
564
565 fd = open (conf.mixer_name, O_RDWR);
566 if (fd < 0) {
567 Log( ("WINMMAUD: Failed to open mixer `%s'\nReason: %s\n",
568 conf.mixer_name, errstr ()));
569 goto ret;
570 }
571
572 conf.recsrc = winmm_read_recsrc (fd);
573
574 if (audio_state.allow_mixer_access) {
575 for (i = 0; i < sizeof (conf.vol) / sizeof (conf.vol[0]); ++i) {
576 conf.vol[0].vol = winmm_read_volume (fd, conf.vol[i].ctl);
577 }
578 }
579
580 err = close (fd);
581 if (err) {
582 Log( ("WINMMAUD: Failed to close mixer device\nReason: %s\n", errstr ()));
583 }
584 ret:
585 return &conf;
586#endif
587 return (void *)1;
588}
589
590static void winmm_audio_fini (void *opaque)
591{
592#if 0
593 int fd, err, temp, i;
594
595 fd = open (conf.mixer_name, O_RDWR);
596 if (fd < 0) {
597 Log( ("WINMMAUD: Failed to open mixer `%s'\nReason: %s\n",
598 conf.mixer_name, errstr ()));
599 return;
600 }
601
602 if (conf.recsrc != -1) {
603 temp = conf.recsrc;
604 winmm_write_recsrc (fd, &temp);
605 }
606
607 for (i = 0; i < sizeof (conf.vol) / sizeof (conf.vol[0]); ++i) {
608 temp = conf.vol[i].vol;
609 if (temp != -1)
610 winmm_write_volume (fd, conf.vol[i].ctl, &temp);
611 }
612
613 err = close (fd);
614 if (err) {
615 Log( ("WINMMAUD: Failed to close mixer device\nReason: %s\n", errstr ()));
616 }
617#endif
618}
619
620#if 0
621static int aud_to_winmm_record_source (audrecsource_t s)
622{
623 switch (s) {
624 case AUD_REC_MIC: return SOUND_MASK_MIC;
625 case AUD_REC_CD: return SOUND_MASK_CD;
626 case AUD_REC_VIDEO: return SOUND_MASK_VIDEO;
627 case AUD_REC_AUX: return SOUND_MASK_LINE1; /* ??? */
628 case AUD_REC_LINE_IN: return SOUND_MASK_LINE;
629 case AUD_REC_PHONE: return SOUND_MASK_PHONEIN;
630 default:
631 Log( ("WINMMAUD: Unknown recording source %d using MIC\n", s));
632 return SOUND_MIXER_MIC;
633 }
634}
635
636static int winmm_to_aud_record_source (int s)
637{
638 switch (s) {
639 case SOUND_MASK_MIC: return AUD_REC_MIC;
640 case SOUND_MASK_CD: return AUD_REC_CD;
641 case SOUND_MASK_VIDEO: return AUD_REC_VIDEO;
642 case SOUND_MASK_LINE1: return AUD_REC_AUX;
643 case SOUND_MASK_LINE: return AUD_REC_LINE_IN;
644 case SOUND_MASK_PHONEIN: return AUD_REC_PHONE;
645 default:
646 Log( ("WINMMAUD: Unknown OSS recording source %d using MIC\n", s));
647 return AUD_REC_MIC;
648 }
649}
650#endif
651
652#if 0
653static int winmm_set_record_source (audrecsource_t *lrs, audrecsource_t *rrs)
654{
655#if 0
656 int source, fd, err;
657 int ret = -1;
658
659 source = aud_to_winmm_record_source (*lrs);
660 if (source == -1) {
661 Log( ("WINMMAUD: Unsupported recording source %s\n",
662 AUD_record_source_name (*lrs)));
663 return -1;
664 }
665
666 fd = open (conf.mixer_name, O_RDWR);
667
668 if (fd == -1) {
669 Log( ("WINMMAUD: Failed to open mixer device\nReason: %s\n", errstr ()));
670 return -1;
671 }
672
673 err = ioctl (fd, SOUND_MIXER_WRITE_RECSRC, &source);
674 if (err) {
675 Log( ("WINMMAUD: Failed to set recording source to %s\nReason: %s\n",
676 AUD_record_source_name (*lrs), errstr ()));
677 goto err;
678 }
679
680 *rrs = *lrs = winmm_to_aud_record_source (source);
681 ret = 0;
682
683 err:
684 if (close (fd)) {
685 Log( ("WINMMAUD: Failed to close mixer device\nReason: %s\n",
686 errstr ())));
687 }
688 return ret;
689#else
690 return 0;
691#endif
692}
693
694static int winmm_set_volume (audmixerctl_t m, int *mute,
695 uint8_t *lvol, uint8_t *rvol)
696{
697 int vol;
698 int winmm_mixerctl, err;
699 int fd = open (conf.mixer_name, O_RDWR);
700 int ret = -1;
701
702 if (fd == -1) {
703 Log( ("WINMMAUD: Failed to open mixer device\nReason: %s\n", errstr ()));
704 return -1;
705 }
706
707 vol = *mute ? 0 : ((*lvol * 100) / 256) | (((*rvol * 100) / 256) << 8);
708
709 switch (m) {
710 case AUD_MIXER_VOLUME:
711 winmm_mixerctl = SOUND_MIXER_VOLUME;
712 break;
713 case AUD_MIXER_PCM:
714 winmm_mixerctl = SOUND_MIXER_PCM;
715 break;
716 case AUD_MIXER_LINE_IN:
717 winmm_mixerctl = SOUND_MIXER_LINE;
718 break;
719 default:
720 Log( ("WINMMAUD: Unknown mixer control %d\n", m));
721 return -1;
722 }
723
724 err = ioctl (fd, MIXER_WRITE (winmm_mixerctl), &vol);
725 if (err) {
726 Log( ("WINMMAUD: Failed to update mixer\nReason: %s\n", errstr ()));
727 goto err;
728 }
729
730 if (!*mute) {
731 *lvol = ((vol & 0xff) * 100) / 256;
732 *rvol = ((vol >> 8) * 100) / 256;
733 }
734 ret = 0;
735
736 err:
737 if (close (fd)) {
738 Log( ("WINMMAUD: Failed to close mixer device\nReason: %s\n",
739 errstr ()));
740 }
741 return ret;
742}
743#endif
744
745static int winmm_audio_ctl (void *opaque, int cmd, ...)
746{
747 int ret = 0;
748#if 0
749 switch (cmd) {
750 case SET_RECORD_SOURCE:
751 {
752 va_list ap;
753 va_start (ap, cmd);
754 audrecsource_t *lrs = va_arg (ap, audrecsource_t *);
755 audrecsource_t *rrs = va_arg (ap, audrecsource_t *);
756 va_end (ap);
757 ret = winmm_set_record_source (lrs, rrs);
758 }
759 break;
760 case SET_VOLUME:
761 {
762 va_list ap;
763 va_start (ap, cmd);
764 audmixerctl_t m = va_arg (ap, audmixerctl_t);
765 int *mute = va_arg (ap, int *);
766 uint8_t *lvol = va_arg (ap, uint8_t *);
767 uint8_t *rvol = va_arg (ap, uint8_t *);
768 va_end (ap);
769 ret = winmm_set_volume (m, mute, lvol, rvol);
770 }
771 break;
772 default:
773 ret = -1;
774 break;
775 }
776#endif
777 return ret;
778}
779
780static struct pcm_ops winmm_pcm_ops = {
781 winmm_init_out,
782 winmm_fini_out,
783 winmm_run_out,
784 winmm_write,
785 winmm_ctl_out,
786
787 winmm_init_in,
788 winmm_fini_in,
789 winmm_run_in,
790 winmm_read,
791 winmm_ctl_in,
792};
793
794struct audio_driver winmm_audio_driver = {
795 "WINMM",
796 winmm_audio_init,
797 winmm_audio_fini,
798 winmm_audio_ctl,
799 &winmm_pcm_ops,
800 1,
801 INT_MAX,
802 INT_MAX,
803 sizeof (OSSVoiceOut),
804 sizeof (OSSVoiceIn)
805};
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette