forked from Lephenixnoir/fxsdk
356 lines
9.5 KiB
C
356 lines
9.5 KiB
C
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <getopt.h>
|
|
|
|
#include <fxgxa.h>
|
|
#include <g1a.h>
|
|
#include <g3a.h>
|
|
|
|
static const char *help_string =
|
|
"usage: fxgxa [-g] <binary file> [options...]\n"
|
|
" fxgxa -e <g1a/g3a file> [options...]\n"
|
|
" fxgxa -d <g1a/g3a file>\n"
|
|
" fxgxa -r <g1a/g3a file> [-o <g1a/g3a file>]\n"
|
|
" fxgxa -x <g1a/g3a file> [-o <png file>]\n"
|
|
"\n"
|
|
"fxgxa creates or edits g1a and g3a files (add-in applications for CASIO\n"
|
|
"fx-9860G and fx-CG series) that consist of a header followed by code.\n"
|
|
"\n"
|
|
"Operating modes:\n"
|
|
" -g, --g1a, --g3a Generate a g1a/g3a file (default)\n"
|
|
" -e, --edit Edit header of an existing g1a/g3a file\n"
|
|
" -d, --dump Dump header of an existing g1a/g3a file\n"
|
|
" -r, --repair Recalculate control bytes and checksums\n"
|
|
" -x, --extract Extract icon into a PNG file\n"
|
|
"\n"
|
|
"General options:\n"
|
|
" -o, --output=<file> Output file (default: input with .g1a/.g3a suffix\n"
|
|
" [-g]; with .png suffix [-x]; input file [-e, -r])\n"
|
|
" --output-uns=<file> Output for unselected icon with [-x] and g3a file\n"
|
|
" --output-sel=<file> Output for selected icon with [-x] and g3a file\n"
|
|
"\n"
|
|
"Generation and edition options:\n"
|
|
" -i, --icon=<png> Program icon, in PNG format (default: blank) [g1a]\n"
|
|
" --icon-uns=<png> Unselected program icon, in PNG format [g3a]\n"
|
|
" --icon-sel=<png> Selected program icon, in PNG format [g3a]\n"
|
|
" -n, --name=<name> Add-in name (default: output file name)\n"
|
|
" --version=<text> Program version, MM.mm.pppp format (default: empty)\n"
|
|
" --internal=<name> Internal name, eg. '@NAME' (default: empty)\n"
|
|
" --date=<date> Date of build, yyyy.MMdd.hhmm (default: now)\n";
|
|
|
|
/*
|
|
** Field customization
|
|
*/
|
|
|
|
/* A set of user-defined fields, often taken on the command-line
|
|
Default values are NULL and indicate "no value" (-g) or "no change" (-e). */
|
|
struct fields
|
|
{
|
|
/* New values for basic fields */
|
|
const char *name;
|
|
const char *version;
|
|
const char *internal;
|
|
const char *date;
|
|
/* Icon file name */
|
|
const char *icon;
|
|
const char *icon_uns, *icon_sel;
|
|
|
|
// TODO: G3A: Fill the filename field
|
|
};
|
|
|
|
/* fields_edit(): Set the value of some fields altogether
|
|
@gxa Header to edit, is assumed checksumed and filled
|
|
@fields New values for fields, any members can be NULL */
|
|
void fields_edit(void *gxa, struct fields const *fields)
|
|
{
|
|
/* For easy fields, just call the appropriate edition function */
|
|
if(fields->name) edit_name(gxa, fields->name);
|
|
if(fields->version) edit_version(gxa, fields->version);
|
|
if(fields->internal) edit_internal(gxa, fields->internal);
|
|
if(fields->date) edit_date(gxa, fields->date);
|
|
|
|
/* Load icon from PNG file */
|
|
if(fields->icon && is_g1a(gxa)) {
|
|
int w, h;
|
|
uint8_t *rgb24 = icon_load(fields->icon, &w, &h);
|
|
|
|
if(rgb24) {
|
|
/* Skip the first row if h > 17, since the usual
|
|
representation at 30x19 skips the first and last */
|
|
uint8_t *mono = icon_conv_24to1(
|
|
h > 17 ? rgb24 + 3*w : rgb24, w, h - (h > 17));
|
|
if(mono) edit_g1a_icon(gxa, mono);
|
|
free(mono);
|
|
}
|
|
free(rgb24);
|
|
}
|
|
if(fields->icon_uns && is_g3a(gxa)) {
|
|
int w, h;
|
|
uint8_t *rgb24 = icon_load(fields->icon_uns, &w, &h);
|
|
|
|
if(rgb24) {
|
|
uint16_t *rgb16be = icon_conv_24to16(rgb24, w, h);
|
|
if(rgb16be) edit_g3a_icon(gxa, rgb16be, false);
|
|
free(rgb16be);
|
|
}
|
|
free(rgb24);
|
|
}
|
|
if(fields->icon_sel && is_g3a(gxa)) {
|
|
int w, h;
|
|
uint8_t *rgb24 = icon_load(fields->icon_sel, &w, &h);
|
|
|
|
if(rgb24) {
|
|
uint16_t *rgb16be = icon_conv_24to16(rgb24, w, h);
|
|
if(rgb16be) edit_g3a_icon(gxa, rgb16be, true);
|
|
free(rgb16be);
|
|
}
|
|
free(rgb24);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Tool implementation
|
|
*/
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
/* Result of option parsing */
|
|
int mode = 'g', error = 0;
|
|
struct fields fields = { 0 };
|
|
const char *output = NULL;
|
|
const char *output_uns=NULL, *output_sel=NULL;
|
|
|
|
const struct option longs[] = {
|
|
{ "help", no_argument, NULL, 'h' },
|
|
{ "g1a", no_argument, NULL, '1' },
|
|
{ "g3a", no_argument, NULL, '3' },
|
|
{ "edit", no_argument, NULL, 'e' },
|
|
{ "dump", no_argument, NULL, 'd' },
|
|
{ "repair", no_argument, NULL, 'r' },
|
|
{ "extract", no_argument, NULL, 'x' },
|
|
{ "output", required_argument, NULL, 'o' },
|
|
{ "output-uns", required_argument, NULL, 'O' },
|
|
{ "output-sel", required_argument, NULL, 'P' },
|
|
{ "icon", required_argument, NULL, 'i' },
|
|
{ "icon-uns", required_argument, NULL, 'I' },
|
|
{ "icon-sel", required_argument, NULL, 'J' },
|
|
{ "name", required_argument, NULL, 'n' },
|
|
{ "version", required_argument, NULL, 'v' },
|
|
{ "internal", required_argument, NULL, 't' },
|
|
{ "date", required_argument, NULL, 'a' },
|
|
{ NULL, 0, NULL, 0 },
|
|
};
|
|
|
|
int option = 0;
|
|
while(option >= 0 && option != '?')
|
|
switch((option = getopt_long(argc, argv, "hgedrxo:i:n:", longs, NULL)))
|
|
{
|
|
case 'h':
|
|
fprintf(stderr, help_string, argv[0]);
|
|
return 0;
|
|
case 'g':
|
|
case 'e':
|
|
case 'd':
|
|
case 'r':
|
|
case 'x':
|
|
case '1':
|
|
case '3':
|
|
mode = option;
|
|
break;
|
|
case 'o':
|
|
output = optarg;
|
|
break;
|
|
case 'O':
|
|
output_uns = optarg;
|
|
break;
|
|
case 'P':
|
|
output_sel = optarg;
|
|
break;
|
|
case 'i':
|
|
fields.icon = optarg;
|
|
break;
|
|
case 'I':
|
|
fields.icon_uns = optarg;
|
|
break;
|
|
case 'J':
|
|
fields.icon_sel = optarg;
|
|
break;
|
|
case 'n':
|
|
fields.name = optarg;
|
|
break;
|
|
case 'v':
|
|
fields.version = optarg;
|
|
break;
|
|
case 't':
|
|
fields.internal = optarg;
|
|
break;
|
|
case 'a':
|
|
fields.date = optarg;
|
|
break;
|
|
case '?':
|
|
error = 1;
|
|
break;
|
|
}
|
|
|
|
if(mode == 'g' && !strcmp(argv[0], "fxg1a"))
|
|
mode = '1';
|
|
if(mode == 'g' && !strcmp(argv[0], "fxg3a"))
|
|
mode = '3';
|
|
if(error) return 1;
|
|
|
|
if(argv[optind] == NULL)
|
|
{
|
|
fprintf(stderr, help_string, argv[0]);
|
|
return 1;
|
|
}
|
|
if(mode == 'g') {
|
|
fprintf(stderr, "cannot guess -g; use --g1a or --g3a\n");
|
|
return 1;
|
|
}
|
|
if(mode == '1' || mode == '3')
|
|
{
|
|
/* Load binary file into memory */
|
|
size_t size;
|
|
int header = (mode == '1' ? 0x200 : 0x7000);
|
|
int footer = (mode == '1' ? 0 : 4);
|
|
void *gxa = load_binary(argv[optind], &size, header, footer);
|
|
if(!gxa) return 1;
|
|
|
|
/* If [output] is set, use it, otherwise compute a default */
|
|
char *alloc = NULL;
|
|
if(!output)
|
|
{
|
|
alloc = malloc(strlen(argv[optind]) + 5);
|
|
if(!alloc) {fprintf(stderr, "error: %m\n"); return 1;}
|
|
default_output(argv[optind],
|
|
(mode == '1' ? ".g1a" : ".g3a"), alloc);
|
|
}
|
|
|
|
/* First set the type so that is_g1a() and is_g3a() work */
|
|
((uint8_t *)gxa)[8] = (mode == '1' ? 0xf3 : 0x2c);
|
|
|
|
/* Start with output file name as application name */
|
|
edit_name(gxa, output ? output : alloc);
|
|
|
|
/* Start with "now" as build date */
|
|
char date[15];
|
|
time_t t = time(NULL);
|
|
struct tm *now = localtime(&t);
|
|
strftime(date, 15, "%Y.%m%d.%H%M", now);
|
|
edit_date(gxa, date);
|
|
|
|
/* Start with an uppercase name as internal name */
|
|
char internal[12];
|
|
if(fields.name)
|
|
default_internal(fields.name, internal, 11);
|
|
else if(is_g1a(gxa))
|
|
default_internal(G1A(gxa)->header.name, internal, 11);
|
|
else if(is_g3a(gxa))
|
|
default_internal(G3A(gxa)->header.name, internal, 11);
|
|
edit_internal(gxa, internal);
|
|
|
|
/* Edit the fields with user-customized values */
|
|
fields_edit(gxa, &fields);
|
|
|
|
/* Set fixed fields and calculate checksums */
|
|
sign(gxa, size);
|
|
|
|
save_gxa(output ? output : alloc, gxa, size);
|
|
free(alloc);
|
|
free(gxa);
|
|
}
|
|
if(mode == 'e')
|
|
{
|
|
/* Load file into memory */
|
|
size_t size;
|
|
void *gxa = load_gxa(argv[optind], &size);
|
|
if(!gxa) return 1;
|
|
|
|
/* Edit the fields with user-customized values */
|
|
fields_edit(gxa, &fields);
|
|
|
|
/* We don't reset fixed fields or recalculate checksums because
|
|
we only want to edit what was requested by the user.
|
|
Besides, the control bytes and checksums do *not* depend on
|
|
the value of user-customizable fields. */
|
|
|
|
/* Regenerate input file, or output somewhere else */
|
|
if(!output) output = argv[optind];
|
|
save_gxa(output, gxa, size);
|
|
free(gxa);
|
|
}
|
|
if(mode == 'd')
|
|
{
|
|
size_t size;
|
|
void *gxa = load_gxa(argv[optind], &size);
|
|
if(!gxa) return 1;
|
|
|
|
dump(gxa, size);
|
|
free(gxa);
|
|
}
|
|
if(mode == 'r')
|
|
{
|
|
size_t size;
|
|
void *gxa = load_gxa(argv[optind], &size);
|
|
if(!gxa) return 1;
|
|
|
|
/* Repair file by recalculating fixed fields and checksums */
|
|
sign(gxa, size);
|
|
|
|
/* Regenerate input file, or output somewhere else */
|
|
if(!output) output = argv[optind];
|
|
save_gxa(output, gxa, size);
|
|
free(gxa);
|
|
}
|
|
if(mode == 'x')
|
|
{
|
|
size_t size;
|
|
void *gxa = load_gxa(argv[optind], &size);
|
|
if(!gxa) return 1;
|
|
|
|
if(is_g1a(gxa)) {
|
|
/* Add clean top/bottom rows */
|
|
uint8_t mono[76];
|
|
memcpy(mono, "\x00\x00\x00\x00", 4);
|
|
memcpy(mono+4, G1A(gxa)->header.icon, 68);
|
|
memcpy(mono+72, "\x7f\xff\xff\xfc", 4);
|
|
uint8_t *rgb24 = icon_conv_1to24(mono, 30, 19);
|
|
|
|
/* Calculate a default output name if none is given */
|
|
char *alloc = NULL;
|
|
if(!output) {
|
|
alloc = malloc(strlen(argv[optind]) + 5);
|
|
if(!alloc) {
|
|
fprintf(stderr, "error: %m\n");
|
|
return 1;
|
|
}
|
|
default_output(argv[optind], ".png", alloc);
|
|
}
|
|
|
|
icon_save(output ? output : alloc, rgb24, 30, 19);
|
|
free(alloc);
|
|
free(rgb24);
|
|
}
|
|
else if(is_g3a(gxa)) {
|
|
uint8_t *rgb24_uns = icon_conv_16to24(
|
|
G3A(gxa)->header.icon_uns, 92, 64);
|
|
uint8_t *rgb24_sel = icon_conv_16to24(
|
|
G3A(gxa)->header.icon_sel, 92, 64);
|
|
|
|
if(output_uns)
|
|
icon_save(output_uns, rgb24_uns, 92, 64);
|
|
if(output_sel)
|
|
icon_save(output_sel, rgb24_sel, 92, 64);
|
|
if(!output_uns && !output_sel) fprintf(stderr, "Please"
|
|
" specify --output-uns or --output-sel.\n");
|
|
|
|
free(rgb24_uns);
|
|
free(rgb24_sel);
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|