Mercurial > hg > xmms-sid

comparison src/xs_sidplay2.cc @ 230:608f31f6c095

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Raw cleanup.
author Matti Hamalainen <ccr@tnsp.org>
date Tue, 21 Dec 2004 09:25:03 +0000
parents ddb513bd2610
children e613873c3379
comparison
equal deleted inserted replaced
229:7bb9e20e3092 230:608f31f6c095
21 */ 21 */
22 #include "xmms-sid.h" 22 #include "xmms-sid.h"
23 23
24 #ifdef HAVE_SIDPLAY2 24 #ifdef HAVE_SIDPLAY2
25 25
26 extern "C" {
27 #include "xs_sidplay2.h" 26 #include "xs_sidplay2.h"
28 #include <stdio.h> 27 #include <stdio.h>
29 #include <xmms/titlestring.h>
30 #include "xs_config.h" 28 #include "xs_config.h"
31 #include "xs_support.h" 29 #include "xs_support.h"
32 #include "xs_length.h" 30 #include "xs_length.h"
33 } 31 #include "xs_title.h"
34 32
35 #include <sidplay/sidplay2.h> 33 #include <sidplay/sidplay2.h>
36 #ifdef HAVE_RESID_BUILDER 34 #ifdef HAVE_RESID_BUILDER
37 #include <sidplay/builders/resid.h> 35 #include <sidplay/builders/resid.h>
38 #endif 36 #endif
77 /* 75 /*
78 * Initialize SIDPlay2 76 * Initialize SIDPlay2
79 */ 77 */
80 gboolean xs_sidplay2_init(t_xs_status *myStatus) 78 gboolean xs_sidplay2_init(t_xs_status *myStatus)
81 { 79 {
82 t_xs_sidplay2 *myPlayer; 80 t_xs_sidplay2 *myEngine;
83 assert(myStatus); 81 assert(myStatus);
84 82
85 /* Allocate internal structures */ 83 /* Allocate internal structures */
86 myPlayer = (t_xs_sidplay2 *) g_malloc0(sizeof(t_xs_sidplay2)); 84 myEngine = (t_xs_sidplay2 *) g_malloc0(sizeof(t_xs_sidplay2));
87 if (!myPlayer) return FALSE; 85 if (!myEngine) return FALSE;
88 86
89 87
90 /* Initialize the engine */ 88 /* Initialize the engine */
91 myPlayer->currEng = new sidplay2; 89 myEngine->currEng = new sidplay2;
92 if (!myPlayer->currEng) 90 if (!myEngine->currEng)
93 { 91 {
94 XSERR("Could not initialize libSIDPlay2 emulation engine\n"); 92 XSERR("Could not initialize libSIDPlay2 emulation engine\n");
95 return FALSE; 93 return FALSE;
96 } 94 }
97 95
101 if (xs_cfg.sid2Builder == XS_BLD_RESID) 99 if (xs_cfg.sid2Builder == XS_BLD_RESID)
102 { 100 {
103 ReSIDBuilder *tmpb = new ReSIDBuilder("SIDPlay2 suxx and is made by a fag - ReSID builder"); 101 ReSIDBuilder *tmpb = new ReSIDBuilder("SIDPlay2 suxx and is made by a fag - ReSID builder");
104 102
105 /* Create the builder -- WHAT IS THIS MEANT FOR??? */ 103 /* Create the builder -- WHAT IS THIS MEANT FOR??? */
106 tmpb->create(myPlayer->currEng->info().maxsids); 104 tmpb->create(myEngine->currEng->info().maxsids);
107 105
108 myPlayer->currBuilder = (sidbuilder *) tmpb; 106 myEngine->currBuilder = (sidbuilder *) tmpb;
109 } 107 }
110 #endif 108 #endif
111 #ifdef HAVE_HARDSID_BUILDER 109 #ifdef HAVE_HARDSID_BUILDER
112 if (xs_cfg.sid2Builder == XS_BLD_HARDSID) 110 if (xs_cfg.sid2Builder == XS_BLD_HARDSID)
113 { 111 {
114 } 112 }
115 #endif 113 #endif
116 114
117 if (!myPlayer->currBuilder) 115 if (!myEngine->currBuilder)
118 { 116 {
119 XSERR("Could not initialize SIDBuilder object.\n"); 117 XSERR("Could not initialize SIDBuilder object.\n");
120 return FALSE; 118 return FALSE;
121 } 119 }
122 120
123 XSDEBUG("%s\n", myPlayer->currBuilder->credits()); 121 XSDEBUG("%s\n", myEngine->currBuilder->credits());
124 122
125 123
126 /* Create the sidtune */ 124 /* Create the sidtune */
127 myPlayer->currTune = new SidTune(0); 125 myEngine->currTune = new SidTune(0);
128 if (!myPlayer->currTune) 126 if (!myEngine->currTune)
129 { 127 {
130 XSERR("Could not initialize SIDTune object.\n"); 128 XSERR("Could not initialize SIDTune object.\n");
131 return FALSE; 129 return FALSE;
132 } 130 }
133 131
134 /* OK */ 132 /* OK */
135 myStatus->player = myPlayer; 133 myStatus->sidEngine = myEngine;
136 return TRUE; 134 return TRUE;
137 } 135 }
138 136
139 137
140 /* 138 /*
141 * Close SIDPlay2 139 * Close SIDPlay2
142 */ 140 */
143 void xs_sidplay2_close(t_xs_status *myStatus) 141 void xs_sidplay2_close(t_xs_status *myStatus)
144 { 142 {
145 t_xs_sidplay2 *myPlayer; 143 t_xs_sidplay2 *myEngine;
146 assert(myStatus); 144 assert(myStatus);
147 145
148 /* Free internals */ 146 /* Free internals */
149 myPlayer = (t_xs_sidplay2 *) myStatus->player; 147 myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
150 148
151 if (myPlayer->currBuilder) 149 if (myEngine->currBuilder)
152 { 150 {
153 delete myPlayer->currBuilder; 151 delete myEngine->currBuilder;
154 myPlayer->currBuilder = NULL; 152 myEngine->currBuilder = NULL;
155 } 153 }
156 154
157 if (myPlayer->currEng) 155 if (myEngine->currEng)
158 { 156 {
159 delete myPlayer->currEng; 157 delete myEngine->currEng;
160 myPlayer->currEng = NULL; 158 myEngine->currEng = NULL;
161 } 159 }
162 160
163 if (myPlayer->currTune) 161 if (myEngine->currTune)
164 { 162 {
165 delete myPlayer->currTune; 163 delete myEngine->currTune;
166 myPlayer->currTune = NULL; 164 myEngine->currTune = NULL;
167 } 165 }
168 166
169 xs_sidplay2_deletesid(myStatus); 167 xs_sidplay2_deletesid(myStatus);
170 168
171 g_free(myPlayer); 169 g_free(myEngine);
172 myStatus->player = NULL; 170 myStatus->sidEngine = NULL;
173 } 171 }
174 172
175 173
176 gboolean xs_sidplay2_initsong(t_xs_status *myStatus) 174 gboolean xs_sidplay2_initsong(t_xs_status *myStatus)
177 { 175 {
178 t_xs_sidplay2 *myPlayer = (t_xs_sidplay2 *) myStatus->player; 176 t_xs_sidplay2 *myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
179 177
180 if (!myPlayer) return FALSE; 178 if (!myEngine) return FALSE;
181 179
182 if (!myPlayer->currTune->selectSong(myStatus->currSong)) 180 if (!myEngine->currTune->selectSong(myStatus->currSong))
183 { 181 {
184 XSERR("ENGINE selectSong() failed\n"); 182 XSERR("ENGINE selectSong() failed\n");
185 return FALSE; 183 return FALSE;
186 } 184 }
187 185
188 if (myPlayer->currEng->load(myPlayer->currTune) < 0) 186 if (myEngine->currEng->load(myEngine->currTune) < 0)
189 { 187 {
190 XSERR("ENGINE load() failed\n"); 188 XSERR("ENGINE load() failed\n");
191 return FALSE; 189 return FALSE;
192 } 190 }
193 191
195 } 193 }
196 194
197 195
198 guint xs_sidplay2_fillbuffer(t_xs_status *myStatus, gchar *audioBuffer, guint audioBufSize) 196 guint xs_sidplay2_fillbuffer(t_xs_status *myStatus, gchar *audioBuffer, guint audioBufSize)
199 { 197 {
200 t_xs_sidplay2 *myPlayer = (t_xs_sidplay2 *) myStatus->player; 198 t_xs_sidplay2 *myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
201 199
202 return myPlayer->currEng->play(audioBuffer, audioBufSize); 200 return myEngine->currEng->play(audioBuffer, audioBufSize);
203 } 201 }
204 202
205 203
206 gboolean xs_sidplay2_loadsid(t_xs_status *myStatus, gchar *pcFilename) 204 gboolean xs_sidplay2_loadsid(t_xs_status *myStatus, gchar *pcFilename)
207 { 205 {
208 t_xs_sidplay2 *myPlayer = (t_xs_sidplay2 *) myStatus->player; 206 t_xs_sidplay2 *myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
209 assert(myStatus); 207 assert(myStatus);
210 208
211 /* Try to get the tune */ 209 /* Try to get the tune */
212 if (!pcFilename) return FALSE; 210 if (!pcFilename) return FALSE;
213 if (!myPlayer->currTune->load(pcFilename)) return FALSE; 211 if (!myEngine->currTune->load(pcFilename)) return FALSE;
214 212
215 /* Get current configuration */ 213 /* Get current configuration */
216 myPlayer->currConfig = myPlayer->currEng->config(); 214 myEngine->currConfig = myEngine->currEng->config();
217 215
218 /* Configure channels and stuff */ 216 /* Configure channels and stuff */
219 switch (myStatus->audioChannels) { 217 switch (myStatus->audioChannels) {
220 218
221 case XS_CHN_AUTOPAN: 219 case XS_CHN_AUTOPAN:
222 myPlayer->currConfig.playback = sid2_stereo; 220 myEngine->currConfig.playback = sid2_stereo;
223 break; 221 break;
224 222
225 case XS_CHN_STEREO: 223 case XS_CHN_STEREO:
226 myPlayer->currConfig.playback = sid2_stereo; 224 myEngine->currConfig.playback = sid2_stereo;
227 break; 225 break;
228 226
229 case XS_CHN_MONO: 227 case XS_CHN_MONO:
230 default: 228 default:
231 myPlayer->currConfig.playback = sid2_mono; 229 myEngine->currConfig.playback = sid2_mono;
232 break; 230 break;
233 } 231 }
234 232
235 233
236 /* Memory mode settings */ 234 /* Memory mode settings */
237 switch (xs_cfg.memoryMode) { 235 switch (xs_cfg.memoryMode) {
238 case XS_MPU_BANK_SWITCHING: 236 case XS_MPU_BANK_SWITCHING:
239 myPlayer->currConfig.environment = sid2_envBS; 237 myEngine->currConfig.environment = sid2_envBS;
240 break; 238 break;
241 239
242 case XS_MPU_TRANSPARENT_ROM: 240 case XS_MPU_TRANSPARENT_ROM:
243 myPlayer->currConfig.environment = sid2_envTP; 241 myEngine->currConfig.environment = sid2_envTP;
244 break; 242 break;
245 243
246 case XS_MPU_PLAYSID_ENVIRONMENT: 244 case XS_MPU_PLAYSID_ENVIRONMENT:
247 myPlayer->currConfig.environment = sid2_envPS; 245 myEngine->currConfig.environment = sid2_envPS;
248 break; 246 break;
249 247
250 case XS_MPU_REAL: 248 case XS_MPU_REAL:
251 default: 249 default:
252 myPlayer->currConfig.environment = sid2_envR; 250 myEngine->currConfig.environment = sid2_envR;
253 break; 251 break;
254 } 252 }
255 253
256 254
257 /* Clockspeed settings */ 255 /* Clockspeed settings */
258 switch (xs_cfg.clockSpeed) { 256 switch (xs_cfg.clockSpeed) {
259 case XS_CLOCK_NTSC: 257 case XS_CLOCK_NTSC:
260 myPlayer->currConfig.clockSpeed = myPlayer->currConfig.clockDefault = SID2_CLOCK_NTSC; 258 myEngine->currConfig.clockSpeed = myEngine->currConfig.clockDefault = SID2_CLOCK_NTSC;
261 break; 259 break;
262 260
263 case XS_CLOCK_PAL: 261 case XS_CLOCK_PAL:
264 default: 262 default:
265 myPlayer->currConfig.clockSpeed = myPlayer->currConfig.clockDefault = SID2_CLOCK_PAL; 263 myEngine->currConfig.clockSpeed = myEngine->currConfig.clockDefault = SID2_CLOCK_PAL;
266 break; 264 break;
267 } 265 }
268 266
269 267
270 /* Configure rest of the emulation */ 268 /* Configure rest of the emulation */
271 myPlayer->currConfig.sidEmulation = myPlayer->currBuilder; 269 myEngine->currConfig.sidEmulation = myEngine->currBuilder;
272 myPlayer->currConfig.clockForced = xs_cfg.forceSpeed; 270 myEngine->currConfig.clockForced = xs_cfg.forceSpeed;
273 myPlayer->currConfig.optimisation = (xs_cfg.sid2OptLevel) ? 1 : 0; 271 myEngine->currConfig.optimisation = (xs_cfg.sid2OptLevel) ? 1 : 0;
274 myPlayer->currConfig.sidDefault = myPlayer->currConfig.sidModel = (xs_cfg.mos8580) ? SID2_MOS8580 : SID2_MOS6581; 272 myEngine->currConfig.sidDefault = myEngine->currConfig.sidModel = (xs_cfg.mos8580) ? SID2_MOS8580 : SID2_MOS6581;
275 myPlayer->currConfig.sidSamples = TRUE; // FIXME FIX ME, make configurable! 273 myEngine->currConfig.sidSamples = TRUE; // FIXME FIX ME, make configurable!
276 myPlayer->currConfig.precision = myStatus->audioBitsPerSample; 274 myEngine->currConfig.precision = myStatus->audioBitsPerSample;
277 myPlayer->currConfig.frequency = myStatus->audioFrequency; 275 myEngine->currConfig.frequency = myStatus->audioFrequency;
278 276
279 switch (myStatus->audioBitsPerSample) { 277 switch (myStatus->audioBitsPerSample) {
280 case XS_RES_8BIT: 278 case XS_RES_8BIT:
281 myStatus->audioFormat = FMT_U8; 279 myStatus->audioFormat = FMT_U8;
282 myPlayer->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED; 280 myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
283 break; 281 break;
284 282
285 case XS_RES_16BIT: 283 case XS_RES_16BIT:
286 switch (myStatus->audioFormat) { 284 switch (myStatus->audioFormat) {
287 case FMT_U16_LE: 285 case FMT_U16_LE:
288 myPlayer->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED; 286 myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
289 break; 287 break;
290 288
291 case FMT_U16_BE: 289 case FMT_U16_BE:
292 myPlayer->currConfig.sampleFormat = SID2_BIG_UNSIGNED; 290 myEngine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
293 break; 291 break;
294 292
295 case FMT_U16_NE: 293 case FMT_U16_NE:
296 myStatus->audioFormat = FMT_U16_NE; 294 myStatus->audioFormat = FMT_U16_NE;
297 #ifdef WORDS_BIGENDIAN 295 #ifdef WORDS_BIGENDIAN
298 myPlayer->currConfig.sampleFormat = SID2_BIG_UNSIGNED; 296 myEngine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
299 #else 297 #else
300 myPlayer->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED; 298 myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
301 #endif 299 #endif
302 break; 300 break;
303 301
304 case FMT_S16_LE: 302 case FMT_S16_LE:
305 myPlayer->currConfig.sampleFormat = SID2_LITTLE_SIGNED; 303 myEngine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
306 break; 304 break;
307 305
308 case FMT_S16_BE: 306 case FMT_S16_BE:
309 myPlayer->currConfig.sampleFormat = SID2_BIG_SIGNED; 307 myEngine->currConfig.sampleFormat = SID2_BIG_SIGNED;
310 break; 308 break;
311 309
312 default: 310 default:
313 myStatus->audioFormat = FMT_S16_NE; 311 myStatus->audioFormat = FMT_S16_NE;
314 #ifdef WORDS_BIGENDIAN 312 #ifdef WORDS_BIGENDIAN
315 myPlayer->currConfig.sampleFormat = SID2_BIG_SIGNED; 313 myEngine->currConfig.sampleFormat = SID2_BIG_SIGNED;
316 #else 314 #else
317 myPlayer->currConfig.sampleFormat = SID2_LITTLE_SIGNED; 315 myEngine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
318 #endif 316 #endif
319 break; 317 break;
320 318
321 } 319 }
322 break; 320 break;
323 } 321 }
324 322
325 323
326 /* Now set the emulator configuration */ 324 /* Now set the emulator configuration */
327 if (myPlayer->currEng->config(myPlayer->currConfig) < 0) 325 if (myEngine->currEng->config(myEngine->currConfig) < 0)
328 { 326 {
329 XSERR("Emulator engine configuration failed!\n"); 327 XSERR("Emulator engine configuration failed!\n");
330 return FALSE; 328 return FALSE;
331 } 329 }
332 330
346 344
347 345
348 /* 346 /*
349 * Return song information 347 * Return song information
350 */ 348 */
351 #define TFUNCTION1 xs_sidplay2_filetitle 349 #define TFUNCTION xs_sidplay2_getsidinfo
352 #define TFUNCTION2 xs_sidplay2_getsidinfo
353 #define TTUNEINFO SidTuneInfo 350 #define TTUNEINFO SidTuneInfo
354 #define TTUNE SidTune 351 #define TTUNE SidTune
355 #include "xs_sidplay.h" 352 #include "xs_sidplay.h"
356 353
357 } /* extern "C" */ 354 } /* extern "C" */