← Back to branch summary

~ubuntu-branches/ubuntu/lucid/fceux/lucid

« back to all changes in this revision

Viewing changes to fceu/src/ines.h

  • Committer: Bazaar Package Importer
  • Author(s): Fabrice Coutadeur
  • Date: 2009-12-14 08:05:17 UTC
  • Revision ID: james.westby@ubuntu.com-20091214080517-abi5tj8avthfan7c
Tags: upstream-2.1.2+repack
Import upstream version 2.1.2+repack

Show diffs side-by-side

added added

removed removed

Lines of Context:
fceu/src/ines.h
 
1
/* FCE Ultra - NES/Famicom Emulator
 
2
 *
 
3
 * Copyright notice for this file:
 
4
 *  Copyright (C) 1998 Bero
 
5
 *  Copyright (C) 2002 Xodnizel
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify
 
8
 * it under the terms of the GNU General Public License as published by
 
9
 * the Free Software Foundation; either version 2 of the License, or
 
10
 * (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
20
 */
 
21
 
 
22
#ifndef _INES_H_
 
23
#define _INES_H_
 
24
#include <stdlib.h>
 
25
#include <string.h>
 
26
#ifdef INESPRIV
 
27
 
 
28
void iNESStateRestore(int version);
 
29
extern uint32 iNESGameCRC32;
 
30
 
 
31
extern uint32 VROM_size;
 
32
extern uint32 ROM_size;
 
33
 
 
34
extern void (*MapStateRestore)(int version);
 
35
extern void (*MapClose)(void);
 
36
extern void (*MapperReset)(void);
 
37
 
 
38
/* This order is necessary */
 
39
#define WRAM    (GameMemBlock)
 
40
#define sizeofWRAM    8192
 
41
 
 
42
#define MapperExRAM   (GameMemBlock+sizeofWRAM)
 
43
#define sizeofMapperExRAM  32768
 
44
/* for the MMC5 code to work properly.  It might be fixed later... */
 
45
 
 
46
#define CHRRAM  (GameMemBlock+sizeofWRAM+sizeofMapperExRAM)
 
47
#define sizeofCHRRAM 8192
 
48
 
 
49
#define ExtraNTARAM   (GameMemBlock+sizeofWRAM+sizeofMapperExRAM+sizeofCHRRAM)
 
50
#define sizeofExtraNTARAM 2048
 
51
 
 
52
#define PRGBankList    (ExtraNTARAM+sizeofExtraNTARAM)
 
53
 
 
54
#define mapbyte1       (PRGBankList+4)
 
55
#define mapbyte2       (mapbyte1+8)
 
56
#define mapbyte3       (mapbyte2+8)
 
57
#define mapbyte4       (mapbyte3+8)
 
58
extern uint16 iNESCHRBankList[8];
 
59
extern int32 iNESIRQLatch,iNESIRQCount;
 
60
extern uint8 iNESMirroring;
 
61
extern uint8 iNESIRQa;
 
62
 
 
63
#define IRQa iNESIRQa
 
64
#define Mirroring iNESMirroring
 
65
#define IRQCount iNESIRQCount
 
66
#define IRQLatch iNESIRQLatch
 
67
#define CHRBankList iNESCHRBankList
 
68
#else
 
69
#endif
 
70
 
 
71
//mbg merge 6/29/06
 
72
extern uint8 *ROM;
 
73
extern uint8 *VROM;
 
74
extern uint32 VROM_size;
 
75
extern uint32 ROM_size;
 
76
extern int iNesSave(); //bbit Edited: line added
 
77
extern int iNesSaveAs(char* name);
 
78
extern char LoadedRomFName[2048]; //bbit Edited: line added
 
79
 
 
80
//mbg merge 7/19/06 changed to c++ decl format
 
