Mercurial > vba-clojure

annotate src/common/movie.cpp @ 533:60da469773e5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
minor fix to create render dir if it does not already exist.
author Robert McIntyre <rlm@mit.edu>
date Mon, 25 Jun 2012 11:58:36 -0500
parents 3e36553d0cbf
children
rev   line source
rlm@1 1 #include <cstdio>
rlm@1 2 #include <cctype>
rlm@1 3 #include <cstdlib>
rlm@1 4 #include <cstring>
rlm@1 5 #include <cassert>
rlm@1 6 #include <algorithm>
rlm@1 7
rlm@1 8 using namespace std;
rlm@1 9
rlm@1 10 #ifdef HAVE_STRINGS_H
rlm@1 11 # include <strings.h>
rlm@1 12 #endif
rlm@1 13
rlm@1 14 #if defined(__unix) || defined(__linux) || defined(__sun) || defined(__DJGPP)
rlm@1 15 # include <unistd.h>
rlm@1 16 # include <sys/types.h>
rlm@1 17 # include <sys/stat.h>
rlm@1 18 # include <climits>
rlm@1 19 # define stricmp strcasecmp
rlm@1 20 // FIXME: this is wrong, but we don't want buffer overflow
rlm@1 21 # if defined _MAX_PATH
rlm@1 22 # undef _MAX_PATH
rlm@1 23 //# define _MAX_PATH 128
rlm@1 24 # define _MAX_PATH 260
rlm@1 25 # endif
rlm@1 26 #endif
rlm@1 27
rlm@1 28 #ifdef WIN32
rlm@1 29 # include <io.h>
rlm@1 30 # ifndef W_OK
rlm@1 31 # define W_OK 2
rlm@1 32 # endif
rlm@1 33 # define ftruncate chsize
rlm@1 34 #endif
rlm@1 35
rlm@1 36 #include "movie.h"
rlm@1 37 #include "System.h"
rlm@1 38 #include "../gba/GBA.h"
rlm@1 39 #include "../gba/GBAGlobals.h"
rlm@1 40 #include "../gba/RTC.h"
rlm@1 41 #include "../gb/GB.h"
rlm@1 42 #include "../gb/gbGlobals.h"
rlm@1 43 #include "inputGlobal.h"
rlm@1 44 #include "unzip.h"
rlm@1 45 #include "Util.h"
rlm@1 46
rlm@1 47 #include "vbalua.h"
rlm@1 48
rlm@1 49 #if (defined(WIN32) && !defined(SDL))
rlm@1 50 # include "../win32/stdafx.h"
rlm@1 51 # include "../win32/MainWnd.h"
rlm@1 52 # include "../win32/VBA.h"
rlm@1 53 # include "../win32/WinMiscUtil.h"
rlm@1 54 #endif
rlm@1 55
rlm@1 56 extern int emulating; // from system.cpp
rlm@36 57 extern u16 currentButtons[4]; // from SDL.cpp
rlm@1 58 extern u16 lastKeys;
rlm@1 59
rlm@1 60 SMovie Movie;
rlm@1 61 bool loadingMovie = false;
rlm@1 62
rlm@1 63 // probably bad idea to have so many global variables, but I hate to recompile almost everything after editing VBA.h
rlm@1 64 bool autoConvertMovieWhenPlaying = false;
rlm@1 65
rlm@36 66 static u16 initialInputs[4] = { 0, 0, 0, 0 };
rlm@1 67
rlm@1 68 static bool resetSignaled = false;
rlm@1 69 static bool resetSignaledLast = false;
rlm@1 70
rlm@1 71 static int prevEmulatorType, prevBorder, prevWinBorder, prevBorderAuto;
rlm@1 72
rlm@1 73 // little-endian integer pop/push functions:
rlm@1 74 static inline uint32 Pop32(const uint8 * &ptr)
rlm@1 75 {
rlm@33 76 uint32 v = (ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24));
rlm@33 77 ptr += 4;
rlm@33 78 return v;
rlm@1 79 }
rlm@1 80
rlm@1 81 static inline uint16 Pop16(const uint8 * &ptr) /* const version */
rlm@1 82 {
rlm@33 83 uint16 v = (ptr[0] | (ptr[1] << 8));
rlm@33 84 ptr += 2;
rlm@33 85 return v;
rlm@1 86 }
rlm@1 87
rlm@1 88 static inline uint16 Pop16(uint8 * &ptr) /* non-const version */
rlm@1 89 {
rlm@33 90 uint16 v = (ptr[0] | (ptr[1] << 8));
rlm@33 91 ptr += 2;
rlm@33 92 return v;
rlm@1 93 }
rlm@1 94
rlm@1 95 static inline uint8 Pop8(const uint8 * &ptr)
rlm@1 96 {
rlm@33 97 return *(ptr)++;
rlm@1 98 }
rlm@1 99
rlm@1 100 static inline void Push32(uint32 v, uint8 * &ptr)
rlm@1 101 {
rlm@33 102 ptr[0] = (uint8)(v & 0xff);
rlm@33 103 ptr[1] = (uint8)((v >> 8) & 0xff);
rlm@33 104 ptr[2] = (uint8)((v >> 16) & 0xff);
rlm@33 105 ptr[3] = (uint8)((v >> 24) & 0xff);
rlm@33 106 ptr += 4;
rlm@1 107 }
rlm@1 108
rlm@1 109 static inline void Push16(uint16 v, uint8 * &ptr)
rlm@1 110 {
rlm@33 111 ptr[0] = (uint8)(v & 0xff);
rlm@33 112 ptr[1] = (uint8)((v >> 8) & 0xff);
rlm@33 113 ptr += 2;
rlm@1 114 }
rlm@1 115
rlm@1 116 static inline void Push8(uint8 v, uint8 * &ptr)
rlm@1 117 {
rlm@33 118 *ptr++ = v;
rlm@1 119 }
rlm@1 120
rlm@1 121 // little-endian integer read/write functions:
rlm@1 122 static inline uint16 Read16(const uint8 *ptr)
rlm@1 123 {
rlm@33 124 return ptr[0] | (ptr[1] << 8);
rlm@1 125 }
rlm@1 126
rlm@1 127 static inline void Write16(uint16 v, uint8 *ptr)
rlm@1 128 {
rlm@33 129 ptr[0] = uint8(v & 0xff);
rlm@33 130 ptr[1] = uint8((v >> 8) & 0xff);
rlm@1 131 }
rlm@1 132
rlm@1 133 static long file_length(FILE *fp)
rlm@1 134 {
rlm@33 135 long cur_pos = ftell(fp);
rlm@33 136 fseek(fp, 0, SEEK_END);
rlm@33 137 long length = ftell(fp);
rlm@33 138 fseek(fp, cur_pos, SEEK_SET);
rlm@33 139 return length;
rlm@1 140 }
rlm@1 141
rlm@1 142 static int bytes_per_frame(SMovie &mov)
rlm@1 143 {
rlm@33 144 int num_controllers = 0;
rlm@1 145
rlm@33 146 for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)
rlm@33 147 if (mov.header.controllerFlags & MOVIE_CONTROLLER(i))
rlm@33 148 ++num_controllers;
rlm@1 149
rlm@33 150 return CONTROLLER_DATA_SIZE * num_controllers;
rlm@1 151 }
rlm@1 152
rlm@1 153 static void reserve_buffer_space(uint32 space_needed)
rlm@1 154 {
rlm@33 155 if (space_needed > Movie.inputBufferSize)
rlm@33 156 {
rlm@33 157 uint32 ptr_offset = Movie.inputBufferPtr - Movie.inputBuffer;
rlm@33 158 uint32 alloc_chunks = (space_needed - 1) / BUFFER_GROWTH_SIZE + 1;
rlm@33 159 uint32 old_size = Movie.inputBufferSize;
rlm@33 160 Movie.inputBufferSize = BUFFER_GROWTH_SIZE * alloc_chunks;
rlm@33 161 Movie.inputBuffer = (uint8 *)realloc(Movie.inputBuffer, Movie.inputBufferSize);
rlm@33 162 // FIXME: this only fixes the random input problem during dma-frame-skip, but not the skip
rlm@33 163 memset(Movie.inputBuffer + old_size, 0, Movie.inputBufferSize - old_size);
rlm@33 164 Movie.inputBufferPtr = Movie.inputBuffer + ptr_offset;
rlm@33 165 }
rlm@1 166 }
rlm@1 167
rlm@1 168 static int read_movie_header(FILE *file, SMovie &movie)
rlm@1 169 {
rlm@33 170 assert(file != NULL);
rlm@33 171 assert(VBM_HEADER_SIZE == sizeof(SMovieFileHeader)); // sanity check on the header type definition
rlm@1 172
rlm@33 173 uint8 headerData [VBM_HEADER_SIZE];
rlm@1 174
rlm@33 175 if (fread(headerData, 1, VBM_HEADER_SIZE, file) != VBM_HEADER_SIZE)
rlm@33 176 return MOVIE_WRONG_FORMAT; // if we failed to read in all VBM_HEADER_SIZE bytes of the header
rlm@1 177
rlm@33 178 const uint8 * ptr = headerData;
rlm@33 179 SMovieFileHeader &header = movie.header;
rlm@1 180
rlm@33 181 header.magic = Pop32(ptr);
rlm@33 182 if (header.magic != VBM_MAGIC)
rlm@33 183 return MOVIE_WRONG_FORMAT;
rlm@1 184
rlm@33 185 header.version = Pop32(ptr);
rlm@33 186 if (header.version != VBM_VERSION)
rlm@33 187 return MOVIE_WRONG_VERSION;
rlm@1 188
rlm@33 189 header.uid = Pop32(ptr);
rlm@33 190 header.length_frames = Pop32(ptr) + 1; // HACK: add 1 to the length for compatibility
rlm@33 191 header.rerecord_count = Pop32(ptr);
rlm@1 192
rlm@33 193 header.startFlags = Pop8(ptr);
rlm@33 194 header.controllerFlags = Pop8(ptr);
rlm@33 195 header.typeFlags = Pop8(ptr);
rlm@33 196 header.optionFlags = Pop8(ptr);
rlm@1 197
rlm@33 198 header.saveType = Pop32(ptr);
rlm@33 199 header.flashSize = Pop32(ptr);
rlm@33 200 header.gbEmulatorType = Pop32(ptr);
rlm@1 201
rlm@33 202 for (int i = 0; i < 12; i++)
rlm@33 203 header.romTitle[i] = Pop8(ptr);
rlm@1 204
rlm@33 205 header.minorVersion = Pop8(ptr);
rlm@1 206
rlm@33 207 header.romCRC = Pop8(ptr);
rlm@33 208 header.romOrBiosChecksum = Pop16(ptr);
rlm@33 209 header.romGameCode = Pop32(ptr);
rlm@1 210
rlm@33 211 header.offset_to_savestate = Pop32(ptr);
rlm@33 212 header.offset_to_controller_data = Pop32(ptr);
rlm@1 213
rlm@33 214 return MOVIE_SUCCESS;
rlm@1 215 }
rlm@1 216
rlm@1 217 static void write_movie_header(FILE *file, const SMovie &movie)
rlm@1 218 {
rlm@33 219 assert(ftell(file) == 0); // we assume file points to beginning of movie file
rlm@1 220
rlm@33 221 uint8 headerData [VBM_HEADER_SIZE];
rlm@33 222 uint8 *ptr = headerData;
rlm@33 223 const SMovieFileHeader &header = movie.header;
rlm@1 224
rlm@33 225 Push32(header.magic, ptr);
rlm@33 226 Push32(header.version, ptr);
rlm@1 227
rlm@33 228 Push32(header.uid, ptr);
rlm@33 229 Push32(header.length_frames - 1, ptr); // HACK: reduce the length by 1 for compatibility with certain faulty old tools
rlm@33 230 // like TME
rlm@33 231 Push32(header.rerecord_count, ptr);
rlm@1 232
rlm@33 233 Push8(header.startFlags, ptr);
rlm@33 234 Push8(header.controllerFlags, ptr);
rlm@33 235 Push8(header.typeFlags, ptr);
rlm@33 236 Push8(header.optionFlags, ptr);
rlm@1 237
rlm@33 238 Push32(header.saveType, ptr);
rlm@33 239 Push32(header.flashSize, ptr);
rlm@33 240 Push32(header.gbEmulatorType, ptr);
rlm@1 241
rlm@33 242 for (int i = 0; i < 12; ++i)
rlm@33 243 Push8(header.romTitle[i], ptr);
rlm@1 244
rlm@33 245 Push8(header.minorVersion, ptr);
rlm@1 246
rlm@33 247 Push8(header.romCRC, ptr);
rlm@33 248 Push16(header.romOrBiosChecksum, ptr);
rlm@33 249 Push32(header.romGameCode, ptr);
rlm@1 250
rlm@33 251 Push32(header.offset_to_savestate, ptr);
rlm@33 252 Push32(header.offset_to_controller_data, ptr);
rlm@1 253
rlm@33 254 fwrite(headerData, 1, VBM_HEADER_SIZE, file);
rlm@1 255 }
rlm@1 256
rlm@1 257 static void flush_movie_header()
rlm@1 258 {
rlm@33 259 assert(Movie.file != 0 && "logical error!");
rlm@33 260 if (!Movie.file)
rlm@33 261 return;
rlm@1 262
rlm@33 263 long originalPos = ftell(Movie.file);
rlm@1 264
rlm@33 265 // (over-)write the header
rlm@33 266 fseek(Movie.file, 0, SEEK_SET);
rlm@33 267 write_movie_header(Movie.file, Movie);
rlm@1 268
rlm@33 269 fflush(Movie.file);
rlm@1 270
rlm@33 271 fseek(Movie.file, originalPos, SEEK_SET);
rlm@1 272 }
rlm@1 273
rlm@1 274 static void flush_movie_frames()
rlm@1 275 {
rlm@33 276 assert(Movie.file && "logical error!");
rlm@33 277 if (!Movie.file)
rlm@33 278 return;
rlm@1 279
rlm@33 280 long originalPos = ftell(Movie.file);
rlm@1 281
rlm@33 282 // overwrite the controller data
rlm@33 283 fseek(Movie.file, Movie.header.offset_to_controller_data, SEEK_SET);
rlm@33 284 fwrite(Movie.inputBuffer, 1, Movie.bytesPerFrame * Movie.header.length_frames, Movie.file);
rlm@1 285
rlm@33 286 fflush(Movie.file);
rlm@1 287
rlm@33 288 fseek(Movie.file, originalPos, SEEK_SET);
rlm@1 289 }
rlm@1 290
rlm@1 291 static void truncate_movie(long length)
rlm@1 292 {
rlm@33 293 // truncate movie to length
rlm@33 294 // NOTE: it's certain that the savestate block is never after the
rlm@33 295 // controller data block, because the VBM format decrees it.
rlm@1 296
rlm@33 297 assert(Movie.file && length >= 0);
rlm@33 298 if (!Movie.file || length < 0)
rlm@33 299 return;
rlm@1 300
rlm@33 301 assert(Movie.header.offset_to_savestate <= Movie.header.offset_to_controller_data);
rlm@33 302 if (Movie.header.offset_to_savestate > Movie.header.offset_to_controller_data)
rlm@33 303 return;
rlm@1 304
rlm@33 305 Movie.header.length_frames = length;
rlm@33 306 flush_movie_header();
rlm@33 307 const long truncLen = long(Movie.header.offset_to_controller_data + Movie.bytesPerFrame * length);
rlm@33 308 if (file_length(Movie.file) != truncLen)
rlm@33 309 {
rlm@33 310 ftruncate(fileno(Movie.file), truncLen);
rlm@33 311 }
rlm@1 312 }
rlm@1 313
rlm@1 314 static void remember_input_state()
rlm@1 315 {
rlm@33 316 for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)
rlm@33 317 {
rlm@33 318 if (systemCartridgeType == 0)
rlm@1 319 {
rlm@33 320 initialInputs[i] = u16(~P1 & 0x03FF);
rlm@1 321 }
rlm@33 322 else
rlm@33 323 {
rlm@33 324 extern int32 gbJoymask[4];
rlm@33 325 for (int i = 0; i < 4; ++i)
rlm@33 326 initialInputs[i] = u16(gbJoymask[i] & 0xFFFF);
rlm@33 327 }
rlm@33 328 }
rlm@1 329 }
rlm@1 330
rlm@1 331 static void change_state(MovieState new_state)
rlm@1 332 {
rlm@1 333 #if (defined(WIN32) && !defined(SDL))
rlm@33 334 theApp.frameSearching = false;
rlm@33 335 theApp.frameSearchSkipping = false;
rlm@1 336 #endif
rlm@1 337
rlm@33 338 if (new_state == MOVIE_STATE_NONE)
rlm@33 339 {
rlm@33 340 Movie.pauseFrame = -1;
rlm@33 341
rlm@33 342 if (Movie.state == MOVIE_STATE_NONE)
rlm@33 343 return;
rlm@33 344
rlm@33 345 truncate_movie(Movie.header.length_frames);
rlm@33 346
rlm@33 347 fclose(Movie.file);
rlm@33 348 Movie.file = NULL;
rlm@33 349 Movie.currentFrame = 0;
rlm@33 350 #if (defined(WIN32) && !defined(SDL))
rlm@33 351 // undo changes to border settings
rlm@33 352 {
rlm@33 353 gbBorderOn = prevBorder;
rlm@33 354 theApp.winGbBorderOn = prevWinBorder;
rlm@33 355 gbBorderAutomatic = prevBorderAuto;
rlm@33 356 systemGbBorderOn();
rlm@33 357 }
rlm@33 358 #endif
rlm@33 359 gbEmulatorType = prevEmulatorType;
rlm@33 360
rlm@33 361 extern int32 gbDMASpeedVersion;
rlm@33 362 gbDMASpeedVersion = 1;
rlm@33 363
rlm@33 364 extern int32 gbEchoRAMFixOn;
rlm@33 365 gbEchoRAMFixOn = 1;
rlm@33 366
rlm@33 367 gbNullInputHackTempEnabled = gbNullInputHackEnabled;
rlm@35 368
rlm@33 369 if (Movie.inputBuffer)
rlm@1 370 {
rlm@33 371 free(Movie.inputBuffer);
rlm@33 372 Movie.inputBuffer = NULL;
rlm@33 373 }
rlm@35 374
rlm@33 375 }
rlm@33 376 else if (new_state == MOVIE_STATE_PLAY)
rlm@33 377 {
rlm@33 378 assert(Movie.file);
rlm@1 379
rlm@33 380 // this would cause problems if not dealt with
rlm@33 381 if (Movie.currentFrame >= Movie.header.length_frames)
rlm@33 382 {
rlm@33 383 new_state = MOVIE_STATE_END;
rlm@33 384 Movie.inputBufferPtr = Movie.inputBuffer + Movie.bytesPerFrame * Movie.header.length_frames;
rlm@33 385 }
rlm@33 386 }
rlm@33 387 else if (new_state == MOVIE_STATE_RECORD)
rlm@33 388 {
rlm@33 389 assert(Movie.file);
rlm@1 390
rlm@33 391 // this would cause problems if not dealt with
rlm@33 392 if (Movie.currentFrame > Movie.header.length_frames)
rlm@1 393 {
rlm@33 394 new_state = MOVIE_STATE_END;
rlm@33 395 Movie.inputBufferPtr = Movie.inputBuffer + Movie.bytesPerFrame * Movie.header.length_frames;
rlm@1 396 }
rlm@1 397
rlm@33 398 fseek(Movie.file, Movie.header.offset_to_controller_data + Movie.bytesPerFrame * Movie.currentFrame, SEEK_SET);
rlm@33 399 }
rlm@33 400
rlm@33 401 if (new_state == MOVIE_STATE_END && Movie.state != MOVIE_STATE_END)
rlm@33 402 {
rlm@33 403 #if defined(SDL)
rlm@33 404 systemClearJoypads();
rlm@33 405 #endif
rlm@33 406 systemScreenMessage("Movie end");
rlm@33 407 }
rlm@33 408
rlm@33 409 Movie.state = new_state;
rlm@33 410
rlm@33 411 // checking for movie end
rlm@33 412 bool willPause = false;
rlm@33 413
rlm@33 414 // if the movie's been set to pause at a certain frame
rlm@33 415 if (Movie.state != MOVIE_STATE_NONE && Movie.pauseFrame >= 0 && Movie.currentFrame == (uint32)Movie.pauseFrame)
rlm@33 416 {
rlm@33 417 Movie.pauseFrame = -1;
rlm@33 418 willPause = true;
rlm@33 419 }
rlm@33 420
rlm@33 421 if (Movie.state == MOVIE_STATE_END)
rlm@33 422 {
rlm@33 423 if (Movie.currentFrame == Movie.header.length_frames)
rlm@1 424 {
rlm@1 425 #if (defined(WIN32) && !defined(SDL))
rlm@33 426 if (theApp.movieOnEndPause)
rlm@33 427 {
rlm@33 428 willPause = true;
rlm@33 429 }
rlm@1 430 #else
rlm@33 431 // SDL FIXME
rlm@1 432 #endif
rlm@1 433
rlm@1 434 #if (defined(WIN32) && !defined(SDL))
rlm@33 435 switch (theApp.movieOnEndBehavior)
rlm@33 436 {
rlm@33 437 case 1:
rlm@33 438 // the old behavior
rlm@33 439 //VBAMovieRestart();
rlm@33 440 break;
rlm@33 441 case 2:
rlm@1 442 #else
rlm@33 443 // SDL FIXME
rlm@1 444 #endif
rlm@33 445 if (Movie.RecordedThisSession)
rlm@33 446 {
rlm@33 447 // if user has been recording this movie since the last time it started playing,
rlm@33 448 // they probably don't want the movie to end now during playback,
rlm@33 449 // so switch back to recording when it reaches the end
rlm@33 450 VBAMovieSwitchToRecording();
rlm@33 451 systemScreenMessage("Recording resumed");
rlm@33 452 willPause = true;
rlm@33 453 }
rlm@1 454 #if (defined(WIN32) && !defined(SDL))
rlm@33 455 break;
rlm@33 456 case 3:
rlm@33 457 // keep open
rlm@33 458 break;
rlm@33 459 case 0:
rlm@33 460 // fall through
rlm@33 461 default:
rlm@33 462 // close movie
rlm@33 463 //VBAMovieStop(false);
rlm@33 464 break;
rlm@33 465 }
rlm@1 466 #else
rlm@33 467 // SDL FIXME
rlm@1 468 #endif
rlm@33 469 }
rlm@1 470 #if 1
rlm@33 471 else if (Movie.currentFrame > Movie.header.length_frames)
rlm@33 472 {
rlm@1 473 #if (defined(WIN32) && !defined(SDL))
rlm@33 474 switch (theApp.movieOnEndBehavior)
rlm@33 475 {
rlm@33 476 case 1:
rlm@33 477 // FIXME: this should be delayed till the current frame ends
rlm@33 478 VBAMovieRestart();
rlm@33 479 break;
rlm@33 480 case 2:
rlm@33 481 // nothing
rlm@33 482 break;
rlm@33 483 case 3:
rlm@33 484 // keep open
rlm@33 485 break;
rlm@33 486 case 0:
rlm@33 487 // fall through
rlm@33 488 default:
rlm@33 489 // close movie
rlm@33 490 VBAMovieStop(false);
rlm@33 491 break;
rlm@33 492 }
rlm@1 493 #else
rlm@33 494 // SDLFIXME
rlm@1 495 #endif
rlm@33 496 }
rlm@1 497 #endif
rlm@33 498 } // end if (Movie.state == MOVIE_STATE_END)
rlm@1 499
rlm@33 500 if (willPause)
rlm@33 501 {
rlm@33 502 systemSetPause(true);
rlm@33 503 }
rlm@1 504 }
rlm@1 505
rlm@1 506 void VBAMovieInit()
rlm@1 507 {
rlm@33 508 memset(&Movie, 0, sizeof(Movie));
rlm@33 509 Movie.state = MOVIE_STATE_NONE;
rlm@33 510 Movie.pauseFrame = -1;
rlm@1 511
rlm@33 512 resetSignaled = false;
rlm@33 513 resetSignaledLast = false;
rlm@35 514
rlm@35 515 // RLM: should probably add inputBuffer initialization here.
rlm@35 516 reserve_buffer_space(90001);
rlm@1 517 }
rlm@1 518
rlm@1 519 void VBAMovieGetRomInfo(const SMovie &movieInfo, char romTitle [12], uint32 &romGameCode, uint16 &checksum, uint8 &crc)
rlm@1 520 {
rlm@33 521 if (systemCartridgeType == 0) // GBA
rlm@33 522 {
rlm@33 523 extern u8 *bios, *rom;
rlm@33 524 memcpy(romTitle, &rom[0xa0], 12); // GBA TITLE
rlm@33 525 memcpy(&romGameCode, &rom[0xac], 4); // GBA ROM GAME CODE
rlm@33 526 if ((movieInfo.header.optionFlags & MOVIE_SETTING_USEBIOSFILE) != 0)
rlm@33 527 checksum = utilCalcBIOSChecksum(bios, 4); // GBA BIOS CHECKSUM
rlm@33 528 else
rlm@33 529 checksum = 0;
rlm@33 530 crc = rom[0xbd]; // GBA ROM CRC
rlm@33 531 }
rlm@33 532 else // non-GBA
rlm@33 533 {
rlm@33 534 extern u8 *gbRom;
rlm@33 535 memcpy(romTitle, &gbRom[0x134], 12); // GB TITLE (note this can be 15 but is truncated to 12)
rlm@33 536 romGameCode = (uint32)gbRom[0x146]; // GB ROM UNIT CODE
rlm@1 537
rlm@33 538 checksum = (gbRom[0x14e] << 8) | gbRom[0x14f]; // GB ROM CHECKSUM, read from big-endian
rlm@33 539 crc = gbRom[0x14d]; // GB ROM CRC
rlm@33 540 }
rlm@1 541 }
rlm@1 542
rlm@1 543 #ifdef SDL
rlm@1 544 static void GetBatterySaveName(char *buffer)
rlm@1 545 {
rlm@33 546 extern char batteryDir[2048], filename[2048]; // from SDL.cpp
rlm@33 547 extern char *sdlGetFilename(char *name); // from SDL.cpp
rlm@33 548 if (batteryDir[0])
rlm@33 549 sprintf(buffer, "%s/%s.sav", batteryDir, sdlGetFilename(filename));
rlm@33 550 else
rlm@33 551 sprintf(buffer, "%s.sav", filename);
rlm@1 552 }
rlm@1 553
rlm@1 554 #endif
rlm@1 555
rlm@1 556 static void SetPlayEmuSettings()
rlm@1 557 {
rlm@33 558 prevEmulatorType = gbEmulatorType;
rlm@33 559 gbEmulatorType = Movie.header.gbEmulatorType;
rlm@1 560
rlm@1 561 #if (defined(WIN32) && !defined(SDL))
rlm@33 562 // theApp.removeIntros = false;
rlm@33 563 theApp.skipBiosFile = (Movie.header.optionFlags & MOVIE_SETTING_SKIPBIOSFILE) != 0;
rlm@33 564 theApp.useBiosFile = (Movie.header.optionFlags & MOVIE_SETTING_USEBIOSFILE) != 0;
rlm@1 565 #else
rlm@33 566 extern int saveType, sdlRtcEnable, sdlFlashSize; // from SDL.cpp
rlm@33 567 extern bool8 useBios, skipBios, removeIntros; // from SDL.cpp
rlm@33 568 useBios = (Movie.header.optionFlags & MOVIE_SETTING_USEBIOSFILE) != 0;
rlm@33 569 skipBios = (Movie.header.optionFlags & MOVIE_SETTING_SKIPBIOSFILE) != 0;
rlm@33 570 removeIntros = false /*(Movie.header.optionFlags & MOVIE_SETTING_REMOVEINTROS) != 0*/;
rlm@1 571 #endif
rlm@1 572
rlm@33 573 extern void SetPrefetchHack(bool);
rlm@33 574 if (systemCartridgeType == 0) // lag disablement applies only to GBA
rlm@33 575 SetPrefetchHack((Movie.header.optionFlags & MOVIE_SETTING_LAGHACK) != 0);
rlm@1 576
rlm@33 577 gbNullInputHackTempEnabled = ((Movie.header.optionFlags & MOVIE_SETTING_GBINPUTHACK) != 0);
rlm@1 578
rlm@33 579 // some GB/GBC games depend on the sound rate, so just use the highest one
rlm@33 580 systemSoundSetQuality(1);
rlm@33 581 useOldFrameTiming = false;
rlm@1 582
rlm@33 583 extern int32 gbDMASpeedVersion;
rlm@33 584 if ((Movie.header.optionFlags & MOVIE_SETTING_GBCFF55FIX) != 0)
rlm@33 585 gbDMASpeedVersion = 1;
rlm@33 586 else
rlm@33 587 gbDMASpeedVersion = 0; // old CGB HDMA5 timing was used
rlm@1 588
rlm@33 589 extern int32 gbEchoRAMFixOn;
rlm@33 590 if ((Movie.header.optionFlags & MOVIE_SETTING_GBECHORAMFIX) != 0)
rlm@33 591 gbEchoRAMFixOn = 1;
rlm@33 592 else
rlm@33 593 gbEchoRAMFixOn = 0;
rlm@1 594
rlm@1 595 #if (defined(WIN32) && !defined(SDL))
rlm@33 596 rtcEnable((Movie.header.optionFlags & MOVIE_SETTING_RTCENABLE) != 0);
rlm@33 597 theApp.winSaveType = Movie.header.saveType;
rlm@33 598 theApp.winFlashSize = Movie.header.flashSize;
rlm@1 599
rlm@33 600 prevBorder = gbBorderOn;
rlm@33 601 prevWinBorder = theApp.winGbBorderOn;
rlm@33 602 prevBorderAuto = gbBorderAutomatic;
rlm@33 603 if ((gbEmulatorType == 2 || gbEmulatorType == 5)
rlm@33 604 && !theApp.hideMovieBorder) // games played in SGB mode can have a border
rlm@33 605 {
rlm@33 606 gbBorderOn = true;
rlm@33 607 theApp.winGbBorderOn = true;
rlm@33 608 gbBorderAutomatic = false;
rlm@33 609 }
rlm@33 610 else
rlm@33 611 {
rlm@33 612 gbBorderOn = false;
rlm@33 613 theApp.winGbBorderOn = false;
rlm@33 614 gbBorderAutomatic = false;
rlm@33 615 if (theApp.hideMovieBorder)
rlm@1 616 {
rlm@33 617 theApp.hideMovieBorder = false;
rlm@33 618 prevBorder = false; // it might be expected behaviour that it stays hidden after the movie
rlm@1 619 }
rlm@33 620 }
rlm@33 621 systemGbBorderOn();
rlm@1 622 #else
rlm@33 623 sdlRtcEnable = (Movie.header.optionFlags & MOVIE_SETTING_RTCENABLE) != 0;
rlm@33 624 saveType = Movie.header.saveType;
rlm@33 625 sdlFlashSize = Movie.header.flashSize;
rlm@1 626 #endif
rlm@1 627 }
rlm@1 628
rlm@1 629 static void HardResetAndSRAMClear()
rlm@1 630 {
rlm@1 631 #if (defined(WIN32) && !defined(SDL))
rlm@33 632 winEraseBatteryFile(); // delete the damn SRAM file and keep it from being resurrected from RAM
rlm@33 633 MainWnd *temp = ((MainWnd *)theApp.m_pMainWnd);
rlm@33 634 if (!temp->winFileRun(true)) // restart running the game
rlm@33 635 {
rlm@33 636 temp->winFileClose();
rlm@33 637 }
rlm@1 638 #else
rlm@33 639 char fname [1024];
rlm@33 640 GetBatterySaveName(fname);
rlm@33 641 remove(fname); // delete the damn SRAM file
rlm@1 642
rlm@33 643 // Henceforth, emuCleanUp means "clear out SRAM"
rlm@33 644 //theEmulator.emuCleanUp(); // keep it from being resurrected from RAM <--This is wrong, it'll deallocate all variables --Felipe
rlm@1 645
rlm@33 646 /// FIXME the correct SDL code to call for a full restart isn't in a function yet
rlm@33 647 theEmulator.emuReset(false);
rlm@1 648 #endif
rlm@1 649 }
rlm@1 650
rlm@1 651 int VBAMovieOpen(const char *filename, bool8 read_only)
rlm@1 652 {
rlm@33 653 loadingMovie = true;
rlm@33 654 uint8 movieReadOnly = read_only ? 1 : 0;
rlm@1 655
rlm@33 656 FILE * file;
rlm@33 657 STREAM stream;
rlm@33 658 int result;
rlm@33 659 int fn;
rlm@1 660
rlm@33 661 char movie_filename[_MAX_PATH];
rlm@1 662 #ifdef WIN32
rlm@33 663 _fullpath(movie_filename, filename, _MAX_PATH);
rlm@1 664 #else
rlm@33 665 // SDL FIXME: convert to fullpath
rlm@33 666 strncpy(movie_filename, filename, _MAX_PATH);
rlm@33 667 movie_filename[_MAX_PATH - 1] = '\0';
rlm@1 668 #endif
rlm@1 669
rlm@33 670 if (movie_filename[0] == '\0')
rlm@33 671 { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }
rlm@1 672
rlm@33 673 if (!emulating)
rlm@33 674 { loadingMovie = false; return MOVIE_UNKNOWN_ERROR; }
rlm@1 675
rlm@33 676 // bool alreadyOpen = (Movie.file != NULL && _stricmp(movie_filename, Movie.filename) == 0);
rlm@1 677
rlm@33 678 // if (alreadyOpen)
rlm@33 679 change_state(MOVIE_STATE_NONE); // have to stop current movie before trying to re-open it
rlm@1 680
rlm@33 681 if (!(file = fopen(movie_filename, "rb+")))
rlm@33 682 if (!(file = fopen(movie_filename, "rb")))
rlm@33 683 { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }
rlm@33 684 //else
rlm@33 685 // movieReadOnly = 2; // we have to open the movie twice, no need to do this both times
rlm@1 686
rlm@33 687 // if (!alreadyOpen)
rlm@33 688 // change_state(MOVIE_STATE_NONE); // stop current movie when we're able to open the other one
rlm@33 689 //
rlm@33 690 // if (!(file = fopen(movie_filename, "rb+")))
rlm@33 691 // if(!(file = fopen(movie_filename, "rb")))
rlm@33 692 // {loadingMovie = false; return MOVIE_FILE_NOT_FOUND;}
rlm@33 693 // else
rlm@33 694 // movieReadOnly = 2;
rlm@1 695
rlm@33 696 // clear out the current movie
rlm@33 697 VBAMovieInit();
rlm@1 698
rlm@33 699 // read header
rlm@33 700 if ((result = read_movie_header(file, Movie)) != MOVIE_SUCCESS)
rlm@33 701 {
rlm@33 702 fclose(file);
rlm@33 703 { loadingMovie = false; return result; }
rlm@33 704 }
rlm@1 705
rlm@33 706 // set emulator settings that make the movie more likely to stay synchronized
rlm@33 707 SetPlayEmuSettings();
rlm@1 708
rlm@33 709 // extern bool systemLoadBIOS();
rlm@33 710 // if (!systemLoadBIOS())
rlm@33 711 // { loadingMovie = false; return MOVIE_UNKNOWN_ERROR; }
rlm@1 712
rlm@33 713 // read the metadata / author info from file
rlm@33 714 fread(Movie.authorInfo, 1, MOVIE_METADATA_SIZE, file);
rlm@33 715 fn = dup(fileno(file)); // XXX: why does this fail?? it returns -1 but errno == 0
rlm@33 716 fclose(file);
rlm@1 717
rlm@33 718 // apparently this lseek is necessary
rlm@33 719 lseek(fn, Movie.header.offset_to_savestate, SEEK_SET);
rlm@33 720 if (!(stream = utilGzReopen(fn, "rb")))
rlm@33 721 if (!(stream = utilGzOpen(movie_filename, "rb")))
rlm@33 722 { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }
rlm@33 723 else
rlm@33 724 fn = dup(fileno(file));
rlm@33 725 // in case the above dup failed but opening the file normally doesn't fail
rlm@1 726
rlm@33 727 if (Movie.header.startFlags & MOVIE_START_FROM_SNAPSHOT)
rlm@33 728 {
rlm@33 729 // load the snapshot
rlm@33 730 result = theEmulator.emuReadStateFromStream(stream) ? MOVIE_SUCCESS : MOVIE_WRONG_FORMAT;
rlm@1 731
rlm@33 732 // FIXME: Kludge for conversion
rlm@33 733 remember_input_state();
rlm@33 734 }
rlm@33 735 else if (Movie.header.startFlags & MOVIE_START_FROM_SRAM)
rlm@33 736 {
rlm@33 737 // 'soft' reset:
rlm@33 738 theEmulator.emuReset(false);
rlm@1 739
rlm@33 740 // load the SRAM
rlm@33 741 result = theEmulator.emuReadBatteryFromStream(stream) ? MOVIE_SUCCESS : MOVIE_WRONG_FORMAT;
rlm@33 742 }
rlm@33 743 else
rlm@33 744 {
rlm@33 745 HardResetAndSRAMClear();
rlm@33 746 }
rlm@1 747
rlm@33 748 utilGzClose(stream);
rlm@1 749
rlm@33 750 if (result != MOVIE_SUCCESS)
rlm@33 751 { loadingMovie = false; return result; }
rlm@1 752
rlm@33 753 // if (!(file = fopen(movie_filename, /*read_only ? "rb" :*/ "rb+"))) // want to be able to switch out of read-only later
rlm@33 754 // {
rlm@33 755 // if(!Movie.readOnly || !(file = fopen(movie_filename, "rb"))) // try read-only if failed
rlm@33 756 // return MOVIE_FILE_NOT_FOUND;
rlm@33 757 // }
rlm@33 758 if (!(file = fopen(movie_filename, "rb+")))
rlm@33 759 if (!(file = fopen(movie_filename, "rb")))
rlm@33 760 { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }
rlm@33 761 else
rlm@33 762 movieReadOnly = 2;
rlm@1 763
rlm@33 764 // recalculate length of movie from the file size
rlm@33 765 Movie.bytesPerFrame = bytes_per_frame(Movie);
rlm@33 766 fseek(file, 0, SEEK_END);
rlm@33 767 long fileSize = ftell(file);
rlm@33 768 Movie.header.length_frames = (fileSize - Movie.header.offset_to_controller_data) / Movie.bytesPerFrame;
rlm@1 769
rlm@33 770 if (fseek(file, Movie.header.offset_to_controller_data, SEEK_SET))
rlm@33 771 { fclose(file); loadingMovie = false; return MOVIE_WRONG_FORMAT; }
rlm@1 772
rlm@33 773 strcpy(Movie.filename, movie_filename);
rlm@33 774 Movie.file = file;
rlm@33 775 Movie.inputBufferPtr = Movie.inputBuffer;
rlm@33 776 Movie.currentFrame = 0;
rlm@33 777 Movie.readOnly = movieReadOnly;
rlm@33 778 Movie.RecordedThisSession = false;
rlm@1 779
rlm@33 780 // read controller data
rlm@33 781 uint32 to_read = Movie.bytesPerFrame * Movie.header.length_frames;
rlm@33 782 reserve_buffer_space(to_read);
rlm@33 783 fread(Movie.inputBuffer, 1, to_read, file);
rlm@1 784
rlm@33 785 change_state(MOVIE_STATE_PLAY);
rlm@1 786
rlm@33 787 char messageString[64] = "Movie ";
rlm@33 788 bool converted = false;
rlm@33 789 if (autoConvertMovieWhenPlaying)
rlm@33 790 {
rlm@33 791 int result = VBAMovieConvertCurrent();
rlm@33 792 if (result == MOVIE_SUCCESS)
rlm@33 793 strcat(messageString, "converted and ");
rlm@33 794 else if (result == MOVIE_WRONG_VERSION)
rlm@33 795 strcat(messageString, "higher revision ");
rlm@33 796 }
rlm@1 797
rlm@33 798 if (Movie.state == MOVIE_STATE_PLAY)
rlm@33 799 strcat(messageString, "replaying ");
rlm@33 800 else
rlm@33 801 strcat(messageString, "finished ");
rlm@33 802 if (Movie.readOnly)
rlm@33 803 strcat(messageString, "(read)");
rlm@33 804 else
rlm@33 805 strcat(messageString, "(edit)");
rlm@33 806 systemScreenMessage(messageString);
rlm@1 807
rlm@33 808 VBAUpdateButtonPressDisplay();
rlm@33 809 VBAUpdateFrameCountDisplay();
rlm@33 810 systemRefreshScreen();
rlm@1 811
rlm@33 812 { loadingMovie = false; return MOVIE_SUCCESS; }
rlm@1 813 }
rlm@1 814
rlm@1 815 static void SetRecordEmuSettings()
rlm@1 816 {
rlm@33 817 Movie.header.optionFlags = 0;
rlm@1 818 #if (defined(WIN32) && !defined(SDL))
rlm@33 819 if (theApp.useBiosFile)
rlm@33 820 Movie.header.optionFlags |= MOVIE_SETTING_USEBIOSFILE;
rlm@33 821 if (theApp.skipBiosFile)
rlm@33 822 Movie.header.optionFlags |= MOVIE_SETTING_SKIPBIOSFILE;
rlm@33 823 if (rtcIsEnabled())
rlm@33 824 Movie.header.optionFlags |= MOVIE_SETTING_RTCENABLE;
rlm@33 825 Movie.header.saveType = theApp.winSaveType;
rlm@33 826 Movie.header.flashSize = theApp.winFlashSize;
rlm@1 827 #else
rlm@33 828 extern int saveType, sdlRtcEnable, sdlFlashSize; // from SDL.cpp
rlm@33 829 extern bool8 useBios, skipBios; // from SDL.cpp
rlm@33 830 if (useBios)
rlm@33 831 Movie.header.optionFlags |= MOVIE_SETTING_USEBIOSFILE;
rlm@33 832 if (skipBios)
rlm@33 833 Movie.header.optionFlags |= MOVIE_SETTING_SKIPBIOSFILE;
rlm@33 834 if (sdlRtcEnable)
rlm@33 835 Movie.header.optionFlags |= MOVIE_SETTING_RTCENABLE;
rlm@33 836 Movie.header.saveType = saveType;
rlm@33 837 Movie.header.flashSize = sdlFlashSize;
rlm@1 838 #endif
rlm@33 839 prevEmulatorType = Movie.header.gbEmulatorType = gbEmulatorType;
rlm@1 840
rlm@33 841 if (!memLagTempEnabled)
rlm@33 842 Movie.header.optionFlags |= MOVIE_SETTING_LAGHACK;
rlm@1 843
rlm@33 844 if (gbNullInputHackTempEnabled)
rlm@33 845 Movie.header.optionFlags |= MOVIE_SETTING_GBINPUTHACK;
rlm@1 846
rlm@33 847 Movie.header.optionFlags |= MOVIE_SETTING_GBCFF55FIX;
rlm@33 848 extern int32 gbDMASpeedVersion;
rlm@33 849 gbDMASpeedVersion = 1;
rlm@1 850
rlm@33 851 Movie.header.optionFlags |= MOVIE_SETTING_GBECHORAMFIX;
rlm@33 852 extern int32 gbEchoRAMFixOn;
rlm@33 853 gbEchoRAMFixOn = 1;
rlm@1 854
rlm@33 855 // some GB/GBC games depend on the sound rate, so just use the highest one
rlm@33 856 systemSoundSetQuality(1);
rlm@1 857
rlm@33 858 useOldFrameTiming = false;
rlm@1 859
rlm@1 860 #if (defined(WIN32) && !defined(SDL))
rlm@33 861 // theApp.removeIntros = false;
rlm@1 862
rlm@33 863 prevBorder = gbBorderOn;
rlm@33 864 prevWinBorder = theApp.winGbBorderOn;
rlm@33 865 prevBorderAuto = gbBorderAutomatic;
rlm@33 866 if (gbEmulatorType == 2 || gbEmulatorType == 5) // only games played in SGB mode will have a border
rlm@33 867 {
rlm@33 868 gbBorderOn = true;
rlm@33 869 theApp.winGbBorderOn = true;
rlm@33 870 gbBorderAutomatic = false;
rlm@33 871 }
rlm@33 872 else
rlm@33 873 {
rlm@33 874 gbBorderOn = false;
rlm@33 875 theApp.winGbBorderOn = false;
rlm@33 876 gbBorderAutomatic = false;
rlm@33 877 }
rlm@33 878 systemGbBorderOn();
rlm@1 879 #else
rlm@33 880 /// SDLFIXME
rlm@1 881 #endif
rlm@1 882 }
rlm@1 883
rlm@1 884 uint16 VBAMovieGetCurrentInputOf(int controllerNum, bool normalOnly)
rlm@1 885 {
rlm@33 886 if (controllerNum < 0 || controllerNum >= MOVIE_NUM_OF_POSSIBLE_CONTROLLERS)
rlm@33 887 return 0;
rlm@1 888
rlm@33 889 return normalOnly ? (currentButtons[controllerNum] & BUTTON_REGULAR_MASK) : currentButtons[controllerNum];
rlm@1 890 }
rlm@1 891
rlm@1 892 int VBAMovieCreate(const char *filename, const char *authorInfo, uint8 startFlags, uint8 controllerFlags, uint8 typeFlags)
rlm@1 893 {
rlm@33 894 // make sure at least one controller is enabled
rlm@33 895 if ((controllerFlags & MOVIE_CONTROLLERS_ANY_MASK) == 0)
rlm@33 896 return MOVIE_WRONG_FORMAT;
rlm@1 897
rlm@33 898 if (!emulating)
rlm@33 899 return MOVIE_UNKNOWN_ERROR;
rlm@1 900
rlm@33 901 loadingMovie = true;
rlm@1 902
rlm@33 903 FILE * file;
rlm@33 904 STREAM stream;
rlm@33 905 int fn;
rlm@1 906
rlm@33 907 char movie_filename [_MAX_PATH];
rlm@1 908 #ifdef WIN32
rlm@33 909 _fullpath(movie_filename, filename, _MAX_PATH);
rlm@1 910 #else
rlm@33 911 // FIXME: convert to fullpath
rlm@33 912 strncpy(movie_filename, filename, _MAX_PATH);
rlm@33 913 movie_filename[_MAX_PATH - 1] = '\0';
rlm@1 914 #endif
rlm@1 915
rlm@33 916 bool alreadyOpen = (Movie.file != NULL && stricmp(movie_filename, Movie.filename) == 0);
rlm@1 917
rlm@33 918 if (alreadyOpen)
rlm@33 919 change_state(MOVIE_STATE_NONE); // have to stop current movie before trying to re-open it
rlm@1 920
rlm@33 921 if (movie_filename[0] == '\0')
rlm@33 922 { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }
rlm@33 923
rlm@33 924 if (!(file = fopen(movie_filename, "wb")))
rlm@33 925 { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }
rlm@33 926
rlm@33 927 if (!alreadyOpen)
rlm@33 928 change_state(MOVIE_STATE_NONE); // stop current movie when we're able to open the other one
rlm@33 929
rlm@33 930 // clear out the current movie
rlm@39 931 //printf("RLM: movie init\n");
rlm@33 932
rlm@33 933 VBAMovieInit();
rlm@33 934
rlm@33 935 // fill in the movie's header
rlm@33 936 Movie.header.uid = (uint32)time(NULL);
rlm@33 937 Movie.header.magic = VBM_MAGIC;
rlm@33 938 Movie.header.version = VBM_VERSION;
rlm@33 939 Movie.header.rerecord_count = 0;
rlm@33 940 Movie.header.length_frames = 0;
rlm@33 941 Movie.header.startFlags = startFlags;
rlm@33 942 Movie.header.controllerFlags = controllerFlags;
rlm@33 943 Movie.header.typeFlags = typeFlags;
rlm@33 944 Movie.header.minorVersion = VBM_REVISION;
rlm@33 945
rlm@33 946 // set emulator settings that make the movie more likely to stay synchronized when it's later played back
rlm@33 947 SetRecordEmuSettings();
rlm@33 948
rlm@33 949 // set ROM and BIOS checksums and stuff
rlm@33 950 VBAMovieGetRomInfo(Movie, Movie.header.romTitle, Movie.header.romGameCode, Movie.header.romOrBiosChecksum, Movie.header.romCRC);
rlm@33 951
rlm@39 952 //printf("RLM: Writing movie header\n");
rlm@33 953 // write the header to file
rlm@33 954 write_movie_header(file, Movie);
rlm@33 955
rlm@39 956 //printf("RLM: setting metadata\n");
rlm@33 957
rlm@33 958 // copy over the metadata / author info
rlm@33 959 VBAMovieSetMetadata("________________Robert McIntyre______________________________________________________________________________________________________________________________________________________________________________________________________________________");
rlm@33 960
rlm@39 961 //printf("RLM: writing metadata\n");
rlm@33 962
rlm@33 963 // write the metadata / author info to file
rlm@33 964
rlm@33 965
rlm@33 966 fwrite(Movie.authorInfo, 1, sizeof(char) * MOVIE_METADATA_SIZE, file);
rlm@33 967
rlm@33 968 // write snapshot or SRAM if applicable
rlm@33 969 if (Movie.header.startFlags & MOVIE_START_FROM_SNAPSHOT
rlm@33 970 || Movie.header.startFlags & MOVIE_START_FROM_SRAM)
rlm@33 971 {
rlm@33 972 Movie.header.offset_to_savestate = (uint32)ftell(file);
rlm@33 973
rlm@33 974 // close the file and reopen it as a stream:
rlm@33 975
rlm@33 976 fn = dup(fileno(file));
rlm@33 977 fclose(file);
rlm@33 978
rlm@33 979 if (!(stream = utilGzReopen(fn, "ab"))) // append mode to start at end, no seek necessary
rlm@1 980 { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }
rlm@1 981
rlm@33 982 // write the save data:
rlm@33 983 if (Movie.header.startFlags & MOVIE_START_FROM_SNAPSHOT)
rlm@33 984 {
rlm@33 985 // save snapshot
rlm@33 986 if (!theEmulator.emuWriteStateToStream(stream))
rlm@33 987 {
rlm@33 988 utilGzClose(stream);
rlm@33 989 { loadingMovie = false; return MOVIE_UNKNOWN_ERROR; }
rlm@33 990 }
rlm@33 991 }
rlm@33 992 else if (Movie.header.startFlags & MOVIE_START_FROM_SRAM)
rlm@33 993 {
rlm@33 994 // save SRAM
rlm@33 995 if (!theEmulator.emuWriteBatteryToStream(stream))
rlm@33 996 {
rlm@33 997 utilGzClose(stream);
rlm@33 998 { loadingMovie = false; return MOVIE_UNKNOWN_ERROR; }
rlm@33 999 }
rlm@33 1000
rlm@33 1001 // 'soft' reset:
rlm@33 1002 theEmulator.emuReset(false);
rlm@33 1003 }
rlm@33 1004
rlm@33 1005 utilGzClose(stream);
rlm@33 1006
rlm@33 1007 // reopen the file and seek back to the end
rlm@33 1008
rlm@33 1009 if (!(file = fopen(movie_filename, "rb+")))
rlm@1 1010 { loadingMovie = false; return MOVIE_FILE_NOT_FOUND; }
rlm@1 1011
rlm@33 1012 fseek(file, 0, SEEK_END);
rlm@33 1013 }
rlm@33 1014 else // no snapshot or SRAM
rlm@33 1015 {
rlm@33 1016 HardResetAndSRAMClear();
rlm@33 1017 }
rlm@1 1018
rlm@33 1019 Movie.header.offset_to_controller_data = (uint32)ftell(file);
rlm@1 1020
rlm@33 1021 strcpy(Movie.filename, movie_filename);
rlm@33 1022 Movie.file = file;
rlm@33 1023 Movie.bytesPerFrame = bytes_per_frame(Movie);
rlm@33 1024 Movie.inputBufferPtr = Movie.inputBuffer;
rlm@33 1025 Movie.currentFrame = 0;
rlm@33 1026 Movie.readOnly = false;
rlm@33 1027 Movie.RecordedThisSession = true;
rlm@1 1028
rlm@33 1029 change_state(MOVIE_STATE_RECORD);
rlm@1 1030
rlm@33 1031 systemScreenMessage("Recording movie...");
rlm@33 1032 { loadingMovie = false; return MOVIE_SUCCESS; }
rlm@1 1033 }
rlm@1 1034
rlm@1 1035 void VBAUpdateButtonPressDisplay()
rlm@1 1036 {
rlm@33 1037 uint32 keys = currentButtons[0] & BUTTON_REGULAR_RECORDING_MASK;
rlm@1 1038
rlm@33 1039 const static char KeyMap[] = { 'A', 'B', 's', 'S', '>', '<', '^', 'v', 'R', 'L', '!', '?', '{', '}', 'v', '^' };
rlm@33 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 { = } _
rlm@33 1041 // ? !
rlm@33 1042 char buffer[256];
rlm@33 1043 sprintf(buffer, " ");
rlm@1 1044
rlm@1 1045 #ifndef WIN32
rlm@33 1046 // don't bother color-coding autofire and such
rlm@33 1047 int i;
rlm@33 1048 for (i = 0; i < 15; i++)
rlm@33 1049 {
rlm@33 1050 int j = KeyOrder[i];
rlm@33 1051 int mask = (1 << (j));
rlm@33 1052 buffer[strlen(" ") + i] = ((keys & mask) != 0) ? KeyMap[j] : ' ';
rlm@33 1053 }
rlm@33 1054
rlm@33 1055 systemScreenMessage(buffer, 2, -1);
rlm@33 1056 #else
rlm@33 1057 const bool eraseAll = !theApp.inputDisplay;
rlm@33 1058 uint32 autoHeldKeys = eraseAll ? 0 : theApp.autoHold & BUTTON_REGULAR_RECORDING_MASK;
rlm@33 1059 uint32 autoFireKeys = eraseAll ? 0 : (theApp.autoFire | theApp.autoFire2) & BUTTON_REGULAR_RECORDING_MASK;
rlm@33 1060 uint32 pressedKeys = eraseAll ? 0 : keys;
rlm@33 1061
rlm@33 1062 char colorList[64];
rlm@33 1063 memset(colorList, 1, strlen(buffer));
rlm@33 1064
rlm@33 1065 if (!eraseAll)
rlm@33 1066 {
rlm@33 1067 for (int i = 0; i < 15; i++)
rlm@1 1068 {
rlm@33 1069 const int j = KeyOrder[i];
rlm@33 1070 const int mask = (1 << (j));
rlm@33 1071 bool pressed = (pressedKeys & mask) != 0;
rlm@33 1072 const bool autoHeld = (autoHeldKeys & mask) != 0;
rlm@33 1073 const bool autoFired = (autoFireKeys & mask) != 0;
rlm@33 1074 const bool erased = (lastKeys & mask) != 0 && (!pressed && !autoHeld && !autoFired);
rlm@33 1075 extern int textMethod;
rlm@33 1076 if (textMethod != 2 && (autoHeld || (autoFired && !pressed) || erased))
rlm@33 1077 {
rlm@33 1078 int colorNum = 1; // default is white
rlm@33 1079 if (autoHeld)
rlm@33 1080 colorNum += (pressed ? 2 : 1); // yellow if pressed, red if not
rlm@33 1081 else if (autoFired)
rlm@33 1082 colorNum += 5; // blue if autofired and not currently pressed
rlm@33 1083 else if (erased)
rlm@33 1084 colorNum += 8; // black on black
rlm@33 1085
rlm@33 1086 colorList[strlen(" ") + i] = colorNum;
rlm@33 1087 pressed = true;
rlm@33 1088 }
rlm@33 1089 buffer[strlen(" ") + i] = pressed ? KeyMap[j] : ' ';
rlm@1 1090 }
rlm@33 1091 }
rlm@1 1092
rlm@33 1093 lastKeys = currentButtons[0];
rlm@33 1094 lastKeys |= theApp.autoHold & BUTTON_REGULAR_RECORDING_MASK;
rlm@33 1095 lastKeys |= (theApp.autoFire | theApp.autoFire2) & BUTTON_REGULAR_RECORDING_MASK;
rlm@1 1096
rlm@33 1097 systemScreenMessage(buffer, 2, -1, colorList);
rlm@1 1098 #endif
rlm@1 1099 }
rlm@1 1100
rlm@1 1101 void VBAUpdateFrameCountDisplay()
rlm@1 1102 {
rlm@33 1103 const int MAGICAL_NUMBER = 64; // FIXME: this won't do any better, but only to remind you of sz issues
rlm@33 1104 char frameDisplayString[MAGICAL_NUMBER];
rlm@33 1105 char lagFrameDisplayString[MAGICAL_NUMBER];
rlm@33 1106 char extraCountDisplayString[MAGICAL_NUMBER];
rlm@1 1107
rlm@1 1108 #if (defined(WIN32) && !defined(SDL))
rlm@33 1109 if (theApp.frameCounter)
rlm@33 1110 #else
rlm@33 1111 /// SDL FIXME
rlm@33 1112 #endif
rlm@33 1113 {
rlm@33 1114 switch (Movie.state)
rlm@33 1115 {
rlm@33 1116 case MOVIE_STATE_PLAY:
rlm@33 1117 case MOVIE_STATE_END:
rlm@33 1118 {
rlm@33 1119 sprintf(frameDisplayString, "%d / %d", Movie.currentFrame, Movie.header.length_frames);
rlm@33 1120 if (!Movie.readOnly)
rlm@33 1121 strcat(frameDisplayString, " (edit)");
rlm@33 1122 break;
rlm@33 1123 }
rlm@33 1124 case MOVIE_STATE_RECORD:
rlm@33 1125 {
rlm@33 1126 sprintf(frameDisplayString, "%d (record)", Movie.currentFrame);
rlm@33 1127 break;
rlm@33 1128 }
rlm@33 1129 default:
rlm@33 1130 {
rlm@33 1131 sprintf(frameDisplayString, "%d (no movie)", systemCounters.frameCount);
rlm@33 1132 break;
rlm@33 1133 }
rlm@33 1134 }
rlm@33 1135
rlm@33 1136 #if (defined(WIN32) && !defined(SDL))
rlm@33 1137 if (theApp.lagCounter)
rlm@1 1138 #else
rlm@1 1139 /// SDL FIXME
rlm@1 1140 #endif
rlm@1 1141 {
rlm@33 1142 // sprintf(lagFrameDisplayString, " %c %d", systemCounters.laggedLast ? '*' : '|', systemCounters.lagCount);
rlm@33 1143 sprintf(lagFrameDisplayString, " | %d%s", systemCounters.lagCount, systemCounters.laggedLast ? " *" : "");
rlm@33 1144 strcat(frameDisplayString, lagFrameDisplayString);
rlm@33 1145 }
rlm@1 1146
rlm@1 1147 #if (defined(WIN32) && !defined(SDL))
rlm@33 1148 if (theApp.extraCounter)
rlm@1 1149 #else
rlm@1 1150 /// SDL FIXME
rlm@1 1151 #endif
rlm@33 1152 {
rlm@33 1153 sprintf(extraCountDisplayString, " | %d", systemCounters.frameCount - systemCounters.extraCount);
rlm@33 1154 strcat(frameDisplayString, extraCountDisplayString);
rlm@33 1155 }
rlm@33 1156 }
rlm@33 1157 #if (defined(WIN32) && !defined(SDL))
rlm@33 1158 else
rlm@33 1159 {
rlm@33 1160 frameDisplayString[0] = '\0';
rlm@33 1161 }
rlm@33 1162 #else
rlm@33 1163 /// SDL FIXME
rlm@33 1164 #endif
rlm@33 1165 systemScreenMessage(frameDisplayString, 1, -1);
rlm@1 1166 }
rlm@1 1167
rlm@1 1168 // this function should only be called once every frame
rlm@1 1169 void VBAMovieUpdateState()
rlm@1 1170 {
rlm@33 1171 ++Movie.currentFrame;
rlm@39 1172 //printf("RLM: inside updateState\n");
rlm@33 1173 if (Movie.state == MOVIE_STATE_PLAY)
rlm@33 1174 {
rlm@33 1175 Movie.inputBufferPtr += Movie.bytesPerFrame;
rlm@33 1176 if (Movie.currentFrame >= Movie.header.length_frames)
rlm@1 1177 {
rlm@33 1178 // the movie ends anyway; what to do next depends on the settings
rlm@33 1179 change_state(MOVIE_STATE_END);
rlm@1 1180 }
rlm@33 1181 }
rlm@33 1182 else if (Movie.state == MOVIE_STATE_RECORD)
rlm@33 1183 {
rlm@39 1184 //printf("RLM: Movie_STATE_RECORD\n");
rlm@36 1185 VBAMovieWrite(0,true);
rlm@33 1186 // use first fseek?
rlm@33 1187 //TODO: THis is the problem.
rlm@35 1188 if (Movie.inputBuffer){
rlm@35 1189 fwrite(Movie.inputBufferPtr, 1, Movie.bytesPerFrame, Movie.file);
rlm@35 1190 }
rlm@39 1191 //printf("RLM: write successful.\n");
rlm@33 1192 Movie.header.length_frames = Movie.currentFrame;
rlm@33 1193 Movie.inputBufferPtr += Movie.bytesPerFrame;
rlm@33 1194 Movie.RecordedThisSession = true;
rlm@33 1195 flush_movie_header();
rlm@33 1196 }
rlm@33 1197 else if (Movie.state == MOVIE_STATE_END)
rlm@33 1198 {
rlm@33 1199 change_state(MOVIE_STATE_END);
rlm@33 1200 }
rlm@1 1201 }
rlm@1 1202
rlm@1 1203 void VBAMovieRead(int i, bool /*sensor*/)
rlm@1 1204 {
rlm@33 1205 if (Movie.state != MOVIE_STATE_PLAY)
rlm@33 1206 return;
rlm@1 1207
rlm@33 1208 if (i < 0 || i >= MOVIE_NUM_OF_POSSIBLE_CONTROLLERS)
rlm@33 1209 return; // not a controller we're recognizing
rlm@1 1210
rlm@33 1211 if (Movie.header.controllerFlags & MOVIE_CONTROLLER(i))
rlm@33 1212 {
rlm@33 1213 currentButtons[i] = Read16(Movie.inputBufferPtr + CONTROLLER_DATA_SIZE * i);
rlm@33 1214 }
rlm@33 1215 else
rlm@33 1216 {
rlm@33 1217 currentButtons[i] = 0; // pretend the controller is disconnected
rlm@33 1218 }
rlm@39 1219
rlm@39 1220 printf("RLM: button %d\n",currentButtons[i]);
rlm@39 1221 if ((currentButtons[i] & BUTTON_MASK_NEW_RESET) != 0){
rlm@39 1222 printf("RLM: reset signaled\n");
rlm@33 1223 resetSignaled = true;
rlm@39 1224 }
rlm@1 1225 }
rlm@1 1226
rlm@1 1227 void VBAMovieWrite(int i, bool /*sensor*/)
rlm@1 1228 {
rlm@33 1229 if (Movie.state != MOVIE_STATE_RECORD)
rlm@33 1230 return;
rlm@1 1231
rlm@33 1232 if (i < 0 || i >= MOVIE_NUM_OF_POSSIBLE_CONTROLLERS)
rlm@33 1233 return; // not a controller we're recognizing
rlm@1 1234
rlm@33 1235 reserve_buffer_space((uint32)((Movie.inputBufferPtr - Movie.inputBuffer) + Movie.bytesPerFrame));
rlm@1 1236
rlm@36 1237 if (Movie.header.controllerFlags)
rlm@33 1238 {
rlm@33 1239 // get the current controller data
rlm@33 1240 uint16 buttonData = currentButtons[i];
rlm@39 1241 //printf("RLM: currentButtons %i\n", currentButtons[0]);
rlm@33 1242
rlm@33 1243 // mask away the irrelevent bits
rlm@33 1244 buttonData &= BUTTON_REGULAR_MASK | BUTTON_MOTION_MASK;
rlm@33 1245
rlm@33 1246 // soft-reset "button" for 1 frame if the game is reset while recording
rlm@33 1247 if (resetSignaled)
rlm@1 1248 {
rlm@33 1249 buttonData |= BUTTON_MASK_NEW_RESET;
rlm@33 1250 }
rlm@1 1251
rlm@33 1252 // backward compatibility kludge
rlm@33 1253 if (resetSignaledLast)
rlm@33 1254 {
rlm@33 1255 buttonData |= BUTTON_MASK_OLD_RESET;
rlm@33 1256 }
rlm@1 1257
rlm@33 1258 Write16(buttonData, Movie.inputBufferPtr + CONTROLLER_DATA_SIZE * i);
rlm@1 1259
rlm@33 1260 // and for display
rlm@33 1261 currentButtons[i] = buttonData;
rlm@33 1262 }
rlm@33 1263 else
rlm@33 1264 {
rlm@33 1265 // pretend the controller is disconnected (otherwise input it gives could cause desync since we're not writing it to the
rlm@33 1266 // movie)
rlm@33 1267 currentButtons[i] = 0;
rlm@33 1268 }
rlm@1 1269 }
rlm@1 1270
rlm@1 1271 void VBAMovieStop(bool8 suppress_message)
rlm@1 1272 {
rlm@33 1273 if (Movie.state != MOVIE_STATE_NONE)
rlm@33 1274 {
rlm@33 1275 change_state(MOVIE_STATE_NONE);
rlm@33 1276 if (!suppress_message)
rlm@33 1277 systemScreenMessage("Movie stop");
rlm@33 1278 }
rlm@1 1279 }
rlm@1 1280
rlm@1 1281 int VBAMovieGetInfo(const char *filename, SMovie *info)
rlm@1 1282 {
rlm@33 1283 assert(info != NULL);
rlm@33 1284 if (info == NULL)
rlm@33 1285 return -1;
rlm@1 1286
rlm@33 1287 FILE * file;
rlm@33 1288 int result;
rlm@33 1289 SMovie &local_movie = *info;
rlm@1 1290
rlm@33 1291 memset(info, 0, sizeof(*info));
rlm@33 1292 if (filename[0] == '\0')
rlm@33 1293 return MOVIE_FILE_NOT_FOUND;
rlm@33 1294 if (!(file = fopen(filename, "rb")))
rlm@33 1295 return MOVIE_FILE_NOT_FOUND;
rlm@1 1296
rlm@33 1297 // read header
rlm@33 1298 if ((result = (read_movie_header(file, local_movie))) != MOVIE_SUCCESS)
rlm@33 1299 {
rlm@33 1300 fclose(file);
rlm@33 1301 return result;
rlm@33 1302 }
rlm@1 1303
rlm@33 1304 // read the metadata / author info from file
rlm@33 1305 fread(local_movie.authorInfo, 1, sizeof(char) * MOVIE_METADATA_SIZE, file);
rlm@1 1306
rlm@33 1307 strncpy(local_movie.filename, filename, _MAX_PATH);
rlm@33 1308 local_movie.filename[_MAX_PATH - 1] = '\0';
rlm@1 1309
rlm@33 1310 if (Movie.file != NULL && stricmp(local_movie.filename, Movie.filename) == 0) // alreadyOpen
rlm@33 1311 {
rlm@33 1312 local_movie.bytesPerFrame = Movie.bytesPerFrame;
rlm@33 1313 local_movie.header.length_frames = Movie.header.length_frames;
rlm@33 1314 }
rlm@33 1315 else
rlm@33 1316 {
rlm@33 1317 // recalculate length of movie from the file size
rlm@33 1318 local_movie.bytesPerFrame = bytes_per_frame(local_movie);
rlm@33 1319 fseek(file, 0, SEEK_END);
rlm@33 1320 int fileSize = ftell(file);
rlm@33 1321 local_movie.header.length_frames =
rlm@33 1322 (fileSize - local_movie.header.offset_to_controller_data) / local_movie.bytesPerFrame;
rlm@33 1323 }
rlm@1 1324
rlm@33 1325 fclose(file);
rlm@1 1326
rlm@33 1327 if (access(filename, W_OK))
rlm@33 1328 info->readOnly = true;
rlm@1 1329
rlm@33 1330 return MOVIE_SUCCESS;
rlm@1 1331 }
rlm@1 1332
rlm@1 1333 bool8 VBAMovieActive()
rlm@1 1334 {
rlm@33 1335 return (Movie.state != MOVIE_STATE_NONE);
rlm@1 1336 }
rlm@1 1337
rlm@1 1338 bool8 VBAMovieLoading()
rlm@1 1339 {
rlm@33 1340 return loadingMovie;
rlm@1 1341 }
rlm@1 1342
rlm@1 1343 bool8 VBAMoviePlaying()
rlm@1 1344 {
rlm@33 1345 return (Movie.state == MOVIE_STATE_PLAY);
rlm@1 1346 }
rlm@1 1347
rlm@1 1348 bool8 VBAMovieRecording()
rlm@1 1349 {
rlm@33 1350 return (Movie.state == MOVIE_STATE_RECORD);
rlm@1 1351 }
rlm@1 1352
rlm@1 1353 bool8 VBAMovieReadOnly()
rlm@1 1354 {
rlm@33 1355 if (!VBAMovieActive())
rlm@33 1356 return false;
rlm@1 1357
rlm@33 1358 return Movie.readOnly;
rlm@1 1359 }
rlm@1 1360
rlm@1 1361 void VBAMovieToggleReadOnly()
rlm@1 1362 {
rlm@33 1363 if (!VBAMovieActive())
rlm@33 1364 return;
rlm@1 1365
rlm@33 1366 if (Movie.readOnly != 2)
rlm@33 1367 {
rlm@33 1368 Movie.readOnly = !Movie.readOnly;
rlm@1 1369
rlm@33 1370 systemScreenMessage(Movie.readOnly ? "Movie now read-only" : "Movie now editable");
rlm@33 1371 }
rlm@33 1372 else
rlm@33 1373 {
rlm@33 1374 systemScreenMessage("Can't toggle read-only movie");
rlm@33 1375 }
rlm@1 1376 }
rlm@1 1377
rlm@1 1378 uint32 VBAMovieGetVersion()
rlm@1 1379 {
rlm@33 1380 if (!VBAMovieActive())
rlm@33 1381 return 0;
rlm@1 1382
rlm@33 1383 return Movie.header.version;
rlm@1 1384 }
rlm@1 1385
rlm@1 1386 uint32 VBAMovieGetMinorVersion()
rlm@1 1387 {
rlm@33 1388 if (!VBAMovieActive())
rlm@33 1389 return 0;
rlm@1 1390
rlm@33 1391 return Movie.header.minorVersion;
rlm@1 1392 }
rlm@1 1393
rlm@1 1394 uint32 VBAMovieGetId()
rlm@1 1395 {
rlm@33 1396 if (!VBAMovieActive())
rlm@33 1397 return 0;
rlm@1 1398
rlm@33 1399 return Movie.header.uid;
rlm@1 1400 }
rlm@1 1401
rlm@1 1402 uint32 VBAMovieGetLength()
rlm@1 1403 {
rlm@33 1404 if (!VBAMovieActive())
rlm@33 1405 return 0;
rlm@1 1406
rlm@33 1407 return Movie.header.length_frames;
rlm@1 1408 }
rlm@1 1409
rlm@1 1410 uint32 VBAMovieGetFrameCounter()
rlm@1 1411 {
rlm@33 1412 if (!VBAMovieActive())
rlm@33 1413 return 0;
rlm@1 1414
rlm@33 1415 return Movie.currentFrame;
rlm@1 1416 }
rlm@1 1417
rlm@1 1418 uint32 VBAMovieGetRerecordCount()
rlm@1 1419 {
rlm@33 1420 if (!VBAMovieActive())
rlm@33 1421 return 0;
rlm@1 1422
rlm@33 1423 return Movie.header.rerecord_count;
rlm@1 1424 }
rlm@1 1425
rlm@1 1426 uint32 VBAMovieSetRerecordCount(uint32 newRerecordCount)
rlm@1 1427 {
rlm@33 1428 uint32 oldRerecordCount = 0;
rlm@33 1429 if (!VBAMovieActive())
rlm@33 1430 return 0;
rlm@1 1431
rlm@33 1432 oldRerecordCount = Movie.header.rerecord_count;
rlm@33 1433 Movie.header.rerecord_count = newRerecordCount;
rlm@33 1434 return oldRerecordCount;
rlm@1 1435 }
rlm@1 1436
rlm@1 1437 std::string VBAMovieGetAuthorInfo()
rlm@1 1438 {
rlm@33 1439 if (!VBAMovieActive())
rlm@33 1440 return "";
rlm@1 1441
rlm@33 1442 return Movie.authorInfo;
rlm@1 1443 }
rlm@1 1444
rlm@1 1445 std::string VBAMovieGetFilename()
rlm@1 1446 {
rlm@33 1447 if (!VBAMovieActive())
rlm@33 1448 return "";
rlm@1 1449
rlm@33 1450 return Movie.filename;
rlm@1 1451 }
rlm@1 1452
rlm@1 1453 void VBAMovieFreeze(uint8 * *buf, uint32 *size)
rlm@1 1454 {
rlm@33 1455 // sanity check
rlm@33 1456 if (!VBAMovieActive())
rlm@33 1457 {
rlm@33 1458 return;
rlm@33 1459 }
rlm@1 1460
rlm@33 1461 *buf = NULL;
rlm@33 1462 *size = 0;
rlm@1 1463
rlm@33 1464 // compute size needed for the buffer
rlm@33 1465 // room for header.uid, currentFrame, and header.length_frames
rlm@33 1466 uint32 size_needed = sizeof(Movie.header.uid) + sizeof(Movie.currentFrame) + sizeof(Movie.header.length_frames);
rlm@33 1467 size_needed += (uint32)(Movie.bytesPerFrame * Movie.header.length_frames);
rlm@33 1468 *buf = new uint8[size_needed];
rlm@33 1469 *size = size_needed;
rlm@1 1470
rlm@33 1471 uint8 *ptr = *buf;
rlm@33 1472 if (!ptr)
rlm@33 1473 {
rlm@33 1474 return;
rlm@33 1475 }
rlm@1 1476
rlm@33 1477 Push32(Movie.header.uid, ptr);
rlm@33 1478 Push32(Movie.currentFrame, ptr);
rlm@33 1479 Push32(Movie.header.length_frames - 1, ptr); // HACK: shorten the length by 1 for backward compatibility
rlm@1 1480
rlm@33 1481 memcpy(ptr, Movie.inputBuffer, Movie.bytesPerFrame * Movie.header.length_frames);
rlm@1 1482 }
rlm@1 1483
rlm@1 1484 int VBAMovieUnfreeze(const uint8 *buf, uint32 size)
rlm@1 1485 {
rlm@33 1486 // sanity check
rlm@33 1487 if (!VBAMovieActive())
rlm@33 1488 {
rlm@33 1489 return MOVIE_NOT_FROM_A_MOVIE;
rlm@33 1490 }
rlm@33 1491
rlm@33 1492 const uint8 *ptr = buf;
rlm@33 1493 if (size < sizeof(Movie.header.uid) + sizeof(Movie.currentFrame) + sizeof(Movie.header.length_frames))
rlm@33 1494 {
rlm@33 1495 return MOVIE_WRONG_FORMAT;
rlm@33 1496 }
rlm@33 1497
rlm@33 1498 uint32 movie_id = Pop32(ptr);
rlm@33 1499 uint32 current_frame = Pop32(ptr);
rlm@33 1500 uint32 end_frame = Pop32(ptr) + 1; // HACK: restore the length for backward compatibility
rlm@33 1501 uint32 space_needed = Movie.bytesPerFrame * end_frame;
rlm@33 1502
rlm@33 1503 if (movie_id != Movie.header.uid)
rlm@33 1504 return MOVIE_NOT_FROM_THIS_MOVIE;
rlm@33 1505
rlm@33 1506 if (space_needed > size)
rlm@33 1507 return MOVIE_WRONG_FORMAT;
rlm@33 1508
rlm@33 1509 if (Movie.readOnly)
rlm@33 1510 {
rlm@33 1511 // here, we are going to keep the input data from the movie file
rlm@33 1512 // and simply rewind to the currentFrame pointer
rlm@33 1513 // this will cause a desync if the savestate is not in sync // <-- NOT ANYMORE
rlm@33 1514 // with the on-disk recording data, but it's easily solved
rlm@33 1515 // by loading another savestate or playing the movie from the beginning
rlm@33 1516
rlm@33 1517 // don't allow loading a state inconsistent with the current movie
rlm@33 1518 uint32 length_history = min(current_frame, Movie.header.length_frames);
rlm@33 1519 if (end_frame < length_history)
rlm@33 1520 return MOVIE_SNAPSHOT_INCONSISTENT;
rlm@33 1521
rlm@33 1522 uint32 space_shared = Movie.bytesPerFrame * length_history;
rlm@33 1523 if (memcmp(Movie.inputBuffer, ptr, space_shared))
rlm@33 1524 return MOVIE_SNAPSHOT_INCONSISTENT;
rlm@33 1525
rlm@33 1526 Movie.currentFrame = current_frame;
rlm@33 1527 Movie.inputBufferPtr = Movie.inputBuffer + Movie.bytesPerFrame * min(current_frame, Movie.header.length_frames);
rlm@33 1528 }
rlm@33 1529 else
rlm@33 1530 {
rlm@33 1531 // here, we are going to take the input data from the savestate
rlm@33 1532 // and make it the input data for the current movie, then continue
rlm@33 1533 // writing new input data at the currentFrame pointer
rlm@33 1534 Movie.currentFrame = current_frame;
rlm@33 1535 Movie.header.length_frames = end_frame;
rlm@33 1536 if (!VBALuaRerecordCountSkip())
rlm@33 1537 ++Movie.header.rerecord_count;
rlm@33 1538
rlm@33 1539 Movie.RecordedThisSession = true;
rlm@33 1540
rlm@33 1541 // do this before calling reserve_buffer_space()
rlm@33 1542 Movie.inputBufferPtr = Movie.inputBuffer + Movie.bytesPerFrame * min(current_frame, Movie.header.length_frames);
rlm@33 1543 reserve_buffer_space(space_needed);
rlm@33 1544 memcpy(Movie.inputBuffer, ptr, space_needed);
rlm@33 1545
rlm@33 1546 // for consistency, no auto movie conversion here since we don't auto convert the corresponding savestate
rlm@33 1547 flush_movie_header();
rlm@33 1548 flush_movie_frames();
rlm@33 1549 }
rlm@33 1550
rlm@33 1551 change_state(MOVIE_STATE_PLAY); // check for movie end
rlm@33 1552
rlm@33 1553 // necessary!
rlm@33 1554 resetSignaled = false;
rlm@33 1555 resetSignaledLast = false;
rlm@33 1556
rlm@33 1557 // necessary to check if there's a reset signal at the previous frame
rlm@33 1558 if (current_frame > 0)
rlm@33 1559 {
rlm@33 1560 const u8 NEW_RESET = u8(BUTTON_MASK_NEW_RESET >> 8);
rlm@33 1561 for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)
rlm@1 1562 {
rlm@33 1563 if ((Movie.header.controllerFlags & MOVIE_CONTROLLER(i)) && (*(Movie.inputBufferPtr+1- Movie.bytesPerFrame) & NEW_RESET))
rlm@33 1564 {
rlm@33 1565 resetSignaledLast = true;
rlm@33 1566 break;
rlm@33 1567 }
rlm@1 1568 }
rlm@33 1569 }
rlm@1 1570
rlm@33 1571 return MOVIE_SUCCESS;
rlm@1 1572 }
rlm@1 1573
rlm@1 1574 bool VBAMovieEnded()
rlm@1 1575 {
rlm@33 1576 return (Movie.state == MOVIE_STATE_END);
rlm@33 1577 // return (Movie.state != MOVIE_STATE_NONE && Movie.currentFrame >= Movie.header.length_frames);
rlm@1 1578 }
rlm@1 1579
rlm@1 1580 bool VBAMovieAllowsRerecording()
rlm@1 1581 {
rlm@33 1582 bool allows = (Movie.state != MOVIE_STATE_NONE) && (Movie.currentFrame <= Movie.header.length_frames);
rlm@33 1583 return /*!VBAMovieReadOnly() &&*/ allows;
rlm@1 1584 }
rlm@1 1585
rlm@1 1586 bool VBAMovieSwitchToPlaying()
rlm@1 1587 {
rlm@33 1588 if (!VBAMovieActive())
rlm@33 1589 return false;
rlm@1 1590
rlm@33 1591 if (!Movie.readOnly)
rlm@33 1592 {
rlm@33 1593 VBAMovieToggleReadOnly();
rlm@33 1594 }
rlm@1 1595
rlm@33 1596 change_state(MOVIE_STATE_PLAY);
rlm@33 1597 if (Movie.state == MOVIE_STATE_PLAY)
rlm@33 1598 systemScreenMessage("Movie replay (continue)");
rlm@33 1599 else
rlm@33 1600 systemScreenMessage("Movie end");
rlm@1 1601
rlm@33 1602 return true;
rlm@1 1603 }
rlm@1 1604
rlm@1 1605 bool VBAMovieSwitchToRecording()
rlm@1 1606 {
rlm@33 1607 if (!VBAMovieAllowsRerecording())
rlm@33 1608 return false;
rlm@1 1609
rlm@33 1610 if (Movie.readOnly)
rlm@33 1611 {
rlm@33 1612 VBAMovieToggleReadOnly();
rlm@33 1613 }
rlm@1 1614
rlm@33 1615 if (!VBALuaRerecordCountSkip())
rlm@33 1616 ++Movie.header.rerecord_count;
rlm@1 1617
rlm@33 1618 change_state(MOVIE_STATE_RECORD);
rlm@33 1619 systemScreenMessage("Movie re-record");
rlm@1 1620
rlm@33 1621 //truncate_movie(Movie.currentFrame);
rlm@1 1622
rlm@33 1623 return true;
rlm@1 1624 }
rlm@1 1625
rlm@1 1626 uint32 VBAMovieGetState()
rlm@1 1627 {
rlm@33 1628 // ?
rlm@33 1629 if (!VBAMovieActive())
rlm@33 1630 return MOVIE_STATE_NONE;
rlm@1 1631
rlm@33 1632 return Movie.state;
rlm@1 1633 }
rlm@1 1634
rlm@1 1635 void VBAMovieSignalReset()
rlm@1 1636 {
rlm@33 1637 if (VBAMovieActive())
rlm@33 1638 resetSignaled = true;
rlm@1 1639 }
rlm@1 1640
rlm@1 1641 void VBAMovieResetIfRequested()
rlm@1 1642 {
rlm@33 1643 if (resetSignaled)
rlm@33 1644 {
rlm@33 1645 theEmulator.emuReset(false);
rlm@33 1646 resetSignaled = false;
rlm@33 1647 resetSignaledLast = true;
rlm@33 1648 }
rlm@33 1649 else
rlm@33 1650 {
rlm@33 1651 resetSignaledLast = false;
rlm@33 1652 }
rlm@1 1653 }
rlm@1 1654
rlm@1 1655 void VBAMovieSetMetadata(const char *info)
rlm@1 1656 {
rlm@33 1657 if (!memcmp(Movie.authorInfo, info, MOVIE_METADATA_SIZE))
rlm@33 1658 return;
rlm@1 1659
rlm@33 1660 memcpy(Movie.authorInfo, info, MOVIE_METADATA_SIZE); // strncpy would omit post-0 bytes
rlm@33 1661 Movie.authorInfo[MOVIE_METADATA_SIZE - 1] = '\0';
rlm@1 1662
rlm@33 1663 if (Movie.file)
rlm@33 1664 {
rlm@33 1665 // (over-)write the header
rlm@33 1666 fseek(Movie.file, 0, SEEK_SET);
rlm@1 1667
rlm@33 1668 write_movie_header(Movie.file, Movie);
rlm@1 1669
rlm@33 1670 // write the metadata / author info to file
rlm@33 1671 fwrite(Movie.authorInfo, 1, sizeof(char) * MOVIE_METADATA_SIZE, Movie.file);
rlm@33 1672
rlm@33 1673 fflush(Movie.file);
rlm@33 1674 }
rlm@39 1675 //printf("RLM: setMetadata called\n");
rlm@33 1676
rlm@1 1677 }
rlm@1 1678
rlm@1 1679 void VBAMovieRestart()
rlm@1 1680 {
rlm@33 1681 if (VBAMovieActive())
rlm@33 1682 {
rlm@33 1683 systemSoundClearBuffer();
rlm@1 1684
rlm@33 1685 bool8 modified = Movie.RecordedThisSession;
rlm@1 1686
rlm@33 1687 VBAMovieStop(true);
rlm@1 1688
rlm@33 1689 char movieName [_MAX_PATH];
rlm@33 1690 strncpy(movieName, Movie.filename, _MAX_PATH);
rlm@33 1691 movieName[_MAX_PATH - 1] = '\0';
rlm@33 1692 VBAMovieOpen(movieName, Movie.readOnly); // can't just pass in Movie.filename, since VBAMovieOpen clears out Movie's
rlm@33 1693 // variables
rlm@1 1694
rlm@33 1695 Movie.RecordedThisSession = modified;
rlm@1 1696
rlm@33 1697 systemScreenMessage("Movie replay (restart)");
rlm@33 1698 }
rlm@1 1699 }
rlm@1 1700
rlm@1 1701 int VBAMovieGetPauseAt()
rlm@1 1702 {
rlm@33 1703 return Movie.pauseFrame;
rlm@1 1704 }
rlm@1 1705
rlm@1 1706 void VBAMovieSetPauseAt(int at)
rlm@1 1707 {
rlm@33 1708 Movie.pauseFrame = at;
rlm@1 1709 }
rlm@1 1710
rlm@1 1711 ///////////////////////
rlm@1 1712 // movie tools
rlm@1 1713
rlm@1 1714 // FIXME: is it safe to convert/flush a movie while recording it (considering fseek() problem)?
rlm@1 1715 int VBAMovieConvertCurrent()
rlm@1 1716 {
rlm@33 1717 if (!VBAMovieActive())
rlm@33 1718 {
rlm@33 1719 return MOVIE_NOTHING;
rlm@33 1720 }
rlm@33 1721
rlm@33 1722 if (Movie.header.minorVersion > VBM_REVISION)
rlm@33 1723 {
rlm@33 1724 return MOVIE_WRONG_VERSION;
rlm@33 1725 }
rlm@33 1726
rlm@33 1727 if (Movie.header.minorVersion == VBM_REVISION)
rlm@33 1728 {
rlm@33 1729 return MOVIE_NOTHING;
rlm@33 1730 }
rlm@33 1731
rlm@33 1732 Movie.header.minorVersion = VBM_REVISION;
rlm@33 1733
rlm@33 1734 if (Movie.header.length_frames == 0) // this could happen
rlm@33 1735 {
rlm@33 1736 truncate_movie(0);
rlm@33 1737 return MOVIE_SUCCESS;
rlm@33 1738 }
rlm@33 1739
rlm@33 1740 // fix movies recorded from snapshots
rlm@33 1741 if (Movie.header.startFlags & MOVIE_START_FROM_SNAPSHOT)
rlm@33 1742 {
rlm@33 1743 uint8 *firstFramePtr = Movie.inputBuffer;
rlm@33 1744 for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)
rlm@1 1745 {
rlm@33 1746 if (Movie.header.controllerFlags & MOVIE_CONTROLLER(i))
rlm@33 1747 {
rlm@33 1748 Push16(initialInputs[i], firstFramePtr);
rlm@33 1749 // note: this is correct since Push16 advances the dest pointer by sizeof u16
rlm@33 1750 }
rlm@1 1751 }
rlm@33 1752 }
rlm@1 1753
rlm@33 1754 // convert old resets to new ones
rlm@33 1755 const u8 OLD_RESET = u8(BUTTON_MASK_OLD_RESET >> 8);
rlm@33 1756 const u8 NEW_RESET = u8(BUTTON_MASK_NEW_RESET >> 8);
rlm@33 1757 for (int i = 0; i < MOVIE_NUM_OF_POSSIBLE_CONTROLLERS; ++i)
rlm@33 1758 {
rlm@33 1759 if (Movie.header.controllerFlags & MOVIE_CONTROLLER(i))
rlm@1 1760 {
rlm@33 1761 uint8 *startPtr = Movie.inputBuffer + sizeof(u16) * i + 1;
rlm@33 1762 uint8 *endPtr = Movie.inputBuffer + Movie.bytesPerFrame * (Movie.header.length_frames - 1);
rlm@33 1763 for (; startPtr < endPtr; startPtr += Movie.bytesPerFrame)
rlm@33 1764 {
rlm@33 1765 if (startPtr[Movie.bytesPerFrame] & OLD_RESET)
rlm@33 1766 {
rlm@33 1767 startPtr[0] |= NEW_RESET;
rlm@33 1768 }
rlm@33 1769 }
rlm@1 1770 }
rlm@33 1771 }
rlm@1 1772
rlm@33 1773 flush_movie_header();
rlm@33 1774 flush_movie_frames();
rlm@33 1775 return MOVIE_SUCCESS;
rlm@1 1776 }
rlm@1 1777
rlm@1 1778 bool VBAMovieTuncateAtCurrentFrame()
rlm@1 1779 {
rlm@33 1780 if (!VBAMovieActive())
rlm@33 1781 return false;
rlm@1 1782
rlm@33 1783 truncate_movie(Movie.currentFrame);
rlm@33 1784 change_state(MOVIE_STATE_END);
rlm@33 1785 systemScreenMessage("Movie truncated");
rlm@1 1786
rlm@33 1787 return true;
rlm@1 1788 }
rlm@1 1789
rlm@1 1790 bool VBAMovieFixHeader()
rlm@1 1791 {
rlm@33 1792 if (!VBAMovieActive())
rlm@33 1793 return false;
rlm@1 1794
rlm@33 1795 flush_movie_header();
rlm@33 1796 systemScreenMessage("Movie header fixed");
rlm@33 1797 return true;
rlm@1 1798 }