foo
[dosdemo] / libs / mikmod / include / mikmod.h
1 /*  MikMod sound library
2     (c) 1998-2014 Miodrag Vallat and others - see the AUTHORS file
3     for complete list.
4
5     This library is free software; you can redistribute it and/or modify
6     it under the terms of the GNU Library General Public License as
7     published by the Free Software Foundation; either version 2 of
8     the License, or (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public
16     License along with this library; if not, write to the Free Software
17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
18     02111-1307, USA.
19 */
20
21 /*==============================================================================
22
23   MikMod sound library include file
24
25   ==============================================================================*/
26
27 #ifndef _MIKMOD_H_
28 #define _MIKMOD_H_
29
30 #include <stdio.h>
31 #include <stdlib.h>
32
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36
37 #ifndef MIKMOD_STATIC
38 #define MIKMOD_STATIC
39 #endif
40
41 /*
42  * ========== Compiler magic for shared libraries
43  *
44  * ========== NOTE TO WINDOWS DEVELOPERS:
45  * If you are compiling for Windows and will link to the static library
46  * (libmikmod.a with MinGW, or mikmod_static.lib with MSVC or LCC, etc),
47  * you must define MIKMOD_STATIC in your project.  Otherwise, dllimport
48  * will be assumed.
49  */
50 #if defined(_WIN32) || defined(__CYGWIN__)
51 # if defined(MIKMOD_BUILD) && defined(DLL_EXPORT)       /* building libmikmod as a dll for windows */
52 #   define MIKMODAPI __declspec(dllexport)
53 # elif defined(MIKMOD_BUILD) || defined(MIKMOD_STATIC)  /* building or using static libmikmod for windows */
54 #   define MIKMODAPI
55 # else
56 #   define MIKMODAPI __declspec(dllimport)                      /* using libmikmod dll for windows */
57 # endif
58 #elif defined(__OS2__) && defined(__WATCOMC__)
59 # if defined(MIKMOD_BUILD) && defined(__SW_BD)          /* building libmikmod as a dll for os/2 */
60 #   define MIKMODAPI __declspec(dllexport)
61 # else
62 #   define MIKMODAPI                                    /* using dll or static libmikmod for os/2 */
63 # endif
64 /* SYM_VISIBILITY should be defined if both the compiler
65  * and the target support the visibility attributes. the
66  * configury does that automatically. for the standalone
67  * makefiles, etc, the developer should add the required
68  * flags, i.e.:  -DSYM_VISIBILITY -fvisibility=hidden  */
69 #elif defined(MIKMOD_BUILD) && defined(SYM_VISIBILITY)
70 #   define MIKMODAPI __attribute__((visibility("default")))
71 #else
72 #   define MIKMODAPI
73 #endif
74
75 /*
76  *  ========== Library version
77  */
78
79 #define LIBMIKMOD_VERSION_MAJOR 3L
80 #define LIBMIKMOD_VERSION_MINOR 3L
81 #define LIBMIKMOD_REVISION     10L
82
83 #define LIBMIKMOD_VERSION \
84     ((LIBMIKMOD_VERSION_MAJOR<<16)| \
85      (LIBMIKMOD_VERSION_MINOR<< 8)| \
86      (LIBMIKMOD_REVISION))
87
88 MIKMODAPI extern long MikMod_GetVersion(void);
89
90 /*
91  *  ========== Dependency platform headers
92  */
93
94 #ifdef _WIN32
95 #ifndef WIN32_LEAN_AND_MEAN
96 #define WIN32_LEAN_AND_MEAN
97 #endif
98 #include <windows.h>
99 #include <io.h>
100 #include <mmsystem.h>
101 #define _MIKMOD_WIN32
102 #endif
103
104 #if defined(__DJGPP__) || defined(MSDOS) || defined(__MSDOS__) || defined(__DOS__)
105 #define _MIKMOD_DOS
106 #endif
107
108 #if defined(__OS2__) || defined(__EMX__)
109 #define INCL_DOSSEMAPHORES
110 #include <os2.h>
111 #include <io.h>
112 #define _MIKMOD_OS2
113 #endif
114
115 #if defined(__MORPHOS__) || defined(__AROS__) || defined(_AMIGA) || defined(__AMIGA__) || defined(__amigaos__) || defined(AMIGAOS)
116 #include <exec/types.h>
117 #define _MIKMOD_AMIGA
118 #endif
119
120 /*
121  *  ========== Platform independent-type definitions
122  * (pain when it comes to cross-platform maintenance..)
123  */
124
125 #if !(defined(_MIKMOD_OS2) || defined(_MIKMOD_WIN32))
126 typedef char               CHAR;
127 #endif
128
129 /* BOOL:  0=false, <>0 true -- 16 bits on Amiga, int-wide on others. */
130 #if !(defined(_MIKMOD_OS2) || defined(_MIKMOD_WIN32) || defined(_MIKMOD_AMIGA))
131 typedef int                BOOL;
132 #endif
133
134 /* 1 byte, signed and unsigned: */
135 typedef signed char        SBYTE;
136 #ifndef _MIKMOD_AMIGA
137 typedef unsigned char      UBYTE;
138 #endif
139
140 /* 2 bytes, signed and unsigned: */
141 #ifndef __LCC__
142 typedef signed short int   SWORD;
143 #endif
144 #if !(defined(__LCC__) || defined(_MIKMOD_AMIGA))
145 typedef unsigned short int UWORD;
146 #endif
147
148 /* 4 bytes, signed and unsigned: */
149 #if defined(_LP64) || defined(__LP64__) || defined(__arch64__) || defined(__alpha) || defined(__x86_64) || defined(__powerpc64__)
150         /* 64 bit architectures: */
151 typedef signed int         SLONG;
152 #if !(defined(_WIN32) || defined(_MIKMOD_AMIGA))
153 typedef unsigned int       ULONG;
154 #endif
155
156 #else  /* 32 bit architectures: */
157 typedef signed long int    SLONG;
158 #if !(defined(_MIKMOD_OS2) || defined(_MIKMOD_WIN32) || defined(_MIKMOD_AMIGA))
159 typedef unsigned long int  ULONG;
160 #endif
161 #endif
162
163 /* make sure types are of correct sizes: */
164 typedef int __mikmod_typetest [
165    (
166         (sizeof(SBYTE)==1) && (sizeof(UBYTE)==1)
167      && (sizeof(SWORD)==2) && (sizeof(UWORD)==2)
168      && (sizeof(SLONG)==4) && (sizeof(ULONG)==4)
169 #ifndef _MIKMOD_AMIGA
170      && (sizeof(BOOL) == sizeof(int))
171 #endif
172      && (sizeof(CHAR) == sizeof(char))
173    ) * 2 - 1 ];
174
175 /*
176  *  ========== Error codes
177  */
178
179 enum {
180     MMERR_OPENING_FILE = 1,
181     MMERR_OUT_OF_MEMORY,
182     MMERR_DYNAMIC_LINKING,
183
184     MMERR_SAMPLE_TOO_BIG,
185     MMERR_OUT_OF_HANDLES,
186     MMERR_UNKNOWN_WAVE_TYPE,
187
188     MMERR_LOADING_PATTERN,
189     MMERR_LOADING_TRACK,
190     MMERR_LOADING_HEADER,
191     MMERR_LOADING_SAMPLEINFO,
192     MMERR_NOT_A_MODULE,
193     MMERR_NOT_A_STREAM,
194     MMERR_MED_SYNTHSAMPLES,
195     MMERR_ITPACK_INVALID_DATA,
196
197     MMERR_DETECTING_DEVICE,
198     MMERR_INVALID_DEVICE,
199     MMERR_INITIALIZING_MIXER,
200     MMERR_OPENING_AUDIO,
201     MMERR_8BIT_ONLY,
202     MMERR_16BIT_ONLY,
203     MMERR_STEREO_ONLY,
204     MMERR_ULAW,
205     MMERR_NON_BLOCK,
206
207     MMERR_AF_AUDIO_PORT,
208
209     MMERR_AIX_CONFIG_INIT,
210     MMERR_AIX_CONFIG_CONTROL,
211     MMERR_AIX_CONFIG_START,
212
213     MMERR_GUS_SETTINGS,
214     MMERR_GUS_RESET,
215     MMERR_GUS_TIMER,
216
217     MMERR_HP_SETSAMPLESIZE,
218     MMERR_HP_SETSPEED,
219     MMERR_HP_CHANNELS,
220     MMERR_HP_AUDIO_OUTPUT,
221     MMERR_HP_AUDIO_DESC,
222     MMERR_HP_BUFFERSIZE,
223
224     MMERR_OSS_SETFRAGMENT,
225     MMERR_OSS_SETSAMPLESIZE,
226     MMERR_OSS_SETSTEREO,
227     MMERR_OSS_SETSPEED,
228
229     MMERR_SGI_SPEED,
230     MMERR_SGI_16BIT,
231     MMERR_SGI_8BIT,
232     MMERR_SGI_STEREO,
233     MMERR_SGI_MONO,
234
235     MMERR_SUN_INIT,
236
237     MMERR_OS2_MIXSETUP,
238     MMERR_OS2_SEMAPHORE,
239     MMERR_OS2_TIMER,
240     MMERR_OS2_THREAD,
241
242     MMERR_DS_PRIORITY,
243     MMERR_DS_BUFFER,
244     MMERR_DS_FORMAT,
245     MMERR_DS_NOTIFY,
246     MMERR_DS_EVENT,
247     MMERR_DS_THREAD,
248     MMERR_DS_UPDATE,
249
250     MMERR_WINMM_HANDLE,
251     MMERR_WINMM_ALLOCATED,
252     MMERR_WINMM_DEVICEID,
253     MMERR_WINMM_FORMAT,
254     MMERR_WINMM_UNKNOWN,
255
256     MMERR_MAC_SPEED,
257     MMERR_MAC_START,
258
259     MMERR_OSX_UNKNOWN_DEVICE,
260     MMERR_OSX_BAD_PROPERTY,
261     MMERR_OSX_UNSUPPORTED_FORMAT,
262     MMERR_OSX_SET_STEREO,
263     MMERR_OSX_BUFFER_ALLOC,
264     MMERR_OSX_ADD_IO_PROC,
265     MMERR_OSX_DEVICE_START,
266     MMERR_OSX_PTHREAD,
267
268     MMERR_DOSWSS_STARTDMA,
269     MMERR_DOSSB_STARTDMA,
270
271     MMERR_NO_FLOAT32,/* should actually be after MMERR_ULAW or something */
272
273     MMERR_OPENAL_CREATECTX,
274     MMERR_OPENAL_CTXCURRENT,
275     MMERR_OPENAL_GENBUFFERS,
276     MMERR_OPENAL_GENSOURCES,
277     MMERR_OPENAL_SOURCE,
278     MMERR_OPENAL_QUEUEBUFFERS,
279     MMERR_OPENAL_UNQUEUEBUFFERS,
280     MMERR_OPENAL_BUFFERDATA,
281     MMERR_OPENAL_GETSOURCE,
282     MMERR_OPENAL_SOURCEPLAY,
283     MMERR_OPENAL_SOURCESTOP,
284
285     MMERR_ALSA_NOCONFIG,
286     MMERR_ALSA_SETPARAMS,
287     MMERR_ALSA_SETFORMAT,
288     MMERR_ALSA_SETRATE,
289     MMERR_ALSA_SETCHANNELS,
290     MMERR_ALSA_BUFFERSIZE,
291     MMERR_ALSA_PCM_START,
292     MMERR_ALSA_PCM_WRITE,
293     MMERR_ALSA_PCM_RECOVER,
294
295     MMERR_SNDIO_SETPARAMS,
296     MMERR_SNDIO_BADPARAMS,
297
298     MMERR_MAX
299 };
300
301 /*
302  *  ========== Error handling
303  */
304
305 typedef void (MikMod_handler)(void);
306 typedef MikMod_handler *MikMod_handler_t;
307
308 MIKMODAPI extern int  MikMod_errno;
309 MIKMODAPI extern BOOL MikMod_critical;
310 MIKMODAPI extern const char *MikMod_strerror(int);
311
312 MIKMODAPI extern MikMod_handler_t MikMod_RegisterErrorHandler(MikMod_handler_t);
313
314 /*
315  *  ========== Library initialization and core functions
316  */
317
318 struct MDRIVER;
319
320 MIKMODAPI extern void   MikMod_RegisterAllDrivers(void);
321
322 MIKMODAPI extern CHAR*  MikMod_InfoDriver(void);
323 MIKMODAPI extern void   MikMod_RegisterDriver(struct MDRIVER*);
324 MIKMODAPI extern int    MikMod_DriverFromAlias(const CHAR*);
325 MIKMODAPI extern struct MDRIVER *MikMod_DriverByOrdinal(int);
326
327 MIKMODAPI extern int    MikMod_Init(const CHAR*);
328 MIKMODAPI extern void   MikMod_Exit(void);
329 MIKMODAPI extern int    MikMod_Reset(const CHAR*);
330 MIKMODAPI extern int    MikMod_SetNumVoices(int,int);
331 MIKMODAPI extern BOOL   MikMod_Active(void);
332 MIKMODAPI extern int    MikMod_EnableOutput(void);
333 MIKMODAPI extern void   MikMod_DisableOutput(void);
334 MIKMODAPI extern void   MikMod_Update(void);
335
336 MIKMODAPI extern BOOL   MikMod_InitThreads(void);
337 MIKMODAPI extern void   MikMod_Lock(void);
338 MIKMODAPI extern void   MikMod_Unlock(void);
339
340 MIKMODAPI extern void*  MikMod_malloc(size_t);
341 MIKMODAPI extern void*  MikMod_calloc(size_t,size_t);
342 MIKMODAPI extern void*  MikMod_realloc(void*,size_t);
343 MIKMODAPI extern CHAR*  MikMod_strdup(const CHAR*);
344 MIKMODAPI extern void   MikMod_free(void*);  /* frees if ptr != NULL */
345
346 /*
347  *  ========== Reader, Writer
348  */
349
350 typedef struct MREADER {
351     int  (*Seek)(struct MREADER*,long,int);
352     long (*Tell)(struct MREADER*);
353     BOOL (*Read)(struct MREADER*,void*,size_t);
354     int  (*Get)(struct MREADER*);
355     BOOL (*Eof)(struct MREADER*);
356     long iobase;
357     long prev_iobase;
358 } MREADER;
359
360 typedef struct MWRITER {
361     int  (*Seek)(struct MWRITER*, long, int);
362     long (*Tell)(struct MWRITER*);
363     BOOL (*Write)(struct MWRITER*, const void*, size_t);
364     int  (*Put)(struct MWRITER*, int);
365 } MWRITER;
366
367 /*
368  *  ========== Samples
369  */
370
371 /* Sample playback should not be interrupted */
372 #define SFX_CRITICAL 1
373
374 /* Sample format [loading and in-memory] flags: */
375 #define SF_16BITS       0x0001
376 #define SF_STEREO       0x0002
377 #define SF_SIGNED       0x0004
378 #define SF_BIG_ENDIAN   0x0008
379 #define SF_DELTA        0x0010
380 #define SF_ITPACKED     0x0020
381
382 #define SF_FORMATMASK   0x003F
383
384 /* General Playback flags */
385
386 #define SF_LOOP         0x0100
387 #define SF_BIDI         0x0200
388 #define SF_REVERSE      0x0400
389 #define SF_SUSTAIN      0x0800
390
391 #define SF_PLAYBACKMASK 0x0C00
392
393 /* Module-only Playback Flags */
394
395 #define SF_OWNPAN       0x1000
396 #define SF_UST_LOOP     0x2000
397
398 #define SF_EXTRAPLAYBACKMASK    0x3000
399
400 /* Panning constants */
401 #define PAN_LEFT        0
402 #define PAN_HALFLEFT    64
403 #define PAN_CENTER      128
404 #define PAN_HALFRIGHT   192
405 #define PAN_RIGHT       255
406 #define PAN_SURROUND    512 /* panning value for Dolby Surround */
407
408 typedef struct SAMPLE {
409     SWORD  panning;     /* panning (0-255 or PAN_SURROUND) */
410     ULONG  speed;       /* Base playing speed/frequency of note */
411     UBYTE  volume;      /* volume 0-64 */
412     UWORD  inflags;     /* sample format on disk */
413     UWORD  flags;       /* sample format in memory */
414     ULONG  length;      /* length of sample (in samples!) */
415     ULONG  loopstart;   /* repeat position (relative to start, in samples) */
416     ULONG  loopend;     /* repeat end */
417     ULONG  susbegin;    /* sustain loop begin (in samples) \  Not Supported */
418     ULONG  susend;      /* sustain loop end                /      Yet! */
419
420     /* Variables used by the module player only! (ignored for sound effects) */
421     UBYTE  globvol;     /* global volume */
422     UBYTE  vibflags;    /* autovibrato flag stuffs */
423     UBYTE  vibtype;     /* Vibratos moved from INSTRUMENT to SAMPLE */
424     UBYTE  vibsweep;
425     UBYTE  vibdepth;
426     UBYTE  vibrate;
427     CHAR*  samplename;  /* name of the sample */
428
429     /* Values used internally only */
430     UWORD  avibpos;     /* autovibrato pos [player use] */
431     UBYTE  divfactor;   /* for sample scaling, maintains proper period slides */
432     ULONG  seekpos;     /* seek position in file */
433     SWORD  handle;      /* sample handle used by individual drivers */
434     void (*onfree)(void *ctx); /* called from Sample_Free if not NULL */
435     void *ctx;          /* context passed to previous function*/
436 } SAMPLE;
437
438 /* Sample functions */
439
440 MIKMODAPI extern SAMPLE *Sample_LoadRaw(const CHAR *,ULONG rate, ULONG channel, ULONG flags);
441 MIKMODAPI extern SAMPLE *Sample_LoadRawFP(FILE *fp,ULONG rate,ULONG channel, ULONG flags);
442 MIKMODAPI extern SAMPLE *Sample_LoadRawMem(const char *buf, int len, ULONG rate, ULONG channel, ULONG flags);
443 MIKMODAPI extern SAMPLE *Sample_LoadRawGeneric(MREADER*reader,ULONG rate, ULONG channel, ULONG flags);
444
445 MIKMODAPI extern SAMPLE *Sample_Load(const CHAR*);
446 MIKMODAPI extern SAMPLE *Sample_LoadFP(FILE*);
447 MIKMODAPI extern SAMPLE *Sample_LoadMem(const char *buf, int len);
448 MIKMODAPI extern SAMPLE *Sample_LoadGeneric(MREADER*);
449 MIKMODAPI extern void   Sample_Free(SAMPLE*);
450 MIKMODAPI extern SBYTE  Sample_Play(SAMPLE*,ULONG,UBYTE);
451
452 MIKMODAPI extern void   Voice_SetVolume(SBYTE,UWORD);
453 MIKMODAPI extern UWORD  Voice_GetVolume(SBYTE);
454 MIKMODAPI extern void   Voice_SetFrequency(SBYTE,ULONG);
455 MIKMODAPI extern ULONG  Voice_GetFrequency(SBYTE);
456 MIKMODAPI extern void   Voice_SetPanning(SBYTE,ULONG);
457 MIKMODAPI extern ULONG  Voice_GetPanning(SBYTE);
458 MIKMODAPI extern void   Voice_Play(SBYTE,SAMPLE*,ULONG);
459 MIKMODAPI extern void   Voice_Stop(SBYTE);
460 MIKMODAPI extern BOOL   Voice_Stopped(SBYTE);
461 MIKMODAPI extern SLONG  Voice_GetPosition(SBYTE);
462 MIKMODAPI extern ULONG  Voice_RealVolume(SBYTE);
463
464 /*
465  *  ========== Internal module representation (UniMod)
466  */
467
468 /*
469     Instrument definition - for information only, the only field which may be
470     of use in user programs is the name field
471 */
472
473 /* Instrument note count */
474 #define INSTNOTES 120
475
476 /* Envelope point */
477 typedef struct ENVPT {
478     SWORD pos;
479     SWORD val;
480 } ENVPT;
481
482 /* Envelope point count */
483 #define ENVPOINTS 32
484
485 /* Instrument structure */
486 typedef struct INSTRUMENT {
487     CHAR* insname;
488
489     UBYTE flags;
490     UWORD samplenumber[INSTNOTES];
491     UBYTE samplenote[INSTNOTES];
492
493     UBYTE nnatype;
494     UBYTE dca;              /* duplicate check action */
495     UBYTE dct;              /* duplicate check type */
496     UBYTE globvol;
497     UWORD volfade;
498     SWORD panning;          /* instrument-based panning var */
499
500     UBYTE pitpansep;        /* pitch pan separation (0 to 255) */
501     UBYTE pitpancenter;     /* pitch pan center (0 to 119) */
502     UBYTE rvolvar;          /* random volume varations (0 - 100%) */
503     UBYTE rpanvar;          /* random panning varations (0 - 100%) */
504
505     /* volume envelope */
506     UBYTE volflg;           /* bit 0: on 1: sustain 2: loop */
507     UBYTE volpts;
508     UBYTE volsusbeg;
509     UBYTE volsusend;
510     UBYTE volbeg;
511     UBYTE volend;
512     ENVPT volenv[ENVPOINTS];
513     /* panning envelope */
514     UBYTE panflg;           /* bit 0: on 1: sustain 2: loop */
515     UBYTE panpts;
516     UBYTE pansusbeg;
517     UBYTE pansusend;
518     UBYTE panbeg;
519     UBYTE panend;
520     ENVPT panenv[ENVPOINTS];
521     /* pitch envelope */
522     UBYTE pitflg;           /* bit 0: on 1: sustain 2: loop */
523     UBYTE pitpts;
524     UBYTE pitsusbeg;
525     UBYTE pitsusend;
526     UBYTE pitbeg;
527     UBYTE pitend;
528     ENVPT pitenv[ENVPOINTS];
529 } INSTRUMENT;
530
531 struct MP_CONTROL;
532 struct MP_VOICE;
533
534 /*
535     Module definition
536 */
537
538 /* maximum master channels supported */
539 #define UF_MAXCHAN      64
540
541 /* Module flags */
542 #define UF_XMPERIODS    0x0001 /* XM periods / finetuning */
543 #define UF_LINEAR       0x0002 /* LINEAR periods (UF_XMPERIODS must be set) */
544 #define UF_INST         0x0004 /* Instruments are used */
545 #define UF_NNA          0x0008 /* IT: NNA used, set numvoices rather
546                                   than numchn */
547 #define UF_S3MSLIDES    0x0010 /* uses old S3M volume slides */
548 #define UF_BGSLIDES     0x0020 /* continue volume slides in the background */
549 #define UF_HIGHBPM      0x0040 /* MED: can use >255 bpm */
550 #define UF_NOWRAP       0x0080 /* XM-type (i.e. illogical) pattern break
551                                   semantics */
552 #define UF_ARPMEM       0x0100 /* IT: need arpeggio memory */
553 #define UF_FT2QUIRKS    0x0200 /* emulate some FT2 replay quirks */
554 #define UF_PANNING      0x0400 /* module uses panning effects or have
555                                   non-tracker default initial panning */
556
557 typedef struct MODULE {
558  /* general module information */
559     CHAR*       songname;    /* name of the song */
560     CHAR*       modtype;     /* string type of module loaded */
561     CHAR*       comment;     /* module comments */
562
563     UWORD       flags;       /* See module flags above */
564     UBYTE       numchn;      /* number of module channels */
565     UBYTE       numvoices;   /* max # voices used for full NNA playback */
566     UWORD       numpos;      /* number of positions in this song */
567     UWORD       numpat;      /* number of patterns in this song */
568     UWORD       numins;      /* number of instruments */
569     UWORD       numsmp;      /* number of samples */
570
571     struct INSTRUMENT* instruments; /* all instruments */
572     struct SAMPLE*     samples;     /* all samples */
573
574     UBYTE       realchn;     /* real number of channels used */
575     UBYTE       totalchn;    /* total number of channels used (incl NNAs) */
576
577  /* playback settings */
578     UWORD       reppos;      /* restart position */
579     UBYTE       initspeed;   /* initial song speed */
580     UWORD       inittempo;   /* initial song tempo */
581     UBYTE       initvolume;  /* initial global volume (0 - 128) */
582     UWORD       panning[UF_MAXCHAN]; /* panning positions */
583     UBYTE       chanvol[UF_MAXCHAN]; /* channel positions */
584     UWORD       bpm;         /* current beats-per-minute speed */
585     UWORD       sngspd;      /* current song speed */
586     SWORD       volume;      /* song volume (0-128) (or user volume) */
587
588     BOOL        extspd;      /* extended speed flag (default enabled) */
589     BOOL        panflag;     /* panning flag (default enabled) */
590     BOOL        wrap;        /* wrap module ? (default disabled) */
591     BOOL        loop;        /* allow module to loop ? (default enabled) */
592     BOOL        fadeout;     /* volume fade out during last pattern */
593
594     UWORD       patpos;      /* current row number */
595     SWORD       sngpos;      /* current song position */
596     ULONG       sngtime;     /* current song time in 2^-10 seconds */
597
598     SWORD       relspd;      /* relative speed factor */
599
600  /* internal module representation */
601     UWORD       numtrk;      /* number of tracks */
602     UBYTE**     tracks;      /* array of numtrk pointers to tracks */
603     UWORD*      patterns;    /* array of Patterns */
604     UWORD*      pattrows;    /* array of number of rows for each pattern */
605     UWORD*      positions;   /* all positions */
606
607     BOOL        forbid;      /* if true, no player update! */
608     UWORD       numrow;      /* number of rows on current pattern */
609     UWORD       vbtick;      /* tick counter (counts from 0 to sngspd) */
610     UWORD       sngremainder;/* used for song time computation */
611
612     struct MP_CONTROL* control; /* Effects Channel info (size pf->numchn) */
613     struct MP_VOICE*   voice;   /* Audio Voice information (size md_numchn) */
614
615     UBYTE       globalslide; /* global volume slide rate */
616     UBYTE       pat_repcrazy;/* module has just looped to position -1 */
617     UWORD       patbrk;      /* position where to start a new pattern */
618     UBYTE       patdly;      /* patterndelay counter (command memory) */
619     UBYTE       patdly2;     /* patterndelay counter (real one) */
620     SWORD       posjmp;      /* flag to indicate a jump is needed... */
621     UWORD       bpmlimit;    /* threshold to detect bpm or speed values */
622 } MODULE;
623
624
625 /* This structure is used to query current playing voices status */
626 typedef struct VOICEINFO {
627     INSTRUMENT* i;            /* Current channel instrument */
628     SAMPLE*     s;            /* Current channel sample */
629     SWORD       panning;      /* panning position */
630     SBYTE       volume;       /* channel's "global" volume (0..64) */
631     UWORD       period;       /* period to play the sample at */
632     UBYTE       kick;         /* if true = sample has been restarted */
633 } VOICEINFO;
634
635 /*
636  *  ========== Module loaders
637  */
638
639 struct MLOADER;
640
641 MIKMODAPI extern CHAR*   MikMod_InfoLoader(void);
642 MIKMODAPI extern void    MikMod_RegisterAllLoaders(void);
643 MIKMODAPI extern void    MikMod_RegisterLoader(struct MLOADER*);
644
645 MIKMODAPI extern struct MLOADER load_669; /* 669 and Extended-669 (by Tran/Renaissance) */
646 MIKMODAPI extern struct MLOADER load_amf; /* DMP Advanced Module Format (by Otto Chrons) */
647 MIKMODAPI extern struct MLOADER load_asy; /* ASYLUM Music Format 1.0 */
648 MIKMODAPI extern struct MLOADER load_dsm; /* DSIK internal module format */
649 MIKMODAPI extern struct MLOADER load_far; /* Farandole Composer (by Daniel Potter) */
650 MIKMODAPI extern struct MLOADER load_gdm; /* General DigiMusic (by Edward Schlunder) */
651 MIKMODAPI extern struct MLOADER load_gt2; /* Graoumf tracker */
652 MIKMODAPI extern struct MLOADER load_it;  /* Impulse Tracker (by Jeffrey Lim) */
653 MIKMODAPI extern struct MLOADER load_imf; /* Imago Orpheus (by Lutz Roeder) */
654 MIKMODAPI extern struct MLOADER load_med; /* Amiga MED modules (by Teijo Kinnunen) */
655 MIKMODAPI extern struct MLOADER load_m15; /* Soundtracker 15-instrument */
656 MIKMODAPI extern struct MLOADER load_mod; /* Standard 31-instrument Module loader */
657 MIKMODAPI extern struct MLOADER load_mtm; /* Multi-Tracker Module (by Renaissance) */
658 MIKMODAPI extern struct MLOADER load_okt; /* Amiga Oktalyzer */
659 MIKMODAPI extern struct MLOADER load_stm; /* ScreamTracker 2 (by Future Crew) */
660 MIKMODAPI extern struct MLOADER load_stx; /* STMIK 0.2 (by Future Crew) */
661 MIKMODAPI extern struct MLOADER load_s3m; /* ScreamTracker 3 (by Future Crew) */
662 MIKMODAPI extern struct MLOADER load_ult; /* UltraTracker (by MAS) */
663 MIKMODAPI extern struct MLOADER load_umx; /* Unreal UMX container of Epic Games */
664 MIKMODAPI extern struct MLOADER load_uni; /* MikMod and APlayer internal module format */
665 MIKMODAPI extern struct MLOADER load_xm;  /* FastTracker 2 (by Triton) */
666
667 /*
668  *  ========== Module player
669  */
670
671 MIKMODAPI extern MODULE* Player_Load(const CHAR*,int,BOOL);
672 MIKMODAPI extern MODULE* Player_LoadFP(FILE*,int,BOOL);
673 MIKMODAPI extern MODULE* Player_LoadMem(const char *buffer,int len,int maxchan,BOOL curious);
674 MIKMODAPI extern MODULE* Player_LoadGeneric(MREADER*,int,BOOL);
675 MIKMODAPI extern CHAR*   Player_LoadTitle(const CHAR*);
676 MIKMODAPI extern CHAR*   Player_LoadTitleFP(FILE*);
677 MIKMODAPI extern CHAR*   Player_LoadTitleMem(const char *buffer,int len);
678 MIKMODAPI extern CHAR*   Player_LoadTitleGeneric(MREADER*);
679
680 MIKMODAPI extern void    Player_Free(MODULE*);
681 MIKMODAPI extern void    Player_Start(MODULE*);
682 MIKMODAPI extern BOOL    Player_Active(void);
683 MIKMODAPI extern void    Player_Stop(void);
684 MIKMODAPI extern void    Player_TogglePause(void);
685 MIKMODAPI extern BOOL    Player_Paused(void);
686 MIKMODAPI extern void    Player_NextPosition(void);
687 MIKMODAPI extern void    Player_PrevPosition(void);
688 MIKMODAPI extern void    Player_SetPosition(UWORD);
689 MIKMODAPI extern BOOL    Player_Muted(UBYTE);
690 MIKMODAPI extern void    Player_SetVolume(SWORD);
691 MIKMODAPI extern MODULE* Player_GetModule(void);
692 MIKMODAPI extern void    Player_SetSpeed(UWORD);
693 MIKMODAPI extern void    Player_SetTempo(UWORD);
694 MIKMODAPI extern void    Player_Unmute(SLONG,...);
695 MIKMODAPI extern void    Player_Mute(SLONG,...);
696 MIKMODAPI extern void    Player_ToggleMute(SLONG,...);
697 MIKMODAPI extern int     Player_GetChannelVoice(UBYTE);
698 MIKMODAPI extern UWORD   Player_GetChannelPeriod(UBYTE);
699 MIKMODAPI extern int     Player_QueryVoices(UWORD numvoices, VOICEINFO *vinfo);
700 MIKMODAPI extern int     Player_GetRow(void);
701 MIKMODAPI extern int     Player_GetOrder(void);
702
703 typedef void (*MikMod_player_t)(void);
704 typedef void (*MikMod_callback_t)(unsigned char *data, size_t len);
705
706 MIKMODAPI extern MikMod_player_t MikMod_RegisterPlayer(MikMod_player_t);
707
708 #define MUTE_EXCLUSIVE  32000
709 #define MUTE_INCLUSIVE  32001
710
711 /*
712  *  ========== Drivers
713  */
714
715 enum {
716     MD_MUSIC = 0,
717     MD_SNDFX
718 };
719
720 enum {
721     MD_HARDWARE = 0,
722     MD_SOFTWARE
723 };
724
725 /* Mixing flags */
726
727 /* These ones take effect only after MikMod_Init or MikMod_Reset */
728 #define DMODE_16BITS     0x0001 /* enable 16 bit output */
729 #define DMODE_STEREO     0x0002 /* enable stereo output */
730 #define DMODE_SOFT_SNDFX 0x0004 /* Process sound effects via software mixer */
731 #define DMODE_SOFT_MUSIC 0x0008 /* Process music via software mixer */
732 #define DMODE_HQMIXER    0x0010 /* Use high-quality (slower) software mixer */
733 #define DMODE_FLOAT      0x0020 /* enable float output */
734 /* These take effect immediately. */
735 #define DMODE_SURROUND   0x0100 /* enable surround sound */
736 #define DMODE_INTERP     0x0200 /* enable interpolation */
737 #define DMODE_REVERSE    0x0400 /* reverse stereo */
738 #define DMODE_SIMDMIXER  0x0800 /* enable SIMD mixing */
739 #define DMODE_NOISEREDUCTION 0x1000 /* Low pass filtering */
740
741
742 struct SAMPLOAD;
743
744 typedef struct MDRIVER {
745     struct MDRIVER* next;
746     const CHAR* Name;
747     const CHAR* Version;
748
749     UBYTE       HardVoiceLimit; /* Limit of hardware mixer voices */
750     UBYTE       SoftVoiceLimit; /* Limit of software mixer voices */
751
752     const CHAR* Alias;
753     const CHAR* CmdLineHelp;
754
755     void        (*CommandLine)      (const CHAR*);
756     BOOL        (*IsPresent)        (void);
757     SWORD       (*SampleLoad)       (struct SAMPLOAD*,int);
758     void        (*SampleUnload)     (SWORD);
759     ULONG       (*FreeSampleSpace)  (int);
760     ULONG       (*RealSampleLength) (int,struct SAMPLE*);
761     int         (*Init)             (void);
762     void        (*Exit)             (void);
763     int         (*Reset)            (void);
764     int         (*SetNumVoices)     (void);
765     int         (*PlayStart)        (void);
766     void        (*PlayStop)         (void);
767     void        (*Update)           (void);
768     void        (*Pause)            (void);
769     void        (*VoiceSetVolume)   (UBYTE,UWORD);
770     UWORD       (*VoiceGetVolume)   (UBYTE);
771     void        (*VoiceSetFrequency)(UBYTE,ULONG);
772     ULONG       (*VoiceGetFrequency)(UBYTE);
773     void        (*VoiceSetPanning)  (UBYTE,ULONG);
774     ULONG       (*VoiceGetPanning)  (UBYTE);
775     void        (*VoicePlay)        (UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);
776     void        (*VoiceStop)        (UBYTE);
777     BOOL        (*VoiceStopped)     (UBYTE);
778     SLONG       (*VoiceGetPosition) (UBYTE);
779     ULONG       (*VoiceRealVolume)  (UBYTE);
780 } MDRIVER;
781
782 /* These variables can be changed at ANY time and results will be immediate */
783 MIKMODAPI extern UBYTE md_volume;      /* global sound volume (0-128) */
784 MIKMODAPI extern UBYTE md_musicvolume; /* volume of song */
785 MIKMODAPI extern UBYTE md_sndfxvolume; /* volume of sound effects */
786 MIKMODAPI extern UBYTE md_reverb;      /* 0 = none;  15 = chaos */
787 MIKMODAPI extern UBYTE md_pansep;      /* 0 = mono;  128 == 100% (full left/right) */
788
789 /* The variables below can be changed at any time, but changes will not be
790    implemented until MikMod_Reset is called. A call to MikMod_Reset may result
791    in a skip or pop in audio (depending on the soundcard driver and the settings
792    changed). */
793 MIKMODAPI extern UWORD md_device;      /* device */
794 MIKMODAPI extern UWORD md_mixfreq;     /* mixing frequency */
795 MIKMODAPI extern UWORD md_mode;        /* mode. See DMODE_? flags above */
796
797 /* The following variable should not be changed! */
798 MIKMODAPI extern MDRIVER* md_driver;   /* Current driver in use. */
799
800 /* Known drivers list */
801
802 MIKMODAPI extern struct MDRIVER drv_nos;    /* no sound */
803 MIKMODAPI extern struct MDRIVER drv_pipe;   /* piped output */
804 MIKMODAPI extern struct MDRIVER drv_raw;    /* raw file disk writer [music.raw] */
805 MIKMODAPI extern struct MDRIVER drv_stdout; /* output to stdout */
806 MIKMODAPI extern struct MDRIVER drv_wav;    /* RIFF WAVE file disk writer [music.wav] */
807 MIKMODAPI extern struct MDRIVER drv_aiff;   /* AIFF file disk writer [music.aiff] */
808
809 MIKMODAPI extern struct MDRIVER drv_ultra;  /* Linux Ultrasound driver */
810 MIKMODAPI extern struct MDRIVER drv_sam9407;/* Linux sam9407 driver */
811
812 MIKMODAPI extern struct MDRIVER drv_AF;     /* Dec Alpha AudioFile */
813 MIKMODAPI extern struct MDRIVER drv_ahi;    /* Amiga AHI */
814 MIKMODAPI extern struct MDRIVER drv_aix;    /* AIX audio device */
815 MIKMODAPI extern struct MDRIVER drv_alsa;   /* Advanced Linux Sound Architecture (ALSA) */
816 MIKMODAPI extern struct MDRIVER drv_esd;    /* Enlightened sound daemon (EsounD) */
817 MIKMODAPI extern struct MDRIVER drv_pulseaudio; /* PulseAudio  */
818 MIKMODAPI extern struct MDRIVER drv_hp;     /* HP-UX audio device */
819 MIKMODAPI extern struct MDRIVER drv_nas;    /* Network Audio System (NAS) */
820 MIKMODAPI extern struct MDRIVER drv_oss;    /* OpenSound System (Linux,FreeBSD...) */
821 MIKMODAPI extern struct MDRIVER drv_openal; /* OpenAL driver */
822 MIKMODAPI extern struct MDRIVER drv_sdl;    /* SDL audio driver */
823 MIKMODAPI extern struct MDRIVER drv_sgi;    /* SGI audio library */
824 MIKMODAPI extern struct MDRIVER drv_sndio;  /* OpenBSD sndio */
825 MIKMODAPI extern struct MDRIVER drv_sun;    /* Sun/NetBSD/OpenBSD audio device */
826
827 MIKMODAPI extern struct MDRIVER drv_dart;   /* OS/2 Direct Audio RealTime */
828 MIKMODAPI extern struct MDRIVER drv_os2;    /* OS/2 MMPM/2 */
829
830 MIKMODAPI extern struct MDRIVER drv_ds;     /* Win32 DirectSound driver */
831 MIKMODAPI extern struct MDRIVER drv_xaudio2;/* Win32 XAudio2 driver */
832 MIKMODAPI extern struct MDRIVER drv_win;    /* Win32 multimedia API driver */
833
834 MIKMODAPI extern struct MDRIVER drv_mac;    /* Macintosh Sound Manager driver */
835 MIKMODAPI extern struct MDRIVER drv_osx;    /* MacOS X CoreAudio Driver */
836
837 MIKMODAPI extern struct MDRIVER drv_dc;     /* Dreamcast driver */
838 MIKMODAPI extern struct MDRIVER drv_gp32;   /* GP32 Sound driver */
839 MIKMODAPI extern struct MDRIVER drv_psp;    /* PlayStation Portable driver */
840
841 MIKMODAPI extern struct MDRIVER drv_wss;    /* DOS WSS driver */
842 MIKMODAPI extern struct MDRIVER drv_sb;     /* DOS S/B driver */
843
844 MIKMODAPI extern struct MDRIVER drv_osles;  /* OpenSL ES driver for android */
845
846 /*========== Virtual channel mixer interface (for user-supplied drivers only) */
847
848 MIKMODAPI extern int   VC_Init(void);
849 MIKMODAPI extern void  VC_Exit(void);
850 MIKMODAPI extern void  VC_SetCallback(MikMod_callback_t callback);
851 MIKMODAPI extern int   VC_SetNumVoices(void);
852 MIKMODAPI extern ULONG VC_SampleSpace(int);
853 MIKMODAPI extern ULONG VC_SampleLength(int,SAMPLE*);
854
855 MIKMODAPI extern int   VC_PlayStart(void);
856 MIKMODAPI extern void  VC_PlayStop(void);
857
858 MIKMODAPI extern SWORD VC_SampleLoad(struct SAMPLOAD*,int);
859 MIKMODAPI extern void  VC_SampleUnload(SWORD);
860
861 MIKMODAPI extern ULONG VC_WriteBytes(SBYTE*,ULONG);
862 MIKMODAPI extern ULONG VC_SilenceBytes(SBYTE*,ULONG);
863
864 MIKMODAPI extern void  VC_VoiceSetVolume(UBYTE,UWORD);
865 MIKMODAPI extern UWORD VC_VoiceGetVolume(UBYTE);
866 MIKMODAPI extern void  VC_VoiceSetFrequency(UBYTE,ULONG);
867 MIKMODAPI extern ULONG VC_VoiceGetFrequency(UBYTE);
868 MIKMODAPI extern void  VC_VoiceSetPanning(UBYTE,ULONG);
869 MIKMODAPI extern ULONG VC_VoiceGetPanning(UBYTE);
870 MIKMODAPI extern void  VC_VoicePlay(UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);
871
872 MIKMODAPI extern void  VC_VoiceStop(UBYTE);
873 MIKMODAPI extern BOOL  VC_VoiceStopped(UBYTE);
874 MIKMODAPI extern SLONG VC_VoiceGetPosition(UBYTE);
875 MIKMODAPI extern ULONG VC_VoiceRealVolume(UBYTE);
876
877 #ifdef __cplusplus
878 }
879 #endif
880
881 #endif
882
883 /* ex:set ts=4: */