Mercurial > vba-clojure

     1 #include <cstdio>

     2 #include <cctype>

     3 #include <cstdlib>

     4 #include <cstring>

     5 #include <cassert>

     6 #include <algorithm>

     7 

     8 using namespace std;

     9 

    10 #ifdef HAVE_STRINGS_H

    11 #   include <strings.h>

    12 #endif

    13 

    14 #if defined(__unix) || defined(__linux) || defined(__sun) || defined(__DJGPP)

    15 #   include <unistd.h>

    16 #   include <sys/types.h>

    17 #   include <sys/stat.h>

    18 #   include <climits>

    19 #   define stricmp strcasecmp

    20 // FIXME: this is wrong, but we don't want buffer overflow

    21 #   if defined _MAX_PATH

    22 #       undef _MAX_PATH

    23 //#       define _MAX_PATH 128

    24 #       define _MAX_PATH 260

    25 #   endif

    26 #endif

    27 

    28 #ifdef WIN32

    29 #   include <io.h>

    30 #   ifndef W_OK

    31 #       define W_OK 2

    32 #   endif

    33 #   define ftruncate chsize

    34 #endif

    35 

    36 #include "movie.h"

    37 #include "System.h"

    38 #include "../gba/GBA.h"

    39 #include "../gba/GBAGlobals.h"

    40 #include "../gba/RTC.h"

    41 #include "../gb/GB.h"

    42 #include "../gb/gbGlobals.h"

    43 #include "inputGlobal.h"

    44 #include "unzip.h"

    45 #include "Util.h"

    46 

    47 #include "vbalua.h"

    48 

    49 #if (defined(WIN32) && !defined(SDL))

    50 #   include "../win32/stdafx.h"

    51 #   include "../win32/MainWnd.h"

    52 #   include "../win32/VBA.h"

    53 #   include "../win32/WinMiscUtil.h"

    54 #endif

    55 

    56 extern int emulating; // from system.cpp

    57 extern u16 currentButtons[4];     // from System.cpp

    58 extern u16 lastKeys;

    59 

    60 SMovie Movie;

    61 bool   loadingMovie = false;

    62 

    63 // probably bad idea to have so many global variables, but I hate to recompile almost everything after editing VBA.h

    64 bool autoConvertMovieWhenPlaying = false;

    65 

    66 static u16 initialInputs[4] = { 0 };

    67 

    68 static bool resetSignaled	  = false;

    69 static bool resetSignaledLast = false;

    70 

    71 static int prevEmulatorType, prevBorder, prevWinBorder, prevBorderAuto;

    72 

    73 // little-endian integer pop/push functions:

    74 static inline uint32 Pop32(const uint8 * &ptr)

    75 {

    76   uint32 v = (ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24));

    77   ptr += 4;

    78   return v;

    79 }

    80 

    81 static inline uint16 Pop16(const uint8 * &ptr) /* const version */

    82 {

    83   uint16 v = (ptr[0] | (ptr[1] << 8));

    84   ptr += 2;

    85   return v;

    86 }

    87 

    88 static inline uint16 Pop16(uint8 * &ptr) /* non-const version */

    89 {

    90   uint16 v = (ptr[0] | (ptr[1] << 8));

    91   ptr += 2;

    92   return v;

    93 }

    94 

    95 static inline uint8 Pop8(const uint8 * &ptr)

    96 {

    97   return *(ptr)++;

    98 }

    99 

   100 static inline void Push32(uint32 v, uint8 * &ptr)

   101 {

   102   ptr[0] = (uint8)(v & 0xff);

   103   ptr[1] = (uint8)((v >> 8) & 0xff);

   104   ptr[2] = (uint8)((v >> 16) & 0xff);

   105   ptr[3] = (uint8)((v >> 24) & 0xff);

   106   ptr	  += 4;

   107 }

   108 

   109 static inline void Push16(uint16 v, uint8 * &ptr)

   110 {

   111   ptr[0] = (uint8)(v & 0xff);

   112   ptr[1] = (uint8)((v >> 8) & 0xff);

   113   ptr	  += 2;

   114 }

   115 

   116 static inline void Push8(uint8 v, uint8 * &ptr)

   117 {

   118   *ptr++ = v;

   119 }

   120 

   121 // little-endian integer read/write functions:

   122 static inline uint16 Read16(const uint8 *ptr)

   123 {

   124   return ptr[0] | (ptr[1] << 8);

   125 }

   126 

   127 static inline void Write16(uint16 v, uint8 *ptr)

   128 {

   129   ptr[0] = uint8(v & 0xff);

   130   ptr[1] = uint8((v >> 8) & 0xff);

   131 }

   132 

   133 static long file_length(FILE *fp)

   134 {

   135   long cur_pos = ftell(fp);

   136   fseek(fp, 0, SEEK_END);

   137   long length = ftell(fp);

   138   fseek(fp, cur_pos, SEEK_SET);

   139   return length;

   140 }

   141 

   142 static int bytes_per_frame(SMovie &mov)

   143 {

   144   int num_controllers = 0;

   145 

   146   for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)

   147     if (mov.header.controllerFlags & MOVIE_CONTROLLER(i))

   148       ++num_controllers;

   149 

   150   return CONTROLLER_DATA_SIZE * num_controllers;

   151 }

   152 

   153 static void reserve_buffer_space(uint32 space_needed)

   154 {

   155   if (space_needed > Movie.inputBufferSize)

   156     {

   157       uint32 ptr_offset	= Movie.inputBufferPtr - Movie.inputBuffer;

   158       uint32 alloc_chunks = (space_needed - 1) / BUFFER_GROWTH_SIZE + 1;

   159       uint32 old_size     = Movie.inputBufferSize;

   160       Movie.inputBufferSize = BUFFER_GROWTH_SIZE * alloc_chunks;

   161       Movie.inputBuffer	  = (uint8 *)realloc(Movie.inputBuffer, Movie.inputBufferSize);

   162       // FIXME: this only fixes the random input problem during dma-frame-skip, but not the skip

   163       memset(Movie.inputBuffer + old_size, 0, Movie.inputBufferSize - old_size);

   164       Movie.inputBufferPtr  = Movie.inputBuffer + ptr_offset;

   165     }

   166 }

   167 

   168 static int read_movie_header(FILE *file, SMovie &movie)

   169 {

   170   assert(file != NULL);

   171   assert(VBM_HEADER_SIZE == sizeof(SMovieFileHeader)); // sanity check on the header type definition

   172 

   173   uint8 headerData [VBM_HEADER_SIZE];

   174 

   175   if (fread(headerData, 1, VBM_HEADER_SIZE, file) != VBM_HEADER_SIZE)

   176     return MOVIE_WRONG_FORMAT;  // if we failed to read in all VBM_HEADER_SIZE bytes of the header

   177 

   178   const uint8 *	  ptr	 = headerData;

   179   SMovieFileHeader &header = movie.header;

   180 

   181   header.magic = Pop32(ptr);

   182   if (header.magic != VBM_MAGIC)

   183     return MOVIE_WRONG_FORMAT;

   184 

   185   header.version = Pop32(ptr);

   186   if (header.version != VBM_VERSION)

   187     return MOVIE_WRONG_VERSION;

   188 

   189   header.uid = Pop32(ptr);

   190   header.length_frames  = Pop32(ptr) + 1;    // HACK: add 1 to the length for compatibility

   191   header.rerecord_count = Pop32(ptr);

   192 

   193   header.startFlags	   = Pop8(ptr);

   194   header.controllerFlags = Pop8(ptr);

   195   header.typeFlags	   = Pop8(ptr);

   196   header.optionFlags	   = Pop8(ptr);

   197 

   198   header.saveType		  = Pop32(ptr);

   199   header.flashSize	  = Pop32(ptr);

   200   header.gbEmulatorType = Pop32(ptr);

   201 

   202   for (int i = 0; i < 12; i++)

   203     header.romTitle[i] = Pop8(ptr);

   204 

   205   header.minorVersion = Pop8(ptr);

   206 

   207   header.romCRC = Pop8(ptr);

   208   header.romOrBiosChecksum = Pop16(ptr);

   209   header.romGameCode		 = Pop32(ptr);

   210 

   211   header.offset_to_savestate		 = Pop32(ptr);

   212   header.offset_to_controller_data = Pop32(ptr);

   213 

   214   return MOVIE_SUCCESS;

   215 }

   216 

   217 static void write_movie_header(FILE *file, const SMovie &movie)

   218 {

   219   assert(ftell(file) == 0); // we assume file points to beginning of movie file

   220 

   221   uint8  headerData [VBM_HEADER_SIZE];

   222   uint8 *ptr = headerData;

   223   const SMovieFileHeader &header = movie.header;

   224 

   225   Push32(header.magic, ptr);

   226   Push32(header.version, ptr);

   227 

   228   Push32(header.uid, ptr);

   229   Push32(header.length_frames - 1, ptr);     // HACK: reduce the length by 1 for compatibility with certain faulty old tools

   230   // like TME

   231   Push32(header.rerecord_count, ptr);

   232 

   233   Push8(header.startFlags, ptr);

   234   Push8(header.controllerFlags, ptr);

   235   Push8(header.typeFlags, ptr);

   236   Push8(header.optionFlags, ptr);

   237 

   238   Push32(header.saveType, ptr);

   239   Push32(header.flashSize, ptr);

   240   Push32(header.gbEmulatorType, ptr);

   241 

   242   for (int i = 0; i < 12; ++i)

   243     Push8(header.romTitle[i], ptr);

   244 

   245   Push8(header.minorVersion, ptr);

   246 

   247   Push8(header.romCRC, ptr);

   248   Push16(header.romOrBiosChecksum, ptr);

   249   Push32(header.romGameCode, ptr);

   250 

   251   Push32(header.offset_to_savestate, ptr);

   252   Push32(header.offset_to_controller_data, ptr);

   253 

   254   fwrite(headerData, 1, VBM_HEADER_SIZE, file);

   255 }

   256 

   257 static void flush_movie_header()

   258 {

   259   assert(Movie.file != 0 && "logical error!");

   260   if (!Movie.file)

   261     return;

   262 

   263   long originalPos = ftell(Movie.file);

   264 

   265   // (over-)write the header

   266   fseek(Movie.file, 0, SEEK_SET);

   267   write_movie_header(Movie.file, Movie);

   268 

   269   fflush(Movie.file);

   270 

   271   fseek(Movie.file, originalPos, SEEK_SET);

   272 }

   273 

   274 static void flush_movie_frames()

   275 {

   276   assert(Movie.file && "logical error!");

   277   if (!Movie.file)

   278     return;

   279 

   280   long originalPos = ftell(Movie.file);

   281 

   282   // overwrite the controller data

   283   fseek(Movie.file, Movie.header.offset_to_controller_data, SEEK_SET);

   284   fwrite(Movie.inputBuffer, 1, Movie.bytesPerFrame * Movie.header.length_frames, Movie.file);

   285 

   286   fflush(Movie.file);

   287 

   288   fseek(Movie.file, originalPos, SEEK_SET);

   289 }

   290 

   291 static void truncate_movie(long length)

   292 {

   293   // truncate movie to length

   294   // NOTE: it's certain that the savestate block is never after the

   295   //       controller data block, because the VBM format decrees it.

   296 

   297   assert(Movie.file && length >= 0);

   298   if (!Movie.file || length < 0)

   299     return;

   300 

   301   assert(Movie.header.offset_to_savestate <= Movie.header.offset_to_controller_data);

   302   if (Movie.header.offset_to_savestate > Movie.header.offset_to_controller_data)

   303     return;

   304 

   305   Movie.header.length_frames = length;

   306   flush_movie_header();

   307   const long truncLen = long(Movie.header.offset_to_controller_data + Movie.bytesPerFrame * length);

   308   if (file_length(Movie.file) != truncLen)

   309     {

   310       ftruncate(fileno(Movie.file), truncLen);

   311     }

   312 }

   313 

   314 static void remember_input_state()

   315 {

   316   for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)

   317     {

   318       if (systemCartridgeType == 0)

   319 	{

   320 	  initialInputs[i] = u16(~P1 & 0x03FF);

   321 	}

   322       else

   323 	{

   324 	  extern int32 gbJoymask[4];

   325 	  for (int i = 0; i < 4; ++i)

   326 	    initialInputs[i] = u16(gbJoymask[i] & 0xFFFF);

   327 	}

   328     }

   329 }

   330 

   331 static void change_state(MovieState new_state)

   332 {

   333 #if (defined(WIN32) && !defined(SDL))

   334   theApp.frameSearching	   = false;

   335   theApp.frameSearchSkipping = false;

   336 #endif

   337 

   338   if (new_state == MOVIE_STATE_NONE)

   339     {

   340       Movie.pauseFrame = -1;

   341 

   342       if (Movie.state == MOVIE_STATE_NONE)

   343 	return;

   344 

   345       truncate_movie(Movie.header.length_frames);

   346 

   347       fclose(Movie.file);

   348       Movie.file		   = NULL;

   349       Movie.currentFrame = 0;

   350 #if (defined(WIN32) && !defined(SDL))

   351       // undo changes to border settings

   352       {

   353 	gbBorderOn = prevBorder;

   354 	theApp.winGbBorderOn = prevWinBorder;

   355 	gbBorderAutomatic	 = prevBorderAuto;

   356 	systemGbBorderOn();

   357       }

   358 #endif

   359       gbEmulatorType = prevEmulatorType;

   360 

   361       extern int32 gbDMASpeedVersion;

   362       gbDMASpeedVersion = 1;

   363 

   364       extern int32 gbEchoRAMFixOn;

   365       gbEchoRAMFixOn = 1;

   366 

   367       gbNullInputHackTempEnabled = gbNullInputHackEnabled;

   368       

   369       if (Movie.inputBuffer)

   370 	{

   371 	  free(Movie.inputBuffer);

   372 	  Movie.inputBuffer = NULL;

   373 	}

   374       

   375     }

   376   else if (new_state == MOVIE_STATE_PLAY)

   377     {

   378       assert(Movie.file);

   379 

   380       // this would cause problems if not dealt with

   381       if (Movie.currentFrame >= Movie.header.length_frames)

   382 	{

   383 	  new_state = MOVIE_STATE_END;

   384 	  Movie.inputBufferPtr = Movie.inputBuffer + Movie.bytesPerFrame * Movie.header.length_frames;

   385 	}

   386     }

   387   else if (new_state == MOVIE_STATE_RECORD)

   388     {

   389       assert(Movie.file);

   390 

   391       // this would cause problems if not dealt with

   392       if (Movie.currentFrame > Movie.header.length_frames)

   393 	{

   394 	  new_state = MOVIE_STATE_END;

   395 	  Movie.inputBufferPtr = Movie.inputBuffer + Movie.bytesPerFrame * Movie.header.length_frames;

   396 	}

   397 

   398       fseek(Movie.file, Movie.header.offset_to_controller_data + Movie.bytesPerFrame * Movie.currentFrame, SEEK_SET);

   399     }

   400 

   401   if (new_state == MOVIE_STATE_END && Movie.state != MOVIE_STATE_END)

   402     {

   403 #if defined(SDL)		

   404       systemClearJoypads();

   405 #endif

   406       systemScreenMessage("Movie end");

   407     }

   408 

   409   Movie.state = new_state;

   410 

   411   // checking for movie end

   412   bool willPause = false;

   413 

   414   // if the movie's been set to pause at a certain frame

   415   if (Movie.state != MOVIE_STATE_NONE && Movie.pauseFrame >= 0 && Movie.currentFrame == (uint32)Movie.pauseFrame)

   416     {

   417       Movie.pauseFrame = -1;

   418       willPause		 = true;

   419     }

   420 

   421   if (Movie.state == MOVIE_STATE_END)

   422     {

   423       if (Movie.currentFrame == Movie.header.length_frames)

   424 	{

   425 #if (defined(WIN32) && !defined(SDL))

   426 	  if (theApp.movieOnEndPause)

   427 	    {

   428 	      willPause = true;

   429 	    }

   430 #else

   431 	  // SDL FIXME

   432 #endif

   433 

   434 #if (defined(WIN32) && !defined(SDL))

   435 	  switch (theApp.movieOnEndBehavior)

   436 	    {

   437 	    case 1:

   438 	      // the old behavior

   439 	      //VBAMovieRestart();

   440 	      break;

   441 	    case 2:

   442 #else

   443 	      // SDL FIXME

   444 #endif

   445 	      if (Movie.RecordedThisSession)

   446 		{

   447 		  // if user has been recording this movie since the last time it started playing,

   448 		  // they probably don't want the movie to end now during playback,

   449 		  // so switch back to recording when it reaches the end

   450 		  VBAMovieSwitchToRecording();

   451 		  systemScreenMessage("Recording resumed");

   452 		  willPause = true;

   453 		}

   454 #if (defined(WIN32) && !defined(SDL))

   455 	      break;

   456 	    case 3:

   457 	      // keep open

   458 	      break;

   459 	    case 0:

   460 	      // fall through

   461 	    default:

   462 	      // close movie

   463 	      //VBAMovieStop(false);

   464 	      break;

   465 	    }

   466 #else

   467 	  // SDL FIXME

   468 #endif

   469 	}

   470 #if 1

   471       else if (Movie.currentFrame > Movie.header.length_frames)

   472 	{

   473 #if (defined(WIN32) && !defined(SDL))

   474 	  switch (theApp.movieOnEndBehavior)

   475 	    {

   476 	    case 1:

   477 	      // FIXME: this should be delayed till the current frame ends

   478 	      VBAMovieRestart();

   479 	      break;

   480 	    case 2:

   481 	      // nothing

   482 	      break;

   483 	    case 3:

   484 	      // keep open

   485 	      break;

   486 	    case 0:

   487 	      // fall through

   488 	    default:

   489 	      // close movie

   490 	      VBAMovieStop(false);

   491 	      break;

   492 	    }

   493 #else

   494 	  // SDLFIXME

   495 #endif

   496 	}

   497 #endif

   498     } // end if (Movie.state == MOVIE_STATE_END)

   499 

   500   if (willPause)

   501     {

   502       systemSetPause(true);

   503     }

   504 }

   505 

   506 void VBAMovieInit()

   507 {

   508   memset(&Movie, 0, sizeof(Movie));

   509   Movie.state		 = MOVIE_STATE_NONE;

   510   Movie.pauseFrame = -1;

   511 

   512   resetSignaled	  = false;

   513   resetSignaledLast = false;

   514   

   515   // RLM: should probably add inputBuffer initialization here.

   516   reserve_buffer_space(90001); 

   517 }

   518 

   519 void VBAMovieGetRomInfo(const SMovie &movieInfo, char romTitle [12], uint32 &romGameCode, uint16 &checksum, uint8 &crc)

   520 {

   521   if (systemCartridgeType == 0) // GBA

   522     {

   523       extern u8 *bios, *rom;

   524       memcpy(romTitle, &rom[0xa0], 12); // GBA TITLE

   525       memcpy(&romGameCode, &rom[0xac], 4); // GBA ROM GAME CODE

   526       if ((movieInfo.header.optionFlags & MOVIE_SETTING_USEBIOSFILE) != 0)

   527 	checksum = utilCalcBIOSChecksum(bios, 4);  // GBA BIOS CHECKSUM

   528       else

   529 	checksum = 0;

   530       crc = rom[0xbd]; // GBA ROM CRC

   531     }

   532   else // non-GBA

   533     {

   534       extern u8 *gbRom;

   535       memcpy(romTitle, &gbRom[0x134], 12); // GB TITLE (note this can be 15 but is truncated to 12)

   536       romGameCode = (uint32)gbRom[0x146]; // GB ROM UNIT CODE

   537 

   538       checksum = (gbRom[0x14e] << 8) | gbRom[0x14f]; // GB ROM CHECKSUM, read from big-endian

   539       crc		 = gbRom[0x14d]; // GB ROM CRC

   540     }

   541 }

   542 

   543 #ifdef SDL

   544 static void GetBatterySaveName(char *buffer)

   545 {

   546   extern char batteryDir[2048], filename[2048];     // from SDL.cpp

   547   extern char *sdlGetFilename(char *name);     // from SDL.cpp

   548   if (batteryDir[0])

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

   550   else

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

   552 }

   553 

   554 #endif

   555 

   556 static void SetPlayEmuSettings()

   557 {

   558   prevEmulatorType = gbEmulatorType;

   559   gbEmulatorType	 = Movie.header.gbEmulatorType;

   560 

   561 #if (defined(WIN32) && !defined(SDL))

   562   //    theApp.removeIntros   = false;

   563   theApp.skipBiosFile = (Movie.header.optionFlags & MOVIE_SETTING_SKIPBIOSFILE) != 0;

   564   theApp.useBiosFile	= (Movie.header.optionFlags & MOVIE_SETTING_USEBIOSFILE) != 0;

   565 #else

   566   extern int	 saveType, sdlRtcEnable, sdlFlashSize;   // from SDL.cpp

   567   extern bool8 useBios, skipBios, removeIntros;     // from SDL.cpp

   568   useBios		 = (Movie.header.optionFlags & MOVIE_SETTING_USEBIOSFILE) != 0;

   569   skipBios	 = (Movie.header.optionFlags & MOVIE_SETTING_SKIPBIOSFILE) != 0;

   570   removeIntros = false /*(Movie.header.optionFlags & MOVIE_SETTING_REMOVEINTROS) != 0*/;

   571 #endif

   572 

   573   extern void SetPrefetchHack(bool);

   574   if (systemCartridgeType == 0)    // lag disablement applies only to GBA

   575     SetPrefetchHack((Movie.header.optionFlags & MOVIE_SETTING_LAGHACK) != 0);

   576 

   577   gbNullInputHackTempEnabled = ((Movie.header.optionFlags & MOVIE_SETTING_GBINPUTHACK) != 0);

   578 

   579   // some GB/GBC games depend on the sound rate, so just use the highest one

   580   systemSoundSetQuality(1);

   581   useOldFrameTiming = false;

   582 

   583   extern int32 gbDMASpeedVersion;

   584   if ((Movie.header.optionFlags & MOVIE_SETTING_GBCFF55FIX) != 0)

   585     gbDMASpeedVersion = 1;

   586   else

   587     gbDMASpeedVersion = 0;     // old CGB HDMA5 timing was used

   588 

   589   extern int32 gbEchoRAMFixOn;

   590   if ((Movie.header.optionFlags & MOVIE_SETTING_GBECHORAMFIX) != 0)

   591     gbEchoRAMFixOn = 1;

   592   else

   593     gbEchoRAMFixOn = 0;

   594 

   595 #if (defined(WIN32) && !defined(SDL))

   596   rtcEnable((Movie.header.optionFlags & MOVIE_SETTING_RTCENABLE) != 0);

   597   theApp.winSaveType	= Movie.header.saveType;

   598   theApp.winFlashSize = Movie.header.flashSize;

   599 

   600   prevBorder	   = gbBorderOn;

   601   prevWinBorder  = theApp.winGbBorderOn;

   602   prevBorderAuto = gbBorderAutomatic;

   603   if ((gbEmulatorType == 2 || gbEmulatorType == 5)

   604       && !theApp.hideMovieBorder) // games played in SGB mode can have a border

   605     {

   606       gbBorderOn = true;

   607       theApp.winGbBorderOn = true;

   608       gbBorderAutomatic	 = false;

   609     }

   610   else

   611     {

   612       gbBorderOn = false;

   613       theApp.winGbBorderOn = false;

   614       gbBorderAutomatic	 = false;

   615       if (theApp.hideMovieBorder)

   616 	{

   617 	  theApp.hideMovieBorder = false;

   618 	  prevBorder = false;     // it might be expected behaviour that it stays hidden after the movie

   619 	}

   620     }

   621   systemGbBorderOn();

   622 #else

   623   sdlRtcEnable = (Movie.header.optionFlags & MOVIE_SETTING_RTCENABLE) != 0;

   624   saveType	 = Movie.header.saveType;

   625   sdlFlashSize = Movie.header.flashSize;

   626 #endif

   627 }

   628 

   629 static void HardResetAndSRAMClear()

   630 {

   631 #if (defined(WIN32) && !defined(SDL))

   632   winEraseBatteryFile(); // delete the damn SRAM file and keep it from being resurrected from RAM

   633   MainWnd *temp = ((MainWnd *)theApp.m_pMainWnd);

   634   if (!temp->winFileRun(true)) // restart running the game

   635     {

   636       temp->winFileClose();

   637     }

   638 #else

   639   char fname [1024];

   640   GetBatterySaveName(fname);

   641   remove(fname);     // delete the damn SRAM file

   642 

   643   // Henceforth, emuCleanUp means "clear out SRAM"

   644   //theEmulator.emuCleanUp();     // keep it from being resurrected from RAM <--This is wrong, it'll deallocate all variables --Felipe

   645 

   646   /// FIXME the correct SDL code to call for a full restart isn't in a function yet

   647   theEmulator.emuReset(false);

   648 #endif

   649 }

   650 

   651 int VBAMovieOpen(const char *filename, bool8 read_only)

   652 {

   653   loadingMovie = true;

   654   uint8 movieReadOnly = read_only ? 1 : 0;

   655 

   656   FILE * file;

   657   STREAM stream;

   658   int	   result;

   659   int	   fn;

   660 

   661   char movie_filename[_MAX_PATH];

   662 #ifdef WIN32

   663   _fullpath(movie_filename, filename, _MAX_PATH);

   664 #else

   665   // SDL FIXME: convert to fullpath

   666   strncpy(movie_filename, filename, _MAX_PATH);

   667   movie_filename[_MAX_PATH - 1] = '\0';

   668 #endif

   669 

   670   if (movie_filename[0] == '\0')

   671     { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }

   672 

   673   if (!emulating)

   674     { loadingMovie = false; return MOVIE_UNKNOWN_ERROR; }

   675 

   676   //	bool alreadyOpen = (Movie.file != NULL && _stricmp(movie_filename, Movie.filename) == 0);

   677 

   678   //	if (alreadyOpen)

   679   change_state(MOVIE_STATE_NONE);     // have to stop current movie before trying to re-open it

   680 

   681   if (!(file = fopen(movie_filename, "rb+")))

   682     if (!(file = fopen(movie_filename, "rb")))

   683       { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }

   684   //else

   685   //	movieReadOnly = 2; // we have to open the movie twice, no need to do this both times

   686 

   687   //	if (!alreadyOpen)

   688   //		change_state(MOVIE_STATE_NONE); // stop current movie when we're able to open the other one

   689   //

   690   //	if (!(file = fopen(movie_filename, "rb+")))

   691   //		if(!(file = fopen(movie_filename, "rb")))

   692   //			{loadingMovie = false; return MOVIE_FILE_NOT_FOUND;}

   693   //		else

   694   //			movieReadOnly = 2;

   695 

   696   // clear out the current movie

   697   VBAMovieInit();

   698 

   699   // read header

   700   if ((result = read_movie_header(file, Movie)) != MOVIE_SUCCESS)

   701     {

   702       fclose(file);

   703       { loadingMovie = false; return result; }

   704     }

   705 

   706   // set emulator settings that make the movie more likely to stay synchronized

   707   SetPlayEmuSettings();

   708 

   709   //	extern bool systemLoadBIOS();

   710   //	if (!systemLoadBIOS())

   711   //	{ loadingMovie = false; return MOVIE_UNKNOWN_ERROR; }

   712 

   713   // read the metadata / author info from file

   714   fread(Movie.authorInfo, 1, MOVIE_METADATA_SIZE, file);

   715   fn = dup(fileno(file)); // XXX: why does this fail?? it returns -1 but errno == 0

   716   fclose(file);

   717 

   718   // apparently this lseek is necessary

   719   lseek(fn, Movie.header.offset_to_savestate, SEEK_SET);

   720   if (!(stream = utilGzReopen(fn, "rb")))

   721     if (!(stream = utilGzOpen(movie_filename, "rb")))

   722       { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }

   723     else

   724       fn = dup(fileno(file));

   725   // in case the above dup failed but opening the file normally doesn't fail

   726 

   727   if (Movie.header.startFlags & MOVIE_START_FROM_SNAPSHOT)

   728     {

   729       // load the snapshot

   730       result = theEmulator.emuReadStateFromStream(stream) ? MOVIE_SUCCESS : MOVIE_WRONG_FORMAT;

   731 

   732       // FIXME: Kludge for conversion

   733       remember_input_state();

   734     }

   735   else if (Movie.header.startFlags & MOVIE_START_FROM_SRAM)

   736     {

   737       // 'soft' reset:

   738       theEmulator.emuReset(false);

   739 

   740       // load the SRAM

   741       result = theEmulator.emuReadBatteryFromStream(stream) ? MOVIE_SUCCESS : MOVIE_WRONG_FORMAT;

   742     }

   743   else

   744     {

   745       HardResetAndSRAMClear();

   746     }

   747 

   748   utilGzClose(stream);

   749 

   750   if (result != MOVIE_SUCCESS)

   751     { loadingMovie = false; return result; }

   752 

   753   //	if (!(file = fopen(movie_filename, /*read_only ? "rb" :*/ "rb+"))) // want to be able to switch out of read-only later

   754   //	{

   755   //		if(!Movie.readOnly || !(file = fopen(movie_filename, "rb"))) // try read-only if failed

   756   //			return MOVIE_FILE_NOT_FOUND;

   757   //	}

   758   if (!(file = fopen(movie_filename, "rb+")))

   759     if (!(file = fopen(movie_filename, "rb")))

   760       { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }

   761     else

   762       movieReadOnly = 2;

   763 

   764   // recalculate length of movie from the file size

   765   Movie.bytesPerFrame = bytes_per_frame(Movie);

   766   fseek(file, 0, SEEK_END);

   767   long fileSize = ftell(file);

   768   Movie.header.length_frames = (fileSize - Movie.header.offset_to_controller_data) / Movie.bytesPerFrame;

   769 

   770   if (fseek(file, Movie.header.offset_to_controller_data, SEEK_SET))

   771     { fclose(file); loadingMovie = false; return MOVIE_WRONG_FORMAT; }

   772 

   773   strcpy(Movie.filename, movie_filename);

   774   Movie.file = file;

   775   Movie.inputBufferPtr	  = Movie.inputBuffer;

   776   Movie.currentFrame		  = 0;

   777   Movie.readOnly			  = movieReadOnly;

   778   Movie.RecordedThisSession = false;

   779 

   780   // read controller data

   781   uint32 to_read = Movie.bytesPerFrame * Movie.header.length_frames;

   782   reserve_buffer_space(to_read);

   783   fread(Movie.inputBuffer, 1, to_read, file);

   784 

   785   change_state(MOVIE_STATE_PLAY);

   786 

   787   char messageString[64] = "Movie ";

   788   bool converted		   = false;

   789   if (autoConvertMovieWhenPlaying)

   790     {

   791       int result = VBAMovieConvertCurrent();

   792       if (result == MOVIE_SUCCESS)

   793 	strcat(messageString, "converted and ");

   794       else if (result == MOVIE_WRONG_VERSION)

   795 	strcat(messageString, "higher revision ");

   796     }

   797 

   798   if (Movie.state == MOVIE_STATE_PLAY)

   799     strcat(messageString, "replaying ");

   800   else

   801     strcat(messageString, "finished ");

   802   if (Movie.readOnly)

   803     strcat(messageString, "(read)");

   804   else

   805     strcat(messageString, "(edit)");

   806   systemScreenMessage(messageString);

   807 

   808   VBAUpdateButtonPressDisplay();

   809   VBAUpdateFrameCountDisplay();

   810   systemRefreshScreen();

   811 

   812   { loadingMovie = false; return MOVIE_SUCCESS; }

   813 }

   814 

   815 static void SetRecordEmuSettings()

   816 {

   817   Movie.header.optionFlags = 0;

   818 #if (defined(WIN32) && !defined(SDL))

   819   if (theApp.useBiosFile)

   820     Movie.header.optionFlags |= MOVIE_SETTING_USEBIOSFILE;

   821   if (theApp.skipBiosFile)

   822     Movie.header.optionFlags |= MOVIE_SETTING_SKIPBIOSFILE;

   823   if (rtcIsEnabled())

   824     Movie.header.optionFlags |= MOVIE_SETTING_RTCENABLE;

   825   Movie.header.saveType  = theApp.winSaveType;

   826   Movie.header.flashSize = theApp.winFlashSize;

   827 #else

   828   extern int	 saveType, sdlRtcEnable, sdlFlashSize;   // from SDL.cpp

   829   extern bool8 useBios, skipBios;     // from SDL.cpp

   830   if (useBios)

   831     Movie.header.optionFlags |= MOVIE_SETTING_USEBIOSFILE;

   832   if (skipBios)

   833     Movie.header.optionFlags |= MOVIE_SETTING_SKIPBIOSFILE;

   834   if (sdlRtcEnable)

   835     Movie.header.optionFlags |= MOVIE_SETTING_RTCENABLE;

   836   Movie.header.saveType  = saveType;

   837   Movie.header.flashSize = sdlFlashSize;

   838 #endif

   839   prevEmulatorType = Movie.header.gbEmulatorType = gbEmulatorType;

   840 

   841   if (!memLagTempEnabled)

   842     Movie.header.optionFlags |= MOVIE_SETTING_LAGHACK;

   843 

   844   if (gbNullInputHackTempEnabled)

   845     Movie.header.optionFlags |= MOVIE_SETTING_GBINPUTHACK;

   846 

   847   Movie.header.optionFlags |= MOVIE_SETTING_GBCFF55FIX;

   848   extern int32 gbDMASpeedVersion;

   849   gbDMASpeedVersion = 1;

   850 

   851   Movie.header.optionFlags |= MOVIE_SETTING_GBECHORAMFIX;

   852   extern int32 gbEchoRAMFixOn;

   853   gbEchoRAMFixOn = 1;

   854 

   855   // some GB/GBC games depend on the sound rate, so just use the highest one

   856   systemSoundSetQuality(1);

   857 

   858   useOldFrameTiming = false;

   859 

   860 #if (defined(WIN32) && !defined(SDL))

   861   //    theApp.removeIntros   = false;

   862 

   863   prevBorder	   = gbBorderOn;

   864   prevWinBorder  = theApp.winGbBorderOn;

   865   prevBorderAuto = gbBorderAutomatic;

   866   if (gbEmulatorType == 2 || gbEmulatorType == 5)     // only games played in SGB mode will have a border

   867     {

   868       gbBorderOn = true;

   869       theApp.winGbBorderOn = true;

   870       gbBorderAutomatic	 = false;

   871     }

   872   else

   873     {

   874       gbBorderOn = false;

   875       theApp.winGbBorderOn = false;

   876       gbBorderAutomatic	 = false;

   877     }

   878   systemGbBorderOn();

   879 #else

   880   /// SDLFIXME

   881 #endif

   882 }

   883 

   884 uint16 VBAMovieGetCurrentInputOf(int controllerNum, bool normalOnly)

   885 {

   886   if (controllerNum < 0 || controllerNum >= MOVIE_NUM_OF_POSSIBLE_CONTROLLERS)

   887     return 0;

   888 

   889   return normalOnly ? (currentButtons[controllerNum] & BUTTON_REGULAR_MASK) : currentButtons[controllerNum];

   890 }

   891 

   892 int VBAMovieCreate(const char *filename, const char *authorInfo, uint8 startFlags, uint8 controllerFlags, uint8 typeFlags)

   893 {

   894   // make sure at least one controller is enabled

   895   if ((controllerFlags & MOVIE_CONTROLLERS_ANY_MASK) == 0)

   896     return MOVIE_WRONG_FORMAT;

   897 

   898   if (!emulating)

   899     return MOVIE_UNKNOWN_ERROR;

   900 

   901   loadingMovie = true;

   902 

   903   FILE * file;

   904   STREAM stream;

   905   int	   fn;

   906 

   907   char movie_filename [_MAX_PATH];

   908 #ifdef WIN32

   909   _fullpath(movie_filename, filename, _MAX_PATH);

   910 #else

   911   // FIXME: convert to fullpath

   912   strncpy(movie_filename, filename, _MAX_PATH);

   913   movie_filename[_MAX_PATH - 1] = '\0';

   914 #endif

   915 

   916   bool alreadyOpen = (Movie.file != NULL && stricmp(movie_filename, Movie.filename) == 0);

   917 

   918   if (alreadyOpen)

   919     change_state(MOVIE_STATE_NONE);  // have to stop current movie before trying to re-open it

   920 

   921   if (movie_filename[0] == '\0')

   922     { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }

   923 

   924   if (!(file = fopen(movie_filename, "wb")))

   925     { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }

   926 

   927   if (!alreadyOpen)

   928     change_state(MOVIE_STATE_NONE);  // stop current movie when we're able to open the other one

   929 

   930   // clear out the current movie

   931   printf("RLM: movie init\n");

   932 

   933   VBAMovieInit();

   934 

   935   // fill in the movie's header

   936   Movie.header.uid   = (uint32)time(NULL);

   937   Movie.header.magic = VBM_MAGIC;

   938   Movie.header.version		 = VBM_VERSION;

   939   Movie.header.rerecord_count	 = 0;

   940   Movie.header.length_frames	 = 0;

   941   Movie.header.startFlags		 = startFlags;

   942   Movie.header.controllerFlags = controllerFlags;

   943   Movie.header.typeFlags		 = typeFlags;

   944   Movie.header.minorVersion	 = VBM_REVISION;

   945 

   946   // set emulator settings that make the movie more likely to stay synchronized when it's later played back

   947   SetRecordEmuSettings();

   948 

   949   // set ROM and BIOS checksums and stuff

   950   VBAMovieGetRomInfo(Movie, Movie.header.romTitle, Movie.header.romGameCode, Movie.header.romOrBiosChecksum, Movie.header.romCRC);

   951 	

   952   printf("RLM: Writing movie header\n");

   953   // write the header to file

   954   write_movie_header(file, Movie);

   955 

   956   printf("RLM: setting metadata\n");

   957 

   958   // copy over the metadata / author info

   959   VBAMovieSetMetadata("________________Robert  McIntyre______________________________________________________________________________________________________________________________________________________________________________________________________________________");

   960 	

   961   printf("RLM: writing metadata\n");

   962 

   963   // write the metadata / author info to file

   964 

   965 

   966   fwrite(Movie.authorInfo, 1, sizeof(char) * MOVIE_METADATA_SIZE, file);

   967 

   968   // write snapshot or SRAM if applicable

   969   if (Movie.header.startFlags & MOVIE_START_FROM_SNAPSHOT

   970       || Movie.header.startFlags & MOVIE_START_FROM_SRAM)

   971     {

   972       Movie.header.offset_to_savestate = (uint32)ftell(file);

   973 

   974       // close the file and reopen it as a stream:

   975 

   976       fn = dup(fileno(file));

   977       fclose(file);

   978 

   979       if (!(stream = utilGzReopen(fn, "ab"))) // append mode to start at end, no seek necessary

   980 	{ loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }

   981 

   982       // write the save data:

   983       if (Movie.header.startFlags & MOVIE_START_FROM_SNAPSHOT)

   984 	{

   985 	  // save snapshot

   986 	  if (!theEmulator.emuWriteStateToStream(stream))

   987 	    {

   988 	      utilGzClose(stream);

   989 	      { loadingMovie = false; return MOVIE_UNKNOWN_ERROR; }

   990 	    }

   991 	}

   992       else if (Movie.header.startFlags & MOVIE_START_FROM_SRAM)

   993 	{

   994 	  // save SRAM

   995 	  if (!theEmulator.emuWriteBatteryToStream(stream))

   996 	    {

   997 	      utilGzClose(stream);

   998 	      { loadingMovie = false; return MOVIE_UNKNOWN_ERROR; }

   999 	    }

  1000 

  1001 	  // 'soft' reset:

  1002 	  theEmulator.emuReset(false);

  1003 	}

  1004 

  1005       utilGzClose(stream);

  1006 

  1007       // reopen the file and seek back to the end

  1008 

  1009       if (!(file = fopen(movie_filename, "rb+")))

  1010 	{ loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }

  1011 

  1012       fseek(file, 0, SEEK_END);

  1013     }

  1014   else // no snapshot or SRAM

  1015     {

  1016       HardResetAndSRAMClear();

  1017     }

  1018 

  1019   Movie.header.offset_to_controller_data = (uint32)ftell(file);

  1020 

  1021   strcpy(Movie.filename, movie_filename);

  1022   Movie.file = file;

  1023   Movie.bytesPerFrame		  = bytes_per_frame(Movie);

  1024   Movie.inputBufferPtr	  = Movie.inputBuffer;

  1025   Movie.currentFrame		  = 0;

  1026   Movie.readOnly			  = false;

  1027   Movie.RecordedThisSession = true;

  1028 

  1029   change_state(MOVIE_STATE_RECORD);

  1030 

  1031   systemScreenMessage("Recording movie...");

  1032   { loadingMovie = false; return MOVIE_SUCCESS; }

  1033 }

  1034 

  1035 void VBAUpdateButtonPressDisplay()

  1036 {

  1037   uint32 keys = currentButtons[0] & BUTTON_REGULAR_RECORDING_MASK;

  1038 

  1039   const static char KeyMap[]	 =  { 'A', 'B', 's', 'S', '>', '<', '^', 'v', 'R', 'L', '!', '?', '{', '}', 'v', '^' };

  1040   const static int  KeyOrder[] = { 5, 6, 4, 7, 0, 1, 9, 8, 3, 2, 12, 15, 13, 14, 11, 10 }; // < ^ > v   A B  L R  S s  { = } _

  1041   // ? !

  1042   char buffer[256];

  1043   sprintf(buffer, "                    ");

  1044 

  1045 #ifndef WIN32

  1046   // don't bother color-coding autofire and such

  1047   int i;

  1048   for (i = 0; i < 15; i++)

  1049     {

  1050       int j	 = KeyOrder[i];

  1051       int mask = (1 << (j));

  1052       buffer[strlen("    ") + i] = ((keys & mask) != 0) ? KeyMap[j] : ' ';

  1053     }

  1054 

  1055   systemScreenMessage(buffer, 2, -1);

  1056 #else

  1057   const bool eraseAll		= !theApp.inputDisplay;

  1058   uint32	   autoHeldKeys = eraseAll ? 0 : theApp.autoHold & BUTTON_REGULAR_RECORDING_MASK;

  1059   uint32	   autoFireKeys = eraseAll ? 0 : (theApp.autoFire | theApp.autoFire2) & BUTTON_REGULAR_RECORDING_MASK;

  1060   uint32	   pressedKeys	= eraseAll ? 0 : keys;

  1061 

  1062   char colorList[64];

  1063   memset(colorList, 1, strlen(buffer));

  1064 

  1065   if (!eraseAll)

  1066     {

  1067       for (int i = 0; i < 15; i++)

  1068 	{

  1069 	  const int  j		 = KeyOrder[i];

  1070 	  const int  mask		 = (1 << (j));

  1071 	  bool	   pressed	 = (pressedKeys  & mask) != 0;

  1072 	  const bool autoHeld	 = (autoHeldKeys & mask) != 0;

  1073 	  const bool autoFired = (autoFireKeys & mask) != 0;

  1074 	  const bool erased	 = (lastKeys & mask) != 0 && (!pressed && !autoHeld && !autoFired);

  1075 	  extern int textMethod;

  1076 	  if (textMethod != 2 && (autoHeld || (autoFired && !pressed) || erased))

  1077 	    {

  1078 	      int colorNum = 1;     // default is white

  1079 	      if (autoHeld)

  1080 		colorNum += (pressed ? 2 : 1);     // yellow if pressed, red if not

  1081 	      else if (autoFired)

  1082 		colorNum += 5;     // blue if autofired and not currently pressed

  1083 	      else if (erased)

  1084 		colorNum += 8;     // black on black

  1085 

  1086 	      colorList[strlen("    ") + i] = colorNum;

  1087 	      pressed = true;

  1088 	    }

  1089 	  buffer[strlen("    ") + i] = pressed ? KeyMap[j] : ' ';

  1090 	}

  1091     }

  1092 

  1093   lastKeys  = currentButtons[0];

  1094   lastKeys |= theApp.autoHold & BUTTON_REGULAR_RECORDING_MASK;

  1095   lastKeys |= (theApp.autoFire | theApp.autoFire2) & BUTTON_REGULAR_RECORDING_MASK;

  1096 

  1097   systemScreenMessage(buffer, 2, -1, colorList);

  1098 #endif

  1099 }

  1100 

  1101 void VBAUpdateFrameCountDisplay()

  1102 {

  1103   const int MAGICAL_NUMBER = 64;  // FIXME: this won't do any better, but only to remind you of sz issues

  1104   char	  frameDisplayString[MAGICAL_NUMBER];

  1105   char	  lagFrameDisplayString[MAGICAL_NUMBER];

  1106   char      extraCountDisplayString[MAGICAL_NUMBER];

  1107 

  1108 #if (defined(WIN32) && !defined(SDL))

  1109   if (theApp.frameCounter)

  1110 #else

  1111     /// SDL FIXME

  1112 #endif

  1113     {

  1114       switch (Movie.state)

  1115 	{

  1116 	case MOVIE_STATE_PLAY:

  1117 	case MOVIE_STATE_END:

  1118 	  {

  1119 	    sprintf(frameDisplayString, "%d / %d", Movie.currentFrame, Movie.header.length_frames);

  1120 	    if (!Movie.readOnly)

  1121 	      strcat(frameDisplayString, " (edit)");

  1122 	    break;

  1123 	  }

  1124 	case MOVIE_STATE_RECORD:

  1125 	  {

  1126 	    sprintf(frameDisplayString, "%d (record)", Movie.currentFrame);

  1127 	    break;

  1128 	  }

  1129 	default:

  1130 	  {

  1131 	    sprintf(frameDisplayString, "%d (no movie)", systemCounters.frameCount);

  1132 	    break;

  1133 	  }

  1134 	}

  1135 

  1136 #if (defined(WIN32) && !defined(SDL))

  1137       if (theApp.lagCounter)

  1138 #else

  1139 	/// SDL FIXME

  1140 #endif

  1141 	{

  1142 	  //			sprintf(lagFrameDisplayString, " %c %d", systemCounters.laggedLast ? '*' : '|', systemCounters.lagCount);

  1143 	  sprintf(lagFrameDisplayString, " | %d%s", systemCounters.lagCount, systemCounters.laggedLast ? " *" : "");

  1144 	  strcat(frameDisplayString, lagFrameDisplayString);

  1145 	}

  1146 

  1147 #if (defined(WIN32) && !defined(SDL))

  1148       if (theApp.extraCounter)

  1149 #else

  1150 	/// SDL FIXME

  1151 #endif

  1152 	{

  1153 	  sprintf(extraCountDisplayString, " | %d", systemCounters.frameCount - systemCounters.extraCount);

  1154 	  strcat(frameDisplayString, extraCountDisplayString);

  1155 	}

  1156     }

  1157 #if (defined(WIN32) && !defined(SDL))

  1158   else

  1159     {

  1160       frameDisplayString[0] = '\0';

  1161     }

  1162 #else

  1163   /// SDL FIXME

  1164 #endif

  1165   systemScreenMessage(frameDisplayString, 1, -1);

  1166 }

  1167 

  1168 // this function should only be called once every frame

  1169 void VBAMovieUpdateState()

  1170 {

  1171   ++Movie.currentFrame;

  1172   printf("RLM: inside updateState\n");

  1173   if (Movie.state == MOVIE_STATE_PLAY)

  1174     {

  1175       Movie.inputBufferPtr += Movie.bytesPerFrame;

  1176       if (Movie.currentFrame >= Movie.header.length_frames)

  1177 	{

  1178 	  // the movie ends anyway; what to do next depends on the settings

  1179 	  change_state(MOVIE_STATE_END);

  1180 	}

  1181     }

  1182   else if (Movie.state == MOVIE_STATE_RECORD)

  1183     {

  1184       printf("RLM: Movie_STATE_RECORD\n");

  1185       // use first fseek?

  1186       //TODO: THis is the problem.

  1187       if (Movie.inputBuffer){

  1188 	fwrite(Movie.inputBufferPtr, 1, Movie.bytesPerFrame, Movie.file);

  1189       }

  1190       printf("RLM: write successful.\n");

  1191       Movie.header.length_frames = Movie.currentFrame;

  1192       Movie.inputBufferPtr	 += Movie.bytesPerFrame;

  1193       Movie.RecordedThisSession = true;

  1194       flush_movie_header();

  1195     }

  1196   else if (Movie.state == MOVIE_STATE_END)

  1197     {

  1198       change_state(MOVIE_STATE_END);

  1199     }

  1200 }

  1201 

  1202 void VBAMovieRead(int i, bool /*sensor*/)

  1203 {

  1204   if (Movie.state != MOVIE_STATE_PLAY)

  1205     return;

  1206 

  1207   if (i < 0 || i >= MOVIE_NUM_OF_POSSIBLE_CONTROLLERS)

  1208     return;      // not a controller we're recognizing

  1209 

  1210   if (Movie.header.controllerFlags & MOVIE_CONTROLLER(i))

  1211     {

  1212       currentButtons[i] = Read16(Movie.inputBufferPtr + CONTROLLER_DATA_SIZE * i);

  1213     }

  1214   else

  1215     {

  1216       currentButtons[i] = 0;        // pretend the controller is disconnected

  1217     }

  1218 

  1219   if ((currentButtons[i] & BUTTON_MASK_NEW_RESET) != 0)

  1220     resetSignaled = true;

  1221 }

  1222 

  1223 void VBAMovieWrite(int i, bool /*sensor*/)

  1224 {

  1225   if (Movie.state != MOVIE_STATE_RECORD)

  1226     return;

  1227 

  1228   if (i < 0 || i >= MOVIE_NUM_OF_POSSIBLE_CONTROLLERS)

  1229     return;      // not a controller we're recognizing

  1230 

  1231   reserve_buffer_space((uint32)((Movie.inputBufferPtr - Movie.inputBuffer) + Movie.bytesPerFrame));

  1232 

  1233   if (Movie.header.controllerFlags & MOVIE_CONTROLLER(i))

  1234     {

  1235       // get the current controller data

  1236       uint16 buttonData = currentButtons[i];

  1237 

  1238       // mask away the irrelevent bits

  1239       buttonData &= BUTTON_REGULAR_MASK | BUTTON_MOTION_MASK;

  1240 

  1241       // soft-reset "button" for 1 frame if the game is reset while recording

  1242       if (resetSignaled)

  1243 	{

  1244 	  buttonData |= BUTTON_MASK_NEW_RESET;

  1245 	}

  1246 

  1247       // backward compatibility kludge

  1248       if (resetSignaledLast)

  1249 	{

  1250 	  buttonData |= BUTTON_MASK_OLD_RESET;

  1251 	}

  1252 

  1253       Write16(buttonData, Movie.inputBufferPtr + CONTROLLER_DATA_SIZE * i);

  1254 

  1255       // and for display

  1256       currentButtons[i] = buttonData;

  1257     }

  1258   else

  1259     {

  1260       // pretend the controller is disconnected (otherwise input it gives could cause desync since we're not writing it to the

  1261       // movie)

  1262       currentButtons[i] = 0;

  1263     }

  1264 }

  1265 

  1266 void VBAMovieStop(bool8 suppress_message)

  1267 {

  1268   if (Movie.state != MOVIE_STATE_NONE)

  1269     {

  1270       change_state(MOVIE_STATE_NONE);

  1271       if (!suppress_message)

  1272 	systemScreenMessage("Movie stop");

  1273     }

  1274 }

  1275 

  1276 int VBAMovieGetInfo(const char *filename, SMovie *info)

  1277 {

  1278   assert(info != NULL);

  1279   if (info == NULL)

  1280     return -1;

  1281 

  1282   FILE *	file;

  1283   int		result;

  1284   SMovie &local_movie = *info;

  1285 

  1286   memset(info, 0, sizeof(*info));

  1287   if (filename[0] == '\0')

  1288     return MOVIE_FILE_NOT_FOUND;

  1289   if (!(file = fopen(filename, "rb")))

  1290     return MOVIE_FILE_NOT_FOUND;

  1291 

  1292   // read header

  1293   if ((result = (read_movie_header(file, local_movie))) != MOVIE_SUCCESS)

  1294     {

  1295       fclose(file);

  1296       return result;

  1297     }

  1298 

  1299   // read the metadata / author info from file

  1300   fread(local_movie.authorInfo, 1, sizeof(char) * MOVIE_METADATA_SIZE, file);

  1301 

  1302   strncpy(local_movie.filename, filename, _MAX_PATH);

  1303   local_movie.filename[_MAX_PATH - 1] = '\0';

  1304 

  1305   if (Movie.file != NULL && stricmp(local_movie.filename, Movie.filename) == 0) // alreadyOpen

  1306     {

  1307       local_movie.bytesPerFrame		 = Movie.bytesPerFrame;

  1308       local_movie.header.length_frames = Movie.header.length_frames;

  1309     }

  1310   else

  1311     {

  1312       // recalculate length of movie from the file size

  1313       local_movie.bytesPerFrame = bytes_per_frame(local_movie);

  1314       fseek(file, 0, SEEK_END);

  1315       int fileSize = ftell(file);

  1316       local_movie.header.length_frames =

  1317 	(fileSize - local_movie.header.offset_to_controller_data) / local_movie.bytesPerFrame;

  1318     }

  1319 

  1320   fclose(file);

  1321 

  1322   if (access(filename, W_OK))

  1323     info->readOnly = true;

  1324 

  1325   return MOVIE_SUCCESS;

  1326 }

  1327 

  1328 bool8 VBAMovieActive()

  1329 {

  1330   return (Movie.state != MOVIE_STATE_NONE);

  1331 }

  1332 

  1333 bool8 VBAMovieLoading()

  1334 {

  1335   return loadingMovie;

  1336 }

  1337 

  1338 bool8 VBAMoviePlaying()

  1339 {

  1340   return (Movie.state == MOVIE_STATE_PLAY);

  1341 }

  1342 

  1343 bool8 VBAMovieRecording()

  1344 {

  1345   return (Movie.state == MOVIE_STATE_RECORD);

  1346 }

  1347 

  1348 bool8 VBAMovieReadOnly()

  1349 {

  1350   if (!VBAMovieActive())

  1351     return false;

  1352 

  1353   return Movie.readOnly;

  1354 }

  1355 

  1356 void VBAMovieToggleReadOnly()

  1357 {

  1358   if (!VBAMovieActive())

  1359     return;

  1360 

  1361   if (Movie.readOnly != 2)

  1362     {

  1363       Movie.readOnly = !Movie.readOnly;

  1364 

  1365       systemScreenMessage(Movie.readOnly ? "Movie now read-only" : "Movie now editable");

  1366     }

  1367   else

  1368     {

  1369       systemScreenMessage("Can't toggle read-only movie");

  1370     }

  1371 }

  1372 

  1373 uint32 VBAMovieGetVersion()

  1374 {

  1375   if (!VBAMovieActive())

  1376     return 0;

  1377 

  1378   return Movie.header.version;

  1379 }

  1380 

  1381 uint32 VBAMovieGetMinorVersion()

  1382 {

  1383   if (!VBAMovieActive())

  1384     return 0;

  1385 

  1386   return Movie.header.minorVersion;

  1387 }

  1388 

  1389 uint32 VBAMovieGetId()

  1390 {

  1391   if (!VBAMovieActive())

  1392     return 0;

  1393 

  1394   return Movie.header.uid;

  1395 }

  1396 

  1397 uint32 VBAMovieGetLength()

  1398 {

  1399   if (!VBAMovieActive())

  1400     return 0;

  1401 

  1402   return Movie.header.length_frames;

  1403 }

  1404 

  1405 uint32 VBAMovieGetFrameCounter()

  1406 {

  1407   if (!VBAMovieActive())

  1408     return 0;

  1409 

  1410   return Movie.currentFrame;

  1411 }

  1412 

  1413 uint32 VBAMovieGetRerecordCount()

  1414 {

  1415   if (!VBAMovieActive())

  1416     return 0;

  1417 

  1418   return Movie.header.rerecord_count;

  1419 }

  1420 

  1421 uint32 VBAMovieSetRerecordCount(uint32 newRerecordCount)

  1422 {

  1423   uint32 oldRerecordCount = 0;

  1424   if (!VBAMovieActive())

  1425     return 0;

  1426 

  1427   oldRerecordCount = Movie.header.rerecord_count;

  1428   Movie.header.rerecord_count = newRerecordCount;

  1429   return oldRerecordCount;

  1430 }

  1431 

  1432 std::string VBAMovieGetAuthorInfo()

  1433 {

  1434   if (!VBAMovieActive())

  1435     return "";

  1436 

  1437   return Movie.authorInfo;

  1438 }

  1439 

  1440 std::string VBAMovieGetFilename()

  1441 {

  1442   if (!VBAMovieActive())

  1443     return "";

  1444 

  1445   return Movie.filename;

  1446 }

  1447 

  1448 void VBAMovieFreeze(uint8 * *buf, uint32 *size)

  1449 {

  1450   // sanity check

  1451   if (!VBAMovieActive())

  1452     {

  1453       return;

  1454     }

  1455 

  1456   *buf  = NULL;

  1457   *size = 0;

  1458 

  1459   // compute size needed for the buffer

  1460   // room for header.uid, currentFrame, and header.length_frames

  1461   uint32 size_needed = sizeof(Movie.header.uid) + sizeof(Movie.currentFrame) + sizeof(Movie.header.length_frames);

  1462   size_needed += (uint32)(Movie.bytesPerFrame * Movie.header.length_frames);

  1463   *buf		 = new uint8[size_needed];

  1464   *size		 = size_needed;

  1465 

  1466   uint8 *ptr = *buf;

  1467   if (!ptr)

  1468     {

  1469       return;

  1470     }

  1471 

  1472   Push32(Movie.header.uid, ptr);

  1473   Push32(Movie.currentFrame, ptr);

  1474   Push32(Movie.header.length_frames - 1, ptr);   // HACK: shorten the length by 1 for backward compatibility

  1475 

  1476   memcpy(ptr, Movie.inputBuffer, Movie.bytesPerFrame * Movie.header.length_frames);

  1477 }

  1478 

  1479 int VBAMovieUnfreeze(const uint8 *buf, uint32 size)

  1480 {

  1481   // sanity check

  1482   if (!VBAMovieActive())

  1483     {

  1484       return MOVIE_NOT_FROM_A_MOVIE;

  1485     }

  1486 

  1487   const uint8 *ptr = buf;

  1488   if (size < sizeof(Movie.header.uid) + sizeof(Movie.currentFrame) + sizeof(Movie.header.length_frames))

  1489     {

  1490       return MOVIE_WRONG_FORMAT;

  1491     }

  1492 

  1493   uint32 movie_id		 = Pop32(ptr);

  1494   uint32 current_frame = Pop32(ptr);

  1495   uint32 end_frame	 = Pop32(ptr) + 1;     // HACK: restore the length for backward compatibility

  1496   uint32 space_needed	 = Movie.bytesPerFrame * end_frame;

  1497 

  1498   if (movie_id != Movie.header.uid)

  1499     return MOVIE_NOT_FROM_THIS_MOVIE;

  1500 

  1501   if (space_needed > size)

  1502     return MOVIE_WRONG_FORMAT;

  1503 

  1504   if (Movie.readOnly)

  1505     {

  1506       // here, we are going to keep the input data from the movie file

  1507       // and simply rewind to the currentFrame pointer

  1508       // this will cause a desync if the savestate is not in sync // <-- NOT ANYMORE

  1509       // with the on-disk recording data, but it's easily solved

  1510       // by loading another savestate or playing the movie from the beginning

  1511 

  1512       // don't allow loading a state inconsistent with the current movie

  1513       uint32 length_history = min(current_frame, Movie.header.length_frames);

  1514       if (end_frame < length_history)

  1515 	return MOVIE_SNAPSHOT_INCONSISTENT;

  1516 

  1517       uint32 space_shared = Movie.bytesPerFrame * length_history;

  1518       if (memcmp(Movie.inputBuffer, ptr, space_shared))

  1519 	return MOVIE_SNAPSHOT_INCONSISTENT;

  1520 

  1521       Movie.currentFrame	 = current_frame;

  1522       Movie.inputBufferPtr = Movie.inputBuffer + Movie.bytesPerFrame * min(current_frame, Movie.header.length_frames);

  1523     }

  1524   else

  1525     {

  1526       // here, we are going to take the input data from the savestate

  1527       // and make it the input data for the current movie, then continue

  1528       // writing new input data at the currentFrame pointer

  1529       Movie.currentFrame		   = current_frame;

  1530       Movie.header.length_frames = end_frame;

  1531       if (!VBALuaRerecordCountSkip())

  1532 	++Movie.header.rerecord_count;

  1533 

  1534       Movie.RecordedThisSession = true;

  1535 

  1536       // do this before calling reserve_buffer_space()

  1537       Movie.inputBufferPtr = Movie.inputBuffer + Movie.bytesPerFrame * min(current_frame, Movie.header.length_frames);

  1538       reserve_buffer_space(space_needed);

  1539       memcpy(Movie.inputBuffer, ptr, space_needed);

  1540 

  1541       // for consistency, no auto movie conversion here since we don't auto convert the corresponding savestate

  1542       flush_movie_header();

  1543       flush_movie_frames();

  1544     }

  1545 

  1546   change_state(MOVIE_STATE_PLAY);	// check for movie end

  1547 

  1548   // necessary!

  1549   resetSignaled	  = false;

  1550   resetSignaledLast = false;

  1551 

  1552   // necessary to check if there's a reset signal at the previous frame

  1553   if (current_frame > 0)

  1554     {

  1555       const u8 NEW_RESET = u8(BUTTON_MASK_NEW_RESET >> 8);

  1556       for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)

  1557 	{

  1558 	  if ((Movie.header.controllerFlags & MOVIE_CONTROLLER(i)) && (*(Movie.inputBufferPtr+1- Movie.bytesPerFrame) & NEW_RESET))

  1559 	    {

  1560 	      resetSignaledLast = true;

  1561 	      break;

  1562 	    }

  1563 	}

  1564     }

  1565 

  1566   return MOVIE_SUCCESS;

  1567 }

  1568 

  1569 bool VBAMovieEnded()

  1570 {

  1571   return (Movie.state == MOVIE_STATE_END);

  1572   //	return (Movie.state != MOVIE_STATE_NONE && Movie.currentFrame >= Movie.header.length_frames);

  1573 }

  1574 

  1575 bool VBAMovieAllowsRerecording()

  1576 {

  1577   bool allows = (Movie.state != MOVIE_STATE_NONE) && (Movie.currentFrame <= Movie.header.length_frames);

  1578   return /*!VBAMovieReadOnly() &&*/ allows;

  1579 }

  1580 

  1581 bool VBAMovieSwitchToPlaying()

  1582 {

  1583   if (!VBAMovieActive())

  1584     return false;

  1585 

  1586   if (!Movie.readOnly)

  1587     {

  1588       VBAMovieToggleReadOnly();

  1589     }

  1590 

  1591   change_state(MOVIE_STATE_PLAY);

  1592   if (Movie.state == MOVIE_STATE_PLAY)

  1593     systemScreenMessage("Movie replay (continue)");

  1594   else

  1595     systemScreenMessage("Movie end");

  1596 

  1597   return true;

  1598 }

  1599 

  1600 bool VBAMovieSwitchToRecording()

  1601 {

  1602   if (!VBAMovieAllowsRerecording())

  1603     return false;

  1604 

  1605   if (Movie.readOnly)

  1606     {

  1607       VBAMovieToggleReadOnly();

  1608     }

  1609 

  1610   if (!VBALuaRerecordCountSkip())

  1611     ++Movie.header.rerecord_count;

  1612 

  1613   change_state(MOVIE_STATE_RECORD);

  1614   systemScreenMessage("Movie re-record");

  1615 

  1616   //truncate_movie(Movie.currentFrame);

  1617 

  1618   return true;

  1619 }

  1620 

  1621 uint32 VBAMovieGetState()

  1622 {

  1623   // ?

  1624   if (!VBAMovieActive())

  1625     return MOVIE_STATE_NONE;

  1626 

  1627   return Movie.state;

  1628 }

  1629 

  1630 void VBAMovieSignalReset()

  1631 {

  1632   if (VBAMovieActive())

  1633     resetSignaled = true;

  1634 }

  1635 

  1636 void VBAMovieResetIfRequested()

  1637 {

  1638   if (resetSignaled)

  1639     {

  1640       theEmulator.emuReset(false);

  1641       resetSignaled	  = false;

  1642       resetSignaledLast = true;

  1643     }

  1644   else

  1645     {

  1646       resetSignaledLast = false;

  1647     }

  1648 }

  1649 

  1650 void VBAMovieSetMetadata(const char *info)

  1651 {

  1652   if (!memcmp(Movie.authorInfo, info, MOVIE_METADATA_SIZE))

  1653     return;

  1654 

  1655   memcpy(Movie.authorInfo, info, MOVIE_METADATA_SIZE); // strncpy would omit post-0 bytes

  1656   Movie.authorInfo[MOVIE_METADATA_SIZE - 1] = '\0';

  1657 

  1658   if (Movie.file)

  1659     {

  1660       // (over-)write the header

  1661       fseek(Movie.file, 0, SEEK_SET);

  1662 

  1663       write_movie_header(Movie.file, Movie);

  1664 

  1665       // write the metadata / author info to file

  1666       fwrite(Movie.authorInfo, 1, sizeof(char) * MOVIE_METADATA_SIZE, Movie.file);

  1667 

  1668       fflush(Movie.file);

  1669     }

  1670   printf("RLM: setMetadata called\n");

  1671 

  1672 }

  1673 

  1674 void VBAMovieRestart()

  1675 {

  1676   if (VBAMovieActive())

  1677     {

  1678       systemSoundClearBuffer();

  1679 

  1680       bool8 modified = Movie.RecordedThisSession;

  1681 

  1682       VBAMovieStop(true);

  1683 

  1684       char movieName [_MAX_PATH];

  1685       strncpy(movieName, Movie.filename, _MAX_PATH);

  1686       movieName[_MAX_PATH - 1] = '\0';

  1687       VBAMovieOpen(movieName, Movie.readOnly); // can't just pass in Movie.filename, since VBAMovieOpen clears out Movie's

  1688       // variables

  1689 

  1690       Movie.RecordedThisSession = modified;

  1691 

  1692       systemScreenMessage("Movie replay (restart)");

  1693     }

  1694 }

  1695 

  1696 int VBAMovieGetPauseAt()

  1697 {

  1698   return Movie.pauseFrame;

  1699 }

  1700 

  1701 void VBAMovieSetPauseAt(int at)

  1702 {

  1703   Movie.pauseFrame = at;

  1704 }

  1705 

  1706 ///////////////////////

  1707 // movie tools

  1708 

  1709 // FIXME: is it safe to convert/flush a movie while recording it (considering fseek() problem)?

  1710 int VBAMovieConvertCurrent()

  1711 {

  1712   if (!VBAMovieActive())

  1713     {

  1714       return MOVIE_NOTHING;

  1715     }

  1716 

  1717   if (Movie.header.minorVersion > VBM_REVISION)

  1718     {

  1719       return MOVIE_WRONG_VERSION;

  1720     }

  1721 

  1722   if (Movie.header.minorVersion == VBM_REVISION)

  1723     {

  1724       return MOVIE_NOTHING;

  1725     }

  1726 

  1727   Movie.header.minorVersion = VBM_REVISION;

  1728 

  1729   if (Movie.header.length_frames == 0) // this could happen

  1730     {

  1731       truncate_movie(0);

  1732       return MOVIE_SUCCESS;

  1733     }

  1734 

  1735   // fix movies recorded from snapshots

  1736   if (Movie.header.startFlags & MOVIE_START_FROM_SNAPSHOT)

  1737     {

  1738       uint8 *firstFramePtr = Movie.inputBuffer;

  1739       for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)

  1740 	{

  1741 	  if (Movie.header.controllerFlags & MOVIE_CONTROLLER(i))

  1742 	    {

  1743 	      Push16(initialInputs[i], firstFramePtr);

  1744 	      // note: this is correct since Push16 advances the dest pointer by sizeof u16

  1745 	    }

  1746 	}

  1747     }

  1748 

  1749   // convert old resets to new ones

  1750   const u8 OLD_RESET = u8(BUTTON_MASK_OLD_RESET >> 8);

  1751   const u8 NEW_RESET = u8(BUTTON_MASK_NEW_RESET >> 8);

  1752   for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)

  1753     {

  1754       if (Movie.header.controllerFlags & MOVIE_CONTROLLER(i))

  1755 	{

  1756 	  uint8 *startPtr = Movie.inputBuffer + sizeof(u16) * i + 1;

  1757 	  uint8 *endPtr	= Movie.inputBuffer + Movie.bytesPerFrame * (Movie.header.length_frames - 1);

  1758 	  for (; startPtr < endPtr; startPtr += Movie.bytesPerFrame)

  1759 	    {

  1760 	      if (startPtr[Movie.bytesPerFrame] & OLD_RESET)

  1761 		{

  1762 		  startPtr[0] |= NEW_RESET;

  1763 		}

  1764 	    }

  1765 	}

  1766     }

  1767 

  1768   flush_movie_header();

  1769   flush_movie_frames();

  1770   return MOVIE_SUCCESS;

  1771 }

  1772 

  1773 bool VBAMovieTuncateAtCurrentFrame()

  1774 {

  1775   if (!VBAMovieActive())

  1776     return false;

  1777 

  1778   truncate_movie(Movie.currentFrame);

  1779   change_state(MOVIE_STATE_END);

  1780   systemScreenMessage("Movie truncated");

  1781 

  1782   return true;

  1783 }

  1784 

  1785 bool VBAMovieFixHeader()

  1786 {

  1787   if (!VBAMovieActive())

  1788     return false;

  1789 

  1790   flush_movie_header();

  1791   systemScreenMessage("Movie header fixed");

  1792   return true;

  1793 }
author	Robert McIntyre <rlm@mit.edu>
date	Mon, 05 Mar 2012 14:26:45 -0600
parents	6bde5b67a2b8
children	47a513ea3529