81
struct iNES_HEADER {
 
82
    char ID[4]; /*NES^Z*/
 
83
    uint8 ROM_size;
 
84
    uint8 VROM_size;
 
85
    uint8 ROM_type;
 
86
    uint8 ROM_type2;
 
87
    uint8 reserve[8];
 
88
 
 
89
        void cleanup()
 
90
        {
 
91
                if(!memcmp((char *)(this)+0x7,"DiskDude",8))
 
92
                {
 
93
                        memset((char *)(this)+0x7,0,0x9);
 
94
                }
 
95
 
 
96
                if(!memcmp((char *)(this)+0x7,"demiforce",9))
 
97
                {
 
98
                        memset((char *)(this)+0x7,0,0x9);
 
99
                }
 
100
 
 
101
                if(!memcmp((char *)(this)+0xA,"Ni03",4))
 
102
                {
 
103
                        if(!memcmp((char *)(this)+0x7,"Dis",3))
 
104
                                memset((char *)(this)+0x7,0,0x9);
 
105
                        else
 
106
                                memset((char *)(this)+0xA,0,0x6);
 
107
                }
 
108
        }
 
109
};
 
110
extern struct iNES_HEADER head; //for mappers usage
 
111
 
 
112
void VRAM_BANK1(uint32 A, uint8 V);
 
113
void VRAM_BANK4(uint32 A,uint32 V);
 
114
 
 
115
void VROM_BANK1(uint32 A,uint32 V);
 
116
void VROM_BANK2(uint32 A,uint32 V);
 
117
void VROM_BANK4(uint32 A, uint32 V);
 
118
void VROM_BANK8(uint32 V);
 
119
void ROM_BANK8(uint32 A, uint32 V);
 
120
void ROM_BANK16(uint32 A, uint32 V);
 
121
void ROM_BANK32(uint32 V);
 
122
 
 
123
extern uint8 vmask;
 
124
extern uint32 vmask1;
 
125
extern uint32 vmask2;
 
126
extern uint32 vmask4;
 
127
extern uint32 pmask8;
 
128
extern uint8 pmask16;
 
129
extern uint8 pmask32;
 
130
 
 
131
void onemir(uint8 V);
 
132
void MIRROR_SET2(uint8 V);
 
133
void MIRROR_SET(uint8 V);
 
134
 
 
135
void Mapper0_init(void);
 
136
void Mapper1_init(void);
 
137
//void Mapper2_init(void);
 
138
//void Mapper3_init(void);
 
139
void Mapper6_init(void);
 
140
//void Mapper7_init(void);
 
141
void Mapper8_init(void);
 
142
void Mapper9_init(void);
 
143
void Mapper10_init(void);
 
144
//void Mapper11_init(void);
 
145
void Mapper12_init(void);
 
146
//void Mapper13_init(void);
 
147
void Mapper14_init(void);
 
148
//void Mapper15_init(void);
 
149
//void Mapper16_init(void);
 
150
void Mapper17_init(void);
 
151
void Mapper18_init(void);
 
152
void Mapper19_init(void);
 
153
void Mapper20_init(void);
 
154
void Mapper21_init(void);
 
155
void Mapper22_init(void);
 
156
//void Mapper23_init(void);
 
157
void Mapper24_init(void);
 
158
void Mapper25_init(void);
 
159
void Mapper26_init(void);
 
160
void Mapper27_init(void);
 
161
void Mapper28_init(void);
 
162
void Mapper29_init(void);
 
163
void Mapper30_init(void);
 
164
void Mapper31_init(void);
 
165
void Mapper32_init(void);
 
166
void Mapper33_init(void);
 
167
void Mapper34_init(void);
 
168
void Mapper35_init(void);
 
169
void Mapper36_init(void);
 
170
//void Mapper37_init(void);
 
171
//void Mapper38_init(void);
 
172
//void Mapper39_init(void);
 
173
void Mapper40_init(void);
 
174
void Mapper41_init(void);
 
175
void Mapper42_init(void);
 
176
//void Mapper43_init(void);
 
177
void Mapper44_init(void);
 
178
void Mapper45_init(void);
 
179
void Mapper46_init(void);
 
180
void Mapper47_init(void);
 
181
void Mapper48_init(void);
 
182
void Mapper49_init(void);
 
183
void Mapper50_init(void);
 
184
void Mapper51_init(void);
 
185
void Mapper53_init(void);
 
186
void Mapper54_init(void);
 
187
void Mapper55_init(void);
 
188
void Mapper56_init(void);
 
189
void Mapper59_init(void);
 
