Skip to content
Permalink
master
Switch branches/tags

oricutron/8912.c

Go to file
 
 
Cannot retrieve contributors at this time
849 lines (730 sloc) 24.6 KB
Raw Blame
/*
** Oricutron
** Copyright (C) 2009-2014 Peter Gordon
**
** This program is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License
** as published by the Free Software Foundation, version 2
** of the License.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**
** General Instruments AY-8912 emulation (including oric keyboard emulation)
*/
#define TONETIME 8
#define NOISETIME 8
#define ENVTIME 16
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "system.h"
#include "6502.h"
#include "8912.h"
#include "via.h"
#include "gui.h"
#include "disk.h"
#include "monitor.h"
#include "6551.h"
#include "machine.h"
#include "avi.h"
#ifdef __amigaos4__
#include <proto/exec.h>
#endif
SDL_AudioSpec obtained;
Uint32 cyclespersample;
static SDL_AudioCVT cvt;
static Sint16 audiocapbuf[AUDIO_BUFLEN];
extern struct avi_handle *vidcap;
extern Sint16 soundsilence;
extern SDL_bool soundavailable, soundon, warpspeed;
// Variables used by the queuekeys function
// (only works for ROM routines)
static char *keyqueue = NULL;
static int keysqueued = 0, kqoffs = 0;
// Volume levels
Sint32 voltab[] = { 0, 513/4, 828/4, 1239/4, 1923/4, 3238/4, 4926/4, 9110/4, 10344/4, 17876/4, 24682/4, 30442/4, 38844/4, 47270/4, 56402/4, 65535/4};
// Envelope shape descriptions
// Bit 7 set = go to step defined in bits 0-6
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
unsigned char eshape0[] = { 15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 128+15 };
unsigned char eshape4[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15, 0, 128+16 };
unsigned char eshape8[] = { 15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 128+0 };
unsigned char eshapeA[] = { 15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15, 128+0 };
unsigned char eshapeB[] = { 15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 128+16 };
unsigned char eshapeC[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15, 128+0 };
unsigned char eshapeD[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15, 128+15 };
unsigned char eshapeE[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 128+0 };
unsigned char *eshapes[] = { eshape0, // 0000
eshape0, // 0001
eshape0, // 0010
eshape0, // 0011
eshape4, // 0100
eshape4, // 0101
eshape4, // 0110
eshape4, // 0111
eshape8, // 1000
eshape0, // 1001
eshapeA, // 1010
eshapeB, // 1011
eshapeC, // 1100
eshapeD, // 1101
eshapeE, // 1110
eshape4 };//1111
static SDL_COMPAT_KEY *keytab;
// Oric keymap (QWERTY)
// FE FD FB F7 EF DF BF 7F
static SDL_COMPAT_KEY qwktab[] = { '7' , 'n' , '5' , 'v' , SDLK_RCTRL , '1' , 'x' , '3' ,
'j' , 't' , 'r' , 'f' , 0 , SDLK_ESCAPE, 'q' , 'd' ,
'm' , '6' , 'b' , '4' , SDLK_LCTRL , 'z' , '2' , 'c' ,
'k' , '9' , ';' , '-' , '#' , 0 , '\\' , '\'' ,
SDLK_SPACE , ',' , '.' , SDLK_UP , SDLK_LSHIFT, SDLK_LEFT , SDLK_DOWN , SDLK_RIGHT ,
'u' , 'i' , 'o' , 'p' , SDLK_LALT , SDLK_BACKSPACE, ']' , '[' ,
'y' , 'h' , 'g' , 'e' , SDLK_RALT , 'a' , 's' , 'w' ,
'8' , 'l' , '0' , '/' , SDLK_RSHIFT, SDLK_RETURN, '`' , SDLK_EQUALS };
// AZERTY
static SDL_COMPAT_KEY azktab[] = { '7' , 'n' , '5' , 'v' , SDLK_RCTRL , '1' , 'x' , '3' ,
'j' , 't' , 'r' , 'f' , 0 , SDLK_ESCAPE, 'a' , 'd' ,
'm' , '6' , 'b' , '4' , SDLK_LCTRL , 'w' , '2' , 'c' ,
'k' , '9' , ';' , '-' , '#' , 0 , '\\' , '\'' ,
SDLK_SPACE , ',' , '.' , SDLK_UP , SDLK_LSHIFT, SDLK_LEFT , SDLK_DOWN , SDLK_RIGHT ,
'u' , 'i' , 'o' , 'p' , SDLK_LALT , SDLK_BACKSPACE, ']' , '[' ,
'y' , 'h' , 'g' , 'e' , SDLK_RALT , 'q' , 's' , 'z' ,
'8' , 'l' , '0' , '/' , SDLK_RSHIFT, SDLK_RETURN, '`' , SDLK_EQUALS };
// QWERTZ
static SDL_COMPAT_KEY qzktab[] = { '7' , 'n' , '5' , 'v' , SDLK_RCTRL , '1' , 'x' , '3' ,
'j' , 't' , 'r' , 'f' , 0 , SDLK_ESCAPE, 'q' , 'd' ,
'm' , '6' , 'b' , '4' , SDLK_LCTRL , 'y' , '2' , 'c' ,
'k' , '9' , ';' , '-' , '#' , 0 , '\\' , '\'' ,
SDLK_SPACE , ',' , '.' , SDLK_UP , SDLK_LSHIFT, SDLK_LEFT , SDLK_DOWN , SDLK_RIGHT ,
'u' , 'i' , 'o' , 'p' , SDLK_LALT , SDLK_BACKSPACE, ']' , '[' ,
'z' , 'h' , 'g' , 'e' , SDLK_RALT , 'a' , 's' , 'w' ,
'8' , 'l' , '0' , '/' , SDLK_RSHIFT, SDLK_RETURN, '`' , SDLK_EQUALS };
// Queue up some key presses. These key presses
// are only detected by the standard ROM routines.
void queuekeys( char *str )
{
if( str )
{
int len = (int)strlen( str );
if( keyqueue )
{
keyqueue = realloc(keyqueue, strlen(keyqueue) + len + 1);
strcat(keyqueue, str);
keysqueued += len;
}
else
{
keyqueue = strdup( str );
keysqueued = len;
kqoffs = 0;
}
}
}
/*
** RNG for the AY noise generator
*/
static Uint32 ayrand( struct ay8912 *ay )
{
Uint32 rbit = (ay->rndrack&1) ^ ((ay->rndrack>>2)&1);
ay->rndrack = (ay->rndrack>>1)|(rbit<<16);
return rbit&1;
}
void ay_audioticktock( struct ay8912 *ay, Uint32 cycles )
{
Sint32 i;
Sint32 output;
// For each clock cycle...
while( cycles > 0 )
{
// Count for the noise cycle counter
if( (++ay->ctn) >= ay->noiseper )
{
// Noise counter expired, calculate the next noise output level
ay->currnoise ^= ayrand( ay );
// Reset the noise counter
ay->ctn = 0;
// Remember that the noise output changed
ay->newnoise = SDL_TRUE;
}
// For each audio channel...
for( i=0; i<3; i++ )
{
if( !ay->toneper[i] )
{
if( !ay->sign[i] )
{
ay->sign[i] = 1;
ay->newout |= (1<<i);
continue;
}
}
// Count for the square wave counter
if( (++ay->ct[i]) >= ay->toneper[i] )
{
// Square wave counter expired, reset it...
ay->ct[i] = 0;
// ...and invert the square wave output
ay->sign[i] ^= 1;
// Remember that this channels output has changed
ay->newout |= (1<<i);
}
// If this channel is mixed with noise, and the noise changed,
// then so did this channel.
if( ( ay->newnoise ) && ( !ay->noisebit[i] ) )
ay->newout |= (1<<i);
}
// Count down the envelope cycle counter
if( (++ay->cte) >= ay->envper )
{
// Counter expired, so reset it
ay->cte = 0;
// Move to the next envelope position
ay->envpos++;
// Reached the end of the envelope?
if( ay->envtab[ay->envpos]&0x80 )
ay->envpos = ay->envtab[ay->envpos]&0x7f;
// For each channel...
for( i=0; i<3; i++ )
{
// If the channel is using the envelope generator...
if( ay->regs[AY_CHA_AMP+i]&0x10 )
{
// Recalculate its output volume
ay->vol[i] = voltab[ay->envtab[ay->envpos]];
// and remember that the channel has changed
ay->newout |= (1<<i);
}
}
}
// Done one cycle!
cycles--;
}
if( !ay->newout ) return;
// "Output" accumulates the audio data from all sources
output = soundsilence;
// Loop through the channels
for( i=0; i<3; i++ )
{
// Yep, calculate the squarewave signal...
if( ay->newout & (1<<i) )
ay->out[i] = ((ay->tonebit[i]|ay->sign[i])&(ay->noisebit[i]|ay->currnoise)) * ay->vol[i];
// Mix in the output of this channel
output += ay->out[i];
}
ay->newout = 0;
// Clamp the output
if( output > 32767 ) output = 32767;
// if( output < -32768 ) output = -32768;
ay->output = output;
}
void ay_dowrite( struct ay8912 *ay, struct aywrite *aw )
{
Sint32 i;
switch( aw->reg )
{
case AY_CHA_PER_L: // Channel A period
case AY_CHA_PER_H:
ay->regs[aw->reg] = aw->val;
ay->toneper[0] = (((ay->regs[AY_CHA_PER_H]&0xf)<<8)|ay->regs[AY_CHA_PER_L]) * TONETIME;
break;
case AY_CHB_PER_L: // Channel B period
case AY_CHB_PER_H:
ay->regs[aw->reg] = aw->val;
ay->toneper[1] = (((ay->regs[AY_CHB_PER_H]&0xf)<<8)|ay->regs[AY_CHB_PER_L]) * TONETIME;
break;
case AY_CHC_PER_L: // Channel C period
case AY_CHC_PER_H:
ay->regs[aw->reg] = aw->val;
ay->toneper[2] = (((ay->regs[AY_CHC_PER_H]&0xf)<<8)|ay->regs[AY_CHC_PER_L]) * TONETIME;
break;
case AY_STATUS: // Status
ay->regs[aw->reg] = aw->val;
ay->tonebit[0] = (aw->val&0x01)?1:0;
ay->tonebit[1] = (aw->val&0x02)?1:0;
ay->tonebit[2] = (aw->val&0x04)?1:0;
ay->noisebit[0] = (aw->val&0x08)?1:0;
ay->noisebit[1] = (aw->val&0x10)?1:0;
ay->noisebit[2] = (aw->val&0x20)?1:0;
ay->newout = 7;
break;
case AY_NOISE_PER: // Noise period
ay->regs[aw->reg] = aw->val;
ay->noiseper = (ay->regs[AY_NOISE_PER]&0x1f) * NOISETIME;
break;
case AY_CHA_AMP:
case AY_CHB_AMP:
case AY_CHC_AMP:
ay->regs[aw->reg] = aw->val;
i = aw->reg-AY_CHA_AMP;
if(aw->val&0x10)
ay->vol[i] = voltab[ay->envtab[ay->envpos]];
else
ay->vol[i] = voltab[aw->val&0xf];
ay->newout |= (1<<i);
break;
case AY_ENV_PER_L:
case AY_ENV_PER_H:
ay->regs[aw->reg] = aw->val;
ay->envper = ((ay->regs[AY_ENV_PER_H]<<8)|ay->regs[AY_ENV_PER_L])*ENVTIME;
break;
case AY_ENV_CYCLE:
if( aw->val != 0xff )
{
ay->regs[aw->reg] = aw->val;
ay->envtab = eshapes[aw->val&0xf];
ay->envpos = 0;
for( i=0; i<3; i++ )
{
if( ay->regs[AY_CHA_AMP+i]&0x10 )
{
ay->vol[i] = voltab[ay->envtab[ay->envpos]];
ay->newout |= (1<<i);
}
}
}
break;
}
}
void ay_flushlog( struct ay8912 *ay )
{
int i;
for (i=0; i<ay->logged; i++)
ay_dowrite( ay, &ay->writelog[i] );
ay->logged = 0;
}
/*
** This is the SDL audio callback. It is called by SDL
** when it needs a sound buffer to be filled.
*/
void ay_callback( void *dummy, Sint8 *stream, int length )
{
Uint16 *out;
Sint16 fout;
Sint32 i, j, logc, tlogc;
struct ay8912 *ay = (struct ay8912 *)dummy;
Sint32 dcadjustave, dcadjustmax;
SDL_bool tapenoise;
int actual_length;
logc = 0;
tlogc = 0;
dcadjustave = 0;
dcadjustmax = soundsilence;
tapenoise = ay->soundloopon || (ay->oric->tapenoise && ((!ay->oric->tapeturbo)||(ay->oric->rawtape)));
if( !tapenoise ) ay->tapeout = 0;
out = (Uint16 *)stream;
cvt.buf = (Uint8 *)stream;
actual_length = length/(2*sizeof(Uint16));
actual_length = (actual_length < AUDIO_BUFLEN)? actual_length : AUDIO_BUFLEN;
actual_length = (actual_length < obtained.samples)? actual_length : obtained.samples;
for( i=0,j=0; i<actual_length; i++ )
{
ay->ccyc = ay->ccycle>>FPBITS;
while( ( logc < ay->logged ) && ( ay->ccyc >= ay->writelog[logc].cycle ) )
ay_dowrite( ay, &ay->writelog[logc++] );
if( tapenoise )
{
while( ( tlogc < ay->tlogged ) && ( ay->ccyc >= ay->tapelog[tlogc].cycle ) )
ay->tapeout = ay->tapelog[tlogc++].val * 8192;
}
if( ay->ccyc > ay->lastcyc )
{
ay_audioticktock( ay, ay->ccyc-ay->lastcyc );
ay->lastcyc = ay->ccyc;
}
fout = ay->output + ay->tapeout;
out[j++] = fout;
out[j++] = fout;
if( vidcap ) audiocapbuf[i] = fout;
if( fout > dcadjustmax ) dcadjustmax = fout;
dcadjustave += fout;
ay->ccycle += cyclespersample;
}
dcadjustave /= (length/4);
if( (dcadjustmax-dcadjustave) > 32767 )
dcadjustave = -(32767-dcadjustmax);
if( ay->oric->dcadjust && dcadjustave )
{
for( i=0, j=0; i<actual_length; i++ )
{
out[j++] -= dcadjustave;
out[j++] -= dcadjustave;
if( vidcap ) audiocapbuf[i] -= dcadjustave;
}
}
if( vidcap )
{
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
for( i=0; i<(length/4); i++ )
audiocapbuf[i] = SDL_Swap16( audiocapbuf[i] );
#endif
avi_addaudio( &vidcap, audiocapbuf, length/2 );
}
if (ay->logged > logc)
{
memmove(&ay->writelog[0], &ay->writelog[logc], (ay->logged-logc) * sizeof(ay->writelog[0]));
ay->logged -= logc;
for (i=0; i<ay->logged; i++)
ay->writelog[i].cycle -= ay->lastcyc;
/* Got out of sync? */
if (ay->logged > 150)
ay_flushlog( ay );
}
else
{
ay->logged = 0;
}
if( tapenoise )
{
while( tlogc < ay->tlogged )
ay->tapeout = ay->tapelog[tlogc++].val * 8192;
}
SDL_ConvertAudio(&cvt);
ay->ccycle -= (ay->lastcyc<<FPBITS);
ay->lastcyc = 0;
ay->newlogcycle = ay->ccycle>>FPBITS;
ay->do_logcycle_reset = SDL_TRUE;
// ay->logged = 0;
ay->tlogged = 0;
}
/*
** Emulate the AY for some clock cycles
** Output is cycle-exact.
*/
void ay_ticktock( struct ay8912 *ay, int cycles )
{
// Need to do queued keys?
if( ( keyqueue ) && ( keysqueued ) && (!ay->oric->cpu.irq) )
{
if( kqoffs >= keysqueued )
{
free(keyqueue);
keyqueue = NULL;
keysqueued = 0;
kqoffs = 0;
} else {
switch( ay->oric->type )
{
case MACH_ATMOS:
case MACH_PRAVETZ:
if( ( ay->oric->cpu.pc == 0xeb78 ) && ( ay->oric->romon ) )
{
ay->oric->cpu.a = keyqueue[kqoffs++];
ay->oric->cpu.write( &ay->oric->cpu, 0x2df, 0 );
ay->oric->cpu.f_n = 1;
ay->oric->cpu.calcpc = 0xeb88;
ay->oric->cpu.calcop = ay->oric->cpu.read( &ay->oric->cpu, ay->oric->cpu.calcpc );
}
break;
case MACH_ORIC1:
case MACH_ORIC1_16K:
if( ( ay->oric->cpu.pc == 0xe905 ) && ( ay->oric->romon ) )
{
ay->oric->cpu.a = keyqueue[kqoffs++];
ay->oric->cpu.write( &ay->oric->cpu, 0x2df, 0 );
ay->oric->cpu.f_n = 1;
ay->oric->cpu.calcpc = 0xe915;
ay->oric->cpu.calcop = ay->oric->cpu.read( &ay->oric->cpu, ay->oric->cpu.calcpc );
}
break;
}
}
}
// Also use the queuekey location to do the jasmin auto reset
if( ay->oric->auto_jasmin_reset )
{
if (ay->oric->drivetype == DRV_JASMIN)
{
switch( ay->oric->type )
{
case MACH_ATMOS:
case MACH_PRAVETZ:
if( ( ay->oric->cpu.pc == 0xeb78 ) && ( ay->oric->romon ) )
{
ay->oric->cpu.write( &ay->oric->cpu, 0x3fb, 1 ); // ROMDIS
setromon( ay->oric );
m6502_reset( &ay->oric->cpu );
m6502_set_icycles( &ay->oric->cpu, SDL_FALSE, NULL );
via_init( &ay->oric->via, ay->oric, VIA_MAIN );
ay->oric->auto_jasmin_reset = SDL_FALSE;
}
break;
case MACH_ORIC1:
case MACH_ORIC1_16K:
if( ( ay->oric->cpu.pc == 0xe905 ) && ( ay->oric->romon ) )
{
ay->oric->cpu.write( &ay->oric->cpu, 0x3fb, 1 ); // ROMDIS
setromon( ay->oric );
m6502_reset( &ay->oric->cpu );
m6502_set_icycles( &ay->oric->cpu, SDL_FALSE, NULL );
via_init( &ay->oric->via, ay->oric, VIA_MAIN );
ay->oric->auto_jasmin_reset = SDL_FALSE;
}
break;
}
}
else
{
ay->oric->auto_jasmin_reset = SDL_FALSE;
}
}
if( ay->keybitdelay > 0 )
{
if( cycles >= ay->keybitdelay )
{
ay->keybitdelay = 0;
ay_update_keybits( ay );
} else {
ay->keybitdelay -= cycles;
}
}
if( ay->do_logcycle_reset )
{
ay->logcycle = ay->newlogcycle;
ay->do_logcycle_reset = SDL_FALSE;
}
ay->logcycle += cycles;
}
void ay_lockaudio( struct ay8912 *ay )
{
if( ay->audiolocked ) return;
if( ( ay->oric->emu_mode != EM_RUNNING ) || ( !soundon ) || ( warpspeed ) ) return;
SDL_LockAudio();
ay->audiolocked = SDL_TRUE;
}
void ay_unlockaudio( struct ay8912 *ay )
{
if( !ay->audiolocked ) return;
SDL_UnlockAudio();
ay->audiolocked = SDL_FALSE;
}
/*
** Initialise the AY emulation
** (... and oric keyboard)
*/
SDL_bool ay_init( struct ay8912 *ay, struct machine *oric )
{
int i;
switch( oric->keymap )
{
case KMAP_AZERTY: keytab = azktab; break;
case KMAP_QWERTZ: keytab = qzktab; break;
default: keytab = qwktab; break;
}
// No oric keys pressed
for( i=0; i<8; i++ )
ay->keystates[i] = SDL_FALSE;
// Reset all regs to 0
for( i=0; i<NUM_AY_REGS; i++ )
ay->regs[i] = 0;
// Reset the three audio channels
for( i=0; i<3; i++ )
{
ay->ct[i] = 0; // Cycle counter to zero
ay->out[i] = 0; // 0v output for each channel
ay->sign[i] = 0; // Initial sign bit
ay->tonebit[i] = 1; // Output disabled
ay->noisebit[i] = 1; // Noise disabled
ay->vol[i] = 0; // Zero volume
}
ay->newout = 7;
ay->newnoise = SDL_TRUE;
ay->ctn = 0; // Reset the noise counter
ay->cte = 0; // Reset the envelope counter
ay->envtab = eshape0; // Default to envelope 0
ay->envpos = 0;
ay->bmode = 0; // GI silly addressing mode
ay->creg = 0; // Current register to 0
ay->oric = oric;
ay->soundon = soundavailable && soundon && (!warpspeed);
ay->soundloopon = oric->soundloopon;
ay->currnoise = 0;
ay->rndrack = 1;
ay->logged = 0;
ay->logcycle = 0;
ay->do_logcycle_reset = SDL_FALSE;
ay->output = soundsilence;
ay->lastcyc = 0;
ay->ccyc = 0;
ay->ccycle = 0;
ay->tlogged = 0;
ay->tapeout = 0;
ay->keybitdelay = 0;
ay->audiolocked = SDL_FALSE;
if( soundavailable )
SDL_PauseAudio( 0 );
// initialize audio conversion system for SDL2
SDL_BuildAudioCVT(&cvt, AUDIO_S16SYS, 2, AUDIO_FREQ, obtained.format, obtained.channels, obtained.freq);
cvt.len = obtained.samples * sizeof(Sint16) * obtained.channels;
// Do not allocate a buffer, write directly into the callback stream
return SDL_TRUE;
}
/*
** Update the VIA bits when key states change
*/
void ay_update_keybits( struct ay8912 *ay )
{
ay->currkeyoffs = ay->oric->via.read_port_b( &ay->oric->via ) & 0x7;
if( (ay->eregs[AY_STATUS]&0x40) == 0 )
{
ay->oric->via.write_port_b( &ay->oric->via, 0x08, 0x00 );
return;
}
if( ay->keystates[ay->currkeyoffs] & (ay->eregs[AY_PORT_A]^0xff) )
ay->oric->via.write_port_b( &ay->oric->via, 0x08, 0x08 );
else
ay->oric->via.write_port_b( &ay->oric->via, 0x08, 0x00 );
}
/*
** Handle a key press
*/
void ay_keypress( struct ay8912 *ay, SDL_COMPAT_KEY key, SDL_bool down )
{
int i;
// No key?
if( key == 0 ) return;
// Does this key exist on the Oric?
for( i=0; i<64; i++ )
if( keytab[i] == key ) break;
// No...
if( i == 64 ) return;
// Key down event, or key up event?
if( down )
ay->keystates[i>>3] |= (1<<(i&7)); // Down, so set the corresponding bit
else
ay->keystates[i>>3] &= ~(1<<(i&7)); // Up, so clear it
// Maybe update the VIA
if( ay->currkeyoffs == (i>>3) )
{
if( ay->keystates[ay->currkeyoffs] & (ay->eregs[AY_PORT_A]^0xff) )
ay->oric->via.write_port_b( &ay->oric->via, 0x08, 0x08 );
else
ay->oric->via.write_port_b( &ay->oric->via, 0x08, 0x00 );
}
}
/*
** GI addressing
*/
void ay_modeset( struct ay8912 *ay )
{
unsigned char v, lasts6=0;
if( (ay->bmode != AYBMF_BC1) && (ay->oric->porta_ay != 0xff) )
{
ay->oric->porta_ay = 0xff;
if( ay->oric->porta_is_ay )
ay->oric->via.write_port_a( &ay->oric->via, 0xff, 0xff );
}
switch( ay->bmode )
{
case AYBMF_BC1: // Read AY register
ay->oric->porta_ay = (ay->creg>=NUM_AY_REGS) ? 0 : ay->eregs[ay->creg];
ay->oric->via.write_port_a( &ay->oric->via, 0xff, ay->oric->porta_ay );
ay->oric->porta_is_ay = SDL_TRUE;
break;
case AYBMF_BDIR: // Write AY register
if( ay->creg >= NUM_AY_REGS ) break;
v = ay->oric->via.read_port_a( &ay->oric->via );
if( ay->creg == AY_STATUS )
lasts6 = ay->eregs[AY_STATUS] & 0x40;
if( ( ay->creg != AY_ENV_CYCLE ) || ( v != 0xff ) )
ay->eregs[ay->creg] = v;
switch( ay->creg )
{
case AY_STATUS:
if( (ay->eregs[AY_STATUS]&0x40) != lasts6 )
{
ay->keybitdelay = 3;
}
case AY_CHA_PER_L: // Channel A period
case AY_CHA_PER_H:
case AY_CHB_PER_L: // Channel B period
case AY_CHB_PER_H:
case AY_CHC_PER_L: // Channel C period
case AY_CHC_PER_H:
case AY_NOISE_PER: // Noise period
case AY_CHA_AMP:
case AY_CHB_AMP:
case AY_CHC_AMP:
case AY_ENV_PER_L:
case AY_ENV_PER_H:
case AY_ENV_CYCLE:
if( ( !soundon ) || ( warpspeed ) )
{
struct aywrite writenow;
ay_flushlog( ay );
writenow.cycle = 0;
writenow.reg = ay->creg;
writenow.val = v;
ay_dowrite( ay, &writenow );
break;
}
ay_lockaudio( ay ); // Gets unlocked at the end of each frame
if( ay->do_logcycle_reset )
{
ay->logcycle = ay->newlogcycle;
ay->do_logcycle_reset = SDL_FALSE;
}
if( ay->logged >= WRITELOG_SIZE )
ay_flushlog( ay );
ay->writelog[ay->logged ].cycle = ay->logcycle;
ay->writelog[ay->logged ].reg = ay->creg;
ay->writelog[ay->logged++].val = v;
break;
case AY_PORT_A:
ay->keybitdelay = 3;
break;
}
break;
case AYBMF_BDIR|AYBMF_BC1: // Set register
ay->creg = ay->oric->via.read_port_a( &ay->oric->via );
break;
}
}
void ay_set_bcmode( struct ay8912 *ay, unsigned char bc1, unsigned char bdir )
{
ay->bmode = (bc1?AYBMF_BC1:0)|(bdir?AYBMF_BDIR:0);
ay_modeset( ay );
}
void ay_set_bc1( struct ay8912 *ay, unsigned char state )
{
if( state )
ay->bmode |= AYBMF_BC1;
else
ay->bmode &= ~AYBMF_BC1;
ay_modeset( ay );
}
void ay_set_bdir( struct ay8912 *ay, unsigned char state )
{
if( state )
ay->bmode |= AYBMF_BDIR;
else
ay->bmode &= ~AYBMF_BDIR;
ay_modeset( ay );
}
void ay_soundloop( struct ay8912 *ay, unsigned char oldval, unsigned char newval)
{
if( !ay->soundloopon )
return;
oldval &= 0x80;
newval &= 0x80;
if( oldval == newval )
return;
ay_lockaudio( ay );
if(ay->do_logcycle_reset)
{
ay->logcycle = ay->newlogcycle;
ay->do_logcycle_reset = SDL_FALSE;
}
if(ay->tlogged < TAPELOG_SIZE)
{
ay->tapelog[ay->tlogged].cycle = ay->logcycle;
ay->tapelog[ay->tlogged++].val = newval? 1 : 0;
}
ay_unlockaudio( ay );
}