PageRenderTime 73ms CodeModel.GetById 35ms RepoModel.GetById 0ms app.codeStats 1ms

/src/sdl/SDL.cpp

https://bitbucket.org/kanzure/vba-clojure
C++ | 3688 lines | 3106 code | 401 blank | 181 comment | 752 complexity | 5972383e5966ce44ecfbbe5c3d51fc38 MD5 | raw file
Possible License(s): BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. // VisualBoyAdvance - Nintendo Gameboy/GameboyAdvance (TM) emulator.
    2. 

  2. // Copyright (C) 1999-2003 Forgotten
    3. 

  3. // Copyright (C) 2004 Forgotten and the VBA development team
    4. 

  4. 

  5. // This program is free software; you can redistribute it and/or modify
    6. 

  6. // it under the terms of the GNU General Public License as published by
    7. 

  7. // the Free Software Foundation; either version 2, or(at your option)
    8. 

  8. // any later version.
    9. 

  9. //
    10. 

  10. // This program is distributed in the hope that it will be useful,
    11. 

  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
    12. 

  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13. 

  13. // GNU General Public License for more details.
    14. 

  14. //
    15. 

  15. // You should have received a copy of the GNU General Public License
    16. 

  16. // along with this program; if not, write to the Free Software Foundation,
    17. 

  17. // Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
    18. 

  18. 

  19. #include <stdarg.h>
    20. 

  20. #include <stdlib.h>
    21. 

  21. #include <stdio.h>
    22. 

  22. #include <string.h>
    23. 

  23. #include <sys/types.h>
    24. 

  24. #include <sys/stat.h>
    25. 

  25. #include <config.h>
    26. 

  26. #include "AutoBuild.h"
    27. 

  27. 

  28. #include "Port.h"
    29. 

  29. #include "SDL.h"
    30. 

  30. #include "debugger.h"
    31. 

  31. #include "gba/GBA.h"
    32. 

  32. #include "gba/GBAGlobals.h"
    33. 

  33. #include "gba/agbprint.h"
    34. 

  34. #include "gba/Flash.h"
    35. 

  35. #include "gba/RTC.h"
    36. 

  36. #include "gba/GBASound.h"
    37. 

  37. #include "gb/GB.h"
    38. 

  38. #include "gb/gbGlobals.h"
    39. 

  39. #include "common/Text.h"
    40. 

  40. #include "common/unzip.h"
    41. 

  41. #include "common/Util.h"
    42. 

  42. #include "common/movie.h"
    43. 

  43. #include "common/System.h"
    44. 

  44. #include "common/inputGlobal.h"
    45. 

  45. #include "../common/vbalua.h"
    46. 

  46. #include "SoundSDL.h"
    47. 

  47. #include "Drive.h"
    48. 

  48. 

  49. #define GBC_CAPABLE ((gbRom[0x143] & 0x80) != 0)
    50. 

  50. #define SGB_CAPABLE (gbRom[0x146] == 0x03)
    51. 

  51. 

  52. #ifndef WIN32
    53. 

  53. # include <unistd.h>
    54. 

  54. # define GETCWD getcwd
    55. 

  55. #else // WIN32
    56. 

  56. # include <direct.h>
    57. 

  57. # define GETCWD _getcwd
    58. 

  58. #endif // WIN32
    59. 

  59. 

  60. #ifndef __GNUC__
    61. 

  61. # define HAVE_DECL_GETOPT 0
    62. 

  62. # define __STDC__ 1
    63. 

  63. # include "getopt.h"
    64. 

  64. #else // ! __GNUC__
    65. 

  65. # define HAVE_DECL_GETOPT 1
    66. 

  66. # include "getopt.h"
    67. 

  67. #endif // ! __GNUC__
    68. 

  68. 

  69. #ifdef MMX
    70. 

  70. extern "C" bool cpu_mmx;
    71. 

  71. #endif
    72. 

  72. extern bool8 soundEcho;
    73. 

  73. extern bool8 soundLowPass;
    74. 

  74. extern bool8 soundReverse;
    75. 

  75. extern int Init_2xSaI(u32);
    76. 

  76. extern void _2xSaI(u8*,u32,u8*,u8*,u32,int,int);
    77. 

  77. extern void _2xSaI32(u8*,u32,u8*,u8*,u32,int,int);  
    78. 

  78. extern void Super2xSaI(u8*,u32,u8*,u8*,u32,int,int);
    79. 

  79. extern void Super2xSaI32(u8*,u32,u8*,u8*,u32,int,int);
    80. 

  80. extern void SuperEagle(u8*,u32,u8*,u8*,u32,int,int);
    81. 

  81. extern void SuperEagle32(u8*,u32,u8*,u8*,u32,int,int);  
    82. 

  82. extern void Pixelate2x16(u8*,u32,u8*,u8*,u32,int,int);
    83. 

  83. extern void Pixelate2x32(u8*,u32,u8*,u8*,u32,int,int);
    84. 

  84. extern void MotionBlur(u8*,u32,u8*,u8*,u32,int,int);
    85. 

  85. extern void MotionBlur32(u8*,u32,u8*,u8*,u32,int,int);
    86. 

  86. extern void AdMame2x(u8*,u32,u8*,u8*,u32,int,int);
    87. 

  87. extern void AdMame2x32(u8*,u32,u8*,u8*,u32,int,int);
    88. 

  88. extern void Simple2x16(u8*,u32,u8*,u8*,u32,int,int);
    89. 

  89. extern void Simple2x32(u8*,u32,u8*,u8*,u32,int,int);
    90. 

  90. extern void Bilinear(u8*,u32,u8*,u8*,u32,int,int);
    91. 

  91. extern void Bilinear32(u8*,u32,u8*,u8*,u32,int,int);
    92. 

  92. extern void BilinearPlus(u8*,u32,u8*,u8*,u32,int,int);
    93. 

  93. extern void BilinearPlus32(u8*,u32,u8*,u8*,u32,int,int);
    94. 

  94. extern void Scanlines(u8*,u32,u8*,u8*,u32,int,int);
    95. 

  95. extern void Scanlines32(u8*,u32,u8*,u8*,u32,int,int);
    96. 

  96. extern void ScanlinesTV(u8*,u32,u8*,u8*,u32,int,int);
    97. 

  97. extern void ScanlinesTV32(u8*,u32,u8*,u8*,u32,int,int);
    98. 

  98. extern void hq2x(u8*,u32,u8*,u8*,u32,int,int);
    99. 

  99. extern void hq2x32(u8*,u32,u8*,u8*,u32,int,int);
    100. 

  100. extern void lq2x(u8*,u32,u8*,u8*,u32,int,int);
    101. 

  101. extern void lq2x32(u8*,u32,u8*,u8*,u32,int,int);
    102. 

  102. 

  103. extern void SmartIB(u8*,u32,int,int);
    104. 

  104. extern void SmartIB32(u8*,u32,int,int);
    105. 

  105. extern void MotionBlurIB(u8*,u32,int,int);
    106. 

  106. extern void MotionBlurIB32(u8*,u32,int,int);
    107. 

  107. 

  108. void Init_Overlay(SDL_Surface *surface, int overlaytype);
    109. 

  109. void Quit_Overlay(void);
    110. 

  110. void Draw_Overlay(SDL_Surface *surface, int size);
    111. 

  111. 

  112. extern void remoteInit();
    113. 

  113. extern void remoteCleanUp();
    114. 

  114. extern void remoteStubMain();
    115. 

  115. extern void remoteStubSignal(int,int);
    116. 

  116. extern void remoteOutput(char *, u32);
    117. 

  117. extern void remoteSetProtocol(int);
    118. 

  118. extern void remoteSetPort(int);
    119. 

  119. extern void debuggerOutput(char *, u32);
    120. 

  120. 

  121. extern void CPUUpdateRenderBuffers(bool);
    122. 

  122. 

  123. struct EmulatedSystem theEmulator = {
    124. 

  124.   NULL,
    125. 

  125.   NULL,
    126. 

  126.   NULL,
    127. 

  127.   NULL,
    128. 

  128.   NULL,
    129. 

  129.   NULL,
    130. 

  130.   NULL,
    131. 

  131.   NULL,
    132. 

  132.   NULL,
    133. 

  133.   NULL,
    134. 

  134.   NULL,
    135. 

  135.   NULL,
    136. 

  136.   false,
    137. 

  137.   0
    138. 

  138. };
    139. 

  139. 

  140. SDL_Surface *surface = NULL;
    141. 

  141. SDL_Overlay *overlay = NULL;
    142. 

  142. SDL_Rect overlay_rect;
    143. 

  143. 

  144. int systemSpeed = 0;
    145. 

  145. int systemRedShift = 0;
    146. 

  146. int systemBlueShift = 0;
    147. 

  147. int systemGreenShift = 0;
    148. 

  148. int systemColorDepth = 0;
    149. 

  149. int systemDebug = 0;
    150. 

  150. int systemVerbose = 0;
    151. 

  151. int systemFrameSkip = 0;
    152. 

  152. int systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
    153. 

  153. 

  154. int srcPitch = 0;
    155. 

  155. int srcWidth = 0;
    156. 

  156. int srcHeight = 0;
    157. 

  157. int destWidth = 0;
    158. 

  158. int destHeight = 0;
    159. 

  159. 

  160. int sensorX = 2047;
    161. 

  161. int sensorY = 2047;
    162. 

  162. bool sensorOn = false;
    163. 

  163. 

  164. int filter = 0;
    165. 

  165. u8 *delta = NULL;
    166. 

  166. 

  167. int sdlPrintUsage = 0;
    168. 

  168. int disableMMX = 0;
    169. 

  169. 

  170. int systemCartridgeType = 3;
    171. 

  171. int sizeOption = 0;
    172. 

  172. int captureFormat = 0;
    173. 

  173. int useMovie = 0;
    174. 

  174. 

  175. int pauseWhenInactive = 0;
    176. 

  176. int active = 1;
    177. 

  177. int emulating = 0;
    178. 

  178. int RGB_LOW_BITS_MASK=0x821;
    179. 

  179. u32 systemColorMap32[0x10000];
    180. 

  180. u16 systemColorMap16[0x10000];
    181. 

  181. u16 systemGbPalette[24];
    182. 

  182. void (*filterFunction)(u8*,u32,u8*,u8*,u32,int,int) = NULL;
    183. 

  183. void (*ifbFunction)(u8*,u32,int,int) = NULL;
    184. 

  184. int ifbType = 0;
    185. 

  185. char filename[2048];
    186. 

  186. char ipsname[2048];
    187. 

  187. char biosFileName[2048];
    188. 

  188. char movieFileName[2048];
    189. 

  189. char captureDir[2048];
    190. 

  190. char saveDir[2048];
    191. 

  191. char batteryDir[2048];
    192. 

  192. 

  193. static char *rewindMemory = NULL;
    194. 

  194. static int rewindPos = 0;
    195. 

  195. static int rewindTopPos = 0;
    196. 

  196. static int rewindCounter = 0;
    197. 

  197. static int rewindCount = 0;
    198. 

  198. static bool rewindSaveNeeded = false;
    199. 

  199. static int rewindTimer = 0;
    200. 

  200. 

  201. #define REWIND_SIZE 400000
    202. 

  202. 

  203. #define _stricmp strcasecmp
    204. 

  204. 

  205. /*bool sdlButtons[4][12] = {
    206. 

  206.   { false, false, false, false, false, false, 
    207. 

  207.     false, false, false, false, false, false },
    208. 

  208.   { false, false, false, false, false, false,
    209. 

  209.     false, false, false, false, false, false },
    210. 

  210.   { false, false, false, false, false, false,
    211. 

  211.     false, false, false, false, false, false },
    212. 

  212.   { false, false, false, false, false, false,
    213. 

  213.     false, false, false, false, false, false }
    214. 

  214. };*/
    215. 

  215. /*
    216. 

  216. 	I'm changing the way the SDL GUI handles the button
    217. 

  217. 	input to match the one in win32, this is needed in
    218. 

  218. 	order to be compatible with the format required by
    219. 

  219. 	common/movie.cpp
    220. 

  220. 	--Felipe
    221. 

  221. */
    222. 

  222. 

  223. u16 currentButtons[4] = {0, 0, 0, 0};
    224. 

  224. 

  225. bool sdlMotionButtons[4] = { false, false, false, false };
    226. 

  226. const int32 INITIAL_SENSOR_VALUE = 2047;
    227. 

  227. 

  228. int sdlNumDevices = 0;
    229. 

  229. SDL_Joystick **sdlDevices = NULL;
    230. 

  230. 

  231. bool wasPaused = false;
    232. 

  232. int autoFrameSkip = 0;
    233. 

  233. int frameskipadjust = 0;
    234. 

  234. int showRenderedFrames = 0;
    235. 

  235. int renderedFrames = 0;
    236. 

  236. 

  237. int throttle = 0;
    238. 

  238. u32 throttleLastTime = 0;
    239. 

  239. u32 autoFrameSkipLastTime = 0;
    240. 

  240. 

  241. int showSpeed = 1;
    242. 

  242. int showSpeedTransparent = 1;
    243. 

  243. bool disableStatusMessages = false;
    244. 

  244. bool paused = false;
    245. 

  245. bool untilCapture = false;
    246. 

  246. bool pauseNextFrame = false;
    247. 

  247. bool debugger = false;
    248. 

  248. bool debuggerStub = false;
    249. 

  249. int fullscreen = 0;
    250. 

  250. bool systemSoundOn = false;
    251. 

  251. bool yuv = false;
    252. 

  252. int yuvType = 0;
    253. 

  253. bool removeIntros = false;
    254. 

  254. int sdlFlashSize = 0;
    255. 

  255. int sdlAutoIPS = 1;
    256. 

  256. int sdlRtcEnable = 0;
    257. 

  257. int sdlAgbPrint = 0;
    258. 

  258. 

  259. int sdlDefaultJoypad = 0;
    260. 

  260. 

  261. extern void debuggerSignal(int,int);
    262. 

  262. 

  263. void (*dbgMain)() = debuggerMain;
    264. 

  264. void (*dbgSignal)(int,int) = debuggerSignal;
    265. 

  265. void (*dbgOutput)(char *, u32) = debuggerOutput;
    266. 

  266. 

  267. int  mouseCounter = 0;
    268. 

  268. int autoFire = 0;
    269. 

  269. bool autoFireToggle = false;
    270. 

  270. 

  271. bool screenMessage[8] = {false,false,false,false,false,false,false,false};
    272. 

  272. char screenMessageBuffer[8][21];
    273. 

  273. u32  screenMessageTime[8] = {0,0,0,0,0,0,0,0};
    274. 

  274. u32  screenMessageDuration[8] = {0,0,0,0,0,0,0,0};
    275. 

  275. 

  276. SDL_cond *cond = NULL;
    277. 

  277. SDL_mutex *mutex = NULL;
    278. 

  278. u8* sdlBuffer;
    279. 

  279. int sdlSoundLen = 0;
    280. 

  280. SoundSDL* soundDriver = NULL;
    281. 

  281. 

  282. char *arg0;
    283. 

  283. 

  284. #ifndef C_CORE
    285. 

  285. u8 sdlStretcher[16384];
    286. 

  286. int sdlStretcherPos;
    287. 

  287. #else
    288. 

  288. void (*sdlStretcher)(u8 *, u8*) = NULL;
    289. 

  289. #endif
    290. 

  290. 

  291. u16 joypad[4][12] = {
    292. 

  292.   { SDLK_LEFT,  SDLK_RIGHT,
    293. 

  293.     SDLK_UP,    SDLK_DOWN,
    294. 

  294.     SDLK_z,     SDLK_x,
    295. 

  295.     SDLK_RETURN,SDLK_BACKSPACE,
    296. 

  296.     SDLK_a,     SDLK_s,
    297. 

  297.     SDLK_SPACE, SDLK_F12
    298. 

  298.   },
    299. 

  299.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    300. 

  300.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    301. 

  301.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
    302. 

  302. };
    303. 

  303. 

  304. u16 defaultJoypad[12] = {
    305. 

  305.   SDLK_LEFT,  SDLK_RIGHT,
    306. 

  306.   SDLK_UP,    SDLK_DOWN,
    307. 

  307.   SDLK_z,     SDLK_x,
    308. 

  308.   SDLK_RETURN,SDLK_BACKSPACE,
    309. 

  309.   SDLK_a,     SDLK_s,
    310. 

  310.   SDLK_SPACE, SDLK_F12
    311. 

  311. };
    312. 

  312. 

  313. u16 motion[4] = {
    314. 

  314.   SDLK_KP4, SDLK_KP6, SDLK_KP8, SDLK_KP2
    315. 

  315. };
    316. 

  316. 

  317. u16 defaultMotion[4] = {
    318. 

  318.   SDLK_KP4, SDLK_KP6, SDLK_KP8, SDLK_KP2
    319. 

  319. };
    320. 

  320. 

  321. struct option sdlOptions[] = {
    322. 

  322.   { "agb-print", no_argument, &sdlAgbPrint, 1 },
    323. 

  323.   { "auto-frameskip", no_argument, &autoFrameSkip, 1 },  
    324. 

  324.   { "bios", required_argument, 0, 'b' },
    325. 

  325.   { "config", required_argument, 0, 'c' },
    326. 

  326.   { "debug", no_argument, 0, 'd' },
    327. 

  327.   { "filter", required_argument, 0, 'f' },
    328. 

  328.   { "filter-normal", no_argument, &filter, 0 },
    329. 

  329.   { "filter-tv-mode", no_argument, &filter, 1 },
    330. 

  330.   { "filter-2xsai", no_argument, &filter, 2 },
    331. 

  331.   { "filter-super-2xsai", no_argument, &filter, 3 },
    332. 

  332.   { "filter-super-eagle", no_argument, &filter, 4 },
    333. 

  333.   { "filter-pixelate", no_argument, &filter, 5 },
    334. 

  334.   { "filter-motion-blur", no_argument, &filter, 6 },
    335. 

  335.   { "filter-advmame", no_argument, &filter, 7 },
    336. 

  336.   { "filter-simple2x", no_argument, &filter, 8 },
    337. 

  337.   { "filter-bilinear", no_argument, &filter, 9 },
    338. 

  338.   { "filter-bilinear+", no_argument, &filter, 10 },
    339. 

  339.   { "filter-scanlines", no_argument, &filter, 11 },
    340. 

  340.   { "filter-hq2x", no_argument, &filter, 12 },
    341. 

  341.   { "filter-lq2x", no_argument, &filter, 13 },
    342. 

  342.   { "flash-size", required_argument, 0, 'S' },
    343. 

  343.   { "flash-64k", no_argument, &sdlFlashSize, 0 },
    344. 

  344.   { "flash-128k", no_argument, &sdlFlashSize, 1 },
    345. 

  345.   { "frameskip", required_argument, 0, 's' },
    346. 

  346.   { "fullscreen", no_argument, &fullscreen, 1 },
    347. 

  347.   { "gdb", required_argument, 0, 'G' },
    348. 

  348.   { "help", no_argument, &sdlPrintUsage, 1 },
    349. 

  349.   { "ifb-none", no_argument, &ifbType, 0 },
    350. 

  350.   { "ifb-motion-blur", no_argument, &ifbType, 1 },
    351. 

  351.   { "ifb-smart", no_argument, &ifbType, 2 },
    352. 

  352.   { "ips", required_argument, 0, 'i' },
    353. 

  353.   { "no-agb-print", no_argument, &sdlAgbPrint, 0 },
    354. 

  354.   { "no-auto-frameskip", no_argument, &autoFrameSkip, 0 },
    355. 

  355.   { "no-debug", no_argument, 0, 'N' },
    356. 

  356.   { "no-ips", no_argument, &sdlAutoIPS, 0 },
    357. 

  357.   { "no-mmx", no_argument, &disableMMX, 1 },
    358. 

  358.   { "no-pause-when-inactive", no_argument, &pauseWhenInactive, 0 },
    359. 

  359.   { "no-rtc", no_argument, &sdlRtcEnable, 0 },
    360. 

  360.   { "no-show-speed", no_argument, &showSpeed, 0 },
    361. 

  361.   { "no-throttle", no_argument, &throttle, 0 },
    362. 

  362.   { "pause-when-inactive", no_argument, &pauseWhenInactive, 1 },
    363. 

  363.   { "profile", optional_argument, 0, 'P' },
    364. 

  364.   { "rtc", no_argument, &sdlRtcEnable, 1 },
    365. 

  365.   { "save-type", required_argument, 0, 't' },
    366. 

  366.   { "save-auto", no_argument, &cpuSaveType, 0 },
    367. 

  367.   { "save-eeprom", no_argument, &cpuSaveType, 1 },
    368. 

  368.   { "save-sram", no_argument, &cpuSaveType, 2 },
    369. 

  369.   { "save-flash", no_argument, &cpuSaveType, 3 },
    370. 

  370.   { "save-sensor", no_argument, &cpuSaveType, 4 },
    371. 

  371.   { "save-none", no_argument, &cpuSaveType, 5 },
    372. 

  372.   { "show-speed-normal", no_argument, &showSpeed, 1 },
    373. 

  373.   { "show-speed-detailed", no_argument, &showSpeed, 2 },
    374. 

  374.   { "throttle", required_argument, 0, 'T' },
    375. 

  375.   { "verbose", required_argument, 0, 'v' },  
    376. 

  376.   { "video-1x", no_argument, &sizeOption, 0 },
    377. 

  377.   { "video-2x", no_argument, &sizeOption, 1 },
    378. 

  378.   { "video-3x", no_argument, &sizeOption, 2 },
    379. 

  379.   { "video-4x", no_argument, &sizeOption, 3 },
    380. 

  380.   { "yuv", required_argument, 0, 'Y' },
    381. 

  381.   { "recordmovie", required_argument, 0, 'r' },
    382. 

  382.   { "playmovie", required_argument, 0, 'p' },
    383. 

  383.   { "watchmovie", required_argument, 0, 'w' },
    384. 

  384.   { NULL, no_argument, NULL, 0 }
    385. 

  385. };
    386. 

  386. 

  387. #ifndef C_CORE
    388. 

  388. #define SDL_LONG(val) \
    389. 

  389.   *((u32 *)&sdlStretcher[sdlStretcherPos]) = val;\
    390. 

  390.   sdlStretcherPos+=4;
    391. 

  391. 

  392. #define SDL_AND_EAX(val) \
    393. 

  393.   sdlStretcher[sdlStretcherPos++] = 0x25;\
    394. 

  394.   SDL_LONG(val);
    395. 

  395. 

  396. #define SDL_AND_EBX(val) \
    397. 

  397.   sdlStretcher[sdlStretcherPos++] = 0x81;\
    398. 

  398.   sdlStretcher[sdlStretcherPos++] = 0xe3;\
    399. 

  399.   SDL_LONG(val);
    400. 

  400. 

  401. #define SDL_OR_EAX_EBX \
    402. 

  402.   sdlStretcher[sdlStretcherPos++] = 0x09;\
    403. 

  403.   sdlStretcher[sdlStretcherPos++] = 0xd8;
    404. 

  404. 

  405. #define SDL_LOADL_EBX \
    406. 

  406.   sdlStretcher[sdlStretcherPos++] = 0x8b;\
    407. 

  407.   sdlStretcher[sdlStretcherPos++] = 0x1f;
    408. 

  408. 

  409. #define SDL_LOADW \
    410. 

  410.   sdlStretcher[sdlStretcherPos++] = 0x66;\
    411. 

  411.   sdlStretcher[sdlStretcherPos++] = 0x8b;\
    412. 

  412.   sdlStretcher[sdlStretcherPos++] = 0x06;\
    413. 

  413.   sdlStretcher[sdlStretcherPos++] = 0x83;\
    414. 

  414.   sdlStretcher[sdlStretcherPos++] = 0xc6;\
    415. 

  415.   sdlStretcher[sdlStretcherPos++] = 0x02;  
    416. 

  416. 

  417. #define SDL_LOADL \
    418. 

  418.   sdlStretcher[sdlStretcherPos++] = 0x8b;\
    419. 

  419.   sdlStretcher[sdlStretcherPos++] = 0x06;\
    420. 

  420.   sdlStretcher[sdlStretcherPos++] = 0x83;\
    421. 

  421.   sdlStretcher[sdlStretcherPos++] = 0xc6;\
    422. 

  422.   sdlStretcher[sdlStretcherPos++] = 0x04;  
    423. 

  423. 

  424. #define SDL_LOADL2 \
    425. 

  425.   sdlStretcher[sdlStretcherPos++] = 0x8b;\
    426. 

  426.   sdlStretcher[sdlStretcherPos++] = 0x06;\
    427. 

  427.   sdlStretcher[sdlStretcherPos++] = 0x83;\
    428. 

  428.   sdlStretcher[sdlStretcherPos++] = 0xc6;\
    429. 

  429.   sdlStretcher[sdlStretcherPos++] = 0x03;  
    430. 

  430. 

  431. #define SDL_STOREW \
    432. 

  432.   sdlStretcher[sdlStretcherPos++] = 0x66;\
    433. 

  433.   sdlStretcher[sdlStretcherPos++] = 0x89;\
    434. 

  434.   sdlStretcher[sdlStretcherPos++] = 0x07;\
    435. 

  435.   sdlStretcher[sdlStretcherPos++] = 0x83;\
    436. 

  436.   sdlStretcher[sdlStretcherPos++] = 0xc7;\
    437. 

  437.   sdlStretcher[sdlStretcherPos++] = 0x02;  
    438. 

  438. 

  439. #define SDL_STOREL \
    440. 

  440.   sdlStretcher[sdlStretcherPos++] = 0x89;\
    441. 

  441.   sdlStretcher[sdlStretcherPos++] = 0x07;\
    442. 

  442.   sdlStretcher[sdlStretcherPos++] = 0x83;\
    443. 

  443.   sdlStretcher[sdlStretcherPos++] = 0xc7;\
    444. 

  444.   sdlStretcher[sdlStretcherPos++] = 0x04;  
    445. 

  445. 

  446. #define SDL_STOREL2 \
    447. 

  447.   sdlStretcher[sdlStretcherPos++] = 0x89;\
    448. 

  448.   sdlStretcher[sdlStretcherPos++] = 0x07;\
    449. 

  449.   sdlStretcher[sdlStretcherPos++] = 0x83;\
    450. 

  450.   sdlStretcher[sdlStretcherPos++] = 0xc7;\
    451. 

  451.   sdlStretcher[sdlStretcherPos++] = 0x03;  
    452. 

  452. 

  453. #define SDL_RET \
    454. 

  454.   sdlStretcher[sdlStretcherPos++] = 0xc3;
    455. 

  455. 

  456. #define SDL_PUSH_EAX \
    457. 

  457.   sdlStretcher[sdlStretcherPos++] = 0x50;
    458. 

  458. 

  459. #define SDL_PUSH_ECX \
    460. 

  460.   sdlStretcher[sdlStretcherPos++] = 0x51;
    461. 

  461. 

  462. #define SDL_PUSH_EBX \
    463. 

  463.   sdlStretcher[sdlStretcherPos++] = 0x53;
    464. 

  464. 

  465. #define SDL_PUSH_ESI \
    466. 

  466.   sdlStretcher[sdlStretcherPos++] = 0x56;
    467. 

  467. 

  468. #define SDL_PUSH_EDI \
    469. 

  469.   sdlStretcher[sdlStretcherPos++] = 0x57;
    470. 

  470. 

  471. #define SDL_POP_EAX \
    472. 

  472.   sdlStretcher[sdlStretcherPos++] = 0x58;
    473. 

  473. 

  474. #define SDL_POP_ECX \
    475. 

  475.   sdlStretcher[sdlStretcherPos++] = 0x59;
    476. 

  476. 

  477. #define SDL_POP_EBX \
    478. 

  478.   sdlStretcher[sdlStretcherPos++] = 0x5b;
    479. 

  479. 

  480. #define SDL_POP_ESI \
    481. 

  481.   sdlStretcher[sdlStretcherPos++] = 0x5e;
    482. 

  482. 

  483. #define SDL_POP_EDI \
    484. 

  484.   sdlStretcher[sdlStretcherPos++] = 0x5f;
    485. 

  485. 

  486. #define SDL_MOV_ECX(val) \
    487. 

  487.   sdlStretcher[sdlStretcherPos++] = 0xb9;\
    488. 

  488.   SDL_LONG(val);
    489. 

  489. 

  490. #define SDL_REP_MOVSB \
    491. 

  491.   sdlStretcher[sdlStretcherPos++] = 0xf3;\
    492. 

  492.   sdlStretcher[sdlStretcherPos++] = 0xa4;
    493. 

  493. 

  494. #define SDL_REP_MOVSW \
    495. 

  495.   sdlStretcher[sdlStretcherPos++] = 0xf3;\
    496. 

  496.   sdlStretcher[sdlStretcherPos++] = 0x66;\
    497. 

  497.   sdlStretcher[sdlStretcherPos++] = 0xa5;
    498. 

  498. 

  499. #define SDL_REP_MOVSL \
    500. 

  500.   sdlStretcher[sdlStretcherPos++] = 0xf3;\
    501. 

  501.   sdlStretcher[sdlStretcherPos++] = 0xa5;
    502. 

  502. 

  503. void sdlMakeStretcher(int width)
    504. 

  504. {
    505. 

  505.   sdlStretcherPos = 0;
    506. 

  506.   switch(systemColorDepth) {
    507. 

  507.   case 16:
    508. 

  508.     if(sizeOption) {
    509. 

  509.       SDL_PUSH_EAX;
    510. 

  510.       SDL_PUSH_ESI;
    511. 

  511.       SDL_PUSH_EDI;
    512. 

  512.       for(int i = 0; i < width; i++) {
    513. 

  513.         SDL_LOADW;
    514. 

  514.         SDL_STOREW;
    515. 

  515.         SDL_STOREW;
    516. 

  516.         if(sizeOption > 1) {
    517. 

  517.           SDL_STOREW;
    518. 

  518.         }
    519. 

  519.         if(sizeOption > 2) {
    520. 

  520.           SDL_STOREW;
    521. 

  521.         }
    522. 

  522.       }
    523. 

  523.       SDL_POP_EDI;
    524. 

  524.       SDL_POP_ESI;
    525. 

  525.       SDL_POP_EAX;
    526. 

  526.       SDL_RET;
    527. 

  527.     } else {
    528. 

  528.       SDL_PUSH_ESI;
    529. 

  529.       SDL_PUSH_EDI;
    530. 

  530.       SDL_PUSH_ECX;
    531. 

  531.       SDL_MOV_ECX(width);
    532. 

  532.       SDL_REP_MOVSW;
    533. 

  533.       SDL_POP_ECX;
    534. 

  534.       SDL_POP_EDI;
    535. 

  535.       SDL_POP_ESI;
    536. 

  536.       SDL_RET;
    537. 

  537.     }
    538. 

  538.     break;
    539. 

  539.   case 24:
    540. 

  540.     if(sizeOption) {
    541. 

  541.       SDL_PUSH_EAX;
    542. 

  542.       SDL_PUSH_ESI;
    543. 

  543.       SDL_PUSH_EDI;
    544. 

  544.       int w = width - 1;
    545. 

  545.       for(int i = 0; i < w; i++) {
    546. 

  546.         SDL_LOADL2;
    547. 

  547.         SDL_STOREL2;
    548. 

  548.         SDL_STOREL2;
    549. 

  549.         if(sizeOption > 1) {
    550. 

  550.           SDL_STOREL2;
    551. 

  551.         }
    552. 

  552.         if(sizeOption > 2) {
    553. 

  553.           SDL_STOREL2;
    554. 

  554.         }
    555. 

  555.       }
    556. 

  556.       // need to write the last one
    557. 

  557.       SDL_LOADL2;
    558. 

  558.       SDL_STOREL2;
    559. 

  559.       if(sizeOption > 1) {
    560. 

  560.         SDL_STOREL2;
    561. 

  561.       }
    562. 

  562.       if(sizeOption > 2) {
    563. 

  563.         SDL_STOREL2;
    564. 

  564.       }
    565. 

  565.       SDL_AND_EAX(0x00ffffff);
    566. 

  566.       SDL_PUSH_EBX;
    567. 

  567.       SDL_LOADL_EBX;
    568. 

  568.       SDL_AND_EBX(0xff000000);
    569. 

  569.       SDL_OR_EAX_EBX;
    570. 

  570.       SDL_POP_EBX;
    571. 

  571.       SDL_STOREL2;
    572. 

  572.       SDL_POP_EDI;
    573. 

  573.       SDL_POP_ESI;
    574. 

  574.       SDL_POP_EAX;
    575. 

  575.       SDL_RET;
    576. 

  576.     } else {
    577. 

  577.       SDL_PUSH_ESI;
    578. 

  578.       SDL_PUSH_EDI;
    579. 

  579.       SDL_PUSH_ECX;
    580. 

  580.       SDL_MOV_ECX(3*width);
    581. 

  581.       SDL_REP_MOVSB;
    582. 

  582.       SDL_POP_ECX;
    583. 

  583.       SDL_POP_EDI;
    584. 

  584.       SDL_POP_ESI;
    585. 

  585.       SDL_RET;
    586. 

  586.     }
    587. 

  587.     break;
    588. 

  588.   case 32:
    589. 

  589.     if(sizeOption) {
    590. 

  590.       SDL_PUSH_EAX;
    591. 

  591.       SDL_PUSH_ESI;
    592. 

  592.       SDL_PUSH_EDI;
    593. 

  593.       for(int i = 0; i < width; i++) {
    594. 

  594.         SDL_LOADL;
    595. 

  595.         SDL_STOREL;
    596. 

  596.         SDL_STOREL;
    597. 

  597.         if(sizeOption > 1) {
    598. 

  598.           SDL_STOREL;
    599. 

  599.         }
    600. 

  600.         if(sizeOption > 2) {
    601. 

  601.           SDL_STOREL;
    602. 

  602.         }
    603. 

  603.       }
    604. 

  604.       SDL_POP_EDI;
    605. 

  605.       SDL_POP_ESI;
    606. 

  606.       SDL_POP_EAX;
    607. 

  607.       SDL_RET;
    608. 

  608.     } else {
    609. 

  609.       SDL_PUSH_ESI;
    610. 

  610.       SDL_PUSH_EDI;
    611. 

  611.       SDL_PUSH_ECX;
    612. 

  612.       SDL_MOV_ECX(width);
    613. 

  613.       SDL_REP_MOVSL;
    614. 

  614.       SDL_POP_ECX;
    615. 

  615.       SDL_POP_EDI;
    616. 

  616.       SDL_POP_ESI;
    617. 

  617.       SDL_RET;
    618. 

  618.     }
    619. 

  619.     break;
    620. 

  620.   }
    621. 

  621. }
    622. 

  622. 

  623. #ifdef _MSC_VER
    624. 

  624. #define SDL_CALL_STRETCHER \
    625. 

  625.   {\
    626. 

  626.     __asm mov eax, stretcher\
    627. 

  627.     __asm mov edi, dest\
    628. 

  628.     __asm mov esi, src\
    629. 

  629.     __asm call eax\
    630. 

  630.   }
    631. 

  631. #else
    632. 

  632. #define SDL_CALL_STRETCHER \
    633. 

  633.         asm volatile("call *%%eax"::"a" (stretcher),"S" (src),"D" (dest))
    634. 

  634. #endif
    635. 

  635. #else
    636. 

  636. #define SDL_CALL_STRETCHER \
    637. 

  637.        sdlStretcher(src, dest)
    638. 

  638. 

  639. void sdlStretch16x1(u8 *src, u8 *dest)
    640. 

  640. {
    641. 

  641.   u16 *s = (u16 *)src;
    642. 

  642.   u16 *d = (u16 *)dest;
    643. 

  643.   for(int i = 0; i < srcWidth; i++)
    644. 

  644.     *d++ = *s++;
    645. 

  645. }
    646. 

  646. 

  647. void sdlStretch16x2(u8 *src, u8 *dest)
    648. 

  648. {
    649. 

  649.   u16 *s = (u16 *)src;
    650. 

  650.   u16 *d = (u16 *)dest;
    651. 

  651.   for(int i = 0; i < srcWidth; i++) {
    652. 

  652.     *d++ = *s;
    653. 

  653.     *d++ = *s++;
    654. 

  654.   }
    655. 

  655. }
    656. 

  656. 

  657. void sdlStretch16x3(u8 *src, u8 *dest)
    658. 

  658. {
    659. 

  659.   u16 *s = (u16 *)src;
    660. 

  660.   u16 *d = (u16 *)dest;
    661. 

  661.   for(int i = 0; i < srcWidth; i++) {
    662. 

  662.     *d++ = *s;
    663. 

  663.     *d++ = *s;
    664. 

  664.     *d++ = *s++;
    665. 

  665.   }
    666. 

  666. }
    667. 

  667. 

  668. void sdlStretch16x4(u8 *src, u8 *dest)
    669. 

  669. {
    670. 

  670.   u16 *s = (u16 *)src;
    671. 

  671.   u16 *d = (u16 *)dest;
    672. 

  672.   for(int i = 0; i < srcWidth; i++) {
    673. 

  673.     *d++ = *s;
    674. 

  674.     *d++ = *s;
    675. 

  675.     *d++ = *s;
    676. 

  676.     *d++ = *s++;
    677. 

  677.   }
    678. 

  678. }
    679. 

  679. 

  680. void (*sdlStretcher16[4])(u8 *, u8 *) = {
    681. 

  681.   sdlStretch16x1,
    682. 

  682.   sdlStretch16x2,
    683. 

  683.   sdlStretch16x3,
    684. 

  684.   sdlStretch16x4
    685. 

  685. };
    686. 

  686. 

  687. void sdlStretch32x1(u8 *src, u8 *dest)
    688. 

  688. {
    689. 

  689.   u32 *s = (u32 *)src;
    690. 

  690.   u32 *d = (u32 *)dest;
    691. 

  691.   for(int i = 0; i < srcWidth; i++)
    692. 

  692.     *d++ = *s++;
    693. 

  693. }
    694. 

  694. 

  695. void sdlStretch32x2(u8 *src, u8 *dest)
    696. 

  696. {
    697. 

  697.   u32 *s = (u32 *)src;
    698. 

  698.   u32 *d = (u32 *)dest;
    699. 

  699.   for(int i = 0; i < srcWidth; i++) {
    700. 

  700.     *d++ = *s;
    701. 

  701.     *d++ = *s++;
    702. 

  702.   }
    703. 

  703. }
    704. 

  704. 

  705. void sdlStretch32x3(u8 *src, u8 *dest)
    706. 

  706. {
    707. 

  707.   u32 *s = (u32 *)src;
    708. 

  708.   u32 *d = (u32 *)dest;
    709. 

  709.   for(int i = 0; i < srcWidth; i++) {
    710. 

  710.     *d++ = *s;
    711. 

  711.     *d++ = *s;
    712. 

  712.     *d++ = *s++;
    713. 

  713.   }
    714. 

  714. }
    715. 

  715. 

  716. void sdlStretch32x4(u8 *src, u8 *dest)
    717. 

  717. {
    718. 

  718.   u32 *s = (u32 *)src;
    719. 

  719.   u32 *d = (u32 *)dest;
    720. 

  720.   for(int i = 0; i < srcWidth; i++) {
    721. 

  721.     *d++ = *s;
    722. 

  722.     *d++ = *s;
    723. 

  723.     *d++ = *s;
    724. 

  724.     *d++ = *s++;
    725. 

  725.   }
    726. 

  726. }
    727. 

  727. 

  728. void (*sdlStretcher32[4])(u8 *, u8 *) = {
    729. 

  729.   sdlStretch32x1,
    730. 

  730.   sdlStretch32x2,
    731. 

  731.   sdlStretch32x3,
    732. 

  732.   sdlStretch32x4
    733. 

  733. };
    734. 

  734. 

  735. void sdlStretch24x1(u8 *src, u8 *dest)
    736. 

  736. {
    737. 

  737.   u8 *s = src;
    738. 

  738.   u8 *d = dest;
    739. 

  739.   for(int i = 0; i < srcWidth; i++) {
    740. 

  740.     *d++ = *s++;
    741. 

  741.     *d++ = *s++;
    742. 

  742.     *d++ = *s++;
    743. 

  743.   }
    744. 

  744. }
    745. 

  745. 

  746. void sdlStretch24x2(u8 *src, u8 *dest)
    747. 

  747. {
    748. 

  748.   u8 *s = (u8 *)src;
    749. 

  749.   u8 *d = (u8 *)dest;
    750. 

  750.   for(int i = 0; i < srcWidth; i++) {
    751. 

  751.     *d++ = *s;
    752. 

  752.     *d++ = *(s+1);
    753. 

  753.     *d++ = *(s+2);
    754. 

  754.     s += 3;
    755. 

  755.     *d++ = *s;
    756. 

  756.     *d++ = *(s+1);
    757. 

  757.     *d++ = *(s+2);
    758. 

  758.     s += 3;
    759. 

  759.   }
    760. 

  760. }
    761. 

  761. 

  762. void sdlStretch24x3(u8 *src, u8 *dest)
    763. 

  763. {
    764. 

  764.   u8 *s = (u8 *)src;
    765. 

  765.   u8 *d = (u8 *)dest;
    766. 

  766.   for(int i = 0; i < srcWidth; i++) {
    767. 

  767.     *d++ = *s;
    768. 

  768.     *d++ = *(s+1);
    769. 

  769.     *d++ = *(s+2);
    770. 

  770.     s += 3;
    771. 

  771.     *d++ = *s;
    772. 

  772.     *d++ = *(s+1);
    773. 

  773.     *d++ = *(s+2);
    774. 

  774.     s += 3;
    775. 

  775.     *d++ = *s;
    776. 

  776.     *d++ = *(s+1);
    777. 

  777.     *d++ = *(s+2);
    778. 

  778.     s += 3;
    779. 

  779.   }
    780. 

  780. }
    781. 

  781. 

  782. void sdlStretch24x4(u8 *src, u8 *dest)
    783. 

  783. {
    784. 

  784.   u8 *s = (u8 *)src;
    785. 

  785.   u8 *d = (u8 *)dest;
    786. 

  786.   for(int i = 0; i < srcWidth; i++) {
    787. 

  787.     *d++ = *s;
    788. 

  788.     *d++ = *(s+1);
    789. 

  789.     *d++ = *(s+2);
    790. 

  790.     s += 3;
    791. 

  791.     *d++ = *s;
    792. 

  792.     *d++ = *(s+1);
    793. 

  793.     *d++ = *(s+2);
    794. 

  794.     s += 3;
    795. 

  795.     *d++ = *s;
    796. 

  796.     *d++ = *(s+1);
    797. 

  797.     *d++ = *(s+2);
    798. 

  798.     s += 3;
    799. 

  799.     *d++ = *s;
    800. 

  800.     *d++ = *(s+1);
    801. 

  801.     *d++ = *(s+2);
    802. 

  802.     s += 3;
    803. 

  803.   }
    804. 

  804. }
    805. 

  805. 

  806. void (*sdlStretcher24[4])(u8 *, u8 *) = {
    807. 

  807.   sdlStretch24x1,
    808. 

  808.   sdlStretch24x2,
    809. 

  809.   sdlStretch24x3,
    810. 

  810.   sdlStretch24x4
    811. 

  811. };
    812. 

  812. 

  813. #endif
    814. 

  814. 

  815. u32 sdlFromHex(char *s)
    816. 

  816. {
    817. 

  817.   u32 value;
    818. 

  818.   sscanf(s, "%x", &value);
    819. 

  819.   return value;
    820. 

  820. }
    821. 

  821. 

  822. #ifdef __MSC__
    823. 

  823. #define stat _stat
    824. 

  824. #define S_IFDIR _S_IFDIR
    825. 

  825. #endif
    826. 

  826. 

  827. void sdlCheckDirectory(char *dir)
    828. 

  828. {
    829. 

  829.   struct stat buf;
    830. 

  830. 

  831.   int len = strlen(dir);
    832. 

  832. 

  833.   char *p = dir + len - 1;
    834. 

  834. 

  835.   if(*p == '/' ||
    836. 

  836.      *p == '\\')
    837. 

  837.     *p = 0;
    838. 

  838.   
    839. 

  839.   if(stat(dir, &buf) == 0) {
    840. 

  840.     if(!(buf.st_mode & S_IFDIR)) {
    841. 

  841.       fprintf(stderr, "Error: %s is not a directory\n", dir);
    842. 

  842.       dir[0] = 0;
    843. 

  843.     }
    844. 

  844.   } else {
    845. 

  845.     fprintf(stderr, "Error: %s does not exist\n", dir);
    846. 

  846.     dir[0] = 0;
    847. 

  847.   }
    848. 

  848. }
    849. 

  849. 

  850. char *sdlGetFilename(char *name)
    851. 

  851. {
    852. 

  852.   static char filebuffer[2048];
    853. 

  853. 

  854.   int len = strlen(name);
    855. 

  855.   
    856. 

  856.   char *p = name + len - 1;
    857. 

  857.   
    858. 

  858.   while(true) {
    859. 

  859.     if(*p == '/' ||
    860. 

  860.        *p == '\\') {
    861. 

  861.       p++;
    862. 

  862.       break;
    863. 

  863.     }
    864. 

  864.     len--;
    865. 

  865.     p--;
    866. 

  866.     if(len == 0)
    867. 

  867.       break;
    868. 

  868.   }
    869. 

  869.   
    870. 

  870.   if(len == 0)
    871. 

  871.     strcpy(filebuffer, name);
    872. 

  872.   else
    873. 

  873.     strcpy(filebuffer, p);
    874. 

  874.   return filebuffer;
    875. 

  875. }
    876. 

  876. 

  877. FILE *sdlFindFile(const char *name)
    878. 

  878. {
    879. 

  879.   char buffer[4096];
    880. 

  880.   char path[2048];
    881. 

  881. 

  882. #ifdef WIN32
    883. 

  883. #define PATH_SEP ";"
    884. 

  884. #define FILE_SEP '\\'
    885. 

  885. #define EXE_NAME "VisualBoyAdvance-SDL.exe"
    886. 

  886. #else // ! WIN32
    887. 

  887. #define PATH_SEP ":"
    888. 

  888. #define FILE_SEP '/'
    889. 

  889. #define EXE_NAME "VisualBoyAdvance"
    890. 

  890. #endif // ! WIN32
    891. 

  891. 

  892.   fprintf(stderr, "Searching for file %s\n", name);
    893. 

  893.   
    894. 

  894.   if(GETCWD(buffer, 2048)) {
    895. 

  895.     fprintf(stderr, "Searching current directory: %s\n", buffer);
    896. 

  896.   }
    897. 

  897.   
    898. 

  898.   FILE *f = fopen(name, "r");
    899. 

  899.   if(f != NULL) {
    900. 

  900.     return f;
    901. 

  901.   }
    902. 

  902. 

  903.   char *home = getenv("HOME");
    904. 

  904. 

  905.   if(home != NULL) {
    906. 

  906.     fprintf(stderr, "Searching home directory: %s\n", home);
    907. 

  907.     sprintf(path, "%s%c%s", home, FILE_SEP, name);
    908. 

  908.     f = fopen(path, "r");
    909. 

  909.     if(f != NULL)
    910. 

  910.       return f;
    911. 

  911.   }
    912. 

  912. 

  913. #ifdef WIN32
    914. 

  914.   home = getenv("USERPROFILE");
    915. 

  915.   if(home != NULL) {
    916. 

  916.     fprintf(stderr, "Searching user profile directory: %s\n", home);
    917. 

  917.     sprintf(path, "%s%c%s", home, FILE_SEP, name);
    918. 

  918.     f = fopen(path, "r");
    919. 

  919.     if(f != NULL)
    920. 

  920.       return f;
    921. 

  921.   }
    922. 

  922. #else // ! WIN32
    923. 

  923.     fprintf(stderr, "Searching system config directory: %s\n", SYSCONFDIR);
    924. 

  924.     sprintf(path, "%s%c%s", SYSCONFDIR, FILE_SEP, name);
    925. 

  925.     f = fopen(path, "r");
    926. 

  926.     if(f != NULL)
    927. 

  927.       return f;
    928. 

  928. #endif // ! WIN32
    929. 

  929. 

  930.   if(!strchr(arg0, '/') &&
    931. 

  931.      !strchr(arg0, '\\')) {
    932. 

  932.     char *path = getenv("PATH");
    933. 

  933. 

  934.     if(path != NULL) {
    935. 

  935.       fprintf(stderr, "Searching PATH\n");
    936. 

  936.       strncpy(buffer, path, 4096);
    937. 

  937.       buffer[4095] = 0;
    938. 

  938.       char *tok = strtok(buffer, PATH_SEP);
    939. 

  939.       
    940. 

  940.       while(tok) {
    941. 

  941.         sprintf(path, "%s%c%s", tok, FILE_SEP, EXE_NAME);
    942. 

  942.         f = fopen(path, "r");
    943. 

  943.         if(f != NULL) {
    944. 

  944.           char path2[2048];
    945. 

  945.           fclose(f);
    946. 

  946.           sprintf(path2, "%s%c%s", tok, FILE_SEP, name);
    947. 

  947.           f = fopen(path2, "r");
    948. 

  948.           if(f != NULL) {
    949. 

  949.             fprintf(stderr, "Found at %s\n", path2);
    950. 

  950.             return f;
    951. 

  951.           }
    952. 

  952.         }
    953. 

  953.         tok = strtok(NULL, PATH_SEP);
    954. 

  954.       }
    955. 

  955.     }
    956. 

  956.   } else {
    957. 

  957.     // executable is relative to some directory
    958. 

  958.     fprintf(stderr, "Searching executable directory\n");
    959. 

  959.     strcpy(buffer, arg0);
    960. 

  960.     char *p = strrchr(buffer, FILE_SEP);
    961. 

  961.     if(p) {
    962. 

  962.       *p = 0;
    963. 

  963.       sprintf(path, "%s%c%s", buffer, FILE_SEP, name);
    964. 

  964.       f = fopen(path, "r");
    965. 

  965.       if(f != NULL)
    966. 

  966.         return f;
    967. 

  967.     }
    968. 

  968.   }
    969. 

  969.   return NULL;
    970. 

  970. }
    971. 

  971. 

  972. void sdlReadPreferences(FILE *f)
    973. 

  973. {
    974. 

  974.   char buffer[2048];
    975. 

  975.   
    976. 

  976.   while(1) {
    977. 

  977.     char *s = fgets(buffer, 2048, f);
    978. 

  978. 

  979.     if(s == NULL)
    980. 

  980.       break;
    981. 

  981. 

  982.     char *p  = strchr(s, '#');
    983. 

  983.     
    984. 

  984.     if(p)
    985. 

  985.       *p = 0;
    986. 

  986.     
    987. 

  987.     char *token = strtok(s, " \t\n\r=");
    988. 

  988. 

  989.     if(!token)
    990. 

  990.       continue;
    991. 

  991. 

  992.     if(strlen(token) == 0)
    993. 

  993.       continue;
    994. 

  994. 

  995.     char *key = token;
    996. 

  996.     char *value = strtok(NULL, "\t\n\r");
    997. 

  997. 

  998.     if(value == NULL) {
    999. 

  999.       fprintf(stderr, "Empty value for key %s\n", key);
    1000. 

  1000.       continue;
    1001. 

  1001.     }
    1002. 

  1002. 

  1003.     if(!strcmp(key,"Joy0_Left")) {
    1004. 

  1004.       joypad[0][KEY_LEFT] = sdlFromHex(value);
    1005. 

  1005.     } else if(!strcmp(key, "Joy0_Right")) {
    1006. 

  1006.       joypad[0][KEY_RIGHT] = sdlFromHex(value);
    1007. 

  1007.     } else if(!strcmp(key, "Joy0_Up")) {
    1008. 

  1008.       joypad[0][KEY_UP] = sdlFromHex(value);
    1009. 

  1009.     } else if(!strcmp(key, "Joy0_Down")) {
    1010. 

  1010.       joypad[0][KEY_DOWN] = sdlFromHex(value);
    1011. 

  1011.     } else if(!strcmp(key, "Joy0_A")) {
    1012. 

  1012.       joypad[0][KEY_BUTTON_A] = sdlFromHex(value);
    1013. 

  1013.     } else if(!strcmp(key, "Joy0_B")) {
    1014. 

  1014.       joypad[0][KEY_BUTTON_B] = sdlFromHex(value);
    1015. 

  1015.     } else if(!strcmp(key, "Joy0_L")) {
    1016. 

  1016.       joypad[0][KEY_BUTTON_L] = sdlFromHex(value);
    1017. 

  1017.     } else if(!strcmp(key, "Joy0_R")) {
    1018. 

  1018.       joypad[0][KEY_BUTTON_R] = sdlFromHex(value);
    1019. 

  1019.     } else if(!strcmp(key, "Joy0_Start")) {
    1020. 

  1020.       joypad[0][KEY_BUTTON_START] = sdlFromHex(value);
    1021. 

  1021.     } else if(!strcmp(key, "Joy0_Select")) {
    1022. 

  1022.       joypad[0][KEY_BUTTON_SELECT] = sdlFromHex(value);
    1023. 

  1023.     } else if(!strcmp(key, "Joy0_Speed")) {
    1024. 

  1024.       joypad[0][KEY_BUTTON_SPEED] = sdlFromHex(value);
    1025. 

  1025.     } else if(!strcmp(key, "Joy0_Capture")) {
    1026. 

  1026.       joypad[0][KEY_BUTTON_CAPTURE] = sdlFromHex(value);
    1027. 

  1027.     } else if(!strcmp(key,"Joy1_Left")) {
    1028. 

  1028.       joypad[1][KEY_LEFT] = sdlFromHex(value);
    1029. 

  1029.     } else if(!strcmp(key, "Joy1_Right")) {
    1030. 

  1030.       joypad[1][KEY_RIGHT] = sdlFromHex(value);
    1031. 

  1031.     } else if(!strcmp(key, "Joy1_Up")) {
    1032. 

  1032.       joypad[1][KEY_UP] = sdlFromHex(value);
    1033. 

  1033.     } else if(!strcmp(key, "Joy1_Down")) {
    1034. 

  1034.       joypad[1][KEY_DOWN] = sdlFromHex(value);
    1035. 

  1035.     } else if(!strcmp(key, "Joy1_A")) {
    1036. 

  1036.       joypad[1][KEY_BUTTON_A] = sdlFromHex(value);
    1037. 

  1037.     } else if(!strcmp(key, "Joy1_B")) {
    1038. 

  1038.       joypad[1][KEY_BUTTON_B] = sdlFromHex(value);
    1039. 

  1039.     } else if(!strcmp(key, "Joy1_L")) {
    1040. 

  1040.       joypad[1][KEY_BUTTON_L] = sdlFromHex(value);
    1041. 

  1041.     } else if(!strcmp(key, "Joy1_R")) {
    1042. 

  1042.       joypad[1][KEY_BUTTON_R] = sdlFromHex(value);
    1043. 

  1043.     } else if(!strcmp(key, "Joy1_Start")) {
    1044. 

  1044.       joypad[1][KEY_BUTTON_START] = sdlFromHex(value);
    1045. 

  1045.     } else if(!strcmp(key, "Joy1_Select")) {
    1046. 

  1046.       joypad[1][KEY_BUTTON_SELECT] = sdlFromHex(value);
    1047. 

  1047.     } else if(!strcmp(key, "Joy1_Speed")) {
    1048. 

  1048.       joypad[1][KEY_BUTTON_SPEED] = sdlFromHex(value);
    1049. 

  1049.     } else if(!strcmp(key, "Joy1_Capture")) {
    1050. 

  1050.       joypad[1][KEY_BUTTON_CAPTURE] = sdlFromHex(value);
    1051. 

  1051.     } else if(!strcmp(key,"Joy2_Left")) {
    1052. 

  1052.       joypad[2][KEY_LEFT] = sdlFromHex(value);
    1053. 

  1053.     } else if(!strcmp(key, "Joy2_Right")) {
    1054. 

  1054.       joypad[2][KEY_RIGHT] = sdlFromHex(value);
    1055. 

  1055.     } else if(!strcmp(key, "Joy2_Up")) {
    1056. 

  1056.       joypad[2][KEY_UP] = sdlFromHex(value);
    1057. 

  1057.     } else if(!strcmp(key, "Joy2_Down")) {
    1058. 

  1058.       joypad[2][KEY_DOWN] = sdlFromHex(value);
    1059. 

  1059.     } else if(!strcmp(key, "Joy2_A")) {
    1060. 

  1060.       joypad[2][KEY_BUTTON_A] = sdlFromHex(value);
    1061. 

  1061.     } else if(!strcmp(key, "Joy2_B")) {
    1062. 

  1062.       joypad[2][KEY_BUTTON_B] = sdlFromHex(value);
    1063. 

  1063.     } else if(!strcmp(key, "Joy2_L")) {
    1064. 

  1064.       joypad[2][KEY_BUTTON_L] = sdlFromHex(value);
    1065. 

  1065.     } else if(!strcmp(key, "Joy2_R")) {
    1066. 

  1066.       joypad[2][KEY_BUTTON_R] = sdlFromHex(value);
    1067. 

  1067.     } else if(!strcmp(key, "Joy2_Start")) {
    1068. 

  1068.       joypad[2][KEY_BUTTON_START] = sdlFromHex(value);
    1069. 

  1069.     } else if(!strcmp(key, "Joy2_Select")) {
    1070. 

  1070.       joypad[2][KEY_BUTTON_SELECT] = sdlFromHex(value);
    1071. 

  1071.     } else if(!strcmp(key, "Joy2_Speed")) {
    1072. 

  1072.       joypad[2][KEY_BUTTON_SPEED] = sdlFromHex(value);
    1073. 

  1073.     } else if(!strcmp(key, "Joy2_Capture")) {
    1074. 

  1074.       joypad[2][KEY_BUTTON_CAPTURE] = sdlFromHex(value);
    1075. 

  1075.     } else if(!strcmp(key,"Joy4_Left")) {
    1076. 

  1076.       joypad[4][KEY_LEFT] = sdlFromHex(value);
    1077. 

  1077.     } else if(!strcmp(key, "Joy4_Right")) {
    1078. 

  1078.       joypad[4][KEY_RIGHT] = sdlFromHex(value);
    1079. 

  1079.     } else if(!strcmp(key, "Joy4_Up")) {
    1080. 

  1080.       joypad[4][KEY_UP] = sdlFromHex(value);
    1081. 

  1081.     } else if(!strcmp(key, "Joy4_Down")) {
    1082. 

  1082.       joypad[4][KEY_DOWN] = sdlFromHex(value);
    1083. 

  1083.     } else if(!strcmp(key, "Joy4_A")) {
    1084. 

  1084.       joypad[4][KEY_BUTTON_A] = sdlFromHex(value);
    1085. 

  1085.     } else if(!strcmp(key, "Joy4_B")) {
    1086. 

  1086.       joypad[4][KEY_BUTTON_B] = sdlFromHex(value);
    1087. 

  1087.     } else if(!strcmp(key, "Joy4_L")) {
    1088. 

  1088.       joypad[4][KEY_BUTTON_L] = sdlFromHex(value);
    1089. 

  1089.     } else if(!strcmp(key, "Joy4_R")) {
    1090. 

  1090.       joypad[4][KEY_BUTTON_R] = sdlFromHex(value);
    1091. 

  1091.     } else if(!strcmp(key, "Joy4_Start")) {
    1092. 

  1092.       joypad[4][KEY_BUTTON_START] = sdlFromHex(value);
    1093. 

  1093.     } else if(!strcmp(key, "Joy4_Select")) {
    1094. 

  1094.       joypad[4][KEY_BUTTON_SELECT] = sdlFromHex(value);
    1095. 

  1095.     } else if(!strcmp(key, "Joy4_Speed")) {
    1096. 

  1096.       joypad[4][KEY_BUTTON_SPEED] = sdlFromHex(value);
    1097. 

  1097.     } else if(!strcmp(key, "Joy4_Capture")) {
    1098. 

  1098.       joypad[4][KEY_BUTTON_CAPTURE] = sdlFromHex(value);
    1099. 

  1099.     } else if(!strcmp(key, "Motion_Left")) {
    1100. 

  1100.       motion[KEY_LEFT] = sdlFromHex(value);
    1101. 

  1101.     } else if(!strcmp(key, "Motion_Right")) {
    1102. 

  1102.       motion[KEY_RIGHT] = sdlFromHex(value);
    1103. 

  1103.     } else if(!strcmp(key, "Motion_Up")) {
    1104. 

  1104.       motion[KEY_UP] = sdlFromHex(value);
    1105. 

  1105.     } else if(!strcmp(key, "Motion_Down")) {
    1106. 

  1106.       motion[KEY_DOWN] = sdlFromHex(value);
    1107. 

  1107.     } else if(!strcmp(key, "frameSkip")) {
    1108. 

  1108.       frameSkip = sdlFromHex(value);
    1109. 

  1109.       if(frameSkip < 0 || frameSkip > 9)
    1110. 

  1110.         frameSkip = 2;
    1111. 

  1111.     } else if(!strcmp(key, "gbFrameSkip")) {
    1112. 

  1112.       gbFrameSkip = sdlFromHex(value);
    1113. 

  1113.       if(gbFrameSkip < 0 || gbFrameSkip > 9)
    1114. 

  1114.         gbFrameSkip = 0;      
    1115. 

  1115.     } else if(!strcmp(key, "video")) {
    1116. 

  1116.       sizeOption = sdlFromHex(value);
    1117. 

  1117.       if(sizeOption < 0 || sizeOption > 3)
    1118. 

  1118.         sizeOption = 1;
    1119. 

  1119.     } else if(!strcmp(key, "fullScreen")) {
    1120. 

  1120.       fullscreen = sdlFromHex(value) ? 1 : 0;
    1121. 

  1121.     } else if(!strcmp(key, "useBios")) {
    1122. 

  1122.       useBios = sdlFromHex(value) ? true : false;
    1123. 

  1123.     } else if(!strcmp(key, "skipBios")) {
    1124. 

  1124.       skipBios = sdlFromHex(value) ? true : false;
    1125. 

  1125.     } else if(!strcmp(key, "biosFile")) {
    1126. 

  1126.       strcpy(biosFileName, value);
    1127. 

  1127.     } else if(!strcmp(key, "filter")) {
    1128. 

  1128.       filter = sdlFromHex(value);
    1129. 

  1129.       if(filter < 0 || filter > 13)
    1130. 

  1130.         filter = 0;
    1131. 

  1131.     } else if(!strcmp(key, "disableStatus")) {
    1132. 

  1132.       disableStatusMessages = sdlFromHex(value) ? true : false;
    1133. 

  1133.     } else if(!strcmp(key, "borderOn")) {
    1134. 

  1134.       gbBorderOn = sdlFromHex(value) ? true : false;
    1135. 

  1135.     } else if(!strcmp(key, "borderAutomatic")) {
    1136. 

  1136.       gbBorderAutomatic = sdlFromHex(value) ? true : false;
    1137. 

  1137.     } else if(!strcmp(key, "emulatorType")) {
    1138. 

  1138.       gbEmulatorType = sdlFromHex(value);
    1139. 

  1139.       if(gbEmulatorType < 0 || gbEmulatorType > 5)
    1140. 

  1140.         gbEmulatorType = 1;
    1141. 

  1141.     } else if(!strcmp(key, "colorOption")) {
    1142. 

  1142.       gbColorOption = sdlFromHex(value) ? true : false;
    1143. 

  1143.     } else if(!strcmp(key, "captureDir")) {
    1144. 

  1144.       sdlCheckDirectory(value);
    1145. 

  1145.       strcpy(captureDir, value);
    1146. 

  1146.     } else if(!strcmp(key, "saveDir")) {
    1147. 

  1147.       sdlCheckDirectory(value);
    1148. 

  1148.       strcpy(saveDir, value);
    1149. 

  1149.     } else if(!strcmp(key, "batteryDir")) {
    1150. 

  1150.       sdlCheckDirectory(value);
    1151. 

  1151.       strcpy(batteryDir, value);
    1152. 

  1152.     } else if(!strcmp(key, "captureFormat")) {
    1153. 

  1153.       captureFormat = sdlFromHex(value);
    1154. 

  1154.     } else if(!strcmp(key, "soundQuality")) {
    1155. 

  1155.       soundQuality = sdlFromHex(value);
    1156. 

  1156.       switch(soundQuality) {
    1157. 

  1157.       case 1: break;
    1158. 

  1158.       default:
    1159. 

  1159.         fprintf(stderr, "The rerecording version will run only sound at highest quality. Defaulting to 44.1 KHz\n");
    1160. 

  1160.         soundQuality = 1;
    1161. 

  1161.         break;
    1162. 

  1162.       }
    1163. 

  1163.     } else if(!strcmp(key, "soundOff")) {
    1164. 

  1164.       soundOffFlag = sdlFromHex(value) ? true : false;
    1165. 

  1165.     } else if(!strcmp(key, "soundEnable")) {
    1166. 

  1166.       int res = sdlFromHex(value) & 0x30f;
    1167. 

  1167.       soundEnableChannels(res);
    1168. 

  1168.       soundDisableChannels(~res);
    1169. 

  1169.     } else if(!strcmp(key, "soundEcho")) {
    1170. 

  1170.       soundEcho = sdlFromHex(value) ? true : false;
    1171. 

  1171.     } else if(!strcmp(key, "soundLowPass")) {
    1172. 

  1172.       soundLowPass = sdlFromHex(value) ? true : false;
    1173. 

  1173.     } else if(!strcmp(key, "soundReverse")) {
    1174. 

  1174.       soundReverse = sdlFromHex(value) ? true : false;
    1175. 

  1175.     } else if(!strcmp(key, "soundVolume")) {
    1176. 

  1176.       soundVolume = sdlFromHex(value);
    1177. 

  1177.       if(soundVolume < 0 || soundVolume > 3)
    1178. 

  1178.         soundVolume = 0;
    1179. 

  1179.     } else if(!strcmp(key, "removeIntros")) {
    1180. 

  1180.       removeIntros = sdlFromHex(value) ? true : false;
    1181. 

  1181.     } else if(!strcmp(key, "saveType")) {
    1182. 

  1182.       cpuSaveType = sdlFromHex(value);
    1183. 

  1183.       if(cpuSaveType < 0 || cpuSaveType > 5)
    1184. 

  1184.         cpuSaveType = 0;
    1185. 

  1185.     } else if(!strcmp(key, "flashSize")) {
    1186. 

  1186.       sdlFlashSize = sdlFromHex(value);
    1187. 

  1187.       if(sdlFlashSize != 0 && sdlFlashSize != 1)
    1188. 

  1188.         sdlFlashSize = 0;
    1189. 

  1189.     } else if(!strcmp(key, "ifbType")) {
    1190. 

  1190.       ifbType = sdlFromHex(value);
    1191. 

  1191.       if(ifbType < 0 || ifbType > 2)
    1192. 

  1192.         ifbType = 0;
    1193. 

  1193.     } else if(!strcmp(key, "showSpeed")) {
    1194. 

  1194.       showSpeed = sdlFromHex(value);
    1195. 

  1195.       if(showSpeed < 0 || showSpeed > 2)
    1196. 

  1196.         showSpeed = 1;
    1197. 

  1197.     } else if(!strcmp(key, "showSpeedTransparent")) {
    1198. 

  1198.       showSpeedTransparent = sdlFromHex(value);
    1199. 

  1199.     } else if(!strcmp(key, "autoFrameSkip")) {
    1200. 

  1200.       autoFrameSkip = sdlFromHex(value);
    1201. 

  1201.     } else if(!strcmp(key, "throttle")) {
    1202. 

  1202.       throttle = sdlFromHex(value);
    1203. 

  1203.       if(throttle != 0 && (throttle < 5 || throttle > 1000))
    1204. 

  1204.         throttle = 0;
    1205. 

  1205.     } else if(!strcmp(key, "disableMMX")) {
    1206. 

  1206. #ifdef MMX
    1207. 

  1207.       cpu_mmx = sdlFromHex(value) ? false : true;
    1208. 

  1208. #endif
    1209. 

  1209.     } else if(!strcmp(key, "pauseWhenInactive")) {
    1210. 

  1210.       pauseWhenInactive = sdlFromHex(value) ? true : false;
    1211. 

  1211.     } else if(!strcmp(key, "agbPrint")) {
    1212. 

  1212.       sdlAgbPrint = sdlFromHex(value);
    1213. 

  1213.     } else if(!strcmp(key, "rtcEnabled")) {
    1214. 

  1214.       sdlRtcEnable = sdlFromHex(value);
    1215. 

  1215.     } else if(!strcmp(key, "rewindTimer")) {
    1216. 

  1216.       rewindTimer = sdlFromHex(value);
    1217. 

  1217.       if(rewindTimer < 0 || rewindTimer > 600)
    1218. 

  1218.         rewindTimer = 0;
    1219. 

  1219.       rewindTimer *= 6;  // convert value to 10 frames multiple
    1220. 

  1220.     } else if(!strcmp(key, "enhancedDetection")) {
    1221. 

  1221.       cpuEnhancedDetection = sdlFromHex(value) ? true : false;
    1222. 

  1222.     } else {
    1223. 

  1223.       fprintf(stderr, "Unknown configuration key %s\n", key);
    1224. 

  1224.     }
    1225. 

  1225.   }
    1226. 

  1226. }
    1227. 

  1227. 

  1228. void sdlReadPreferences()
    1229. 

  1229. {
    1230. 

  1230.   FILE *f = sdlFindFile("VisualBoyAdvance.cfg");
    1231. 

  1231. 

  1232.   if(f == NULL) {
    1233. 

  1233.     fprintf(stderr, "Configuration file NOT FOUND (using defaults)\n");
    1234. 

  1234.     return;
    1235. 

  1235.   } else
    1236. 

  1236.     fprintf(stderr, "Reading configuration file.\n");
    1237. 

  1237. 

  1238.   sdlReadPreferences(f);
    1239. 

  1239. 

  1240.   fclose(f);
    1241. 

  1241. }
    1242. 

  1242. 

  1243. static void sdlApplyPerImagePreferences()
    1244. 

  1244. {
    1245. 

  1245.   FILE *f = sdlFindFile("vba-over.ini");
    1246. 

  1246.   if(!f) {
    1247. 

  1247.     fprintf(stderr, "vba-over.ini NOT FOUND (using emulator settings)\n");
    1248. 

  1248.     return;
    1249. 

  1249.   } else
    1250. 

  1250.     fprintf(stderr, "Reading vba-over.ini\n");
    1251. 

  1251. 

  1252.   char buffer[7];
    1253. 

  1253.   buffer[0] = '[';
    1254. 

  1254.   buffer[1] = rom[0xac];
    1255. 

  1255.   buffer[2] = rom[0xad];
    1256. 

  1256.   buffer[3] = rom[0xae];
    1257. 

  1257.   buffer[4] = rom[0xaf];
    1258. 

  1258.   buffer[5] = ']';
    1259. 

  1259.   buffer[6] = 0;
    1260. 

  1260. 

  1261.   char readBuffer[2048];
    1262. 

  1262. 

  1263.   bool found = false;
    1264. 

  1264.   
    1265. 

  1265.   while(1) {
    1266. 

  1266.     char *s = fgets(readBuffer, 2048, f);
    1267. 

  1267. 

  1268.     if(s == NULL)
    1269. 

  1269.       break;
    1270. 

  1270. 

  1271.     char *p  = strchr(s, ';');
    1272. 

  1272.     
    1273. 

  1273.     if(p)
    1274. 

  1274.       *p = 0;
    1275. 

  1275.     
    1276. 

  1276.     char *token = strtok(s, " \t\n\r=");
    1277. 

  1277. 

  1278.     if(!token)
    1279. 

  1279.       continue;
    1280. 

  1280.     if(strlen(token) == 0)
    1281. 

  1281.       continue;
    1282. 

  1282. 

  1283.     if(!strcmp(token, buffer)) {
    1284. 

  1284.       found = true;
    1285. 

  1285.       break;
    1286. 

  1286.     }
    1287. 

  1287.   }
    1288. 

  1288. 

  1289.   if(found) {
    1290. 

  1290.     while(1) {
    1291. 

  1291.       char *s = fgets(readBuffer, 2048, f);
    1292. 

  1292. 

  1293.       if(s == NULL)
    1294. 

  1294.         break;
    1295. 

  1295. 

  1296.       char *p = strchr(s, ';');
    1297. 

  1297.       if(p)
    1298. 

  1298.         *p = 0;
    1299. 

  1299. 

  1300.       char *token = strtok(s, " \t\n\r=");
    1301. 

  1301.       if(!token)
    1302. 

  1302.         continue;
    1303. 

  1303.       if(strlen(token) == 0)
    1304. 

  1304.         continue;
    1305. 

  1305. 

  1306.       if(token[0] == '[') // starting another image settings
    1307. 

  1307.         break;
    1308. 

  1308.       char *value = strtok(NULL, "\t\n\r=");
    1309. 

  1309.       if(value == NULL)
    1310. 

  1310.         continue;
    1311. 

  1311.       
    1312. 

  1312.       if(!strcmp(token, "rtcEnabled"))
    1313. 

  1313.         rtcEnable(atoi(value) == 0 ? false : true);
    1314. 

  1314.       else if(!strcmp(token, "flashSize")) {
    1315. 

  1315.         int size = atoi(value);
    1316. 

  1316.         if(size == 0x10000 || size == 0x20000)
    1317. 

  1317.           flashSetSize(size);
    1318. 

  1318.       } else if(!strcmp(token, "saveType")) {
    1319. 

  1319.         int save = atoi(value);
    1320. 

  1320.         if(save >= 0 && save <= 5)
    1321. 

  1321.           cpuSaveType = save;
    1322. 

  1322.       }
    1323. 

  1323.     }
    1324. 

  1324.   }
    1325. 

  1325.   fclose(f);
    1326. 

  1326. }
    1327. 

  1327. 

  1328. static int sdlCalculateShift(u32 mask)
    1329. 

  1329. {
    1330. 

  1330.   int m = 0;
    1331. 

  1331.   
    1332. 

  1332.   while(mask) {
    1333. 

  1333.     m++;
    1334. 

  1334.     mask >>= 1;
    1335. 

  1335.   }
    1336. 

  1336. 

  1337.   return m-5;
    1338. 

  1338. }
    1339. 

  1339. 

  1340. static int sdlCalculateMaskWidth(u32 mask)
    1341. 

  1341. {
    1342. 

  1342.   int m = 0;
    1343. 

  1343.   int mask2 = mask;
    1344. 

  1344. 

  1345.   while(mask2) {
    1346. 

  1346.     m++;
    1347. 

  1347.     mask2 >>= 1;
    1348. 

  1348.   }
    1349. 

  1349. 

  1350.   int m2 = 0;
    1351. 

  1351.   mask2 = mask;
    1352. 

  1352.   while(!(mask2 & 1)) {
    1353. 

  1353.     m2++;
    1354. 

  1354.     mask2 >>= 1;
    1355. 

  1355.   }
    1356. 

  1356. 

  1357.   return m - m2;
    1358. 

  1358. }
    1359. 

  1359. 

  1360. void sdlWriteState(int num)
    1361. 

  1361. {
    1362. 

  1362.   char stateName[2048];
    1363. 

  1363. 

  1364.   if(saveDir[0])
    1365. 

  1365.     sprintf(stateName, "%s/%s%d.sgm", saveDir, sdlGetFilename(filename),
    1366. 

  1366.             num+1);
    1367. 

  1367.   else
    1368. 

  1368.     sprintf(stateName,"%s%d.sgm", filename, num+1);
    1369. 

  1369.   if(theEmulator.emuWriteState)
    1370. 

  1370.     theEmulator.emuWriteState(stateName);
    1371. 

  1371.   sprintf(stateName, "Wrote state %d", num+1);
    1372. 

  1372.   systemScreenMessage(stateName);
    1373. 

  1373. }
    1374. 

  1374. 

  1375. void sdlReadState(int num)
    1376. 

  1376. {
    1377. 

  1377.   char stateName[2048];
    1378. 

  1378. 

  1379.   if(saveDir[0])
    1380. 

  1380.     sprintf(stateName, "%s/%s%d.sgm", saveDir, sdlGetFilename(filename),
    1381. 

  1381.             num+1);
    1382. 

  1382.   else
    1383. 

  1383.     sprintf(stateName,"%s%d.sgm", filename, num+1);
    1384. 

  1384. 

  1385.   if(theEmulator.emuReadState)
    1386. 

  1386.     theEmulator.emuReadState(stateName);
    1387. 

  1387. 

  1388.   sprintf(stateName, "Loaded state %d", num+1);
    1389. 

  1389.   systemScreenMessage(stateName);
    1390. 

  1390. }
    1391. 

  1391. 

  1392. void sdlWriteBattery()
    1393. 

  1393. {
    1394. 

  1394.   char buffer[1048];
    1395. 

  1395. 

  1396.   if(batteryDir[0])
    1397. 

  1397.     sprintf(buffer, "%s/%s.sav", batteryDir, sdlGetFilename(filename));
    1398. 

  1398.   else  
    1399. 

  1399.     sprintf(buffer, "%s.sav", filename);
    1400. 

  1400. 

  1401.   theEmulator.emuWriteBattery(buffer);	
    1402. 

  1402. 

  1403.   systemScreenMessage("Wrote battery");
    1404. 

  1404. }
    1405. 

  1405. 

  1406. void sdlReadBattery()
    1407. 

  1407. {
    1408. 

  1408.   char buffer[1048];
    1409. 

  1409.   
    1410. 

  1410.   if(batteryDir[0])
    1411. 

  1411.     sprintf(buffer, "%s/%s.sav", batteryDir, sdlGetFilename(filename));
    1412. 

  1412.   else 
    1413. 

  1413.     sprintf(buffer, "%s.sav", filename);
    1414. 

  1414.   
    1415. 

  1415.   bool res = false;
    1416. 

  1416. 

  1417.   res = theEmulator.emuReadBattery(buffer);
    1418. 

  1418. 

  1419.   if(res)
    1420. 

  1420.     systemScreenMessage("Loaded battery");
    1421. 

  1421. }
    1422. 

  1422. 

  1423. #define MOD_KEYS    (KMOD_CTRL|KMOD_SHIFT|KMOD_ALT|KMOD_META)
    1424. 

  1424. #define MOD_NOCTRL  (KMOD_SHIFT|KMOD_ALT|KMOD_META)
    1425. 

  1425. #define MOD_NOALT   (KMOD_CTRL|KMOD_SHIFT|KMOD_META)
    1426. 

  1426. #define MOD_NOSHIFT (KMOD_CTRL|KMOD_ALT|KMOD_META)
    1427. 

  1427. 

  1428. void sdlUpdateKey(int key, bool down)
    1429. 

  1429. {
    1430. 

  1430.   int i;
    1431. 

  1431.   for(int j = 0; j < 4; j++) {
    1432. 

  1432.     for(i = 0 ; i < 12; i++) {
    1433. 

  1433.       if((joypad[j][i] & 0xf000) == 0) {
    1434. 

  1434.         if(key == joypad[j][i])
    1435. 

  1435.           if (down) currentButtons[j] |= 1<<i;
    1436. 

  1436.           else currentButtons[j] ^= 1<<i;
    1437. 

  1437.       }
    1438. 

  1438.     }
    1439. 

  1439.   }
    1440. 

  1440.   for(i = 0 ; i < 4; i++) {
    1441. 

  1441.     if((motion[i] & 0xf000) == 0) {
    1442. 

  1442.       if(key == motion[i])
    1443. 

  1443.         sdlMotionButtons[i] = down;
    1444. 

  1444.     }
    1445. 

  1445.   }
    1446. 

  1446. }
    1447. 

  1447. 

  1448. void sdlUpdateJoyButton(int which,
    1449. 

  1449.                         int button,
    1450. 

  1450.                         bool pressed)
    1451. 

  1451. {
    1452. 

  1452.   int i;
    1453. 

  1453.   for(int j = 0; j < 4; j++) {
    1454. 

  1454.     for(i = 0; i < 12; i++) {
    1455. 

  1455.       int dev = (joypad[j][i] >> 12);
    1456. 

  1456.       int b = joypad[j][i] & 0xfff;
    1457. 

  1457.       if(dev) {
    1458. 

  1458.         dev--;
    1459. 

  1459.         
    1460. 

  1460.         if((dev == which) && (b >= 128) && (b == (button+128))) {
    1461. 

  1461.           if (pressed) currentButtons[j] |= 1<<i;
    1462. 

  1462.           else currentButtons[j] ^= 1<<i;
    1463. 

  1463.         }
    1464. 

  1464.       }
    1465. 

  1465.     }
    1466. 

  1466.   }
    1467. 

  1467.   for(i = 0; i < 4; i++) {
    1468. 

  1468.     int dev = (motion[i] >> 12);
    1469. 

  1469.     int b = motion[i] & 0xfff;
    1470. 

  1470.     if(dev) {
    1471. 

  1471.       dev--;
    1472. 

  1472. 

  1473.       if((dev == which) && (b >= 128) && (b == (button+128))) {
    1474. 

  1474.         sdlMotionButtons[i] = pressed;
    1475. 

  1475.       }
    1476. 

  1476.     }
    1477. 

  1477.   }  
    1478. 

  1478. }
    1479. 

  1479. 

  1480. void sdlUpdateJoyHat(int which,
    1481. 

  1481.                      int hat,
    1482. 

  1482.                      int value)
    1483. 

  1483. {
    1484. 

  1484.   int i;
    1485. 

  1485.   for(int j = 0; j < 4; j++) {
    1486. 

  1486.     for(i = 0; i < 12; i++) {
    1487. 

  1487.       int dev = (joypad[j][i] >> 12);
    1488. 

  1488.       int a = joypad[j][i] & 0xfff;
    1489. 

  1489.       if(dev) {
    1490. 

  1490.         dev--;
    1491. 

  1491.         
    1492. 

  1492.         if((dev == which) && (a>=32) && (a < 48) && (((a&15)>>2) == hat)) {
    1493. 

  1493.           int dir = a & 3;
    1494. 

  1494.           int v = 0;
    1495. 

  1495.           switch(dir) {
    1496. 

  1496.           case 0:
    1497. 

  1497.             v = value & SDL_HAT_UP;
    1498. 

  1498.             break;
    1499. 

  1499.           case 1:
    1500. 

  1500.             v = value & SDL_HAT_DOWN;
    1501. 

  1501.             break;
    1502. 

  1502.           case 2:
    1503. 

  1503.             v = value & SDL_HAT_RIGHT;
    1504. 

  1504.             break;
    1505. 

  1505.           case 3:
    1506. 

  1506.             v = value & SDL_HAT_LEFT;
    1507. 

  1507.             break;
    1508. 

  1508.           }
    1509. 

  1509.           if (v) currentButtons[j] |= 1<<i;
    1510. 

  1510.           else currentButtons[j] ^= 1<<i;
    1511. 

  1511.         }
    1512. 

  1512.       }
    1513. 

  1513.     }
    1514. 

  1514.   }
    1515. 

  1515.   for(i = 0; i < 4; i++) {
    1516. 

  1516.     int dev = (motion[i] >> 12);
    1517. 

  1517.     int a = motion[i] & 0xfff;
    1518. 

  1518.     if(dev) {
    1519. 

  1519.       dev--;
    1520. 

  1520. 

  1521.       if((dev == which) && (a>=32) && (a < 48) && (((a&15)>>2) == hat)) {
    1522. 

  1522.         int dir = a & 3;
    1523. 

  1523.         int v = 0;
    1524. 

  1524.         switch(dir) {
    1525. 

  1525.         case 0:
    1526. 

  1526.           v = value & SDL_HAT_UP;
    1527. 

  1527.           break;
    1528. 

  1528.         case 1:
    1529. 

  1529.           v = value & SDL_HAT_DOWN;
    1530. 

  1530.           break;
    1531. 

  1531.         case 2:
    1532. 

  1532.           v = value & SDL_HAT_RIGHT;
    1533. 

  1533.           break;
    1534. 

  1534.         case 3:
    1535. 

  1535.           v = value & SDL_HAT_LEFT;
    1536. 

  1536.           break;
    1537. 

  1537.         }
    1538. 

  1538.         sdlMotionButtons[i] = (v ? true : false);
    1539. 

  1539.       }
    1540. 

  1540.     }
    1541. 

  1541.   }      
    1542. 

  1542. }
    1543. 

  1543. 

  1544. void sdlUpdateJoyAxis(int which,
    1545. 

  1545.                       int axis,
    1546. 

  1546.                       int value)
    1547. 

  1547. {
    1548. 

  1548.   int i;
    1549. 

  1549.   for(int j = 0; j < 4; j++) {
    1550. 

  1550.     for(i = 0; i < 12; i++) {
    1551. 

  1551.       int dev = (joypad[j][i] >> 12);
    1552. 

  1552.       int a = joypad[j][i] & 0xfff;
    1553. 

  1553.       if(dev) {
    1554. 

  1554.         dev--;
    1555. 

  1555.         
    1556. 

  1556.         if((dev == which) && (a < 32) && ((a>>1) == axis)) {
    1557. 

  1557. 	  //I have no idea what this does, is this reimplementation correct? --Felipe
    1558. 

  1558. 	  if (value>16384) {
    1559. 

  1559. 	  	if (a&1) currentButtons[j] |= 1<<i;
    1560. 

  1560. 	  	else currentButtons[j] ^= 1<<i;
    1561. 

  1561. 	  }
    1562. 

  1562.           else if (value<16384){
    1563. 

  1563.           	if (a&1) currentButtons[j] ^= 1<<i;
    1564. 

  1564.           	else currentButtons[j] |= 1<<i;
    1565. 

  1565.           }
    1566. 

  1566.         }
    1567. 

  1567.       }
    1568. 

  1568.     }
    1569. 

  1569.   }
    1570. 

  1570.   for(i = 0; i < 4; i++) {
    1571. 

  1571.     int dev = (motion[i] >> 12);
    1572. 

  1572.     int a = motion[i] & 0xfff;
    1573. 

  1573.     if(dev) {
    1574. 

  1574.       dev--;
    1575. 

  1575. 

  1576.       if((dev == which) && (a < 32) && ((a>>1) == axis)) {
    1577. 

  1577.         sdlMotionButtons[i] = (a & 1) ? (value > 16384) : (value < -16384);
    1578. 

  1578.       }
    1579. 

  1579.     }
    1580. 

  1580.   }  
    1581. 

  1581. }
    1582. 

  1582. 

  1583. bool sdlCheckJoyKey(int key)
    1584. 

  1584. {
    1585. 

  1585.   int dev = (key >> 12) - 1;
    1586. 

  1586.   int what = key & 0xfff;
    1587. 

  1587. 

  1588.   if(what >= 128) {
    1589. 

  1589.     // joystick button
    1590. 

  1590.     int button = what - 128;
    1591. 

  1591. 

  1592.     if(button >= SDL_JoystickNumButtons(sdlDevices[dev]))
    1593. 

  1593.       return false;
    1594. 

  1594.   } else if (what < 0x20) {
    1595. 

  1595.     // joystick axis    
    1596. 

  1596.     what >>= 1;
    1597. 

  1597.     if(what >= SDL_JoystickNumAxes(sdlDevices[dev]))
    1598. 

  1598.       return false;
    1599. 

  1599.   } else if (what < 0x30) {
    1600. 

  1600.     // joystick hat
    1601. 

  1601.     what = (what & 15);
    1602. 

  1602.     what >>= 2;
    1603. 

  1603.     if(what >= SDL_JoystickNumHats(sdlDevices[dev]))
    1604. 

  1604.       return false;
    1605. 

  1605.   }
    1606. 

  1606. 

  1607.   // no problem found
    1608. 

  1608.   return true;
    1609. 

  1609. }
    1610. 

  1610. 

  1611. void sdlCheckKeys()
    1612. 

  1612. {
    1613. 

  1613.   sdlNumDevices = SDL_NumJoysticks();
    1614. 

  1614. 

  1615.   if(sdlNumDevices)
    1616. 

  1616.     sdlDevices = (SDL_Joystick **)calloc(1,sdlNumDevices *
    1617. 

  1617.                                          sizeof(SDL_Joystick **));
    1618. 

  1618.   int i;
    1619. 

  1619. 

  1620.   bool usesJoy = false;
    1621. 

  1621. 

  1622.   for(int j = 0; j < 4; j++) {
    1623. 

  1623.     for(i = 0; i < 12; i++) {
    1624. 

  1624.       int dev = joypad[j][i] >> 12;
    1625. 

  1625.       if(dev) {
    1626. 

  1626.         dev--;
    1627. 

  1627.         bool ok = false;
    1628. 

  1628.         
    1629. 

  1629.         if(sdlDevices) {
    1630. 

  1630.           if(dev < sdlNumDevices) {
    1631. 

  1631.             if(sdlDevices[dev] == NULL) {
    1632. 

  1632.               sdlDevices[dev] = SDL_JoystickOpen(dev);
    1633. 

  1633.             }
    1634. 

  1634.             
    1635. 

  1635.             ok = sdlCheckJoyKey(joypad[j][i]);
    1636. 

  1636.           } else
    1637. 

  1637.             ok = false;
    1638. 

  1638.         }
    1639. 

  1639.         
    1640. 

  1640.         if(!ok)
    1641. 

  1641.           joypad[j][i] = defaultJoypad[i];
    1642. 

  1642.         else
    1643. 

  1643.           usesJoy = true;
    1644. 

  1644.       }
    1645. 

  1645.     }
    1646. 

  1646.   }
    1647. 

  1647. 

  1648.   for(i = 0; i < 4; i++) {
    1649. 

  1649.     int dev = motion[i] >> 12;
    1650. 

  1650.     if(dev) {
    1651. 

  1651.       dev--;
    1652. 

  1652.       bool ok = false;
    1653. 

  1653.       
    1654. 

  1654.       if(sdlDevices) {
    1655. 

  1655.         if(dev < sdlNumDevices) {
    1656. 

  1656.           if(sdlDevices[dev] == NULL) {
    1657. 

  1657.             sdlDevices[dev] = SDL_JoystickOpen(dev);
    1658. 

  1658.           }
    1659. 

  1659.           
    1660. 

  1660.           ok = sdlCheckJoyKey(motion[i]);
    1661. 

  1661.         } else
    1662. 

  1662.           ok = false;
    1663. 

  1663.       }
    1664. 

  1664.       
    1665. 

  1665.       if(!ok)
    1666. 

  1666.         motion[i] = defaultMotion[i];
    1667. 

  1667.       else
    1668. 

  1668.         usesJoy = true;
    1669. 

  1669.     }
    1670. 

  1670.   }
    1671. 

  1671. 

  1672.   if(usesJoy)
    1673. 

  1673.     SDL_JoystickEventState(SDL_ENABLE);
    1674. 

  1674. }
    1675. 

  1675. 

  1676. void sdlPollEvents()
    1677. 

  1677. {
    1678. 

  1678.   SDL_Event event;
    1679. 

  1679.   while(SDL_PollEvent(&event)) {
    1680. 

  1680.     switch(event.type) {
    1681. 

  1681.     case SDL_QUIT:
    1682. 

  1682.       emulating = 0;
    1683. 

  1683.       break;
    1684. 

  1684.     case SDL_ACTIVEEVENT:
    1685. 

  1685.       if(pauseWhenInactive && (event.active.state & SDL_APPINPUTFOCUS)) {
    1686. 

  1686.         active = event.active.gain;
    1687. 

  1687.         if(active) {
    1688. 

  1688.           if(!paused) {
    1689. 

  1689.             if(emulating)
    1690. 

  1690.               soundResume();
    1691. 

  1691.           }
    1692. 

  1692.         } else {
    1693. 

  1693.           wasPaused = true;
    1694. 

  1694.           if(pauseWhenInactive) {
    1695. 

  1695.             if(emulating)
    1696. 

  1696.               soundPause();
    1697. 

  1697.           }
    1698. 

  1698.           
    1699. 

  1699.           memset(delta,255,sizeof(delta));
    1700. 

  1700.         }
    1701. 

  1701.       }
    1702. 

  1702.       break;
    1703. 

  1703.     case SDL_MOUSEMOTION:
    1704. 

  1704.     case SDL_MOUSEBUTTONUP:
    1705. 

  1705.     case SDL_MOUSEBUTTONDOWN:
    1706. 

  1706.       if(fullscreen) {
    1707. 

  1707.         SDL_ShowCursor(SDL_ENABLE);
    1708. 

  1708.         mouseCounter = 120;
    1709. 

  1709.       }
    1710. 

  1710.       break;
    1711. 

  1711.     case SDL_JOYHATMOTION:
    1712. 

  1712.       sdlUpdateJoyHat(event.jhat.which,
    1713. 

  1713.                       event.jhat.hat,
    1714. 

  1714.                       event.jhat.value);
    1715. 

  1715.       break;
    1716. 

  1716.     case SDL_JOYBUTTONDOWN:
    1717. 

  1717.     case SDL_JOYBUTTONUP:
    1718. 

  1718.       sdlUpdateJoyButton(event.jbutton.which,
    1719. 

  1719.                          event.jbutton.button,
    1720. 

  1720.                          event.jbutton.state == SDL_PRESSED);
    1721. 

  1721.       break;
    1722. 

  1722.     case SDL_JOYAXISMOTION:
    1723. 

  1723.       sdlUpdateJoyAxis(event.jaxis.which,
    1724. 

  1724.                        event.jaxis.axis,
    1725. 

  1725.                        event.jaxis.value);
    1726. 

  1726.       break;
    1727. 

  1727.     case SDL_KEYDOWN:
    1728. 

  1728.       sdlUpdateKey(event.key.keysym.sym, true);
    1729. 

  1729.       break;
    1730. 

  1730.     case SDL_KEYUP:
    1731. 

  1731.       switch(event.key.keysym.sym) {
    1732. 

  1732.       case SDLK_r:
    1733. 

  1733.         if(!(event.key.keysym.mod & MOD_NOCTRL) &&
    1734. 

  1734.            (event.key.keysym.mod & KMOD_CTRL)) {
    1735. 

  1735.           if(emulating) {
    1736. 

  1736.             theEmulator.emuReset(true);
    1737. 

  1737. 

  1738.             systemScreenMessage("Reset");
    1739. 

  1739.           }
    1740. 

  1740.         }
    1741. 

  1741.         break;
    1742. 

  1742.       case SDLK_b:
    1743. 

  1743.         if(!(event.key.keysym.mod & MOD_NOCTRL) &&
    1744. 

  1744.            (event.key.keysym.mod & KMOD_CTRL)) {
    1745. 

  1745.           if(emulating && theEmulator.emuReadMemState && rewindMemory 
    1746. 

  1746.              && rewindCount) {
    1747. 

  1747.             rewindPos = --rewindPos & 7;
    1748. 

  1748.             theEmulator.emuReadMemState(&rewindMemory[REWIND_SIZE*rewindPos], 
    1749. 

  1749.                                      REWIND_SIZE);
    1750. 

  1750.             rewindCount--;
    1751. 

  1751.             rewindCounter = 0;
    1752. 

  1752.             systemScreenMessage("Rewind");
    1753. 

  1753.           }
    1754. 

  1754.         }
    1755. 

  1755.         break;
    1756. 

  1756.       case SDLK_p:
    1757. 

  1757.         if(!(event.key.keysym.mod & MOD_NOCTRL) &&
    1758. 

  1758.            (event.key.keysym.mod & KMOD_CTRL)) {
    1759. 

  1759.           paused = !paused;
    1760. 

  1760.           SDL_PauseAudio(paused);
    1761. 

  1761.           if(paused)
    1762. 

  1762.             wasPaused = true;
    1763. 

  1763.         }
    1764. 

  1764.         break;
    1765. 

  1765.       case SDLK_ESCAPE:
    1766. 

  1766.         emulating = 0;
    1767. 

  1767.         break;
    1768. 

  1768.       case SDLK_F12:
    1769. 

  1769.         untilCapture = !untilCapture;
    1770. 

  1770.       case SDLK_f:
    1771. 

  1771.         if(!(event.key.keysym.mod & MOD_NOCTRL) &&
    1772. 

  1772.            (event.key.keysym.mod & KMOD_CTRL)) {
    1773. 

  1773.           int flags = 0;
    1774. 

  1774.           fullscreen = !fullscreen;
    1775. 

  1775.           if(fullscreen)
    1776. 

  1776.             flags |= SDL_FULLSCREEN;
    1777. 

  1777.           SDL_SetVideoMode(destWidth, destHeight, systemColorDepth, flags);
    1778. 

  1778.           //          if(SDL_WM_ToggleFullScreen(surface))
    1779. 

  1779.           //            fullscreen = !fullscreen;
    1780. 

  1780.         }
    1781. 

  1781.         break;
    1782. 

  1782.       case SDLK_F11:
    1783. 

  1783.         if(dbgMain != debuggerMain) {
    1784. 

  1784.           if(armState) {
    1785. 

  1785.             armNextPC -= 4;
    1786. 

  1786.             reg[15].I -= 4;
    1787. 

  1787.           } else {
    1788. 

  1788.             armNextPC -= 2;
    1789. 

  1789.             reg[15].I -= 2;
    1790. 

  1790.           }
    1791. 

  1791.         }
    1792. 

  1792.         debugger = true;
    1793. 

  1793.         break;
    1794. 

  1794.       case SDLK_F1:
    1795. 

  1795.       case SDLK_F2:
    1796. 

  1796.       case SDLK_F3:
    1797. 

  1797.       case SDLK_F4:
    1798. 

  1798.       case SDLK_F5:
    1799. 

  1799.       case SDLK_F6:
    1800. 

  1800.       case SDLK_F7:
    1801. 

  1801.       case SDLK_F8:
    1802. 

  1802.       case SDLK_F9:
    1803. 

  1803.       case SDLK_F10:
    1804. 

  1804.         if(!(event.key.keysym.mod & MOD_NOSHIFT) &&
    1805. 

  1805.            (event.key.keysym.mod & KMOD_SHIFT)) {
    1806. 

  1806.           sdlWriteState(event.key.keysym.sym-SDLK_F1);
    1807. 

  1807.         } else if(!(event.key.keysym.mod & MOD_KEYS)) {
    1808. 

  1808.           sdlReadState(event.key.keysym.sym-SDLK_F1);
    1809. 

  1809.         }
    1810. 

  1810.         break;
    1811. 

  1811.       case SDLK_1:
    1812. 

  1812.       case SDLK_2:
    1813. 

  1813.       case SDLK_3:
    1814. 

  1814.       case SDLK_4:
    1815. 

  1815.         if(!(event.key.keysym.mod & MOD_NOALT) &&
    1816. 

  1816.            (event.key.keysym.mod & KMOD_ALT)) {
    1817. 

  1817.           char *disableMessages[4] = 
    1818. 

  1818.             { "autofire A disabled",
    1819. 

  1819.               "autofire B disabled",
    1820. 

  1820.               "autofire R disabled",
    1821. 

  1821.               "autofire L disabled"};
    1822. 

  1822.           char *enableMessages[4] = 
    1823. 

  1823.             { "autofire A",
    1824. 

  1824.               "autofire B",
    1825. 

  1825.               "autofire R",
    1826. 

  1826.               "autofire L"};
    1827. 

  1827.           int mask = 1 << (event.key.keysym.sym - SDLK_1);
    1828. 

  1828.     if(event.key.keysym.sym > SDLK_2)
    1829. 

  1829.       mask <<= 6;
    1830. 

  1830.           if(autoFire & mask) {
    1831. 

  1831.             autoFire &= ~mask;
    1832. 

  1832.             systemScreenMessage(disableMessages[event.key.keysym.sym - SDLK_1]);
    1833. 

  1833.           } else {
    1834. 

  1834.             autoFire |= mask;
    1835. 

  1835.             systemScreenMessage(enableMessages[event.key.keysym.sym - SDLK_1]);
    1836. 

  1836.           }
    1837. 

  1837.         } if(!(event.key.keysym.mod & MOD_NOCTRL) &&
    1838. 

  1838.              (event.key.keysym.mod & KMOD_CTRL)) {
    1839. 

  1839.           int mask = 0x0100 << (event.key.keysym.sym - SDLK_1);
    1840. 

  1840.           layerSettings ^= mask;
    1841. 

  1841.           layerEnable = DISPCNT & layerSettings;
    1842. 

  1842.           CPUUpdateRenderBuffers(false);
    1843. 

  1843.         }
    1844. 

  1844.         break;
    1845. 

  1845.       case SDLK_5:
    1846. 

  1846.       case SDLK_6:
    1847. 

  1847.       case SDLK_7:
    1848. 

  1848.       case SDLK_8:
    1849. 

  1849.         if(!(event.key.keysym.mod & MOD_NOCTRL) &&
    1850. 

  1850.            (event.key.keysym.mod & KMOD_CTRL)) {
    1851. 

  1851.           int mask = 0x0100 << (event.key.keysym.sym - SDLK_1);
    1852. 

  1852.           layerSettings ^= mask;
    1853. 

  1853.           layerEnable = DISPCNT & layerSettings;
    1854. 

  1854.         }
    1855. 

  1855.         break;
    1856. 

  1856.       case SDLK_n:
    1857. 

  1857.         if(!(event.key.keysym.mod & MOD_NOCTRL) &&
    1858. 

  1858.            (event.key.keysym.mod & KMOD_CTRL)) {
    1859. 

  1859.           if(paused)
    1860. 

  1860.             paused = false;
    1861. 

  1861.           pauseNextFrame = true;
    1862. 

  1862.         }
    1863. 

  1863.         break;
    1864. 

  1864.       default:
    1865. 

  1865.         break;
    1866. 

  1866.       }
    1867. 

  1867.       sdlUpdateKey(event.key.keysym.sym, false);
    1868. 

  1868.       break;
    1869. 

  1869.     }
    1870. 

  1870.   }
    1871. 

  1871. }
    1872. 

  1872. 

  1873. void usage(char *cmd)
    1874. 

  1874. {
    1875. 

  1875.   printf("%s [option ...] file\n", cmd);
    1876. 

  1876.   printf("\
    1877. 

  1877. \n\
    1878. 

  1878. Options:\n\
    1879. 

  1879.   -1, --video-1x               1x\n\
    1880. 

  1880.   -2, --video-2x               2x\n\
    1881. 

  1881.   -3, --video-3x               3x\n\
    1882. 

  1882.   -4, --video-4x               4x\n\
    1883. 

  1883.   -F, --fullscreen             Full screen\n\
    1884. 

  1884.   -G, --gdb=PROTOCOL           GNU Remote Stub mode:\n\
    1885. 

  1885.                                 tcp      - use TCP at port 55555\n\
    1886. 

  1886.                                 tcp:PORT - use TCP at port PORT\n\
    1887. 

  1887.                                 pipe     - use pipe transport\n\
    1888. 

  1888.   -N, --no-debug               Don't parse debug information\n\
    1889. 

  1889.   -S, --flash-size=SIZE        Set the Flash size\n\
    1890. 

  1890.       --flash-64k               0 -  64K Flash\n\
    1891. 

  1891.       --flash-128k              1 - 128K Flash\n\
    1892. 

  1892.   -T, --throttle=THROTTLE      Set the desired throttle (5...1000)\n\
    1893. 

  1893.   -Y, --yuv=TYPE               Use YUV overlay for drawing:\n\
    1894. 

  1894.                                 0 - YV12\n\
    1895. 

  1895.                                 1 - UYVY\n\
    1896. 

  1896.                                 2 - YVYU\n\
    1897. 

  1897.                                 3 - YUY2\n\
    1898. 

  1898.                                 4 - IYUV\n\
    1899. 

  1899.   -b, --bios=BIOS              Use given bios file\n\
    1900. 

  1900.   -c, --config=FILE            Read the given configuration file\n\
    1901. 

  1901.   -d, --debug     …
    1902.

Large files files are truncated, but you can click here to view the full file