hw/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 <assert.h>
  26 #include "hw.h"
  27 #include "audiodev.h"
  28 #include "audio/audio.h"
  29 #include "isa.h"
  30
  31 //#define DEBUG
  32
  33 #define ADLIB_KILL_TIMERS 1
  34
  35 #ifdef DEBUG
  36 #include "qemu-timer.h"
  37 #endif
  38
  39 #define dolog(...) AUD_log ("adlib", __VA_ARGS__)
  40 #ifdef DEBUG
  41 #define ldebug(...) dolog (__VA_ARGS__)
  42 #else
  43 #define ldebug(...)
  44 #endif
  45
  46 #ifdef HAS_YMF262
  47 #include "ymf262.h"
  48 void YMF262UpdateOneQEMU (int which, INT16 *dst, int length);
  49 #define SHIFT 2
  50 #else
  51 #include "fmopl.h"
  52 #define SHIFT 1
  53 #endif
  54
  55 #define IO_READ_PROTO(name) \
  56     uint32_t name (void *opaque, uint32_t nport)
  57 #define IO_WRITE_PROTO(name) \
  58     void name (void *opaque, uint32_t nport, uint32_t val)
  59
  60 static struct {
  61     int port;
  62     int freq;
  63 } conf = {0x220, 44100};
  64
  65 typedef struct {
  66     QEMUSoundCard card;
  67     int ticking[2];
  68     int enabled;
  69     int active;
  70     int bufpos;
  71 #ifdef DEBUG
  72     int64_t exp[2];
  73 #endif
  74     int16_t *mixbuf;
  75     uint64_t dexp[2];
  76     SWVoiceOut *voice;
  77     int left, pos, samples;
  78     QEMUAudioTimeStamp ats;
  79 #ifndef HAS_YMF262
  80     FM_OPL *opl;
  81 #endif
  82 } AdlibState;
  83
  84 static AdlibState glob_adlib;
  85
  86 static void adlib_stop_opl_timer (AdlibState *s, size_t n)
  87 {
  88 #ifdef HAS_YMF262
  89     YMF262TimerOver (0, n);
  90 #else
  91     OPLTimerOver (s->opl, n);
  92 #endif
  93     s->ticking[n] = 0;
  94 }
  95
  96 static void adlib_kill_timers (AdlibState *s)
  97 {
  98     size_t i;
  99
 100     for (i = 0; i < 2; ++i) {
 101         if (s->ticking[i]) {
 102             uint64_t delta;
 103
 104             delta = AUD_get_elapsed_usec_out (s->voice, &s->ats);
 105             ldebug (
 106                 "delta = %f dexp = %f expired => %d\n",
 107                 delta / 1000000.0,
 108                 s->dexp[i] / 1000000.0,
 109                 delta >= s->dexp[i]
 110                 );
 111             if (ADLIB_KILL_TIMERS || delta >= s->dexp[i]) {
 112                 adlib_stop_opl_timer (s, i);
 113                 AUD_init_time_stamp_out (s->voice, &s->ats);
 114             }
 115         }
 116     }
 117 }
 118
 119 static IO_WRITE_PROTO(adlib_write)
 120 {
 121     AdlibState *s = opaque;
 122     int a = nport & 3;
 123     int status;
 124
 125     s->active = 1;
 126     AUD_set_active_out (s->voice, 1);
 127
 128     adlib_kill_timers (s);
 129
 130 #ifdef HAS_YMF262
 131     status = YMF262Write (0, a, val);
 132 #else
 133     status = OPLWrite (s->opl, a, val);
 134 #endif
 135 }
 136
 137 static IO_READ_PROTO(adlib_read)
 138 {
 139     AdlibState *s = opaque;
 140     uint8_t data;
 141     int a = nport & 3;
 142
 143     adlib_kill_timers (s);
 144
 145 #ifdef HAS_YMF262
 146     data = YMF262Read (0, a);
 147 #else
 148     data = OPLRead (s->opl, a);
 149 #endif
 150     return data;
 151 }
 152
 153 static void timer_handler (int c, double interval_Sec)
 154 {
 155     AdlibState *s = &glob_adlib;
 156     unsigned n = c & 1;
 157 #ifdef DEBUG
 158     double interval;
 159     int64_t exp;
 160 #endif
 161
 162     if (interval_Sec == 0.0) {
 163         s->ticking[n] = 0;
 164         return;
 165     }
 166
 167     s->ticking[n] = 1;
 168 #ifdef DEBUG
 169     interval = ticks_per_sec * interval_Sec;
 170     exp = qemu_get_clock (vm_clock) + interval;
 171     s->exp[n] = exp;
 172 #endif
 173
 174     s->dexp[n] = interval_Sec * 1000000.0;
 175     AUD_init_time_stamp_out (s->voice, &s->ats);
 176 }
 177
 178 static int write_audio (AdlibState *s, int samples)
 179 {
 180     int net = 0;
 181     int pos = s->pos;
 182
 183     while (samples) {
 184         int nbytes, wbytes, wsampl;
 185
 186         nbytes = samples << SHIFT;
 187         wbytes = AUD_write (
 188             s->voice,
 189             s->mixbuf + (pos << (SHIFT - 1)),
 190             nbytes
 191             );
 192
 193         if (wbytes) {
 194             wsampl = wbytes >> SHIFT;
 195
 196             samples -= wsampl;
 197             pos = (pos + wsampl) % s->samples;
 198
 199             net += wsampl;
 200         }
 201         else {
 202             break;
 203         }
 204     }
 205
 206     return net;
 207 }
 208
 209 static void adlib_callback (void *opaque, int free)
 210 {
 211     AdlibState *s = opaque;
 212     int samples, net = 0, to_play, written;
 213
 214     samples = free >> SHIFT;
 215     if (!(s->active && s->enabled) || !samples) {
 216         return;
 217     }
 218
 219     to_play = audio_MIN (s->left, samples);
 220     while (to_play) {
 221         written = write_audio (s, to_play);
 222
 223         if (written) {
 224             s->left -= written;
 225             samples -= written;
 226             to_play -= written;
 227             s->pos = (s->pos + written) % s->samples;
 228         }
 229         else {
 230             return;
 231         }
 232     }
 233
 234     samples = audio_MIN (samples, s->samples - s->pos);
 235     if (!samples) {
 236         return;
 237     }
 238
 239 #ifdef HAS_YMF262
 240     YMF262UpdateOneQEMU (0, s->mixbuf + s->pos * 2, samples);
 241 #else
 242     YM3812UpdateOne (s->opl, s->mixbuf + s->pos, samples);
 243 #endif
 244
 245     while (samples) {
 246         written = write_audio (s, samples);
 247
 248         if (written) {
 249             net += written;
 250             samples -= written;
 251             s->pos = (s->pos + written) % s->samples;
 252         }
 253         else {
 254             s->left = samples;
 255             return;
 256         }
 257     }
 258 }
 259
 260 static void Adlib_fini (AdlibState *s)
 261 {
 262 #ifdef HAS_YMF262
 263     YMF262Shutdown ();
 264 #else
 265     if (s->opl) {
 266         OPLDestroy (s->opl);
 267         s->opl = NULL;
 268     }
 269 #endif
 270
 271     if (s->mixbuf) {
 272         qemu_free (s->mixbuf);
 273     }
 274
 275     s->active = 0;
 276     s->enabled = 0;
 277     AUD_remove_card (&s->card);
 278 }
 279
 280 int Adlib_init (AudioState *audio, qemu_irq *pic)
 281 {
 282     AdlibState *s = &glob_adlib;
 283     struct audsettings as;
 284
 285     if (!audio) {
 286         dolog ("No audio state\n");
 287         return -1;
 288     }
 289
 290 #ifdef HAS_YMF262
 291     if (YMF262Init (1, 14318180, conf.freq)) {
 292         dolog ("YMF262Init %d failed\n", conf.freq);
 293         return -1;
 294     }
 295     else {
 296         YMF262SetTimerHandler (0, timer_handler, 0);
 297         s->enabled = 1;
 298     }
 299 #else
 300     s->opl = OPLCreate (OPL_TYPE_YM3812, 3579545, conf.freq);
 301     if (!s->opl) {
 302         dolog ("OPLCreate %d failed\n", conf.freq);
 303         return -1;
 304     }
 305     else {
 306         OPLSetTimerHandler (s->opl, timer_handler, 0);
 307         s->enabled = 1;
 308     }
 309 #endif
 310
 311     as.freq = conf.freq;
 312     as.nchannels = SHIFT;
 313     as.fmt = AUD_FMT_S16;
 314     as.endianness = AUDIO_HOST_ENDIANNESS;
 315
 316     AUD_register_card (audio, "adlib", &s->card);
 317
 318     s->voice = AUD_open_out (
 319         &s->card,
 320         s->voice,
 321         "adlib",
 322         s,
 323         adlib_callback,
 324         &as
 325         );
 326     if (!s->voice) {
 327         Adlib_fini (s);
 328         return -1;
 329     }
 330
 331     s->samples = AUD_get_buffer_size_out (s->voice) >> SHIFT;
 332     s->mixbuf = qemu_mallocz (s->samples << SHIFT);
 333
 334     if (!s->mixbuf) {
 335         dolog ("Could not allocate mixing buffer, %d samples (each %d bytes)\n",
 336                s->samples, 1 << SHIFT);
 337         Adlib_fini (s);
 338         return -1;
 339     }
 340
 341     register_ioport_read (0x388, 4, 1, adlib_read, s);
 342     register_ioport_write (0x388, 4, 1, adlib_write, s);
 343
 344     register_ioport_read (conf.port, 4, 1, adlib_read, s);
 345     register_ioport_write (conf.port, 4, 1, adlib_write, s);
 346
 347     register_ioport_read (conf.port + 8, 2, 1, adlib_read, s);
 348     register_ioport_write (conf.port + 8, 2, 1, adlib_write, s);
 349
 350     return 0;
 351 }