![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to spiceaudio.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 spiceaudio.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / audio |
1.1 root 1: /*
2: * Copyright (C) 2010 Red Hat, Inc.
3: *
4: * maintained by Gerd Hoffmann <[email protected]>
5: *
6: * This program is free software; you can redistribute it and/or
7: * modify it under the terms of the GNU General Public License as
8: * published by the Free Software Foundation; either version 2 or
9: * (at your option) version 3 of the License.
10: *
11: * This program is distributed in the hope that it will be useful,
12: * but WITHOUT ANY WARRANTY; without even the implied warranty of
13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: * GNU General Public License for more details.
15: *
16: * You should have received a copy of the GNU General Public License
17: * along with this program; if not, see <http://www.gnu.org/licenses/>.
18: */
19:
20: #include "hw/hw.h"
21: #include "qemu-timer.h"
22: #include "ui/qemu-spice.h"
23:
24: #define AUDIO_CAP "spice"
25: #include "audio.h"
26: #include "audio_int.h"
27:
28: #define LINE_IN_SAMPLES 1024
29: #define LINE_OUT_SAMPLES 1024
30:
31: typedef struct SpiceRateCtl {
32: int64_t start_ticks;
33: int64_t bytes_sent;
34: } SpiceRateCtl;
35:
36: typedef struct SpiceVoiceOut {
37: HWVoiceOut hw;
38: SpicePlaybackInstance sin;
39: SpiceRateCtl rate;
40: int active;
41: uint32_t *frame;
42: uint32_t *fpos;
43: uint32_t fsize;
44: } SpiceVoiceOut;
45:
46: typedef struct SpiceVoiceIn {
47: HWVoiceIn hw;
48: SpiceRecordInstance sin;
49: SpiceRateCtl rate;
50: int active;
51: uint32_t samples[LINE_IN_SAMPLES];
52: } SpiceVoiceIn;
53:
54: static const SpicePlaybackInterface playback_sif = {
55: .base.type = SPICE_INTERFACE_PLAYBACK,
56: .base.description = "playback",
57: .base.major_version = SPICE_INTERFACE_PLAYBACK_MAJOR,
58: .base.minor_version = SPICE_INTERFACE_PLAYBACK_MINOR,
59: };
60:
61: static const SpiceRecordInterface record_sif = {
62: .base.type = SPICE_INTERFACE_RECORD,
63: .base.description = "record",
64: .base.major_version = SPICE_INTERFACE_RECORD_MAJOR,
65: .base.minor_version = SPICE_INTERFACE_RECORD_MINOR,
66: };
67:
68: static void *spice_audio_init (void)
69: {
70: if (!using_spice) {
71: return NULL;
72: }
73: return &spice_audio_init;
74: }
75:
76: static void spice_audio_fini (void *opaque)
77: {
78: /* nothing */
79: }
80:
81: static void rate_start (SpiceRateCtl *rate)
82: {
83: memset (rate, 0, sizeof (*rate));
84: rate->start_ticks = qemu_get_clock (vm_clock);
85: }
86:
87: static int rate_get_samples (struct audio_pcm_info *info, SpiceRateCtl *rate)
88: {
89: int64_t now;
90: int64_t ticks;
91: int64_t bytes;
92: int64_t samples;
93:
94: now = qemu_get_clock (vm_clock);
95: ticks = now - rate->start_ticks;
96: bytes = muldiv64 (ticks, info->bytes_per_second, get_ticks_per_sec ());
97: samples = (bytes - rate->bytes_sent) >> info->shift;
98: if (samples < 0 || samples > 65536) {
99: fprintf (stderr, "Resetting rate control (%" PRId64 " samples)\n", samples);
100: rate_start (rate);
101: samples = 0;
102: }
103: rate->bytes_sent += samples << info->shift;
104: return samples;
105: }
106:
107: /* playback */
108:
109: static int line_out_init (HWVoiceOut *hw, struct audsettings *as)
110: {
111: SpiceVoiceOut *out = container_of (hw, SpiceVoiceOut, hw);
112: struct audsettings settings;
113:
114: settings.freq = SPICE_INTERFACE_PLAYBACK_FREQ;
115: settings.nchannels = SPICE_INTERFACE_PLAYBACK_CHAN;
116: settings.fmt = AUD_FMT_S16;
117: settings.endianness = AUDIO_HOST_ENDIANNESS;
118:
119: audio_pcm_init_info (&hw->info, &settings);
120: hw->samples = LINE_OUT_SAMPLES;
121: out->active = 0;
122:
123: out->sin.base.sif = &playback_sif.base;
124: qemu_spice_add_interface (&out->sin.base);
125: return 0;
126: }
127:
128: static void line_out_fini (HWVoiceOut *hw)
129: {
130: SpiceVoiceOut *out = container_of (hw, SpiceVoiceOut, hw);
131:
132: spice_server_remove_interface (&out->sin.base);
133: }
134:
135: static int line_out_run (HWVoiceOut *hw, int live)
136: {
137: SpiceVoiceOut *out = container_of (hw, SpiceVoiceOut, hw);
138: int rpos, decr;
139: int samples;
140:
141: if (!live) {
142: return 0;
143: }
144:
145: decr = rate_get_samples (&hw->info, &out->rate);
146: decr = audio_MIN (live, decr);
147:
148: samples = decr;
149: rpos = hw->rpos;
150: while (samples) {
151: int left_till_end_samples = hw->samples - rpos;
152: int len = audio_MIN (samples, left_till_end_samples);
153:
154: if (!out->frame) {
155: spice_server_playback_get_buffer (&out->sin, &out->frame, &out->fsize);
156: out->fpos = out->frame;
157: }
158: if (out->frame) {
159: len = audio_MIN (len, out->fsize);
160: hw->clip (out->fpos, hw->mix_buf + rpos, len);
161: out->fsize -= len;
162: out->fpos += len;
163: if (out->fsize == 0) {
164: spice_server_playback_put_samples (&out->sin, out->frame);
165: out->frame = out->fpos = NULL;
166: }
167: }
168: rpos = (rpos + len) % hw->samples;
169: samples -= len;
170: }
171: hw->rpos = rpos;
172: return decr;
173: }
174:
175: static int line_out_write (SWVoiceOut *sw, void *buf, int len)
176: {
177: return audio_pcm_sw_write (sw, buf, len);
178: }
179:
180: static int line_out_ctl (HWVoiceOut *hw, int cmd, ...)
181: {
182: SpiceVoiceOut *out = container_of (hw, SpiceVoiceOut, hw);
183:
184: switch (cmd) {
185: case VOICE_ENABLE:
186: if (out->active) {
187: break;
188: }
189: out->active = 1;
190: rate_start (&out->rate);
191: spice_server_playback_start (&out->sin);
192: break;
193: case VOICE_DISABLE:
194: if (!out->active) {
195: break;
196: }
197: out->active = 0;
198: if (out->frame) {
199: memset (out->fpos, 0, out->fsize << 2);
200: spice_server_playback_put_samples (&out->sin, out->frame);
201: out->frame = out->fpos = NULL;
202: }
203: spice_server_playback_stop (&out->sin);
204: break;
205: }
206: return 0;
207: }
208:
209: /* record */
210:
211: static int line_in_init (HWVoiceIn *hw, struct audsettings *as)
212: {
213: SpiceVoiceIn *in = container_of (hw, SpiceVoiceIn, hw);
214: struct audsettings settings;
215:
216: settings.freq = SPICE_INTERFACE_RECORD_FREQ;
217: settings.nchannels = SPICE_INTERFACE_RECORD_CHAN;
218: settings.fmt = AUD_FMT_S16;
219: settings.endianness = AUDIO_HOST_ENDIANNESS;
220:
221: audio_pcm_init_info (&hw->info, &settings);
222: hw->samples = LINE_IN_SAMPLES;
223: in->active = 0;
224:
225: in->sin.base.sif = &record_sif.base;
226: qemu_spice_add_interface (&in->sin.base);
227: return 0;
228: }
229:
230: static void line_in_fini (HWVoiceIn *hw)
231: {
232: SpiceVoiceIn *in = container_of (hw, SpiceVoiceIn, hw);
233:
234: spice_server_remove_interface (&in->sin.base);
235: }
236:
237: static int line_in_run (HWVoiceIn *hw)
238: {
239: SpiceVoiceIn *in = container_of (hw, SpiceVoiceIn, hw);
240: int num_samples;
241: int ready;
242: int len[2];
243: uint64_t delta_samp;
244: const uint32_t *samples;
245:
246: if (!(num_samples = hw->samples - audio_pcm_hw_get_live_in (hw))) {
247: return 0;
248: }
249:
250: delta_samp = rate_get_samples (&hw->info, &in->rate);
251: num_samples = audio_MIN (num_samples, delta_samp);
252:
253: ready = spice_server_record_get_samples (&in->sin, in->samples, num_samples);
254: samples = in->samples;
255: if (ready == 0) {
256: static const uint32_t silence[LINE_IN_SAMPLES];
257: samples = silence;
258: ready = LINE_IN_SAMPLES;
259: }
260:
261: num_samples = audio_MIN (ready, num_samples);
262:
263: if (hw->wpos + num_samples > hw->samples) {
264: len[0] = hw->samples - hw->wpos;
265: len[1] = num_samples - len[0];
266: } else {
267: len[0] = num_samples;
268: len[1] = 0;
269: }
270:
271: hw->conv (hw->conv_buf + hw->wpos, samples, len[0]);
272:
273: if (len[1]) {
274: hw->conv (hw->conv_buf, samples + len[0], len[1]);
275: }
276:
277: hw->wpos = (hw->wpos + num_samples) % hw->samples;
278:
279: return num_samples;
280: }
281:
282: static int line_in_read (SWVoiceIn *sw, void *buf, int size)
283: {
284: return audio_pcm_sw_read (sw, buf, size);
285: }
286:
287: static int line_in_ctl (HWVoiceIn *hw, int cmd, ...)
288: {
289: SpiceVoiceIn *in = container_of (hw, SpiceVoiceIn, hw);
290:
291: switch (cmd) {
292: case VOICE_ENABLE:
293: if (in->active) {
294: break;
295: }
296: in->active = 1;
297: rate_start (&in->rate);
298: spice_server_record_start (&in->sin);
299: break;
300: case VOICE_DISABLE:
301: if (!in->active) {
302: break;
303: }
304: in->active = 0;
305: spice_server_record_stop (&in->sin);
306: break;
307: }
308: return 0;
309: }
310:
311: static struct audio_option audio_options[] = {
312: { /* end of list */ },
313: };
314:
315: static struct audio_pcm_ops audio_callbacks = {
316: .init_out = line_out_init,
317: .fini_out = line_out_fini,
318: .run_out = line_out_run,
319: .write = line_out_write,
320: .ctl_out = line_out_ctl,
321:
322: .init_in = line_in_init,
323: .fini_in = line_in_fini,
324: .run_in = line_in_run,
325: .read = line_in_read,
326: .ctl_in = line_in_ctl,
327: };
328:
329: struct audio_driver spice_audio_driver = {
330: .name = "spice",
331: .descr = "spice audio driver",
332: .options = audio_options,
333: .init = spice_audio_init,
334: .fini = spice_audio_fini,
335: .pcm_ops = &audio_callbacks,
336: .max_voices_out = 1,
337: .max_voices_in = 1,
338: .voice_size_out = sizeof (SpiceVoiceOut),
339: .voice_size_in = sizeof (SpiceVoiceIn),
340: };
341:
342: void qemu_spice_audio_init (void)
343: {
344: spice_audio_driver.can_be_default = 1;
345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.