fork/slippc
git clone https://git.julia.blue/fork/slippc
0f889f2
0.7.1
1#include "compressor.h" 2 3namespace slip { 4 5Compressor ::Compressor (int debug_level ) { 6_debug = debug_level ; 7FRAME_ENC_DELTA = _debug ?1 :1 ; 8_bp = 0 ; 9 } 10 11Compressor ::~Compressor () { 12if (_rb != nullptr ) {delete []_rb ; } 13if (_wb != nullptr ) {delete []_wb ; } 14if (_outfilename != nullptr ) {delete _outfilename ; } 15 } 16 17bool Compressor ::loadFromFile (const char * replayfilename ) { 18DOUT1 ("Loading " <<replayfilename << std::endl ); 19 std::ifstream myfile ; 20myfile .open (replayfilename ,std::ios::binary | std::ios::in ); 21if (myfile .fail ()) { 22FAIL ("File " <<replayfilename <<" could not be opened or does not exist" ); 23return false; 24 } 25 26myfile .seekg (0 ,myfile .end ); 27_file_size = myfile .tellg (); 28if (_file_size < MIN_REPLAY_LENGTH ) { 29FAIL ("File " <<replayfilename <<" is too short to be a valid Slippi replay" ); 30return false; 31 } 32myfile .seekg (0 ,myfile .beg ); 33 34_rb = new char [_file_size ]; 35myfile .read (_rb ,_file_size ); 36myfile .close (); 37 38// Check if we have a compressed stream 39bool is_compressed = same4 (& _rb [0 ],LZMA_HEADER ); 40if (is_compressed ) { 41DOUT1 (" File Size: " <<+ _file_size <<", compressed" << std::endl ); 42// Copy the buffer to a string 43 std::string rs (_rb ,_file_size ); 44// Decompress the string 45 std::string decomp = decompressWithLzma (rs ); 46// Get the new file size 47_file_size = decomp .size (); 48// Delete the old read buffer 49delete []_rb ; 50// Reallocate it with more spce 51_rb = new char [_file_size ]; 52// Copy buffer from the decompressed string 53memcpy (_rb ,decomp .c_str (),_file_size ); 54 }else { 55DOUT1 (" File Size: " <<+ _file_size << std::endl ); 56 } 57if (_outfilename == nullptr ) { 58 std::string fname = std::string (replayfilename ); 59_outfilename = new std::string ( 60fname .substr (0 , 61fname .find_last_of ("." ))+ 62 std::string (is_compressed ?".slp" :".zlp" )); 63if (fileExists (* _outfilename )) { 64 std::cerr <<"File " <<* _outfilename <<" already exists or is invalid" << std::endl ; 65return false; 66 } 67 } 68 69_wb = new char [_file_size ]; 70memcpy (_wb ,_rb ,sizeof (char )* _file_size ); 71 72return this -> _parse (); 73 } 74 75void Compressor ::saveToFile (bool rawencode ) { 76if (fileExists (* _outfilename )) { 77 std::cerr <<"File " <<* _outfilename <<" exists, refusing to overwrite" << std::endl ; 78return ; 79 } 80 81 std::ofstream ofile ; 82ofile .open (* _outfilename , std::ios::binary | std::ios::out ); 83// If this is the unencoded version, compress it first 84if (!(_is_encoded || rawencode )) { 85// Copy the buffer to a string 86 std::string ws (_wb ,_file_size ); 87// Compress the string 88 std::string comp = compressWithLzma (ws ); 89DOUT1 ("Compression Ratio = " <<float (_file_size - comp .size ())/_file_size << std::endl ); 90// Write compressed buffer to file 91ofile .write (comp .c_str (),sizeof (char )* comp .size ()); 92 }else { 93// Write norma buffer to file 94ofile .write (_wb ,sizeof (char )* _file_size ); 95 } 96 97ofile .close (); 98 99 } 100 101bool Compressor ::setOutputFilename (const char * fname ) { 102if (fileExists (fname )) { 103return false; 104 } 105if (_outfilename != nullptr ) { 106delete _outfilename ; 107 } 108_outfilename = new std::string (fname ); 109return true; 110 } 111 112unsigned Compressor ::saveToBuff (char ** buffer ) { 113// buffer = new char[_file_size]; 114* buffer = new char [_file_size ]; 115memcpy (* buffer ,_wb ,sizeof (char )* _file_size ); 116return _file_size ; 117 } 118 119bool Compressor ::loadFromBuff (char ** buffer ,unsigned size ) { 120_file_size = size ; 121_wb = new char [_file_size ]; 122_rb = new char [_file_size ]; 123memcpy (_wb ,* buffer ,sizeof (char )* _file_size ); 124memcpy (_rb ,* buffer ,sizeof (char )* _file_size ); 125return this -> _parse (); 126 } 127 128bool Compressor ::validate () { 129if (_is_encoded ) { 130return true; 131 } 132 133char * enc_buff = nullptr ,* dec_buff = nullptr ; 134unsigned size = this -> saveToBuff (& enc_buff ); 135Compressor * d = new slip::Compressor (_debug ); 136d -> loadFromBuff (& enc_buff ,size ); 137d -> saveToBuff (& dec_buff ); 138 139bool success = (memcmp (_rb ,dec_buff ,size )== 0 ); 140 141delete dec_buff ; 142delete enc_buff ; 143delete d ; 144 145return success ; 146 } 147 148bool Compressor ::_parse () { 149_bp = 0 ;//Start reading from byte 0 150if (notthis -> _parseHeader ()) { 151 std::cerr <<"Failed to parse header" << std::endl ; 152return false; 153 } 154if (notthis -> _parseEventDescriptions ()) { 155 std::cerr <<"Failed to parse event descriptions" << std::endl ; 156return false; 157 } 158if (notthis -> _parseEvents ()) { 159 std::cerr <<"Failed to parse events proper" << std::endl ; 160return false; 161 } 162DOUT1 ("Successfully parsed replay!" << std::endl ); 163return true; 164 } 165 166bool Compressor ::_parseHeader () { 167DOUT1 ("Parsing header" << std::endl ); 168 169//First 15 bytes contain header information 170if (same8 (& _rb [_bp ],SLP_HEADER )) { 171DOUT1 (" Slippi Header Matched" << std::endl ); 172 }else { 173FAIL_CORRUPT ("Header did not match expected Slippi file header" ); 174return false; 175 } 176_length_raw_start = readBE4U (& _rb [_bp + 11 ]); 177if (_length_raw_start == 0 ) {//TODO: this is /technically/ recoverable 178FAIL_CORRUPT ("0-byte raw data detected" ); 179return false; 180 } 181DOUT1 (" Raw portion = " <<_length_raw_start <<" bytes" << std::endl ); 182if (_length_raw_start > _file_size ) { 183FAIL_CORRUPT ("Raw data size exceeds file size of " <<_file_size <<" bytes" ); 184return false; 185 } 186_length_raw = _length_raw_start ; 187_bp += 15 ; 188return true; 189 } 190 191bool Compressor ::_parseEventDescriptions () { 192DOUT1 ("Parsing event descriptions" << std::endl ); 193 194//Next 2 bytes should be 0x35 195if (_rb [_bp ]!= Event ::EV_PAYLOADS ) { 196FAIL_CORRUPT ("Expected Event 0x" << std::hex 197 <<Event ::EV_PAYLOADS << std::dec <<" (Event Payloads)" ); 198return false; 199 } 200uint8_t ev_bytes = _rb [_bp + 1 ]- 1 ;//Subtract 1 because the last byte we read counted as part of the payload 201_payload_sizes [Event ::EV_PAYLOADS ]= int32_t (ev_bytes + 1 ); 202DOUT1 (" Event description length = " <<int32_t (ev_bytes + 1 ) <<" bytes" << std::endl ); 203_bp += 2 ; 204 205//Next ev_bytes bytes describe events 206for (unsigned i = 0 ;i < ev_bytes ;i += 3 ) { 207unsigned ev_code = uint8_t (_rb [_bp + i ]); 208if (_payload_sizes [ev_code ]> 0 ) { 209if (ev_code >=Event ::EV_PAYLOADS && ev_code <=Event ::GAME_END ) { 210FAIL_CORRUPT ("Event " <<Event ::name [ev_code - Event ::EV_PAYLOADS ] <<" payload size set multiple times" ); 211 }else { 212FAIL_CORRUPT ("Event " <<hex (ev_code ) << std::dec <<" payload size set multiple times" ); 213 } 214return false; 215 } 216_payload_sizes [ev_code ]= readBE2U (& _rb [_bp + i + 1 ])+ 1 ;//Add one because of the event code itself 217DOUT1 (" Payload size for event " 218 <<hex (ev_code ) << std::dec <<": " <<_payload_sizes [ev_code ] 219 <<" bytes" << std::endl ); 220 } 221 222//Sanity checks to verify we at least have Payload Sizes, Game Start, Pre Frame, Post Frame, and Game End Events 223for (unsigned i = Event ::EV_PAYLOADS ;i <=Event ::GAME_END ;++ i ) { 224if (_payload_sizes [i ]== 0 ) { 225FAIL_CORRUPT ("Event " <<Event ::name [i - Event ::EV_PAYLOADS ] <<" payload size not set" ); 226return false; 227 } 228 } 229 230//Update the remaining length of the raw data to sift through 231_bp += ev_bytes ; 232_length_raw -= (2 + ev_bytes ); 233return true; 234 } 235 236bool Compressor ::_parseEvents () { 237DOUT1 ("Parsing events proper" << std::endl ); 238 239bool success = true; 240for ( ;_length_raw > 0 ; ) { 241unsigned ev_code = uint8_t (_rb [_bp ]); 242 243unsigned shift = _payload_sizes [ev_code ]; 244if (shift > _length_raw ) { 245FAIL_CORRUPT ("Event byte offset exceeds raw data length" ); 246return false; 247 } 248switch (ev_code ) {//Determine the event code 249case Event ::GAME_START :success = _parseGameStart ();break ; 250case Event ::SPLIT_MSG :success = _parseGeckoCodes ();break ; 251case Event ::FRAME_START :success = _parseFrameStart ();break ; 252case Event ::PRE_FRAME :success = _parsePreFrame ();break ; 253case Event ::ITEM_UPDATE :success = _parseItemUpdate ();break ; 254case Event ::POST_FRAME :success = _parsePostFrame ();break ; 255case Event ::BOOKEND :success = _parseBookend ();break ; 256case Event ::GAME_END : 257_game_loop_end = _bp ; 258if (!_is_encoded ) { 259_shuffleEvents (); 260 } 261success = true; 262break ; 263default : 264DOUT1 (" Warning: unknown event code " <<hex (ev_code ) <<" encountered; skipping" << std::endl ); 265break ; 266 } 267if (notsuccess ) { 268return false; 269 } 270if (_payload_sizes [ev_code ]== 0 ) { 271FAIL_CORRUPT ("Uninitialized event " <<hex (ev_code ) <<" encountered" ); 272return false; 273 } 274_length_raw -= shift ; 275_bp += shift ; 276DOUT2 (" Raw bytes remaining: " <<+ _length_raw << std::endl ); 277 } 278 279return true; 280 } 281 282bool Compressor ::_parseGameStart () { 283DOUT1 (" Parsing game start event at byte " <<+ _bp << std::endl ); 284 285//Get Slippi version 286_slippi_maj = uint8_t (_rb [_bp + O_SLP_MAJ ]);//Major version 287_slippi_min = uint8_t (_rb [_bp + O_SLP_MIN ]);//Minor version 288_slippi_rev = uint8_t (_rb [_bp + O_SLP_REV ]);//Build version (4th char unused) 289_is_encoded = uint8_t (_rb [_bp + O_SLP_ENC ]);//Whether the file is encoded 290if (MAX_VERSION (1 ,0 ,0 )) { 291FAIL ("Replays from Slippi 0.x.x are not supported" ); 292return false; 293 } 294if (MIN_VERSION (3 ,8 ,0 )) { 295FAIL ("Replays from Slippi 3.8.0 and higher are not supported" ); 296return false; 297 } 298 299//Flip encoding status for output buffer 300_wb [_bp + O_SLP_ENC ] ^=1 ; 301 302//Print slippi version 303 std::stringstream ss ; 304ss <<+ _slippi_maj <<"." <<+ _slippi_min <<"." <<+ _slippi_rev ; 305DOUT1 ("Slippi Version: " <<ss .str () <<", " << (_is_encoded ?"encoded" :"raw" ) << std::endl ); 306 307//Get starting RNG state 308_rng = readBE4U (& _rb [_bp + O_RNG_GAME_START ]); 309_rng_start = _rng ; 310DOUT1 ("Starting RNG: " <<_rng << std::endl ); 311 312return true; 313 } 314 315bool Compressor ::_parseGeckoCodes () { 316unsigned message_count = 0 ; 317 318// Load default Gecko codes 319char * gecko_codes = nullptr ; 320readDefaultGeckoCodes (& gecko_codes ); 321 322// XOR encode everything but the command byte 323unsigned offset = message_count * MESSAGE_SIZE ; 324if (offset < CODE_SIZE ) { 325for (unsigned i = 1 ;i < MESSAGE_SIZE ;++ i ) { 326_wb [_bp + i ]= _rb [_bp + i ] ^gecko_codes [offset + i ]; 327 } 328 } 329 330delete gecko_codes ; 331 332// Increment the message count and return 333++ message_count ; 334return true; 335 } 336 337bool Compressor ::_parseItemUpdate () { 338//Encodings so far 339//0x00 - 0x00 | Command Byte | No encoding 340//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1) 341//0x05 - 0x06 | Type ID | XORed with last item-slot value 342//0x07 - 0x07 | State | XORed with last item-slot value 343//0x08 - 0x0B | Facing Direction | XORed with last item-slot value 344//0x0C - 0x0F | X Velocity | Predicted from X position on this / last frame 345//0x10 - 0x13 | Y Velocity | Predicted from Y position on this / last frame 346//0x14 - 0x17 | X Position | Predictive encoding (2-frame delta) 347//0x18 - 0x1B | Y Position | Predictive encoding (2-frame delta) 348//0x1C - 0x1D | Damage Taken | XORed with last item-slot value 349//0x1E - 0x21 | Expiration Timer | Predictive encoding (2-frame delta) 350//0x22 - 0x25 | Spawn ID | No encoding 351//0x26 - 0x29 | Misc Values | XORed with last item-slot value 352//0x2A - 0x2A | Owner | XORed with last item-slot value 353 354DOUT2 (" Compressing item event at byte " <<+ _bp << std::endl ); 355 356//Encode frame number, predicting the last frame number +1 357int cur_item_frame = readBE4S (& _rb [_bp + O_FRAME ]); 358int pred_item_frame = predictFrame (cur_item_frame ,lastitemstartframe ,& _wb [_bp + O_FRAME ]); 359lastitemstartframe = _is_encoded ?pred_item_frame :cur_item_frame ; 360 361if (_debug >=3 ) { 362int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 363int inum = readBE4U (& _rb [_bp + O_ITEM_ID ]); 364DOUT3 (" EVID " <<+ fnum <<".3" <<+ inum << std::endl ); 365 } 366 367//Get a storage slot for the item 368uint8_t slot = readBE4U (& _rb [_bp + O_ITEM_ID ]) %ITEM_SLOTS ; 369 370//Predict item positions based on velocity 371predictVelocItem (slot ,O_ITEM_XPOS ); 372predictAccelItem (slot ,O_ITEM_YPOS ); 373 374// Use item positions to determine their velocties 375predictAsDifference (O_ITEM_XVEL ,O_ITEM_XPOS ,_x_item_p [slot ]); 376predictAsDifference (O_ITEM_YVEL ,O_ITEM_YPOS ,_x_item_p [slot ]); 377 378//Predict item expiration based on velocity 379predictVelocItem (slot ,O_ITEM_EXPIRE ); 380 381//XOR all of the remaining data for the item 382xorEncodeRange (O_ITEM_TYPE ,O_ITEM_XVEL ,_x_item [slot ]); 383xorEncodeRange (O_ITEM_DAMAGE ,O_ITEM_EXPIRE ,_x_item [slot ]); 384xorEncodeRange (O_ITEM_MISC ,O_ITEM_END ,_x_item [slot ]); 385 386if (_debug == 0 ) {return true; } 387 388return true; 389 } 390 391bool Compressor ::_parseFrameStart () { 392//Encodings so far 393//0x00 - 0x00 | Command Byte | No encoding 394//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1), second bit flipped if raw RNG 395//0x05 - 0x08 | RNG Seed | Predictive encoding (# of RNG rolls, or raw) 396 397if (_game_loop_start == 0 ) { 398_game_loop_start = _bp ; 399if (_is_encoded ) { 400_unshuffleEvents (); 401 } 402 } 403 404if (_debug >=3 ) { 405int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 406DOUT3 (" EVID " <<+ fnum <<".10" << std::endl ); 407 } 408 409//Encode frame number, predicting the last frame number +1 410int cur_frame = readBE4S (& _rb [_bp + O_FRAME ]); 411int pred_frame = predictFrame (cur_frame ,laststartframe ,& _wb [_bp + O_FRAME ]); 412 413//Update laststartframe since we just crossed a new frame boundary 414laststartframe = _is_encoded ?pred_frame :cur_frame ; 415 416//Predict RNG value from real (not delta encoded) frame number 417predictRNG (O_FRAME ,O_RNG_FS ); 418 419return true; 420 } 421 422bool Compressor ::_parseBookend () { 423//Encodings so far 424//0x00 - 0x00 | Command Byte | No encoding 425//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1) 426//0x05 - 0x08 | Rollback Frame | Predictive encoding (last frame + 1) 427 428if (_debug >=3 ) { 429int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 430int ffin = readBE4S (& _rb [_bp + O_ROLLBACK_FRAME ]); 431DOUT3 (" EVID " <<+ fnum <<".50 (" <<ffin <<")" << std::endl ); 432 } 433 434//Encode actual frame number, predicting and updating laststartframe 435predictFrame (readBE4S (& _rb [_bp + O_FRAME ]),laststartframe ,& _wb [_bp + O_FRAME ]); 436if (MIN_VERSION (3 ,7 ,0 )) { 437//Encode rollback frame number, predicting laststartframe without update 438predictFrame (readBE4S (& _rb [_bp + O_ROLLBACK_FRAME ]),laststartframe ,& _wb [_bp + O_ROLLBACK_FRAME ]); 439 } 440 441return true; 442 } 443 444bool Compressor ::_parsePreFrame () { 445//Encodings so far 446//0x00 - 0x00 | Command Byte | No encoding 447//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1), second bit flipped if raw RNG 448//0x05 - 0x05 | Player Index | No encoding (never changes) 449//0x06 - 0x06 | Is Follower | No encoding (never changes) 450//0x07 - 0x0A | RNG Seed | Predictive encoding (# of RNG rolls, or raw) 451//0x0B - 0x0C | Action State | XORed with last post-frame value 452//0x0D - 0x10 | X Position | XORed with last post-frame value 453//0x11 - 0x14 | Y Position | XORed with last post-frame value 454//0x15 - 0x18 | Facing Direction | XORed with last post-frame value 455//0x19 - 0x1C | Joystick X | Value retrieved from float map 456//0x1D - 0x20 | Joystick Y | Value retrieved from float map 457//0x21 - 0x24 | C-Stick X | Value retrieved from float map 458//0x25 - 0x28 | C-Stick Y | Value retrieved from float map 459//0x29 - 0x2C | Trigger | Value retrieved from float map 460//0x2D - 0x30 | Processed Buttons | No encoding (already sparse) 461//0x31 - 0x32 | Physical Buttons | XORed with lower bits of Processed Buttons 462//0x33 - 0x36 | Physical L | Value retrieved from float map 463//0x37 - 0x3A | Physical R | Value retrieved from float map 464//0x3B - 0x3B | UCF X analog | No encoding 465//0x3C - 0x3F | Damage | No encoding (already sparse) 466 467// Old code for trying to predict Joy X from Joy Y and UCF X 468// if (!_is_encoded) { 469// float joyx = readBE4F(&_rb[_bp+O_JOY_X]); 470// float joyy = readBE4F(&_rb[_bp+O_JOY_Y]); 471// int8_t ucfx = _rb[_bp+O_UCF_ANALOG]; 472// int8_t intx = float(joyx*80.0f); 473// int8_t inty = float(joyy*80.0f); 474 475// int8_t predx; 476// if (inty > 27 || inty < -58) { 477// predx = 0; 478// } else if (ucfx < -22) { 479// predx = ucfx; 480// } else if (ucfx > 22) { 481// predx = ucfx; 482// } else { 483// predx = 0; 484// } 485 486// if (predx > 79) { 487// predx = 79; 488// } else if (predx < -79) { 489// predx = -79; 490// } 491 492// std::cout 493// << " PRED " << padString(predx,4) 494// << " INT X " << padString(intx,4) 495// << " UCF X " << padString(ucfx,4) 496// << " INT Y " << padString(inty,4) 497// << (((predx != 0) && (predx != intx)) ? " MISS" : "") 498// << std::endl; 499// } 500 501DOUT2 (" Compressing pre frame event at byte " <<+ _bp << std::endl ); 502char * main_buf = (_is_encoded ?_wb :_rb ); 503 504//Get player index 505uint8_t p = uint8_t (_rb [_bp + O_PLAYER ])+ 4 * uint8_t (_rb [_bp + O_FOLLOWER ]);//Includes follower 506if (p > 7 ) { 507FAIL_CORRUPT ("Invalid player index " <<+ p ); 508return false; 509 } 510 511if (_debug >=3 ) { 512int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 513DOUT3 (" EVID " <<+ fnum <<".2" <<+ p << std::endl ); 514 } 515 516//Encode frame number, predicting the last frame number +1 517int cur_frame = readBE4S (& _rb [_bp + O_FRAME ]); 518int pred_frame = predictFrame (cur_frame ,lastpreframe [p ],& _wb [_bp + O_FRAME ]); 519//Update lastpreframe[p] since we just crossed a new frame boundary 520lastpreframe [p ]= _is_encoded ?pred_frame :cur_frame ; 521 522//Predict RNG value from real (not delta encoded) frame number 523predictRNG (O_FRAME ,O_RNG_PRE ); 524 525//Carry over action state from last post-frame 526writeBE2U (readBE2U (& _rb [_bp + O_ACTION_PRE ]) ^readBE2U (& _x_post_frame [p ][O_ACTION_POST ]),& _wb [_bp + O_ACTION_PRE ]); 527memcpy (& _x_pre_frame [p ][O_ACTION_PRE ],& main_buf [_bp + O_ACTION_PRE ],2 ); 528 529//Carry over x position from last post-frame 530writeBE4U (readBE4U (& _rb [_bp + O_XPOS_PRE ]) ^readBE4U (& _x_post_frame [p ][O_XPOS_POST ]),& _wb [_bp + O_XPOS_PRE ]); 531memcpy (& _x_pre_frame [p ][O_XPOS_PRE ],& main_buf [_bp + O_XPOS_PRE ],4 ); 532 533//Carry over y position from last post-frame 534writeBE4U (readBE4U (& _rb [_bp + O_YPOS_PRE ]) ^readBE4U (& _x_post_frame [p ][O_YPOS_POST ]),& _wb [_bp + O_YPOS_PRE ]); 535memcpy (& _x_pre_frame [p ][O_YPOS_PRE ],& main_buf [_bp + O_YPOS_PRE ],4 ); 536 537//Carry over facing direction from last post-frame 538writeBE4U (readBE4U (& _rb [_bp + O_FACING_PRE ]) ^readBE4U (& _x_post_frame [p ][O_FACING_POST ]),& _wb [_bp + O_FACING_PRE ]); 539memcpy (& _x_pre_frame [p ][O_FACING_PRE ],& main_buf [_bp + O_FACING_PRE ],4 ); 540 541// Encode analog stick and trigger values as integers 542encodeAnalog (O_JOY_X ,80.0f ); 543encodeAnalog (O_JOY_Y ,80.0f ); 544encodeAnalog (O_CX ,80.0f ); 545encodeAnalog (O_CY ,80.0f ); 546encodeAnalog (O_TRIGGER ,140.0f ); 547encodeAnalog (O_PHYS_L ,140.0f ); 548encodeAnalog (O_PHYS_R ,140.0f ); 549 550// Encode physical buttons from lower bits of processed buttons 551uint16_t phys_buttons = readBE2U (& main_buf [_bp + O_BUTTONS ]); 552uint16_t proc_buttons = readBE2U (& main_buf [_bp + O_PROCESSED + 2 ]); 553writeBE2U (proc_buttons ^phys_buttons ,& _wb [_bp + O_BUTTONS ]); 554 555return true; 556 } 557 558bool Compressor ::_parsePostFrame () { 559//Encodings so far 560//0x00 - 0x00 | Command Byte | No encoding 561//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1) 562//0x05 - 0x05 | Player Index | No encoding (never changes) 563//0x06 - 0x06 | Is Follower | No encoding (never changes) 564//0x07 - 0x07 | Char ID | No encoding (already sparse) 565//0x08 - 0x09 | Action State | No encoding, but used to predict pre-frame 566//0x0A - 0x0D | X Position | Predictive encoding (3-frame accel) 567//0x0E - 0x11 | Y Position | Predictive encoding (3-frame accel) 568//0x12 - 0x15 | Facing Direction | No encoding, but used to predict pre-frame 569//0x16 - 0x19 | Damage | No encoding, but used to predict pre-frame 570//0x1A - 0x1D | Shield | Predictive encoding (2-frame delta) 571//0x1E - 0x1E | Last Hitting Attack | XOR encoding 572//0x1F - 0x1F | Combo Count | XOR encoding 573//0x20 - 0x20 | Last Hit By | XOR encoding 574//0x21 - 0x21 | Stocks Remaining | XOR encoding 575//0x22 - 0x25 | AS Frame Counter | Predictive encoding (2-frame delta) 576//0x26 - 0x2A | State Bit Flags | XOR encoding 577//0x2B - 0x2E | Hitstun Counter | Predictive encoding (2-frame delta) 578//0x2F - 0x2F | Ground / Air State | No encoding (already sparse) 579//0x30 - 0x31 | Ground ID | No encoding (already sparse) 580//0x32 - 0x32 | Jumps Remaining | No encoding (already sparse) 581//0x33 - 0x33 | L Cancel Status | No encoding (already sparse) 582//0x34 - 0x34 | Hurtbox Status | No encoding (already sparse) 583//0x35 - 0x38 | Self Air X-velocity | Predictive encoding (2-frame delta) 584//0x39 - 0x3C | Self Y-velocity | Predictive encoding (2-frame delta) 585//0x3D - 0x40 | Attack X-velocity | Predictive encoding (2-frame delta) 586//0x41 - 0x44 | Attack Y-velocity | Predictive encoding (2-frame delta) 587//0x45 - 0x48 | Self Ground X-vel. | Predictive encoding (2-frame delta) 588 589DOUT2 (" Compressing post frame event at byte " <<+ _bp << std::endl ); 590char * main_buf = (_is_encoded ?_wb :_rb ); 591 592union {float f ;uint32_t u ; }float_true ,float_pred ,float_temp ; 593int32_t fnum = readBE4S (& _rb [_bp + O_FRAME ]); 594int32_t f = fnum - LOAD_FRAME ; 595 596//Get player index 597uint8_t p = uint8_t (_rb [_bp + O_PLAYER ])+ 4 * uint8_t (_rb [_bp + O_FOLLOWER ]);//Includes follower 598if (p > 7 ) { 599FAIL_CORRUPT ("Invalid player index " <<+ p ); 600return false; 601 } 602 603if (_debug >=3 ) { 604int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 605DOUT3 (" EVID " <<+ fnum <<".4" <<+ p << std::endl ); 606 } 607 608//Encode frame number, predicting the last frame number +1 609int cur_frame = readBE4S (& _rb [_bp + O_FRAME ]); 610int pred_frame = predictFrame (cur_frame ,lastpostframe [p ],& _wb [_bp + O_FRAME ]); 611//Update lastpreframe[p] since we just crossed a new frame boundary 612lastpostframe [p ]= _is_encoded ?pred_frame :cur_frame ; 613 614//Predict x position based on velocity and acceleration 615predictAccelPost (p ,O_XPOS_POST ); 616//Predict y position based on velocity and acceleration 617predictAccelPost (p ,O_YPOS_POST ); 618 619//Copy action state to post-frame 620memcpy (& _x_post_frame [p ][O_ACTION_POST ],& main_buf [_bp + O_ACTION_POST ],2 ); 621//Copy x position to post-frame 622memcpy (& _x_post_frame [p ][O_XPOS_POST ],& main_buf [_bp + O_XPOS_POST ],4 ); 623//Copy y position to post-frame 624memcpy (& _x_post_frame [p ][O_YPOS_POST ],& main_buf [_bp + O_YPOS_POST ],4 ); 625//Copy facing direction to post-frame 626memcpy (& _x_post_frame [p ][O_FACING_POST ],& main_buf [_bp + O_FACING_POST ],4 ); 627//Copy damage to post-frame 628memcpy (& _x_post_frame [p ][O_DAMAGE_POST ],& main_buf [_bp + O_DAMAGE_POST ],4 ); 629 630//Predict shield decay as velocity 631predictVelocPost (p ,O_SHIELD ); 632 633//Compress single byte values with XOR encoding 634xorEncodeRange (O_LAST_HIT_ID ,O_ACTION_FRAMES ,_x_post_frame [p ]); 635 636//Predict this frame's action state counter from the last 2 frames' counters 637predictVelocPost (p ,O_ACTION_FRAMES ); 638 639if (MIN_VERSION (2 ,0 ,0 )) { 640//XOR encode state bit flags 641xorEncodeRange (O_STATE_BITS_1 ,O_HITSTUN ,_x_post_frame [p ]); 642 643//Predict this frame's hitstun counter from the last 2 frames' counters 644predictVelocPost (p ,O_HITSTUN ); 645 646if (MIN_VERSION (3 ,5 ,0 )) { 647//Predict delta of various speeds based on previous frames' velocities 648predictVelocPost (p ,O_SELF_AIR_Y ); 649predictVelocPost (p ,O_ATTACK_X ); 650predictVelocPost (p ,O_ATTACK_Y ); 651predictVelocPost (p ,O_SELF_GROUND_X ); 652predictVelocPost (p ,O_SELF_AIR_X ); 653 } 654 } 655 656if (_debug == 0 ) {return true; } 657//Below here is still in testing mode 658 659return true; 660 } 661 662bool Compressor ::_unshuffleEvents () { 663if (MAX_VERSION (3 ,0 ,0 )) { 664return true; 665 } 666bool success = _shuffleEvents (true); 667if (success ) { 668// Copy the relevant portion of _rb to _wb 669memcpy ( 670& _wb [_game_loop_start ], 671& _rb [_game_loop_start ], 672sizeof (char )* (_game_loop_end - _game_loop_start ) 673 ); 674 }else { 675 std::cerr <<"BIG PROBLEM UNSHUFFLING" << std::endl ; 676 } 677return success ; 678 } 679 680bool Compressor ::_shuffleEvents (bool unshuffle ) { 681const unsigned ETYPES = 64 ;//Number of types of events 682const unsigned EMAX = 30 ;//Max event to include as part of the game loop 683 684// Can't do this for replays without frame start events yet 685if (MAX_VERSION (3 ,0 ,0 )) { 686return true; 687 } 688 689// Flag for if we fail anywhere 690bool success = true; 691 692// Determine if we're using the input or output buffer 693char * main_buf = unshuffle ?_rb :_wb ; 694if (unshuffle ) { 695// We don't actually know where _game_loop_end is yet 696_game_loop_end = 999999999 ; 697// We also need to unshuffle columns 698_unshuffleColumns (main_buf ); 699 } 700 701//Allocate space for storing shuffled events 702//TODO: lazy space calculations, should be more robust later 703const int MAX_EVENTS = 100000 ; 704unsigned offset [ETYPES ]= {0 };//Size of individual event arrays 705char ** ev_buf = new char * [ETYPES ]; 706ev_buf [0 ]= new char [MAX_EVENTS * (_payload_sizes [Event ::FRAME_START ])]; 707ev_buf [9 ]= new char [MAX_EVENTS * (_payload_sizes [Event ::ITEM_UPDATE ])]; 708ev_buf [18 ]= new char [MAX_EVENTS * (_payload_sizes [Event ::BOOKEND ])]; 709ev_buf [19 ]= new char [MAX_EVENTS * (_payload_sizes [Event ::SPLIT_MSG ])]; 710for (unsigned i = 0 ;i < 8 ;++ i ) { 711ev_buf [1 + i ]= new char [MAX_EVENTS * (_payload_sizes [Event ::PRE_FRAME ])]; 712ev_buf [10 + i ]= new char [MAX_EVENTS * (_payload_sizes [Event ::POST_FRAME ])]; 713 } 714int * frame_counter = new int [MAX_EVENTS ]{0 }; 715int * finalized_counter = new int [MAX_EVENTS ]{0 }; 716unsigned start_fp = 0 ;//Frame pointer to next start frame 717unsigned end_fp = 0 ;//Frame pointer to next end frame 718 719//Rearrange memory 720uint8_t oid ;//Index into the offset array we're currently working with 721int last_finalized = -125 ;//Last finalized frame 722int cur_frame = -125 ; 723unsigned oldshuffleframe = lastshuffleframe ; 724for (unsigned b = _game_loop_start ;b < _game_loop_end ; ) { 725unsigned ev_code = uint8_t (main_buf [b ]); 726unsigned shift = _payload_sizes [ev_code ]; 727switch (ev_code ) { 728case Event ::FRAME_START : 729oid = 0 ; 730if (unshuffle ) { 731cur_frame = decodeFrame (readBE4S (& main_buf [b + O_FRAME ]),lastshuffleframe ); 732lastshuffleframe = cur_frame ; 733 }else { 734cur_frame = readBE4S (& _rb [b + O_FRAME ]); 735 } 736frame_counter [start_fp ]= cur_frame ; 737++ start_fp ; 738// std::cout << "Started frame " << cur_frame << std::endl; 739break ; 740case Event ::PRE_FRAME ://Includes follower 741oid = 1 + uint8_t (main_buf [b + O_PLAYER ])+ 4 * uint8_t (main_buf [b + O_FOLLOWER ]);break ; 742case Event ::ITEM_UPDATE : 743oid = 9 ; 744// XOR first byte of item id with last finalized frame 745if (!unshuffle ) { 746unsigned item_id = readBE4U (& main_buf [b + O_ITEM_ID ]); 747// int ff = finalized_counter[end_fp-1]; 748int ff = lookAheadToFinalizedFrame (& _rb [b ]); 749item_id = encodeFrameIntoItemId (item_id ,ff ); 750unsigned dec_id = encodeFrameIntoItemId (item_id ,ff ); 751if (encodeFrameIntoItemId (encodeFrameIntoItemId (dec_id ,ff ),ff )!= dec_id ) { 752return false; 753 } 754writeBE4U (item_id ,& main_buf [b + O_ITEM_ID ]); 755// std::cout << "ITEM ID = " << item_id << " (" << dec_id << ") FINAL " << ff << std::endl; 756 } 757break ; 758case Event ::POST_FRAME ://Includes follower 759oid = 10 + uint8_t (main_buf [b + O_PLAYER ])+ 4 * uint8_t (main_buf [b + O_FOLLOWER ]);break ; 760case Event ::BOOKEND : 761oid = 18 ; 762if (unshuffle ) { 763lastshuffleframe = frame_counter [end_fp ]; 764cur_frame = decodeFrame (readBE4S (& main_buf [b + O_ROLLBACK_FRAME ]),lastshuffleframe ); 765 }else { 766cur_frame = readBE4S (& _rb [b + O_ROLLBACK_FRAME ]); 767 } 768finalized_counter [end_fp ]= (cur_frame + 256 ) %256 ; 769++ end_fp ; 770// std::cout << "Finalized frame " << cur_frame << std::endl; 771break ; 772case Event ::SPLIT_MSG ://Includes follower 773oid = EMAX + 1 ;break ; 774case Event ::GAME_END : 775oid = EMAX ; 776_game_loop_end = b ; 777// std::cout << "GAME LOOP END 0x" 778// << std::hex << ev_code << std::dec 779// << " at byte " << +b << std::endl; 780break ; 781default : 782oid = ETYPES - 1 ; 783// std::cout << "NOT GOOD 0x" 784// << std::hex << ev_code << std::dec 785// << " at byte " << +b << std::endl; 786break ; 787 } 788if (oid < EMAX ) { 789// std::cout << "FINE 0x" 790// << std::hex << ev_code << std::dec 791// << " at byte " << +b << std::endl; 792memcpy (& ev_buf [oid ][offset [oid ]],& main_buf [b ],sizeof (char )* shift ); 793 } 794offset [oid ]+= shift ; 795b += shift ; 796 } 797lastshuffleframe = oldshuffleframe ; 798 799//Sanity checks to make sure the number of individual event bytes 800// sums to the total number of bytes in the main game loop 801unsigned tsize = 0 ; 802for (unsigned i = 0 ;i < EMAX ;++ i ) {//Skip game end event 803tsize += offset [i ]; 804// std::cout << "SIZE of " << i << " is " << offset[i] << std::endl; 805 } 806if (tsize != (_game_loop_end - _game_loop_start )) { 807 std::cerr <<"SOMETHING WENT HORRENDOUSLY WRONG D:" << std::endl ; 808 std::cerr <<"tsize=" <<tsize << std::endl ; 809 std::cerr <<"_game_loop_end=" <<_game_loop_end << std::endl ; 810 std::cerr <<"_game_loop_start=" <<_game_loop_start << std::endl ; 811success = false; 812 } 813 814// Copy memory over if we haven't failed horrendously yet 815if (success ) { 816unsigned off = 0 ; 817unsigned b = _game_loop_start ; 818if (unshuffle ) {//Unshuffle into main memory 819unsigned cpos [EMAX ]= {0 };//Buffer positions we're copying out of 820 821// Unshuffle message events first (makes things worse) 822// off = sizeof(char)*_payload_sizes[Event::SPLIT_MSG]; 823// while(cpos[19] < offset[19]) { 824// memcpy(&main_buf[b],&ev_buf[19][cpos[19]],off); 825// cpos[19] += off; 826// b += off; 827// } 828 829for (unsigned frame_ptr = 0 ;b < _game_loop_end ;++ frame_ptr ) { 830// Sanity checks to make sure this is an actual frame start event 831if (cpos [0 ] >=offset [0 ]) { 832 std::cerr <<"THAT SUCKS D:" << std::endl ; 833success = false; 834break ; 835 } 836if (ev_buf [0 ][cpos [0 ]]!= Event ::FRAME_START ) { 837 std::cerr <<"OH SNAP D:" << std::endl ; 838success = false; 839break ; 840 } 841 842// Get the current frame from the next frame start event 843int enc_frame = readBE4S (& ev_buf [0 ][cpos [0 ]+ O_FRAME ]); 844int fnum = decodeFrame (enc_frame ,lastshuffleframe ); 845lastshuffleframe = fnum ; 846DOUT3 ((b ) <<" bytes read, " << (_game_loop_end - b ) <<" bytes left at frame " <<fnum << std::endl ); 847 848// TODO: this isn't working for Game_20210207T004448.slp 849if (fnum < -123 || fnum > pow (2 ,30 )) { 850 std::cerr <<"SOMETHING WENT HORRENDOUSLY WRONG D:" << std::endl ; 851success = false; 852break ; 853 } 854 855// Copy the frame start event over to the main buffer 856off = sizeof (char )* _payload_sizes [Event ::FRAME_START ]; 857memcpy (& main_buf [b ],& ev_buf [0 ][cpos [0 ]],off ); 858cpos [0 ]+= off ; 859b += off ; 860 861// Check if each player has a pre-frame this frame 862for (unsigned p = 0 ;p < 8 ;++ p ) { 863// True player order: 0,4,1,5,2,6,3,7 864unsigned i = (4 * (p %2 ))+ unsigned (p /2 ); 865//If the player has no more pre-frame data, move on 866if (cpos [1 + i ] >=offset [1 + i ]) { 867continue ; 868 } 869// If the next frame isn't the one we're expecting, move on 870if (decodeFrame (readBE4S (& ev_buf [1 + i ][cpos [1 + i ]+ O_FRAME ]),lastshufflepreframe [p ])!= fnum ) { 871 std::cout <<fnum <<" NO MATCH pre-frame " <<i + 1 <<" @ " <<decodeFrame (readBE4S (& ev_buf [1 + i ][cpos [1 + i ]+ O_FRAME ]),lastshuffleframe ) << std::endl ; 872continue ; 873 } 874// Copy the pre frame event over to the main buffer 875off = sizeof (char )* _payload_sizes [Event ::PRE_FRAME ]; 876memcpy (& main_buf [b ],& ev_buf [1 + i ][cpos [1 + i ]],off ); 877cpos [1 + i ]+= off ; 878b += off ; 879lastshufflepreframe [p ]= fnum ; 880// std::cout << fnum << " pre-frame " << i+1 << std::endl; 881 } 882 883// Copy over any items with matching frames 884int last_id = -1 ; 885for (;;) { 886// If there are no more items, move on 887if (cpos [9 ] >=offset [9 ]) {break ; } 888 889// If the next item frame isn't the current frame, move on 890int iframe = readBE4S (& ev_buf [9 ][cpos [9 ]+ O_FRAME ]); 891iframe = decodeFrame (iframe ,lastitemshuffleframe ); 892if (iframe != fnum ) {break ; } 893 894// Double check we're on the correctly finalized frame 895int item_id = readBE4U (& ev_buf [9 ][cpos [9 ]+ O_ITEM_ID ]); 896int ff = finalized_counter [frame_ptr ]; 897int fmod = getFrameModFromItemId (item_id ); 898if (fmod != ff ) { 899break ; 900 } 901 902 903// Decode item_id encoded with frame number 904unsigned dec_id = encodeFrameIntoItemId (item_id ,ff ); 905item_id = dec_id ; 906 907// Verify we aren't repeating items this frame 908if (item_id <=last_id ) { 909break ; 910 } 911 912 913// Update lastitemshuffleframe 914lastitemshuffleframe = iframe ; 915 916// Restore the actual item ID to the buffer 917writeBE4U (dec_id ,& ev_buf [9 ][cpos [9 ]+ O_ITEM_ID ]); 918 919// Copy the item event over to the main buffer 920off = sizeof (char )* _payload_sizes [Event ::ITEM_UPDATE ]; 921memcpy (& main_buf [b ],& ev_buf [9 ][cpos [9 ]],off ); 922cpos [9 ]+= off ; 923b += off ; 924last_id = item_id ; 925// std::cout << fnum << " item " << std::endl; 926 } 927 928// Check if each player has a post-frame this frame 929for (unsigned p = 0 ;p < 8 ;++ p ) { 930// True player order: 0,4,1,5,2,6,3,7 931unsigned i = (4 * (p %2 ))+ unsigned (p /2 ); 932//If the player has no more post-frame data, move on 933if (cpos [10 + i ] >=offset [10 + i ]) { 934continue ; 935 } 936// If the next frame isn't the one we're expecting, move on 937if (decodeFrame (readBE4S (& ev_buf [10 + i ][cpos [10 + i ]+ O_FRAME ]),lastshufflepostframe [p ])!= fnum ) { 938continue ; 939 } 940// Copy the post frame event over to the main buffer 941off = sizeof (char )* _payload_sizes [Event ::POST_FRAME ]; 942memcpy (& main_buf [b ],& ev_buf [10 + i ][cpos [10 + i ]],off ); 943cpos [10 + i ]+= off ; 944b += off ; 945lastshufflepostframe [p ]= fnum ; 946// std::cout << fnum << " post-frame " << i+1 << std::endl; 947 } 948 949// Copy the frame end event over to the main buffer 950if (decodeFrame (readBE4S (& ev_buf [18 ][cpos [18 ]+ O_FRAME ]),lastshuffleframe )== fnum ) { 951off = sizeof (char )* _payload_sizes [Event ::BOOKEND ]; 952memcpy (& main_buf [b ],& ev_buf [18 ][cpos [18 ]],off ); 953cpos [18 ]+= off ; 954b += off ; 955// std::cout << fnum << " end " << std::endl; 956 } 957 958// finalized = decodeFrame(readBE4S(&ev_buf[18][cpos[18]+0x5]), lastshuffleframe); 959 } 960 }else {//Shuffle into main memory 961// Copy message events (makes things worse) 962// memcpy(&main_buf[b],&ev_buf[19][0],offset[19]); 963// b += offset[19]; 964 965// Copy frame start events 966memcpy (& main_buf [b ],& ev_buf [0 ][0 ],offset [0 ]); 967b += offset [0 ]; 968 969// Copy pre-frame events 970for (unsigned i = 0 ;i < 8 ;++ i ) { 971memcpy (& main_buf [b ],& ev_buf [1 + i ][0 ],offset [1 + i ]); 972b += offset [1 + i ]; 973 } 974 975// Copy item events 976memcpy (& main_buf [b ],& ev_buf [9 ][0 ],offset [9 ]); 977b += offset [9 ]; 978 979// Copy post-frame events 980for (unsigned i = 0 ;i < 8 ;++ i ) { 981memcpy (& main_buf [b ],& ev_buf [10 + i ][0 ],offset [10 + i ]); 982b += offset [10 + i ]; 983 } 984 985// Copy frame end events 986memcpy (& main_buf [b ],& ev_buf [18 ][0 ],offset [18 ]); 987b += offset [18 ]; 988 989// Shuffle columns 990_shuffleColumns (offset ); 991 } 992 } 993 994//Free memory 995for (unsigned i = 0 ;i < 19 ;++ i ) { 996delete ev_buf [i ]; 997 } 998delete ev_buf ; 999delete frame_counter ; 1000 1001return success ; 1002 } 1003 1004}