190
void Mapper60_init(void);
 
191
void Mapper61_init(void);
 
192
void Mapper62_init(void);
 
193
void Mapper63_init(void);
 
194
void Mapper64_init(void);
 
195
void Mapper65_init(void);
 
196
//void Mapper66_init(void);
 
197
void Mapper67_init(void);
 
198
//void Mapper68_init(void);
 
199
void Mapper69_init(void);
 
200
//void Mapper70_init(void);
 
201
void Mapper71_init(void);
 
202
void Mapper72_init(void);
 
203
void Mapper73_init(void);
 
204
void Mapper74_init(void);
 
205
void Mapper75_init(void);
 
206
void Mapper76_init(void);
 
207
void Mapper77_init(void);
 
208
//void Mapper78_init(void);
 
209
void Mapper79_init(void);
 
210
void Mapper80_init(void);
 
211
void Mapper81_init(void);
 
212
void Mapper82_init(void);
 
213
void Mapper83_init(void);
 
214
void Mapper84_init(void);
 
215
void Mapper85_init(void);
 
216
void Mapper86_init(void);
 
217
//void Mapper87_init(void);
 
218
void Mapper88_init(void);
 
219
void Mapper89_init(void);
 
220
void Mapper91_init(void);
 
221
void Mapper92_init(void);
 
222
//void Mapper93_init(void);
 
223
//void Mapper94_init(void);
 
224
void Mapper96_init(void);
 
225
void Mapper97_init(void);
 
226
void Mapper98_init(void);
 
227
void Mapper99_init(void);
 
228
void Mapper100_init(void);
 
229
//void Mapper101_init(void);
 
230
//void Mapper103_init(void);
 
231
void Mapper104_init(void);
 
232
//void Mapper106_init(void);
 
233
//void Mapper107_init(void);
 
234
//void Mapper108_init(void);
 
235
void Mapper109_init(void);
 
236
void Mapper110_init(void);
 
237
void Mapper111_init(void);
 
238
//void Mapper113_init(void);
 
239
void Mapper115_init(void);
 
240
void Mapper116_init(void);
 
241
//void Mapper117_init(void);
 
242
//void Mapper120_init(void);
 
243
//void Mapper121_init(void);
 
244
void Mapper122_init(void);
 
245
void Mapper123_init(void);
 
246
void Mapper124_init(void);
 
247
void Mapper126_init(void);
 
248
void Mapper127_init(void);
 
249
void Mapper128_init(void);
 
250
void Mapper129_init(void);
 
251
void Mapper130_init(void);
 
252
void Mapper131_init(void);
 
253
void Mapper132_init(void);
 
254
//void Mapper134_init(void);
 
255
void Mapper135_init(void);
 
256
void Mapper136_init(void);
 
257
void Mapper137_init(void);
 
258
void Mapper139_init(void);
 
259
//void Mapper140_init(void);
 
260
void Mapper141_init(void);
 
261
//void Mapper142_init(void);
 
262
void Mapper143_init(void);
 
263
//void Mapper144_init(void);
 
264
void Mapper150_init(void);
 
265
void Mapper151_init(void);
 
266
//void Mapper152_init(void);
 
267
//void Mapper153_init(void);
 
268
void Mapper154_init(void);
 
269
void Mapper156_init(void);
 
270
void Mapper157_init(void);
 
271
//void Mapper158_init(void);
 
272
void Mapper159_init(void);
 
273
void Mapper160_init(void);
 
274
void Mapper161_init(void);
 
275
void Mapper162_init(void);
 
276
void Mapper166_init(void);
 
277
void Mapper167_init(void);
 
278
void Mapper168_init(void);
 
279
//void Mapper169_init(void);
 
280
void Mapper170_init(void);
 
281
//void Mapper171_init(void);
 
282
//void Mapper172_init(void);
 
283
//void Mapper173_init(void);
 
284
void Mapper174_init(void);
 
285
void Mapper175_init(void);
 
286
void Mapper176_init(void);
 
287
//void Mapper177_init(void);
 
288
//void Mapper178_init(void);
 
289
//void Mapper179_init(void);
 
290
//void Mapper180_init(void);
 
