mirror of
https://github.com/d0k3/GodMode9.git
synced 2025-06-26 05:32:47 +00:00
add BEAT interactivity, fix typos and other small bugs
This commit is contained in:
Wolfvak
d0k3
parent
e4b98e0932
commit
ce9f0a25ef
@ -16,18 +16,31 @@
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <libgen.h>
|
||||
|
||||
#include "common.h"
|
||||
#include "timer.h"
|
||||
#include "crc32.h"
|
||||
#include "bps.h"
|
||||
#include "fs.h"
|
||||
#include "ui.h"
|
||||
|
||||
#define BEAT_VLIBUFSZ (16)
|
||||
#include "hid.h"
|
||||
#include "bps.h"
|
||||
|
||||
#define BEAT_VLIBUFSZ (8)
|
||||
#define BEAT_MAXPATH (256)
|
||||
#define BEAT_RANGESZ(c, i) ((c)->ranges[1][i] - (c)->ranges[0][i])
|
||||
#define BEAT_FILEBUFSZ (256 * 1024)
|
||||
|
||||
#define BEAT_RANGE(c, i) ((c)->ranges[1][i] - (c)->ranges[0][i])
|
||||
#define BEAT_UPDATEDELAYMS (1000 / 4)
|
||||
|
||||
#define BEAT_ABSPOS(c, i) ((c)->foff[i] + (c)->ranges[0][i])
|
||||
|
||||
#define BEAT_READONLY (FA_READ | FA_OPEN_EXISTING)
|
||||
#define BEAT_RWCREATE (FA_READ | FA_WRITE | FA_CREATE_NEW)
|
||||
#define BEAT_RWCREATE (FA_READ | FA_WRITE | FA_CREATE_ALWAYS)
|
||||
|
||||
static u32 progress_refcnt = 0;
|
||||
static u64 progress_timer = 0;
|
||||
|
||||
static size_t fs_size(const char *path)
|
||||
{
|
||||
@ -37,6 +50,15 @@ static size_t fs_size(const char *path)
|
||||
return fno.fsize;
|
||||
}
|
||||
|
||||
static const char *basepath(const char *path)
|
||||
{
|
||||
const char *ret = path + strlen(path);
|
||||
while((--ret) > path) {
|
||||
if (*ret == '/') break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Possible error codes */
|
||||
enum {
|
||||
BEAT_OK = 0,
|
||||
@ -69,23 +91,23 @@ enum {
|
||||
|
||||
/* File handles used within the Beat state */
|
||||
enum {
|
||||
BEAT_PATCHFILE = 0,
|
||||
BEAT_SRCFILE,
|
||||
BEAT_DSTFILE,
|
||||
BEAT_FILECOUNT,
|
||||
BEAT_PF = 0, // patch file
|
||||
BEAT_IF, // input file
|
||||
BEAT_OF, // output file
|
||||
BEAT_FILENUM,
|
||||
};
|
||||
|
||||
static const u8 bps_signature[] = { 'B', 'P', 'S', '1' };
|
||||
static const u8 bps_chksumoffs[BEAT_FILECOUNT] = {
|
||||
[BEAT_PATCHFILE] = 4, [BEAT_DSTFILE] = 8, [BEAT_SRCFILE] = 12,
|
||||
static const u8 bps_chksumoffs[BEAT_FILENUM] = {
|
||||
[BEAT_PF] = 4, [BEAT_OF] = 8, [BEAT_IF] = 12,
|
||||
};
|
||||
static const u8 bpm_signature[] = { 'B', 'P', 'M', '1' };
|
||||
|
||||
/** BEAT STATE STORAGE */
|
||||
typedef struct {
|
||||
u8 *copybuf;
|
||||
ssize_t foffset[BEAT_FILECOUNT], eoal_offset;
|
||||
size_t ranges[2][BEAT_FILECOUNT];
|
||||
size_t foff[BEAT_FILENUM], eoal_offset;
|
||||
size_t ranges[2][BEAT_FILENUM];
|
||||
u32 ocrc; // Output crc
|
||||
|
||||
union {
|
||||
@ -97,10 +119,26 @@ typedef struct {
|
||||
const char *bpm_path, *source_dir, *target_dir;
|
||||
};
|
||||
};
|
||||
FIL file[BEAT_FILECOUNT];
|
||||
char processing[BEAT_MAXPATH];
|
||||
FIL file[BEAT_FILENUM];
|
||||
} BEAT_Context;
|
||||
|
||||
typedef int (*BEAT_Action)(BEAT_Context*, u64);
|
||||
typedef int (*BEAT_Action)(BEAT_Context*, u32);
|
||||
|
||||
static bool BEAT_UpdateProgress(const BEAT_Context *ctx)
|
||||
{ // only updates progress for the parent patch, so the embedded BPS wont be displayed
|
||||
u64 tmr;
|
||||
if (progress_refcnt > 2) bkpt; // nope, bug out
|
||||
|
||||
tmr = timer_msec(progress_timer);
|
||||
if (CheckButton(BUTTON_B)) return false; // check for an abort situation
|
||||
if (progress_refcnt != 1) return true; // only show the first level progress
|
||||
if (tmr < BEAT_UPDATEDELAYMS) return true; // give it some time
|
||||
|
||||
progress_timer = timer_start();
|
||||
ShowProgress(ctx->foff[BEAT_PF], BEAT_RANGE(ctx, BEAT_PF), ctx->processing);
|
||||
return true;
|
||||
}
|
||||
|
||||
static const char *BEAT_ErrString(int error)
|
||||
{ // Get an error description string
|
||||
@ -120,103 +158,94 @@ static const char *BEAT_ErrString(int error)
|
||||
}
|
||||
}
|
||||
|
||||
static int BEAT_Read(BEAT_Context *ctx, int id, void *out, size_t len, bool advance)
|
||||
static int BEAT_Read(BEAT_Context *ctx, int id, void *out, size_t len, int fwd)
|
||||
{ // Read up to `len` bytes from the context file `id` to the `out` buffer
|
||||
FRESULT res;
|
||||
UINT br;
|
||||
len = min(len, BEAT_RANGESZ(ctx, id) - ctx->foffset[id]);
|
||||
fvx_lseek(&ctx->file[id], ctx->ranges[0][id] + ctx->foffset[id]); // ALWAYS use the state offset + start range
|
||||
if (advance) ctx->foffset[id] += len;
|
||||
FRESULT res;
|
||||
if ((len + ctx->foff[id]) > BEAT_RANGE(ctx, id))
|
||||
return BEAT_OVERFLOW;
|
||||
|
||||
fvx_lseek(&ctx->file[id], BEAT_ABSPOS(ctx, id)); // ALWAYS use the state offset + start range
|
||||
ctx->foff[id] += len * fwd;
|
||||
res = fvx_read(&ctx->file[id], out, len, &br);
|
||||
return (res == FR_OK && br == len) ? BEAT_OK : BEAT_IO_ERROR;
|
||||
}
|
||||
|
||||
static int BEAT_WriteOut(BEAT_Context *ctx, const u8 *in, size_t len, bool advance)
|
||||
{ // Write `len` bytes from `in` to BEAT_DSTFILE, updates the output CRC
|
||||
FRESULT res;
|
||||
static int BEAT_WriteOut(BEAT_Context *ctx, const u8 *in, size_t len, int fwd)
|
||||
{ // Write `len` bytes from `in` to BEAT_OF, updates the output CRC
|
||||
UINT bw;
|
||||
if ((len + ctx->foffset[BEAT_DSTFILE]) > BEAT_RANGESZ(ctx, BEAT_DSTFILE))
|
||||
FRESULT res;
|
||||
if ((len + ctx->foff[BEAT_OF]) > BEAT_RANGE(ctx, BEAT_OF))
|
||||
return BEAT_OVERFLOW;
|
||||
|
||||
// Blindly assume all writes will be done linearly
|
||||
ctx->ocrc = ~crc32_calculate(~ctx->ocrc, in, len);
|
||||
fvx_lseek(&ctx->file[BEAT_DSTFILE], ctx->ranges[0][BEAT_DSTFILE] + ctx->foffset[BEAT_DSTFILE]);
|
||||
if (advance) ctx->foffset[BEAT_DSTFILE] += len;
|
||||
res = fvx_write(&ctx->file[BEAT_DSTFILE], in, len, &bw);
|
||||
fvx_lseek(&ctx->file[BEAT_OF], BEAT_ABSPOS(ctx, BEAT_OF));
|
||||
ctx->foff[BEAT_OF] += len * fwd;
|
||||
res = fvx_write(&ctx->file[BEAT_OF], in, len, &bw);
|
||||
return (res == FR_OK && bw == len) ? BEAT_OK : BEAT_IO_ERROR;
|
||||
}
|
||||
|
||||
static void BEAT_SeekOff(BEAT_Context *ctx, int id, ssize_t offset)
|
||||
{ ctx->foffset[id] += offset; } // Seek `offset` bytes forward
|
||||
{ ctx->foff[id] += offset; } // Seek `offset` bytes forward
|
||||
static void BEAT_SeekAbs(BEAT_Context *ctx, int id, size_t pos)
|
||||
{ ctx->foffset[id] = pos; } // Seek to absolute position `pos`
|
||||
{ ctx->foff[id] = pos; } // Seek to absolute position `pos`
|
||||
|
||||
static int BEAT_NextVLI(BEAT_Context *ctx, u64 *vli)
|
||||
static int BEAT_NextVLI(BEAT_Context *ctx, u32 *vli)
|
||||
{ // Read the next VLI in the file, update the seek position
|
||||
u8 vli_rdbuf[BEAT_VLIBUFSZ], *scan = vli_rdbuf;
|
||||
u32 iter = 0;
|
||||
u64 ret = 0;
|
||||
int res;
|
||||
u32 ret = 0;
|
||||
u32 iter = 0;
|
||||
u8 vli_rdbuf[BEAT_VLIBUFSZ], *scan = vli_rdbuf;
|
||||
|
||||
res = BEAT_Read(ctx, BEAT_PATCHFILE, vli_rdbuf, sizeof(vli_rdbuf), false);
|
||||
res = BEAT_Read(ctx, BEAT_PF, vli_rdbuf, sizeof(vli_rdbuf), 0);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
while(scan < &vli_rdbuf[sizeof(vli_rdbuf)]) {
|
||||
u64 val = *(scan++);
|
||||
u32 val = *(scan++);
|
||||
ret += (val & 0x7F) << iter;
|
||||
if (val & 0x80) break;
|
||||
iter += 7;
|
||||
ret += (u64)(1ULL << iter);
|
||||
ret += (u32)(1ULL << iter);
|
||||
}
|
||||
|
||||
// Seek forward only by the amount of used bytes
|
||||
BEAT_SeekOff(ctx, BEAT_PATCHFILE, scan - vli_rdbuf);
|
||||
BEAT_SeekOff(ctx, BEAT_PF, scan - vli_rdbuf);
|
||||
*vli = ret;
|
||||
return res;
|
||||
}
|
||||
|
||||
static s64 BEAT_DecodeSigned(u64 val) // Extract the signed number
|
||||
static s32 BEAT_DecodeSigned(u32 val) // Extract the signed number
|
||||
{ if (val&1) return -(val>>1); else return (val>>1); }
|
||||
|
||||
static int BEAT_NextAction(int *act, u64 *len, BEAT_Context *ctx)
|
||||
{ // Decode next action word, retrieves state and length parameters
|
||||
int res;
|
||||
ssize_t end;
|
||||
u64 val;
|
||||
|
||||
end = BEAT_RANGESZ(ctx, BEAT_PATCHFILE) - ctx->foffset[BEAT_PATCHFILE];
|
||||
|
||||
if (end == ctx->eoal_offset) return BEAT_EOAL;
|
||||
if (end < ctx->eoal_offset) return BEAT_PATCH_EXPECT;
|
||||
|
||||
res = BEAT_NextVLI(ctx, &val);
|
||||
*act = val & 3;
|
||||
*len = (val >> 2) + 1;
|
||||
return res;
|
||||
}
|
||||
|
||||
static int BEAT_RunActions(BEAT_Context *ctx, const BEAT_Action *acts)
|
||||
{ // Parses an action list and runs commands specified in `acts`
|
||||
int cmd;
|
||||
u64 len;
|
||||
u32 vli, len;
|
||||
int cmd, res;
|
||||
|
||||
while(1) {
|
||||
int res = BEAT_NextAction(&cmd, &len, ctx);
|
||||
if (res == BEAT_EOAL) return BEAT_EOAL; // End of patch
|
||||
if (res != BEAT_OK) return res; // Failed to get next action
|
||||
while((res == BEAT_OK) &&
|
||||
(ctx->foff[BEAT_PF] < (BEAT_RANGE(ctx, BEAT_PF) - ctx->eoal_offset))) {
|
||||
res = BEAT_NextVLI(ctx, &vli); // get next action
|
||||
cmd = vli & 3;
|
||||
len = (vli >> 2) + 1;
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
if (!BEAT_UpdateProgress(ctx)) return BEAT_ABORTED;
|
||||
|
||||
res = (acts[cmd])(ctx, len); // Execute next action
|
||||
if (res == BEAT_ABORTED) return BEAT_ABORTED; // Return on user abort
|
||||
if (res != BEAT_OK) return res; // Break on error
|
||||
if (res != BEAT_OK) return res; // Break on error or user abort
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static void BEAT_ReleaseCTX(BEAT_Context *ctx)
|
||||
{ // Release any resources associated to the context
|
||||
free(ctx->copybuf);
|
||||
for (int i = 0; i < BEAT_FILECOUNT; i++) {
|
||||
for (int i = 0; i < BEAT_FILENUM; i++) {
|
||||
if (fvx_opened(&ctx->file[i])) fvx_close(&ctx->file[i]);
|
||||
}
|
||||
progress_refcnt--; // lol what even are atomics
|
||||
}
|
||||
|
||||
// BPS Specific functions
|
||||
@ -227,12 +256,12 @@ static void BEAT_ReleaseCTX(BEAT_Context *ctx)
|
||||
- extracts initial info
|
||||
- leaves the file ready to begin state machine execution
|
||||
*/
|
||||
static int BPS_InitCTX_Advanced(BEAT_Context *ctx, const char *bps_path, const char *in_path, const char *out_path, size_t start, size_t end)
|
||||
static int BPS_InitCTX_Advanced(BEAT_Context *ctx, const char *bps_path, const char *in_path, const char *out_path, size_t start, size_t end, bool do_chksum)
|
||||
{
|
||||
int res;
|
||||
u8 read_magic[4];
|
||||
u64 vli, in_sz, metaend_off;
|
||||
u32 chksum[BEAT_FILECOUNT], expected_chksum[BEAT_FILECOUNT];
|
||||
u32 vli, in_sz, metaend_off;
|
||||
u32 chksum[BEAT_FILENUM], expected_chksum[BEAT_FILENUM];
|
||||
|
||||
// Clear stackbuf
|
||||
memset(ctx, 0, sizeof(*ctx));
|
||||
@ -243,24 +272,25 @@ static int BPS_InitCTX_Advanced(BEAT_Context *ctx, const char *bps_path, const c
|
||||
end = fs_size(bps_path);
|
||||
}
|
||||
|
||||
// Get checksums of BPS and input files
|
||||
chksum[BEAT_PATCHFILE] = crc32_calculate_from_file(bps_path, start, end - start - 4);
|
||||
chksum[BEAT_SRCFILE] = crc32_calculate_from_file(in_path, 0, fs_size(in_path));
|
||||
if (do_chksum) // get BPS checksum
|
||||
chksum[BEAT_PF] = crc32_calculate_from_file(bps_path, start, end - start - 4);
|
||||
|
||||
strcpy(ctx->processing, basepath(bps_path));
|
||||
|
||||
// open all files
|
||||
fvx_open(&ctx->file[BEAT_PATCHFILE], bps_path, BEAT_READONLY);
|
||||
ctx->ranges[0][BEAT_PATCHFILE] = start;
|
||||
ctx->ranges[1][BEAT_PATCHFILE] = end;
|
||||
fvx_open(&ctx->file[BEAT_PF], bps_path, BEAT_READONLY);
|
||||
ctx->ranges[0][BEAT_PF] = start;
|
||||
ctx->ranges[1][BEAT_PF] = end;
|
||||
|
||||
fvx_open(&ctx->file[BEAT_SRCFILE], in_path, BEAT_READONLY);
|
||||
ctx->ranges[0][BEAT_SRCFILE] = 0;
|
||||
ctx->ranges[1][BEAT_SRCFILE] = fs_size(in_path);
|
||||
fvx_open(&ctx->file[BEAT_IF], in_path, BEAT_READONLY);
|
||||
ctx->ranges[0][BEAT_IF] = 0;
|
||||
ctx->ranges[1][BEAT_IF] = fs_size(in_path);
|
||||
|
||||
res = fvx_open(&ctx->file[BEAT_DSTFILE], out_path, BEAT_RWCREATE);
|
||||
res = fvx_open(&ctx->file[BEAT_OF], out_path, BEAT_RWCREATE);
|
||||
if (res != FR_OK) return BEAT_IO_ERROR;
|
||||
|
||||
// Verify BPS1 header magic
|
||||
res = BEAT_Read(ctx, BEAT_PATCHFILE, read_magic, sizeof(read_magic), true);
|
||||
res = BEAT_Read(ctx, BEAT_PF, read_magic, sizeof(read_magic), 1);
|
||||
if (res != BEAT_OK) return BEAT_IO_ERROR;
|
||||
res = memcmp(read_magic, bps_signature, sizeof(bps_signature));
|
||||
if (res != 0) return BEAT_BADPATCH;
|
||||
@ -268,113 +298,114 @@ static int BPS_InitCTX_Advanced(BEAT_Context *ctx, const char *bps_path, const c
|
||||
// Check input size
|
||||
res = BEAT_NextVLI(ctx, &in_sz);
|
||||
if (res != BEAT_OK) return res;
|
||||
if (ctx->ranges[1][BEAT_SRCFILE] != in_sz) return BEAT_BADINPUT;
|
||||
if (ctx->ranges[1][BEAT_IF] != in_sz) return BEAT_BADINPUT;
|
||||
|
||||
// Get expected output size
|
||||
res = BEAT_NextVLI(ctx, &vli);
|
||||
if (res != BEAT_OK) return res;
|
||||
ctx->ranges[0][BEAT_DSTFILE] = 0;
|
||||
ctx->ranges[1][BEAT_DSTFILE] = vli;
|
||||
ctx->ranges[0][BEAT_OF] = 0;
|
||||
ctx->ranges[1][BEAT_OF] = vli;
|
||||
|
||||
// Get end of metadata offset
|
||||
res = BEAT_NextVLI(ctx, &metaend_off);
|
||||
if (res != BEAT_OK) return res;
|
||||
metaend_off += ctx->foffset[BEAT_PATCHFILE];
|
||||
metaend_off += ctx->foff[BEAT_PF];
|
||||
|
||||
// Read checksums from BPS file
|
||||
for (int i = 0; i < BEAT_FILECOUNT; i++) {
|
||||
BEAT_SeekAbs(ctx, BEAT_PATCHFILE, ctx->ranges[1][BEAT_PATCHFILE] - ctx->ranges[0][BEAT_PATCHFILE] - bps_chksumoffs[i]);
|
||||
BEAT_Read(ctx, BEAT_PATCHFILE, &expected_chksum[i], sizeof(u32), false);
|
||||
for (int i = 0; i < BEAT_FILENUM; i++) {
|
||||
BEAT_SeekAbs(ctx, BEAT_PF, BEAT_RANGE(ctx, BEAT_PF) - bps_chksumoffs[i]);
|
||||
BEAT_Read(ctx, BEAT_PF, &expected_chksum[i], sizeof(u32), 0);
|
||||
}
|
||||
|
||||
// Verify patch and input checksums
|
||||
if (chksum[BEAT_PATCHFILE] != expected_chksum[BEAT_PATCHFILE]) return BEAT_BADCHKSUM;
|
||||
if (chksum[BEAT_SRCFILE] != expected_chksum[BEAT_SRCFILE]) return BEAT_BADCHKSUM;
|
||||
if (do_chksum) { // Verify patch checksum
|
||||
if (chksum[BEAT_PF] != expected_chksum[BEAT_PF]) return BEAT_BADCHKSUM;
|
||||
}
|
||||
|
||||
// Initialize output checksums
|
||||
ctx->ocrc = 0;
|
||||
ctx->xocrc = expected_chksum[BEAT_DSTFILE];
|
||||
ctx->xocrc = expected_chksum[BEAT_OF];
|
||||
|
||||
// Allocate temporary block copy buffer
|
||||
ctx->copybuf = malloc(STD_BUFFER_SIZE);
|
||||
ctx->copybuf = malloc(BEAT_FILEBUFSZ);
|
||||
if (ctx->copybuf == NULL) return BEAT_OUT_OF_MEMORY;
|
||||
|
||||
// Seek back to the start of action stream / end of metadata
|
||||
BEAT_SeekAbs(ctx, BEAT_PATCHFILE, metaend_off);
|
||||
BEAT_SeekAbs(ctx, BEAT_PF, metaend_off);
|
||||
progress_refcnt++;
|
||||
return BEAT_OK;
|
||||
}
|
||||
|
||||
static int BPS_InitCTX(BEAT_Context *ctx, const char *bps_path, const char *in_path, const char *out_path)
|
||||
{
|
||||
return BPS_InitCTX_Advanced(ctx, bps_path, in_path, out_path, 0, 0);
|
||||
}
|
||||
static int BPS_InitCTX(BEAT_Context *ctx, const char *bps, const char *in, const char *out)
|
||||
{ return BPS_InitCTX_Advanced(ctx, bps, in, out, 0, 0, true); }
|
||||
|
||||
/*
|
||||
Generic helper function to copy from `src_id` to BEAT_DSTFILE
|
||||
Generic helper function to copy from `src_id` to BEAT_OF
|
||||
Used by SourceRead, TargetRead and CreateFile
|
||||
*/
|
||||
static int BEAT_BlkCopy(BEAT_Context *ctx, int src_id, u64 len)
|
||||
static int BEAT_BlkCopy(BEAT_Context *ctx, int src_id, u32 len)
|
||||
{
|
||||
while(len > 0) {
|
||||
ssize_t blksz = min(len, STD_BUFFER_SIZE);
|
||||
int res = BEAT_Read(ctx, src_id, ctx->copybuf, blksz, true);
|
||||
ssize_t blksz = min(len, BEAT_FILEBUFSZ);
|
||||
int res = BEAT_Read(ctx, src_id, ctx->copybuf, blksz, 1);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
res = BEAT_WriteOut(ctx, ctx->copybuf, blksz, true);
|
||||
res = BEAT_WriteOut(ctx, ctx->copybuf, blksz, 1);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
if (!BEAT_UpdateProgress(ctx)) return BEAT_ABORTED;
|
||||
|
||||
len -= blksz;
|
||||
}
|
||||
return BEAT_OK;
|
||||
}
|
||||
|
||||
static int BPS_SourceRead(BEAT_Context *ctx, u64 len)
|
||||
static int BPS_SourceRead(BEAT_Context *ctx, u32 len)
|
||||
{ // This command copies bytes from the source file to the target file
|
||||
BEAT_SeekAbs(ctx, BEAT_SRCFILE, ctx->foffset[BEAT_DSTFILE]);
|
||||
return BEAT_BlkCopy(ctx, BEAT_SRCFILE, len);
|
||||
BEAT_SeekAbs(ctx, BEAT_IF, ctx->foff[BEAT_OF]);
|
||||
return BEAT_BlkCopy(ctx, BEAT_IF, len);
|
||||
}
|
||||
|
||||
/*
|
||||
[...] the actual data is not available to the patch applier,
|
||||
so it is stored directly inside the patch.
|
||||
*/
|
||||
static int BPS_TargetRead(BEAT_Context *ctx, u64 len)
|
||||
static int BPS_TargetRead(BEAT_Context *ctx, u32 len)
|
||||
{
|
||||
return BEAT_BlkCopy(ctx, BEAT_PATCHFILE, len);
|
||||
return BEAT_BlkCopy(ctx, BEAT_PF, len);
|
||||
}
|
||||
|
||||
/*
|
||||
An offset is supplied to seek the sourceRelativeOffset to the desired
|
||||
location, and then data is copied from said offset to the target file
|
||||
*/
|
||||
static int BPS_SourceCopy(BEAT_Context *ctx, u64 len)
|
||||
static int BPS_SourceCopy(BEAT_Context *ctx, u32 len)
|
||||
{
|
||||
int res;
|
||||
u64 vli;
|
||||
s64 offset;
|
||||
u32 vli;
|
||||
s32 offset;
|
||||
|
||||
res = BEAT_NextVLI(ctx, &vli);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
offset = BEAT_DecodeSigned(vli);
|
||||
BEAT_SeekAbs(ctx, BEAT_SRCFILE, ctx->source_relative + offset);
|
||||
BEAT_SeekAbs(ctx, BEAT_IF, ctx->source_relative + offset);
|
||||
ctx->source_relative += offset + len;
|
||||
|
||||
return BEAT_BlkCopy(ctx, BEAT_SRCFILE, len);
|
||||
return BEAT_BlkCopy(ctx, BEAT_IF, len);
|
||||
}
|
||||
|
||||
/* This command treats all of the data that has already been written to the target file as a dictionary */
|
||||
static int BPS_TargetCopy(BEAT_Context *ctx, u64 len)
|
||||
static int BPS_TargetCopy(BEAT_Context *ctx, u32 len)
|
||||
{ // the black sheep of the family, needs special care
|
||||
int res;
|
||||
s64 offset;
|
||||
u64 out_off, rel_off, vli;
|
||||
s32 offset;
|
||||
u32 out_off, rel_off, vli;
|
||||
|
||||
res = BEAT_NextVLI(ctx, &vli);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
offset = BEAT_DecodeSigned(vli);
|
||||
out_off = ctx->foffset[BEAT_DSTFILE];
|
||||
out_off = ctx->foff[BEAT_OF];
|
||||
rel_off = ctx->target_relative + offset;
|
||||
if (rel_off > out_off) return BEAT_BADPATCH; // Illegal
|
||||
|
||||
@ -382,11 +413,11 @@ static int BPS_TargetCopy(BEAT_Context *ctx, u64 len)
|
||||
u8 *remfill;
|
||||
ssize_t blksz, distance, remainder;
|
||||
|
||||
blksz = min(len, STD_BUFFER_SIZE);
|
||||
blksz = min(len, BEAT_FILEBUFSZ);
|
||||
distance = min((ssize_t)(out_off - rel_off), blksz);
|
||||
|
||||
BEAT_SeekAbs(ctx, BEAT_DSTFILE, rel_off);
|
||||
res = BEAT_Read(ctx, BEAT_DSTFILE, ctx->copybuf, distance, false);
|
||||
BEAT_SeekAbs(ctx, BEAT_OF, rel_off);
|
||||
res = BEAT_Read(ctx, BEAT_OF, ctx->copybuf, distance, 0);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
remfill = ctx->copybuf + distance;
|
||||
@ -398,16 +429,17 @@ static int BPS_TargetCopy(BEAT_Context *ctx, u64 len)
|
||||
remainder -= remblk;
|
||||
}
|
||||
|
||||
BEAT_SeekAbs(ctx, BEAT_DSTFILE, out_off);
|
||||
res = BEAT_WriteOut(ctx, ctx->copybuf, blksz, false);
|
||||
BEAT_SeekAbs(ctx, BEAT_OF, out_off);
|
||||
res = BEAT_WriteOut(ctx, ctx->copybuf, blksz, 0);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
if (!BEAT_UpdateProgress(ctx)) return BEAT_ABORTED;
|
||||
rel_off += blksz;
|
||||
out_off += blksz;
|
||||
len -= blksz;
|
||||
}
|
||||
|
||||
BEAT_SeekAbs(ctx, BEAT_DSTFILE, out_off);
|
||||
BEAT_SeekAbs(ctx, BEAT_OF, out_off);
|
||||
ctx->target_relative = rel_off;
|
||||
return BEAT_OK;
|
||||
}
|
||||
@ -433,10 +465,10 @@ static int BPS_RunActions(BEAT_Context *ctx)
|
||||
static int BPM_OpenFile(BEAT_Context *ctx, int id, const char *path, size_t max_sz)
|
||||
{
|
||||
FRESULT res;
|
||||
if (fvx_opened(&ctx->file[id])) fvx_close(&ctx->file[id]);
|
||||
|
||||
if (fvx_opened(&ctx->file[id])) fvx_close(&ctx->file[id]);
|
||||
res = fvx_open(&ctx->file[id], path, max_sz ? BEAT_RWCREATE : BEAT_READONLY);
|
||||
if (res == FR_OK) return BEAT_IO_ERROR;
|
||||
if (res != FR_OK) return BEAT_IO_ERROR;
|
||||
|
||||
ctx->ranges[0][id] = 0;
|
||||
if (max_sz > 0) {
|
||||
@ -448,14 +480,14 @@ static int BPM_OpenFile(BEAT_Context *ctx, int id, const char *path, size_t max_
|
||||
// if a new file is opened it makes no sense to keep the old CRC
|
||||
// a single outfile wont be created from more than one infile (& patch)
|
||||
ctx->ocrc = 0;
|
||||
ctx->foffset[id] = 0;
|
||||
ctx->foff[id] = 0;
|
||||
return BEAT_OK;
|
||||
}
|
||||
|
||||
static int BPM_InitCTX(BEAT_Context *ctx, const char *bpm_path, const char *src_dir, const char *dst_dir)
|
||||
{
|
||||
int res;
|
||||
u64 metaend_off;
|
||||
u32 metaend_off;
|
||||
u8 read_magic[4];
|
||||
u32 chksum, expected_chksum;
|
||||
|
||||
@ -467,37 +499,44 @@ static int BPM_InitCTX(BEAT_Context *ctx, const char *bpm_path, const char *src_
|
||||
ctx->eoal_offset = 4;
|
||||
|
||||
chksum = crc32_calculate_from_file(bpm_path, 0, fs_size(bpm_path) - 4);
|
||||
res = BPM_OpenFile(ctx, BEAT_PATCHFILE, bpm_path, 0);
|
||||
res = BEAT_Read(ctx, BEAT_PATCHFILE, read_magic, sizeof(read_magic), true);
|
||||
res = BPM_OpenFile(ctx, BEAT_PF, bpm_path, 0);
|
||||
if (res != BEAT_OK) return res;
|
||||
res = BEAT_Read(ctx, BEAT_PF, read_magic, sizeof(read_magic), 1);
|
||||
if (res != BEAT_OK) return res;
|
||||
res = memcmp(read_magic, bpm_signature, sizeof(bpm_signature));
|
||||
ShowPrompt(false, "%.4s %.4s", bpm_signature, read_magic);
|
||||
if (res != 0) return BEAT_BADPATCH;
|
||||
|
||||
// Get end of metadata offset
|
||||
res = BEAT_NextVLI(ctx, &metaend_off);
|
||||
if (res != BEAT_OK) return res;
|
||||
metaend_off += ctx->foffset[BEAT_PATCHFILE];
|
||||
metaend_off += ctx->foff[BEAT_PF];
|
||||
|
||||
// Read checksums from BPS file
|
||||
BEAT_SeekAbs(ctx, BEAT_PATCHFILE, BEAT_RANGESZ(ctx, BEAT_PATCHFILE) - 4);
|
||||
res = BEAT_Read(ctx, BEAT_PATCHFILE, &expected_chksum, sizeof(u32), false);
|
||||
BEAT_SeekAbs(ctx, BEAT_PF, BEAT_RANGE(ctx, BEAT_PF) - 4);
|
||||
res = BEAT_Read(ctx, BEAT_PF, &expected_chksum, sizeof(u32), 0);
|
||||
if (res != BEAT_OK) return res;
|
||||
if (expected_chksum != chksum) return BEAT_BADCHKSUM;
|
||||
|
||||
// Allocate temporary block copy buffer
|
||||
ctx->copybuf = malloc(STD_BUFFER_SIZE);
|
||||
ctx->copybuf = malloc(BEAT_FILEBUFSZ);
|
||||
if (ctx->copybuf == NULL) return BEAT_OUT_OF_MEMORY;
|
||||
|
||||
// Seek back to the start of action stream / end of metadata
|
||||
BEAT_SeekAbs(ctx, BEAT_PATCHFILE, metaend_off);
|
||||
BEAT_SeekAbs(ctx, BEAT_PF, metaend_off);
|
||||
progress_refcnt++;
|
||||
return BEAT_OK;
|
||||
}
|
||||
|
||||
static int BPM_NextPath(BEAT_Context *ctx, char *out, int name_len)
|
||||
{
|
||||
if (name_len >= BEAT_MAXPATH) return BEAT_BADPATCH;
|
||||
int res = BEAT_Read(ctx, BEAT_PATCHFILE, out, name_len, true);
|
||||
out[name_len] = '\0'; // make sure the buffer ends with a zero char
|
||||
int res = BEAT_Read(ctx, BEAT_PF, out, name_len, 1);
|
||||
out[name_len] = '\0';
|
||||
if (res == BEAT_OK) {
|
||||
out[name_len] = '\0'; // make sure the buffer ends with a zero char
|
||||
strcpy(ctx->processing, out);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
@ -513,7 +552,7 @@ static int BPM_MakeRelativePaths(BEAT_Context *ctx, char *src, char *dst, int na
|
||||
return res;
|
||||
}
|
||||
|
||||
static int BPM_CreatePath(BEAT_Context *ctx, u64 name_len)
|
||||
static int BPM_CreatePath(BEAT_Context *ctx, u32 name_len)
|
||||
{ // Create a directory
|
||||
char path[BEAT_MAXPATH];
|
||||
int res = BPM_MakeRelativePaths(ctx, NULL, path, name_len);
|
||||
@ -524,9 +563,9 @@ static int BPM_CreatePath(BEAT_Context *ctx, u64 name_len)
|
||||
return BEAT_OK;
|
||||
}
|
||||
|
||||
static int BPM_CreateFile(BEAT_Context *ctx, u64 name_len)
|
||||
static int BPM_CreateFile(BEAT_Context *ctx, u32 name_len)
|
||||
{ // Create a file and fill it with data provided in the BPM
|
||||
u64 file_sz;
|
||||
u32 file_sz;
|
||||
u32 checksum;
|
||||
char path[BEAT_MAXPATH];
|
||||
|
||||
@ -535,20 +574,20 @@ static int BPM_CreateFile(BEAT_Context *ctx, u64 name_len)
|
||||
|
||||
res = BEAT_NextVLI(ctx, &file_sz); // get new file size
|
||||
if (res != BEAT_OK) return res;
|
||||
res = BPM_OpenFile(ctx, BEAT_DSTFILE, path, file_sz); // open file as RW
|
||||
res = BPM_OpenFile(ctx, BEAT_OF, path, file_sz); // open file as RW
|
||||
if (res != BEAT_OK) return res;
|
||||
res = BEAT_BlkCopy(ctx, BEAT_PATCHFILE, file_sz); // copy data to new file
|
||||
res = BEAT_BlkCopy(ctx, BEAT_PF, file_sz); // copy data to new file
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
res = BEAT_Read(ctx, BEAT_PATCHFILE, &checksum, sizeof(u32), true);
|
||||
res = BEAT_Read(ctx, BEAT_PF, &checksum, sizeof(u32), 1);
|
||||
if (res != BEAT_OK) return res;
|
||||
if (ctx->ocrc != checksum) return BEAT_BADOUTPUT; // get and check CRC32
|
||||
return BEAT_OK;
|
||||
}
|
||||
|
||||
static int BPM_ModifyFile(BEAT_Context *ctx, u64 name_len)
|
||||
static int BPM_ModifyFile(BEAT_Context *ctx, u32 name_len)
|
||||
{ // Apply a BPS patch
|
||||
u64 origin, bps_sz;
|
||||
u32 origin, bps_sz;
|
||||
BEAT_Context bps_context;
|
||||
char src[BEAT_MAXPATH], dst[BEAT_MAXPATH];
|
||||
|
||||
@ -562,19 +601,20 @@ static int BPM_ModifyFile(BEAT_Context *ctx, u64 name_len)
|
||||
|
||||
res = BPS_InitCTX_Advanced(
|
||||
&bps_context, ctx->bpm_path, src, dst,
|
||||
ctx->foffset[BEAT_PATCHFILE], ctx->foffset[BEAT_PATCHFILE] + bps_sz
|
||||
ctx->foff[BEAT_PF], ctx->foff[BEAT_PF] + bps_sz,
|
||||
false
|
||||
); // create a BPS context using the current ranges
|
||||
if (res == BEAT_OK) res = BPS_RunActions(&bps_context); // run if OK
|
||||
BEAT_ReleaseCTX(&bps_context);
|
||||
if (res != BEAT_OK) return res; // break off if there was an error
|
||||
|
||||
BEAT_SeekOff(ctx, BEAT_PATCHFILE, bps_sz); // advance beyond the BPS
|
||||
BEAT_SeekOff(ctx, BEAT_PF, bps_sz); // advance beyond the BPS
|
||||
return BEAT_OK;
|
||||
}
|
||||
|
||||
static int BPM_MirrorFile(BEAT_Context *ctx, u64 name_len)
|
||||
static int BPM_MirrorFile(BEAT_Context *ctx, u32 name_len)
|
||||
{ // Copy a file from source to target without any modifications
|
||||
u64 origin;
|
||||
u32 origin;
|
||||
u32 checksum;
|
||||
char src[BEAT_MAXPATH], dst[BEAT_MAXPATH];
|
||||
|
||||
@ -582,18 +622,18 @@ static int BPM_MirrorFile(BEAT_Context *ctx, u64 name_len)
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
// open source and destination files, read the origin dummy
|
||||
res = BPM_OpenFile(ctx, BEAT_SRCFILE, src, 0);
|
||||
res = BPM_OpenFile(ctx, BEAT_IF, src, 0);
|
||||
if (res != BEAT_OK) return res;
|
||||
res = BPM_OpenFile(ctx, BEAT_DSTFILE, dst, ctx->ranges[1][BEAT_SRCFILE]);
|
||||
res = BPM_OpenFile(ctx, BEAT_OF, dst, ctx->ranges[1][BEAT_IF]);
|
||||
if (res != BEAT_OK) return res;
|
||||
res = BEAT_NextVLI(ctx, &origin);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
// copy straight from source to destination
|
||||
res = BEAT_BlkCopy(ctx, BEAT_SRCFILE, ctx->ranges[1][BEAT_SRCFILE]);
|
||||
res = BEAT_BlkCopy(ctx, BEAT_IF, ctx->ranges[1][BEAT_IF]);
|
||||
if (res != BEAT_OK) return res;
|
||||
|
||||
res = BEAT_Read(ctx, BEAT_PATCHFILE, &checksum, sizeof(u32), true);
|
||||
res = BEAT_Read(ctx, BEAT_PF, &checksum, sizeof(u32), 1);
|
||||
if (res != BEAT_OK) return res;
|
||||
if (ctx->ocrc != checksum) return BEAT_BADOUTPUT; // verify checksum
|
||||
return BEAT_OK;
|
||||
@ -617,6 +657,8 @@ static int BEAT_Run(const char *p, const char *s, const char *d, bool bpm)
|
||||
{
|
||||
int res;
|
||||
BEAT_Context ctx;
|
||||
|
||||
progress_timer = timer_start();
|
||||
res = (bpm ? BPM_InitCTX : BPS_InitCTX)(&ctx, p, s, d);
|
||||
if (res != BEAT_OK) {
|
||||
ShowPrompt(false, "Failed to initialize %s file:\n%s",
|
||||
@ -625,7 +667,7 @@ static int BEAT_Run(const char *p, const char *s, const char *d, bool bpm)
|
||||
res = (bpm ? BPM_RunActions : BPS_RunActions)(&ctx);
|
||||
switch(res) {
|
||||
case BEAT_OK:
|
||||
ShowPrompt(false, "Successfully patched");
|
||||
ShowPrompt(false, "Patch successfully applied");
|
||||
break;
|
||||
case BEAT_ABORTED:
|
||||
ShowPrompt(false, "Patching aborted by user");
|
||||
@ -641,6 +683,5 @@ static int BEAT_Run(const char *p, const char *s, const char *d, bool bpm)
|
||||
|
||||
int ApplyBPSPatch(const char* modifyName, const char* sourceName, const char* targetName)
|
||||
{ return BEAT_Run(modifyName, sourceName, targetName, false); }
|
||||
|
||||
int ApplyBPMPatch(const char* patchName, const char* sourcePath, const char* targetPath)
|
||||
{ return BEAT_Run(patchName, sourcePath, targetPath, true); }
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user