scsi: convert to QEMU Object Model
[qemu.git] / audio / spiceaudio.c
1 /*
2 * Copyright (C) 2010 Red Hat, Inc.
3 *
4 * maintained by Gerd Hoffmann <kraxel@redhat.com>
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_ns (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_ns (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 }