1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
31typedef struct SpiceRateCtl {
32 int64_t start_ticks;
33 int64_t bytes_sent;
34} SpiceRateCtl;
35
36typedef 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
46typedef struct SpiceVoiceIn {
47 HWVoiceIn hw;
48 SpiceRecordInstance sin;
49 SpiceRateCtl rate;
50 int active;
51 uint32_t samples[LINE_IN_SAMPLES];
52} SpiceVoiceIn;
53
54static 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
61static 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
68static void *spice_audio_init (void)
69{
70 if (!using_spice) {
71 return NULL;
72 }
73 return &spice_audio_init;
74}
75
76static void spice_audio_fini (void *opaque)
77{
78
79}
80
81static void rate_start (SpiceRateCtl *rate)
82{
83 memset (rate, 0, sizeof (*rate));
84 rate->start_ticks = qemu_get_clock (vm_clock);
85}
86
87static 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
108
109static 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
128static 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
135static 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
175static int line_out_write (SWVoiceOut *sw, void *buf, int len)
176{
177 return audio_pcm_sw_write (sw, buf, len);
178}
179
180static 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
210
211static 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
230static 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
237static 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
282static int line_in_read (SWVoiceIn *sw, void *buf, int size)
283{
284 return audio_pcm_sw_read (sw, buf, size);
285}
286
287static 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
311static struct audio_option audio_options[] = {
312 { },
313};
314
315static 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
329struct 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
342void qemu_spice_audio_init (void)
343{
344 spice_audio_driver.can_be_default = 1;
345}
346
