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
139
140
141
142
143
144
145
146
|
// ---------------------------------------------------------------------------
// This file is part of reSID, a MOS6581 SID emulator engine.
// Copyright (C) 2004 Dag Lem <resid@nimrod.no>
//
// 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; either version 2 of the License, or
// (at your option) any later version.
//
// 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// ---------------------------------------------------------------------------
#ifndef __SID_H__
#define __SID_H__
#include "siddefs.h"
#include "voice.h"
#include "filter.h"
#include "extfilt.h"
#include "pot.h"
class cSID
{
public:
cSID();
~cSID();
void set_chip_model(chip_model model);
void enable_filter(bool enable);
void enable_external_filter(bool enable);
bool set_sampling_parameters(double clock_freq, sampling_method method,
double sample_freq, double pass_freq = -1,
double filter_scale = 0.97);
void adjust_sampling_frequency(double sample_freq);
void fc_default(const fc_point*& points, int& count);
PointPlotter<sound_sample> fc_plotter();
void clock();
void clock(cycle_count delta_t);
int clock(cycle_count& delta_t, short* buf, int n, int interleave = 1);
void reset();
// Read/write registers.
reg8 read(reg8 offset);
void write(reg8 offset, reg8 value);
// Read/write state.
class State
{
public:
State();
char sid_register[0x20];
reg8 bus_value;
cycle_count bus_value_ttl;
reg24 accumulator[3];
reg24 shift_register[3];
reg16 rate_counter[3];
reg16 rate_counter_period[3];
reg16 exponential_counter[3];
reg16 exponential_counter_period[3];
reg8 envelope_counter[3];
EnvelopeGenerator::State envelope_state[3];
bool hold_zero[3];
};
State read_state();
void write_state(const State& state);
// 16-bit input (EXT IN).
void input(int sample);
// 16-bit output (AUDIO OUT).
int output();
// n-bit output.
int output(int bits);
protected:
static double I0(double x);
RESID_INLINE int clock_fast(cycle_count& delta_t, short* buf, int n,
int interleave);
RESID_INLINE int clock_interpolate(cycle_count& delta_t, short* buf, int n,
int interleave);
RESID_INLINE int clock_resample_interpolate(cycle_count& delta_t, short* buf,
int n, int interleave);
RESID_INLINE int clock_resample_fast(cycle_count& delta_t, short* buf,
int n, int interleave);
Voice voice[3];
Filter filter;
ExternalFilter extfilt;
Potentiometer potx;
Potentiometer poty;
reg8 bus_value;
cycle_count bus_value_ttl;
double clock_frequency;
// External audio input.
int ext_in;
// Resampling constants.
// The error in interpolated lookup is bounded by 1.234/L^2,
// while the error in non-interpolated lookup is bounded by
// 0.7854/L + 0.4113/L^2, see
// http://www-ccrma.stanford.edu/~jos/resample/Choice_Table_Size.html
// For a resolution of 16 bits this yields L >= 285 and L >= 51473,
// respectively.
static const int FIR_N;
static const int FIR_RES_INTERPOLATE;
static const int FIR_RES_FAST;
static const int FIR_SHIFT;
static const int RINGSIZE;
// Fixpoint constants (16.16 bits).
static const int FIXP_SHIFT;
static const int FIXP_MASK;
// Sampling variables.
sampling_method sampling;
cycle_count cycles_per_sample;
cycle_count sample_offset;
int sample_index;
short sample_prev;
int fir_N;
int fir_RES;
// Ring buffer with overflow for contiguous storage of RINGSIZE samples.
short* sample;
// FIR_RES filter tables (FIR_N*FIR_RES).
short* fir;
};
#endif // not __SID_H__
|
