SIDPlayer/src/prefs.cpp

/*
 *  prefs.cpp - Preferences handling
 *
 *  SIDPlayer (C) Copyright 1996-2000 Christian Bauer
 *
 *  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
 */

#include "sys.h"

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

#include "prefs.h"


// List of preferences items
prefs_desc prefs_items[] = {
        {"victype", TYPE_STRING, false},                // Type number of VIC-II to emulate ("6569", "6567" or "6567R5")
        {"sidtype", TYPE_STRING, false},                // Type number of SID to emulate ("6581" or "8580")
        {"samplerate", TYPE_INT32, false},              // Audio sample rate in Hz
        {"audio16bit", TYPE_BOOLEAN, false},    // 16-bit audio output?
        {"stereo", TYPE_BOOLEAN, false},                // Stereo audio output?
        {"filters", TYPE_BOOLEAN, false},               // Emulate SID filters?
        {"dualsid", TYPE_BOOLEAN, false},               // Emulate 2 SID chips?
        {"audioeffect", TYPE_INT32, false},             // Audio effect type (0 = none, 1 = reverb, 2 = spatial)
        {"revdelay", TYPE_INT32, false},                // Reverb delay in ms
        {"revfeedback", TYPE_INT32, false},             // Reverb feedback (0..0x100 = 0..100%)
        {"volume", TYPE_INT32, false},                  // Master volume (0..0x100 = 0..100%)
        {"v1volume", TYPE_INT32, false},                // Volume voice 1 (0..0x100 = 0..100%)
        {"v2volume", TYPE_INT32, false},                // Volume voice 2 (0..0x100 = 0..100%)
        {"v3volume", TYPE_INT32, false},                // Volume voice 3 (0..0x100 = 0..100%)
        {"v4volume", TYPE_INT32, false},                // Volume sampled voice (0..0x100 = 0..100%)
        {"v1pan", TYPE_INT32, false},                   // Panning voice 1 (-0x100..0x100 = left..right)
        {"v2pan", TYPE_INT32, false},                   // Panning voice 2 (-0x100..0x100 = left..right)
        {"v3pan", TYPE_INT32, false},                   // Panning voice 3 (-0x100..0x100 = left..right)
        {"v4pan", TYPE_INT32, false},                   // Panning sampled voice (-0x100..0x100 = left..right)
        {"dualsep", TYPE_INT32, false},                 // Dual-SID stereo separation (0..0x100 = 0..100%)
        {"replayfreq", TYPE_INT32, false},              // Frequency at which 6510 replay routine is called in Hz
        {NULL, TYPE_END, false} // End of list
};


// Prefs item are stored in a linked list of these nodes
struct prefs_node {
        prefs_node *next;
        const char *name;
        prefs_type type;
        void *data;
        prefs_desc *desc;
};

// List of prefs nodes
static prefs_node *the_prefs;


/*
 *  Initialize preferences
 */

void PrefsInit(int argc, char **argv)
{
        // Start with empty list
        the_prefs = NULL;

        // Set defaults
        PrefsAddString("victype", "6569");
        PrefsAddString("sidtype", "6581");
        PrefsAddInt32("samplerate", 44100);
        PrefsAddBool("audio16bit", true);
        PrefsAddBool("stereo", true);
        PrefsAddBool("filters", true);
        PrefsAddBool("dualsid", false);
        PrefsAddInt32("audioeffect", 2);
        PrefsAddInt32("revdelay", 125);
        PrefsAddInt32("revfeedback", 0x50);
        PrefsAddInt32("volume", 0x100);
        PrefsAddInt32("v1volume", 0x100);
        PrefsAddInt32("v1pan", -0x40);
        PrefsAddInt32("v2volume", 0x100);
        PrefsAddInt32("v2pan", 0);
        PrefsAddInt32("v3volume", 0x100);
        PrefsAddInt32("v3pan", 0x40);
        PrefsAddInt32("v4volume", 0x100);
        PrefsAddInt32("v4pan", 0);
        PrefsAddInt32("dualsep", 0x80);
        PrefsAddInt32("replayfreq", 50);
}


/*
 *  Deinitialize preferences
 */

void PrefsExit(void)
{
        // Free prefs list
        prefs_node *p = the_prefs, *next;
        while (p) {
                next = p->next;
                free((void *)p->name);
                free(p->data);
                delete p;
                p = next;
        }
}


/*
 *  Find preferences descriptor by keyword
 */

static prefs_desc *find_prefs_desc(const char *name, prefs_desc *list)
{
        while (list->type != TYPE_ANY) {
                if (strcmp(list->name, name) == 0)
                        return list;
                list++;
        }
        return NULL;
}


