2006-07-29 05:46:15 +00:00
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
2008-05-22 07:43:48 +00:00
# include <assert.h>
2008-05-23 09:58:38 +00:00
# include <vector>
# include <map>
2006-07-30 22:49:15 +00:00
# ifdef MSVC
2006-07-29 05:46:15 +00:00
# include <windows.h>
# endif
# include "types.h"
2006-08-01 05:50:19 +00:00
# include "utils/endian.h"
2006-07-29 05:46:15 +00:00
# include "palette.h"
# include "input.h"
# include "fceu.h"
# include "driver.h"
# include "state.h"
2006-08-01 05:50:19 +00:00
# include "file.h"
2006-07-29 05:46:15 +00:00
# include "video.h"
# include "movie.h"
2008-05-23 09:58:38 +00:00
# include "utils/memory.h"
# include "utils/xstring.h"
2006-07-29 05:46:15 +00:00
# define MOVIE_MAGIC 0x1a4d4346 // FCM\x1a
2008-05-23 09:58:38 +00:00
# define MOVIE_VERSION 3 // still at 2 since the format itself is still compatible - to detect which version the movie was made with, check the fceu version stored in the movie header (e.g against FCEU_VERSION_NUMERIC)
2006-07-29 05:46:15 +00:00
# define MOVIE_FLAG_NOSYNCHACK (1<<4) // set in newer version, used for old movie compatibility
// backwards compat
static void FCEUI_LoadMovie_v1 ( char * fname , int _read_only ) ;
static int FCEUI_MovieGetInfo_v1 ( const char * fname , MOVIE_INFO * info ) ;
extern char FileBase [ ] ;
2008-05-23 09:58:38 +00:00
//TODO - remove the synchack stuff from the replay gui and require it to be put into the fm2 file
//which the user would have already converted from fcm
//also cleanup the whole emulator version bullshit in replay. we dont support that old stuff anymore
2006-07-29 05:46:15 +00:00
/*
struct MovieHeader
{
2008-05-22 07:43:48 +00:00
uint32 magic ; // +0
uint32 version = 2 ; // +4
uint8 flags [ 4 ] ; // +8
uint32 length_frames ; // +12
uint32 rerecord_count ; // +16
uint32 movie_data_size ; // +20
uint32 offset_to_savestate ; // +24, should be 4-byte-aligned
uint32 offset_to_movie_data ; // +28, should be 4-byte-aligned
uint8 md5_of_rom_used [ 16 ] ; // +32
uint32 version_of_emu_used // +48
char name_of_rom_used [ ] // +52, utf-8, null-terminated
char metadata [ ] ; // utf-8, null-terminated
uint8 padding [ ] ;
uint8 savestate [ ] ; // always present, even in a "from reset" recording
uint8 padding [ ] ; // used for byte-alignment
uint8 movie_data [ ] ;
2006-07-29 05:46:15 +00:00
}
*/
2008-05-23 09:58:38 +00:00
FILE * slots ;
2006-07-29 05:46:15 +00:00
static int current = 0 ; // > 0 for recording, < 0 for playback
2008-05-22 07:43:48 +00:00
static uint8 joop [ 4 ] ; //mbg 5/22/08 - seems to be a snapshot of the joystates for delta compression
2006-07-29 05:46:15 +00:00
static uint32 framets = 0 ;
static uint32 frameptr = 0 ;
static uint8 * moviedata = NULL ;
static uint32 moviedatasize = 0 ;
static uint32 firstframeoffset = 0 ;
static uint32 savestate_offset = 0 ;
static uint32 framecount = 0 ;
static uint32 rerecord_count = 0 ;
/*static*/ int movie_readonly = 1 ;
2008-05-23 09:58:38 +00:00
static uint32 pauseframe = 0 ;
2006-07-29 05:46:15 +00:00
int frame_display = 0 ;
static uint32 last_frame_display = ~ 0 ;
int input_display = 0 ;
uint32 cur_input_display = 0 ;
static uint32 last_input_display = ~ 0 ;
int resetDMCacc = 0 ;
2008-05-23 09:58:38 +00:00
int justAutoConverted = 0 ; //PLEASE REMOVE ME
2006-07-29 05:46:15 +00:00
/* Cache variables used for playback. */
static uint32 nextts = 0 ;
static int32 nextd = 0 ;
SFORMAT FCEUMOV_STATEINFO [ ] = {
2008-05-22 07:43:48 +00:00
{ joop , 4 , " JOOP " } ,
{ & framets , 4 | FCEUSTATE_RLSB , " FTS " } ,
{ & nextts , 4 | FCEUSTATE_RLSB , " NXTS " } ,
{ & nextd , 4 | FCEUSTATE_RLSB , " NXTD " } ,
{ & frameptr , 4 | FCEUSTATE_RLSB , " FPTR " } ,
{ & framecount , 4 | FCEUSTATE_RLSB , " FCNT " } ,
{ 0 }
2006-07-29 05:46:15 +00:00
} ;
static int MovieShow = 0 ;
2008-05-23 09:58:38 +00:00
//sometimes we accidentally produce movie stop signals while we're trying to do other things with movies..
bool suppressMovieStop = false ;
2006-07-29 05:46:15 +00:00
2008-05-23 09:58:38 +00:00
int movieConvertOffset1 = 0 , movieConvertOffset2 = 0 , movieConvertOK = 0 , movieSyncHackOn = 0 ;
//todo - consider a MemoryBackedFile class..
//..a lot of work.. instead lets just read back from the current fcm
static enum EMOVIEMODE
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
MOVIEMODE_INACTIVE , MOVIEMODE_RECORD , MOVIEMODE_PLAY
} movieMode = MOVIEMODE_INACTIVE ;
2006-07-29 05:46:15 +00:00
2008-05-23 09:58:38 +00:00
//this should not be set unless we are in MOVIEMODE_RECORD!
FILE * fpRecordingMovie = 0 ;
int currFrameCounter ;
int FCEUMOV_GetFrame ( void )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
return currFrameCounter ;
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
bool FCEUMOV_ShouldPause ( void )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
if ( pauseframe & & currFrameCounter = = pauseframe )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
pauseframe = 0 ; //only pause once!
return true ;
2006-07-29 05:46:15 +00:00
}
else
{
2008-05-23 09:58:38 +00:00
return false ;
2006-07-29 05:46:15 +00:00
}
}
2008-05-23 09:58:38 +00:00
int FCEUMOV_IsPlaying ( void )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
return movieMode = = MOVIEMODE_PLAY ;
}
2007-02-06 18:59:15 +00:00
2008-05-23 09:58:38 +00:00
int FCEUMOV_IsRecording ( void )
{
return movieMode = = MOVIEMODE_RECORD ;
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
char curMovieFilename [ 512 ] ;
class MovieRecord
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
public :
ValueArray < uint8 , 4 > joysticks ;
} ;
2006-07-29 05:46:15 +00:00
2008-05-23 09:58:38 +00:00
class MovieData
{
public :
MovieData ( )
: version ( MOVIE_VERSION )
, emuVersion ( FCEU_VERSION_NUMERIC )
, palFlag ( false )
, poweronFlag ( false )
, resetFlag ( false )
{
memset ( & romChecksum , 0 , sizeof ( MD5DATA ) ) ;
}
2006-07-29 05:46:15 +00:00
2008-05-23 09:58:38 +00:00
int emuVersion ;
int version ;
//todo - somehow force mutual exclusion for poweron and reset (with an error in the parser)
bool palFlag ;
bool poweronFlag ;
bool resetFlag ;
MD5DATA romChecksum ;
std : : string romFilename ;
std : : vector < char > savestate ;
std : : vector < MovieRecord > records ;
class TDictionary : public std : : map < std : : string , std : : string >
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
public :
bool containsKey ( std : : string key )
{
return find ( key ) ! = end ( ) ;
}
2006-07-29 05:46:15 +00:00
2008-05-23 09:58:38 +00:00
void tryInstallBool ( std : : string key , bool & val )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
if ( containsKey ( key ) )
val = atoi ( operator [ ] ( key ) . c_str ( ) ) ! = 0 ;
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
void tryInstallString ( std : : string key , std : : string & val )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
if ( containsKey ( key ) )
val = operator [ ] ( key ) ;
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
void tryInstallInt ( std : : string key , int & val )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
if ( containsKey ( key ) )
val = atoi ( operator [ ] ( key ) . c_str ( ) ) ;
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
} ;
void installDictionary ( TDictionary & dictionary )
{
dictionary . tryInstallInt ( " version " , version ) ;
dictionary . tryInstallInt ( " emuVersion " , emuVersion ) ;
dictionary . tryInstallBool ( " palFlag " , palFlag ) ;
dictionary . tryInstallBool ( " poweronFlag " , poweronFlag ) ;
dictionary . tryInstallBool ( " resetFlag " , resetFlag ) ;
dictionary . tryInstallString ( " romFilename " , romFilename ) ;
if ( dictionary . containsKey ( " romChecksum " ) )
StringToBytes ( dictionary [ " romChecksum " ] , & romChecksum , MD5DATA : : size ) ;
if ( dictionary . containsKey ( " savestate " ) )
{
std : : string & str = dictionary [ " savestate " ] ;
int len = HexStringToBytesLength ( str ) ;
if ( len > = 1 )
{
savestate . resize ( len ) ;
StringToBytes ( str , & savestate [ 0 ] , len ) ;
}
}
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
} currMovieData ;
void DumpCurrentHeader ( FILE * fp )
{
fprintf ( fp , " :version %d \n " , currMovieData . version ) ;
fprintf ( fp , " :emuVersion %d \n " , currMovieData . emuVersion ) ;
fprintf ( fp , " :palFlag %d \n " , currMovieData . palFlag ? 1 : 0 ) ;
fprintf ( fp , " :poweronFlag %d \n " , currMovieData . poweronFlag ? 1 : 0 ) ;
fprintf ( fp , " :resetFlag %d \n " , currMovieData . resetFlag ? 1 : 0 ) ;
fprintf ( fp , " :romFilename %s \n " , currMovieData . romFilename . c_str ( ) ) ;
fprintf ( fp , " :romChecksum %s \n " , BytesToString ( currMovieData . romChecksum . data , MD5DATA : : size ) . c_str ( ) ) ;
if ( currMovieData . savestate . size ( ) ! = 0 )
fprintf ( fp , " :savestate %s \n " , BytesToString ( & currMovieData . savestate [ 0 ] , currMovieData . savestate . size ( ) ) . c_str ( ) ) ;
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
//yuck... another custom text parser.
void LoadFM2 ( MovieData & movieData , FILE * fp )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
MovieData : : TDictionary dictionary ;
std : : string key , value ;
enum {
NEWLINE , KEY , SEPARATOR , VALUE , RECORD
} state = NEWLINE ;
bool bail = false ;
for ( ; ; )
2007-02-06 18:59:15 +00:00
{
2008-05-23 09:58:38 +00:00
int c = fgetc ( fp ) ;
if ( c = = - 1 )
goto bail ;
bool iswhitespace = ( c = = ' ' | | c = = ' \t ' ) ;
bool iskeychar = ( c = = ' : ' ) ;
bool isnewline = ( c = = 10 | | c = = 13 ) ;
switch ( state )
{
case NEWLINE :
if ( isnewline ) goto done ;
if ( iskeychar )
{
key = " " ;
value = " " ;
state = KEY ;
goto done ;
}
goto dorecord ;
break ;
case RECORD : {
dorecord :
MovieRecord record ;
ungetc ( c , fp ) ;
//for each joystick
for ( int i = 0 ; i < 4 ; i + + )
{
uint8 & joystate = record . joysticks [ i ] ;
joystate = 0 ;
for ( int bit = 7 ; bit > = 0 ; bit - - )
{
int c = fgetc ( fp ) ;
if ( c = = - 1 )
goto bail ;
if ( c ! = ' ' )
joystate | = ( 1 < < bit ) ;
}
//eat the separator (a pipe or a newline)
fgetc ( fp ) ;
}
movieData . records . push_back ( record ) ;
state = NEWLINE ;
break ;
}
case KEY :
dokey : //dookie
state = KEY ;
if ( iswhitespace ) goto doseparator ;
if ( isnewline ) goto commit ;
key + = c ;
break ;
case SEPARATOR :
doseparator :
state = SEPARATOR ;
if ( isnewline ) goto commit ;
if ( ! iswhitespace ) goto dovalue ;
break ;
case VALUE :
dovalue :
state = VALUE ;
if ( isnewline ) goto commit ;
value + = c ;
}
goto done ;
bail :
bail = true ;
if ( state = = VALUE ) goto commit ;
commit :
dictionary [ key ] = value ;
state = NEWLINE ;
if ( bail ) break ;
done : ;
2007-02-06 18:59:15 +00:00
}
2008-05-23 09:58:38 +00:00
movieData . installDictionary ( dictionary ) ;
}
2007-02-06 18:59:15 +00:00
2008-05-23 09:58:38 +00:00
/// Stop movie playback.
void StopPlayback ( )
{
FCEU_DispMessage ( " Movie playback stopped. " ) ;
movieMode = MOVIEMODE_INACTIVE ;
}
/// Stop movie recording
void StopRecording ( )
{
FCEU_DispMessage ( " Movie recording stopped. " ) ;
movieMode = MOVIEMODE_INACTIVE ;
//mbg todo - think about this
resetDMCacc = movieSyncHackOn = 0 ;
2007-02-06 18:59:15 +00:00
2008-05-23 09:58:38 +00:00
//mbg todo - think about this
//DoEncode(0,0,1); // Write a dummy timestamp value so that the movie will keep "playing" after user input has stopped.
//mbg todo - add the equivalent
// finish header
//MovieFlushHeader();
2007-02-06 18:59:15 +00:00
// FIXME: truncate movie to length
// ftruncate();
2008-05-23 09:58:38 +00:00
fclose ( fpRecordingMovie ) ;
fpRecordingMovie = 0 ;
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
2007-02-06 18:59:15 +00:00
void FCEUI_StopMovie ( )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
if ( suppressMovieStop )
return ;
if ( movieMode = = MOVIEMODE_PLAY )
2007-02-06 18:59:15 +00:00
StopPlayback ( ) ;
2008-05-23 09:58:38 +00:00
else if ( movieMode = = MOVIEMODE_RECORD )
2007-02-06 18:59:15 +00:00
StopRecording ( ) ;
2006-07-29 05:46:15 +00:00
}
void ParseGIInput ( FCEUGI * GI ) ; //mbg merge 7/17/06 - had to add. gross.
void InitOtherInput ( void ) ; //mbg merge 7/17/06 - had to add. gross.
static void ResetInputTypes ( )
{
2006-07-30 22:49:15 +00:00
# ifdef MSVC
2008-05-22 07:43:48 +00:00
extern int UsrInputType [ 3 ] ;
UsrInputType [ 0 ] = SI_GAMEPAD ;
UsrInputType [ 1 ] = SI_GAMEPAD ;
UsrInputType [ 2 ] = SIFC_NONE ;
2006-07-29 05:46:15 +00:00
2008-05-22 07:43:48 +00:00
ParseGIInput ( NULL /*GameInfo*/ ) ;
extern int cspec , gametype ;
cspec = GameInfo - > cspecial ;
gametype = GameInfo - > type ;
2006-07-29 05:46:15 +00:00
2008-05-22 07:43:48 +00:00
InitOtherInput ( ) ;
2006-07-29 05:46:15 +00:00
# endif
}
2008-05-23 09:58:38 +00:00
//begin playing an existing movie
void FCEUI_LoadMovie ( char * fname , int _read_only , int _pauseframe )
2006-07-29 05:46:15 +00:00
{
2008-05-23 09:58:38 +00:00
assert ( fname ) ;
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
pauseframe = _pauseframe ;
2008-05-22 07:43:48 +00:00
FCEUI_StopMovie ( ) ;
2008-05-23 09:58:38 +00:00
currMovieData = MovieData ( ) ;
FILE * fp = FCEUD_UTF8fopen ( fname , " rb " ) ;
LoadFM2 ( currMovieData , fp ) ;
fclose ( fp ) ;
2008-05-22 07:43:48 +00:00
// fully reload the game to reinitialize everything before playing any movie
// to try fixing nondeterministic playback of some games
{
extern char lastLoadedGameName [ 2048 ] ;
extern int disableBatteryLoading , suppressAddPowerCommand ;
suppressAddPowerCommand = 1 ;
2008-05-23 09:58:38 +00:00
suppressMovieStop = true ;
2008-05-22 07:43:48 +00:00
{
FCEUGI * gi = FCEUI_LoadGame ( lastLoadedGameName , 0 ) ;
2008-05-23 09:58:38 +00:00
//mbg 5/23/08 - wtf? why would this return null?
//if(!gi) PowerNES();
assert ( gi ) ;
2008-05-22 07:43:48 +00:00
}
2008-05-23 09:58:38 +00:00
suppressMovieStop = false ;
2008-05-22 07:43:48 +00:00
suppressAddPowerCommand = 0 ;
}
2008-05-23 09:58:38 +00:00
//todo - if reset flag is set, will the poweron flag be set?
//WE NEED TO LOAD A SAVESTATE
if ( ! currMovieData . poweronFlag )
2008-05-22 07:43:48 +00:00
{
2008-05-23 09:58:38 +00:00
FILE * fp = tmpfile ( ) ;
fwrite ( & currMovieData . savestate [ 0 ] , 1 , currMovieData . savestate . size ( ) , fp ) ;
fseek ( fp , 0 , SEEK_SET ) ;
bool success = FCEUSS_LoadFP ( fp , SSLOADPARAM_BACKUP ) ;
fclose ( fp ) ;
if ( ! success ) return ;
2008-05-22 07:43:48 +00:00
}
2008-05-23 09:58:38 +00:00
//TODO - handle reset flag
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
//...why do we have to do this. isnt it setup by the rom?
if ( currMovieData . palFlag )
2008-05-22 07:43:48 +00:00
FCEUI_SetVidSystem ( 1 ) ;
else
FCEUI_SetVidSystem ( 0 ) ;
2008-05-23 09:58:38 +00:00
//we really need to research this...
ResetInputTypes ( ) ;
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
currFrameCounter = 0 ;
movieMode = MOVIEMODE_PLAY ;
}
2008-05-22 07:43:48 +00:00
2006-07-29 05:46:15 +00:00
2008-05-23 09:58:38 +00:00
//begin recording a new movie
2006-07-29 05:46:15 +00:00
void FCEUI_SaveMovie ( char * fname , uint8 flags , const char * metadata )
{
2008-05-23 09:58:38 +00:00
assert ( fname ) ;
2008-05-22 07:43:48 +00:00
FCEUI_StopMovie ( ) ;
2008-05-23 09:58:38 +00:00
fpRecordingMovie = FCEUD_UTF8fopen ( fname , " wb " ) ;
if ( ! fpRecordingMovie )
2008-05-22 07:43:48 +00:00
{
2008-05-23 09:58:38 +00:00
FCEU_PrintError ( " Error opening movie output file: %s " , fname ) ;
2008-05-22 07:43:48 +00:00
}
2008-05-23 09:58:38 +00:00
movieMode = MOVIEMODE_RECORD ;
currMovieData = MovieData ( ) ;
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
//old sync management code:
//flags |= MOVIE_FLAG_NOSYNCHACK;
2008-05-22 07:43:48 +00:00
resetDMCacc = movieSyncHackOn = 0 ;
2008-05-23 09:58:38 +00:00
currMovieData . palFlag = FCEUI_GetCurrentVidSystem ( 0 , 0 ) ;
currMovieData . poweronFlag = ( flags & MOVIE_FLAG_FROM_POWERON ) ! = 0 ;
currMovieData . resetFlag = ( flags & MOVIE_FLAG_FROM_RESET ) ! = 0 ;
currMovieData . romChecksum = GameInfo - > MD5 ;
currMovieData . romFilename = FileBase ;
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
if ( currMovieData . poweronFlag )
2008-05-22 07:43:48 +00:00
{
2006-07-29 05:46:15 +00:00
// make a for-movie-recording power-on clear the game's save data, too
extern char lastLoadedGameName [ 2048 ] ;
extern int disableBatteryLoading , suppressAddPowerCommand ;
suppressAddPowerCommand = 1 ;
disableBatteryLoading = 1 ;
2008-05-23 09:58:38 +00:00
suppressMovieStop = true ;
2006-07-29 05:46:15 +00:00
{
// NOTE: this will NOT write an FCEUNPCMD_POWER into the movie file
2008-05-23 09:58:38 +00:00
FCEUGI * gi = FCEUI_LoadGame ( lastLoadedGameName , 0 ) ;
//mbg 5/23/08 - wtf? why would this return null?
//if(!gi) PowerNES();
assert ( gi ) ;
2006-07-29 05:46:15 +00:00
}
2008-05-23 09:58:38 +00:00
suppressMovieStop = false ;
2006-07-29 05:46:15 +00:00
disableBatteryLoading = 0 ;
suppressAddPowerCommand = 0 ;
2008-05-22 07:43:48 +00:00
}
else
{
2008-05-23 09:58:38 +00:00
//dump a savestate
FILE * tmp = tmpfile ( ) ;
FCEUSS_SaveFP ( tmp ) ;
fseek ( tmp , 0 , SEEK_END ) ;
int len = ( int ) ftell ( tmp ) ;
fseek ( tmp , 0 , SEEK_SET ) ;
currMovieData . savestate . resize ( len ) ;
fread ( & currMovieData . savestate [ 0 ] , 1 , len , tmp ) ;
fclose ( tmp ) ;
2008-05-22 07:43:48 +00:00
}
2008-05-23 09:58:38 +00:00
//we are going to go ahead and dump the header. from now on we will only be appending frames
DumpCurrentHeader ( fpRecordingMovie ) ;
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
//todo - think about this
2008-05-22 07:43:48 +00:00
ResetInputTypes ( ) ;
2008-05-23 09:58:38 +00:00
//todo - think about this
2008-05-23 04:11:35 +00:00
// trigger a reset
if ( flags & MOVIE_FLAG_FROM_RESET )
{
ResetNES ( ) ; // NOTE: this will write an FCEUNPCMD_RESET into the movie file
}
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
FCEU_DispMessage ( " Movie recording started. " ) ;
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
strcpy ( curMovieFilename , fname ) ;
2006-07-29 05:46:15 +00:00
}
static void movie_writechar ( int c )
{
2008-05-23 09:58:38 +00:00
fputc ( c , fpRecordingMovie ) ;
2006-07-29 05:46:15 +00:00
}
2008-05-22 07:43:48 +00:00
2006-07-29 05:46:15 +00:00
2008-05-22 07:43:48 +00:00
//the main interaction point between the emulator and the movie system.
//either dumps the current joystick state or loads one state from the movie
2006-07-29 05:46:15 +00:00
void FCEUMOV_AddJoy ( uint8 * js , int SkipFlush )
{
2008-05-22 07:43:48 +00:00
int x , y ;
2008-05-23 09:58:38 +00:00
if ( movieMode = = MOVIEMODE_PLAY )
2008-05-22 07:43:48 +00:00
{
//TODO - rock solid stability and error detection
2008-05-23 09:58:38 +00:00
//stop when we run out of frames
if ( currFrameCounter = = currMovieData . records . size ( ) )
2008-05-22 07:43:48 +00:00
{
2008-05-23 09:58:38 +00:00
StopPlayback ( ) ;
}
else
{
MovieRecord & mr = currMovieData . records [ currFrameCounter ] ;
for ( int i = 0 ; i < 4 ; i + + )
js [ i ] = mr . joysticks [ i ] ;
currFrameCounter + + ;
}
//pause the movie at a specified frame
if ( FCEUMOV_ShouldPause ( ) & & FCEUI_EmulationPaused ( ) = = 0 )
{
FCEUI_ToggleEmulationPause ( ) ;
FCEU_DispMessage ( " Paused at specified movie frame " ) ;
2008-05-22 07:43:48 +00:00
}
}
2008-05-23 09:58:38 +00:00
else if ( movieMode = = MOVIEMODE_RECORD )
2008-05-22 07:43:48 +00:00
{
//for each joystick
for ( int i = 0 ; i < 4 ; i + + )
{
//these are mnemonics for each joystick bit.
//since we usually use the regular joypad, these will be more helpful.
//but any character other than ' ' should count as a set bit
//maybe other input types will need to be encoded another way..
const char mnemonics [ ] = { ' A ' , ' B ' , ' S ' , ' T ' , ' U ' , ' D ' , ' L ' , ' R ' } ;
for ( int bit = 7 ; bit > = 0 ; bit - - )
{
uint8 & joystate = js [ i ] ;
int bitmask = ( 1 < < bit ) ;
char mnemonic = mnemonics [ bit ] ;
//if the bit is set write the mnemonic
if ( joystate & bitmask )
movie_writechar ( mnemonic ) ;
else //otherwise write a space
movie_writechar ( ' ' ) ;
}
//separate the joysticks
if ( i ! = 3 ) movie_writechar ( ' | ' ) ;
}
//each frame is on a new line
movie_writechar ( ' \n ' ) ;
}
memcpy ( & cur_input_display , js , 4 ) ;
2008-05-23 09:58:38 +00:00
2006-07-29 05:46:15 +00:00
}
void FCEUMOV_AddCommand ( int cmd )
{
2008-05-22 07:43:48 +00:00
if ( current < = 0 ) return ; // Return if not recording a movie
//printf("%d\n",cmd);
2006-07-29 05:46:15 +00:00
2008-05-23 09:58:38 +00:00
//MBG TODO BIG TODO TODO TODO
//DoEncode((cmd>>3)&0x3,cmd&0x7,1);
2006-07-29 05:46:15 +00:00
}
void FCEU_DrawMovies ( uint8 * XBuf )
{
2008-05-23 09:58:38 +00:00
//mbg todo
// int frameDisplayOn = current != 0 && frame_display;
// extern int howlong;
//#if MSVC
// extern int32 fps_scale;
//#else
// int32 fps_scale=256;
//#endif
// int howl=(180-(FCEUI_EmulationPaused()?(60):(20*fps_scale/256)));
// if(howl>176) howl=180;
// if(howl<1) howl=1;
// if((howlong<howl || movcounter)
// && (frameDisplayOn &&
// (!movcounter || last_frame_display!=framecount)))
// //|| input_display && (!movcounter || last_input_display!=cur_input_display)))
// {
// //Old input display code
// /*
// char inputstr [32];
// if(input_display)
// {
// uint32 c = cur_input_display;
// sprintf(inputstr, "%c%c%c%c%c%c%c%c %c%c%c%c%c%c%c%c",
// (c&0x40)?'<':' ', (c&0x10)?'^':' ', (c&0x80)?'>':' ', (c&0x20)?'v':' ',
// (c&0x01)?'A':' ', (c&0x02)?'B':' ', (c&0x08)?'S':' ', (c&0x04)?'s':' ',
// (c&0x4000)?'<':' ', (c&0x1000)?'^':' ', (c&0x8000)?'>':' ', (c&0x2000)?'v':' ',
// (c&0x0100)?'A':' ', (c&0x0200)?'B':' ', (c&0x0800)?'S':' ', (c&0x0400)?'s':' ');
// if(!(c&0xff00))
// inputstr[8] = '\0';
// }
// if(frameDisplayOn && !input_display)
// FCEU_DispMessage("%s frame %u",current >= 0?"Recording":"Playing",framecount);
// else if(input_display && !frameDisplayOn)
// FCEU_DispMessage("Input: %s",inputstr);
// else //if(input_display && frame_display)
// FCEU_DispMessage("%s %u %s",current >= 0?"Recording":"Playing",framecount,inputstr);
// */
// if(frameDisplayOn)
// {
// FCEU_DispMessage("%s frame %u",current >= 0?"Recording":"Playing",framecount);
// }
// last_frame_display = framecount;
// last_input_display = cur_input_display;
// movcounter=180-1;
// return;
// }
//
// if(movcounter) movcounter--;
//
// if(!MovieShow) return;
//
// FCEU_DrawNumberRow(XBuf,MovieStatus, CurrentMovie);
// MovieShow--;
2006-07-29 05:46:15 +00:00
}
int FCEUMOV_WriteState ( FILE * st )
{
2008-05-22 07:43:48 +00:00
uint32 to_write = 0 ;
if ( current < 0 )
to_write = moviedatasize ;
else if ( current > 0 )
to_write = frameptr ;
if ( ! st )
return to_write ;
if ( to_write )
fwrite ( moviedata , 1 , to_write , st ) ;
return to_write ;
2006-07-29 05:46:15 +00:00
}
static int load_successful ;
int FCEUMOV_ReadState ( FILE * st , uint32 size )
{
2008-05-23 09:58:38 +00:00
//// if this savestate was made while replaying,
//// we need to "undo" nextd and nextts
//if(nextd != -1)
//{
// int d = 1;
// if(nextts > 65536)
// d = 4;
// else if(nextts > 256)
// d = 3;
// else if(nextts > 0)
// d = 2;
// frameptr -= d;
// nextd = -1;
//}
//// if(current > 0 || (!movie_readonly && current < 0)) /* Recording or Playback (!read-only) */
//if(current!=0 && !movie_readonly)
//{
// // copy movie data from savestate
// moviedata = (uint8*)realloc(moviedata, size);
// moviedatasize = size;
// if(size && fread(moviedata, 1, size, st)<size)
// return 0;
// if(current < 0) // switch to recording
// current = -current;
// fseek(slots[current - 1], firstframeoffset, SEEK_SET);
// fwrite(moviedata, 1, frameptr, slots[current - 1]);
// if(!FCEU_BotMode())
// {
// rerecord_count++;
// }
//}
//// else if(current < 0) /* Playback (read-only) */
//else if(current!=0 && movie_readonly)
//{
// if(current > 0) // switch to playback
// current = -current;
// // allow frameptr to be updated but keep movie data
// fseek(st, size, SEEK_CUR);
// // prevent seeking beyond the end of the movie
// if(frameptr > moviedatasize)
// frameptr = moviedatasize;
//}
//else /* Neither recording or replaying */
//{
// // skip movie data
// fseek(st, size, SEEK_CUR);
//}
//load_successful=1;
//// Maximus: Show the last input combination entered from the
//// movie within the state
//if(current!=0) // <- mz: only if playing or recording a movie
// memcpy(&cur_input_display, joop, 4);
2008-05-22 07:43:48 +00:00
return 1 ;
2006-07-29 05:46:15 +00:00
}
void FCEUMOV_PreLoad ( void )
{
load_successful = 0 ;
}
int FCEUMOV_PostLoad ( void )
{
if ( ! FCEUI_IsMovieActive ( ) )
return 1 ;
else
return load_successful ;
}
int FCEUI_IsMovieActive ( void )
{
2008-05-23 09:58:38 +00:00
//this is a lame method. we should change all the fceu code that uses it to call the
//IsRecording or IsPlaying methods
//return > 0 for recording, < 0 for playback
if ( FCEUMOV_IsRecording ( ) ) return 1 ;
else if ( FCEUMOV_IsPlaying ( ) ) return - 1 ;
else return 0 ;
2006-07-29 05:46:15 +00:00
}
void FCEUI_MovieToggleFrameDisplay ( void )
{
2008-05-22 07:43:48 +00:00
frame_display = ! frame_display ;
if ( ! ( current ! = 0 & & frame_display ) ) // && !input_display)
FCEU_ResetMessages ( ) ;
else
{
last_frame_display = ~ framecount ;
last_input_display = ~ cur_input_display ;
}
2006-07-29 05:46:15 +00:00
}
void FCEUI_ToggleInputDisplay ( void )
{
switch ( input_display )
{
case 0 :
input_display = 1 ;
break ;
case 1 :
input_display = 2 ;
break ;
case 2 :
input_display = 4 ;
break ;
default :
input_display = 0 ;
break ;
}
2008-05-22 07:43:48 +00:00
//if(!input_display && !(current != 0 && frame_display))
//FCEU_ResetMessages();
//else
2006-07-29 05:46:15 +00:00
if ( input_display )
2008-05-22 07:43:48 +00:00
{
last_frame_display = ~ framecount ;
last_input_display = ~ cur_input_display ;
}
2006-07-29 05:46:15 +00:00
}
void FCEUI_MovieToggleReadOnly ( void )
{
if ( movie_readonly < 2 )
{
movie_readonly = ! movie_readonly ;
if ( movie_readonly )
FCEU_DispMessage ( " Movie is now Read-Only. " ) ;
else
FCEU_DispMessage ( " Movie is now Read+Write. " ) ;
}
else
{
FCEU_DispMessage ( " Movie file is Read-Only. " ) ;
}
}
int FCEUI_MovieGetInfo ( const char * fname , MOVIE_INFO * info )
{
2008-05-23 09:58:38 +00:00
memset ( info , 0 , sizeof ( MOVIE_INFO ) ) ;
2006-07-29 05:46:15 +00:00
2008-05-23 09:58:38 +00:00
MovieData md ;
FILE * fp = FCEUD_UTF8fopen ( fname , " rb " ) ;
if ( ! fp ) return 0 ;
LoadFM2 ( md , fp ) ;
fclose ( fp ) ;
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
info - > movie_version = md . version ;
info - > poweron = md . poweronFlag ;
info - > reset = md . resetFlag ;
info - > pal = md . palFlag ;
info - > nosynchack = true ;
info - > num_frames = md . records . size ( ) ;
info - > md5_of_rom_used = md . romChecksum ;
info - > md5_of_rom_used_present = 1 ;
info - > emu_version_used = md . emuVersion ;
info - > name_of_rom_used = md . romFilename ;
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
return 1 ;
}
2008-05-22 07:43:48 +00:00
2008-05-23 09:58:38 +00:00
//
//int _old_FCEUI_MovieGetInfo(const char* fname, MOVIE_INFO* info)
//{
// //mbg: wtf?
// //MovieFlushHeader();
//
// // main get info part of function
// {
// uint32 magic;
// uint32 version;
// uint8 _flags[4];
//
// FILE* fp = FCEUD_UTF8fopen(fname, "rb");
// if(!fp)
// return 0;
//
// read32le(&magic, fp);
// if(magic != MOVIE_MAGIC)
// {
// fclose(fp);
// return 0;
// }
//
// read32le(&version, fp);
// if(version != MOVIE_VERSION)
// {
// fclose(fp);
// if(version == 1)
// return FCEUI_MovieGetInfo_v1(fname, info);
// else
// return 0;
// }
//
// info->movie_version = MOVIE_VERSION;
//
// fread(_flags, 1, 4, fp);
//
// info->flags = _flags[0];
// read32le(&info->num_frames, fp);
// read32le(&info->rerecord_count, fp);
//
// if(access(fname, W_OK))
// info->read_only = 1;
// else
// info->read_only = 0;
//
// fseek(fp, 12, SEEK_CUR); // skip movie_data_size, offset_to_savestate, and offset_to_movie_data
//
// fread(&info->md5_of_rom_used, 1, 16, fp);
// info->md5_of_rom_used_present = 1;
//
// read32le(&info->emu_version_used, fp);
//
// // I probably could have planned this better...
// {
// char str[256];
// size_t r;
// uint32 p; //mbg merge 7/17/06 change to uint32
// int p2=0;
// char last_c=32;
//
// if(info->name_of_rom_used && info->name_of_rom_used_size)
// info->name_of_rom_used[0]='\0';
//
// r=fread(str, 1, 256, fp);
// while(r > 0)
// {
// for(p=0; p<r && last_c != '\0'; ++p)
// {
// if(info->name_of_rom_used && info->name_of_rom_used_size && (p2 < info->name_of_rom_used_size-1))
// {
// info->name_of_rom_used[p2]=str[p];
// p2++;
// last_c=str[p];
// }
// }
// if(p<r)
// {
// memmove(str, str+p, r-p);
// r -= p;
// break;
// }
// r=fread(str, 1, 256, fp);
// }
//
// p2=0;
// last_c=32;
//
// if(info->metadata && info->metadata_size)
// info->metadata[0]='\0';
//
// while(r > 0)
// {
// for(p=0; p<r && last_c != '\0'; ++p)
// {
// if(info->metadata && info->metadata_size && (p2 < info->metadata_size-1))
// {
// info->metadata[p2]=str[p];
// p2++;
// last_c=str[p];
// }
// }
// if(p != r)
// break;
// r=fread(str, 1, 256, fp);
// }
//
// if(r<=0)
// {
// // somehow failed to read romname and metadata
// fclose(fp);
// return 0;
// }
// }
//
// // check what hacks are necessary
// fseek(fp, 24, SEEK_SET); // offset_to_savestate offset
// uint32 temp_savestate_offset;
// read32le(&temp_savestate_offset, fp);
// if(temp_savestate_offset != 0xFFFFFFFF)
// {
// if(fseek(fp, temp_savestate_offset, SEEK_SET))
// {
// fclose(fp);
// return 0;
// }
//
// //don't really load, just load to find what's there then load backup
// if(!FCEUSS_LoadFP(fp,SSLOADPARAM_DUMMY)) return 0;
// }
//
// fclose(fp);
// return 1;
// }
//}
2006-07-29 05:46:15 +00:00
/*
2008-05-22 07:43:48 +00:00
Backwards compat
2006-07-29 05:46:15 +00:00
*/
/*
struct MovieHeader_v1
{
2008-05-22 07:43:48 +00:00
uint32 magic ;
uint32 version = 1 ;
uint8 flags [ 4 ] ;
uint32 length_frames ;
uint32 rerecord_count ;
uint32 movie_data_size ;
uint32 offset_to_savestate ;
uint32 offset_to_movie_data ;
uint16 metadata_ucs2 [ ] ; // ucs-2, ick! sizeof(metadata) = offset_to_savestate - MOVIE_HEADER_SIZE
2006-07-29 05:46:15 +00:00
}
*/
2008-05-23 09:58:38 +00:00
//
//#define MOVIE_V1_HEADER_SIZE 32
//
//static void FCEUI_LoadMovie_v1(char *fname, int _read_only)
//{
// FILE *fp;
// char *fn = NULL;
//
// FCEUI_StopMovie();
//
// if(!fname)
// fname = fn = FCEU_MakeFName(FCEUMKF_MOVIE,0,0);
//
// // check movie_readonly
// movie_readonly = _read_only;
// if(access(fname, W_OK))
// movie_readonly = 2;
//
// fp = FCEUD_UTF8fopen(fname, (movie_readonly>=2) ? "rb" : "r+b");
//
// if(fn)
// {
// free(fn);
// fname = NULL;
// }
//
// if(!fp) return;
//
// // read header
// {
// uint32 magic;
// uint32 version;
// uint8 flags[4];
// uint32 fc;
//
// read32le(&magic, fp);
// if(magic != MOVIE_MAGIC)
// {
// fclose(fp);
// return;
// }
//
// read32le(&version, fp);
// if(version != 1)
// {
// fclose(fp);
// return;
// }
//
// fread(flags, 1, 4, fp);
// read32le(&fc, fp);
// read32le(&rerecord_count, fp);
// read32le(&moviedatasize, fp);
// read32le(&savestate_offset, fp);
// read32le(&firstframeoffset, fp);
// if(fseek(fp, savestate_offset, SEEK_SET))
// {
// fclose(fp);
// return;
// }
//
// if(flags[0] & MOVIE_FLAG_NOSYNCHACK)
// movieSyncHackOn=0;
// else
// movieSyncHackOn=1;
// }
//
// // fully reload the game to reinitialize everything before playing any movie
// // to try fixing nondeterministic playback of some games
// {
// extern char lastLoadedGameName [2048];
// extern int disableBatteryLoading, suppressAddPowerCommand;
// suppressAddPowerCommand=1;
// suppressMovieStop=true;
// {
// FCEUGI * gi = FCEUI_LoadGame(lastLoadedGameName, 0);
// if(!gi)
// PowerNES();
// }
// suppressMovieStop=false;
// suppressAddPowerCommand=0;
// }
//
// if(!FCEUSS_LoadFP(fp,SSLOADPARAM_BACKUP)) return;
//
// ResetInputTypes();
//
// fseek(fp, firstframeoffset, SEEK_SET);
// moviedata = (uint8*)realloc(moviedata, moviedatasize);
// fread(moviedata, 1, moviedatasize, fp);
//
// framecount = 0; // movies start at frame 0!
// frameptr = 0;
// current = 0;
// slots = fp;
//
// memset(joop,0,sizeof(joop));
// current = -1 - current;
// framets=0;
// nextts=0;
// nextd = -1;
// FCEU_DispMessage("Movie playback started.");
//}
//
//static int FCEUI_MovieGetInfo_v1(const char* fname, MOVIE_INFO* info)
//{
// uint32 magic;
// uint32 version;
// uint8 _flags[4];
// uint32 savestateoffset;
// uint8 tmp[MOVIE_MAX_METADATA<<1];
// int metadata_length;
//
// FILE* fp = FCEUD_UTF8fopen(fname, "rb");
// if(!fp)
// return 0;
//
// read32le(&magic, fp);
// if(magic != MOVIE_MAGIC)
// {
// fclose(fp);
// return 0;
// }
//
// read32le(&version, fp);
// if(version != 1)
// {
// fclose(fp);
// return 0;
// }
//
// info->movie_version = 1;
// info->emu_version_used = 0; // unknown
//
// fread(_flags, 1, 4, fp);
//
// info->flags = _flags[0];
// read32le(&info->num_frames, fp);
// read32le(&info->rerecord_count, fp);
//
// if(access(fname, W_OK))
// info->read_only = 1;
// else
// info->read_only = 0;
//
// fseek(fp, 4, SEEK_CUR);
// read32le(&savestateoffset, fp);
//
// metadata_length = (int)savestateoffset - MOVIE_V1_HEADER_SIZE;
// if(metadata_length > 0)
// {
// //int i; //mbg merge 7/17/06 removed
//
// metadata_length >>= 1;
// if(metadata_length >= MOVIE_MAX_METADATA)
// metadata_length = MOVIE_MAX_METADATA-1;
//
// fseek(fp, MOVIE_V1_HEADER_SIZE, SEEK_SET);
// fread(tmp, 1, metadata_length<<1, fp);
// }
//
// // turn old ucs2 metadata into utf8
// if(info->metadata && info->metadata_size)
// {
// char* ptr=info->metadata;
// char* ptr_end=info->metadata+info->metadata_size-1;
// int c_ptr=0;
// while(ptr<ptr_end && c_ptr<metadata_length)
// {
// uint16 c=(tmp[c_ptr<<1] | (tmp[(c_ptr<<1)+1] << 8));
// //mbg merge 7/17/06 changed to if..elseif
// if(c<=0x7f)
// *ptr++ = (char)(c&0x7f);
// else if(c<=0x7FF)
// if(ptr+1>=ptr_end)
// ptr_end=ptr;
// else
// {
// *ptr++=(0xc0 | (c>>6));
// *ptr++=(0x80 | (c & 0x3f));
// }
// else
// if(ptr+2>=ptr_end)
// ptr_end=ptr;
// else
// {
// *ptr++=(0xe0 | (c>>12));
// *ptr++=(0x80 | ((c>>6) & 0x3f));
// *ptr++=(0x80 | (c & 0x3f));
// }
//
// c_ptr++;
// }
// *ptr='\0';
// }
//
// // md5 info not available from v1
// info->md5_of_rom_used_present = 0;
// // rom name used for the movie not available from v1
// if(info->name_of_rom_used && info->name_of_rom_used_size)
// info->name_of_rom_used[0] = '\0';
//
// // check what hacks are necessary
// fseek(fp, 24, SEEK_SET); // offset_to_savestate offset
// uint32 temp_savestate_offset;
// read32le(&temp_savestate_offset, fp);
// if(fseek(fp, temp_savestate_offset, SEEK_SET))
// {
// fclose(fp);
// return 0;
// }
// if(!FCEUSS_LoadFP(fp,SSLOADPARAM_DUMMY)) return 0; // 2 -> don't really load, just load to find what's there then load backup
//
//
// fclose(fp);
// return 1;
//}
//
//// PlayMovie / MoviePlay function
//void _old_FCEUI_LoadMovie(char *fname, int _read_only, int _stopframe)
//{
// char buffer [512];
// //fname = (char*)convertToFCM(fname,buffer);
//
// FILE *fp;
// char *fn = NULL;
//
// FCEUI_StopMovie();
//
// if(!fname)
// fname = fn = FCEU_MakeFName(FCEUMKF_MOVIE,0,0);
//
// char origname[512];
// strcpy(origname,fname);
//
// pauseframe = _stopframe;
//
// // check movie_readonly
// movie_readonly = _read_only;
// if(access(fname, W_OK))
// movie_readonly = 2;
//
// fp = FCEUD_UTF8fopen(fname, (movie_readonly>=2) ? "rb" : "r+b");
//
// if(fn)
// {
// free(fn);
// fname = NULL;
// }
//
// if(!fp) return;
//
// // read header
//
// uint32 magic;
// uint32 version;
// uint8 flags[4];
//
// read32le(&magic, fp);
// if(magic != MOVIE_MAGIC)
// {
// fclose(fp);
// return;
// }
// //DEBUG_COMPARE_RAM(__LINE__);
//
// read32le(&version, fp);
// if(version == 1)
// {
// // attempt to load previous version's format
// fclose(fp);
// FCEUI_LoadMovie_v1(fname, _read_only);
// return;
// }
// else if(version == MOVIE_VERSION)
// {}
// else
// {
// // unsupported version
// fclose(fp);
// return;
// }
//
// fread(flags, 1, 4, fp);
// read32le(&framecount, fp);
// read32le(&rerecord_count, fp);
// read32le(&moviedatasize, fp);
// read32le(&savestate_offset, fp);
// read32le(&firstframeoffset, fp);
//
// // FCEU_PrintError("flags[0] & MOVIE_FLAG_NOSYNCHACK=%d",flags[0] & MOVIE_FLAG_NOSYNCHACK);
// if(flags[0] & MOVIE_FLAG_NOSYNCHACK)
// movieSyncHackOn=0;
// else
// movieSyncHackOn=1;
//
// if(flags[0] & MOVIE_FLAG_PAL)
// {
// FCEUI_SetVidSystem(1);
// }
// else
// {
// FCEUI_SetVidSystem(0);
// }
//
//
// // fully reload the game to reinitialize everything before playing any movie
// // to try fixing nondeterministic playback of some games
// {
// extern char lastLoadedGameName [2048];
// extern int disableBatteryLoading, suppressAddPowerCommand;
// suppressAddPowerCommand=1;
// suppressMovieStop=true;
// {
// FCEUGI * gi = FCEUI_LoadGame(lastLoadedGameName, 0);
// if(!gi)
// PowerNES();
// }
// suppressMovieStop=false;
// suppressAddPowerCommand=0;
// }
//
// if(flags[0] & MOVIE_FLAG_FROM_POWERON)
// {
// //don't need to load a savestate
// //there shouldn't be a savestate!
// if(savestate_offset != 0xFFFFFFFF)
// FCEU_PrintError("Savestate found in a start-from-poweron movie!");
// }
// else
// {
// if(savestate_offset == 0xFFFFFFFF)
// FCEU_PrintError("No savestate found in a start-from-savestate movie!");
//
// if(fseek(fp, savestate_offset, SEEK_SET))
// {
// fclose(fp);
// return;
// }
//
// if(!FCEUSS_LoadFP(fp,SSLOADPARAM_BACKUP))
// return;
// }
//
// if(flags[0] & MOVIE_FLAG_PAL)
// {
// FCEUI_SetVidSystem(1);
// }
// else
// {
// FCEUI_SetVidSystem(0);
// }
// ResetInputTypes();
//
// fseek(fp, firstframeoffset, SEEK_SET);
// moviedata = (uint8*)realloc(moviedata, moviedatasize);
// fread(moviedata, 1, moviedatasize, fp);
//
// framecount = 0; // movies start at frame 0!
// frameptr = 0;
// current = 0;
// slots = fp;
//
// memset(joop,0,sizeof(joop));
// current = -1 - current;
// framets=0;
// nextts=0;
// nextd = -1;
//
// FCEU_DispMessage("Movie playback started.");
//
// strcpy(curMovieFilename, origname);
//}
//static void DoEncode(int joy, int button, int dummy)
//{
// uint8 d;
//
// d = 0;
//
// if(framets >= 65536)
// d = 3 << 5;
// else if(framets >= 256)
// d = 2 << 5;
// else if(framets > 0)
// d = 1 << 5;
//
// if(dummy) d|=0x80;
//
// d |= joy << 3;
// d |= button;
//
// movie_writechar(d);
// //printf("Wr: %02x, %d\n",d,slots[current-1]);
// while(framets)
// {
// movie_writechar(framets & 0xff);
// //printf("Wrts: %02x\n",framets & 0xff);
// framets >>= 8;
// }
//}