291
//void Mapper181_init(void);
 
292
//void Mapper184_init(void);
 
293
//void Mapper185_init(void);
 
294
//void Mapper189_init(void);
 
295
//void Mapper192_init(void);
 
296
void Mapper193_init(void);
 
297
//void Mapper194_init(void);
 
298
//void Mapper195_init(void);
 
299
//void Mapper196_init(void);
 
300
//void Mapper197_init(void);
 
301
//void Mapper198_init(void);
 
302
void Mapper199_init(void);
 
303
//void Mapper200_init(void);
 
304
void Mapper201_init(void);
 
305
void Mapper202_init(void);
 
306
void Mapper203_init(void);
 
307
void Mapper204_init(void);
 
308
void Mapper207_init(void);
 
309
//void Mapper211_init(void);
 
310
void Mapper212_init(void);
 
311
void Mapper213_init(void);
 
312
void Mapper214_init(void);
 
313
//void Mapper218_init(void);
 
314
void Mapper219_init(void);
 
315
//void Mapper220_init(void);
 
316
void Mapper221_init(void);
 
317
//void Mapper222_init(void);
 
318
void Mapper223_init(void);
 
319
void Mapper224_init(void);
 
320
void Mapper225_init(void);
 
321
//void Mapper226_init(void);
 
322
void Mapper227_init(void);
 
323
void Mapper228_init(void);
 
324
void Mapper229_init(void);
 
325
void Mapper230_init(void);
 
326
void Mapper231_init(void);
 
327
void Mapper232_init(void);
 
328
void Mapper233_init(void);
 
329
void Mapper234_init(void);
 
330
//void Mapper235_init(void);
 
331
void Mapper236_init(void);
 
332
void Mapper237_init(void);
 
333
void Mapper238_init(void);
 
334
void Mapper239_init(void);
 
335
void Mapper240_init(void);
 
336
void Mapper241_init(void);
 
337
void Mapper242_init(void);
 
338
void Mapper244_init(void);
 
339
void Mapper245_init(void);
 
340
void Mapper246_init(void);
 
341
void Mapper247_init(void);
 
342
void Mapper249_init(void);
 
343
void Mapper251_init(void);
 
344
void Mapper252_init(void);
 
345
//void Mapper253_init(void);
 
346
void Mapper255_init(void);
 
347
 
 
348
void NSFVRC6_Init(void);
 
349
void NSFMMC5_Init(void);
 
350
void NSFAY_Init(void);
 
351
void NSFN106_Init(void);
 
352
void NSFVRC7_Init(void);
 
353
void Mapper19_ESI(void);
 
354
 
 
355
void Mapper1_Init(CartInfo *);
 
356
void Mapper4_Init(CartInfo *);
 
357
void Mapper5_Init(CartInfo *);
 
358
void Mapper11_Init(CartInfo *);
 
359
void Mapper12_Init(CartInfo *);
 
360
void Mapper15_Init(CartInfo *);
 
361
void Mapper16_Init(CartInfo *);
 
362
void Mapper19_Init(CartInfo *);
 
363
void Mapper23_Init(CartInfo *);
 
364
void Mapper36_Init(CartInfo *);
 
365
void Mapper37_Init(CartInfo *);
 
366
void Mapper38_Init(CartInfo *);
 
367
void Mapper43_Init(CartInfo *);
 
368
void Mapper44_Init(CartInfo *);
 
369
void Mapper45_Init(CartInfo *);
 
370
void Mapper47_Init(CartInfo *);
 
371
void Mapper49_Init(CartInfo *);
 
372
void Mapper52_Init(CartInfo *);
 
373
void Mapper57_Init(CartInfo *);
 
374
//void Mapper58_Init(CartInfo *);
 
375
void Mapper68_Init(CartInfo *);
 
376
void Mapper70_Init(CartInfo *);
 
377
void Mapper74_Init(CartInfo *);
 
378
void Mapper78_Init(CartInfo *);
 
379
void Mapper87_Init(CartInfo *);
 
380
void Mapper88_Init(CartInfo *);
 
381
void Mapper90_Init(CartInfo *);
 
382
void Mapper93_Init(CartInfo *);
 
