1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
// Nes_Snd_Emu 0.1.8. http://www.slack.net/~ant/
#include "nes_namco_apu.h"
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for more
details. You should have received a copy of the GNU Lesser General Public
License along with this module; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
#include "blargg_source.h"
void Namco_init( struct Nes_Namco_Apu* this )
{
Synth_init( &this->synth );
Namco_output( this, NULL );
Namco_volume( this, (int)FP_ONE_VOLUME );
Namco_reset( this );
}
void Namco_reset( struct Nes_Namco_Apu* this )
{
this->last_time = 0;
this->addr_reg = 0;
int i;
for ( i = 0; i < namco_reg_count; i++ )
this->reg [i] = 0;
for ( i = 0; i < namco_osc_count; i++ )
{
struct Namco_Osc* osc = &this->oscs [i];
osc->delay = 0;
osc->last_amp = 0;
osc->wave_pos = 0;
}
}
void Namco_output( struct Nes_Namco_Apu* this, struct Blip_Buffer* buf )
{
int i;
for ( i = 0; i < namco_osc_count; i++ )
Namco_osc_output( this, i, buf );
}
void Namco_end_frame( struct Nes_Namco_Apu* this, blip_time_t time )
{
if ( time > this->last_time )
Namco_run_until( this, time );
assert( this->last_time >= time );
this->last_time -= time;
}
void Namco_run_until( struct Nes_Namco_Apu* this, blip_time_t nes_end_time )
{
int active_oscs = (this->reg [0x7F] >> 4 & 7) + 1;
int i;
for ( i = namco_osc_count - active_oscs; i < namco_osc_count; i++ )
{
struct Namco_Osc* osc = &this->oscs [i];
struct Blip_Buffer* output = osc->output;
if ( !output )
continue;
blip_resampled_time_t time =
Blip_resampled_time( output, this->last_time ) + osc->delay;
blip_resampled_time_t end_time = Blip_resampled_time( output, nes_end_time );
osc->delay = 0;
if ( time < end_time )
{
const uint8_t* osc_reg = &this->reg [i * 8 + 0x40];
if ( !(osc_reg [4] & 0xE0) )
continue;
int volume = osc_reg [7] & 15;
if ( !volume )
continue;
int freq = (osc_reg [4] & 3) * 0x10000 + osc_reg [2] * 0x100L + osc_reg [0];
if ( freq < 64 * active_oscs )
continue; // prevent low frequencies from excessively delaying freq changes
int const master_clock_divider = 12; // NES time derived via divider of master clock
int const n106_divider = 45; // N106 then divides master clock by this
int const max_freq = 0x3FFFF;
int const lowest_freq_period = (max_freq + 1) * n106_divider / master_clock_divider;
// divide by 8 to avoid overflow
blip_resampled_time_t period =
Blip_resampled_duration( output, lowest_freq_period / 8 ) / freq * 8 * active_oscs;
int wave_size = 32 - (osc_reg [4] >> 2 & 7) * 4;
if ( !wave_size )
continue;
int last_amp = osc->last_amp;
int wave_pos = osc->wave_pos;
Blip_set_modified( output );
do
{
// read wave sample
int addr = wave_pos + osc_reg [6];
int sample = this->reg [addr >> 1] >> (addr << 2 & 4);
wave_pos++;
sample = (sample & 15) * volume;
// output impulse if amplitude changed
int delta = sample - last_amp;
if ( delta )
{
last_amp = sample;
Synth_offset_resampled( &this->synth, time, delta, output );
}
// next sample
time += period;
if ( wave_pos >= wave_size )
wave_pos = 0;
}
while ( time < end_time );
osc->wave_pos = wave_pos;
osc->last_amp = last_amp;
}
osc->delay = time - end_time;
}
this->last_time = nes_end_time;
}
|