/*
 *  Set prefs items
 */

static void add_data(const char *name, prefs_type type, void *data, int size)
{
        void *d = malloc(size);
        if (d == NULL)
                return;
        memcpy(d, data, size);
        prefs_node *p = new prefs_node;
        p->next = 0;
        p->name = strdup(name);
        p->type = type;
        p->data = d;
        p->desc = find_prefs_desc(p->name, prefs_items);
        if (the_prefs) {
                prefs_node *prev = the_prefs;
                while (prev->next)
                        prev = prev->next;
                prev->next = p;
        } else
                the_prefs = p;
}

void PrefsAddString(const char *name, const char *s)
{
        add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
}

void PrefsAddBool(const char *name, bool b)
{
        add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
}

void PrefsAddInt32(const char *name, int32 val)
{
        add_data(name, TYPE_INT32, &val, sizeof(int32));
}


/*
 *  Replace prefs items
 */

static prefs_node *find_node(const char *name, prefs_type type, int index = 0)
{
        prefs_node *p = the_prefs;
        int i = 0;
        while (p) {
                if ((type == TYPE_ANY || p->type == type) && !strcmp(p->name, name)) {
                        if (i == index)
                                return p;
                        else
                                i++;
                }
                p = p->next;
        }
        return NULL;
}

void PrefsReplaceString(const char *name, const char *s, int index)
{
        prefs_node *p = find_node(name, TYPE_STRING, index);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_string)(p->desc->func))(name, (const char *)p->data, s);
                free(p->data);
                p->data = strdup(s);
        } else
                add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
}

void PrefsReplaceBool(const char *name, bool b)
{
        prefs_node *p = find_node(name, TYPE_BOOLEAN);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_bool)(p->desc->func))(name, *(bool *)(p->data), b);
                *(bool *)(p->data) = b;
        } else
                add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
}

void PrefsReplaceInt32(const char *name, int32 val)
{
        prefs_node *p = find_node(name, TYPE_INT32);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_int32)(p->desc->func))(name, *(int32 *)(p->data), val);
                *(int32 *)(p->data) = val;
        } else
                add_data(name, TYPE_INT32, &val, sizeof(int32));
}


/*
 *  Get prefs items
 */

const char *PrefsFindString(const char *name, int index)
{
        prefs_node *p = find_node(name, TYPE_STRING, index);
        if (p)
                return (char *)(p->data);
        else
                return NULL;
}

bool PrefsFindBool(const char *name)
{
        prefs_node *p = find_node(name, TYPE_BOOLEAN, 0);
        if (p)
                return *(bool *)(p->data);
        else
                return false;
}

int32 PrefsFindInt32(const char *name)
{
        prefs_node *p = find_node(name, TYPE_INT32, 0);
        if (p)
                return *(int32 *)(p->data);
        else
                return 0;
}


/*
 *  Remove prefs items
 */

void PrefsRemoveItem(const char *name, int index)
{
        prefs_node *p = find_node(name, TYPE_ANY, index);
        if (p) {
                free((void *)p->name);
                free(p->data);
                prefs_node *q = the_prefs;
                if (q == p) {
                        the_prefs = NULL;
                        delete p;
                        return;
                }
                while (q) {
                        if (q->next == p) {
                                q->next = p->next;
                                delete p;
                                return;
                        }
                        q = q->next;
                }
        }
}


/*
 *  Set prefs change callback function
 */

static void set_callback(const char *name, prefs_func f)
{
        prefs_desc *d = find_prefs_desc(name, prefs_items);
        if (d == NULL)
                return;
        d->func = f;
}

void PrefsSetCallback(const char *name, prefs_func_string f)
{
        set_callback(name, (prefs_func)f);
}

void PrefsSetCallback(const char *name, prefs_func_bool f)
{
        set_callback(name, (prefs_func)f);
}

