zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2024-11-10 14:51:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

- did some cleanup on the OPL files to remove all use of homegrown integer types in favor of the standard ones. This already helps getting rid of one of the MUSLIB files still left.

Browse source
This commit is contained in:
Christoph Oelckers 2017-02-06 19:26:45 +01:00
parent f368e70f89
commit 12477216ef
7 changed files with 352 additions and 389 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
src/oplsynth/deftypes.h
View file

@ -1,28 +0,0 @@
/*
* Name: General Use Types Definitions -- Header Include file
* Version: 1.24
* Author: Vladimir Arnost (QA-Software)
* Last revision: Sep-4-1995
* Compiler: Borland C++ 3.1, Watcom C/C++ 10.0
*
*/
#ifndef __DEFTYPES_H_
#define __DEFTYPES_H_
/* Global type declarations */
#include "doomtype.h"
/* machine dependent types */
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef signed char schar;
typedef signed short sshort;
typedef signed int sint;
typedef signed long slong;
#endif // __DEFTYPES_H_

495
src/oplsynth/fmopl.cpp
View file

@ -105,12 +105,6 @@ Revision History:
/* compiler dependence */ /* compiler dependence */
#ifndef OSD_CPU_H #ifndef OSD_CPU_H
#define OSD_CPU_H #define OSD_CPU_H
typedef unsigned char UINT8; /* unsigned 8bit */
typedef unsigned short UINT16; /* unsigned 16bit */
typedef unsigned int UINT32; /* unsigned 32bit */
typedef signed char INT8; /* signed 8bit */
typedef signed short INT16; /* signed 16bit */
typedef signed int INT32; /* signed 32bit */
#endif #endif
#ifndef PI #ifndef PI
@ -119,34 +113,30 @@ typedef signed int INT32; /* signed 32bit */
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning (disable: 4244) #pragma warning (disable: 4244)
#define INLINE __forceinline
#endif #endif
#ifdef __GNUC__
#define INLINE __inline
#endif
#define FREQ_SH 16 /* 16.16 fixed point (frequency calculations) */ #define FREQ_SH 16 /* 16.16 fixed point (frequency calculations) */
#define EG_SH 16 /* 16.16 fixed point (EG timing) */ #define EG_SH 16 /* 16.16 fixed point (EG timing) */
#define LFO_SH 24 /* 8.24 fixed point (LFO calculations) */ #define LFO_SH 24 /* 8.24 fixed point (LFO calculations) */
#define TIMER_SH 16 /* 16.16 fixed point (timers calculations) */ #define TIMER_SH 16 /* 16.16 fixed point (timers calculations) */
#define FREQ_MASK ((1<<FREQ_SH)-1) #define FREQ_MASK ((1<<FREQ_SH)-1)
/* envelope output entries */ /* envelope output entries */
#define ENV_BITS 10 #define ENV_BITS 10
#define ENV_LEN (1<<ENV_BITS) #define ENV_LEN (1<<ENV_BITS)
#define ENV_STEP (128.0/ENV_LEN) #define ENV_STEP (128.0/ENV_LEN)
#define MAX_ATT_INDEX ((1<<(ENV_BITS-1))-1) /*511*/ #define MAX_ATT_INDEX ((1<<(ENV_BITS-1))-1) /*511*/
#define MIN_ATT_INDEX (0) #define MIN_ATT_INDEX (0)
/* sinwave entries */ /* sinwave entries */
#define SIN_BITS 10 #define SIN_BITS 10
#define SIN_LEN (1<<SIN_BITS) #define SIN_LEN (1<<SIN_BITS)
#define SIN_MASK (SIN_LEN-1) #define SIN_MASK (SIN_LEN-1)
#define TL_RES_LEN (256) /* 8 bits addressing (real chip) */ #define TL_RES_LEN (256) /* 8 bits addressing (real chip) */
@ -156,11 +146,11 @@ typedef signed int INT32; /* signed 32bit */
/* Envelope Generator phases */ /* Envelope Generator phases */
#define EG_ATT 4 #define EG_ATT 4
#define EG_DEC 3 #define EG_DEC 3
#define EG_SUS 2 #define EG_SUS 2
#define EG_REL 1 #define EG_REL 1
#define EG_OFF 0 #define EG_OFF 0
#define OPL_CLOCK 3579545 // master clock (Hz) #define OPL_CLOCK 3579545 // master clock (Hz)
@ -171,97 +161,100 @@ typedef signed int INT32; /* signed 32bit */
/* Saving is necessary for member of the 'R' mark for suspend/resume */ /* Saving is necessary for member of the 'R' mark for suspend/resume */
typedef struct{ struct OPL_SLOT
UINT32 ar; /* attack rate: AR<<2 */ {
UINT32 dr; /* decay rate: DR<<2 */ uint32_t ar; /* attack rate: AR<<2 */
UINT32 rr; /* release rate:RR<<2 */ uint32_t dr; /* decay rate: DR<<2 */
UINT8 KSR; /* key scale rate */ uint32_t rr; /* release rate:RR<<2 */
UINT8 ksl; /* keyscale level */ uint8_t KSR; /* key scale rate */
UINT8 ksr; /* key scale rate: kcode>>KSR */ uint8_t ksl; /* keyscale level */
UINT8 mul; /* multiple: mul_tab[ML] */ uint8_t ksr; /* key scale rate: kcode>>KSR */
uint8_t mul; /* multiple: mul_tab[ML] */
/* Phase Generator */ /* Phase Generator */
UINT32 Cnt; /* frequency counter */ uint32_t Cnt; /* frequency counter */
UINT32 Incr; /* frequency counter step */ uint32_t Incr; /* frequency counter step */
UINT8 FB; /* feedback shift value */ uint8_t FB; /* feedback shift value */
INT32 *connect1; /* slot1 output pointer */ int32_t *connect1; /* slot1 output pointer */
INT32 op1_out[2]; /* slot1 output for feedback */ int32_t op1_out[2]; /* slot1 output for feedback */
UINT8 CON; /* connection (algorithm) type */ uint8_t CON; /* connection (algorithm) type */
/* Envelope Generator */ /* Envelope Generator */
UINT8 eg_type; /* percussive/non-percussive mode */ uint8_t eg_type; /* percussive/non-percussive mode */
UINT8 state; /* phase type */ uint8_t state; /* phase type */
UINT32 TL; /* total level: TL << 2 */ uint32_t TL; /* total level: TL << 2 */
INT32 TLL; /* adjusted now TL */ int32_t TLL; /* adjusted now TL */
INT32 volume; /* envelope counter */ int32_t volume; /* envelope counter */
UINT32 sl; /* sustain level: sl_tab[SL] */ uint32_t sl; /* sustain level: sl_tab[SL] */
uint8_t eg_sh_ar; /* (attack state) */
UINT8 eg_sh_ar; /* (attack state) */ uint8_t eg_sel_ar; /* (attack state) */
UINT8 eg_sel_ar; /* (attack state) */ uint8_t eg_sh_dr; /* (decay state) */
UINT8 eg_sh_dr; /* (decay state) */ uint8_t eg_sel_dr; /* (decay state) */
UINT8 eg_sel_dr; /* (decay state) */ uint8_t eg_sh_rr; /* (release state) */
UINT8 eg_sh_rr; /* (release state) */ uint8_t eg_sel_rr; /* (release state) */
UINT8 eg_sel_rr; /* (release state) */ uint32_t key; /* 0 = KEY OFF, >0 = KEY ON */
UINT32 key; /* 0 = KEY OFF, >0 = KEY ON */
/* LFO */ /* LFO */
UINT32 AMmask; /* LFO Amplitude Modulation enable mask */ uint32_t AMmask; /* LFO Amplitude Modulation enable mask */
UINT8 vib; /* LFO Phase Modulation enable flag (active high)*/ uint8_t vib; /* LFO Phase Modulation enable flag (active high)*/
/* waveform select */ /* waveform select */
unsigned int wavetable; unsigned int wavetable;
} OPL_SLOT; };
typedef struct{ struct OPL_CH
{
OPL_SLOT SLOT[2]; OPL_SLOT SLOT[2];
/* phase generator state */ /* phase generator state */
UINT32 block_fnum; /* block+fnum */ uint32_t block_fnum; /* block+fnum */
UINT32 fc; /* Freq. Increment base */ uint32_t fc; /* Freq. Increment base */
UINT32 ksl_base; /* KeyScaleLevel Base step */ uint32_t ksl_base; /* KeyScaleLevel Base step */
UINT8 kcode; /* key code (for key scaling) */ uint8_t kcode; /* key code (for key scaling) */
float LeftVol; /* volumes for stereo panning */ float LeftVol; /* volumes for stereo panning */
float RightVol; float RightVol;
} OPL_CH; };
/* OPL state */ /* OPL state */
typedef struct fm_opl_f { struct FM_OPL
{
/* FM channel slots */ /* FM channel slots */
OPL_CH P_CH[9]; /* OPL/OPL2 chips have 9 channels*/ OPL_CH P_CH[9]; /* OPL/OPL2 chips have 9 channels*/
UINT32 eg_cnt; /* global envelope generator counter */ uint32_t eg_cnt; /* global envelope generator counter */
UINT32 eg_timer; /* global envelope generator counter works at frequency = chipclock/72 */ uint32_t eg_timer; /* global envelope generator counter works at frequency = chipclock/72 */
UINT32 eg_timer_add; /* step of eg_timer */ uint32_t eg_timer_add; /* step of eg_timer */
UINT32 eg_timer_overflow; /* envelope generator timer overflows every 1 sample (on real chip) */ uint32_t eg_timer_overflow; /* envelope generator timer overflows every 1 sample (on real chip) */
UINT8 rhythm; /* Rhythm mode */ uint8_t rhythm; /* Rhythm mode */
UINT32 fn_tab[1024]; /* fnumber->increment counter */ uint32_t fn_tab[1024]; /* fnumber->increment counter */
/* LFO */ /* LFO */
UINT8 lfo_am_depth;
UINT8 lfo_pm_depth_range;
UINT32 lfo_am_cnt;
UINT32 lfo_am_inc;
UINT32 lfo_pm_cnt;
UINT32 lfo_pm_inc;
UINT32 noise_rng; /* 23 bit noise shift register */ uint8_t lfo_am_depth;
UINT32 noise_p; /* current noise 'phase' */ uint8_t lfo_pm_depth_range;
UINT32 noise_f; /* current noise peroid */ uint32_t lfo_am_cnt;
uint32_t lfo_am_inc;
uint32_t lfo_pm_cnt;
uint32_t lfo_pm_inc;
UINT8 wavesel; /* waveform select enable flag */ uint32_t noise_rng; /* 23 bit noise shift register */
uint32_t noise_p; /* current noise 'phase' */
uint32_t noise_f; /* current noise period */
uint8_t wavesel; /* waveform select enable flag */
int T[2]; /* timer counters */ int T[2]; /* timer counters */
UINT8 st[2]; /* timer enable */ uint8_t st[2]; /* timer enable */
UINT8 address; /* address register */
UINT8 status; /* status flag */ uint8_t address; /* address register */
UINT8 statusmask; /* status mask */ uint8_t status; /* status flag */
UINT8 mode; /* Reg.08 : CSM,notesel,etc. */ uint8_t statusmask; /* status mask */
uint8_t mode; /* Reg.08 : CSM,notesel,etc. */
bool IsStereo; /* Write stereo output */ bool IsStereo; /* Write stereo output */
} FM_OPL; };
@ -278,68 +271,67 @@ static const int slot_array[32]=
/* table is 3dB/octave , DV converts this into 6dB/octave */ /* table is 3dB/octave , DV converts this into 6dB/octave */
/* 0.1875 is bit 0 weight of the envelope counter (volume) expressed in the 'decibel' scale */ /* 0.1875 is bit 0 weight of the envelope counter (volume) expressed in the 'decibel' scale */
#define DV (0.1875/2.0) #define DV (0.1875/2.0)
static const UINT32 ksl_tab[8*16]= static const uint32_t ksl_tab[8*16]=
{ {
/* OCT 0 */ /* OCT 0 */
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV),
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV),
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV),
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV),
/* OCT 1 */ /* OCT 1 */
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV),
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV),
UINT32(0.000/DV), UINT32(0.750/DV), UINT32(1.125/DV), UINT32(1.500/DV), uint32_t(0.000/DV), uint32_t(0.750/DV), uint32_t(1.125/DV), uint32_t(1.500/DV),
UINT32(1.875/DV), UINT32(2.250/DV), UINT32(2.625/DV), UINT32(3.000/DV), uint32_t(1.875/DV), uint32_t(2.250/DV), uint32_t(2.625/DV), uint32_t(3.000/DV),
/* OCT 2 */ /* OCT 2 */
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV),
UINT32(0.000/DV), UINT32(1.125/DV), UINT32(1.875/DV), UINT32(2.625/DV), uint32_t(0.000/DV), uint32_t(1.125/DV), uint32_t(1.875/DV), uint32_t(2.625/DV),
UINT32(3.000/DV), UINT32(3.750/DV), UINT32(4.125/DV), UINT32(4.500/DV), uint32_t(3.000/DV), uint32_t(3.750/DV), uint32_t(4.125/DV), uint32_t(4.500/DV),
UINT32(4.875/DV), UINT32(5.250/DV), UINT32(5.625/DV), UINT32(6.000/DV), uint32_t(4.875/DV), uint32_t(5.250/DV), uint32_t(5.625/DV), uint32_t(6.000/DV),
/* OCT 3 */ /* OCT 3 */
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(0.000/DV), UINT32(1.875/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(1.875/DV),
UINT32(3.000/DV), UINT32(4.125/DV), UINT32(4.875/DV), UINT32(5.625/DV), uint32_t(3.000/DV), uint32_t(4.125/DV), uint32_t(4.875/DV), uint32_t(5.625/DV),
UINT32(6.000/DV), UINT32(6.750/DV), UINT32(7.125/DV), UINT32(7.500/DV), uint32_t(6.000/DV), uint32_t(6.750/DV), uint32_t(7.125/DV), uint32_t(7.500/DV),
UINT32(7.875/DV), UINT32(8.250/DV), UINT32(8.625/DV), UINT32(9.000/DV), uint32_t(7.875/DV), uint32_t(8.250/DV), uint32_t(8.625/DV), uint32_t(9.000/DV),
/* OCT 4 */ /* OCT 4 */
UINT32(0.000/DV), UINT32(0.000/DV), UINT32(3.000/DV), UINT32(4.875/DV), uint32_t(0.000/DV), uint32_t(0.000/DV), uint32_t(3.000/DV), uint32_t(4.875/DV),
UINT32(6.000/DV), UINT32(7.125/DV), UINT32(7.875/DV), UINT32(8.625/DV), uint32_t(6.000/DV), uint32_t(7.125/DV), uint32_t(7.875/DV), uint32_t(8.625/DV),
UINT32(9.000/DV), UINT32(9.750/DV),UINT32(10.125/DV),UINT32(10.500/DV), uint32_t(9.000/DV), uint32_t(9.750/DV),uint32_t(10.125/DV),uint32_t(10.500/DV),
UINT32(10.875/DV),UINT32(11.250/DV),UINT32(11.625/DV),UINT32(12.000/DV), uint32_t(10.875/DV),uint32_t(11.250/DV),uint32_t(11.625/DV),uint32_t(12.000/DV),
/* OCT 5 */ /* OCT 5 */
UINT32(0.000/DV), UINT32(3.000/DV), UINT32(6.000/DV), UINT32(7.875/DV), uint32_t(0.000/DV), uint32_t(3.000/DV), uint32_t(6.000/DV), uint32_t(7.875/DV),
UINT32(9.000/DV),UINT32(10.125/DV),UINT32(10.875/DV),UINT32(11.625/DV), uint32_t(9.000/DV),uint32_t(10.125/DV),uint32_t(10.875/DV),uint32_t(11.625/DV),
UINT32(12.000/DV),UINT32(12.750/DV),UINT32(13.125/DV),UINT32(13.500/DV), uint32_t(12.000/DV),uint32_t(12.750/DV),uint32_t(13.125/DV),uint32_t(13.500/DV),
UINT32(13.875/DV),UINT32(14.250/DV),UINT32(14.625/DV),UINT32(15.000/DV), uint32_t(13.875/DV),uint32_t(14.250/DV),uint32_t(14.625/DV),uint32_t(15.000/DV),
/* OCT 6 */ /* OCT 6 */
UINT32(0.000/DV), UINT32(6.000/DV), UINT32(9.000/DV),UINT32(10.875/DV), uint32_t(0.000/DV), uint32_t(6.000/DV), uint32_t(9.000/DV),uint32_t(10.875/DV),
UINT32(12.000/DV),UINT32(13.125/DV),UINT32(13.875/DV),UINT32(14.625/DV), uint32_t(12.000/DV),uint32_t(13.125/DV),uint32_t(13.875/DV),uint32_t(14.625/DV),
UINT32(15.000/DV),UINT32(15.750/DV),UINT32(16.125/DV),UINT32(16.500/DV), uint32_t(15.000/DV),uint32_t(15.750/DV),uint32_t(16.125/DV),uint32_t(16.500/DV),
UINT32(16.875/DV),UINT32(17.250/DV),UINT32(17.625/DV),UINT32(18.000/DV), uint32_t(16.875/DV),uint32_t(17.250/DV),uint32_t(17.625/DV),uint32_t(18.000/DV),
/* OCT 7 */ /* OCT 7 */
UINT32(0.000/DV), UINT32(9.000/DV),UINT32(12.000/DV),UINT32(13.875/DV), uint32_t(0.000/DV), uint32_t(9.000/DV),uint32_t(12.000/DV),uint32_t(13.875/DV),
UINT32(15.000/DV),UINT32(16.125/DV),UINT32(16.875/DV),UINT32(17.625/DV), uint32_t(15.000/DV),uint32_t(16.125/DV),uint32_t(16.875/DV),uint32_t(17.625/DV),
UINT32(18.000/DV),UINT32(18.750/DV),UINT32(19.125/DV),UINT32(19.500/DV), uint32_t(18.000/DV),uint32_t(18.750/DV),uint32_t(19.125/DV),uint32_t(19.500/DV),
UINT32(19.875/DV),UINT32(20.250/DV),UINT32(20.625/DV),UINT32(21.000/DV) uint32_t(19.875/DV),uint32_t(20.250/DV),uint32_t(20.625/DV),uint32_t(21.000/DV)
}; };
#undef DV #undef DV
/* 0 / 3.0 / 1.5 / 6.0 dB/OCT */ /* 0 / 3.0 / 1.5 / 6.0 dB/OCT */
static const UINT32 ksl_shift[4] = { 31, 1, 2, 0 }; static const uint32_t ksl_shift[4] = { 31, 1, 2, 0 };
/* sustain level table (3dB per step) */ /* sustain level table (3dB per step) */
/* 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)*/ /* 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)*/
#define SC(db) (UINT32) ( db * (2.0/ENV_STEP) ) #define SC(db) (uint32_t) ( db * (2.0/ENV_STEP) )
static const UINT32 sl_tab[16]={ static const uint32_t sl_tab[16]={
SC( 0),SC( 1),SC( 2),SC(3 ),SC(4 ),SC(5 ),SC(6 ),SC( 7), SC( 0),SC( 1),SC( 2),SC(3 ),SC(4 ),SC(5 ),SC(6 ),SC( 7),
SC( 8),SC( 9),SC(10),SC(11),SC(12),SC(13),SC(14),SC(31) SC( 8),SC( 9),SC(10),SC(11),SC(12),SC(13),SC(14),SC(31)
}; };
#undef SC #undef SC
#define RATE_STEPS (8) #define RATE_STEPS (8)
static const unsigned char eg_inc[15*RATE_STEPS]={ static const unsigned char eg_inc[15*RATE_STEPS]={
/*cycle:0 1 2 3 4 5 6 7*/ /*cycle:0 1 2 3 4 5 6 7*/
/* 0 */ 0,1, 0,1, 0,1, 0,1, /* rates 00..12 0 (increment by 0 or 1) */ /* 0 */ 0,1, 0,1, 0,1, 0,1, /* rates 00..12 0 (increment by 0 or 1) */
@ -366,7 +358,7 @@ static const unsigned char eg_inc[15*RATE_STEPS]={
#define O(a) (a*RATE_STEPS) #define O(a) (a*RATE_STEPS)
/*note that there is no O(13) in this table - it's directly in the code */ /*note that there is no O(13) in this table - it's directly in the code */
static const unsigned char eg_rate_select[16+64+16]={ /* Envelope Generator rates (16 + 64 rates + 16 RKS) */ static const unsigned char eg_rate_select[16+64+16]={ /* Envelope Generator rates (16 + 64 rates + 16 RKS) */
/* 16 infinite time rates */ /* 16 infinite time rates */
O(14),O(14),O(14),O(14),O(14),O(14),O(14),O(14), O(14),O(14),O(14),O(14),O(14),O(14),O(14),O(14),
O(14),O(14),O(14),O(14),O(14),O(14),O(14),O(14), O(14),O(14),O(14),O(14),O(14),O(14),O(14),O(14),
@ -407,7 +399,7 @@ O(12),O(12),O(12),O(12),O(12),O(12),O(12),O(12),
/*mask 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 0, 0, 0 */ /*mask 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 0, 0, 0 */
#define O(a) (a*1) #define O(a) (a*1)
static const unsigned char eg_rate_shift[16+64+16]={ /* Envelope Generator counter shifts (16 + 64 rates + 16 RKS) */ static const unsigned char eg_rate_shift[16+64+16]={ /* Envelope Generator counter shifts (16 + 64 rates + 16 RKS) */
/* 16 infinite time rates */ /* 16 infinite time rates */
O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0),
O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0),
@ -446,22 +438,22 @@ O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),
/* multiple table */ /* multiple table */
#define ML 2 #define ML 2
static const UINT8 mul_tab[16]= { static const uint8_t mul_tab[16]= {
/* 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,10,12,12,15,15 */ /* 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,10,12,12,15,15 */
UINT8(0.50*ML), UINT8(1.00*ML), UINT8(2.00*ML), UINT8(3.00*ML), UINT8(4.00*ML), UINT8(5.00*ML), UINT8(6.00*ML), UINT8(7.00*ML), uint8_t(0.50*ML), uint8_t(1.00*ML), uint8_t(2.00*ML), uint8_t(3.00*ML), uint8_t(4.00*ML), uint8_t(5.00*ML), uint8_t(6.00*ML), uint8_t(7.00*ML),
UINT8(8.00*ML), UINT8(9.00*ML),UINT8(10.00*ML),UINT8(10.00*ML),UINT8(12.00*ML),UINT8(12.00*ML),UINT8(15.00*ML),UINT8(15.00*ML) uint8_t(8.00*ML), uint8_t(9.00*ML),uint8_t(10.00*ML),uint8_t(10.00*ML),uint8_t(12.00*ML),uint8_t(12.00*ML),uint8_t(15.00*ML),uint8_t(15.00*ML)
}; };
#undef ML #undef ML
/* TL_TAB_LEN is calculated as: /* TL_TAB_LEN is calculated as:
* 12 - sinus amplitude bits (Y axis) * 12 - sinus amplitude bits (Y axis)
* 2 - sinus sign bit (Y axis) * 2 - sinus sign bit (Y axis)
* TL_RES_LEN - sinus resolution (X axis) * TL_RES_LEN - sinus resolution (X axis)
*/ */
#define TL_TAB_LEN (12*2*TL_RES_LEN) #define TL_TAB_LEN (12*2*TL_RES_LEN)
static signed int tl_tab[TL_TAB_LEN]; static signed int tl_tab[TL_TAB_LEN];
#define ENV_QUIET (TL_TAB_LEN>>4) #define ENV_QUIET (TL_TAB_LEN>>4)
/* sin waveform table in 'decibel' scale */ /* sin waveform table in 'decibel' scale */
/* four waveforms on OPL2 type chips */ /* four waveforms on OPL2 type chips */
@ -473,17 +465,17 @@ static unsigned int sin_tab[SIN_LEN * 4];
Length: 210 elements. Length: 210 elements.
Each of the elements has to be repeated Each of the elements has to be repeated
exactly 64 times (on 64 consecutive samples). exactly 64 times (on 64 consecutive samples).
The whole table takes: 64 * 210 = 13440 samples. The whole table takes: 64 * 210 = 13440 samples.
When AM = 1 data is used directly When AM = 1 data is used directly
When AM = 0 data is divided by 4 before being used (loosing precision is important) When AM = 0 data is divided by 4 before being used (losing precision is important)
*/ */
#define LFO_AM_TAB_ELEMENTS 210 #define LFO_AM_TAB_ELEMENTS 210
static const UINT8 lfo_am_table[LFO_AM_TAB_ELEMENTS] = { static const uint8_t lfo_am_table[LFO_AM_TAB_ELEMENTS] = {
0,0,0,0,0,0,0, 0,0,0,0,0,0,0,
1,1,1,1, 1,1,1,1,
2,2,2,2, 2,2,2,2,
@ -539,39 +531,38 @@ static const UINT8 lfo_am_table[LFO_AM_TAB_ELEMENTS] = {
}; };
/* LFO Phase Modulation table (verified on real YM3812) */ /* LFO Phase Modulation table (verified on real YM3812) */
static const INT8 lfo_pm_table[8*8*2] = { static const int8_t lfo_pm_table[8*8*2] = {
/* FNUM2/FNUM = 00 0xxxxxxx (0x0000) */ /* FNUM2/FNUM = 00 0xxxxxxx (0x0000) */
0, 0, 0, 0, 0, 0, 0, 0, /*LFO PM depth = 0*/ 0, 0, 0, 0, 0, 0, 0, 0, /*LFO PM depth = 0*/
0, 0, 0, 0, 0, 0, 0, 0, /*LFO PM depth = 1*/ 0, 0, 0, 0, 0, 0, 0, 0, /*LFO PM depth = 1*/
/* FNUM2/FNUM = 00 1xxxxxxx (0x0080) */ /* FNUM2/FNUM = 00 1xxxxxxx (0x0080) */
0, 0, 0, 0, 0, 0, 0, 0, /*LFO PM depth = 0*/ 0, 0, 0, 0, 0, 0, 0, 0, /*LFO PM depth = 0*/
1, 0, 0, 0,-1, 0, 0, 0, /*LFO PM depth = 1*/ 1, 0, 0, 0,-1, 0, 0, 0, /*LFO PM depth = 1*/
/* FNUM2/FNUM = 01 0xxxxxxx (0x0100) */ /* FNUM2/FNUM = 01 0xxxxxxx (0x0100) */
1, 0, 0, 0,-1, 0, 0, 0, /*LFO PM depth = 0*/ 1, 0, 0, 0,-1, 0, 0, 0, /*LFO PM depth = 0*/
2, 1, 0,-1,-2,-1, 0, 1, /*LFO PM depth = 1*/ 2, 1, 0,-1,-2,-1, 0, 1, /*LFO PM depth = 1*/
/* FNUM2/FNUM = 01 1xxxxxxx (0x0180) */ /* FNUM2/FNUM = 01 1xxxxxxx (0x0180) */
1, 0, 0, 0,-1, 0, 0, 0, /*LFO PM depth = 0*/ 1, 0, 0, 0,-1, 0, 0, 0, /*LFO PM depth = 0*/
3, 1, 0,-1,-3,-1, 0, 1, /*LFO PM depth = 1*/ 3, 1, 0,-1,-3,-1, 0, 1, /*LFO PM depth = 1*/
/* FNUM2/FNUM = 10 0xxxxxxx (0x0200) */ /* FNUM2/FNUM = 10 0xxxxxxx (0x0200) */
2, 1, 0,-1,-2,-1, 0, 1, /*LFO PM depth = 0*/ 2, 1, 0,-1,-2,-1, 0, 1, /*LFO PM depth = 0*/
4, 2, 0,-2,-4,-2, 0, 2, /*LFO PM depth = 1*/ 4, 2, 0,-2,-4,-2, 0, 2, /*LFO PM depth = 1*/
/* FNUM2/FNUM = 10 1xxxxxxx (0x0280) */ /* FNUM2/FNUM = 10 1xxxxxxx (0x0280) */
2, 1, 0,-1,-2,-1, 0, 1, /*LFO PM depth = 0*/ 2, 1, 0,-1,-2,-1, 0, 1, /*LFO PM depth = 0*/
5, 2, 0,-2,-5,-2, 0, 2, /*LFO PM depth = 1*/ 5, 2, 0,-2,-5,-2, 0, 2, /*LFO PM depth = 1*/
/* FNUM2/FNUM = 11 0xxxxxxx (0x0300) */ /* FNUM2/FNUM = 11 0xxxxxxx (0x0300) */
3, 1, 0,-1,-3,-1, 0, 1, /*LFO PM depth = 0*/ 3, 1, 0,-1,-3,-1, 0, 1, /*LFO PM depth = 0*/
6, 3, 0,-3,-6,-3, 0, 3, /*LFO PM depth = 1*/ 6, 3, 0,-3,-6,-3, 0, 3, /*LFO PM depth = 1*/
/* FNUM2/FNUM = 11 1xxxxxxx (0x0380) */ /* FNUM2/FNUM = 11 1xxxxxxx (0x0380) */
3, 1, 0,-1,-3,-1, 0, 1, /*LFO PM depth = 0*/ 3, 1, 0,-1,-3,-1, 0, 1, /*LFO PM depth = 0*/
7, 3, 0,-3,-7,-3, 0, 3 /*LFO PM depth = 1*/ 7, 3, 0,-3,-7,-3, 0, 3 /*LFO PM depth = 1*/
}; };
@ -582,8 +573,8 @@ static int num_lock = 0;
static signed int phase_modulation; /* phase modulation input (SLOT 2) */ static signed int phase_modulation; /* phase modulation input (SLOT 2) */
static signed int output; static signed int output;
static UINT32 LFO_AM; static uint32_t LFO_AM;
static INT32 LFO_PM; static int32_t LFO_PM;
static bool CalcVoice (FM_OPL *OPL, int voice, float *buffer, int length); static bool CalcVoice (FM_OPL *OPL, int voice, float *buffer, int length);
static bool CalcRhythm (FM_OPL *OPL, float *buffer, int length); static bool CalcRhythm (FM_OPL *OPL, float *buffer, int length);
@ -591,21 +582,21 @@ static bool CalcRhythm (FM_OPL *OPL, float *buffer, int length);
/* status set and IRQ handling */ /* status set and IRQ handling */
INLINE void OPL_STATUS_SET(FM_OPL *OPL,int flag) static inline void OPL_STATUS_SET(FM_OPL *OPL,int flag)
{ {
/* set status flag */ /* set status flag */
OPL->status |= flag; OPL->status |= flag;
if(!(OPL->status & 0x80)) if(!(OPL->status & 0x80))
{ {
if(OPL->status & OPL->statusmask) if(OPL->status & OPL->statusmask)
{ /* IRQ on */ { /* IRQ on */
OPL->status |= 0x80; OPL->status |= 0x80;
} }
} }
} }
/* status reset and IRQ handling */ /* status reset and IRQ handling */
INLINE void OPL_STATUS_RESET(FM_OPL *OPL,int flag) static inline void OPL_STATUS_RESET(FM_OPL *OPL,int flag)
{ {
/* reset status flag */ /* reset status flag */
OPL->status &=~flag; OPL->status &=~flag;
@ -619,7 +610,7 @@ INLINE void OPL_STATUS_RESET(FM_OPL *OPL,int flag)
} }
/* IRQ mask set */ /* IRQ mask set */
INLINE void OPL_STATUSMASK_SET(FM_OPL *OPL,int flag) static inline void OPL_STATUSMASK_SET(FM_OPL *OPL,int flag)
{ {
OPL->statusmask = flag; OPL->statusmask = flag;
/* IRQ handling check */ /* IRQ handling check */
@ -629,13 +620,13 @@ INLINE void OPL_STATUSMASK_SET(FM_OPL *OPL,int flag)
/* advance LFO to next sample */ /* advance LFO to next sample */
INLINE void advance_lfo(FM_OPL *OPL) static inline void advance_lfo(FM_OPL *OPL)
{ {
UINT8 tmp; uint8_t tmp;
/* LFO */ /* LFO */
OPL->lfo_am_cnt += OPL->lfo_am_inc; OPL->lfo_am_cnt += OPL->lfo_am_inc;
if (OPL->lfo_am_cnt >= (UINT32)(LFO_AM_TAB_ELEMENTS<<LFO_SH) ) /* lfo_am_table is 210 elements long */ if (OPL->lfo_am_cnt >= (uint32_t)(LFO_AM_TAB_ELEMENTS<<LFO_SH) ) /* lfo_am_table is 210 elements long */
OPL->lfo_am_cnt -= (LFO_AM_TAB_ELEMENTS<<LFO_SH); OPL->lfo_am_cnt -= (LFO_AM_TAB_ELEMENTS<<LFO_SH);
tmp = lfo_am_table[ OPL->lfo_am_cnt >> LFO_SH ]; tmp = lfo_am_table[ OPL->lfo_am_cnt >> LFO_SH ];
@ -650,7 +641,7 @@ INLINE void advance_lfo(FM_OPL *OPL)
} }
/* advance to next sample */ /* advance to next sample */
INLINE void advance(FM_OPL *OPL, int loch, int hich) static inline void advance(FM_OPL *OPL, int loch, int hich)
{ {
OPL_CH *CH; OPL_CH *CH;
OPL_SLOT *op; OPL_SLOT *op;
@ -690,28 +681,28 @@ INLINE void advance(FM_OPL *OPL, int loch, int hich)
} }
break; break;
case EG_DEC: /* decay phase */ case EG_DEC: /* decay phase */
if ( !(OPL->eg_cnt & ((1<<op->eg_sh_dr)-1) ) ) if ( !(OPL->eg_cnt & ((1<<op->eg_sh_dr)-1) ) )
{ {
op->volume += eg_inc[op->eg_sel_dr + ((OPL->eg_cnt>>op->eg_sh_dr)&7)]; op->volume += eg_inc[op->eg_sel_dr + ((OPL->eg_cnt>>op->eg_sh_dr)&7)];
if ( op->volume >= (INT32)op->sl ) if ( op->volume >= (int32_t)op->sl )
op->state = EG_SUS; op->state = EG_SUS;
} }
break; break;
case EG_SUS: /* sustain phase */ case EG_SUS: /* sustain phase */
/* this is important behaviour: /* this is important behaviour:
one can change percusive/non-percussive modes on the fly and one can change percusive/non-percussive modes on the fly and
the chip will remain in sustain phase - verified on real YM3812 */ the chip will remain in sustain phase - verified on real YM3812 */
if(op->eg_type) /* non-percussive mode */ if(op->eg_type) /* non-percussive mode */
{ {
/* do nothing */ /* do nothing */
} }
else /* percussive mode */ else /* percussive mode */
{ {
/* during sustain phase chip adds Release Rate (in percussive mode) */ /* during sustain phase chip adds Release Rate (in percussive mode) */
if ( !(OPL->eg_cnt & ((1<<op->eg_sh_rr)-1) ) ) if ( !(OPL->eg_cnt & ((1<<op->eg_sh_rr)-1) ) )
@ -725,7 +716,7 @@ INLINE void advance(FM_OPL *OPL, int loch, int hich)
} }
break; break;
case EG_REL: /* release phase */ case EG_REL: /* release phase */
if ( !(OPL->eg_cnt & ((1<<op->eg_sh_rr)-1) ) ) if ( !(OPL->eg_cnt & ((1<<op->eg_sh_rr)-1) ) )
{ {
op->volume += eg_inc[op->eg_sel_rr + ((OPL->eg_cnt>>op->eg_sh_rr)&7)]; op->volume += eg_inc[op->eg_sel_rr + ((OPL->eg_cnt>>op->eg_sh_rr)&7)];
@ -746,7 +737,7 @@ INLINE void advance(FM_OPL *OPL, int loch, int hich)
/* Phase Generator */ /* Phase Generator */
if(op->vib) if(op->vib)
{ {
UINT8 block; uint8_t block;
unsigned int block_fnum = CH->block_fnum; unsigned int block_fnum = CH->block_fnum;
unsigned int fnum_lfo = (block_fnum&0x0380) >> 7; unsigned int fnum_lfo = (block_fnum&0x0380) >> 7;
@ -772,37 +763,37 @@ INLINE void advance(FM_OPL *OPL, int loch, int hich)
} }
} }
INLINE void advance_noise(FM_OPL *OPL) static inline void advance_noise(FM_OPL *OPL)
{ {
int i; int i;
/* The Noise Generator of the YM3812 is 23-bit shift register. /* The Noise Generator of the YM3812 is 23-bit shift register.
* Period is equal to 2^23-2 samples. * Period is equal to 2^23-2 samples.
* Register works at sampling frequency of the chip, so output * Register works at sampling frequency of the chip, so output
* can change on every sample. * can change on every sample.
* *
* Output of the register and input to the bit 22 is: * Output of the register and input to the bit 22 is:
* bit0 XOR bit14 XOR bit15 XOR bit22 * bit0 XOR bit14 XOR bit15 XOR bit22
* *
* Simply use bit 22 as the noise output. * Simply use bit 22 as the noise output.
*/ */
OPL->noise_p += OPL->noise_f; OPL->noise_p += OPL->noise_f;
i = OPL->noise_p >> FREQ_SH; /* number of events (shifts of the shift register) */ i = OPL->noise_p >> FREQ_SH; /* number of events (shifts of the shift register) */
OPL->noise_p &= FREQ_MASK; OPL->noise_p &= FREQ_MASK;
while (i) while (i)
{ {
/* /*
UINT32 j; uint32_t j;
j = ( (OPL->noise_rng) ^ (OPL->noise_rng>>14) ^ (OPL->noise_rng>>15) ^ (OPL->noise_rng>>22) ) & 1; j = ( (OPL->noise_rng) ^ (OPL->noise_rng>>14) ^ (OPL->noise_rng>>15) ^ (OPL->noise_rng>>22) ) & 1;
OPL->noise_rng = (j<<22) | (OPL->noise_rng>>1); OPL->noise_rng = (j<<22) | (OPL->noise_rng>>1);
*/ */
/* /*
Instead of doing all the logic operations above, we Instead of doing all the logic operations above, we
use a trick here (and use bit 0 as the noise output). use a trick here (and use bit 0 as the noise output).
The difference is only that the noise bit changes one The difference is only that the noise bit changes one
step ahead. This doesn't matter since we don't know step ahead. This doesn't matter since we don't know
what is real state of the noise_rng after the reset. what is real state of the noise_rng after the reset.
*/ */
@ -814,9 +805,9 @@ INLINE void advance_noise(FM_OPL *OPL)
} }
INLINE signed int op_calc(UINT32 phase, unsigned int env, signed int pm, unsigned int wave_tab) static inline signed int op_calc(uint32_t phase, unsigned int env, signed int pm, unsigned int wave_tab)
{ {
UINT32 p; uint32_t p;
p = (env<<4) + sin_tab[wave_tab + ((((signed int)((phase & ~FREQ_MASK) + (pm<<16))) >> FREQ_SH ) & SIN_MASK) ]; p = (env<<4) + sin_tab[wave_tab + ((((signed int)((phase & ~FREQ_MASK) + (pm<<16))) >> FREQ_SH ) & SIN_MASK) ];
@ -825,9 +816,9 @@ INLINE signed int op_calc(UINT32 phase, unsigned int env, signed int pm, unsigne
return tl_tab[p]; return tl_tab[p];
} }
INLINE signed int op_calc1(UINT32 phase, unsigned int env, signed int pm, unsigned int wave_tab) static inline signed int op_calc1(uint32_t phase, unsigned int env, signed int pm, unsigned int wave_tab)
{ {
UINT32 p; uint32_t p;
p = (env<<4) + sin_tab[wave_tab + ((((signed int)((phase & ~FREQ_MASK) + pm )) >> FREQ_SH ) & SIN_MASK) ]; p = (env<<4) + sin_tab[wave_tab + ((((signed int)((phase & ~FREQ_MASK) + pm )) >> FREQ_SH ) & SIN_MASK) ];
@ -837,10 +828,10 @@ INLINE signed int op_calc1(UINT32 phase, unsigned int env, signed int pm, unsign
} }
#define volume_calc(OP) ((OP)->TLL + ((UINT32)(OP)->volume) + (LFO_AM & (OP)->AMmask)) #define volume_calc(OP) ((OP)->TLL + ((uint32_t)(OP)->volume) + (LFO_AM & (OP)->AMmask))
/* calculate output */ /* calculate output */
INLINE float OPL_CALC_CH( OPL_CH *CH ) static inline float OPL_CALC_CH( OPL_CH *CH )
{ {
OPL_SLOT *SLOT; OPL_SLOT *SLOT;
unsigned int env; unsigned int env;
@ -875,9 +866,9 @@ INLINE float OPL_CALC_CH( OPL_CH *CH )
} }
/* /*
operators used in the rhythm sounds generation process: operators used in the rhythm sounds generation process:
Envelope Generator: Envelope Generator:
channel operator register number Bass High Snare Tom Top channel operator register number Bass High Snare Tom Top
/ slot number TL ARDR SLRR Wave Drum Hat Drum Tom Cymbal / slot number TL ARDR SLRR Wave Drum Hat Drum Tom Cymbal
@ -911,7 +902,7 @@ number number BLK/FNUM2 FNUM Drum Hat Drum Tom Cymbal
/* calculate rhythm */ /* calculate rhythm */
INLINE void OPL_CALC_RH( OPL_CH *CH, unsigned int noise ) static inline void OPL_CALC_RH( OPL_CH *CH, unsigned int noise )
{ {
OPL_SLOT *SLOT; OPL_SLOT *SLOT;
signed int out; signed int out;
@ -988,7 +979,7 @@ INLINE void OPL_CALC_RH( OPL_CH *CH, unsigned int noise )
/* when res1 = 0 phase = 0x000 | 0xd0; */ /* when res1 = 0 phase = 0x000 | 0xd0; */
/* when res1 = 1 phase = 0x200 | (0xd0>>2); */ /* when res1 = 1 phase = 0x200 | (0xd0>>2); */
UINT32 phase = res1 ? (0x200|(0xd0>>2)) : 0xd0; uint32_t phase = res1 ? (0x200|(0xd0>>2)) : 0xd0;
/* enable gate based on frequency of operator 2 in channel 8 */ /* enable gate based on frequency of operator 2 in channel 8 */
unsigned char bit5e= ((CH[8].SLOT[SLOT2].Cnt>>FREQ_SH)>>5)&1; unsigned char bit5e= ((CH[8].SLOT[SLOT2].Cnt>>FREQ_SH)>>5)&1;
@ -1029,7 +1020,7 @@ INLINE void OPL_CALC_RH( OPL_CH *CH, unsigned int noise )
/* when bit8 = 0 phase = 0x100; */ /* when bit8 = 0 phase = 0x100; */
/* when bit8 = 1 phase = 0x200; */ /* when bit8 = 1 phase = 0x200; */
UINT32 phase = bit8 ? 0x200 : 0x100; uint32_t phase = bit8 ? 0x200 : 0x100;
/* Noise bit XOR'es phase by 0x100 */ /* Noise bit XOR'es phase by 0x100 */
/* when noisebit = 0 pass the phase from calculation above */ /* when noisebit = 0 pass the phase from calculation above */
@ -1059,7 +1050,7 @@ INLINE void OPL_CALC_RH( OPL_CH *CH, unsigned int noise )
/* when res1 = 0 phase = 0x000 | 0x100; */ /* when res1 = 0 phase = 0x000 | 0x100; */
/* when res1 = 1 phase = 0x200 | 0x100; */ /* when res1 = 1 phase = 0x200 | 0x100; */
UINT32 phase = res1 ? 0x300 : 0x100; uint32_t phase = res1 ? 0x300 : 0x100;
/* enable gate based on frequency of operator 2 in channel 8 */ /* enable gate based on frequency of operator 2 in channel 8 */
unsigned char bit5e= ((CH[8].SLOT[SLOT2].Cnt>>FREQ_SH)>>5)&1; unsigned char bit5e= ((CH[8].SLOT[SLOT2].Cnt>>FREQ_SH)>>5)&1;
@ -1073,7 +1064,6 @@ INLINE void OPL_CALC_RH( OPL_CH *CH, unsigned int noise )
output += op_calc(phase<<FREQ_SH, env, 0, CH[8].SLOT[SLOT2].wavetable) * 2; output += op_calc(phase<<FREQ_SH, env, 0, CH[8].SLOT[SLOT2].wavetable) * 2;
} }
} }
@ -1100,11 +1090,11 @@ static void init_tables(void)
/* we never reach (1<<16) here due to the (x+1) */ /* we never reach (1<<16) here due to the (x+1) */
/* result fits within 16 bits at maximum */ /* result fits within 16 bits at maximum */
n = (int)m; /* 16 bits here */ n = (int)m; /* 16 bits here */
n >>= 4; /* 12 bits here */ n >>= 4; /* 12 bits here */
n = (n+1)>>1; /* round to nearest */ n = (n+1)>>1; /* round to nearest */
/* 11 bits here (rounded) */ /* 11 bits here (rounded) */
n <<= 1; /* 12 bits here (as in real chip) */ n <<= 1; /* 12 bits here (as in real chip) */
tl_tab[ x*2 + 0 ] = n; tl_tab[ x*2 + 0 ] = n;
tl_tab[ x*2 + 1 ] = -tl_tab[ x*2 + 0 ]; tl_tab[ x*2 + 1 ] = -tl_tab[ x*2 + 0 ];
@ -1123,14 +1113,14 @@ static void init_tables(void)
/* we never reach zero here due to ((i*2)+1) */ /* we never reach zero here due to ((i*2)+1) */
if (m>0.0) if (m>0.0)
o = 8*log(1.0/m)/log(2.0); /* convert to 'decibels' */ o = 8*log(1.0/m)/log(2.0); /* convert to 'decibels' */
else else
o = 8*log(-1.0/m)/log(2.0); /* convert to 'decibels' */ o = 8*log(-1.0/m)/log(2.0); /* convert to 'decibels' */
o = o / (ENV_STEP/4); o = o / (ENV_STEP/4);
n = (int)(2.0*o); n = (int)(2.0*o);
if (n&1) /* round to nearest */ if (n&1) /* round to nearest */
n = (n>>1)+1; n = (n>>1)+1;
else else
n = n>>1; n = n>>1;
@ -1176,18 +1166,18 @@ static void OPL_initalize(FM_OPL *OPL)
for( i=0 ; i < 1024 ; i++ ) for( i=0 ; i < 1024 ; i++ )
{ {
/* opn phase increment counter = 20bit */ /* opn phase increment counter = 20bit */
OPL->fn_tab[i] = (UINT32)( (double)i * 64 * OPL_FREQBASE * (1<<(FREQ_SH-10)) ); /* -10 because chip works with 10.10 fixed point, while we use 16.16 */ OPL->fn_tab[i] = (uint32_t)( (double)i * 64 * OPL_FREQBASE * (1<<(FREQ_SH-10)) ); /* -10 because chip works with 10.10 fixed point, while we use 16.16 */
} }
/* Amplitude modulation: 27 output levels (triangle waveform); 1 level takes one of: 192, 256 or 448 samples */ /* Amplitude modulation: 27 output levels (triangle waveform); 1 level takes one of: 192, 256 or 448 samples */
/* One entry from LFO_AM_TABLE lasts for 64 samples */ /* One entry from LFO_AM_TABLE lasts for 64 samples */
OPL->lfo_am_inc = UINT32((1.0 / 64.0 ) * (1<<LFO_SH) * OPL_FREQBASE); OPL->lfo_am_inc = uint32_t((1.0 / 64.0 ) * (1<<LFO_SH) * OPL_FREQBASE);
/* Vibrato: 8 output levels (triangle waveform); 1 level takes 1024 samples */ /* Vibrato: 8 output levels (triangle waveform); 1 level takes 1024 samples */
OPL->lfo_pm_inc = UINT32((1.0 / 1024.0) * (1<<LFO_SH) * OPL_FREQBASE); OPL->lfo_pm_inc = uint32_t((1.0 / 1024.0) * (1<<LFO_SH) * OPL_FREQBASE);
OPL->eg_timer_add = UINT32((1<<EG_SH) * OPL_FREQBASE); OPL->eg_timer_add = uint32_t((1<<EG_SH) * OPL_FREQBASE);
OPL->eg_timer_overflow = UINT32(( 1 ) * (1<<EG_SH)); OPL->eg_timer_overflow = uint32_t(( 1 ) * (1<<EG_SH));
// [RH] Support full MIDI panning. (But default to mono and center panning.) // [RH] Support full MIDI panning. (But default to mono and center panning.)
OPL->IsStereo = false; OPL->IsStereo = false;
@ -1198,7 +1188,7 @@ static void OPL_initalize(FM_OPL *OPL)
} }
} }
INLINE void FM_KEYON(OPL_SLOT *SLOT, UINT32 key_set) static inline void FM_KEYON(OPL_SLOT *SLOT, uint32_t key_set)
{ {
if( !SLOT->key ) if( !SLOT->key )
{ {
@ -1210,7 +1200,7 @@ INLINE void FM_KEYON(OPL_SLOT *SLOT, UINT32 key_set)
SLOT->key |= key_set; SLOT->key |= key_set;
} }
INLINE void FM_KEYOFF(OPL_SLOT *SLOT, UINT32 key_clr) static inline void FM_KEYOFF(OPL_SLOT *SLOT, uint32_t key_clr)
{ {
if( SLOT->key ) if( SLOT->key )
{ {
@ -1226,7 +1216,7 @@ INLINE void FM_KEYOFF(OPL_SLOT *SLOT, UINT32 key_clr)
} }
/* update phase increment counter of operator (also update the EG rates if necessary) */ /* update phase increment counter of operator (also update the EG rates if necessary) */
void CALC_FCSLOT(OPL_CH *CH,OPL_SLOT *SLOT) static inline void CALC_FCSLOT(OPL_CH *CH,OPL_SLOT *SLOT)
{ {
int ksr; int ksr;
@ -1257,7 +1247,7 @@ void CALC_FCSLOT(OPL_CH *CH,OPL_SLOT *SLOT)
} }
/* set multi,am,vib,EG-TYP,KSR,mul */ /* set multi,am,vib,EG-TYP,KSR,mul */
void set_mul(FM_OPL *OPL,int slot,int v) static inline void set_mul(FM_OPL *OPL,int slot,int v)
{ {
OPL_CH *CH = &OPL->P_CH[slot/2]; OPL_CH *CH = &OPL->P_CH[slot/2];
OPL_SLOT *SLOT = &CH->SLOT[slot&1]; OPL_SLOT *SLOT = &CH->SLOT[slot&1];
@ -1271,7 +1261,7 @@ void set_mul(FM_OPL *OPL,int slot,int v)
} }
/* set ksl & tl */ /* set ksl & tl */
void set_ksl_tl(FM_OPL *OPL,int slot,int v) static inline void set_ksl_tl(FM_OPL *OPL,int slot,int v)
{ {
OPL_CH *CH = &OPL->P_CH[slot/2]; OPL_CH *CH = &OPL->P_CH[slot/2];
OPL_SLOT *SLOT = &CH->SLOT[slot&1]; OPL_SLOT *SLOT = &CH->SLOT[slot&1];
@ -1283,7 +1273,7 @@ void set_ksl_tl(FM_OPL *OPL,int slot,int v)
} }
/* set attack rate & decay rate */ /* set attack rate & decay rate */
INLINE void set_ar_dr(FM_OPL *OPL,int slot,int v) static inline void set_ar_dr(FM_OPL *OPL,int slot,int v)
{ {
OPL_CH *CH = &OPL->P_CH[slot/2]; OPL_CH *CH = &OPL->P_CH[slot/2];
OPL_SLOT *SLOT = &CH->SLOT[slot&1]; OPL_SLOT *SLOT = &CH->SLOT[slot&1];
@ -1307,7 +1297,7 @@ INLINE void set_ar_dr(FM_OPL *OPL,int slot,int v)
} }
/* set sustain level & release rate */ /* set sustain level & release rate */
void set_sl_rr(FM_OPL *OPL,int slot,int v) static inline void set_sl_rr(FM_OPL *OPL,int slot,int v)
{ {
OPL_CH *CH = &OPL->P_CH[slot/2]; OPL_CH *CH = &OPL->P_CH[slot/2];
OPL_SLOT *SLOT = &CH->SLOT[slot&1]; OPL_SLOT *SLOT = &CH->SLOT[slot&1];
@ -1333,31 +1323,32 @@ static void OPLWriteReg(FM_OPL *OPL, int r, int v)
switch(r&0xe0) switch(r&0xe0)
{ {
case 0x00: /* 00-1f:control */ case 0x00: /* 00-1f:control */
switch(r&0x1f) switch(r&0x1f)
{ {
case 0x01: /* waveform select enable */ case 0x01: /* waveform select enable */
OPL->wavesel = v&0x20; OPL->wavesel = v&0x20;
break; break;
case 0x02: /* Timer 1 */ case 0x02: /* Timer 1 */
OPL->T[0] = (256-v)*4; OPL->T[0] = (256-v)*4;
break; break;
case 0x03: /* Timer 2 */ case 0x03: /* Timer 2 */
OPL->T[1] = (256-v)*16; OPL->T[1] = (256-v)*16;
break; break;
case 0x04: /* IRQ clear / mask and Timer enable */ case 0x04: /* IRQ clear / mask and Timer enable */
if(v&0x80) if(v&0x80)
{ /* IRQ flag clear */ { /* IRQ flag clear */
OPL_STATUS_RESET(OPL,0x7f-0x08); /* don't reset BFRDY flag or we will have to call deltat module to set the flag */ OPL_STATUS_RESET(OPL,0x7f-0x08); /* don't reset BFRDY flag or we will have to call deltat module to set the flag */
} }
else else
{ /* set IRQ mask ,timer enable*/ { /* set IRQ mask ,timer enable*/
UINT8 st1 = v&1; uint8_t st1 = v&1;
UINT8 st2 = (v>>1)&1; uint8_t st2 = (v>>1)&1;
/* IRQRST,T1MSK,t2MSK,EOSMSK,BRMSK,x,ST2,ST1 */ /* IRQRST,T1MSK,t2MSK,EOSMSK,BRMSK,x,ST2,ST1 */
OPL_STATUS_RESET(OPL, v & (0x78-0x08) ); OPL_STATUS_RESET(OPL, v & (0x78-0x08) );
OPL_STATUSMASK_SET(OPL, (~v) & 0x78 ); OPL_STATUSMASK_SET(OPL, (~v) & 0x78 );
/* timer 2 */ /* timer 2 */
if(OPL->st[1] != st2) if(OPL->st[1] != st2)
{ {
@ -1375,7 +1366,7 @@ static void OPLWriteReg(FM_OPL *OPL, int r, int v)
break; break;
} }
break; break;
case 0x20: /* am ON, vib ON, ksr, eg_type, mul */ case 0x20: /* am ON, vib ON, ksr, eg_type, mul */
slot = slot_array[r&0x1f]; slot = slot_array[r&0x1f];
if(slot < 0) return; if(slot < 0) return;
set_mul(OPL,slot,v); set_mul(OPL,slot,v);
@ -1396,7 +1387,7 @@ static void OPLWriteReg(FM_OPL *OPL, int r, int v)
set_sl_rr(OPL,slot,v); set_sl_rr(OPL,slot,v);
break; break;
case 0xa0: case 0xa0:
if (r == 0xbd) /* am depth, vibrato depth, r,bd,sd,tom,tc,hh */ if (r == 0xbd) /* am depth, vibrato depth, r,bd,sd,tom,tc,hh */
{ {
OPL->lfo_am_depth = v & 0x80; OPL->lfo_am_depth = v & 0x80;
OPL->lfo_pm_depth_range = (v&0x40) ? 8 : 0; OPL->lfo_pm_depth_range = (v&0x40) ? 8 : 0;
@ -1449,11 +1440,11 @@ static void OPLWriteReg(FM_OPL *OPL, int r, int v)
if( (r&0x0f) > 8) return; if( (r&0x0f) > 8) return;
CH = &OPL->P_CH[r&0x0f]; CH = &OPL->P_CH[r&0x0f];
if(!(r&0x10)) if(!(r&0x10))
{ /* a0-a8 */ { /* a0-a8 */
block_fnum = (CH->block_fnum&0x1f00) | v; block_fnum = (CH->block_fnum&0x1f00) | v;
} }
else else
{ /* b0-b8 */ { /* b0-b8 */
block_fnum = ((v&0x1f)<<8) | (CH->block_fnum&0xff); block_fnum = ((v&0x1f)<<8) | (CH->block_fnum&0xff);
if(v&0x20) if(v&0x20)
@ -1468,9 +1459,9 @@ static void OPLWriteReg(FM_OPL *OPL, int r, int v)
} }
} }
/* update */ /* update */
if(CH->block_fnum != (UINT32)block_fnum) if(CH->block_fnum != (uint32_t)block_fnum)
{ {
UINT8 block = block_fnum >> 10; uint8_t block = block_fnum >> 10;
CH->block_fnum = block_fnum; CH->block_fnum = block_fnum;
@ -1480,13 +1471,13 @@ static void OPLWriteReg(FM_OPL *OPL, int r, int v)
/* BLK 2,1,0 bits -> bits 3,2,1 of kcode */ /* BLK 2,1,0 bits -> bits 3,2,1 of kcode */
CH->kcode = (CH->block_fnum&0x1c00)>>9; CH->kcode = (CH->block_fnum&0x1c00)>>9;
/* the info below is actually opposite to what is stated in the Manuals (verifed on real YM3812) */ /* the info below is actually opposite to what is stated in the Manuals (verifed on real YM3812) */
/* if notesel == 0 -> lsb of kcode is bit 10 (MSB) of fnum */ /* if notesel == 0 -> lsb of kcode is bit 10 (MSB) of fnum */
/* if notesel == 1 -> lsb of kcode is bit 9 (MSB-1) of fnum */ /* if notesel == 1 -> lsb of kcode is bit 9 (MSB-1) of fnum */
if (OPL->mode&0x40) if (OPL->mode&0x40)
CH->kcode |= (CH->block_fnum&0x100)>>8; /* notesel == 1 */ CH->kcode |= (CH->block_fnum&0x100)>>8; /* notesel == 1 */
else else
CH->kcode |= (CH->block_fnum&0x200)>>9; /* notesel == 0 */ CH->kcode |= (CH->block_fnum&0x200)>>9; /* notesel == 0 */
/* refresh Total Level in both SLOTs of this channel */ /* refresh Total Level in both SLOTs of this channel */
CH->SLOT[SLOT1].TLL = CH->SLOT[SLOT1].TL + (CH->ksl_base>>CH->SLOT[SLOT1].ksl); CH->SLOT[SLOT1].TLL = CH->SLOT[SLOT1].TL + (CH->ksl_base>>CH->SLOT[SLOT1].ksl);
@ -1527,8 +1518,8 @@ static void OPLResetChip(FM_OPL *OPL)
OPL->eg_timer = 0; OPL->eg_timer = 0;
OPL->eg_cnt = 0; OPL->eg_cnt = 0;
OPL->noise_rng = 1; /* noise shift register */ OPL->noise_rng = 1; /* noise shift register */
OPL->mode = 0; /* normal mode */ OPL->mode = 0; /* normal mode */
OPL_STATUS_RESET(OPL,0x7f); OPL_STATUS_RESET(OPL,0x7f);
/* reset with register write */ /* reset with register write */
@ -1604,15 +1595,15 @@ public:
{ {
int i; int i;
UINT8 rhythm = Chip.rhythm&0x20; uint8_t rhythm = Chip.rhythm&0x20;
UINT32 lfo_am_cnt_bak = Chip.lfo_am_cnt; uint32_t lfo_am_cnt_bak = Chip.lfo_am_cnt;
UINT32 eg_timer_bak = Chip.eg_timer; uint32_t eg_timer_bak = Chip.eg_timer;
UINT32 eg_cnt_bak = Chip.eg_cnt; uint32_t eg_cnt_bak = Chip.eg_cnt;
UINT32 lfo_am_cnt_out = lfo_am_cnt_bak; uint32_t lfo_am_cnt_out = lfo_am_cnt_bak;
UINT32 eg_timer_out = eg_timer_bak; uint32_t eg_timer_out = eg_timer_bak;
UINT32 eg_cnt_out = eg_cnt_bak; uint32_t eg_cnt_out = eg_cnt_bak;
for (i = 0; i <= (rhythm ? 5 : 8); ++i) for (i = 0; i <= (rhythm ? 5 : 8); ++i)
{ {

70
src/oplsynth/mlopl.cpp
View file

@ -69,12 +69,12 @@ musicBlock::~musicBlock ()
if (OPLinstruments != NULL) free(OPLinstruments); if (OPLinstruments != NULL) free(OPLinstruments);
} }
void musicBlock::writeFrequency(uint slot, uint note, int pitch, uint keyOn) void musicBlock::writeFrequency(uint32_t slot, uint32_t note, int pitch, uint32_t keyOn)
{ {
io->OPLwriteFreq (slot, note, pitch, keyOn); io->OPLwriteFreq (slot, note, pitch, keyOn);
} }
void musicBlock::writeModulation(uint slot, struct OPL2instrument *instr, int state) void musicBlock::writeModulation(uint32_t slot, struct OPL2instrument *instr, int state)
{ {
if (state) if (state)
state = 0x40; /* enable Frequency Vibrato */ state = 0x40; /* enable Frequency Vibrato */
@ -83,17 +83,17 @@ void musicBlock::writeModulation(uint slot, struct OPL2instrument *instr, int st
instr->trem_vibr_2 | state); instr->trem_vibr_2 | state);
} }
uint musicBlock::calcVolume(uint channelVolume, uint channelExpression, uint noteVolume) uint32_t musicBlock::calcVolume(uint32_t channelVolume, uint32_t channelExpression, uint32_t noteVolume)
{ {
noteVolume = ((ulong)channelVolume * channelExpression * noteVolume) / (127*127); noteVolume = ((uint64_t)channelVolume * channelExpression * noteVolume) / (127*127);
if (noteVolume > 127) if (noteVolume > 127)
return 127; return 127;
else else
return noteVolume; return noteVolume;
} }
int musicBlock::occupyChannel(uint slot, uint channel, int musicBlock::occupyChannel(uint32_t slot, uint32_t channel,
int note, int volume, struct OP2instrEntry *instrument, uchar secondary) int note, int volume, struct OP2instrEntry *instrument, uint8_t secondary)
{ {
struct OPL2instrument *instr; struct OPL2instrument *instr;
struct channelEntry *ch = &channels[slot]; struct channelEntry *ch = &channels[slot];
@ -142,7 +142,7 @@ int musicBlock::occupyChannel(uint slot, uint channel,
return slot; return slot;
} }
int musicBlock::releaseChannel(uint slot, uint killed) int musicBlock::releaseChannel(uint32_t slot, uint32_t killed)
{ {
struct channelEntry *ch = &channels[slot]; struct channelEntry *ch = &channels[slot];
writeFrequency(slot, ch->realnote, ch->pitch, 0); writeFrequency(slot, ch->realnote, ch->pitch, 0);
@ -157,10 +157,10 @@ int musicBlock::releaseChannel(uint slot, uint killed)
return slot; return slot;
} }
int musicBlock::releaseSustain(uint channel) int musicBlock::releaseSustain(uint32_t channel)
{ {
uint i; uint32_t i;
uint id = channel; uint32_t id = channel;
for(i = 0; i < io->OPLchannels; i++) for(i = 0; i < io->OPLchannels; i++)
{ {
@ -170,16 +170,16 @@ int musicBlock::releaseSustain(uint channel)
return 0; return 0;
} }
int musicBlock::findFreeChannel(uint flag, uint channel, uchar note) int musicBlock::findFreeChannel(uint32_t flag, uint32_t channel, uint8_t note)
{ {
uint i; uint32_t i;
ulong bestfit = 0; uint32_t bestfit = 0;
uint bestvoice = 0; uint32_t bestvoice = 0;
for (i = 0; i < io->OPLchannels; ++i) for (i = 0; i < io->OPLchannels; ++i)
{ {
ulong magic; uint32_t magic;
magic = ((channels[i].flags & CH_FREE) << 24) | magic = ((channels[i].flags & CH_FREE) << 24) |
((channels[i].note == note && ((channels[i].note == note &&
@ -200,9 +200,9 @@ int musicBlock::findFreeChannel(uint flag, uint channel, uchar note)
return bestvoice; return bestvoice;
} }
struct OP2instrEntry *musicBlock::getInstrument(uint channel, uchar note) struct OP2instrEntry *musicBlock::getInstrument(uint32_t channel, uint8_t note)
{ {
uint instrnumber; uint32_t instrnumber;
if (channel == PERCUSSION) if (channel == PERCUSSION)
{ {
@ -225,7 +225,7 @@ struct OP2instrEntry *musicBlock::getInstrument(uint channel, uchar note)
// code 1: play note // code 1: play note
CVAR (Bool, opl_singlevoice, 0, 0) CVAR (Bool, opl_singlevoice, 0, 0)
void musicBlock::OPLplayNote(uint channel, uchar note, int volume) void musicBlock::OPLplayNote(uint32_t channel, uint8_t note, int volume)
{ {
int i; int i;
struct OP2instrEntry *instr; struct OP2instrEntry *instr;
@ -251,11 +251,11 @@ void musicBlock::OPLplayNote(uint channel, uchar note, int volume)
} }
// code 0: release note // code 0: release note
void musicBlock::OPLreleaseNote(uint channel, uchar note) void musicBlock::OPLreleaseNote(uint32_t channel, uint8_t note)
{ {
uint i; uint32_t i;
uint id = channel; uint32_t id = channel;
uint sustain = driverdata.channelSustain[channel]; uint32_t sustain = driverdata.channelSustain[channel];
for(i = 0; i < io->OPLchannels; i++) for(i = 0; i < io->OPLchannels; i++)
{ {
@ -270,10 +270,10 @@ void musicBlock::OPLreleaseNote(uint channel, uchar note)
} }
// code 2: change pitch wheel (bender) // code 2: change pitch wheel (bender)
void musicBlock::OPLpitchWheel(uint channel, int pitch) void musicBlock::OPLpitchWheel(uint32_t channel, int pitch)
{ {
uint i; uint32_t i;
uint id = channel; uint32_t id = channel;
// Convert pitch from 14-bit to 7-bit, then scale it, since the player // Convert pitch from 14-bit to 7-bit, then scale it, since the player
// code only understands sensitivities of 2 semitones. // code only understands sensitivities of 2 semitones.
@ -292,10 +292,10 @@ void musicBlock::OPLpitchWheel(uint channel, int pitch)
} }
// code 4: change control // code 4: change control
void musicBlock::OPLchangeControl(uint channel, uchar controller, int value) void musicBlock::OPLchangeControl(uint32_t channel, uint8_t controller, int value)
{ {
uint i; uint32_t i;
uint id = channel; uint32_t id = channel;
switch (controller) switch (controller)
{ {
@ -310,7 +310,7 @@ void musicBlock::OPLchangeControl(uint channel, uchar controller, int value)
struct channelEntry *ch = &channels[i]; struct channelEntry *ch = &channels[i];
if (ch->channel == id) if (ch->channel == id)
{ {
uchar flags = ch->flags; uint8_t flags = ch->flags;
ch->time = MLtime; ch->time = MLtime;
if (value >= MOD_MIN) if (value >= MOD_MIN)
{ {
@ -418,7 +418,7 @@ void musicBlock::OPLchangeControl(uint channel, uchar controller, int value)
} }
} }
void musicBlock::OPLresetControllers(uint chan, int vol) void musicBlock::OPLresetControllers(uint32_t chan, int vol)
{ {
driverdata.channelVolume[chan] = vol; driverdata.channelVolume[chan] = vol;
driverdata.channelExpression[chan] = 127; driverdata.channelExpression[chan] = 127;
@ -429,14 +429,14 @@ void musicBlock::OPLresetControllers(uint chan, int vol)
driverdata.channelPitchSens[chan] = 200; driverdata.channelPitchSens[chan] = 200;
} }
void musicBlock::OPLprogramChange(uint channel, int value) void musicBlock::OPLprogramChange(uint32_t channel, int value)
{ {
driverdata.channelInstr[channel] = value; driverdata.channelInstr[channel] = value;
} }
void musicBlock::OPLplayMusic(int vol) void musicBlock::OPLplayMusic(int vol)
{ {
uint i; uint32_t i;
for (i = 0; i < CHANNELS; i++) for (i = 0; i < CHANNELS; i++)
{ {
@ -446,7 +446,7 @@ void musicBlock::OPLplayMusic(int vol)
void musicBlock::OPLstopMusic() void musicBlock::OPLstopMusic()
{ {
uint i; uint32_t i;
for(i = 0; i < io->OPLchannels; i++) for(i = 0; i < io->OPLchannels; i++)
if (!(channels[i].flags & CH_FREE)) if (!(channels[i].flags & CH_FREE))
releaseChannel(i, 1); releaseChannel(i, 1);
@ -454,10 +454,10 @@ void musicBlock::OPLstopMusic()
int musicBlock::OPLloadBank (FileReader &data) int musicBlock::OPLloadBank (FileReader &data)
{ {
static const uchar masterhdr[8] = { '#','O','P','L','_','I','I','#' }; static const uint8_t masterhdr[8] = { '#','O','P','L','_','I','I','#' };
struct OP2instrEntry *instruments; struct OP2instrEntry *instruments;
uchar filehdr[8]; uint8_t filehdr[8];
data.Read (filehdr, 8); data.Read (filehdr, 8);
if (memcmp(filehdr, masterhdr, 8)) if (memcmp(filehdr, masterhdr, 8))

44
src/oplsynth/mlopl_io.cpp
View file

@ -22,7 +22,7 @@
* Oct-30-1994 V1.40 V.Arnost * Oct-30-1994 V1.40 V.Arnost
* Added BLASTER variable parsing * Added BLASTER variable parsing
* Apr-14-1995 V1.50 V.Arnost * Apr-14-1995 V1.50 V.Arnost
* Some declarations moved from adlib.h to deftypes.h * Some declarations moved from adlib.h to doomtype.h
* Jul-22-1995 V1.60 V.Arnost * Jul-22-1995 V1.60 V.Arnost
* Ported to Watcom C * Ported to Watcom C
* Simplified WriteChannel() and WriteValue() * Simplified WriteChannel() and WriteValue()
@ -63,7 +63,7 @@ void OPLio::WriteDelay(int ticks)
{ {
} }
void OPLio::OPLwriteReg(int which, uint reg, uchar data) void OPLio::OPLwriteReg(int which, uint32_t reg, uint8_t data)
{ {
if (IsOPL3) if (IsOPL3)
{ {
@ -80,13 +80,13 @@ void OPLio::OPLwriteReg(int which, uint reg, uchar data)
* Write to an operator pair. To be used for register bases of 0x20, 0x40, * Write to an operator pair. To be used for register bases of 0x20, 0x40,
* 0x60, 0x80 and 0xE0. * 0x60, 0x80 and 0xE0.
*/ */
void OPLio::OPLwriteChannel(uint regbase, uint channel, uchar data1, uchar data2) void OPLio::OPLwriteChannel(uint32_t regbase, uint32_t channel, uint8_t data1, uint8_t data2)
{ {
static const uint op_num[OPL2CHANNELS] = { static const uint32_t op_num[OPL2CHANNELS] = {
0x00, 0x01, 0x02, 0x08, 0x09, 0x0A, 0x10, 0x11, 0x12}; 0x00, 0x01, 0x02, 0x08, 0x09, 0x0A, 0x10, 0x11, 0x12};
uint which = channel / OPL2CHANNELS; uint32_t which = channel / OPL2CHANNELS;
uint reg = regbase + op_num[channel % OPL2CHANNELS]; uint32_t reg = regbase + op_num[channel % OPL2CHANNELS];
OPLwriteReg (which, reg, data1); OPLwriteReg (which, reg, data1);
OPLwriteReg (which, reg+3, data2); OPLwriteReg (which, reg+3, data2);
} }
@ -95,10 +95,10 @@ void OPLio::OPLwriteChannel(uint regbase, uint channel, uchar data1, uchar data2
* Write to channel a single value. To be used for register bases of * Write to channel a single value. To be used for register bases of
* 0xA0, 0xB0 and 0xC0. * 0xA0, 0xB0 and 0xC0.
*/ */
void OPLio::OPLwriteValue(uint regbase, uint channel, uchar value) void OPLio::OPLwriteValue(uint32_t regbase, uint32_t channel, uint8_t value)
{ {
uint which = channel / OPL2CHANNELS; uint32_t which = channel / OPL2CHANNELS;
uint reg = regbase + (channel % OPL2CHANNELS); uint32_t reg = regbase + (channel % OPL2CHANNELS);
OPLwriteReg (which, reg, value); OPLwriteReg (which, reg, value);
} }
@ -174,7 +174,7 @@ static WORD frequencies[] =
* That last byte in the table doesn't look right, either, but that's what * That last byte in the table doesn't look right, either, but that's what
* it really is. * it really is.
*/ */
void OPLio::OPLwriteFreq(uint channel, uint note, uint pitch, uint keyon) void OPLio::OPLwriteFreq(uint32_t channel, uint32_t note, uint32_t pitch, uint32_t keyon)
{ {
int octave = 0; int octave = 0;
int j = (note << 5) + pitch; int j = (note << 5) + pitch;
@ -202,9 +202,9 @@ void OPLio::OPLwriteFreq(uint channel, uint note, uint pitch, uint keyon)
/* /*
* Adjust volume value (register 0x40) * Adjust volume value (register 0x40)
*/ */
inline uint OPLio::OPLconvertVolume(uint data, uint volume) inline uint32_t OPLio::OPLconvertVolume(uint32_t data, uint32_t volume)
{ {
static uchar volumetable[128] = { static uint8_t volumetable[128] = {
0, 1, 3, 5, 6, 8, 10, 11, 0, 1, 3, 5, 6, 8, 10, 11,
13, 14, 16, 17, 19, 20, 22, 23, 13, 14, 16, 17, 19, 20, 22, 23,
25, 26, 27, 29, 30, 32, 33, 34, 25, 26, 27, 29, 30, 32, 33, 34,
@ -223,11 +223,11 @@ inline uint OPLio::OPLconvertVolume(uint data, uint volume)
124, 124, 125, 125, 126, 126, 127, 127}; 124, 124, 125, 125, 126, 126, 127, 127};
return 0x3F - (((0x3F - data) * return 0x3F - (((0x3F - data) *
(uint)volumetable[volume <= 127 ? volume : 127]) >> 7); (uint32_t)volumetable[volume <= 127 ? volume : 127]) >> 7);
} }
uint OPLio::OPLpanVolume(uint volume, int pan) uint32_t OPLio::OPLpanVolume(uint32_t volume, int pan)
{ {
if (pan >= 0) if (pan >= 0)
return volume; return volume;
@ -238,7 +238,7 @@ uint OPLio::OPLpanVolume(uint volume, int pan)
/* /*
* Write volume data to a channel * Write volume data to a channel
*/ */
void OPLio::OPLwriteVolume(uint channel, struct OPL2instrument *instr, uint volume) void OPLio::OPLwriteVolume(uint32_t channel, struct OPL2instrument *instr, uint32_t volume)
{ {
if (instr != 0) if (instr != 0)
{ {
@ -251,11 +251,11 @@ void OPLio::OPLwriteVolume(uint channel, struct OPL2instrument *instr, uint volu
/* /*
* Write pan (balance) data to a channel * Write pan (balance) data to a channel
*/ */
void OPLio::OPLwritePan(uint channel, struct OPL2instrument *instr, int pan) void OPLio::OPLwritePan(uint32_t channel, struct OPL2instrument *instr, int pan)
{ {
if (instr != 0) if (instr != 0)
{ {
uchar bits; uint8_t bits;
if (pan < -36) bits = 0x10; // left if (pan < -36) bits = 0x10; // left
else if (pan > 36) bits = 0x20; // right else if (pan > 36) bits = 0x20; // right
else bits = 0x30; // both else bits = 0x30; // both
@ -292,7 +292,7 @@ void OPLio::OPLwritePan(uint channel, struct OPL2instrument *instr, int pan)
* data[5] data[12] reg. 0x40 - output level (bottom 6 bits only) * data[5] data[12] reg. 0x40 - output level (bottom 6 bits only)
* data[6] reg. 0xC0 - feedback/AM-FM (both operators) * data[6] reg. 0xC0 - feedback/AM-FM (both operators)
*/ */
void OPLio::OPLwriteInstrument(uint channel, struct OPL2instrument *instr) void OPLio::OPLwriteInstrument(uint32_t channel, struct OPL2instrument *instr)
{ {
OPLwriteChannel(0x40, channel, 0x3F, 0x3F); // no volume OPLwriteChannel(0x40, channel, 0x3F, 0x3F); // no volume
OPLwriteChannel(0x20, channel, instr->trem_vibr_1, instr->trem_vibr_2); OPLwriteChannel(0x20, channel, instr->trem_vibr_1, instr->trem_vibr_2);
@ -307,7 +307,7 @@ void OPLio::OPLwriteInstrument(uint channel, struct OPL2instrument *instr)
*/ */
void OPLio::OPLshutup(void) void OPLio::OPLshutup(void)
{ {
uint i; uint32_t i;
for(i = 0; i < OPLchannels; i++) for(i = 0; i < OPLchannels; i++)
{ {
@ -321,10 +321,10 @@ void OPLio::OPLshutup(void)
/* /*
* Initialize hardware upon startup * Initialize hardware upon startup
*/ */
int OPLio::OPLinit(uint numchips, bool stereo, bool initopl3) int OPLio::OPLinit(uint32_t numchips, bool stereo, bool initopl3)
{ {
assert(numchips >= 1 && numchips <= countof(chips)); assert(numchips >= 1 && numchips <= countof(chips));
uint i; uint32_t i;
IsOPL3 = (current_opl_core == 1 || current_opl_core == 2 || current_opl_core == 3); IsOPL3 = (current_opl_core == 1 || current_opl_core == 2 || current_opl_core == 3);
memset(chips, 0, sizeof(chips)); memset(chips, 0, sizeof(chips));
@ -349,7 +349,7 @@ int OPLio::OPLinit(uint numchips, bool stereo, bool initopl3)
void OPLio::OPLwriteInitState(bool initopl3) void OPLio::OPLwriteInitState(bool initopl3)
{ {
for (uint i = 0; i < NumChips; ++i) for (uint32_t i = 0; i < NumChips; ++i)
{ {
int chip = i << (int)IsOPL3; int chip = i << (int)IsOPL3;
if (IsOPL3 && initopl3) if (IsOPL3 && initopl3)

2
src/oplsynth/music_opl_mididevice.cpp
View file

@ -289,7 +289,7 @@ FString OPLMIDIDevice::GetStats()
{ {
FString out; FString out;
char star[3] = { TEXTCOLOR_ESCAPE, 'A', '*' }; char star[3] = { TEXTCOLOR_ESCAPE, 'A', '*' };
for (uint i = 0; i < io->OPLchannels; ++i) for (uint32_t i = 0; i < io->OPLchannels; ++i)
{ {
if (channels[i].flags & CH_FREE) if (channels[i].flags & CH_FREE)
{ {

2
src/oplsynth/music_opldumper_mididevice.cpp
View file

@ -336,7 +336,7 @@ DiskWriterIO::~DiskWriterIO()
// //
//========================================================================== //==========================================================================
int DiskWriterIO::OPLinit(uint numchips, bool, bool initopl3) int DiskWriterIO::OPLinit(uint32_t numchips, bool, bool initopl3)
{ {
FILE *file = fopen(Filename, "wb"); FILE *file = fopen(Filename, "wb");
if (file == NULL) if (file == NULL)

100
src/oplsynth/muslib.h
View file

@ -76,7 +76,7 @@ Voice-mail (Czech language only, not recommended; weekends only):
#define __MUSLIB_H_ #define __MUSLIB_H_
#ifndef __DEFTYPES_H_ #ifndef __DEFTYPES_H_
#include "deftypes.h" #include "doomtype.h"
#endif #endif
class FileReader; class FileReader;
@ -119,7 +119,7 @@ struct OPL2instrument {
/*0B*/ BYTE scale_2; /* OP 2: key scale level */ /*0B*/ BYTE scale_2; /* OP 2: key scale level */
/*0C*/ BYTE level_2; /* OP 2: output level */ /*0C*/ BYTE level_2; /* OP 2: output level */
/*0D*/ BYTE unused; /*0D*/ BYTE unused;
/*0E*/ sshort basenote; /* base note offset */ /*0E*/ int16_t basenote; /* base note offset */
}; };
/* OP2 instrument file entry */ /* OP2 instrument file entry */
@ -152,41 +152,41 @@ struct OP2instrEntry {
#define CH_FREE 0x80 #define CH_FREE 0x80
struct OPLdata { struct OPLdata {
uint channelInstr[CHANNELS]; // instrument # uint32_t channelInstr[CHANNELS]; // instrument #
uchar channelVolume[CHANNELS]; // volume uint8_t channelVolume[CHANNELS]; // volume
uchar channelLastVolume[CHANNELS]; // last volume uint8_t channelLastVolume[CHANNELS]; // last volume
schar channelPan[CHANNELS]; // pan, 0=normal int8_t channelPan[CHANNELS]; // pan, 0=normal
schar channelPitch[CHANNELS]; // pitch wheel, 64=normal int8_t channelPitch[CHANNELS]; // pitch wheel, 64=normal
uchar channelSustain[CHANNELS]; // sustain pedal value uint8_t channelSustain[CHANNELS]; // sustain pedal value
uchar channelModulation[CHANNELS]; // modulation pot value uint8_t channelModulation[CHANNELS]; // modulation pot value
ushort channelPitchSens[CHANNELS]; // pitch sensitivity, 2=default uint16_t channelPitchSens[CHANNELS]; // pitch sensitivity, 2=default
ushort channelRPN[CHANNELS]; // RPN number for data entry uint16_t channelRPN[CHANNELS]; // RPN number for data entry
uchar channelExpression[CHANNELS]; // expression uint8_t channelExpression[CHANNELS]; // expression
}; };
struct OPLio { struct OPLio {
virtual ~OPLio(); virtual ~OPLio();
void OPLwriteChannel(uint regbase, uint channel, uchar data1, uchar data2); void OPLwriteChannel(uint32_t regbase, uint32_t channel, uint8_t data1, uint8_t data2);
void OPLwriteValue(uint regbase, uint channel, uchar value); void OPLwriteValue(uint32_t regbase, uint32_t channel, uint8_t value);
void OPLwriteFreq(uint channel, uint freq, uint octave, uint keyon); void OPLwriteFreq(uint32_t channel, uint32_t freq, uint32_t octave, uint32_t keyon);
uint OPLconvertVolume(uint data, uint volume); uint32_t OPLconvertVolume(uint32_t data, uint32_t volume);
uint OPLpanVolume(uint volume, int pan); uint32_t OPLpanVolume(uint32_t volume, int pan);
void OPLwriteVolume(uint channel, struct OPL2instrument *instr, uint volume); void OPLwriteVolume(uint32_t channel, struct OPL2instrument *instr, uint32_t volume);
void OPLwritePan(uint channel, struct OPL2instrument *instr, int pan); void OPLwritePan(uint32_t channel, struct OPL2instrument *instr, int pan);
void OPLwriteInstrument(uint channel, struct OPL2instrument *instr); void OPLwriteInstrument(uint32_t channel, struct OPL2instrument *instr);
void OPLshutup(void); void OPLshutup(void);
void OPLwriteInitState(bool initopl3); void OPLwriteInitState(bool initopl3);
virtual int OPLinit(uint numchips, bool stereo=false, bool initopl3=false); virtual int OPLinit(uint32_t numchips, bool stereo=false, bool initopl3=false);
virtual void OPLdeinit(void); virtual void OPLdeinit(void);
virtual void OPLwriteReg(int which, uint reg, uchar data); virtual void OPLwriteReg(int which, uint32_t reg, uint8_t data);
virtual void SetClockRate(double samples_per_tick); virtual void SetClockRate(double samples_per_tick);
virtual void WriteDelay(int ticks); virtual void WriteDelay(int ticks);
class OPLEmul *chips[MAXOPL2CHIPS]; class OPLEmul *chips[MAXOPL2CHIPS];
uint OPLchannels; uint32_t OPLchannels;
uint NumChips; uint32_t NumChips;
bool IsOPL3; bool IsOPL3;
}; };
@ -195,7 +195,7 @@ struct DiskWriterIO : public OPLio
DiskWriterIO(const char *filename); DiskWriterIO(const char *filename);
~DiskWriterIO(); ~DiskWriterIO();
int OPLinit(uint numchips, bool notused, bool initopl3); int OPLinit(uint32_t numchips, bool notused, bool initopl3);
void SetClockRate(double samples_per_tick); void SetClockRate(double samples_per_tick);
void WriteDelay(int ticks); void WriteDelay(int ticks);
@ -214,14 +214,14 @@ struct musicBlock {
struct OP2instrEntry *OPLinstruments; struct OP2instrEntry *OPLinstruments;
ulong MLtime; uint32_t MLtime;
void OPLplayNote(uint channel, uchar note, int volume); void OPLplayNote(uint32_t channel, uint8_t note, int volume);
void OPLreleaseNote(uint channel, uchar note); void OPLreleaseNote(uint32_t channel, uint8_t note);
void OPLpitchWheel(uint channel, int pitch); void OPLpitchWheel(uint32_t channel, int pitch);
void OPLchangeControl(uint channel, uchar controller, int value); void OPLchangeControl(uint32_t channel, uint8_t controller, int value);
void OPLprogramChange(uint channel, int value); void OPLprogramChange(uint32_t channel, int value);
void OPLresetControllers(uint channel, int vol); void OPLresetControllers(uint32_t channel, int vol);
void OPLplayMusic(int vol); void OPLplayMusic(int vol);
void OPLstopMusic(); void OPLstopMusic();
@ -230,27 +230,27 @@ struct musicBlock {
protected: protected:
/* OPL channel (voice) data */ /* OPL channel (voice) data */
struct channelEntry { struct channelEntry {
uchar channel; /* MUS channel number */ uint8_t channel; /* MUS channel number */
uchar note; /* note number */ uint8_t note; /* note number */
uchar flags; /* see CH_xxx below */ uint8_t flags; /* see CH_xxx below */
uchar realnote; /* adjusted note number */ uint8_t realnote; /* adjusted note number */
schar finetune; /* frequency fine-tune */ int8_t finetune; /* frequency fine-tune */
sint pitch; /* pitch-wheel value */ int pitch; /* pitch-wheel value */
uint volume; /* note volume */ uint32_t volume; /* note volume */
uint realvolume; /* adjusted note volume */ uint32_t realvolume; /* adjusted note volume */
struct OPL2instrument *instr; /* current instrument */ struct OPL2instrument *instr; /* current instrument */
ulong time; /* note start time */ uint32_t time; /* note start time */
} channels[MAXCHANNELS]; } channels[MAXCHANNELS];
void writeFrequency(uint slot, uint note, int pitch, uint keyOn); void writeFrequency(uint32_t slot, uint32_t note, int pitch, uint32_t keyOn);
void writeModulation(uint slot, struct OPL2instrument *instr, int state); void writeModulation(uint32_t slot, struct OPL2instrument *instr, int state);
uint calcVolume(uint channelVolume, uint channelExpression, uint noteVolume); uint32_t calcVolume(uint32_t channelVolume, uint32_t channelExpression, uint32_t noteVolume);
int occupyChannel(uint slot, uint channel, int occupyChannel(uint32_t slot, uint32_t channel,
int note, int volume, struct OP2instrEntry *instrument, uchar secondary); int note, int volume, struct OP2instrEntry *instrument, uint8_t secondary);
int releaseChannel(uint slot, uint killed); int releaseChannel(uint32_t slot, uint32_t killed);
int releaseSustain(uint channel); int releaseSustain(uint32_t channel);
int findFreeChannel(uint flag, uint channel, uchar note); int findFreeChannel(uint32_t flag, uint32_t channel, uint8_t note);
struct OP2instrEntry *getInstrument(uint channel, uchar note); struct OP2instrEntry *getInstrument(uint32_t channel, uint8_t note);
friend class Stat_opl; friend class Stat_opl;