![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fmodaudio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / audio|
Return to fmodaudio.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / audio |
1.1 root 1: /*
2: * QEMU FMOD audio output driver
3: *
4: * Copyright (c) 2004 Vassili Karpov (malc)
5: *
6: * Permission is hereby granted, free of charge, to any person obtaining a copy
7: * of this software and associated documentation files (the "Software"), to deal
8: * in the Software without restriction, including without limitation the rights
9: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10: * copies of the Software, and to permit persons to whom the Software is
11: * furnished to do so, subject to the following conditions:
12: *
13: * The above copyright notice and this permission notice shall be included in
14: * all copies or substantial portions of the Software.
15: *
16: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22: * THE SOFTWARE.
23: */
24: #include <fmod.h>
25: #include <fmod_errors.h>
26: #include "vl.h"
27:
28: #include "audio/audio_int.h"
29:
30: typedef struct FMODVoice {
31: HWVoice hw;
32: unsigned int old_pos;
33: FSOUND_SAMPLE *fmod_sample;
34: int channel;
35: } FMODVoice;
36:
37: #define dolog(...) AUD_log ("fmod", __VA_ARGS__)
38: #ifdef DEBUG
39: #define ldebug(...) dolog (__VA_ARGS__)
40: #else
41: #define ldebug(...)
42: #endif
43:
44: #define QC_FMOD_DRV "QEMU_FMOD_DRV"
45: #define QC_FMOD_FREQ "QEMU_FMOD_FREQ"
46: #define QC_FMOD_SAMPLES "QEMU_FMOD_SAMPLES"
47: #define QC_FMOD_CHANNELS "QEMU_FMOD_CHANNELS"
48: #define QC_FMOD_BUFSIZE "QEMU_FMOD_BUFSIZE"
49: #define QC_FMOD_THRESHOLD "QEMU_FMOD_THRESHOLD"
50:
51: static struct {
52: int nb_samples;
53: int freq;
54: int nb_channels;
55: int bufsize;
56: int threshold;
57: } conf = {
58: 2048,
59: 44100,
60: 1,
61: 0,
62: 128
63: };
64:
65: #define errstr() FMOD_ErrorString (FSOUND_GetError ())
66:
67: static int fmod_hw_write (SWVoice *sw, void *buf, int len)
68: {
69: return pcm_hw_write (sw, buf, len);
70: }
71:
72: static void fmod_clear_sample (FMODVoice *fmd)
73: {
74: HWVoice *hw = &fmd->hw;
75: int status;
76: void *p1 = 0, *p2 = 0;
77: unsigned int len1 = 0, len2 = 0;
78:
79: status = FSOUND_Sample_Lock (
80: fmd->fmod_sample,
81: 0,
82: hw->samples << hw->shift,
83: &p1,
84: &p2,
85: &len1,
86: &len2
87: );
88:
89: if (!status) {
90: dolog ("Failed to lock sample\nReason: %s\n", errstr ());
91: return;
92: }
93:
94: if ((len1 & hw->align) || (len2 & hw->align)) {
95: dolog ("Locking sample returned unaligned length %d, %d\n",
96: len1, len2);
97: goto fail;
98: }
99:
100: if (len1 + len2 != hw->samples << hw->shift) {
101: dolog ("Locking sample returned incomplete length %d, %d\n",
102: len1 + len2, hw->samples << hw->shift);
103: goto fail;
104: }
105: pcm_hw_clear (hw, p1, hw->samples);
106:
107: fail:
108: status = FSOUND_Sample_Unlock (fmd->fmod_sample, p1, p2, len1, len2);
109: if (!status) {
110: dolog ("Failed to unlock sample\nReason: %s\n", errstr ());
111: }
112: }
113:
114: static int fmod_write_sample (HWVoice *hw, uint8_t *dst, st_sample_t *src,
115: int src_size, int src_pos, int dst_len)
116: {
117: int src_len1 = dst_len, src_len2 = 0, pos = src_pos + dst_len;
118: st_sample_t *src1 = src + src_pos, *src2 = 0;
119:
120: if (src_pos + dst_len > src_size) {
121: src_len1 = src_size - src_pos;
122: src2 = src;
123: src_len2 = dst_len - src_len1;
124: pos = src_len2;
125: }
126:
127: if (src_len1) {
128: hw->clip (dst, src1, src_len1);
129: memset (src1, 0, src_len1 * sizeof (st_sample_t));
130: advance (dst, src_len1);
131: }
132:
133: if (src_len2) {
134: hw->clip (dst, src2, src_len2);
135: memset (src2, 0, src_len2 * sizeof (st_sample_t));
136: }
137: return pos;
138: }
139:
140: static int fmod_unlock_sample (FMODVoice *fmd, void *p1, void *p2,
141: unsigned int blen1, unsigned int blen2)
142: {
143: int status = FSOUND_Sample_Unlock (fmd->fmod_sample, p1, p2, blen1, blen2);
144: if (!status) {
145: dolog ("Failed to unlock sample\nReason: %s\n", errstr ());
146: return -1;
147: }
148: return 0;
149: }
150:
151: static int fmod_lock_sample (FMODVoice *fmd, int pos, int len,
152: void **p1, void **p2,
153: unsigned int *blen1, unsigned int *blen2)
154: {
155: HWVoice *hw = &fmd->hw;
156: int status;
157:
158: status = FSOUND_Sample_Lock (
159: fmd->fmod_sample,
160: pos << hw->shift,
161: len << hw->shift,
162: p1,
163: p2,
164: blen1,
165: blen2
166: );
167:
168: if (!status) {
169: dolog ("Failed to lock sample\nReason: %s\n", errstr ());
170: return -1;
171: }
172:
173: if ((*blen1 & hw->align) || (*blen2 & hw->align)) {
174: dolog ("Locking sample returned unaligned length %d, %d\n",
175: *blen1, *blen2);
176: fmod_unlock_sample (fmd, *p1, *p2, *blen1, *blen2);
177: return -1;
178: }
179: return 0;
180: }
181:
182: static void fmod_hw_run (HWVoice *hw)
183: {
184: FMODVoice *fmd = (FMODVoice *) hw;
185: int rpos, live, decr;
186: void *p1 = 0, *p2 = 0;
187: unsigned int blen1 = 0, blen2 = 0;
188: unsigned int len1 = 0, len2 = 0;
189: int nb_active;
190:
191: live = pcm_hw_get_live2 (hw, &nb_active);
192: if (live <= 0) {
193: return;
194: }
195:
196: if (!hw->pending_disable
197: && nb_active
198: && conf.threshold
199: && live <= conf.threshold) {
200: ldebug ("live=%d nb_active=%d\n", live, nb_active);
201: return;
202: }
203:
204: decr = live;
205:
206: #if 1
207: if (fmd->channel >= 0) {
208: int pos2 = (fmd->old_pos + decr) % hw->samples;
209: int pos = FSOUND_GetCurrentPosition (fmd->channel);
210:
211: if (fmd->old_pos < pos && pos2 >= pos) {
212: decr = pos - fmd->old_pos - (pos2 == pos) - 1;
213: }
214: else if (fmd->old_pos > pos && pos2 >= pos && pos2 < fmd->old_pos) {
215: decr = (hw->samples - fmd->old_pos) + pos - (pos2 == pos) - 1;
216: }
217: /* ldebug ("pos=%d pos2=%d old=%d live=%d decr=%d\n", */
218: /* pos, pos2, fmd->old_pos, live, decr); */
219: }
220: #endif
221:
222: if (decr <= 0) {
223: return;
224: }
225:
226: if (fmod_lock_sample (fmd, fmd->old_pos, decr, &p1, &p2, &blen1, &blen2)) {
227: return;
228: }
229:
230: len1 = blen1 >> hw->shift;
231: len2 = blen2 >> hw->shift;
232: ldebug ("%p %p %d %d %d %d\n", p1, p2, len1, len2, blen1, blen2);
233: decr = len1 + len2;
234: rpos = hw->rpos;
235:
236: if (len1) {
237: rpos = fmod_write_sample (hw, p1, hw->mix_buf, hw->samples, rpos, len1);
238: }
239:
240: if (len2) {
241: rpos = fmod_write_sample (hw, p2, hw->mix_buf, hw->samples, rpos, len2);
242: }
243:
244: fmod_unlock_sample (fmd, p1, p2, blen1, blen2);
245:
246: pcm_hw_dec_live (hw, decr);
247: hw->rpos = rpos % hw->samples;
248: fmd->old_pos = (fmd->old_pos + decr) % hw->samples;
249: }
250:
251: static int AUD_to_fmodfmt (audfmt_e fmt, int stereo)
252: {
253: int mode = FSOUND_LOOP_NORMAL;
254:
255: switch (fmt) {
256: case AUD_FMT_S8:
257: mode |= FSOUND_SIGNED | FSOUND_8BITS;
258: break;
259:
260: case AUD_FMT_U8:
261: mode |= FSOUND_UNSIGNED | FSOUND_8BITS;
262: break;
263:
264: case AUD_FMT_S16:
265: mode |= FSOUND_SIGNED | FSOUND_16BITS;
266: break;
267:
268: case AUD_FMT_U16:
269: mode |= FSOUND_UNSIGNED | FSOUND_16BITS;
270: break;
271:
272: default:
273: dolog ("Internal logic error: Bad audio format %d\nAborting\n", fmt);
274: exit (EXIT_FAILURE);
275: }
276: mode |= stereo ? FSOUND_STEREO : FSOUND_MONO;
277: return mode;
278: }
279:
280: static void fmod_hw_fini (HWVoice *hw)
281: {
282: FMODVoice *fmd = (FMODVoice *) hw;
283:
284: if (fmd->fmod_sample) {
285: FSOUND_Sample_Free (fmd->fmod_sample);
286: fmd->fmod_sample = 0;
287:
288: if (fmd->channel >= 0) {
289: FSOUND_StopSound (fmd->channel);
290: }
291: }
292: }
293:
294: static int fmod_hw_init (HWVoice *hw, int freq, int nchannels, audfmt_e fmt)
295: {
296: int bits16, mode, channel;
297: FMODVoice *fmd = (FMODVoice *) hw;
298:
299: mode = AUD_to_fmodfmt (fmt, nchannels == 2 ? 1 : 0);
300: fmd->fmod_sample = FSOUND_Sample_Alloc (
301: FSOUND_FREE, /* index */
302: conf.nb_samples, /* length */
303: mode, /* mode */
304: freq, /* freq */
305: 255, /* volume */
306: 128, /* pan */
307: 255 /* priority */
308: );
309:
310: if (!fmd->fmod_sample) {
311: dolog ("Failed to allocate FMOD sample\nReason: %s\n", errstr ());
312: return -1;
313: }
314:
315: channel = FSOUND_PlaySoundEx (FSOUND_FREE, fmd->fmod_sample, 0, 1);
316: if (channel < 0) {
317: dolog ("Failed to start playing sound\nReason: %s\n", errstr ());
318: FSOUND_Sample_Free (fmd->fmod_sample);
319: return -1;
320: }
321: fmd->channel = channel;
322:
323: hw->freq = freq;
324: hw->fmt = fmt;
325: hw->nchannels = nchannels;
326: bits16 = fmt == AUD_FMT_U16 || fmt == AUD_FMT_S16;
327: hw->bufsize = conf.nb_samples << (nchannels == 2) << bits16;
328: return 0;
329: }
330:
331: static int fmod_hw_ctl (HWVoice *hw, int cmd, ...)
332: {
333: int status;
334: FMODVoice *fmd = (FMODVoice *) hw;
335:
336: switch (cmd) {
337: case VOICE_ENABLE:
338: fmod_clear_sample (fmd);
339: status = FSOUND_SetPaused (fmd->channel, 0);
340: if (!status) {
341: dolog ("Failed to resume channel %d\nReason: %s\n",
342: fmd->channel, errstr ());
343: }
344: break;
345:
346: case VOICE_DISABLE:
347: status = FSOUND_SetPaused (fmd->channel, 1);
348: if (!status) {
349: dolog ("Failed to pause channel %d\nReason: %s\n",
350: fmd->channel, errstr ());
351: }
352: break;
353: }
354: return 0;
355: }
356:
357: static struct {
358: const char *name;
359: int type;
360: } drvtab[] = {
361: {"none", FSOUND_OUTPUT_NOSOUND},
362: #ifdef _WIN32
363: {"winmm", FSOUND_OUTPUT_WINMM},
364: {"dsound", FSOUND_OUTPUT_DSOUND},
365: {"a3d", FSOUND_OUTPUT_A3D},
366: {"asio", FSOUND_OUTPUT_ASIO},
367: #endif
368: #ifdef __linux__
369: {"oss", FSOUND_OUTPUT_OSS},
370: {"alsa", FSOUND_OUTPUT_ALSA},
371: {"esd", FSOUND_OUTPUT_ESD},
372: #endif
373: #ifdef __APPLE__
374: {"mac", FSOUND_OUTPUT_MAC},
375: #endif
376: #if 0
377: {"xbox", FSOUND_OUTPUT_XBOX},
378: {"ps2", FSOUND_OUTPUT_PS2},
379: {"gcube", FSOUND_OUTPUT_GC},
380: #endif
381: {"nort", FSOUND_OUTPUT_NOSOUND_NONREALTIME}
382: };
383:
384: static void *fmod_audio_init (void)
385: {
386: int i;
387: double ver;
388: int status;
389: int output_type = -1;
390: const char *drv = audio_get_conf_str (QC_FMOD_DRV, NULL);
391:
392: ver = FSOUND_GetVersion ();
393: if (ver < FMOD_VERSION) {
394: dolog ("Wrong FMOD version %f, need at least %f\n", ver, FMOD_VERSION);
395: return NULL;
396: }
397:
398: if (drv) {
399: int found = 0;
400: for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
401: if (!strcmp (drv, drvtab[i].name)) {
402: output_type = drvtab[i].type;
403: found = 1;
404: break;
405: }
406: }
407: if (!found) {
408: dolog ("Unknown FMOD output driver `%s'\n", drv);
409: }
410: }
411:
412: if (output_type != -1) {
413: status = FSOUND_SetOutput (output_type);
414: if (!status) {
415: dolog ("FSOUND_SetOutput(%d) failed\nReason: %s\n",
416: output_type, errstr ());
417: return NULL;
418: }
419: }
420:
421: conf.freq = audio_get_conf_int (QC_FMOD_FREQ, conf.freq);
422: conf.nb_samples = audio_get_conf_int (QC_FMOD_SAMPLES, conf.nb_samples);
423: conf.nb_channels =
424: audio_get_conf_int (QC_FMOD_CHANNELS,
425: (audio_state.nb_hw_voices > 1
426: ? audio_state.nb_hw_voices
427: : conf.nb_channels));
428: conf.bufsize = audio_get_conf_int (QC_FMOD_BUFSIZE, conf.bufsize);
429: conf.threshold = audio_get_conf_int (QC_FMOD_THRESHOLD, conf.threshold);
430:
431: if (conf.bufsize) {
432: status = FSOUND_SetBufferSize (conf.bufsize);
433: if (!status) {
434: dolog ("FSOUND_SetBufferSize (%d) failed\nReason: %s\n",
435: conf.bufsize, errstr ());
436: }
437: }
438:
439: status = FSOUND_Init (conf.freq, conf.nb_channels, 0);
440: if (!status) {
441: dolog ("FSOUND_Init failed\nReason: %s\n", errstr ());
442: return NULL;
443: }
444:
445: return &conf;
446: }
447:
448: static void fmod_audio_fini (void *opaque)
449: {
450: FSOUND_Close ();
451: }
452:
453: struct pcm_ops fmod_pcm_ops = {
454: fmod_hw_init,
455: fmod_hw_fini,
456: fmod_hw_run,
457: fmod_hw_write,
458: fmod_hw_ctl
459: };
460:
461: struct audio_output_driver fmod_output_driver = {
462: "fmod",
463: fmod_audio_init,
464: fmod_audio_fini,
465: &fmod_pcm_ops,
466: 1,
467: INT_MAX,
468: sizeof (FMODVoice)
469: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.