void PrefsSetCallback(const char *name, prefs_func_int32 f)
{
        set_callback(name, (prefs_func)f);
}
Revision:	1.1
Committed:	2000-07-28T12:42:30Z (24 years, 3 months ago) by cebix
Branch:	MAIN
Branch point for:	cebix
Log Message:	Initial revision
#	User	Rev	Content
1	cebix	1.1	/*
2			* prefs.cpp - Preferences handling
3			*
4			* SIDPlayer (C) Copyright 1996-2000 Christian Bauer
5			*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "sys.h"
22
23			#include <string.h>
24			#include <stdlib.h>
25			#include <stdio.h>
26			#include <ctype.h>
27
28			#include "prefs.h"
29
30
31			// List of preferences items
32			prefs_desc prefs_items[] = {
33			{"victype", TYPE_STRING, false}, // Type number of VIC-II to emulate ("6569", "6567" or "6567R5")
34			{"sidtype", TYPE_STRING, false}, // Type number of SID to emulate ("6581" or "8580")
35			{"samplerate", TYPE_INT32, false}, // Audio sample rate in Hz
36			{"audio16bit", TYPE_BOOLEAN, false}, // 16-bit audio output?
37			{"stereo", TYPE_BOOLEAN, false}, // Stereo audio output?
38			{"filters", TYPE_BOOLEAN, false}, // Emulate SID filters?
39			{"dualsid", TYPE_BOOLEAN, false}, // Emulate 2 SID chips?
40			{"audioeffect", TYPE_INT32, false}, // Audio effect type (0 = none, 1 = reverb, 2 = spatial)
41			{"revdelay", TYPE_INT32, false}, // Reverb delay in ms
42			{"revfeedback", TYPE_INT32, false}, // Reverb feedback (0..0x100 = 0..100%)
43			{"volume", TYPE_INT32, false}, // Master volume (0..0x100 = 0..100%)
44			{"v1volume", TYPE_INT32, false}, // Volume voice 1 (0..0x100 = 0..100%)
45			{"v2volume", TYPE_INT32, false}, // Volume voice 2 (0..0x100 = 0..100%)
46			{"v3volume", TYPE_INT32, false}, // Volume voice 3 (0..0x100 = 0..100%)
47			{"v4volume", TYPE_INT32, false}, // Volume sampled voice (0..0x100 = 0..100%)
48			{"v1pan", TYPE_INT32, false}, // Panning voice 1 (-0x100..0x100 = left..right)
49			{"v2pan", TYPE_INT32, false}, // Panning voice 2 (-0x100..0x100 = left..right)
50			{"v3pan", TYPE_INT32, false}, // Panning voice 3 (-0x100..0x100 = left..right)
51			{"v4pan", TYPE_INT32, false}, // Panning sampled voice (-0x100..0x100 = left..right)
52			{"dualsep", TYPE_INT32, false}, // Dual-SID stereo separation (0..0x100 = 0..100%)
53			{"replayfreq", TYPE_INT32, false}, // Frequency at which 6510 replay routine is called in Hz
54			{NULL, TYPE_END, false} // End of list
55			};
56
57
58			// Prefs item are stored in a linked list of these nodes
59			struct prefs_node {
60			prefs_node *next;
61			const char *name;
62			prefs_type type;
63			void *data;
64			prefs_desc *desc;
65			};
66
67			// List of prefs nodes
68			static prefs_node *the_prefs;
69
70
71			/*
72			* Initialize preferences
73			*/
74
75			void PrefsInit(int argc, char **argv)
76			{
77			// Start with empty list
78			the_prefs = NULL;
79
80			// Set defaults
81			PrefsAddString("victype", "6569");
82			PrefsAddString("sidtype", "6581");
83			PrefsAddInt32("samplerate", 44100);
84			PrefsAddBool("audio16bit", true);
85			PrefsAddBool("stereo", true);
86			PrefsAddBool("filters", true);
87			PrefsAddBool("dualsid", false);
88			PrefsAddInt32("audioeffect", 2);
89			PrefsAddInt32("revdelay", 125);
90			PrefsAddInt32("revfeedback", 0x50);
91			PrefsAddInt32("volume", 0x100);
92			PrefsAddInt32("v1volume", 0x100);
93			PrefsAddInt32("v1pan", -0x40);
94			PrefsAddInt32("v2volume", 0x100);
95			PrefsAddInt32("v2pan", 0);
96			PrefsAddInt32("v3volume", 0x100);
97			PrefsAddInt32("v3pan", 0x40);
98			PrefsAddInt32("v4volume", 0x100);
99			PrefsAddInt32("v4pan", 0);
100			PrefsAddInt32("dualsep", 0x80);
101			PrefsAddInt32("replayfreq", 50);
102			}
103
104
105			/*
106			* Deinitialize preferences
107			*/
108
109			void PrefsExit(void)
110			{
111			// Free prefs list
112			prefs_node p = the_prefs, next;
113			while (p) {
114			next = p->next;
115			free((void *)p->name);
116			free(p->data);
117			delete p;
118			p = next;
119			}
120			}
121
122
123			/*
124			* Find preferences descriptor by keyword
125			*/
126
127			static prefs_desc find_prefs_desc(const char name, prefs_desc *list)
128			{
129			while (list->type != TYPE_ANY) {
130			if (strcmp(list->name, name) == 0)
131			return list;
132			list++;
133			}
134			return NULL;
135			}
136
137
138			/*
139			* Set prefs items
140			*/
141
142			static void add_data(const char name, prefs_type type, void data, int size)
143			{
144			void *d = malloc(size);
145			if (d == NULL)
146			return;
147			memcpy(d, data, size);
148			prefs_node *p = new prefs_node;
149			p->next = 0;
150			p->name = strdup(name);
151			p->type = type;
152			p->data = d;
153			p->desc = find_prefs_desc(p->name, prefs_items);
154			if (the_prefs) {
155			prefs_node *prev = the_prefs;
156			while (prev->next)
157			prev = prev->next;
158			prev->next = p;
159			} else
160			the_prefs = p;
161			}
162
163			void PrefsAddString(const char name, const char s)
164			{
165			add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
166			}
167
168			void PrefsAddBool(const char *name, bool b)
169			{
170			add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
171			}
172
173			void PrefsAddInt32(const char *name, int32 val)
174			{
175			add_data(name, TYPE_INT32, &val, sizeof(int32));
176			}
177
178
179			/*
180			* Replace prefs items
181			*/
182
183			static prefs_node find_node(const char name, prefs_type type, int index = 0)
184			{
185			prefs_node *p = the_prefs;
186			int i = 0;
187			while (p) {
188			if ((type == TYPE_ANY \|\| p->type == type) && !strcmp(p->name, name)) {
189			if (i == index)
190			return p;
191			else
192			i++;
193			}
194			p = p->next;
195			}
196			return NULL;
197			}
198
199			void PrefsReplaceString(const char name, const char s, int index)
200			{
201			prefs_node *p = find_node(name, TYPE_STRING, index);
202			if (p) {
203			if (p->desc && p->desc->func)
204			((prefs_func_string)(p->desc->func))(name, (const char *)p->data, s);
205			free(p->data);
206			p->data = strdup(s);
207			} else
208			add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
209			}
210
211			void PrefsReplaceBool(const char *name, bool b)
212			{
213			prefs_node *p = find_node(name, TYPE_BOOLEAN);
214			if (p) {
215			if (p->desc && p->desc->func)
216			((prefs_func_bool)(p->desc->func))(name, (bool )(p->data), b);
217			(bool )(p->data) = b;
218			} else
219			add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
220			}
221
222			void PrefsReplaceInt32(const char *name, int32 val)
223			{
224			prefs_node *p = find_node(name, TYPE_INT32);
225			if (p) {
226			if (p->desc && p->desc->func)
227			((prefs_func_int32)(p->desc->func))(name, (int32 )(p->data), val);
228			(int32 )(p->data) = val;
229			} else
230			add_data(name, TYPE_INT32, &val, sizeof(int32));
231			}
232
233
234			/*
235			* Get prefs items
236			*/
237
238			const char PrefsFindString(const char name, int index)
239			{
240			prefs_node *p = find_node(name, TYPE_STRING, index);
241			if (p)
242			return (char *)(p->data);
243			else
244			return NULL;
245			}
246
247			bool PrefsFindBool(const char *name)
248			{
249			prefs_node *p = find_node(name, TYPE_BOOLEAN, 0);
250			if (p)
251			return (bool )(p->data);
252			else
253			return false;
254			}
255
256			int32 PrefsFindInt32(const char *name)
257			{
258			prefs_node *p = find_node(name, TYPE_INT32, 0);
259			if (p)
260			return (int32 )(p->data);
261			else
262			return 0;
263			}
264
265
266			/*
267			* Remove prefs items
268			*/
269
270			void PrefsRemoveItem(const char *name, int index)
271			{
272			prefs_node *p = find_node(name, TYPE_ANY, index);
273			if (p) {
274			free((void *)p->name);
275			free(p->data);
276			prefs_node *q = the_prefs;
277			if (q == p) {
278			the_prefs = NULL;
279			delete p;
280			return;
281			}
282			while (q) {
283			if (q->next == p) {
284			q->next = p->next;
285			delete p;
286			return;
287			}
288			q = q->next;
289			}
290			}
291			}
292
293
294			/*
295			* Set prefs change callback function
296			*/
297
298			static void set_callback(const char *name, prefs_func f)
299			{
300			prefs_desc *d = find_prefs_desc(name, prefs_items);
301			if (d == NULL)
302			return;
303			d->func = f;
304			}
305
306			void PrefsSetCallback(const char *name, prefs_func_string f)
307			{
308			set_callback(name, (prefs_func)f);
309			}
310
311			void PrefsSetCallback(const char *name, prefs_func_bool f)
312			{
313			set_callback(name, (prefs_func)f);
314			}
315
316			void PrefsSetCallback(const char *name, prefs_func_int32 f)
317			{
318			set_callback(name, (prefs_func)f);
319			}