PageRenderTime 39ms CodeModel.GetById 13ms RepoModel.GetById 1ms app.codeStats 0ms

/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 
    

  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                  Enter debugger\n\
    1902. 

  1902.   -f, --filter=FILTER          Select filter:\n\
    1903. 

  1903.       --filter-normal            0 - normal mode\n\
    1904. 

  1904.       --filter-tv-mode           1 - TV Mode\n\
    1905. 

  1905.       --filter-2xsai             2 - 2xSaI\n\
    1906. 

  1906.       --filter-super-2xsai       3 - Super 2xSaI\n\
    1907. 

  1907.       --filter-super-eagle       4 - Super Eagle\n\
    1908. 

  1908.       --filter-pixelate          5 - Pixelate\n\
    1909. 

  1909.       --filter-motion-blur       6 - Motion Blur\n\
    1910. 

  1910.       --filter-advmame           7 - AdvanceMAME Scale2x\n\
    1911. 

  1911.       --filter-simple2x          8 - Simple2x\n\
    1912. 

  1912.       --filter-bilinear          9 - Bilinear\n\
    1913. 

  1913.       --filter-bilinear+        10 - Bilinear Plus\n\
    1914. 

  1914.       --filter-scanlines        11 - Scanlines\n\
    1915. 

  1915.       --filter-hq2x             12 - hq2x\n\
    1916. 

  1916.       --filter-lq2x             13 - lq2x\n\
    1917. 

  1917.   -h, --help                   Print this help\n\
    1918. 

  1918.   -i, --ips=PATCH              Apply given IPS patch\n\
    1919. 

  1919.   -P, --profile=[HERTZ]        Enable profiling\n\
    1920. 

  1920.   -s, --frameskip=FRAMESKIP    Set frame skip (0...9)\n\
    1921. 

  1921. ");
    1922. 

  1922.   printf("\
    1923. 

  1923.   -t, --save-type=TYPE         Set the available save type\n\
    1924. 

  1924.       --save-auto               0 - Automatic (EEPROM, SRAM, FLASH)\n\
    1925. 

  1925.       --save-eeprom             1 - EEPROM\n\
    1926. 

  1926.       --save-sram               2 - SRAM\n\
    1927. 

  1927.       --save-flash              3 - FLASH\n\
    1928. 

  1928.       --save-sensor             4 - EEPROM+Sensor\n\
    1929. 

  1929.       --save-none               5 - NONE\n\
    1930. 

  1930.   -v, --verbose=VERBOSE        Set verbose logging (trace.log)\n\
    1931. 

  1931.                                   1 - SWI\n\
    1932. 

  1932.                                   2 - Unaligned memory access\n\
    1933. 

  1933.                                   4 - Illegal memory write\n\
    1934. 

  1934.                                   8 - Illegal memory read\n\
    1935. 

  1935.                                  16 - DMA 0\n\
    1936. 

  1936.                                  32 - DMA 1\n\
    1937. 

  1937.                                  64 - DMA 2\n\
    1938. 

  1938.                                 128 - DMA 3\n\
    1939. 

  1939.                                 256 - Undefined instruction\n\
    1940. 

  1940.                                 512 - AGBPrint messages\n\
    1941. 

  1941. \n\
    1942. 

  1942. Long options only:\n\
    1943. 

  1943.       --agb-print              Enable AGBPrint support\n\
    1944. 

  1944.       --auto-frameskip         Enable auto frameskipping\n\
    1945. 

  1945.       --ifb-none               No interframe blending\n\
    1946. 

  1946.       --ifb-motion-blur        Interframe motion blur\n\
    1947. 

  1947.       --ifb-smart              Smart interframe blending\n\
    1948. 

  1948.       --no-agb-print           Disable AGBPrint support\n\
    1949. 

  1949.       --no-auto-frameskip      Disable auto frameskipping\n\
    1950. 

  1950.       --no-ips                 Do not apply IPS patch\n\
    1951. 

  1951.       --no-mmx                 Disable MMX support\n\
    1952. 

  1952.       --no-pause-when-inactive Don't pause when inactive\n\
    1953. 

  1953.       --no-rtc                 Disable RTC support\n\
    1954. 

  1954.       --no-show-speed          Don't show emulation speed\n\
    1955. 

  1955.       --no-throttle            Disable thrrotle\n\
    1956. 

  1956.       --pause-when-inactive    Pause when inactive\n\
    1957. 

  1957.       --rtc                    Enable RTC support\n\
    1958. 

  1958.       --show-speed-normal      Show emulation speed\n\
    1959. 

  1959.       --show-speed-detailed    Show detailed speed data\n\
    1960. 

  1960. ");
    1961. 

  1961.   printf("\
    1962. 

  1962.   -r, --recordmovie=filename   Start recording input movie\n\
    1963. 

  1963.   -p, --playmovie=filename   Play input movie non-read-only\n\
    1964. 

  1964.   -w, --watchmovie=filename   Play input movie in read-only mode\n\
    1965. 

  1965. ");
    1966. 

  1966. }
    1967. 

  1967. 

  1968. static char *szFile;
    1969. 

  1969. 

  1970. void file_run()
    1971. 

  1971. {
    1972. 

  1972.   //printf("RLM: file_run\n");
    1973. 

  1973.   utilGetBaseName(szFile, filename);
    1974. 

  1974.     char *p = strrchr(filename, '.');
    1975. 

  1975. 

  1976.     if(p)
    1977. 

  1977.       *p = 0;
    1978. 

  1978. 

  1979.     if(ipsname[0] == 0)
    1980. 

  1980.       sprintf(ipsname, "%s.ips", filename);
    1981. 

  1981.     
    1982. 

  1982.     bool failed = false;
    1983. 

  1983. 

  1984.     IMAGE_TYPE type = utilFindType(szFile);
    1985. 

  1985. 

  1986.     if(type == IMAGE_UNKNOWN) {
    1987. 

  1987.       systemMessage(0, "Unknown file type %s", szFile);
    1988. 

  1988.       exit(-1);
    1989. 

  1989.     }
    1990. 

  1990.     systemCartridgeType = (int)type;
    1991. 

  1991. 

  1992.     if(type == IMAGE_GB) {
    1993. 

  1993.       failed = !gbLoadRom(szFile);
    1994. 

  1994.       if(!failed) {
    1995. 

  1995.         systemCartridgeType = 1;
    1996. 

  1996.         //printf("RLM: choosing GBSystem\n");
    1997. 

  1997. 	theEmulator = GBSystem;
    1998. 

  1998.         if(sdlAutoIPS) {
    1999. 

  1999.           int size = gbRomSize;
    2000. 

  2000.           utilApplyIPS(ipsname, &gbRom, &size);
    2001. 

  2001.           if(size != gbRomSize) {
    2002. 

  2002.             extern bool gbUpdateSizes();
    2003. 

  2003.             gbUpdateSizes();
    2004. 

  2004.             gbReset();
    2005. 

  2005.           }
    2006. 

  2006.         }
    2007. 

  2007.       }
    2008. 

  2008.     } else if(type == IMAGE_GBA) {
    2009. 

  2009.       int size = CPULoadRom(szFile);
    2010. 

  2010.       failed = (size == 0);
    2011. 

  2011.       if(!failed) {
    2012. 

  2012.         //        if(cpuEnhancedDetection && cpuSaveType == 0) {
    2013. 

  2013.         //          utilGBAFindSave(rom, size);
    2014. 

  2014.         //        }
    2015. 

  2015. 	
    2016. 

  2016.         sdlApplyPerImagePreferences();
    2017. 

  2017.         
    2018. 

  2018.         systemCartridgeType = 0;
    2019. 

  2019.         theEmulator = GBASystem;
    2020. 

  2020. 

  2021.         /* disabled due to problems
    2022. 

  2022.         if(removeIntros && rom != NULL) {
    2023. 

  2023.           WRITE32LE(&rom[0], 0xea00002e);
    2024. 

  2024.         }
    2025. 

  2025.         */
    2026. 

  2026.         
    2027. 

  2027.         //CPUInit(biosFileName, useBios);
    2028. 

  2028. 	CPUInit();
    2029. 

  2029.         CPUReset();
    2030. 

  2030.         if(sdlAutoIPS) {
    2031. 

  2031.           int size = 0x2000000;
    2032. 

  2032.           utilApplyIPS(ipsname, &rom, &size);
    2033. 

  2033.           if(size != 0x2000000) {
    2034. 

  2034.             CPUReset();
    2035. 

  2035.           }
    2036. 

  2036.         }
    2037. 

  2037.       }
    2038. 

  2038.     }
    2039. 

  2039.     
    2040. 

  2040.     if(failed) {
    2041. 

  2041.       systemMessage(0, "Failed to load file %s", szFile);
    2042. 

  2042.       exit(-1);
    2043. 

  2043.     }
    2044. 

  2044.   
    2045. 

  2045.   emulating = 1;
    2046. 

  2046.   renderedFrames = 0;
    2047. 

  2047.   }
    2048. 

  2048. 

  2049. 

  2050. void shutdown () {
    2051. 

  2051. fprintf(stderr,"Shutting down\n");
    2052. 

  2052.   remoteCleanUp();
    2053. 

  2053.   soundShutdown();
    2054. 

  2054. 

  2055.   if(gbRom != NULL || rom != NULL) {
    2056. 

  2056.     sdlWriteBattery();
    2057. 

  2057.     theEmulator.emuCleanUp();
    2058. 

  2058.   }
    2059. 

  2059. 

  2060.   if(delta) {
    2061. 

  2061.     free(delta);
    2062. 

  2062.     delta = NULL;
    2063. 

  2063.   }
    2064. 

  2064.   
    2065. 

  2065.   SDL_Quit();
    2066. 

  2066. }
    2067. 

  2067. 

  2068. int tick () {
    2069. 

  2069.   int ret;
    2070. 

  2070.   ret = theEmulator.emuMain(theEmulator.emuCount);
    2071. 

  2071.   // enable user input while ticking.
    2072. 

  2072.   if (ret) {  sdlPollEvents(); }
    2073. 

  2073. }
    2074. 

  2074. 

  2075. void step () {
    2076. 

  2076.   if(!paused && active) {
    2077. 

  2077.     //printf("RLM: emulator main\n");
    2078. 

  2078.     int frameComplete = 0;
    2079. 

  2079.     while (!(frameComplete)){
    2080. 

  2080.       frameComplete = theEmulator.emuMain(theEmulator.emuCount);
    2081. 

  2081.     }
    2082. 

  2082.     //printf("RLM: emulator main called\n");
    2083. 

  2083.   } else {
    2084. 

  2084.     //SDL_Delay(500);
    2085. 

  2085.     // kanzure: wtf! trying to get throttling to work.
    2086. 

  2086.   }
    2087. 

  2087.   sdlPollEvents();
    2088. 

  2088.   SDL_ShowCursor(SDL_DISABLE);
    2089. 

  2089. }
    2090. 

  2090. 

  2091. void step(int keymask){
    2092. 

  2092.   currentButtons[0] = keymask;
    2093. 

  2093.   if (keymask == 0x0800){
    2094. 

  2094.     theEmulator.emuReset(true);
    2095. 

  2095.   }
    2096. 

  2096.   else {
    2097. 

  2097.     step();
    2098. 

  2098.   }
    2099. 

  2099.   currentButtons[0] = keymask;
    2100. 

  2100. }
    2101. 

  2101. 

  2102. // let the player control the game until he decides he hates it. This is particularly useful for playing from the repl.
    2103. 

  2103. void stepUntilCapture() {
    2104. 

  2104.     untilCapture = true;
    2105. 

  2105.     //currentButtons[0] = 0;
    2106. 

  2106.     //systemClearJoypads();
    2107. 

  2107.     //sdlUpdateKey(SDLK_F12, false);
    2108. 

  2108. 

  2109.     //while (currentButtons[0] != 2048) {
    2110. 

  2110.     while (untilCapture) {
    2111. 

  2111.         /* if (currentButtons[0] != 0) {
    2112. 

  2112.             printf("currentButtons[o] is %d\n", currentButtons[0]);
    2113. 

  2113.         } */
    2114. 

  2114.         step();
    2115. 

  2115.     }
    2116. 

  2116. 

  2117.     // reset the buttons so that this function can be called in the future
    2118. 

  2118.     //currentButtons[0] = 0;
    2119. 

  2119.     //systemClearJoypads();
    2120. 

  2120.     //sdlUpdateKey(SDLK_F12, false);
    2121. 

  2121. }
    2122. 

  2122. 

  2123. int main(int argc, char **argv)
    2124. 

  2124. {
    2125. 

  2125.   fprintf(stderr, "VisualBoyAdvance version %s [SDL]\n", PACKAGE_VERSION);
    2126. 

  2126. 

  2127.   arg0 = argv[0];
    2128. 

  2128.   
    2129. 

  2129.   captureDir[0] = 0;
    2130. 

  2130.   saveDir[0] = 0;
    2131. 

  2131.   batteryDir[0] = 0;
    2132. 

  2132.   ipsname[0] = 0;
    2133. 

  2133.   
    2134. 

  2134.   int op = -1;
    2135. 

  2135. 

  2136.   frameSkip = 2;
    2137. 

  2137.   gbBorderOn = 0;
    2138. 

  2138. 

  2139.   parseDebug = true;
    2140. 

  2140. 

  2141.   sdlReadPreferences();
    2142. 

  2142. 

  2143.   sdlPrintUsage = 0;
    2144. 

  2144.   
    2145. 

  2145.   while((op = getopt_long(argc,
    2146. 

  2146.                           argv,
    2147. 

  2147.                           "FNT:Y:G:D:b:c:df:hi:p::s:t:v:1234",
    2148. 

  2148.                           sdlOptions,
    2149. 

  2149.                           NULL)) != -1) {
    2150. 

  2150.     switch(op) {
    2151. 

  2151.     case 0:
    2152. 

  2152.       // long option already processed by getopt_long
    2153. 

  2153.       break;
    2154. 

  2154.     case 'b':
    2155. 

  2155.       useBios = true;
    2156. 

  2156.       if(optarg == NULL) {
    2157. 

  2157.         fprintf(stderr, "Missing BIOS file name\n");
    2158. 

  2158.         exit(-1);
    2159. 

  2159.       }
    2160. 

  2160.       strcpy(biosFileName, optarg);
    2161. 

  2161.       break;
    2162. 

  2162.     case 'c':
    2163. 

  2163.       {
    2164. 

  2164.         if(optarg == NULL) {
    2165. 

  2165.           fprintf(stderr, "Missing config file name\n");
    2166. 

  2166.           exit(-1);
    2167. 

  2167.         }
    2168. 

  2168.         FILE *f = fopen(optarg, "r");
    2169. 

  2169.         if(f == NULL) {
    2170. 

  2170.           fprintf(stderr, "File not found %s\n", optarg);
    2171. 

  2171.           exit(-1);
    2172. 

  2172.         }
    2173. 

  2173.         sdlReadPreferences(f);
    2174. 

  2174.         fclose(f);
    2175. 

  2175.       }
    2176. 

  2176.       break;
    2177. 

  2177.     case 'd':
    2178. 

  2178.       debugger = true;
    2179. 

  2179.       break;
    2180. 

  2180.     case 'h':
    2181. 

  2181.       sdlPrintUsage = 1;
    2182. 

  2182.       break;
    2183. 

  2183.     case 'i':
    2184. 

  2184.       if(optarg == NULL) {
    2185. 

  2185.         fprintf(stderr, "Missing IPS name\n");
    2186. 

  2186.         exit(-1);
    2187. 

  2187.         strcpy(ipsname, optarg);
    2188. 

  2188.       }
    2189. 

  2189.       break;
    2190. 

  2190.     case 'Y':
    2191. 

  2191.       yuv = true;
    2192. 

  2192.       if(optarg) {
    2193. 

  2193.         yuvType = atoi(optarg);
    2194. 

  2194.         switch(yuvType) {
    2195. 

  2195.         case 0:
    2196. 

  2196.           yuvType = SDL_YV12_OVERLAY;
    2197. 

  2197.           break;
    2198. 

  2198.         case 1:
    2199. 

  2199.           yuvType = SDL_UYVY_OVERLAY;
    2200. 

  2200.           break;
    2201. 

  2201.         case 2:
    2202. 

  2202.           yuvType = SDL_YVYU_OVERLAY;
    2203. 

  2203.           break;
    2204. 

  2204.         case 3:
    2205. 

  2205.           yuvType = SDL_YUY2_OVERLAY;
    2206. 

  2206.           break;
    2207. 

  2207.         case 4:
    2208. 

  2208.           yuvType = SDL_IYUV_OVERLAY;
    2209. 

  2209.           break;
    2210. 

  2210.         default:
    2211. 

  2211.           yuvType = SDL_YV12_OVERLAY;
    2212. 

  2212.         }
    2213. 

  2213.       } else
    2214. 

  2214.         yuvType = SDL_YV12_OVERLAY;
    2215. 

  2215.       break;
    2216. 

  2216.     case 'G':
    2217. 

  2217.       dbgMain = remoteStubMain;
    2218. 

  2218.       dbgSignal = remoteStubSignal;
    2219. 

  2219.       dbgOutput = remoteOutput;
    2220. 

  2220.       debugger = true;
    2221. 

  2221.       debuggerStub = true;
    2222. 

  2222.       if(optarg) {
    2223. 

  2223.         char *s = optarg;
    2224. 

  2224.         if(strncmp(s,"tcp:", 4) == 0) {
    2225. 

  2225.           s+=4;
    2226. 

  2226.           int port = atoi(s);
    2227. 

  2227.           remoteSetProtocol(0);
    2228. 

  2228.           remoteSetPort(port);
    2229. 

  2229.         } else if(strcmp(s,"tcp") == 0) {
    2230. 

  2230.           remoteSetProtocol(0);
    2231. 

  2231.         } else if(strcmp(s, "pipe") == 0) {
    2232. 

  2232.           remoteSetProtocol(1);
    2233. 

  2233.         } else {
    2234. 

  2234.           fprintf(stderr, "Unknown protocol %s\n", s);
    2235. 

  2235.           exit(-1);
    2236. 

  2236.         }
    2237. 

  2237.       } else {
    2238. 

  2238.         remoteSetProtocol(0);
    2239. 

  2239.       }
    2240. 

  2240.       break;
    2241. 

  2241.     case 'N':
    2242. 

  2242.       parseDebug = false;
    2243. 

  2243.       break;
    2244. 

  2244.     case 'D':
    2245. 

  2245.       if(optarg) {
    2246. 

  2246.         systemDebug = atoi(optarg);
    2247. 

  2247.       } else {
    2248. 

  2248.         systemDebug = 1;
    2249. 

  2249.       }
    2250. 

  2250.       break;
    2251. 

  2251.     case 'F':
    2252. 

  2252.       fullscreen = 1;
    2253. 

  2253.       mouseCounter = 120;
    2254. 

  2254.       break;
    2255. 

  2255.     case 'f':
    2256. 

  2256.       if(optarg) {
    2257. 

  2257.         filter = atoi(optarg);
    2258. 

  2258.       } else {
    2259. 

  2259.         filter = 0;
    2260. 

  2260.       }
    2261. 

  2261.       break;
    2262. 

  2262.       
    2263. 

  2263.     case 'r':
    2264. 

  2264.       if(optarg == NULL) {
    2265. 

  2265.         fprintf(stderr, "ERROR: --recordmovie ('r') needs movie filename as option\n");
    2266. 

  2266.         exit(-1);
    2267. 

  2267.       }
    2268. 

  2268.         strcpy(movieFileName, optarg);
    2269. 

  2269.         useMovie = 1;
    2270. 

  2270.       break;
    2271. 

  2271.     case 'p': // play without read-only (editable)
    2272. 

  2272.       fprintf (stderr, "-p got called!\n");
    2273. 

  2273.       if(optarg == NULL) {
    2274. 

  2274.         fprintf(stderr, "ERROR: --playmovie ('p') needs movie filename as option\n");
    2275. 

  2275.         exit(-1);
    2276. 

  2276.       }
    2277. 

  2277.         strcpy(movieFileName, optarg);
    2278. 

  2278.         useMovie = 2;
    2279. 

  2279.       break;
    2280. 

  2280.     case 'w': // play with read-only
    2281. 

  2281.      fprintf (stderr, "-w got called!\n"); 
    2282. 

  2282.       if(optarg == NULL) {
    2283. 

  2283.         fprintf(stderr, "ERROR: --watchmovie ('w') needs movie filename as option\n");
    2284. 

  2284.         exit(-1);
    2285. 

  2285.       }
    2286. 

  2286.         strcpy(movieFileName, optarg);
    2287. 

  2287.         useMovie = 3;
    2288. 

  2288.       break;
    2289. 

  2289.                   
    2290. 

  2290.     case 'P':
    2291. 

  2291. #ifdef PROFILING
    2292. 

  2292.       if(optarg) {
    2293. 

  2293.         cpuEnableProfiling(atoi(optarg));
    2294. 

  2294.       } else
    2295. 

  2295.         cpuEnableProfiling(100);
    2296. 

  2296. #endif
    2297. 

  2297.       break;
    2298. 

  2298.     case 'S':
    2299. 

  2299.       sdlFlashSize = atoi(optarg);
    2300. 

  2300.       if(sdlFlashSize < 0 || sdlFlashSize > 1)
    2301. 

  2301.         sdlFlashSize = 0;
    2302. 

  2302.       break;
    2303. 

  2303.     case 's':
    2304. 

  2304.       if(optarg) {
    2305. 

  2305.         int a = atoi(optarg);
    2306. 

  2306.         if(a >= 0 && a <= 9) {
    2307. 

  2307.           gbFrameSkip = a;
    2308. 

  2308.           frameSkip = a;
    2309. 

  2309.         }
    2310. 

  2310.       } else {
    2311. 

  2311.         frameSkip = 2;
    2312. 

  2312.         gbFrameSkip = 0;
    2313. 

  2313.       }
    2314. 

  2314.       break;
    2315. 

  2315.     case 't':
    2316. 

  2316.       if(optarg) {
    2317. 

  2317.         int a = atoi(optarg);
    2318. 

  2318.         if(a < 0 || a > 5)
    2319. 

  2319.           a = 0;
    2320. 

  2320.         cpuSaveType = a;
    2321. 

  2321.       }
    2322. 

  2322.       break;
    2323. 

  2323.     case 'T':
    2324. 

  2324.       if(optarg) {
    2325. 

  2325.         int t = atoi(optarg);
    2326. 

  2326.         throttle = t;
    2327. 

  2327.       }
    2328. 

  2328.       break;
    2329. 

  2329.     case 'v':
    2330. 

  2330.       if(optarg) {
    2331. 

  2331.         systemVerbose = atoi(optarg);
    2332. 

  2332.       } else 
    2333. 

  2333.         systemVerbose = 0;
    2334. 

  2334.       break;
    2335. 

  2335.     case '1':
    2336. 

  2336.       sizeOption = 0;
    2337. 

  2337.       break;
    2338. 

  2338.     case '2':
    2339. 

  2339.       sizeOption = 1;
    2340. 

  2340.       break;
    2341. 

  2341.     case '3':
    2342. 

  2342.       sizeOption = 2;
    2343. 

  2343.       break;
    2344. 

  2344.     case '4':
    2345. 

  2345.       sizeOption = 3;
    2346. 

  2346.       break;
    2347. 

  2347.     case '?':
    2348. 

  2348.       sdlPrintUsage = 1;
    2349. 

  2349.       break;
    2350. 

  2350.     }
    2351. 

  2351.   }
    2352. 

  2352. 

  2353.   //printf("RLM: derpy loves you!\n");
    2354. 

  2354.   //printf("RLM: useMovie: %d (1 is record)\n", useMovie);
    2355. 

  2355.   if(sdlPrintUsage) {
    2356. 

  2356.     usage(argv[0]);
    2357. 

  2357.     exit(-1);
    2358. 

  2358.   }
    2359. 

  2359. 

  2360. #ifdef MMX
    2361. 

  2361.   if(disableMMX)
    2362. 

  2362.     cpu_mmx = 0;
    2363. 

  2363. #endif
    2364. 

  2364. 

  2365.   if(rewindTimer)
    2366. 

  2366.     rewindMemory = (char *)malloc(8*REWIND_SIZE);
    2367. 

  2367. 

  2368.   if(sdlFlashSize == 0)
    2369. 

  2369.     flashSetSize(0x10000);
    2370. 

  2370.   else
    2371. 

  2371.     flashSetSize(0x20000);
    2372. 

  2372. 

  2373.   rtcEnable(sdlRtcEnable ? true : false);
    2374. 

  2374.   agbPrintEnable(sdlAgbPrint ? true : false);
    2375. 

  2375.   
    2376. 

  2376.   if(!debuggerStub) {
    2377. 

  2377.     if(optind >= argc) {
    2378. 

  2378.       systemMessage(0,"Missing image name");
    2379. 

  2379.       usage(argv[0]);
    2380. 

  2380.       exit(-1);
    2381. 

  2381.     }
    2382. 

  2382.   }
    2383. 

  2383. 

  2384.   if(filter) {
    2385. 

  2385.     sizeOption = 1;
    2386. 

  2386.   }
    2387. 

  2387. 

  2388.   for(int i = 0; i < 24;) {
    2389. 

  2389.     systemGbPalette[i++] = (0x1f) | (0x1f << 5) | (0x1f << 10);
    2390. 

  2390.     systemGbPalette[i++] = (0x15) | (0x15 << 5) | (0x15 << 10);
    2391. 

  2391.     systemGbPalette[i++] = (0x0c) | (0x0c << 5) | (0x0c << 10);
    2392. 

  2392.     systemGbPalette[i++] = 0;
    2393. 

  2393.   }
    2394. 

  2394. 

  2395.   systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
    2396. 

  2396. 

  2397.   if(optind < argc) 
    2398. 

  2398.   {
    2399. 

  2399.       szFile = argv[optind];
    2400. 

  2400.       file_run();
    2401. 

  2401.       //printf("RLM: file_run() done\n");
    2402. 

  2402.   }
    2403. 

  2403.    else 
    2404. 

  2404.   {
    2405. 

  2405.     systemCartridgeType = 0;
    2406. 

  2406.     strcpy(filename, "gnu_stub");
    2407. 

  2407.     rom = (u8 *)malloc(0x2000000);
    2408. 

  2408.     workRAM = (u8 *)calloc(1, 0x40000);
    2409. 

  2409.     bios = (u8 *)calloc(1,0x4000);
    2410. 

  2410.     internalRAM = (u8 *)calloc(1,0x8000);
    2411. 

  2411.     paletteRAM = (u8 *)calloc(1,0x400);
    2412. 

  2412.     vram = (u8 *)calloc(1, 0x20000);
    2413. 

  2413.     oam = (u8 *)calloc(1, 0x400);
    2414. 

  2414.     pix = (u8 *)calloc(1, 4 * 240 * 160);
    2415. 

  2415.     ioMem = (u8 *)calloc(1, 0x400);
    2416. 

  2416. 

  2417.     theEmulator = GBASystem;
    2418. 

  2418.     
    2419. 

  2419.     //CPUInit(biosFileName, useBios);
    2420. 

  2420.     CPUInit();
    2421. 

  2421.     CPUReset();
    2422. 

  2422.   }
    2423. 

  2423.   
    2424. 

  2424.   if(debuggerStub) 
    2425. 

  2425.     remoteInit();
    2426. 

  2426.   
    2427. 

  2427.   int flags = SDL_INIT_VIDEO|SDL_INIT_AUDIO|
    2428. 

  2428.     SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE;
    2429. 

  2429. 

  2430.   if(soundOffFlag)
    2431. 

  2431.     flags ^= SDL_INIT_AUDIO;
    2432. 

  2432.   
    2433. 

  2433.   if(SDL_Init(flags)) {
    2434. 

  2434.     systemMessage(0, "Failed to init SDL: %s", SDL_GetError());
    2435. 

  2435.     exit(-1);
    2436. 

  2436.   }
    2437. 

  2437. 

  2438.   if(SDL_InitSubSystem(SDL_INIT_JOYSTICK)) {
    2439. 

  2439.     systemMessage(0, "Failed to init joystick support: %s", SDL_GetError());
    2440. 

  2440.   }
    2441. 

  2441.   
    2442. 

  2442.   sdlCheckKeys();
    2443. 

  2443.   
    2444. 

  2444.   if(systemCartridgeType == 0) {
    2445. 

  2445.     srcWidth = 240;
    2446. 

  2446.     srcHeight = 160;
    2447. 

  2447.     systemFrameSkip = frameSkip;
    2448. 

  2448.   } else if (systemCartridgeType == 1) {
    2449. 

  2449.     if(gbBorderOn) {
    2450. 

  2450.       srcWidth = 256;
    2451. 

  2451.       srcHeight = 224;
    2452. 

  2452.       gbBorderLineSkip = 256;
    2453. 

  2453.       gbBorderColumnSkip = 48;
    2454. 

  2454.       gbBorderRowSkip = 40;
    2455. 

  2455.     } else {      
    2456. 

  2456.       srcWidth = 160;
    2457. 

  2457.       srcHeight = 144;
    2458. 

  2458.       gbBorderLineSkip = 160;
    2459. 

  2459.       gbBorderColumnSkip = 0;
    2460. 

  2460.       gbBorderRowSkip = 0;
    2461. 

  2461.     }
    2462. 

  2462.     systemFrameSkip = gbFrameSkip;
    2463. 

  2463.   } else {
    2464. 

  2464.     srcWidth = 320;
    2465. 

  2465.     srcHeight = 240;
    2466. 

  2466.   }
    2467. 

  2467.   
    2468. 

  2468.   destWidth = (sizeOption+1)*srcWidth;
    2469. 

  2469.   destHeight = (sizeOption+1)*srcHeight;
    2470. 

  2470.   
    2471. 

  2471.   surface = SDL_SetVideoMode(destWidth, destHeight, 16,
    2472. 

  2472.                              SDL_ANYFORMAT|SDL_HWSURFACE|SDL_DOUBLEBUF|
    2473. 

  2473.                              (fullscreen ? SDL_FULLSCREEN : 0));
    2474. 

  2474.   
    2475. 

  2475.   if(surface == NULL) {
    2476. 

  2476.     systemMessage(0, "Failed to set video mode");
    2477. 

  2477.     SDL_Quit();
    2478. 

  2478.     exit(-1);
    2479. 

  2479.   }
    2480. 

  2480.   
    2481. 

  2481.   systemRedShift = sdlCalculateShift(surface->format->Rmask);
    2482. 

  2482.   systemGreenShift = sdlCalculateShift(surface->format->Gmask);
    2483. 

  2483.   systemBlueShift = sdlCalculateShift(surface->format->Bmask);
    2484. 

  2484.   
    2485. 

  2485.   systemColorDepth = surface->format->BitsPerPixel;
    2486. 

  2486.   if(systemColorDepth == 15)
    2487. 

  2487.     systemColorDepth = 16;
    2488. 

  2488. 

  2489.   if(yuv) {
    2490. 

  2490.     Init_Overlay(surface, yuvType);
    2491. 

  2491.     systemColorDepth = 32;
    2492. 

  2492.     systemRedShift = 3;
    2493. 

  2493.     systemGreenShift = 11;
    2494. 

  2494.     systemBlueShift =  19;
    2495. 

  2495.   }
    2496. 

  2496.   
    2497. 

  2497.   if(systemColorDepth != 16 && systemColorDepth != 24 &&
    2498. 

  2498.      systemColorDepth != 32) {
    2499. 

  2499.     fprintf(stderr,"Unsupported color depth '%d'.\nOnly 16, 24 and 32 bit color depths are supported\n", systemColorDepth);
    2500. 

  2500.     exit(-1);
    2501. 

  2501.   }
    2502. 

  2502. 

  2503. #ifndef C_CORE
    2504. 

  2504.   sdlMakeStretcher(srcWidth);
    2505. 

  2505. #else
    2506. 

  2506.   switch(systemColorDepth) {
    2507. 

  2507.   case 16:
    2508. 

  2508.     sdlStretcher = sdlStretcher16[sizeOption];
    2509. 

  2509.     break;
    2510. 

  2510.   case 24:
    2511. 

  2511.     sdlStretcher = sdlStretcher24[sizeOption];
    2512. 

  2512.     break;
    2513. 

  2513.   case 32:
    2514. 

  2514.     sdlStretcher = sdlStretcher32[sizeOption];
    2515. 

  2515.     break;
    2516. 

  2516.   default:
    2517. 

  2517.     fprintf(stderr, "Unsupported resolution: %d\n", systemColorDepth);
    2518. 

  2518.     exit(-1);
    2519. 

  2519.   }
    2520. 

  2520. #endif
    2521. 

  2521. 

  2522.   fprintf(stderr,"Color depth: %d\n", systemColorDepth);
    2523. 

  2523.   
    2524. 

  2524.   if(systemColorDepth == 16) {
    2525. 

  2525.     if(sdlCalculateMaskWidth(surface->format->Gmask) == 6) {
    2526. 

  2526.       Init_2xSaI(565);
    2527. 

  2527.       RGB_LOW_BITS_MASK = 0x821;
    2528. 

  2528.     } else {
    2529. 

  2529.       Init_2xSaI(555);
    2530. 

  2530.       RGB_LOW_BITS_MASK = 0x421;      
    2531. 

  2531.     }
    2532. 

  2532.     if(systemCartridgeType == 2) {
    2533. 

  2533.       for(int i = 0; i < 0x10000; i++) {
    2534. 

  2534.         systemColorMap16[i] = (((i >> 1) & 0x1f) << systemBlueShift) |
    2535. 

  2535.           (((i & 0x7c0) >> 6) << systemGreenShift) |
    2536. 

  2536.           (((i & 0xf800) >> 11) << systemRedShift);  
    2537. 

  2537.       }      
    2538. 

  2538.     } else {
    2539. 

  2539.       for(int i = 0; i < 0x10000; i++) {
    2540. 

  2540.         systemColorMap16[i] = ((i & 0x1f) << systemRedShift) |
    2541. 

  2541.           (((i & 0x3e0) >> 5) << systemGreenShift) |
    2542. 

  2542.           (((i & 0x7c00) >> 10) << systemBlueShift);  
    2543. 

  2543.       }
    2544. 

  2544.     }
    2545. 

  2545.     srcPitch = srcWidth * 2+4;
    2546. 

  2546.   } else {
    2547. 

  2547.     if(systemColorDepth != 32)
    2548. 

  2548.       filterFunction = NULL;
    2549. 

  2549.     RGB_LOW_BITS_MASK = 0x010101;
    2550. 

  2550.     if(systemColorDepth == 32) {
    2551. 

  2551.       Init_2xSaI(32);
    2552. 

  2552.     }
    2553. 

  2553.     for(int i = 0; i < 0x10000; i++) {
    2554. 

  2554.       systemColorMap32[i] = ((i & 0x1f) << systemRedShift) |
    2555. 

  2555.         (((i & 0x3e0) >> 5) << systemGreenShift) |
    2556. 

  2556.         (((i & 0x7c00) >> 10) << systemBlueShift);  
    2557. 

  2557.     }
    2558. 

  2558.     if(systemColorDepth == 32)
    2559. 

  2559.       srcPitch = srcWidth*4 + 4;
    2560. 

  2560.     else
    2561. 

  2561.       srcPitch = srcWidth*3;
    2562. 

  2562.   }
    2563. 

  2563. 

  2564.   if(systemColorDepth != 32) {
    2565. 

  2565.     switch(filter) {
    2566. 

  2566.     case 0:
    2567. 

  2567.       filterFunction = NULL;
    2568. 

  2568.       break;
    2569. 

  2569.     case 1:
    2570. 

  2570.       filterFunction = ScanlinesTV;
    2571. 

  2571.       break;
    2572. 

  2572.     case 2:
    2573. 

  2573.       filterFunction = _2xSaI;
    2574. 

  2574.       break;
    2575. 

  2575.     case 3:
    2576. 

  2576.       filterFunction = Super2xSaI;
    2577. 

  2577.       break;
    2578. 

  2578.     case 4:
    2579. 

  2579.       filterFunction = SuperEagle;
    2580. 

  2580.       break;
    2581. 

  2581.     case 5:
    2582. 

  2582.       filterFunction = Pixelate2x16;
    2583. 

  2583.       break;
    2584. 

  2584.     case 6:
    2585. 

  2585.       filterFunction = MotionBlur;
    2586. 

  2586.       break;
    2587. 

  2587.     case 7:
    2588. 

  2588.       filterFunction = AdMame2x;
    2589. 

  2589.       break;
    2590. 

  2590.     case 8:
    2591. 

  2591.       filterFunction = Simple2x16;
    2592. 

  2592.       break;
    2593. 

  2593.     case 9:
    2594. 

  2594.       filterFunction = Bilinear;
    2595. 

  2595.       break;
    2596. 

  2596.     case 10:
    2597. 

  2597.       filterFunction = BilinearPlus;
    2598. 

  2598.       break;
    2599. 

  2599.     case 11:
    2600. 

  2600.       filterFunction = Scanlines;
    2601. 

  2601.       break;
    2602. 

  2602.     case 12:
    2603. 

  2603.       filterFunction = hq2x;
    2604. 

  2604.       break;
    2605. 

  2605.     case 13:
    2606. 

  2606.       filterFunction = lq2x;
    2607. 

  2607.       break;
    2608. 

  2608.     default:
    2609. 

  2609.       filterFunction = NULL;
    2610. 

  2610.       break;
    2611. 

  2611.     }
    2612. 

  2612.   } else {
    2613. 

  2613.     switch(filter) {
    2614. 

  2614.     case 0:
    2615. 

  2615.       filterFunction = NULL;
    2616. 

  2616.       break;
    2617. 

  2617.     case 1:
    2618. 

  2618.       filterFunction = ScanlinesTV32;
    2619. 

  2619.       break;
    2620. 

  2620.     case 2:
    2621. 

  2621.       filterFunction = _2xSaI32;
    2622. 

  2622.       break;
    2623. 

  2623.     case 3:
    2624. 

  2624.       filterFunction = Super2xSaI32;
    2625. 

  2625.       break;
    2626. 

  2626.     case 4:
    2627. 

  2627.       filterFunction = SuperEagle32;
    2628. 

  2628.       break;
    2629. 

  2629.     case 5:
    2630. 

  2630.       filterFunction = Pixelate2x32;
    2631. 

  2631.       break;
    2632. 

  2632.     case 6:
    2633. 

  2633.       filterFunction = MotionBlur32;
    2634. 

  2634.       break;
    2635. 

  2635.     case 7:
    2636. 

  2636.       filterFunction = AdMame2x32;
    2637. 

  2637.       break;
    2638. 

  2638.     case 8:
    2639. 

  2639.       filterFunction = Simple2x32;
    2640. 

  2640.       break;
    2641. 

  2641.     case 9:
    2642. 

  2642.       filterFunction = Bilinear32;
    2643. 

  2643.       break;
    2644. 

  2644.     case 10:
    2645. 

  2645.       filterFunction = BilinearPlus32;
    2646. 

  2646.       break;
    2647. 

  2647.     case 11:
    2648. 

  2648.       filterFunction = Scanlines32;
    2649. 

  2649.       break;
    2650. 

  2650.     case 12:
    2651. 

  2651.       filterFunction = hq2x32;
    2652. 

  2652.       break;
    2653. 

  2653.     case 13:
    2654. 

  2654.       filterFunction = lq2x32;
    2655. 

  2655.       break;
    2656. 

  2656.     default:
    2657. 

  2657.       filterFunction = NULL;
    2658. 

  2658.       break;
    2659. 

  2659.     }
    2660. 

  2660.   }
    2661. 

  2661.   
    2662. 

  2662.   if(systemColorDepth == 16) {
    2663. 

  2663.     switch(ifbType) {
    2664. 

  2664.     case 0:
    2665. 

  2665.     default:
    2666. 

  2666.       ifbFunction = NULL;
    2667. 

  2667.       break;
    2668. 

  2668.     case 1:
    2669. 

  2669.       ifbFunction = MotionBlurIB;
    2670. 

  2670.       break;
    2671. 

  2671.     case 2:
    2672. 

  2672.       ifbFunction = SmartIB;
    2673. 

  2673.       break;
    2674. 

  2674.     }
    2675. 

  2675.   } else if(systemColorDepth == 32) {
    2676. 

  2676.     switch(ifbType) {
    2677. 

  2677.     case 0:
    2678. 

  2678.     default:
    2679. 

  2679.       ifbFunction = NULL;
    2680. 

  2680.       break;
    2681. 

  2681.     case 1:
    2682. 

  2682.       ifbFunction = MotionBlurIB32;
    2683. 

  2683.       break;
    2684. 

  2684.     case 2:
    2685. 

  2685.       ifbFunction = SmartIB32;
    2686. 

  2686.       break;
    2687. 

  2687.     }
    2688. 

  2688.   } else
    2689. 

  2689.     ifbFunction = NULL;
    2690. 

  2690. 

  2691.   if(delta == NULL) {
    2692. 

  2692.     delta = (u8*)malloc(322*242*4);
    2693. 

  2693.     memset(delta, 255, 322*242*4);
    2694. 

  2694.   }
    2695. 

  2695. 

  2696.   if(!soundOffFlag)
    2697. 

  2697.     soundInit();
    2698. 

  2698. 

  2699.   // kanzure: trying to fix throttling
    2700. 

  2700.   //autoFrameSkipLastTime = throttleLastTime = systemGetClock();
    2701. 

  2701.   //printf("RLM: and now for the movie part!\n");
    2702. 

  2702. 

  2703.   switch(useMovie)
    2704. 

  2704.   {
    2705. 

  2705.     case 1: // --recordMovie
    2706. 

  2706.       VBAMovieCreate(movieFileName,
    2707. 

  2707.         /*authorInfo*/"",
    2708. 

  2708.         /*startFlags*/0,
    2709. 

  2709.         /*controllerFlags*/MOVIE_CONTROLLER(0),
    2710. 

  2710.         /*typeFlags*/(systemCartridgeType==IMAGE_GBA)?(MOVIE_TYPE_GBA):(GBC_CAPABLE?MOVIE_TYPE_GBC:MOVIE_TYPE_SGB));
    2711. 

  2711. 	  break;
    2712. 

  2712.     case 2: // --playMovie
    2713. 

  2713.       VBAMovieOpen(movieFileName, false);
    2714. 

  2714.   	  break;
    2715. 

  2715.     case 3: // --watchMovie
    2716. 

  2716.       VBAMovieOpen(movieFileName, true);
    2717. 

  2717.   	  break;
    2718. 

  2718.     default:
    2719. 

  2719.     	sdlReadBattery();
    2720. 

  2720.   	  break;
    2721. 

  2721.   }
    2722. 

  2722.   //printf("RLM: still alive after movie switch\n");
    2723. 

  2723.   SDL_WM_SetCaption("VisualBoyAdvance", NULL);
    2724. 

  2724.   
    2725. 

  2725.   char *moviefile = getenv("AUTODEMO");
    2726. 

  2726.   fprintf (stderr, "Checking for AUTODEMO...\n");
    2727. 

  2727.   if (moviefile)
    2728. 

  2728.   {
    2729. 

  2729.     fprintf (stderr, "I got a filename OMG!\nCalling VBAMovieOpen...\n");
    2730. 

  2730.     VBAMovieOpen(moviefile, true);
    2731. 

  2731.   }
    2732. 

  2732.   //step();
    2733. 

  2733.   return 0;
    2734. 

  2734. }
    2735. 

  2735. 

  2736. // RLM
    2737. 

  2737. int runVBA(int argc, char **argv){
    2738. 

  2738.   return main(argc, argv);
    2739. 

  2739. }
    2740. 

  2740. 

  2741. 

  2742. 

  2743. 

  2744. 

  2745. 

  2746. 

  2747. void systemMessage(int num, const char *msg, ...)
    2748. 

  2748. {
    2749. 

  2749.   char buffer[2048];
    2750. 

  2750.   va_list valist;
    2751. 

  2751.   
    2752. 

  2752.   va_start(valist, msg);
    2753. 

  2753.   vsprintf(buffer, msg, valist);
    2754. 

  2754.   
    2755. 

  2755.   fprintf(stderr, "%s\n", buffer);
    2756. 

  2756.   va_end(valist);
    2757. 

  2757. }
    2758. 

  2758. 

  2759. //On WIN32, this function messages requesting
    2760. 

  2760. //the window to be redrawn. Can this be ignored here?
    2761. 

  2761. void systemRefreshScreen(){}
    2762. 

  2762. 

  2763. void systemRenderFrame()
    2764. 

  2764. {
    2765. 

  2765.   renderedFrames++;
    2766. 

  2766.   VBAUpdateFrameCountDisplay();
    2767. 

  2767.   VBAUpdateButtonPressDisplay();
    2768. 

  2768.   
    2769. 

  2769.   if(yuv) {
    2770. 

  2770.     Draw_Overlay(surface, sizeOption+1);
    2771. 

  2771.     return;
    2772. 

  2772.   }
    2773. 

  2773.   
    2774. 

  2774.   SDL_LockSurface(surface);
    2775. 

  2775. 

  2776.   for(int slot = 0 ; slot < 8 ; slot++)
    2777. 

  2777.   {
    2778. 

  2778. 	if(screenMessage[slot]) {
    2779. 

  2779. 		if(systemCartridgeType == 1 && gbBorderOn) {
    2780. 

  2780. 			gbSgbRenderBorder();
    2781. 

  2781. 		}
    2782. 

  2782. 		if(((systemGetClock() - screenMessageTime[slot]) < screenMessageDuration[slot]) &&
    2783. 

  2783. 			!disableStatusMessages) {
    2784. 

  2784. 			drawText(pix, srcPitch, 10, srcHeight - 20*(slot+1),
    2785. 

  2785. 					screenMessageBuffer[slot]); 
    2786. 

  2786. 		} else {
    2787. 

  2787. 			screenMessage[slot] = false;
    2788. 

  2788. 		}
    2789. 

  2789. 	}
    2790. 

  2790.   }
    2791. 

  2791. 

  2792.   if(ifbFunction) {
    2793. 

  2793.     if(systemColorDepth == 16)
    2794. 

  2794.       ifbFunction(pix+destWidth+4, destWidth+4, srcWidth, srcHeight);
    2795. 

  2795.     else
    2796. 

  2796.       ifbFunction(pix+destWidth*2+4, destWidth*2+4, srcWidth, srcHeight);
    2797. 

  2797.   }
    2798. 

  2798.   
    2799. 

  2799.   if(filterFunction) {
    2800. 

  2800.     if(systemColorDepth == 16)
    2801. 

  2801.       filterFunction(pix+destWidth+4,destWidth+4, delta,
    2802. 

  2802.                      (u8*)surface->pixels,surface->pitch,
    2803. 

  2803.                      srcWidth,
    2804. 

  2804.                      srcHeight);
    2805. 

  2805.     else
    2806. 

  2806.       filterFunction(pix+destWidth*2+4,
    2807. 

  2807.                      destWidth*2+4,
    2808. 

  2808.                      delta,
    2809. 

  2809.                      (u8*)surface->pixels,
    2810. 

  2810.                      surface->pitch,
    2811. 

  2811.                      srcWidth,
    2812. 

  2812.                      srcHeight);
    2813. 

  2813.   } else {
    2814. 

  2814.     int destPitch = surface->pitch;
    2815. 

  2815.     u8 *src = pix;
    2816. 

  2816.     u8 *dest = (u8*)surface->pixels;
    2817. 

  2817.     int i;
    2818. 

  2818.     u32 *stretcher = (u32 *)sdlStretcher;
    2819. 

  2819.     if(systemColorDepth == 16)
    2820. 

  2820.       src += srcPitch;
    2821. 

  2821.     int option = sizeOption;
    2822. 

  2822.     if(yuv)
    2823. 

  2823.       option = 0;
    2824. 

  2824.     switch(sizeOption) {
    2825. 

  2825.     case 0:
    2826. 

  2826.       for(i = 0; i < srcHeight; i++) {
    2827. 

  2827.         SDL_CALL_STRETCHER;
    2828. 

  2828.         src += srcPitch;
    2829. 

  2829.         dest += destPitch;
    2830. 

  2830.       }
    2831. 

  2831.       break;
    2832. 

  2832.     case 1:
    2833. 

  2833.       for(i = 0; i < srcHeight; i++) {
    2834. 

  2834.         SDL_CALL_STRETCHER;     
    2835. 

  2835.         dest += destPitch;
    2836. 

  2836.         SDL_CALL_STRETCHER;
    2837. 

  2837.         src += srcPitch;
    2838. 

  2838.         dest += destPitch;
    2839. 

  2839.       }
    2840. 

  2840.       break;
    2841. 

  2841.     case 2:
    2842. 

  2842.       for(i = 0; i < srcHeight; i++) {
    2843. 

  2843.         SDL_CALL_STRETCHER;
    2844. 

  2844.         dest += destPitch;
    2845. 

  2845.         SDL_CALL_STRETCHER;
    2846. 

  2846.         dest += destPitch;
    2847. 

  2847.         SDL_CALL_STRETCHER;
    2848. 

  2848.         src += srcPitch;
    2849. 

  2849.         dest += destPitch;
    2850. 

  2850.       }
    2851. 

  2851.       break;
    2852. 

  2852.     case 3:
    2853. 

  2853.       for(i = 0; i < srcHeight; i++) {
    2854. 

  2854.         SDL_CALL_STRETCHER;
    2855. 

  2855.         dest += destPitch;
    2856. 

  2856.         SDL_CALL_STRETCHER;
    2857. 

  2857.         dest += destPitch;
    2858. 

  2858.         SDL_CALL_STRETCHER;
    2859. 

  2859.         dest += destPitch;
    2860. 

  2860.         SDL_CALL_STRETCHER;
    2861. 

  2861.         src += srcPitch;
    2862. 

  2862.         dest += destPitch;
    2863. 

  2863.       }
    2864. 

  2864.       break;
    2865. 

  2865.     }
    2866. 

  2866.   }
    2867. 

  2867. 

  2868.   if(showSpeed && fullscreen) {
    2869. 

  2869.     char buffer[50];
    2870. 

  2870.     if(showSpeed == 1)
    2871. 

  2871.       sprintf(buffer, "%d%%", systemSpeed);
    2872. 

  2872.     else
    2873. 

  2873.       sprintf(buffer, "%3d%%(%d, %d fps)", systemSpeed,
    2874. 

  2874.               systemFrameSkip,
    2875. 

  2875.               showRenderedFrames);
    2876. 

  2876.     if(showSpeedTransparent)
    2877. 

  2877.       drawTextTransp((u8*)surface->pixels,
    2878. 

  2878.                      surface->pitch,
    2879. 

  2879.                      10,
    2880. 

  2880.                      surface->h-20,
    2881. 

  2881.                      buffer);
    2882. 

  2882.     else
    2883. 

  2883.       drawText((u8*)surface->pixels,
    2884. 

  2884.                surface->pitch,
    2885. 

  2885.                10,
    2886. 

  2886.                surface->h-20,
    2887. 

  2887.                buffer);        
    2888. 

  2888.   }  
    2889. 

  2889. 

  2890.   SDL_UnlockSurface(surface);
    2891. 

  2891.   //  SDL_UpdateRect(surface, 0, 0, destWidth, destHeight);
    2892. 

  2892.   SDL_Flip(surface);
    2893. 

  2893. }
    2894. 

  2894. 

  2895. bool systemReadJoypads()
    2896. 

  2896. {
    2897. 

  2897.   return true;
    2898. 

  2898. }
    2899. 

  2899. 

  2900. // Kludge to make Lua call the right function.
    2901. 

  2901. u32 systemGetOriginalJoypad(int which, bool sensor){
    2902. 

  2902. 	return systemGetJoypad(which,sensor);
    2903. 

  2903. }
    2904. 

  2904. 

  2905. u32 systemGetJoypad(int which, bool sensor)
    2906. 

  2906. {
    2907. 

  2907.     sensorOn = sensor;
    2908. 

  2908.   if(which < 0 || which > 3)
    2909. 

  2909.     which = sdlDefaultJoypad;
    2910. 

  2910.   
    2911. 

  2911.   //VBAMovieUpdate(which);
    2912. 

  2912.   //VBAMovieUpdateState();
    2913. 

  2913.   u32 res = 0;
    2914. 

  2914.   
    2915. 

  2915.   //----------------------------//
    2916. 

  2916.   if (VBAMoviePlaying()){
    2917. 

  2917. 	// VBAMovieRead() overwrites currentButtons[i]
    2918. 

  2918. 	VBAMovieRead(which, sensor);
    2919. 

  2919. 	res = currentButtons[which];
    2920. 

  2920. 	return res;
    2921. 

  2921.   }  
    2922. 

  2922.   //---------------------------//
    2923. 

  2923.   //Temporary implementation, not sure if it's correct --Felipe
    2924. 

  2924.   
    2925. 

  2925.   /*
    2926. 

  2926.   if(sdlButtons[which][KEY_BUTTON_A])
    2927. 

  2927.     res |= BUTTON_MASK_A;
    2928. 

  2928.   if(sdlButtons[which][KEY_BUTTON_B])
    2929. 

  2929.     res |= BUTTON_MASK_B;
    2930. 

  2930.   if(sdlButtons[which][KEY_BUTTON_SELECT])
    2931. 

  2931.     res |= BUTTON_MASK_SELECT;
    2932. 

  2932.   if(sdlButtons[which][KEY_BUTTON_START])
    2933. 

  2933.     res |= BUTTON_MASK_START;
    2934. 

  2934.   if(sdlButtons[which][KEY_RIGHT])
    2935. 

  2935.     res |= BUTTON_MASK_RIGHT;
    2936. 

  2936.   if(sdlButtons[which][KEY_LEFT])
    2937. 

  2937.     res |= BUTTON_MASK_LEFT;
    2938. 

  2938.   if(sdlButtons[which][KEY_UP])
    2939. 

  2939.     res |= BUTTON_MASK_UP;
    2940. 

  2940.   if(sdlButtons[which][KEY_DOWN])
    2941. 

  2941.     res |= BUTTON_MASK_DOWN;
    2942. 

  2942.   if(sdlButtons[which][KEY_BUTTON_R])
    2943. 

  2943.     res |= BUTTON_MASK_R;
    2944. 

  2944.   if(sdlButtons[which][KEY_BUTTON_L])
    2945. 

  2945.     res |= BUTTON_MASK_L;
    2946. 

  2946.   */
    2947. 

  2947. /*
    2948. 

  2948.   // disallow L+R or U+D of being pressed at the same time
    2949. 

  2949.   if((res & 48) == 48)
    2950. 

  2950.     res &= ~16;
    2951. 

  2951.   if((res & 192) == 192)
    2952. 

  2952.     res &= ~128;
    2953. 

  2953. */
    2954. 

  2954. 

  2955. /* if(sdlbuttons[which][KEY_BUTTON_SPEED])
    2956. 

  2956.     res |= 1024;
    2957. 

  2957.   if(sdlButtons[which][KEY_BUTTON_CAPTURE])
    2958. 

  2958.     res |= 2048;
    2959. 

  2959. */
    2960. 

  2960. 

  2961. 	res = currentButtons[which];
    2962. 

  2962. 

  2963.   if(autoFire) {
    2964. 

  2964.     res &= (~autoFire);
    2965. 

  2965.     if(autoFireToggle)
    2966. 

  2966.       res |= autoFire;
    2967. 

  2967.     autoFireToggle = !autoFireToggle;
    2968. 

  2968.   }
    2969. 

  2969. 

  2970.   //if (res) fprintf(stdout,"%x\n",res);
    2971. 

  2971.   return res;
    2972. 

  2972. }
    2973. 

  2973. 

  2974. void systemSetJoypad(int which, u32 buttons)
    2975. 

  2975. {
    2976. 

  2976.   if(which < 0 || which > 3)
    2977. 

  2977.     which = sdlDefaultJoypad;
    2978. 

  2978. /*  
    2979. 

  2979.   sdlButtons[which][KEY_BUTTON_A] = (buttons & 1) != 0;
    2980. 

  2980.   sdlButtons[which][KEY_BUTTON_B] = (buttons & 2) != 0;
    2981. 

  2981.   sdlButtons[which][KEY_BUTTON_SELECT] = (buttons & 4) != 0;
    2982. 

  2982.   sdlButtons[which][KEY_BUTTON_START] = (buttons & 8) != 0;
    2983. 

  2983.   sdlButtons[which][KEY_RIGHT] = (buttons & 16) != 0;
    2984. 

  2984.   sdlButtons[which][KEY_LEFT] = (buttons & 32) != 0;
    2985. 

  2985.   sdlButtons[which][KEY_UP] = (buttons & 64) != 0;
    2986. 

  2986.   sdlButtons[which][KEY_DOWN] = (buttons & 128) != 0;
    2987. 

  2987.   sdlButtons[which][KEY_BUTTON_R] = (buttons & 256) != 0;
    2988. 

  2988.   sdlButtons[which][KEY_BUTTON_L] = (buttons & 512) != 0;
    2989. 

  2989. */
    2990. 

  2990. 	currentButtons[which]= buttons & 0x3ff;
    2991. 

  2991. }
    2992. 

  2992. 

  2993. void systemClearJoypads()
    2994. 

  2994. {
    2995. 

  2995. 	for (int i = 0; i < 4; ++i)
    2996. 

  2996. 		currentButtons[i] = 0;
    2997. 

  2997. 

  2998. 	//lastKeys = 0;
    2999. 

  2999. }
    3000. 

  3000. 

  3001. void systemSetTitle(const char *title)
    3002. 

  3002. {
    3003. 

  3003.   SDL_WM_SetCaption(title, NULL);
    3004. 

  3004. }
    3005. 

  3005. 

  3006. void systemShowSpeed(int speed)
    3007. 

  3007. {
    3008. 

  3008.   systemSpeed = speed;
    3009. 

  3009. 

  3010.   showRenderedFrames = renderedFrames;
    3011. 

  3011.   renderedFrames = 0;  
    3012. 

  3012. 

  3013.   if(!fullscreen && showSpeed) {
    3014. 

  3014.     char buffer[80];
    3015. 

  3015.     if(showSpeed == 1)
    3016. 

  3016.       sprintf(buffer, "VisualBoyAdvance-%3d%%", systemSpeed);
    3017. 

  3017.     else
    3018. 

  3018.       sprintf(buffer, "VisualBoyAdvance-%3d%%(%d, %d fps)", systemSpeed,
    3019. 

  3019.               systemFrameSkip,
    3020. 

  3020.               showRenderedFrames);
    3021. 

  3021. 

  3022.     systemSetTitle(buffer);
    3023. 

  3023.   }
    3024. 

  3024. }
    3025. 

  3025. 

  3026. // FIXME: the timing
    3027. 

  3027. void systemFrame(/*int rate*/) //Looking at System.cpp, it looks like rate should be 600
    3028. 

  3028. {
    3029. 

  3029.   u32 time = systemGetClock();  
    3030. 

  3030.   if(!wasPaused && autoFrameSkip && !throttle) {
    3031. 

  3031.     u32 diff = time - autoFrameSkipLastTime;
    3032. 

  3032.     int speed = 100;
    3033. 

  3033. 

  3034.     if(diff)
    3035. 

  3035.       speed = (1000000/600)/diff;
    3036. 

  3036.     
    3037. 

  3037.     if(speed >= 98) {
    3038. 

  3038.       frameskipadjust++;
    3039. 

  3039. 

  3040.       if(frameskipadjust >= 3) {
    3041. 

  3041.         frameskipadjust=0;
    3042. 

  3042.         if(systemFrameSkip > 0)
    3043. 

  3043.           systemFrameSkip--;
    3044. 

  3044.       }
    3045. 

  3045.     } else {
    3046. 

  3046.       if(speed  < 80)
    3047. 

  3047.         frameskipadjust -= (90 - speed)/5;
    3048. 

  3048.       else if(systemFrameSkip < 9)
    3049. 

  3049.         frameskipadjust--;
    3050. 

  3050. 

  3051.       if(frameskipadjust <= -2) {
    3052. 

  3052.         frameskipadjust += 2;
    3053. 

  3053.         if(systemFrameSkip < 9)
    3054. 

  3054.           systemFrameSkip++;
    3055. 

  3055.       }
    3056. 

  3056.     }    
    3057. 

  3057.   }
    3058. 

  3058.   if(!wasPaused && throttle) {
    3059. 

  3059.     /*if(!speedup) {
    3060. 

  3060.       u32 diff = time - throttleLastTime;
    3061. 

  3061.       
    3062. 

  3062.       int target = (1000000.0/(600*throttle));
    3063. 

  3063.       int d = (target - diff);
    3064. 

  3064.       
    3065. 

  3065.       if(d > 0) {
    3066. 

  3066.         SDL_Delay(d);
    3067. 

  3067.       }
    3068. 

  3068.     }
    3069. 

  3069.     throttleLastTime = systemGetClock();
    3070. 

  3070.     */
    3071. 

  3071.   }
    3072. 

  3072.   if(rewindMemory) {
    3073. 

  3073.     if(++rewindCounter >= rewindTimer) {
    3074. 

  3074.       rewindSaveNeeded = true;
    3075. 

  3075.       rewindCounter = 0;
    3076. 

  3076.     }
    3077. 

  3077.   }
    3078. 

  3078. 

  3079.   if(systemSaveUpdateCounter) {
    3080. 

  3080.     if(--systemSaveUpdateCounter <= SYSTEM_SAVE_NOT_UPDATED) {
    3081. 

  3081.       sdlWriteBattery();
    3082. 

  3082.       systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
    3083. 

  3083.     }
    3084. 

  3084.   }
    3085. 

  3085. 

  3086.   wasPaused = false;
    3087. 

  3087.   autoFrameSkipLastTime = time;
    3088. 

  3088. }
    3089. 

  3089. 

  3090. int systemFramesToSkip(){
    3091. 

  3091. 	return systemFrameSkip;
    3092. 

  3092. }
    3093. 

  3093. 

  3094. int systemScreenCapture(int a)
    3095. 

  3095. {
    3096. 

  3096.   char buffer[2048];
    3097. 

  3097. 

  3098.   if(captureFormat) {
    3099. 

  3099.     if(captureDir[0])
    3100. 

  3100.       sprintf(buffer, "%s/%s%02d.bmp", captureDir, sdlGetFilename(filename), a);
    3101. 

  3101.     else
    3102. 

  3102.       sprintf(buffer, "%s%02d.bmp", filename, a);
    3103. 

  3103. 

  3104.     theEmulator.emuWriteBMP(buffer);
    3105. 

  3105.   } else {
    3106. 

  3106.     if(captureDir[0])
    3107. 

  3107.       sprintf(buffer, "%s/%s%02d.png", captureDir, sdlGetFilename(filename), a);
    3108. 

  3108.     else
    3109. 

  3109.       sprintf(buffer, "%s%02d.png", filename, a);
    3110. 

  3110.     theEmulator.emuWritePNG(buffer);
    3111. 

  3111.   }
    3112. 

  3112. 

  3113.   systemScreenMessage("Screen capture");
    3114. 

  3114.   return a;
    3115. 

  3115. }
    3116. 

  3116. 

  3117. void soundCallback(void *,u8 *stream,int len){}
    3118. 

  3118. 

  3119. 

  3120. int writeCounter = 0;
    3121. 

  3121. u8 soundCopyBuffer[1470 * 2];
    3122. 

  3122. 

  3123. 

  3124. 

  3125. void systemSoundWriteToBuffer(){
    3126. 

  3126.   //printf("sound write counter (len) : %07d (%d)\n", 
    3127. 

  3127.   //writeCounter++, soundBufferLen);
    3128. 

  3128.   //int i;
    3129. 

  3129.   //u8* soundBytes = (u8*) soundFinalWave;
    3130. 

  3130.   //for (i = 0; i <   1470 * 2; i++){
    3131. 

  3131.   //  soundCopyBuffer[i] = soundBytes[i];
    3132. 

  3132.   //}
    3133. 

  3133.   soundDriver->write(soundFinalWave, soundBufferLen);  
    3134. 

  3134. }
    3135. 

  3135. 

  3136. 

  3137. void systemSoundClearBuffer()
    3138. 

  3138. {
    3139. 

  3139. 	SDL_mutexP(mutex);
    3140. 

  3140. 	memset(sdlBuffer,0,soundBufferTotalLen);
    3141. 

  3141. 	sdlSoundLen=0;
    3142. 

  3142. 	printf("Hi\n");
    3143. 

  3143. 	SDL_mutexV(mutex);
    3144. 

  3144. }
    3145. 

  3145. 

  3146. bool systemSoundInit(){
    3147. 

  3147. 	systemSoundShutdown();
    3148. 

  3148. 	soundDriver = new SoundSDL();
    3149. 

  3149. 	if ( !soundDriver )
    3150. 

  3150. 		return false;
    3151. 

  3151. 

  3152. 	if (!soundDriver->init()) //<-- sound sample rate
    3153. 

  3153. 		return false;
    3154. 

  3154. 	
    3155. 

  3155. 	if (!(soundDriver->setThrottle(throttle))){
    3156. 

  3156.         	fprintf(stderr,"Failed to set desired throttle, defaulting to 100 %%.\n");
    3157. 

  3157.         	if (!soundDriver->setThrottle(100)) return false;
    3158. 

  3158.         }
    3159. 

  3159. 	soundPaused = true;
    3160. 

  3160. 	systemSoundOn = true;
    3161. 

  3161. 	return true;
    3162. 

  3162. }
    3163. 

  3163. 

  3164. void systemSoundShutdown(){
    3165. 

  3165. 	if (soundDriver)
    3166. 

  3166. 	{
    3167. 

  3167. 		delete soundDriver;
    3168. 

  3168. 		soundDriver = 0;
    3169. 

  3169. 	}
    3170. 

  3170. }
    3171. 

  3171. 

  3172. void systemSoundPause()
    3173. 

  3173. {
    3174. 

  3174.   SDL_PauseAudio(1);
    3175. 

  3175. }
    3176. 

  3176. 

  3177. void systemSoundResume()
    3178. 

  3178. {
    3179. 

  3179.   SDL_PauseAudio(0);
    3180. 

  3180. }
    3181. 

  3181. 

  3182. void systemSoundReset()
    3183. 

  3183. {
    3184. 

  3184. }
    3185. 

  3185. 

  3186. u32 systemGetClock()
    3187. 

  3187. {
    3188. 

  3188.   return SDL_GetTicks();
    3189. 

  3189. }
    3190. 

  3190. 

  3191. void systemUpdateMotionSensor()
    3192. 

  3192. {
    3193. 

  3193.   if(sdlMotionButtons[KEY_LEFT]) {
    3194. 

  3194.     sensorX += 3;
    3195. 

  3195.     if(sensorX > 2197)
    3196. 

  3196.       sensorX = 2197;
    3197. 

  3197.     if(sensorX < 2047)
    3198. 

  3198.       sensorX = 2057;
    3199. 

  3199.   } else if(sdlMotionButtons[KEY_RIGHT]) {
    3200. 

  3200.     sensorX -= 3;
    3201. 

  3201.     if(sensorX < 1897)
    3202. 

  3202.       sensorX = 1897;
    3203. 

  3203.     if(sensorX > 2047)
    3204. 

  3204.       sensorX = 2037;
    3205. 

  3205.   } else if(sensorX > 2047) {
    3206. 

  3206.     sensorX -= 2;
    3207. 

  3207.     if(sensorX < 2047)
    3208. 

  3208.       sensorX = 2047;
    3209. 

  3209.   } else {
    3210. 

  3210.     sensorX += 2;
    3211. 

  3211.     if(sensorX > 2047)
    3212. 

  3212.       sensorX = 2047;
    3213. 

  3213.   }
    3214. 

  3214. 

  3215.   if(sdlMotionButtons[KEY_UP]) {
    3216. 

  3216.     sensorY += 3;
    3217. 

  3217.     if(sensorY > 2197)
    3218. 

  3218.       sensorY = 2197;
    3219. 

  3219.     if(sensorY < 2047)
    3220. 

  3220.       sensorY = 2057;
    3221. 

  3221.   } else if(sdlMotionButtons[KEY_DOWN]) {
    3222. 

  3222.     sensorY -= 3;
    3223. 

  3223.     if(sensorY < 1897)
    3224. 

  3224.       sensorY = 1897;
    3225. 

  3225.     if(sensorY > 2047)
    3226. 

  3226.       sensorY = 2037;
    3227. 

  3227.   } else if(sensorY > 2047) {
    3228. 

  3228.     sensorY -= 2;
    3229. 

  3229.     if(sensorY < 2047)
    3230. 

  3230.       sensorY = 2047;
    3231. 

  3231.   } else {
    3232. 

  3232.     sensorY += 2;
    3233. 

  3233.     if(sensorY > 2047)
    3234. 

  3234.       sensorY = 2047;
    3235. 

  3235.   }    
    3236. 

  3236. }
    3237. 

  3237. 

  3238. void systemResetSensor()
    3239. 

  3239. {
    3240. 

  3240. 	sensorX = sensorY = INITIAL_SENSOR_VALUE;
    3241. 

  3241. }
    3242. 

  3242. 

  3243. int systemGetSensorX()
    3244. 

  3244. {
    3245. 

  3245.   return sensorX;
    3246. 

  3246. }
    3247. 

  3247. 

  3248. int systemGetSensorY()
    3249. 

  3249. {
    3250. 

  3250.   return sensorY;
    3251. 

  3251. }
    3252. 

  3252. 

  3253. void systemGbPrint(u8 *data,int pages,int feed,int palette, int contrast)
    3254. 

  3254. {
    3255. 

  3255. }
    3256. 

  3256. 

  3257. void systemScreenMessage(const char *msg, int slot, int duration, const char *colorList)
    3258. 

  3258. {
    3259. 

  3259.   screenMessage[slot] = true;
    3260. 

  3260.   screenMessageTime[slot] = systemGetClock();
    3261. 

  3261.   screenMessageDuration[slot] = duration;
    3262. 

  3262.   if(strlen(msg) > 20) {
    3263. 

  3263.     strncpy(screenMessageBuffer[slot], msg, 20);
    3264. 

  3264.     screenMessageBuffer[slot][20] = 0;
    3265. 

  3265.   } else
    3266. 

  3266.     strcpy(screenMessageBuffer[slot], msg);  
    3267. 

  3267. }
    3268. 

  3268. 

  3269. bool systemSoundCanChangeQuality()
    3270. 

  3270. {
    3271. 

  3271.   return false;
    3272. 

  3272. }
    3273. 

  3273. 

  3274. bool systemSoundSetQuality(int quality)
    3275. 

  3275. {
    3276. 

  3276. 	if (systemCartridgeType == 0)
    3277. 

  3277. 		soundSetQuality(quality);
    3278. 

  3278. 	else
    3279. 

  3279. 		gbSoundSetQuality(quality);
    3280. 

  3280. 

  3281. 	return true;
    3282. 

  3282. }
    3283. 

  3283. 

  3284. bool systemPauseOnFrame()
    3285. 

  3285. {
    3286. 

  3286.   if(pauseNextFrame) {
    3287. 

  3287.     paused = true;
    3288. 

  3288.     pauseNextFrame = false;
    3289. 

  3289.     return true;
    3290. 

  3290.   }
    3291. 

  3291.   return false;
    3292. 

  3292. }
    3293. 

  3293. 

  3294. // Code donated by Niels Wagenaar (BoycottAdvance)
    3295. 

  3295. 

  3296. // GBA screensize.
    3297. 

  3297. #define GBA_WIDTH   240
    3298. 

  3298. #define GBA_HEIGHT  160
    3299. 

  3299. 

  3300. void Init_Overlay(SDL_Surface *gbascreen, int overlaytype)
    3301. 

  3301. {
    3302. 

  3302.   
    3303. 

  3303.   overlay = SDL_CreateYUVOverlay( GBA_WIDTH,
    3304. 

  3304.                                   GBA_HEIGHT,
    3305. 

  3305.                                   overlaytype, gbascreen);
    3306. 

  3306.   fprintf(stderr, "Created %dx%dx%d %s %s overlay\n",
    3307. 

  3307.           overlay->w,overlay->h,overlay->planes,
    3308. 

  3308.           overlay->hw_overlay?"hardware":"software",
    3309. 

  3309.           overlay->format==SDL_YV12_OVERLAY?"YV12":
    3310. 

  3310.           overlay->format==SDL_IYUV_OVERLAY?"IYUV":
    3311. 

  3311.           overlay->format==SDL_YUY2_OVERLAY?"YUY2":
    3312. 

  3312.           overlay->format==SDL_UYVY_OVERLAY?"UYVY":
    3313. 

  3313.           overlay->format==SDL_YVYU_OVERLAY?"YVYU":
    3314. 

  3314.           "Unknown");
    3315. 

  3315. }
    3316. 

  3316. 

  3317. void Quit_Overlay(void)
    3318. 

  3318. {
    3319. 

  3319.   
    3320. 

  3320.   SDL_FreeYUVOverlay(overlay);
    3321. 

  3321. }
    3322. 

  3322. 

  3323. /* NOTE: These RGB conversion functions are not intended for speed,
    3324. 

  3324.    only as examples.
    3325. 

  3325. */
    3326. 

  3326. inline void RGBtoYUV(Uint8 *rgb, int *yuv)
    3327. 

  3327. {
    3328. 

  3328.   yuv[0] = (int)((0.257 * rgb[0]) + (0.504 * rgb[1]) + (0.098 * rgb[2]) + 16);
    3329. 

  3329.   yuv[1] = (int)(128 - (0.148 * rgb[0]) - (0.291 * rgb[1]) + (0.439 * rgb[2]));
    3330. 

  3330.   yuv[2] = (int)(128 + (0.439 * rgb[0]) - (0.368 * rgb[1]) - (0.071 * rgb[2]));
    3331. 

  3331. }
    3332. 

  3332. 

  3333. inline void ConvertRGBtoYV12(SDL_Overlay *o)
    3334. 

  3334. {
    3335. 

  3335.   int x,y;
    3336. 

  3336.   int yuv[3];
    3337. 

  3337.   Uint8 *p,*op[3];
    3338. 

  3338.   
    3339. 

  3339.   SDL_LockYUVOverlay(o);
    3340. 

  3340.   
    3341. 

  3341.   /* Black initialization */
    3342. 

  3342.   /*
    3343. 

  3343.     memset(o->pixels[0],0,o->pitches[0]*o->h);
    3344. 

  3344.     memset(o->pixels[1],128,o->pitches[1]*((o->h+1)/2));
    3345. 

  3345.     memset(o->pixels[2],128,o->pitches[2]*((o->h+1)/2));
    3346. 

  3346.   */
    3347. 

  3347.   
    3348. 

  3348.   /* Convert */
    3349. 

  3349.   for(y=0; y<160 && y<o->h; y++) {
    3350. 

  3350.     p=(Uint8 *)pix+srcPitch*y;
    3351. 

  3351.     op[0]=o->pixels[0]+o->pitches[0]*y;
    3352. 

  3352.     op[1]=o->pixels[1]+o->pitches[1]*(y/2);
    3353. 

  3353.     op[2]=o->pixels[2]+o->pitches[2]*(y/2);
    3354. 

  3354.     for(x=0; x<240 && x<o->w; x++) {
    3355. 

  3355.       RGBtoYUV(p,yuv);
    3356. 

  3356.       *(op[0]++)=yuv[0];
    3357. 

  3357.       if(x%2==0 && y%2==0) {
    3358. 

  3358.         *(op[1]++)=yuv[2];
    3359. 

  3359.         *(op[2]++)=yuv[1];
    3360. 

  3360.       }
    3361. 

  3361.       p+=4;//s->format->BytesPerPixel;
    3362. 

  3362.     }
    3363. 

  3363.   }
    3364. 

  3364.   
    3365. 

  3365.   SDL_UnlockYUVOverlay(o);
    3366. 

  3366. }
    3367. 

  3367. 

  3368. inline void ConvertRGBtoIYUV(SDL_Overlay *o)
    3369. 

  3369. {
    3370. 

  3370.   int x,y;
    3371. 

  3371.   int yuv[3];
    3372. 

  3372.   Uint8 *p,*op[3];
    3373. 

  3373.   
    3374. 

  3374.   SDL_LockYUVOverlay(o);
    3375. 

  3375.   
    3376. 

  3376.   /* Black initialization */
    3377. 

  3377.   /*
    3378. 

  3378.     memset(o->pixels[0],0,o->pitches[0]*o->h);
    3379. 

  3379.     memset(o->pixels[1],128,o->pitches[1]*((o->h+1)/2));
    3380. 

  3380.     memset(o->pixels[2],128,o->pitches[2]*((o->h+1)/2));
    3381. 

  3381.   */
    3382. 

  3382.   
    3383. 

  3383.   /* Convert */
    3384. 

  3384.   for(y=0; y<160 && y<o->h; y++) {
    3385. 

  3385.     p=(Uint8 *)pix+srcPitch*y;
    3386. 

  3386.     op[0]=o->pixels[0]+o->pitches[0]*y;
    3387. 

  3387.     op[1]=o->pixels[1]+o->pitches[1]*(y/2);
    3388. 

  3388.     op[2]=o->pixels[2]+o->pitches[2]*(y/2);
    3389. 

  3389.     for(x=0; x<240 && x<o->w; x++) {
    3390. 

  3390.       RGBtoYUV(p,yuv);
    3391. 

  3391.       *(op[0]++)=yuv[0];
    3392. 

  3392.       if(x%2==0 && y%2==0) {
    3393. 

  3393.         *(op[1]++)=yuv[1];
    3394. 

  3394.         *(op[2]++)=yuv[2];
    3395. 

  3395.       }
    3396. 

  3396.       p+=4; //s->format->BytesPerPixel;
    3397. 

  3397.     }
    3398. 

  3398.   }
    3399. 

  3399.   
    3400. 

  3400.   SDL_UnlockYUVOverlay(o);
    3401. 

  3401. }
    3402. 

  3402. 

  3403. inline void ConvertRGBtoUYVY(SDL_Overlay *o)
    3404. 

  3404. {
    3405. 

  3405.   int x,y;
    3406. 

  3406.   int yuv[3];
    3407. 

  3407.   Uint8 *p,*op;
    3408. 

  3408.   
    3409. 

  3409.   SDL_LockYUVOverlay(o);
    3410. 

  3410.   
    3411. 

  3411.   for(y=0; y<160 && y<o->h; y++) {
    3412. 

  3412.     p=(Uint8 *)pix+srcPitch*y;
    3413. 

  3413.     op=o->pixels[0]+o->pitches[0]*y;
    3414. 

  3414.     for(x=0; x<240 && x<o->w; x++) {
    3415. 

  3415.       RGBtoYUV(p,yuv);
    3416. 

  3416.       if(x%2==0) {
    3417. 

  3417.         *(op++)=yuv[1];
    3418. 

  3418.         *(op++)=yuv[0];
    3419. 

  3419.         *(op++)=yuv[2];
    3420. 

  3420.       } else
    3421. 

  3421.         *(op++)=yuv[0];
    3422. 

  3422.       
    3423. 

  3423.       p+=4; //s->format->BytesPerPixel;
    3424. 

  3424.     }
    3425. 

  3425.   }
    3426. 

  3426.   
    3427. 

  3427.   SDL_UnlockYUVOverlay(o);
    3428. 

  3428. }
    3429. 

  3429. 

  3430. inline void ConvertRGBtoYVYU(SDL_Overlay *o)
    3431. 

  3431. {
    3432. 

  3432.   int x,y;
    3433. 

  3433.   int yuv[3];
    3434. 

  3434.   Uint8 *p,*op;
    3435. 

  3435.   
    3436. 

  3436.   SDL_LockYUVOverlay(o);
    3437. 

  3437.   
    3438. 

  3438.   for(y=0; y<160 && y<o->h; y++) {
    3439. 

  3439.     p=(Uint8 *)pix+srcPitch*y;
    3440. 

  3440.     op=o->pixels[0]+o->pitches[0]*y;
    3441. 

  3441.     for(x=0; x<240 && x<o->w; x++) {
    3442. 

  3442.       RGBtoYUV(p,yuv);
    3443. 

  3443.       if(x%2==0) {
    3444. 

  3444.         *(op++)=yuv[0];
    3445. 

  3445.         *(op++)=yuv[2];
    3446. 

  3446.         op[1]=yuv[1];
    3447. 

  3447.       } else {
    3448. 

  3448.         *op=yuv[0];
    3449. 

  3449.         op+=2;
    3450. 

  3450.       }
    3451. 

  3451.       
    3452. 

  3452.       p+=4; //s->format->BytesPerPixel;
    3453. 

  3453.     }
    3454. 

  3454.   }
    3455. 

  3455.   
    3456. 

  3456.   SDL_UnlockYUVOverlay(o);
    3457. 

  3457. }
    3458. 

  3458. 

  3459. inline void ConvertRGBtoYUY2(SDL_Overlay *o)
    3460. 

  3460. {
    3461. 

  3461.   int x,y;
    3462. 

  3462.   int yuv[3];
    3463. 

  3463.   Uint8 *p,*op;
    3464. 

  3464.   
    3465. 

  3465.   SDL_LockYUVOverlay(o);
    3466. 

  3466.   
    3467. 

  3467.   for(y=0; y<160 && y<o->h; y++) {
    3468. 

  3468.     p=(Uint8 *)pix+srcPitch*y;
    3469. 

  3469.     op=o->pixels[0]+o->pitches[0]*y;
    3470. 

  3470.     for(x=0; x<240 && x<o->w; x++) {
    3471. 

  3471.       RGBtoYUV(p,yuv);
    3472. 

  3472.       if(x%2==0) {
    3473. 

  3473.         *(op++)=yuv[0];
    3474. 

  3474.         *(op++)=yuv[1];
    3475. 

  3475.         op[1]=yuv[2];
    3476. 

  3476.       } else {
    3477. 

  3477.         *op=yuv[0];
    3478. 

  3478.         op+=2;
    3479. 

  3479.       }
    3480. 

  3480.       
    3481. 

  3481.       p+=4; //s->format->BytesPerPixel;
    3482. 

  3482.     }
    3483. 

  3483.   }
    3484. 

  3484.   
    3485. 

  3485.   SDL_UnlockYUVOverlay(o);
    3486. 

  3486. }
    3487. 

  3487. 

  3488. inline void Convert32bit(SDL_Surface *display)
    3489. 

  3489. {
    3490. 

  3490.   switch(overlay->format) {
    3491. 

  3491.   case SDL_YV12_OVERLAY:
    3492. 

  3492.     ConvertRGBtoYV12(overlay);
    3493. 

  3493.     break;
    3494. 

  3494.   case SDL_UYVY_OVERLAY:
    3495. 

  3495.     ConvertRGBtoUYVY(overlay);
    3496. 

  3496.     break;
    3497. 

  3497.   case SDL_YVYU_OVERLAY:
    3498. 

  3498.     ConvertRGBtoYVYU(overlay);
    3499. 

  3499.     break;
    3500. 

  3500.   case SDL_YUY2_OVERLAY:
    3501. 

  3501.     ConvertRGBtoYUY2(overlay);
    3502. 

  3502.     break;
    3503. 

  3503.   case SDL_IYUV_OVERLAY:
    3504. 

  3504.     ConvertRGBtoIYUV(overlay);
    3505. 

  3505.     break;
    3506. 

  3506.   default:
    3507. 

  3507.     fprintf(stderr, "cannot convert RGB picture to obtained YUV format!\n");
    3508. 

  3508.     exit(1);
    3509. 

  3509.     break;
    3510. 

  3510.   }
    3511. 

  3511.   
    3512. 

  3512. }
    3513. 

  3513. 

  3514. 

  3515. inline void Draw_Overlay(SDL_Surface *display, int size)
    3516. 

  3516. {
    3517. 

  3517.   SDL_LockYUVOverlay(overlay);
    3518. 

  3518.   
    3519. 

  3519.   Convert32bit(display);
    3520. 

  3520.   
    3521. 

  3521.   overlay_rect.x = 0;
    3522. 

  3522.   overlay_rect.y = 0;
    3523. 

  3523.   overlay_rect.w = GBA_WIDTH  * size;
    3524. 

  3524.   overlay_rect.h = GBA_HEIGHT * size;
    3525. 

  3525. 

  3526.   SDL_DisplayYUVOverlay(overlay, &overlay_rect);
    3527. 

  3527.   SDL_UnlockYUVOverlay(overlay);
    3528. 

  3528. }
    3529. 

  3529. 

  3530. bool systemIsEmulating()
    3531. 

  3531. {
    3532. 

  3532. 	return emulating != 0;
    3533. 

  3533. }
    3534. 

  3534. 

  3535. void systemGbBorderOn()
    3536. 

  3536. {
    3537. 

  3537.   srcWidth = 256;
    3538. 

  3538.   srcHeight = 224;
    3539. 

  3539.   gbBorderLineSkip = 256;
    3540. 

  3540.   gbBorderColumnSkip = 48;
    3541. 

  3541.   gbBorderRowSkip = 40;
    3542. 

  3542. 

  3543.   destWidth = (sizeOption+1)*srcWidth;
    3544. 

  3544.   destHeight = (sizeOption+1)*srcHeight;
    3545. 

  3545.   
    3546. 

  3546.   surface = SDL_SetVideoMode(destWidth, destHeight, 16,
    3547. 

  3547.                              SDL_ANYFORMAT|SDL_HWSURFACE|SDL_DOUBLEBUF|
    3548. 

  3548.                              (fullscreen ? SDL_FULLSCREEN : 0));  
    3549. 

  3549. #ifndef C_CORE
    3550. 

  3550.   sdlMakeStretcher(srcWidth);
    3551. 

  3551. #else
    3552. 

  3552.   switch(systemColorDepth) {
    3553. 

  3553.   case 16:
    3554. 

  3554.     sdlStretcher = sdlStretcher16[sizeOption];
    3555. 

  3555.     break;
    3556. 

  3556.   case 24:
    3557. 

  3557.     sdlStretcher = sdlStretcher24[sizeOption];
    3558. 

  3558.     break;
    3559. 

  3559.   case 32:
    3560. 

  3560.     sdlStretcher = sdlStretcher32[sizeOption];
    3561. 

  3561.     break;
    3562. 

  3562.   default:
    3563. 

  3563.     fprintf(stderr, "Unsupported resolution: %d\n", systemColorDepth);
    3564. 

  3564.     exit(-1);
    3565. 

  3565.   }
    3566. 

  3566. #endif
    3567. 

  3567. 

  3568.   if(systemColorDepth == 16) {
    3569. 

  3569.     if(sdlCalculateMaskWidth(surface->format->Gmask) == 6) {
    3570. 

  3570.       Init_2xSaI(565);
    3571. 

  3571.       RGB_LOW_BITS_MASK = 0x821;
    3572. 

  3572.     } else {
    3573. 

  3573.       Init_2xSaI(555);
    3574. 

  3574.       RGB_LOW_BITS_MASK = 0x421;      
    3575. 

  3575.     }
    3576. 

  3576.     if(systemCartridgeType == 2) {
    3577. 

  3577.       for(int i = 0; i < 0x10000; i++) {
    3578. 

  3578.         systemColorMap16[i] = (((i >> 1) & 0x1f) << systemBlueShift) |
    3579. 

  3579.           (((i & 0x7c0) >> 6) << systemGreenShift) |
    3580. 

  3580.           (((i & 0xf800) >> 11) << systemRedShift);  
    3581. 

  3581.       }      
    3582. 

  3582.     } else {
    3583. 

  3583.       for(int i = 0; i < 0x10000; i++) {
    3584. 

  3584.         systemColorMap16[i] = ((i & 0x1f) << systemRedShift) |
    3585. 

  3585.           (((i & 0x3e0) >> 5) << systemGreenShift) |
    3586. 

  3586.           (((i & 0x7c00) >> 10) << systemBlueShift);  
    3587. 

  3587.       }
    3588. 

  3588.     }
    3589. 

  3589.     srcPitch = srcWidth * 2+4;
    3590. 

  3590.   } else {
    3591. 

  3591.     if(systemColorDepth != 32)
    3592. 

  3592.       filterFunction = NULL;
    3593. 

  3593.     RGB_LOW_BITS_MASK = 0x010101;
    3594. 

  3594.     if(systemColorDepth == 32) {
    3595. 

  3595.       Init_2xSaI(32);
    3596. 

  3596.     }
    3597. 

  3597.     for(int i = 0; i < 0x10000; i++) {
    3598. 

  3598.       systemColorMap32[i] = ((i & 0x1f) << systemRedShift) |
    3599. 

  3599.         (((i & 0x3e0) >> 5) << systemGreenShift) |
    3600. 

  3600.         (((i & 0x7c00) >> 10) << systemBlueShift);  
    3601. 

  3601.     }
    3602. 

  3602.     if(systemColorDepth == 32)
    3603. 

  3603.       srcPitch = srcWidth*4 + 4;
    3604. 

  3604.     else
    3605. 

  3605.       srcPitch = srcWidth*3;
    3606. 

  3606.   }
    3607. 

  3607. }
    3608. 

  3608. 

  3609. bool systemIsRunningGBA()
    3610. 

  3610. {
    3611. 

  3611. 	return (rom != NULL);
    3612. 

  3612. }
    3613. 

  3613. 

  3614. int systemGetDefaultJoypad()
    3615. 

  3615. {
    3616. 

  3616. 	return sdlDefaultJoypad;
    3617. 

  3617. }
    3618. 

  3618. 

  3619. bool systemIsPaused()
    3620. 

  3620. {
    3621. 

  3621. 	return paused;
    3622. 

  3622. }
    3623. 

  3623. 

  3624. void systemSetPause(bool pause)
    3625. 

  3625. {
    3626. 

  3626. 	paused = pause;
    3627. 

  3627. 	if (pause)
    3628. 

  3628. 		systemSoundPause();
    3629. 

  3629. 	else
    3630. 

  3630. 		systemSoundResume();
    3631. 

  3631. }
    3632. 

  3632. 

  3633. u16 checksumBIOS()
    3634. 

  3634. {
    3635. 

  3635. 	bool hasBIOS = false;
    3636. 

  3636. 	u8 * tempBIOS;
    3637. 

  3637. 	if(useBios)
    3638. 

  3638. 	{
    3639. 

  3639. 		tempBIOS = (u8 *)malloc(0x4000);
    3640. 

  3640. 		int size = 0x4000;
    3641. 

  3641. 		if(utilLoad(biosFileName,
    3642. 

  3642. 					utilIsGBABios,
    3643. 

  3643. 					tempBIOS,
    3644. 

  3644. 					size)) {
    3645. 

  3645. 		if(size == 0x4000)
    3646. 

  3646. 			hasBIOS = true;
    3647. 

  3647. 		}
    3648. 

  3648. 	}
    3649. 

  3649. 

  3650. 	u16 biosCheck = 0;
    3651. 

  3651. 	if(hasBIOS) {
    3652. 

  3652. 		for(int i = 0; i < 0x4000; i += 4)
    3653. 

  3653. 			biosCheck += *((u32 *)&tempBIOS[i]);
    3654. 

  3654. 		free(tempBIOS);
    3655. 

  3655. 	}
    3656. 

  3656. 

  3657. 	return biosCheck;
    3658. 

  3658. }
    3659. 

  3659. 

  3660. EmulatedSystemCounters systemCounters = {
    3661. 

  3661. 	0,	//framecount
    3662. 

  3662. 	0,	//lagcount
    3663. 

  3663. 	0,	//extracount
    3664. 

  3664. 	true,	//lagged
    3665. 

  3665. 	true	//laggedLast
    3666. 

  3666. };
    3667. 

  3667. 

  3668. void VBAOnEnteringFrameBoundary()
    3669. 

  3669. {
    3670. 

  3670.   //printf("RLM: Entering Frame Boundary\n");
    3671. 

  3671.   CallRegisteredLuaFunctions(LUACALL_AFTEREMULATION);
    3672. 

  3672. 

  3673.   if (VBALuaRunning())
    3674. 

  3674.   	{
    3675. 

  3675. 	  VBALuaFrameBoundary();
    3676. 

  3676.   	}
    3677. 

  3677. 

  3678.   //printf("RLM: Movie state update pending\n");
    3679. 

  3679.   VBAMovieUpdateState();
    3680. 

  3680.   //printf("RLM: Movie state updated\n");
    3681. 

  3681. }
    3682. 

  3682. 

  3683. void VBAOnExitingFrameBoundary()
    3684. 

  3684. {
    3685. 

  3685. 	;
    3686. 

  3686. }
    3687. 

  3687. 

  3688. 

  3689.