732 lines
26 KiB
C
732 lines
26 KiB
C
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "sfx_small.h"
|
|
#include "sfx_fast.h"
|
|
|
|
#define BUFFER_SIZE 65536 /* must be > MAX_OFFSET */
|
|
#define INITIAL_OFFSET 1
|
|
|
|
#define FALSE 0
|
|
#define TRUE 1
|
|
#define DALI_BITS_LEFT 0
|
|
#define DALI_ELIAS_LE 1
|
|
|
|
typedef struct ctx {
|
|
unsigned char *packed_data;
|
|
unsigned char *reencoded_data;
|
|
unsigned char *unpacked_data;
|
|
size_t packed_index;
|
|
size_t packed_size;
|
|
int packed_bit_mask;
|
|
int packed_bit_value;
|
|
size_t reencoded_index;
|
|
int reencoded_bit_mask;
|
|
int reencoded_bit_value;
|
|
int reencoded_bit_index;
|
|
size_t unpacked_index;
|
|
size_t unpacked_size;
|
|
int inplace;
|
|
|
|
char *output_name;
|
|
char *input_name;
|
|
char *prefix_name;
|
|
char *clamped_name;
|
|
|
|
int cbm;
|
|
int cbm_orig_addr;
|
|
int cbm_packed_addr;
|
|
int cbm_range_from;
|
|
int cbm_range_to;
|
|
int cbm_relocate_packed_addr;
|
|
int cbm_relocate_origin_addr;
|
|
int cbm_prefix_from;
|
|
|
|
int sfx;
|
|
int sfx_addr;
|
|
int sfx_01;
|
|
int sfx_cli;
|
|
int sfx_small;
|
|
int sfx_size;
|
|
char *sfx_code;
|
|
int lz_bits;
|
|
} ctx;
|
|
|
|
void salvador_main();
|
|
|
|
static int read_number(char* arg, char* argname, int limit) {
|
|
int number;
|
|
if (arg != NULL && arg[0] == '$') number = strtoul(arg + 1, NULL, 16);
|
|
else if (arg != NULL && arg[0] == '0' && arg[1] == 'x') number = strtoul(arg + 2, NULL, 16);
|
|
else if (arg != NULL && arg[0] >= '0' && arg[0] <= '9') number = strtoul(arg, NULL, 10);
|
|
else {
|
|
fprintf(stderr, "Error: no valid number given for argument %s (given value is: '%s')\n", argname, arg);
|
|
exit(1);
|
|
}
|
|
if (number < 0 || number > limit) {
|
|
fprintf(stderr, "Error: Number '%s' out of range (0 - 65536)\n", arg);
|
|
exit(1);
|
|
}
|
|
return number;
|
|
}
|
|
|
|
static void file_write_byte(int byte, FILE *ofp) {
|
|
if (fputc(byte, ofp) != byte) {
|
|
fprintf(stderr, "Error: Cannot write output file\n");
|
|
perror("fputc");
|
|
exit(1);
|
|
}
|
|
return;
|
|
}
|
|
|
|
static inline unsigned bit_size(unsigned value) {
|
|
# ifdef __GNUC__
|
|
// enum { WORD_BITS = sizeof(unsigned) * CHAR_BIT };
|
|
|
|
return ((sizeof(unsigned) * 8 - 1) ^ __builtin_clz(value));
|
|
# else
|
|
signed bits = -1;
|
|
|
|
do
|
|
++bits;
|
|
while(value >>= 1);
|
|
|
|
return bits;
|
|
# endif
|
|
}
|
|
|
|
void write_reencoded_byte(ctx* ctx, int value) {
|
|
ctx->reencoded_data[ctx->reencoded_index++] = value;
|
|
}
|
|
|
|
void write_reencoded_bit(ctx* ctx, int value) {
|
|
if (!(ctx->reencoded_bit_mask & 255)) {
|
|
if (DALI_BITS_LEFT == 1) {
|
|
ctx->reencoded_bit_mask = 0x80;
|
|
} else {
|
|
ctx->reencoded_bit_mask = 0x1;
|
|
}
|
|
/* remember position of bit-buffer */
|
|
ctx->reencoded_bit_index = ctx->reencoded_index;
|
|
ctx->lz_bits++;
|
|
write_reencoded_byte(ctx, 0);
|
|
}
|
|
if (value)
|
|
ctx->reencoded_data[ctx->reencoded_bit_index] |= ctx->reencoded_bit_mask;
|
|
if (DALI_BITS_LEFT == 1) {
|
|
ctx->reencoded_bit_mask >>= 1;
|
|
} else {
|
|
ctx->reencoded_bit_mask <<= 1;
|
|
}
|
|
}
|
|
|
|
void write_reencoded_interlaced_elias_gamma(ctx* ctx, int value, int skip) {
|
|
int bits = bit_size(value);
|
|
int i;
|
|
|
|
for (i = 2; i <= value; i <<= 1);
|
|
i >>= 1;
|
|
|
|
if (DALI_ELIAS_LE) {
|
|
if (bits >= 8) {
|
|
/* change bit-order, send LSB first */
|
|
/* remove preceeding 1 first */
|
|
value = value & ((0xffff ^ i));
|
|
/* move LSB bits to the beginning */
|
|
value = (value >> 8) | ((value & 0xff) << (bits - 8));
|
|
}
|
|
}
|
|
|
|
while ((i >>= 1) > 0) {
|
|
if (!skip) write_reencoded_bit(ctx, 0);
|
|
skip = 0;
|
|
write_reencoded_bit(ctx, ((value & i) > 0));
|
|
}
|
|
if (!skip) write_reencoded_bit(ctx, 1);
|
|
}
|
|
|
|
int read_byte(ctx* ctx) {
|
|
return ctx->packed_data[ctx->packed_index++];
|
|
}
|
|
|
|
int read_bit(ctx* ctx) {
|
|
if ((ctx->packed_bit_mask >>= 1) == 0) {
|
|
ctx->packed_bit_mask = 0x80;
|
|
ctx->packed_bit_value = read_byte(ctx);
|
|
}
|
|
return (ctx->packed_bit_value & ctx->packed_bit_mask) != 0;
|
|
}
|
|
|
|
int read_interlaced_elias_gamma(ctx* ctx, int inverted, int skip) {
|
|
int value = 1;
|
|
/* skip first read bit if skip != 0 */
|
|
while (skip || !read_bit(ctx)) {
|
|
skip = 0;
|
|
value = (value << 1) | (read_bit(ctx) ^ inverted);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
void save_reencoded_stream(ctx* ctx) {
|
|
}
|
|
|
|
void copy_inplace_literal(ctx* ctx) {
|
|
int i;
|
|
for (i = ctx->unpacked_index; i < ctx->unpacked_size; i++) {
|
|
ctx->reencoded_data[ctx->packed_index] = ctx->unpacked_data[i];
|
|
ctx->packed_index++;
|
|
}
|
|
}
|
|
|
|
void encode_literal(ctx* ctx, int length, int first) {
|
|
int i;
|
|
if (!first) write_reencoded_bit(ctx, 0);
|
|
write_reencoded_interlaced_elias_gamma(ctx, length, 0);
|
|
for (i = 0; i < length; i++) {
|
|
write_reencoded_byte(ctx, ctx->unpacked_data[ctx->unpacked_index + i]);
|
|
}
|
|
}
|
|
|
|
void encode_rep(ctx* ctx, int length) {
|
|
write_reencoded_bit(ctx, 0);
|
|
write_reencoded_interlaced_elias_gamma(ctx, length, 0);
|
|
}
|
|
|
|
void encode_match(ctx* ctx, int length, int offset) {
|
|
write_reencoded_bit(ctx, 1);
|
|
write_reencoded_interlaced_elias_gamma(ctx, ((offset - 1) >> 7) + 1, 0);
|
|
write_reencoded_byte(ctx, (((offset - 1) & 0x7f) << 1) | (length == 2));
|
|
write_reencoded_interlaced_elias_gamma(ctx, length - 1, 1);
|
|
}
|
|
|
|
void reencode_packed_stream(ctx* ctx) {
|
|
int last_offset = INITIAL_OFFSET;
|
|
int length;
|
|
int overwrite;
|
|
|
|
int bit, byte;
|
|
int i;
|
|
|
|
int safe_input_index = 0;
|
|
int safe_output_index = 0;
|
|
|
|
int first = 1;
|
|
|
|
ctx->packed_index = 0;
|
|
ctx->packed_bit_mask = 0;
|
|
|
|
ctx->reencoded_index = 0;
|
|
ctx->reencoded_bit_mask = 0;
|
|
ctx->reencoded_bit_value = 0;
|
|
ctx->reencoded_bit_index = 0;
|
|
|
|
ctx->packed_index = 0;
|
|
ctx->unpacked_index = 0;
|
|
|
|
ctx->packed_bit_mask = 0;
|
|
ctx->lz_bits = 0;
|
|
|
|
while (1) {
|
|
/* literal */
|
|
length = read_interlaced_elias_gamma(ctx, FALSE, 0);
|
|
for (i = 0; i < length; i++) read_byte(ctx);
|
|
encode_literal(ctx, length, first);
|
|
first = 0;
|
|
|
|
ctx->unpacked_index += length;
|
|
|
|
overwrite = (ctx->unpacked_index) - (ctx->unpacked_size - ctx->packed_size + ctx->packed_index);
|
|
/* literal would overwrite packed src */
|
|
if (ctx->inplace && overwrite >= 0) {
|
|
/* go back to previous index */
|
|
ctx->unpacked_index = safe_input_index;
|
|
ctx->packed_index = safe_output_index;
|
|
copy_inplace_literal(ctx);
|
|
return;
|
|
}
|
|
/* do remember last safe position */
|
|
safe_input_index = ctx->unpacked_index;
|
|
safe_output_index = ctx->packed_index;
|
|
|
|
/* copy from new or last offset? */
|
|
bit = read_bit(ctx);
|
|
if (!bit) {
|
|
/* copy from last_offset */
|
|
length = read_interlaced_elias_gamma(ctx, FALSE, 0);
|
|
encode_rep(ctx, length);
|
|
|
|
ctx->unpacked_index += length;
|
|
|
|
overwrite = (ctx->unpacked_index) - (ctx->unpacked_size - ctx->packed_size + ctx->packed_index);
|
|
/* rep would overwrite packed src */
|
|
if (ctx->inplace && overwrite >= 0) {
|
|
copy_inplace_literal(ctx);
|
|
return;
|
|
}
|
|
safe_input_index = ctx->unpacked_index;
|
|
safe_output_index = ctx->packed_index;
|
|
|
|
bit = read_bit(ctx);
|
|
}
|
|
|
|
while (bit) {
|
|
/* copy from new_offset */
|
|
last_offset = read_interlaced_elias_gamma(ctx, TRUE, 0);
|
|
if (last_offset == 256) {
|
|
if (!ctx->inplace) {
|
|
write_reencoded_bit(ctx, 1);
|
|
write_reencoded_interlaced_elias_gamma(ctx, last_offset, 0);
|
|
}
|
|
return;
|
|
}
|
|
byte = read_byte(ctx);
|
|
if (byte & 1) length = 2;
|
|
else length = read_interlaced_elias_gamma(ctx, FALSE, 1) + 1;
|
|
last_offset = (last_offset << 7) - (byte >> 1);
|
|
encode_match(ctx, length, last_offset);
|
|
|
|
ctx->unpacked_index += length;
|
|
|
|
overwrite = (ctx->unpacked_index) - (ctx->unpacked_size - ctx->packed_size + ctx->packed_index);
|
|
/* rep would overwrite packed src */
|
|
if (ctx->inplace && overwrite >= 0) {
|
|
copy_inplace_literal(ctx);
|
|
return;
|
|
}
|
|
safe_input_index = ctx->unpacked_index;
|
|
safe_output_index = ctx->packed_index;
|
|
|
|
bit = read_bit(ctx);
|
|
}
|
|
}
|
|
}
|
|
|
|
void write_reencoded_stream(ctx* ctx) {
|
|
FILE *fp = NULL;
|
|
/* write reencoded output file */
|
|
fp = fopen(ctx->output_name, "wb");
|
|
if (!fp) {
|
|
fprintf(stderr, "Error: Cannot create reencoded file (%s)\n", ctx->output_name);
|
|
exit(1);
|
|
}
|
|
|
|
/* as sfx */
|
|
if (ctx->sfx) {
|
|
printf("Creating sfx with start-address $%04x\n", ctx->sfx_addr);
|
|
if (ctx->sfx_small) {
|
|
ctx->sfx_size = sizeof(decruncher_small);
|
|
/* copy over to change values in code */
|
|
ctx->sfx_code = (char *)malloc(ctx->sfx_size);
|
|
memcpy (ctx->sfx_code, decruncher_small, ctx->sfx_size);
|
|
|
|
/* setup jmp target after decompression */
|
|
ctx->sfx_code[DALI_SMALL_SFX_ADDR + 0] = ctx->sfx_addr & 0xff;
|
|
ctx->sfx_code[DALI_SMALL_SFX_ADDR + 1] = (ctx->sfx_addr >> 8) & 0xff;
|
|
|
|
/* setup decompression destination */
|
|
ctx->sfx_code[DALI_SMALL_DST + 0] = ctx->cbm_orig_addr & 0xff;
|
|
ctx->sfx_code[DALI_SMALL_DST + 1] = (ctx->cbm_orig_addr >> 8) & 0xff;
|
|
|
|
/* setup compressed data src */
|
|
ctx->sfx_code[DALI_SMALL_SRC + 0] = (0x10000 - ctx->reencoded_index) & 0xff;
|
|
ctx->sfx_code[DALI_SMALL_SRC + 1] = ((0x10000 - ctx->reencoded_index) >> 8) & 0xff;
|
|
|
|
/* setup compressed data end */
|
|
ctx->sfx_code[DALI_SMALL_DATA_END + 0] = (0x0801 + ctx->sfx_size - 2 + ctx->reencoded_index - 0x100) & 0xff;
|
|
ctx->sfx_code[DALI_SMALL_DATA_END + 1] = ((0x0801 + ctx->sfx_size - 2 + ctx->reencoded_index - 0x100) >> 8) & 0xff;
|
|
|
|
ctx->sfx_code[DALI_SMALL_DATA_SIZE_HI] = 0xff - (((ctx->reencoded_index + 0x100) >> 8) & 0xff);
|
|
} else {
|
|
ctx->sfx_size = sizeof(decruncher);
|
|
/* copy over to change values in code */
|
|
ctx->sfx_code = (char *)malloc(ctx->sfx_size);
|
|
memcpy (ctx->sfx_code, decruncher, ctx->sfx_size);
|
|
|
|
if (ctx->sfx_01 < 0) ctx->sfx_01 = 0x37;
|
|
|
|
/* setup jmp target after decompression */
|
|
ctx->sfx_code[DALI_FAST_SFX_ADDR + 0] = ctx->sfx_addr & 0xff;
|
|
ctx->sfx_code[DALI_FAST_SFX_ADDR + 1] = (ctx->sfx_addr >> 8) & 0xff;
|
|
|
|
/* setup decompression destination */
|
|
ctx->sfx_code[DALI_FAST_DST + 0] = ctx->cbm_orig_addr & 0xff;
|
|
ctx->sfx_code[DALI_FAST_DST + 1] = (ctx->cbm_orig_addr >> 8) & 0xff;
|
|
|
|
/* setup compressed data src */
|
|
ctx->sfx_code[DALI_FAST_SRC + 0] = (0x10000 - ctx->reencoded_index) & 0xff;
|
|
ctx->sfx_code[DALI_FAST_SRC + 1] = ((0x10000 - ctx->reencoded_index) >> 8) & 0xff;
|
|
|
|
/* setup compressed data end */
|
|
ctx->sfx_code[DALI_FAST_DATA_END + 0] = (0x0801 + ctx->sfx_size - 2 + ctx->reencoded_index - 0x100) & 0xff;
|
|
ctx->sfx_code[DALI_FAST_DATA_END + 1] = ((0x0801 + ctx->sfx_size - 2 + ctx->reencoded_index - 0x100) >> 8) & 0xff;
|
|
|
|
ctx->sfx_code[DALI_FAST_DATA_SIZE_HI] = 0xff - (((ctx->reencoded_index + 0x100) >> 8) & 0xff);
|
|
|
|
ctx->sfx_code[DALI_FAST_01] = ctx->sfx_01;
|
|
if (ctx->sfx_cli) ctx->sfx_code[DALI_FAST_CLI] = 0x58;
|
|
}
|
|
printf("original: $%04x-$%04lx ($%04lx) 100%%\n", ctx->cbm_orig_addr, ctx->cbm_orig_addr + ctx->unpacked_size, ctx->unpacked_size);
|
|
printf("packed: $%04x-$%04lx ($%04lx) %3.2f%%\n", 0x0801, 0x0801 + (int)ctx->sfx_size + ctx->packed_index, (int)ctx->sfx_size + ctx->packed_index, ((float)(ctx->packed_index + (int)ctx->sfx_size) / (float)(ctx->unpacked_size) * 100.0));
|
|
|
|
if (fwrite(ctx->sfx_code, sizeof(char), ctx->sfx_size, fp) != ctx->sfx_size) {
|
|
fprintf(stderr, "Error: Cannot write output file %s\n", ctx->output_name);
|
|
exit(1);
|
|
}
|
|
/* or standard compressed */
|
|
} else {
|
|
if (ctx->cbm_relocate_origin_addr >= 0) {
|
|
ctx->cbm_orig_addr = ctx->cbm_relocate_origin_addr;
|
|
ctx->cbm = TRUE;
|
|
}
|
|
|
|
if (ctx->inplace) {
|
|
ctx->cbm_packed_addr = ctx->cbm_range_to - ctx->packed_index - 2;
|
|
} else {
|
|
if (ctx->cbm_relocate_packed_addr >= 0) {
|
|
ctx->cbm_packed_addr = ctx->cbm_relocate_packed_addr;
|
|
} else {
|
|
ctx->cbm_packed_addr = ctx->cbm_orig_addr;
|
|
}
|
|
}
|
|
|
|
|
|
if (ctx->cbm) {
|
|
printf("original: $%04x-$%04lx ($%04lx) 100%%\n", ctx->cbm_orig_addr, ctx->cbm_orig_addr + ctx->unpacked_size, ctx->unpacked_size);
|
|
printf("packed: $%04x-$%04lx ($%04lx) %3.2f%%\n", ctx->cbm_packed_addr, ctx->cbm_packed_addr + ctx->packed_index + 2, ctx->packed_index + 2, ((float)(ctx->packed_index) / (float)(ctx->unpacked_size) * 100.0));
|
|
if ((ctx->cbm_packed_addr >= 0xd000 && ctx->cbm_packed_addr < 0xe000) || (ctx->cbm_packed_addr < 0xd000 && ctx->cbm_packed_addr + ctx->packed_index + 2 > 0xd000)) {
|
|
fprintf(stderr, "Warning: Packed file lies in I/O-range from $d000-$dfff\n");
|
|
}
|
|
|
|
/* little endian */
|
|
file_write_byte(ctx->cbm_packed_addr & 255, fp);
|
|
file_write_byte((ctx->cbm_packed_addr >> 8) & 255, fp);
|
|
|
|
/* big endian, as read backwards by depacker */
|
|
file_write_byte((ctx->cbm_orig_addr >> 8) & 255, fp);
|
|
file_write_byte(ctx->cbm_orig_addr & 255, fp);
|
|
} else {
|
|
printf("original: $%04x-$%04lx ($%04lx) 100%%\n", 0, ctx->unpacked_size, ctx->unpacked_size);
|
|
printf("packed: $%04x-$%04lx ($%04lx) %3.2f%%\n", 0, ctx->packed_index, ctx->packed_index, ((float)(ctx->packed_index) / (float)(ctx->unpacked_size) * 100.0));
|
|
}
|
|
}
|
|
|
|
if (fwrite(ctx->reencoded_data, sizeof(char), ctx->packed_index, fp) != ctx->packed_index) {
|
|
fprintf(stderr, "Error: Cannot write output file\n");
|
|
exit(1);
|
|
}
|
|
fclose(fp);
|
|
}
|
|
|
|
void do_reencode(ctx* ctx) {
|
|
char tmp_name[] = "dict-XXXXXX";
|
|
char src_name[] = "src-XXXXXX";
|
|
unsigned char *dict_data = NULL;
|
|
int dict_size = 0;
|
|
char *salvador_argv[5];
|
|
int salvador_argc = 0;
|
|
int dict_temp = FALSE;
|
|
FILE *dfp = NULL;
|
|
FILE *sfp = NULL;
|
|
FILE* ufp = NULL;
|
|
FILE* pfp = NULL;
|
|
|
|
|
|
/* determine output filename */
|
|
if (ctx->output_name == NULL) {
|
|
ctx->output_name = (char *)malloc(strlen(ctx->input_name) + 4);
|
|
strcpy(ctx->output_name, ctx->input_name);
|
|
strcat(ctx->output_name, ".lz");
|
|
printf("output name: %s\n", ctx->output_name);
|
|
}
|
|
|
|
/* allocate buffers */
|
|
ctx->packed_data = (unsigned char *)malloc(BUFFER_SIZE);
|
|
ctx->unpacked_data = (unsigned char *)malloc(BUFFER_SIZE + 2);
|
|
ctx->reencoded_data = (unsigned char *)malloc(BUFFER_SIZE);
|
|
|
|
if (!ctx->packed_data || !ctx->unpacked_data || !ctx->reencoded_data) {
|
|
fprintf(stderr, "Error: Insufficient memory\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* load unpacked file */
|
|
ufp = fopen(ctx->input_name, "rb");
|
|
if (!ufp) {
|
|
fprintf(stderr, "Error: Cannot access input file\n");
|
|
exit(1);
|
|
}
|
|
ctx->unpacked_size = fread(ctx->unpacked_data, sizeof(char), BUFFER_SIZE + 2, ufp);
|
|
fclose(ufp);
|
|
|
|
/* cbm address handling */
|
|
if (ctx->cbm_relocate_origin_addr >= 0) {
|
|
ctx->cbm_orig_addr = ctx->cbm_relocate_origin_addr;
|
|
} else {
|
|
ctx->cbm_orig_addr = ctx->unpacked_data[0] + (ctx->unpacked_data[1] << 8);
|
|
}
|
|
|
|
if (ctx->cbm) {
|
|
ctx->unpacked_data += 2;
|
|
ctx->unpacked_size -= 2;
|
|
}
|
|
|
|
/* take care of range (--from --to) */
|
|
if (ctx->cbm_range_from < 0) ctx->cbm_range_from = ctx->cbm_orig_addr;
|
|
if (ctx->cbm_range_to < 0) ctx->cbm_range_to = ctx->cbm_orig_addr + ctx->unpacked_size;
|
|
|
|
if ((ctx->cbm_range_to - ctx->cbm_orig_addr) > ctx->unpacked_size) {
|
|
ctx->cbm_range_to = ctx->unpacked_size + ctx->cbm_orig_addr;
|
|
fprintf(stderr, "Warning: File ends at $%04x, adopting --to value\n", ctx->cbm_range_to);
|
|
}
|
|
ctx->unpacked_size = (ctx->cbm_range_to - ctx->cbm_orig_addr);
|
|
|
|
/* if range is below start_address, adopt range */
|
|
if (ctx->cbm_range_from < ctx->cbm_orig_addr) {
|
|
ctx->cbm_range_from = ctx->cbm_orig_addr;
|
|
fprintf(stderr, "Warning: File starts at $%04x, adopting --from value\n", ctx->cbm_range_from);
|
|
}
|
|
if (ctx->cbm_range_from > ctx->cbm_range_to) {
|
|
fprintf(stderr, "Error: --from beyond fileend ($%04x - $%04x)\n", ctx->cbm_range_from, ctx->cbm_range_to);
|
|
exit(1);
|
|
}
|
|
|
|
/* setup dict lengths and position */
|
|
if (ctx->cbm_prefix_from >= 0) {
|
|
if (ctx->cbm_range_from < 0) {
|
|
fprintf(stderr, "Error: Dict is zero size (use --from)\n");
|
|
exit(1);
|
|
}
|
|
else if (ctx->cbm_prefix_from >= ctx->cbm_range_from) {
|
|
fprintf(stderr, "Error: --from must be greater than --prefix-from\n");
|
|
exit(1);
|
|
}
|
|
if (ctx->cbm_range_from >= 0 && ctx->cbm_range_from - ctx->cbm_prefix_from > 32640) {
|
|
//ctx->cbm_prefix_from = ctx->cbm_range_from - 32640;
|
|
fprintf(stderr, "Info: --prefix-from exceeds max offset, not all bytes can be used\n");
|
|
}
|
|
/* if range is below start_address, adopt range */
|
|
if (ctx->cbm_prefix_from < ctx->cbm_orig_addr) {
|
|
ctx->cbm_prefix_from = ctx->cbm_orig_addr;
|
|
fprintf(stderr, "Warning: File starts at $%04x, adopting --prefix-from value\n", ctx->cbm_prefix_from);
|
|
}
|
|
dict_data = ctx->unpacked_data + ctx->cbm_prefix_from - ctx->cbm_orig_addr;
|
|
dict_size = ctx->cbm_range_from - ctx->cbm_prefix_from;
|
|
}
|
|
|
|
/* load file from start_pos on only, so skip bytes on input */
|
|
ctx->unpacked_data += (ctx->cbm_range_from - ctx->cbm_orig_addr);
|
|
/* also adopt ctx->unpacked_size */
|
|
ctx->unpacked_size -= (ctx->cbm_range_from - ctx->cbm_orig_addr);
|
|
/* and set up new load-address */
|
|
ctx->cbm_orig_addr = ctx->cbm_range_from;
|
|
|
|
if (ctx->unpacked_size <= 0) {
|
|
fprintf(stderr, "Error: Input too small\n");
|
|
exit(1);
|
|
}
|
|
|
|
printf("Compressing from $%04x to $%04x = $%04lx bytes\n", ctx->cbm_range_from, ctx->cbm_range_to, ctx->unpacked_size);
|
|
|
|
if (ctx->cbm_relocate_packed_addr >= 0 || ctx->sfx) {
|
|
ctx->inplace = FALSE;
|
|
}
|
|
|
|
/* write clamped raw data */
|
|
ctx->clamped_name = (char*)malloc(sizeof(src_name));
|
|
strcpy(ctx->clamped_name, src_name);
|
|
sfp = fdopen(mkstemp(ctx->clamped_name),"wb");
|
|
if (!sfp) {
|
|
fprintf(stderr, "Error: Cannot create clamped file %s\n", ctx->clamped_name);
|
|
exit(1);
|
|
}
|
|
if (ctx->unpacked_size != 0) {
|
|
if (fwrite(ctx->unpacked_data, sizeof(char), ctx->unpacked_size, sfp) != ctx->unpacked_size) {
|
|
fprintf(stderr, "Error: Cannot write clamped file\n");
|
|
perror("fwrite");
|
|
exit(1);
|
|
}
|
|
}
|
|
fclose(sfp);
|
|
|
|
/* ctreate temp file for dict */
|
|
if (ctx->cbm_prefix_from >= 0) {
|
|
if (ctx->prefix_name == NULL) {
|
|
ctx->prefix_name = (char*)malloc(sizeof(tmp_name));
|
|
strcpy(ctx->prefix_name, tmp_name);
|
|
dfp = fdopen(mkstemp(ctx->prefix_name),"wb");
|
|
printf("using prefix: $%04x - $%04x\n", ctx->cbm_prefix_from, ctx->cbm_prefix_from + dict_size);
|
|
if (!dfp) {
|
|
fprintf(stderr, "Error: Cannot create dict file %s\n", ctx->prefix_name);
|
|
exit(1);
|
|
}
|
|
if (!dict_data || fwrite(dict_data, sizeof(char), dict_size, dfp) != dict_size) {
|
|
fprintf(stderr, "Error: Cannot write dict file %s\n", ctx->prefix_name);
|
|
remove(ctx->prefix_name);
|
|
exit(1);
|
|
}
|
|
dict_temp = TRUE;
|
|
fclose(dfp);
|
|
}
|
|
}
|
|
|
|
/* compress data with salvador */
|
|
salvador_argv[salvador_argc++] = "salvador";
|
|
if (ctx->prefix_name) {
|
|
salvador_argv[salvador_argc++] = "-D";
|
|
salvador_argv[salvador_argc++] = ctx->prefix_name;
|
|
}
|
|
salvador_argv[salvador_argc++] = ctx->clamped_name;
|
|
salvador_argv[salvador_argc++] = ctx->output_name;
|
|
salvador_main(salvador_argc, salvador_argv);
|
|
|
|
/* delete dict */
|
|
if (dict_temp) remove(ctx->prefix_name);
|
|
/* remove clamped */
|
|
remove(ctx->clamped_name);
|
|
|
|
/* read packed data */
|
|
pfp = fopen(ctx->output_name, "rb");
|
|
if (!pfp) {
|
|
fprintf(stderr, "Error: Cannot access input file\n");
|
|
exit(1);
|
|
}
|
|
ctx->packed_size = fread(ctx->packed_data, sizeof(char), BUFFER_SIZE, pfp);
|
|
fclose(pfp);
|
|
|
|
/* determine size without eof-marker -> remove 18 bits, either 2 byte or three byte depending on position of last bitpair */
|
|
if (ctx->packed_data[ctx->packed_size - 1] & 0x80) ctx->packed_size -= 3;
|
|
else ctx->packed_size -= 2;
|
|
|
|
reencode_packed_stream(ctx);
|
|
|
|
if (ctx->packed_index + 2 > ctx->unpacked_size) {
|
|
fprintf(stderr, "Error: Packed file larger than original\n");
|
|
exit(1);
|
|
}
|
|
|
|
//printf("control-bytes: $%04x\n", ctx->lz_bits);
|
|
|
|
write_reencoded_stream(ctx);
|
|
return;
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
int i;
|
|
|
|
ctx ctx = { 0 };
|
|
|
|
ctx.output_name = NULL;
|
|
ctx.input_name = NULL;
|
|
ctx.prefix_name = NULL;
|
|
|
|
ctx.inplace = TRUE;
|
|
|
|
ctx.cbm = TRUE;
|
|
ctx.cbm_orig_addr = 0;
|
|
ctx.cbm_packed_addr = 0;
|
|
ctx.cbm_range_from = -1;
|
|
ctx.cbm_range_to = -1;
|
|
ctx.cbm_relocate_packed_addr = -1;
|
|
ctx.cbm_relocate_origin_addr = -1;
|
|
ctx.cbm_prefix_from = -1;
|
|
|
|
ctx.sfx = FALSE;
|
|
ctx.sfx_addr = -1;
|
|
ctx.sfx_01 = -1;
|
|
ctx.sfx_cli = FALSE;
|
|
ctx.sfx_small = FALSE;
|
|
ctx.sfx_code = NULL;
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
if (!strncmp(argv[i], "-", 1) || !strncmp(argv[i], "--", 2)) {
|
|
if (!strcmp(argv[i], "--binfile")) {
|
|
ctx.cbm = FALSE;
|
|
} else if (!strcmp(argv[i], "--prefix-from")) {
|
|
ctx.cbm_prefix_from = read_number(argv[i + 1], argv[i], 65536);
|
|
i++;
|
|
} else if (!strcmp(argv[i], "--prefix-file")) {
|
|
i++;
|
|
ctx.prefix_name = argv[i];
|
|
} else if (!strcmp(argv[i], "--no-inplace")) {
|
|
ctx.inplace = FALSE;
|
|
} else if (!strcmp(argv[i], "--small")) {
|
|
ctx.sfx_small = TRUE;
|
|
} else if (!strcmp(argv[i], "--relocate-packed")) {
|
|
ctx.cbm_relocate_packed_addr = read_number(argv[i + 1], argv[i], 65536);
|
|
i++;
|
|
} else if (!strcmp(argv[i], "--relocate-origin")) {
|
|
ctx.cbm_relocate_origin_addr = read_number(argv[i + 1], argv[i], 65536);
|
|
i++;
|
|
} else if (!strcmp(argv[i], "--from")) {
|
|
ctx.cbm_range_from = read_number(argv[i + 1], argv[i], 65536);
|
|
i++;
|
|
} else if (!strcmp(argv[i], "--to")) {
|
|
ctx.cbm_range_to = read_number(argv[i + 1], argv[i], 65536);
|
|
i++;
|
|
} else if (!strcmp(argv[i], "--01")) {
|
|
ctx.sfx_01 = read_number(argv[i + 1], argv[i], 256);
|
|
i++;
|
|
} else if (!strcmp(argv[i], "--cli")) {
|
|
ctx.sfx_cli = TRUE;
|
|
} else if (!strcmp(argv[i], "--sfx")) {
|
|
ctx.sfx_addr = read_number(argv[i + 1], argv[i], 65536);
|
|
i++;
|
|
ctx.sfx = TRUE;
|
|
ctx.inplace = FALSE;
|
|
} else if (!strcmp(argv[i], "-o")) {
|
|
i++;
|
|
ctx.output_name = argv[i];
|
|
} else {
|
|
fprintf(stderr, "Error: Unknown option %s\n", argv[i]);
|
|
exit(1);
|
|
}
|
|
} else if (i == argc - 1) {
|
|
ctx.input_name = argv[i];
|
|
} else {
|
|
fprintf(stderr, "Error: Unknown option %s\n", argv[i]);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
printf("dali v0.3 - a zx0-reencoder for bitfire by Tobias Bindhammer\n");
|
|
printf("underlying zx0-packer salvador by Emmanuel Marty\n");
|
|
|
|
if (argc == 1) {
|
|
fprintf(stderr, "Usage: %s [options] input\n"
|
|
" -o [filename] Set output filename.\n"
|
|
" --sfx [num] Create a c64 compatible sfx-executable.\n"
|
|
" --01 [num] Set 01 to [num] after sfx.\n"
|
|
" --cli [num] Do a CLI after sfx, default is SEI.\n"
|
|
" --small Use a very small depacker that fits into zeropage, but --01 and --cli are ignored and it trashes zeropage (!)\n"
|
|
" --no-inplace Disable inplace-decompression.\n"
|
|
" --binfile Input file is a raw binary without load-address.\n"
|
|
" --from [num] Compress file from [num] on.\n"
|
|
" --to [num] Compress file until position [num].\n"
|
|
" --prefix-from [num] Use preceeding data from [num] on as dictionary (in combination with --from).\n"
|
|
" --prefix-file [file] Use preceeding data from [file] as dictionary.\n"
|
|
" --relocate-packed [num] Relocate packed data to desired address [num] (resulting file can't de decompressed inplace!)\n"
|
|
" --relocate-origin [num] Set load-address of source file to [num] prior to compression. If used on bin-files, load-address and depack-target is prepended on output.\n"
|
|
,argv[0]);
|
|
exit(1);
|
|
}
|
|
|
|
if (!ctx.sfx && ctx.sfx_small) {
|
|
fprintf(stderr, "Info: No sfx, ignoring --small option\n");
|
|
}
|
|
if (!ctx.sfx && ctx.sfx_01 >= 0) {
|
|
fprintf(stderr, "Info: No sfx, ignoring --01 option\n");
|
|
}
|
|
if (!ctx.sfx && ctx.sfx_cli) {
|
|
fprintf(stderr, "Info: No sfx, ignoring --cli option\n");
|
|
}
|
|
|
|
if (ctx.input_name == NULL) {
|
|
fprintf(stderr, "Error: No input-filename given\n");
|
|
exit(1);
|
|
}
|
|
|
|
do_reencode(&ctx);
|
|
return 0;
|
|
}
|