SIDPlayer/src/main.cpp

/*
 *  main.cpp - SIDPlayer common routines
 *
 *  SIDPlayer (C) Copyright 1996-2001 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 <stdio.h>
#include <string.h>

#if defined(__BEOS__)
#include <support/UTF8.h>
#endif

#include "main.h"
#include "prefs.h"
#include "mem.h"
#include "cpu.h"
#include "sid.h"
#include "psid.h"


// Global variables
uint32 f_rand_seed = 1;
int number_of_songs, current_song;
char module_name[64];
char author_name[64];
char copyright_info[64];

// Flag: PSID file loaded and ready
static bool psid_loaded = false;

// Data from PSID header
static uint16 init_adr;                 // C64 init routine address
uint16 play_adr;                                // C64 replay routine address
static uint32 speed_flags;              // Speed flags (1 bit/song)


/*
 *  Init everything
 */

void InitAll(int &argc, char **&argv)
{
        PrefsInit(argc, argv);
        MemoryInit();
        SIDInit();
        CPUInit();
}


/*
 *  Exit everything
 */

void ExitAll(void)
{
        CPUExit();
        SIDExit();
        MemoryExit();
        PrefsExit();
}


/*
 *  Read PSID file header to buffer
 */

bool LoadPSIDHeader(const char *file, uint8 *p)
{
        // Read header
        memset(p, 0, PSID_MAX_HEADER_LENGTH);
        FILE *f = fopen(file, "rb");
        if (f == NULL)
                return false;
        size_t actual = fread(p, 1, PSID_MAX_HEADER_LENGTH, f);
        fclose(f);
        return actual >= PSID_MIN_HEADER_LENGTH;
}


/*
 *  Check for PSID header
 */

bool IsPSIDHeader(const uint8 *p)
{
        // Check signature and version
        uint32 id = read_psid_32(p, PSID_ID);
        uint16 version = read_psid_16(p, PSID_VERSION);
        return id == 0x50534944 && (version == 1 || version == 2);
}


/*
 *  Check whether file is a PSID file
 */

bool IsPSIDFile(const char *file)
{
        // Load header
        uint8 header[PSID_MAX_HEADER_LENGTH];
        if (!LoadPSIDHeader(file, header))
                return false;

        // Check header
        return IsPSIDHeader(header);
}


/*
 *  Load PSID file for playing
 */

bool LoadPSIDFile(const char *file)
{
        // Open file
        FILE *f = fopen(file, "rb");
        if (f == NULL)
                return false;

        // Clear C64 RAM
        MemoryClear();
        psid_loaded = false;

        // Load and check header
        uint8 header[PSID_MAX_HEADER_LENGTH];
        memset(header, 0, PSID_MAX_HEADER_LENGTH);
        size_t actual = fread(header, 1, PSID_MAX_HEADER_LENGTH, f);
        if (actual < PSID_MIN_HEADER_LENGTH || !IsPSIDHeader(header)) {
                fclose(f);
                return false;
        }

        // Extract data from header
        number_of_songs = read_psid_16(header, PSID_NUMBER);
        if (number_of_songs == 0)
                number_of_songs = 1;
        current_song = read_psid_16(header, PSID_DEFSONG);
        if (current_song)
                current_song--;
        if (current_song >= number_of_songs)
                current_song = 0;

        init_adr = read_psid_16(header, PSID_INIT);
        play_adr = read_psid_16(header, PSID_MAIN);

        speed_flags = read_psid_32(header, PSID_SPEED);

#if defined(__BEOS__)
        int32 sl = 32, dl = 64, state = 0;
        convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_NAME), &sl, module_name, &dl, &state);
        sl = 32, dl = 64, state = 0;
        convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_AUTHOR), &sl, author_name, &dl, &state);
        sl = 32, dl = 64, state = 0;
        convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_COPYRIGHT), &sl, copyright_info, &dl, &state);
        module_name[63] = 0;
        author_name[63] = 0;
        copyright_info[63] = 0;
#else
        strncpy(module_name, (char *)(header + PSID_NAME), 32);
        strncpy(author_name, (char *)(header + PSID_AUTHOR), 32);
        strncpy(copyright_info, (char *)(header + PSID_COPYRIGHT), 32);
        module_name[32] = 0;
        author_name[32] = 0;
        copyright_info[32] = 0;
