Statistics
| Branch: | Revision:

root / hw / gusemu_mixer.c @ 78895427

History | View | Annotate | Download (11.9 kB)

1
/*
2
 * GUSEMU32 - mixing engine (similar to Interwave GF1 compatibility)
3
 *
4
 * Copyright (C) 2000-2007 Tibor "TS" Schütz
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24

    
25
#include "gusemu.h"
26
#include "gustate.h"
27

    
28
#define GUSregb(position)  (*            (gusptr+(position)))
29
#define GUSregw(position)  (*(GUSword *) (gusptr+(position)))
30
#define GUSregd(position)  (*(GUSdword *)(gusptr+(position)))
31

    
32
#define GUSvoice(position) (*(GUSword *)(voiceptr+(position)))
33

    
34
/* samples are always 16bit stereo (4 bytes each, first right then left interleaved) */
35
void gus_mixvoices(GUSEmuState * state, unsigned int playback_freq, unsigned int numsamples,
36
                   GUSsample *bufferpos)
37
{
38
    /* note that byte registers are stored in the upper half of each voice register! */
39
    GUSbyte        *gusptr;
40
    int             Voice;
41
    GUSword        *voiceptr;
42

    
43
    unsigned int    count;
44
    for (count = 0; count < numsamples * 2; count++)
45
        *(bufferpos + count) = 0;       /* clear */
46

    
47
    gusptr = state->gusdatapos;
48
    voiceptr = (GUSword *) gusptr;
49
    if (!(GUSregb(GUS4cReset) & 0x01))  /* reset flag active? */
50
        return;
51

    
52
    for (Voice = 0; Voice <= (GUSregb(NumVoices) & 31); Voice++)
53
    {
54
        if (GUSvoice(wVSRControl)        &  0x200)
55
            GUSvoice(wVSRControl)        |= 0x100; /* voice stop request */
56
        if (GUSvoice(wVSRVolRampControl) &  0x200)
57
            GUSvoice(wVSRVolRampControl) |= 0x100; /* Volume ramp stop request */
58
        if (!(GUSvoice(wVSRControl) & GUSvoice(wVSRVolRampControl) & 0x100)) /* neither voice nor volume calculation active - save some time here ;) */
59
        {
60
            unsigned int    sample;
61

    
62
            unsigned int    LoopStart = (GUSvoice(wVSRLoopStartHi) << 16) | GUSvoice(wVSRLoopStartLo); /* 23.9 format */
63
            unsigned int    LoopEnd   = (GUSvoice(wVSRLoopEndHi)   << 16) | GUSvoice(wVSRLoopEndLo);   /* 23.9 format */
64
            unsigned int    CurrPos   = (GUSvoice(wVSRCurrPosHi)   << 16) | GUSvoice(wVSRCurrPosLo);   /* 23.9 format */
65
            int             VoiceIncrement = ((((unsigned long) GUSvoice(wVSRFreq) * 44100) / playback_freq) * (14 >> 1)) /
66
                                             ((GUSregb(NumVoices) & 31) + 1); /* 6.10 increment/frame to 23.9 increment/sample */
67

    
68
            int             PanningPos = (GUSvoice(wVSRPanning) >> 8) & 0xf;
69

    
70
            unsigned int    Volume32   = 32 * GUSvoice(wVSRCurrVol); /* 32 times larger than original gus for maintaining precision while ramping */
71
            unsigned int    StartVol32 = (GUSvoice(wVSRVolRampStartVol) & 0xff00) * 32;
72
            unsigned int    EndVol32   = (GUSvoice(wVSRVolRampEndVol)   & 0xff00) * 32;
73
            int             VolumeIncrement32 = (32 * 16 * (GUSvoice(wVSRVolRampRate) & 0x3f00) >> 8) >> ((((GUSvoice(wVSRVolRampRate) & 0xc000) >> 8) >> 6) * 3); /* including 1/8/64/512 volume speed divisor */
74
            VolumeIncrement32 = (((VolumeIncrement32 * 44100 / 2) / playback_freq) * 14) / ((GUSregb(NumVoices) & 31) + 1); /* adjust ramping speed to playback speed */
75

    
76
            if (GUSvoice(wVSRControl) & 0x4000)
77
                VoiceIncrement    = -VoiceIncrement;    /* reverse playback */
78
            if (GUSvoice(wVSRVolRampControl) & 0x4000)
79
                VolumeIncrement32 = -VolumeIncrement32; /* reverse ramping */
80

    
81
            for (sample = 0; sample < numsamples; sample++)
82
            {
83
                int             sample1, sample2, Volume;
84
                if (GUSvoice(wVSRControl) & 0x400)      /* 16bit */
85
                {
86
                    int offset = ((CurrPos >> 9) & 0xc0000) + (((CurrPos >> 9) & 0x1ffff) << 1);
87
                    GUSchar *adr;
88
                    adr = (GUSchar *) state->himemaddr + offset;
89
                    sample1 = (*adr & 0xff) + (*(adr + 1) * 256);
90
                    sample2 = (*(adr + 2) & 0xff) + (*(adr + 2 + 1) * 256);
91
                }
92
                else            /* 8bit */
93
                {
94
                    int offset = (CurrPos >> 9) & 0xfffff;
95
                    GUSchar *adr;
96
                    adr = (GUSchar *) state->himemaddr + offset;
97
                    sample1 = (*adr) * 256;
98
                    sample2 = (*(adr + 1)) * 256;
99
                }
100

    
101
                Volume = ((((Volume32 >> (4 + 5)) & 0xff) + 256) << (Volume32 >> ((4 + 8) + 5))) / 512; /* semi-logarithmic volume, +5 due to additional precision */
102
                sample1 = (((sample1 * Volume) >> 16) * (512 - (CurrPos % 512))) / 512;
103
                sample2 = (((sample2 * Volume) >> 16) * (CurrPos % 512)) / 512;
104
                sample1 += sample2;
105

    
106
                if (!(GUSvoice(wVSRVolRampControl) & 0x100))
107
                {
108
                    Volume32 += VolumeIncrement32;
109
                    if ((GUSvoice(wVSRVolRampControl) & 0x4000) ? (Volume32 <= StartVol32) : (Volume32 >= EndVol32)) /* ramp up boundary cross */
110
                    {
111
                        if (GUSvoice(wVSRVolRampControl) & 0x2000)
112
                            GUSvoice(wVSRVolRampControl) |= 0x8000;     /* volramp IRQ enabled? -> IRQ wait flag */
113
                        if (GUSvoice(wVSRVolRampControl) & 0x800)       /* loop enabled */
114
                        {
115
                            if (GUSvoice(wVSRVolRampControl) & 0x1000)  /* bidir. loop */
116
                            {
117
                                GUSvoice(wVSRVolRampControl) ^= 0x4000; /* toggle dir */
118
                                VolumeIncrement32 = -VolumeIncrement32;
119
                            }
120
                            else
121
                                Volume32 = (GUSvoice(wVSRVolRampControl) & 0x4000) ? EndVol32 : StartVol32; /* unidir. loop ramp */
122
                        }
123
                        else
124
                        {
125
                            GUSvoice(wVSRVolRampControl) |= 0x100;
126
                            Volume32 =
127
                                (GUSvoice(wVSRVolRampControl) & 0x4000) ? StartVol32 : EndVol32;
128
                        }
129
                    }
130
                }
131
                if ((GUSvoice(wVSRVolRampControl) & 0xa000) == 0xa000)  /* volramp IRQ set and enabled? */
132
                {
133
                    GUSregd(voicevolrampirq) |= 1 << Voice;             /* set irq slot */
134
                }
135
                else
136
                {
137
                    GUSregd(voicevolrampirq) &= (~(1 << Voice));        /* clear irq slot */
138
                    GUSvoice(wVSRVolRampControl) &= 0x7f00;
139
                }
140

    
141
                if (!(GUSvoice(wVSRControl) & 0x100))
142
                {
143
                    CurrPos += VoiceIncrement;
144
                    if ((GUSvoice(wVSRControl) & 0x4000) ? (CurrPos <= LoopStart) : (CurrPos >= LoopEnd)) /* playback boundary cross */
145
                    {
146
                        if (GUSvoice(wVSRControl) & 0x2000)
147
                            GUSvoice(wVSRControl) |= 0x8000;       /* voice IRQ enabled -> IRQ wait flag */
148
                        if (GUSvoice(wVSRControl) & 0x800)         /* loop enabled */
149
                        {
150
                            if (GUSvoice(wVSRControl) & 0x1000)    /* pingpong loop */
151
                            {
152
                                GUSvoice(wVSRControl) ^= 0x4000;   /* toggle dir */
153
                                VoiceIncrement = -VoiceIncrement;
154
                            }
155
                            else
156
                                CurrPos = (GUSvoice(wVSRControl) & 0x4000) ? LoopEnd : LoopStart; /* unidir. loop */
157
                        }
158
                        else if (!(GUSvoice(wVSRVolRampControl) & 0x400))
159
                            GUSvoice(wVSRControl) |= 0x100;        /* loop disabled, rollover check */
160
                    }
161
                }
162
                if ((GUSvoice(wVSRControl) & 0xa000) == 0xa000)    /* wavetable IRQ set and enabled? */
163
                {
164
                    GUSregd(voicewavetableirq) |= 1 << Voice;      /* set irq slot */
165
                }
166
                else
167
                {
168
                    GUSregd(voicewavetableirq) &= (~(1 << Voice)); /* clear irq slot */
169
                    GUSvoice(wVSRControl) &= 0x7f00;
170
                }
171

    
172
                /* mix samples into buffer */
173
                *(bufferpos + 2 * sample)     += (GUSsample) ((sample1 * PanningPos) >> 4);        /* right */
174
                *(bufferpos + 2 * sample + 1) += (GUSsample) ((sample1 * (15 - PanningPos)) >> 4); /* left */
175
            }
176
            /* write back voice and volume */
177
            GUSvoice(wVSRCurrVol)   = Volume32 / 32;
178
            GUSvoice(wVSRCurrPosHi) = CurrPos >> 16;
179
            GUSvoice(wVSRCurrPosLo) = CurrPos & 0xffff;
180
        }
181
        voiceptr += 16; /* next voice */
182
    }
183
}
184

    
185
void gus_irqgen(GUSEmuState * state, unsigned int elapsed_time)
186
/* time given in microseconds */
187
{
188
    int             requestedIRQs = 0;
189
    GUSbyte        *gusptr;
190
    gusptr = state->gusdatapos;
191
    if (GUSregb(TimerDataReg2x9) & 1) /* start timer 1 (80us decrement rate) */
192
    {
193
        unsigned int    timer1fraction = state->timer1fraction;
194
        int             newtimerirqs;
195
        newtimerirqs          = (elapsed_time + timer1fraction) / (80 * (256 - GUSregb(GUS46Counter1)));
196
        state->timer1fraction = (elapsed_time + timer1fraction) % (80 * (256 - GUSregb(GUS46Counter1)));
197
        if (newtimerirqs)
198
        {
199
            if (!(GUSregb(TimerDataReg2x9) & 0x40))
200
                GUSregb(TimerStatus2x8) |= 0xc0; /* maskable bits */
201
            if (GUSregb(GUS45TimerCtrl) & 4)     /* timer1 irq enable */
202
            {
203
                GUSregb(TimerStatus2x8) |= 4;    /* nonmaskable bit */
204
                GUSregb(IRQStatReg2x6)  |= 4;    /* timer 1 irq pending */
205
                GUSregw(TimerIRQs) += newtimerirqs;
206
                requestedIRQs += newtimerirqs;
207
            }
208
        }
209
    }
210
    if (GUSregb(TimerDataReg2x9) & 2) /* start timer 2 (320us decrement rate) */
211
    {
212
        unsigned int timer2fraction = state->timer2fraction;
213
        int             newtimerirqs;
214
        newtimerirqs          = (elapsed_time + timer2fraction) / (320 * (256 - GUSregb(GUS47Counter2)));
215
        state->timer2fraction = (elapsed_time + timer2fraction) % (320 * (256 - GUSregb(GUS47Counter2)));
216
        if (newtimerirqs)
217
        {
218
            if (!(GUSregb(TimerDataReg2x9) & 0x20))
219
                GUSregb(TimerStatus2x8) |= 0xa0; /* maskable bits */
220
            if (GUSregb(GUS45TimerCtrl) & 8)     /* timer2 irq enable */
221
            {
222
                GUSregb(TimerStatus2x8) |= 2;    /* nonmaskable bit */
223
                GUSregb(IRQStatReg2x6)  |= 8;    /* timer 2 irq pending */
224
                GUSregw(TimerIRQs) += newtimerirqs;
225
                requestedIRQs += newtimerirqs;
226
            }
227
        }
228
    }
229
    if (GUSregb(GUS4cReset) & 0x4) /* synth IRQ enable */
230
    {
231
        if (GUSregd(voicewavetableirq))
232
            GUSregb(IRQStatReg2x6) |= 0x20;
233
        if (GUSregd(voicevolrampirq))
234
            GUSregb(IRQStatReg2x6) |= 0x40;
235
    }
236
    if ((!requestedIRQs) && GUSregb(IRQStatReg2x6))
237
        requestedIRQs++;
238
    if (GUSregb(IRQStatReg2x6))
239
        GUSregw(BusyTimerIRQs) = GUS_irqrequest(state, state->gusirq, requestedIRQs);
240
}