383
void Mapper94_Init(CartInfo *);
 
384
void Mapper95_Init(CartInfo *);
 
385
void Mapper101_Init(CartInfo *);
 
386
void Mapper103_Init(CartInfo *);
 
387
void Mapper105_Init(CartInfo *);
 
388
void Mapper106_Init(CartInfo *);
 
389
void Mapper107_Init(CartInfo *);
 
390
void Mapper108_Init(CartInfo *);
 
391
void Mapper112_Init(CartInfo *);
 
392
void Mapper113_Init(CartInfo *);
 
393
void Mapper114_Init(CartInfo *);
 
394
void Mapper115_Init(CartInfo *);
 
395
void Mapper116_Init(CartInfo *);
 
396
void Mapper117_Init(CartInfo *);
 
397
void Mapper118_Init(CartInfo *);
 
398
void Mapper119_Init(CartInfo *);
 
399
void Mapper120_Init(CartInfo *);
 
400
void Mapper121_Init(CartInfo *);
 
401
void Mapper125_Init(CartInfo *);
 
402
void Mapper134_Init(CartInfo *);
 
403
void Mapper140_Init(CartInfo *);
 
404
void Mapper144_Init(CartInfo *);
 
405
void Mapper152_Init(CartInfo *);
 
406
void Mapper153_Init(CartInfo *);
 
407
void Mapper154_Init(CartInfo *);
 
408
void Mapper155_Init(CartInfo *);
 
409
void Mapper163_Init(CartInfo *);
 
410
void Mapper164_Init(CartInfo *);
 
411
void Mapper165_Init(CartInfo *);
 
412
//void Mapper169_Init(CartInfo *);
 
413
void Mapper171_Init(CartInfo *);
 
414
void Mapper172_Init(CartInfo *);
 
415
void Mapper173_Init(CartInfo *);
 
416
void Mapper175_Init(CartInfo *);
 
417
void Mapper177_Init(CartInfo *);
 
418
void Mapper178_Init(CartInfo *);
 
419
void Mapper180_Init(CartInfo *);
 
420
void Mapper181_Init(CartInfo *);
 
421
void Mapper182_Init(CartInfo *);
 
422
void Mapper183_Init(CartInfo *);
 
423
void Mapper184_Init(CartInfo *);
 
424
void Mapper185_Init(CartInfo *);
 
425
void Mapper186_Init(CartInfo *);
 
426
void Mapper187_Init(CartInfo *);
 
427
void Mapper188_Init(CartInfo *);
 
428
void Mapper189_Init(CartInfo *);
 
429
void Mapper191_Init(CartInfo *);
 
430
void Mapper192_Init(CartInfo *);
 
431
void Mapper194_Init(CartInfo *);
 
432
void Mapper195_Init(CartInfo *);
 
433
void Mapper196_Init(CartInfo *);
 
434
void Mapper197_Init(CartInfo *);
 
435
void Mapper198_Init(CartInfo *);
 
436
void Mapper199_Init(CartInfo *);
 
437
void Mapper200_Init(CartInfo *);
 
438
void Mapper205_Init(CartInfo *);
 
439
void Mapper208_Init(CartInfo *);
 
440
void Mapper209_Init(CartInfo *);
 
441
void Mapper210_Init(CartInfo *);
 
442
void Mapper211_Init(CartInfo *);
 
443
void Mapper215_Init(CartInfo *);
 
444
void Mapper216_Init(CartInfo *);
 
445
void Mapper217_Init(CartInfo *);
 
446
void Mapper220_Init(CartInfo *);
 
447
void Mapper222_Init(CartInfo *);
 
448
void Mapper226_Init(CartInfo *);
 
449
void Mapper235_Init(CartInfo *);
 
450
void Mapper236_Init(CartInfo *);
 
451
void Mapper237_Init(CartInfo *);
 
452
void Mapper240_Init(CartInfo *);
 
453
void Mapper245_Init(CartInfo *);
 
454
void Mapper249_Init(CartInfo *);
 
455
void Mapper250_Init(CartInfo *);
 
456
void Mapper253_Init(CartInfo *);
 
457
void Mapper254_Init(CartInfo *);
 
458
 
 
459
#endif