#endif

        // Seek to start of module data
        fseek(f, read_psid_16(header, PSID_LENGTH), SEEK_SET);

        // Find load address
        uint16 load_adr = read_psid_16(header, PSID_START);
        if (load_adr == 0) {    // Load address is at start of module data
                uint8 lo = fgetc(f);
                uint8 hi = fgetc(f);
                load_adr = (hi << 8) | lo;
        }
        if (init_adr == 0)              // Init routine address is equal to load address
                init_adr = load_adr;

        // Load module data to C64 RAM
        fread(ram + load_adr, 1, RAM_SIZE - load_adr, f);
        fclose(f);

        // Select default song
        SelectSong(current_song);

        // Set replay routine address if not given in header
        if (play_adr == 0) {    // Replay routine address is given by interrupt vector
                if (ram[1] & 2)         // Kernal ROM switched in
                        play_adr = (ram[0x0315] << 8) | ram[0x0314];
                else                            // Kernal ROM switched out
                        play_adr = (ram[0xffff] << 8) | ram[0xfffe];
        }

        // Everything OK
        psid_loaded = true;
        return true;
}


/*
 *  PSID file loaded and ready?
 */

bool IsPSIDLoaded(void)
{
        return psid_loaded;
}


/*
 *  Select song for playing
 */

