Return to gusemu_mixer.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / hw

Annotation of qemu/hw/gusemu_mixer.c, revision 1.1

1.1     ! root        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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.