trace: switch position of headers to what Meson requires
[qemu.git] / hw / audio / adlib.c
1 /*
2 * QEMU Proxy for OPL2/3 emulation by MAME team
3 *
4 * Copyright (c) 2004-2005 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
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu/module.h"
28 #include "hw/audio/soundhw.h"
29 #include "audio/audio.h"
30 #include "hw/isa/isa.h"
31 #include "hw/qdev-properties.h"
32
33 //#define DEBUG
34
35 #define ADLIB_KILL_TIMERS 1
36
37 #define ADLIB_DESC "Yamaha YM3812 (OPL2)"
38
39 #ifdef DEBUG
40 #include "qemu/timer.h"
41 #endif
42
43 #define dolog(...) AUD_log ("adlib", __VA_ARGS__)
44 #ifdef DEBUG
45 #define ldebug(...) dolog (__VA_ARGS__)
46 #else
47 #define ldebug(...)
48 #endif
49
50 #include "fmopl.h"
51 #define SHIFT 1
52
53 #define TYPE_ADLIB "adlib"
54 #define ADLIB(obj) OBJECT_CHECK(AdlibState, (obj), TYPE_ADLIB)
55
56 typedef struct {
57 ISADevice parent_obj;
58
59 QEMUSoundCard card;
60 uint32_t freq;
61 uint32_t port;
62 int ticking[2];
63 int enabled;
64 int active;
65 int bufpos;
66 #ifdef DEBUG
67 int64_t exp[2];
68 #endif
69 int16_t *mixbuf;
70 uint64_t dexp[2];
71 SWVoiceOut *voice;
72 int left, pos, samples;
73 QEMUAudioTimeStamp ats;
74 FM_OPL *opl;
75 PortioList port_list;
76 } AdlibState;
77
78 static void adlib_stop_opl_timer (AdlibState *s, size_t n)
79 {
80 OPLTimerOver (s->opl, n);
81 s->ticking[n] = 0;
82 }
83
84 static void adlib_kill_timers (AdlibState *s)
85 {
86 size_t i;
87
88 for (i = 0; i < 2; ++i) {
89 if (s->ticking[i]) {
90 uint64_t delta;
91
92 delta = AUD_get_elapsed_usec_out (s->voice, &s->ats);
93 ldebug (
94 "delta = %f dexp = %f expired => %d\n",
95 delta / 1000000.0,
96 s->dexp[i] / 1000000.0,
97 delta >= s->dexp[i]
98 );
99 if (ADLIB_KILL_TIMERS || delta >= s->dexp[i]) {
100 adlib_stop_opl_timer (s, i);
101 AUD_init_time_stamp_out (s->voice, &s->ats);
102 }
103 }
104 }
105 }
106
107 static void adlib_write(void *opaque, uint32_t nport, uint32_t val)
108 {
109 AdlibState *s = opaque;
110 int a = nport & 3;
111
112 s->active = 1;
113 AUD_set_active_out (s->voice, 1);
114
115 adlib_kill_timers (s);
116
117 OPLWrite (s->opl, a, val);
118 }
119
120 static uint32_t adlib_read(void *opaque, uint32_t nport)
121 {
122 AdlibState *s = opaque;
123 int a = nport & 3;
124
125 adlib_kill_timers (s);
126 return OPLRead (s->opl, a);
127 }
128
129 static void timer_handler (void *opaque, int c, double interval_Sec)
130 {
131 AdlibState *s = opaque;
132 unsigned n = c & 1;
133 #ifdef DEBUG
134 double interval;
135 int64_t exp;
136 #endif
137
138 if (interval_Sec == 0.0) {
139 s->ticking[n] = 0;
140 return;
141 }
142
143 s->ticking[n] = 1;
144 #ifdef DEBUG
145 interval = NANOSECONDS_PER_SECOND * interval_Sec;
146 exp = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + interval;
147 s->exp[n] = exp;
148 #endif
149
150 s->dexp[n] = interval_Sec * 1000000.0;
151 AUD_init_time_stamp_out (s->voice, &s->ats);
152 }
153
154 static int write_audio (AdlibState *s, int samples)
155 {
156 int net = 0;
157 int pos = s->pos;
158
159 while (samples) {
160 int nbytes, wbytes, wsampl;
161
162 nbytes = samples << SHIFT;
163 wbytes = AUD_write (
164 s->voice,
165 s->mixbuf + (pos << (SHIFT - 1)),
166 nbytes
167 );
168
169 if (wbytes) {
170 wsampl = wbytes >> SHIFT;
171
172 samples -= wsampl;
173 pos = (pos + wsampl) % s->samples;
174
175 net += wsampl;
176 }
177 else {
178 break;
179 }
180 }
181
182 return net;
183 }
184
185 static void adlib_callback (void *opaque, int free)
186 {
187 AdlibState *s = opaque;
188 int samples, net = 0, to_play, written;
189
190 samples = free >> SHIFT;
191 if (!(s->active && s->enabled) || !samples) {
192 return;
193 }
194
195 to_play = MIN (s->left, samples);
196 while (to_play) {
197 written = write_audio (s, to_play);
198
199 if (written) {
200 s->left -= written;
201 samples -= written;
202 to_play -= written;
203 s->pos = (s->pos + written) % s->samples;
204 }
205 else {
206 return;
207 }
208 }
209
210 samples = MIN (samples, s->samples - s->pos);
211 if (!samples) {
212 return;
213 }
214
215 YM3812UpdateOne (s->opl, s->mixbuf + s->pos, samples);
216
217 while (samples) {
218 written = write_audio (s, samples);
219
220 if (written) {
221 net += written;
222 samples -= written;
223 s->pos = (s->pos + written) % s->samples;
224 }
225 else {
226 s->left = samples;
227 return;
228 }
229 }
230 }
231
232 static void Adlib_fini (AdlibState *s)
233 {
234 if (s->opl) {
235 OPLDestroy (s->opl);
236 s->opl = NULL;
237 }
238
239 g_free(s->mixbuf);
240
241 s->active = 0;
242 s->enabled = 0;
243 AUD_remove_card (&s->card);
244 }
245
246 static MemoryRegionPortio adlib_portio_list[] = {
247 { 0, 4, 1, .read = adlib_read, .write = adlib_write, },
248 { 0, 2, 1, .read = adlib_read, .write = adlib_write, },
249 { 0x388, 4, 1, .read = adlib_read, .write = adlib_write, },
250 PORTIO_END_OF_LIST(),
251 };
252
253 static void adlib_realizefn (DeviceState *dev, Error **errp)
254 {
255 AdlibState *s = ADLIB(dev);
256 struct audsettings as;
257
258 s->opl = OPLCreate (3579545, s->freq);
259 if (!s->opl) {
260 error_setg (errp, "OPLCreate %d failed", s->freq);
261 return;
262 }
263 else {
264 OPLSetTimerHandler(s->opl, timer_handler, s);
265 s->enabled = 1;
266 }
267
268 as.freq = s->freq;
269 as.nchannels = SHIFT;
270 as.fmt = AUDIO_FORMAT_S16;
271 as.endianness = AUDIO_HOST_ENDIANNESS;
272
273 AUD_register_card ("adlib", &s->card);
274
275 s->voice = AUD_open_out (
276 &s->card,
277 s->voice,
278 "adlib",
279 s,
280 adlib_callback,
281 &as
282 );
283 if (!s->voice) {
284 Adlib_fini (s);
285 error_setg (errp, "Initializing audio voice failed");
286 return;
287 }
288
289 s->samples = AUD_get_buffer_size_out (s->voice) >> SHIFT;
290 s->mixbuf = g_malloc0 (s->samples << SHIFT);
291
292 adlib_portio_list[0].offset = s->port;
293 adlib_portio_list[1].offset = s->port + 8;
294 portio_list_init (&s->port_list, OBJECT(s), adlib_portio_list, s, "adlib");
295 portio_list_add (&s->port_list, isa_address_space_io(&s->parent_obj), 0);
296 }
297
298 static Property adlib_properties[] = {
299 DEFINE_AUDIO_PROPERTIES(AdlibState, card),
300 DEFINE_PROP_UINT32 ("iobase", AdlibState, port, 0x220),
301 DEFINE_PROP_UINT32 ("freq", AdlibState, freq, 44100),
302 DEFINE_PROP_END_OF_LIST (),
303 };
304
305 static void adlib_class_initfn (ObjectClass *klass, void *data)
306 {
307 DeviceClass *dc = DEVICE_CLASS (klass);
308
309 dc->realize = adlib_realizefn;
310 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
311 dc->desc = ADLIB_DESC;
312 device_class_set_props(dc, adlib_properties);
313 }
314
315 static const TypeInfo adlib_info = {
316 .name = TYPE_ADLIB,
317 .parent = TYPE_ISA_DEVICE,
318 .instance_size = sizeof (AdlibState),
319 .class_init = adlib_class_initfn,
320 };
321
322 static void adlib_register_types (void)
323 {
324 type_register_static (&adlib_info);
325 deprecated_register_soundhw("adlib", ADLIB_DESC, 1, TYPE_ADLIB);
326 }
327
328 type_init (adlib_register_types)