void SelectSong(int num)
{
        if (num >= number_of_songs)
                num = 0;
        current_song = num;     

        // Reset SID
        SIDReset(0);

        // Set replay frequency
        int freq = 50;
        if (num < 32)
                freq = speed_flags & (1 << num) ? 60 : 50;
        SIDSetReplayFreq(freq);
        SIDAdjustSpeed(100);

        // Execute init routine
        CPUExecute(init_adr, current_song, 0, 0, 1000000);
}
Revision:	1.5
Committed:	2001-04-01T12:13:49Z (23 years ago) by cebix
Branch:	MAIN
Changes since 1.4:	+1 -1 lines
Log Message:	- PrefsInit() removes processed options - changes to command line argument handling
#	User	Rev	Content
1	cebix	1.1	/*
2	cebix	1.2	* main.cpp - SIDPlayer common routines
3	cebix	1.1	*
4	cebix	1.4	* SIDPlayer (C) Copyright 1996-2001 Christian Bauer
5	cebix	1.1	*
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 <stdio.h>
24			#include <string.h>
25	cebix	1.2
26			#if defined(__BEOS__)
27			#include <support/UTF8.h>
28			#endif
29	cebix	1.1
30			#include "main.h"
31			#include "prefs.h"
32			#include "mem.h"
33			#include "cpu.h"
34			#include "sid.h"
35			#include "psid.h"
36
37
38			// Global variables
39			uint32 f_rand_seed = 1;
40	cebix	1.2	int number_of_songs, current_song;
41			char module_name[64];
42			char author_name[64];
43			char copyright_info[64];
44	cebix	1.1
45			// Flag: PSID file loaded and ready
46			static bool psid_loaded = false;
47
48			// Data from PSID header
49			static uint16 init_adr; // C64 init routine address
50			uint16 play_adr; // C64 replay routine address
51			static uint32 speed_flags; // Speed flags (1 bit/song)
52
53
54
55			/*
56			* Init everything
57			*/
58
59	cebix	1.5	void InitAll(int &argc, char **&argv)
60	cebix	1.1	{
61	cebix	1.3	PrefsInit(argc, argv);
62	cebix	1.1	MemoryInit();
63			SIDInit();
64			CPUInit();
65			}
66
67
68			/*
69			* Exit everything
70			*/
71
72			void ExitAll(void)
73			{
74			CPUExit();
75			SIDExit();
76			MemoryExit();
77			PrefsExit();
78			}
79
80
81			/*
82			* Read PSID file header to buffer
83			*/
84
85			bool LoadPSIDHeader(const char file, uint8 p)
86			{
87			// Read header
88			memset(p, 0, PSID_MAX_HEADER_LENGTH);
89	cebix	1.2	FILE *f = fopen(file, "rb");
90			if (f == NULL)
91	cebix	1.1	return false;
92	cebix	1.2	size_t actual = fread(p, 1, PSID_MAX_HEADER_LENGTH, f);
93			fclose(f);
94	cebix	1.1	return actual >= PSID_MIN_HEADER_LENGTH;
95			}
96
97
98			/*
99			* Check for PSID header
100			*/
101
102			bool IsPSIDHeader(const uint8 *p)
103			{
104			// Check signature and version
105			uint32 id = read_psid_32(p, PSID_ID);
106			uint16 version = read_psid_16(p, PSID_VERSION);
107	cebix	1.2	return id == 0x50534944 && (version == 1 \|\| version == 2);
108	cebix	1.1	}
109
110
111			/*
112			* Check whether file is a PSID file
113			*/
114
115			bool IsPSIDFile(const char *file)
116			{
117			// Load header
118			uint8 header[PSID_MAX_HEADER_LENGTH];
119			if (!LoadPSIDHeader(file, header))
120			return false;
121
122			// Check header
123			return IsPSIDHeader(header);
124			}
125
126
127			/*
128			* Load PSID file for playing
129			*/
130
131			bool LoadPSIDFile(const char *file)
132			{
133			// Open file
134	cebix	1.2	FILE *f = fopen(file, "rb");
135			if (f == NULL)
136	cebix	1.1	return false;
137
138			// Clear C64 RAM
139			MemoryClear();
140			psid_loaded = false;
141
142			// Load and check header
143			uint8 header[PSID_MAX_HEADER_LENGTH];
144	cebix	1.2	memset(header, 0, PSID_MAX_HEADER_LENGTH);
145			size_t actual = fread(header, 1, PSID_MAX_HEADER_LENGTH, f);
146			if (actual < PSID_MIN_HEADER_LENGTH \|\| !IsPSIDHeader(header)) {
147			fclose(f);
148	cebix	1.1	return false;
149			}
150
151			// Extract data from header
152			number_of_songs = read_psid_16(header, PSID_NUMBER);
153			if (number_of_songs == 0)
154			number_of_songs = 1;
155			current_song = read_psid_16(header, PSID_DEFSONG);
156			if (current_song)
157			current_song--;
158			if (current_song >= number_of_songs)
159			current_song = 0;
160
161			init_adr = read_psid_16(header, PSID_INIT);
162			play_adr = read_psid_16(header, PSID_MAIN);
163
164			speed_flags = read_psid_32(header, PSID_SPEED);
165
166	cebix	1.2	#if defined(__BEOS__)
167	cebix	1.1	int32 sl = 32, dl = 64, state = 0;
168			convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_NAME), &sl, module_name, &dl, &state);
169			sl = 32, dl = 64, state = 0;
170			convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_AUTHOR), &sl, author_name, &dl, &state);
171			sl = 32, dl = 64, state = 0;
172			convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_COPYRIGHT), &sl, copyright_info, &dl, &state);
173			module_name[63] = 0;
174			author_name[63] = 0;
175			copyright_info[63] = 0;
176	cebix	1.2	#else
177			strncpy(module_name, (char *)(header + PSID_NAME), 32);
178			strncpy(author_name, (char *)(header + PSID_AUTHOR), 32);
179			strncpy(copyright_info, (char *)(header + PSID_COPYRIGHT), 32);
180			module_name[32] = 0;
181			author_name[32] = 0;
182			copyright_info[32] = 0;
183			#endif
184	cebix	1.1
185			// Seek to start of module data
186	cebix	1.2	fseek(f, read_psid_16(header, PSID_LENGTH), SEEK_SET);
187	cebix	1.1
188			// Find load address
189			uint16 load_adr = read_psid_16(header, PSID_START);
190			if (load_adr == 0) { // Load address is at start of module data
191	cebix	1.2	uint8 lo = fgetc(f);
192			uint8 hi = fgetc(f);
193	cebix	1.1	load_adr = (hi << 8) \| lo;
194			}
195			if (init_adr == 0) // Init routine address is equal to load address
196			init_adr = load_adr;
197
198			// Load module data to C64 RAM
199	cebix	1.2	fread(ram + load_adr, 1, RAM_SIZE - load_adr, f);
200			fclose(f);
201	cebix	1.1
202			// Select default song
203			SelectSong(current_song);
204
205			// Set replay routine address if not given in header
206			if (play_adr == 0) { // Replay routine address is given by interrupt vector
207			if (ram[1] & 2) // Kernal ROM switched in
208			play_adr = (ram[0x0315] << 8) \| ram[0x0314];
209			else // Kernal ROM switched out
210			play_adr = (ram[0xffff] << 8) \| ram[0xfffe];
211			}
212
213			// Everything OK
214			psid_loaded = true;
215			return true;
216	cebix	1.4	}
217
218
219			/*
220			* PSID file loaded and ready?
221			*/
222
223			bool IsPSIDLoaded(void)
224			{
225			return psid_loaded;
226	cebix	1.1	}
227
228
229			/*
230			* Select song for playing
231			*/
232
233			void SelectSong(int num)
234			{
235			if (num >= number_of_songs)
236			num = 0;
237			current_song = num;
238
239			// Reset SID
240			SIDReset(0);
241
242			// Set replay frequency
243			int freq = 50;
244			if (num < 32)
245			freq = speed_flags & (1 << num) ? 60 : 50;
246			SIDSetReplayFreq(freq);
247			SIDAdjustSpeed(100);
248
249			// Execute init routine
250			CPUExecute(init_adr, current_song, 0, 0, 1000000);
251			}