mkfontimg.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "mkfontimg_internal.h"
#include "ra8_attributes.h"
#include "ra8_fs.h"

typedef enum : uint32_t {
  k_block_size         = 512U,               
  k_blocks_fat16       = 8U * 1024U,         
  k_byte_lo_mask       = 0xFFU,              
  k_byte_shift         = 8U,                 
  k_font_min_bytes     = 16U,                
  k_font_cap           = 4U * 1024U * 1024U, 
  k_bpb_off_bytspersec = 11U,                
  k_bpb_off_secperclus = 13U,                
  k_bpb_off_rsvdseccnt = 14U,                
  k_bpb_off_numfats    = 16U,                
  k_bpb_off_rootentcnt = 17U,                
  k_bpb_off_totsec16   = 19U,                
  k_bpb_off_secfat     = 22U,                
  k_bpb_secperclus     = 1U,                 
  k_bpb_rsvdseccnt     = 1U,                 
  k_bpb_numfats        = 2U,                 
  k_bpb_rootentcnt     = 16U,                
  k_bpb_fatsz16        = 32U,                
  k_bpb_sig_off_a      = 510U,               
  k_bpb_sig_off_b      = 511U,               
  k_bpb_sig_a          = 0x55U,              
  k_bpb_sig_b          = 0xAAU,              
} mkfontimg_constant_t;

RA8_INTERNAL static void internal_put16(uint8_t* sector, uint32_t offset, uint16_t value)
{
  sector[offset]      = (uint8_t)(value & (uint16_t)k_byte_lo_mask);
  sector[offset + 1U] = (uint8_t)((value >> (uint16_t)k_byte_shift) & (uint16_t)k_byte_lo_mask);
}

RA8_INTERNAL static void internal_build_fat16(uint8_t sector[k_block_size])
{
  internal_put16(sector, (uint32_t)k_bpb_off_bytspersec, (uint16_t)k_block_size);
  sector[k_bpb_off_secperclus] = (uint8_t)k_bpb_secperclus;
  internal_put16(sector, (uint32_t)k_bpb_off_rsvdseccnt, (uint16_t)k_bpb_rsvdseccnt);
  sector[k_bpb_off_numfats] = (uint8_t)k_bpb_numfats;
  internal_put16(sector, (uint32_t)k_bpb_off_rootentcnt, (uint16_t)k_bpb_rootentcnt);
  internal_put16(sector, (uint32_t)k_bpb_off_totsec16, (uint16_t)k_blocks_fat16);
  internal_put16(sector, (uint32_t)k_bpb_off_secfat, (uint16_t)k_bpb_fatsz16);
  sector[k_bpb_sig_off_a] = (uint8_t)k_bpb_sig_a;
  sector[k_bpb_sig_off_b] = (uint8_t)k_bpb_sig_b;
}

RA8_INTERNAL static bool
internal_mount_image(const char* image_out, mkfontimg_host_t* host, ra8_fs_mount_t** mount)
{
  if (!priv_mkfontimg_host_begin(image_out, k_blocks_fat16, k_block_size, host)) {
    return false;
  }
  uint8_t sector[k_block_size] = {};
  internal_build_fat16(sector);
  if (!priv_mkfontimg_host_seed(host, sector, sizeof(sector)) ||
      ra8_fs_mount(&host->backend, mount) != k_ra8_ok) {
    priv_mkfontimg_host_abort(host);
    return false;
  }
  return true;
}

RA8_INTERNAL static bool internal_finish_image(mkfontimg_host_t* host, ra8_fs_mount_t* mount)
{
  if (ra8_fs_unmount(mount) != k_ra8_ok || host->disk.io_failed) {
    priv_mkfontimg_host_abort(host);
    return false;
  }
  return priv_mkfontimg_host_commit(host);
}

RA8_INTERNAL static int internal_run_blank(const char* image_out)
{
  mkfontimg_host_t host;
  ra8_fs_mount_t*  mount = nullptr;
  if (!internal_mount_image(image_out, &host, &mount) || !internal_finish_image(&host, mount)) {
    priv_mkfontimg_diag("mkfontimg: blank image generation failed; destination preserved\n");
    return 1;
  }
  priv_mkfontimg_diag("mkfontimg: wrote ");
  priv_mkfontimg_diag(image_out);
  priv_mkfontimg_diag(" (blank FAT16, no font)\n");
  return 0;
}

RA8_INTERNAL static int
internal_run_font(const char* font_in, const char* image_out, const char* card_name)
{
  mkfontimg_host_t host;
  ra8_fs_mount_t*  mount = nullptr;
  if (!internal_mount_image(image_out, &host, &mount)) {
    priv_mkfontimg_diag("mkfontimg: cannot create or mount safe output\n");
    return 1;
  }
  uint64_t font_bytes = 0U;
  bool     copied     = priv_mkfontimg_host_copy(&host,
                                                 mount,
                                                 font_in,
                                                 card_name,
                                                 k_font_min_bytes,
                                                 k_font_cap,
                                                 &font_bytes);
  if (!copied) {
    (void)ra8_fs_unmount(mount);
    priv_mkfontimg_host_abort(&host);
    priv_mkfontimg_diag("mkfontimg: font changed, is invalid, or could not be copied exactly: ");
    priv_mkfontimg_diag(font_in);
    priv_mkfontimg_diag("\n");
    return 1;
  }
  if (!internal_finish_image(&host, mount)) {
    priv_mkfontimg_diag("mkfontimg: publication failed; destination preserved\n");
    return 1;
  }
  priv_mkfontimg_diag("mkfontimg: wrote ");
  priv_mkfontimg_diag(image_out);
  priv_mkfontimg_diag(" (");
  priv_mkfontimg_diag(card_name);
  priv_mkfontimg_diag(" = ");
  priv_mkfontimg_diag_u64(font_bytes);
  priv_mkfontimg_diag(" bytes)\n");
  return 0;
}

int main(int argc, char** argv)
{
  if ((argc >= 2) && (strcmp(argv[1], "--blank") == 0)) {
    if (argc != 3) {
      priv_mkfontimg_diag("usage: mkfontimg --blank <image-out>\n");
      return 2;
    }
    return internal_run_blank(argv[2]);
  }
  if (argc < 3 || argc > 4) {
    priv_mkfontimg_diag("usage: mkfontimg <font-in> <image-out> [dest-name]\n");
    return 2;
  }
  const char* card_name = (argc == 4) ? argv[3] : "FONT.OTF";
  return internal_run_font(argv[1], argv[2], card_name);
}