c64 .PRG loader

emulate 6502 to let the autoload picture load itself !
supports multicolor, hires and some C64 FLI .PRGs

src/Makefile

@@ -812,14 +812,14 @@ OBJS = main.o init.o graph.o $(APIOBJ) misc.o special.o \
        fileformats.o miscfileformats.o libraw2crtc.o \
        brush_ops.o buttons_effects.o layers.o \
        oldies.o tiles.o colorred.o unicode.o gfx2surface.o \
-       gfx2log.o gfx2mem.o tifformat.o
+       gfx2log.o gfx2mem.o tifformat.o c64load.o 6502.o
 ifndef NORECOIL
 OBJS += loadrecoil.o recoil.o
 endif
 
 TESTSOBJS = $(patsubst %.c,%.o,$(wildcard tests/*.c)) \
             miscfileformats.o fileformats.o oldies.o libraw2crtc.o \
-            loadsavefuncs.o packbits.o tifformat.o \
+            loadsavefuncs.o packbits.o tifformat.o c64load.o 6502.o \
             op_c.o colorred.o \
             unicode.o \
             io.o realpath.o version.o pversion.o \

src/c64load.c

@@ -0,0 +1,280 @@
+/* vim:expandtab:ts=2 sw=2:
+*/
+/*  Grafx2 - The Ultimate 256-color bitmap paint program
+
+    Copyright 2018-2019 Thomas Bernard
+    Copyright 2011 Pawel Góralski
+    Copyright 2009 Petter Lindquist
+    Copyright 2008 Yves Rizoud
+    Copyright 2008 Franck Charlet
+    Copyright 2007-2011 Adrien Destugues
+    Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud)
+
+    Grafx2 is free software; you can redistribute it and/or
+    modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; version 2
+    of the License.
+
+    Grafx2 is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Grafx2; if not, see <http://www.gnu.org/licenses/>
+*/
+
+///@file c64load.c
+/// Load C64 .PRG files
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "struct.h"
+#include "io.h"
+#include "c64load.h"
+#include "gfx2mem.h"
+#include "gfx2log.h"
+
+#define CPU_6502_STATIC
+#define CPU_6502_DEPENDENCIES_H "6502types.h"
+#define CPU_6502_USE_LOCAL_HEADER
+#include "6502.h"
+
+/**
+ * Check if it is a machine langage program with a BASIC
+ * startup line (eg. 10 SYS2061)
+ * @return 0 or the machine language code start address
+ */
+word C64_isBinaryProgram(FILE * f)
+{
+  word prg_load_addr;
+  word addr, next, linenum;
+  word len;
+  char * line;
+  unsigned long start = 0;
+  int i;
+
+  if (f == NULL)
+    return 0;
+  if (fseek(f, 0, SEEK_SET) < 0)
+    return 0;
+  if (!Read_word_le(f, &prg_load_addr))
+    return 0;
+  if (prg_load_addr != 0x0801)
+    return 0;
+  addr = prg_load_addr;
+  while (start == 0)
+  {
+    if (!Read_word_le(f, &next))
+      return 0;
+    if (next == 0)
+      break;
+    if (!Read_word_le(f, &linenum))
+      return 0;
+    GFX2_Log(GFX2_DEBUG, "$%04x %hu\n", next, linenum);
+    len = next - addr - 4;
+    line = malloc(len);
+    if (!Read_bytes(f, line, len))
+    {
+      free(line);
+      return 0;
+    }
+    GFX2_LogHexDump(GFX2_DEBUG, "", (byte *)line, 0, len);
+    if ((byte)line[0] == 0x9e) // SYS BASIC token
+    {
+      GFX2_Log(GFX2_DEBUG, "SYS%s\n", line + 1);
+      i = 1;
+      while (line[i] == ' ')
+        i++;
+      start = strtoul(line + i, NULL, 10);
+    }
+    free(line);
+  }
+  return start;
+}
+
+static byte C64_mem_read(void *context, word address)
+{
+  if ((((struct c64state *)context)->ram[1] & 2) && address >= 0xe000)
+  {
+    GFX2_Log(GFX2_WARNING, "** ROM ** read($%04x)\n", address);
+    if (address == 0xffe4)
+      ((struct c64state *)context)->keyjoyread++;
+    return 0x60;  // RTS
+  }
+    
+  if ((((struct c64state *)context)->ram[1] & 4) &&
+      (address >= 0xd000) && (address < 0xe000))
+  {
+    GFX2_Log(GFX2_DEBUG, "** IO ** read($%04x)  $%02x\n",
+             address, ((struct c64state *)context)->ram[address]);
+    if ((address & 0xfffe) == 0xdc00)
+      ((struct c64state *)context)->keyjoyread++;
+  }
+  return ((struct c64state *)context)->ram[address];
+}
+
+static void C64_mem_write(void *context, word address, byte value)
+{
+  struct c64state * c64 = (struct c64state *)context;
+  if ((address >= 0xd000 && address < 0xd800) ||
+      (address >= 0xdc00 && address < 0xe000))
+  {
+    GFX2_Log(GFX2_DEBUG, "** IO ** write($%04x, $%02x)\n", address, value);
+    switch (address)
+    {
+      case 0xd011:
+        c64->irqrasterline = (c64->irqrasterline & 0x00ff) | (value >> 7);
+        break;
+      case 0xd012:
+        c64->irqrasterline = (c64->irqrasterline & 0xff00) | value;
+        break;
+      case 0xd018:
+        if (c64->ram[0xd011] & 0x10) // Screen is on
+          c64->fliscreens[(c64->ram[0xd011] - 50) & 7] = value >> 4;
+        break;
+      case 0xd019:
+        // acknowledge rasterirq
+        m6502_irq(c64->cpu, FALSE);
+        break;
+      case 0xd021:  // background color
+        {
+          word line = ((word)(c64->ram[0xd011] & 0x80) << 1) | c64->ram[0xd012];
+          if (line >= 50 && line < 250)
+            c64->backgrounds[line - 50] = value & 0x0f;
+        }
+        break;
+    }
+  }
+  else if (address >= 0xfffa)
+    GFX2_Log(GFX2_DEBUG, "write($%04x, $%02x)\n", address, value);
+  else if (address == 0x314 || address == 0x315)
+    GFX2_Log(GFX2_DEBUG, "write($%04x, $%02x)\n", address, value);
+  c64->ram[address] = value;
+}
+
+int C64_LoadPrg(struct c64state * c64, const byte * prg, long prg_size, word start)
+{
+  M6502 cpu;
+  zusize cycles = 0;
+  zusize next_rasterline = 63;
+  int i, count = 0;
+  byte screen_min = 255;
+
+  GFX2_Log(GFX2_DEBUG, "C64_LoadPrg(%p, %ld, $%04x)\n", prg, prg_size, start);
+  if (c64->ram == NULL)
+  {
+    c64->ram = GFX2_malloc(65536);
+    if (c64->ram == NULL)
+      return 0;
+  }
+  memset(c64->ram, 0, 65536);
+  c64->ram[0x00] = 0x2F;
+  c64->ram[0x01] = 0x37;
+  c64->ram[0x2B] = 0x01;
+  c64->ram[0x2C] = 0x08;
+  c64->ram[0x2D] = (0x7ff + prg_size) & 0xff;
+  c64->ram[0x2E] = (0x7ff + prg_size) >> 8;
+  c64->ram[0x2F] = c64->ram[0x2D];
+  c64->ram[0x30] = c64->ram[0x2E];
+  c64->ram[0x31] = c64->ram[0x2D];
+  c64->ram[0x32] = c64->ram[0x2E];
+  c64->ram[0xd011] = 0x1B;
+  c64->ram[0xd016] = 0xC8;
+  c64->ram[0xd018] = 0x15;
+  c64->ram[0xd020] = 0xFE;
+  c64->ram[0xd021] = 0xF6;
+  c64->ram[0xd022] = 0xF1;
+  c64->ram[0xd023] = 0xF2;
+  c64->ram[0xd024] = 0xF3;
+  c64->ram[0xd025] = 0xF4;
+  c64->ram[0xd026] = 0xF0;
+  c64->ram[0xd027] = 0xF1;
+  c64->ram[0xd028] = 0xF2;
+  c64->ram[0xd029] = 0xF3;
+  c64->ram[0xd02a] = 0xF4;
+  c64->ram[0xd02b] = 0xF5;
+  c64->ram[0xd02c] = 0xF6;
+  c64->ram[0xd02d] = 0xF7;
+  c64->ram[0xd02e] = 0xFC;
+  c64->ram[0xdd00] = 0x97;
+  memcpy(c64->ram + 0x801, prg + 2, prg_size - 2);
+  c64->cpu = &cpu;
+
+  memset(&cpu, 0, sizeof(cpu));
+  cpu.context = (void*)c64;
+  cpu.read = C64_mem_read;
+  cpu.write = C64_mem_write;
+
+  m6502_power(&cpu, TRUE);
+  cpu.state.pc = start;
+  while (cycles < 10000000 && c64->keyjoyread < 10)
+  {
+    word lastpc = cpu.state.pc;
+    //cycles += m6502_run(&cpu, next_rasterline > cycles ? next_rasterline - cycles : 1);
+    cycles += m6502_run(&cpu, 1);
+    if (cycles >= next_rasterline)
+    {
+      word line = ((word)(c64->ram[0xd011] & 0x80) << 1) | c64->ram[0xd012];
+      if (++line >= 312)
+        line = 0;
+      c64->ram[0xd012] = line & 0xff;
+      c64->ram[0xd011] = (c64->ram[0xd011] & 0x7f) | ((line >> 1) & 0x80);
+      if (c64->ram[0xd01a] & 1)
+      {
+        if (line == c64->irqrasterline)
+        {
+          GFX2_Log(GFX2_DEBUG, "pc=$%04x Raster IRQ line %hu\n", cpu.state.pc, line);
+          c64->ram[0xd019] |= 0x81;
+          m6502_irq(&cpu, TRUE);
+        }
+      }
+      next_rasterline += 63;
+    }
+    if (lastpc == cpu.state.pc/* && !(c64->ram[0xd01a] & 1)*/)
+    {
+      GFX2_Log(GFX2_DEBUG, "infinite loop detected\n");
+      if ((c64->ram[0xd011] & 0x10) == 0 // Screen off
+          && (c64->ram[0x315] != 0))
+      {
+        // fake system interrupt
+        cpu.state.pc = ((word)c64->ram[0x315] << 8) + c64->ram[0x314];
+      }
+      else
+        break;
+    }
+  }
+  GFX2_Log(GFX2_DEBUG, "%u cycles pc=$%04x\n", cycles, cpu.state.pc);
+  c64->vicmode = (c64->ram[0xd011] & 0x60) | (c64->ram[0xd016] & 0x10);
+  GFX2_Log(GFX2_DEBUG, "$%02x %s%s%s\n",
+           c64->vicmode,
+           (c64->ram[0xd011] & 0x20) ? "BITMAP" : "TEXT",
+           (c64->ram[0xd011] & 0x40) ? " EXTBKG" : "",
+           (c64->ram[0xd016] & 0x10) ? " MULTICOLOR" : "");
+  GFX2_Log(GFX2_DEBUG, "fliscreens [%x %x %x %x %x %x %x %x]\n",
+           c64->fliscreens[0], c64->fliscreens[1], c64->fliscreens[2], c64->fliscreens[3],
+           c64->fliscreens[4], c64->fliscreens[5], c64->fliscreens[6], c64->fliscreens[7]);
+  for (i = 0; i < 8; i++)
+  {
+    if (c64->fliscreens[i] != 0)
+      count++;
+    if (c64->fliscreens[i] < screen_min)
+      screen_min = c64->fliscreens[i];
+  }
+  if (count > 1)
+  {
+    GFX2_Log(GFX2_INFO, "FLI MODE DETECTED\n");
+    c64->vicmode |= C64_VICMODE_FLI;
+  }
+  c64->bitmap = c64->screen = ((c64->ram[0xdd00] & 3) ^ 3) << 14;
+  c64->bitmap += (c64->ram[0xd018] & 0x0f) << 10;
+  c64->bitmap &= ((c64->ram[0xd011] & 0x20) ? 0xe000 : 0xf800);
+  if (c64->vicmode & C64_VICMODE_FLI)
+    c64->screen += screen_min << 10;
+  else
+    c64->screen += (c64->ram[0xd018] & 0xf0) << 6;
+  GFX2_Log(GFX2_DEBUG, "$D018=$%02x bitmap at $%04x, screen at $%04x\n",
+           c64->ram[0xd018], c64->bitmap, c64->screen);
+  return 1;
+}

src/c64load.h

@@ -0,0 +1,54 @@
+/* vim:expandtab:ts=2 sw=2:
+*/
+/*  Grafx2 - The Ultimate 256-color bitmap paint program
+
+    Copyright 2018-2019 Thomas Bernard
+    Copyright 2011 Pawel Góralski
+    Copyright 2009 Petter Lindquist
+    Copyright 2008 Yves Rizoud
+    Copyright 2008 Franck Charlet
+    Copyright 2007-2011 Adrien Destugues
+    Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud)
+
+    Grafx2 is free software; you can redistribute it and/or
+    modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; version 2
+    of the License.
+
+    Grafx2 is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Grafx2; if not, see <http://www.gnu.org/licenses/>
+*/
+
+///@file c64load.h
+
+#ifndef C64LOAD_H_INCLUDED
+#define C64LOAD_H_INCLUDED
+
+#define C64_VICMODE_MULTI  0x10
+#define C64_VICMODE_TEXT   0x00
+#define C64_VICMODE_BITMAP 0x20
+#define C64_VICMODE_EXTBKG 0x40
+#define C64_VICMODE_FLI    0x80
+
+struct c64state {
+  void * cpu;
+  byte * ram;
+  word screen;
+  word bitmap;
+  word keyjoyread;
+  word irqrasterline;
+  byte fliscreens[8];
+  byte backgrounds[200];
+  byte vicmode;
+};
+
+word C64_isBinaryProgram(FILE * f);
+int C64_LoadPrg(struct c64state * c64, const byte * prg, long prg_size, word start);
+
+#endif
+

src/miscfileformats.c

@@ -53,6 +53,7 @@
 #include "struct.h"
 #include "windows.h"
 #include "oldies.h"
+#include "c64load.h"
 #include "pages.h"
 #include "keycodes.h"
 #include "input.h"
@@ -2724,7 +2725,19 @@ void Test_C64(T_IO_Context * context, FILE * file)
       File_error = 0;
       break;
     default: // then we don't know for now.
-      if (load_addr == 0x6000 || load_addr == 0x5c00)
+      if (load_addr == 0x801)
+      {
+        // 6502 emulators :
+        // https://github.com/redcode/6502
+        // http://rubbermallet.org/fake6502.c
+        // https://github.com/jamestn/cpu6502
+        // https://github.com/dennis-chen/6502-Emu
+        // https://github.com/DavidBuchanan314/6502-emu
+        // basic program
+        if (C64_isBinaryProgram(file) != 0)
+          File_error = 0;
+      }
+      else if (load_addr == 0x6000 || load_addr == 0x5c00)
       {
         long unpacked_size;
         byte * buffer = GFX2_malloc(file_size);
@@ -3134,17 +3147,20 @@ static long C64_unpack_doodle(byte ** file_buffer, long file_size)
  */
 void Load_C64(T_IO_Context * context)
 {
+    int prg_loaded = 0;
     FILE* file;
     long file_size;
     byte hasLoadAddr=0;
     word load_addr;
     enum c64_format loadFormat = F_invalid;
+    struct c64state c64;
 
     byte *file_buffer;
     byte *bitmap, *screen_ram, *color_ram=NULL, *background=NULL; // Only pointers to existing data
     byte *temp_buffer = NULL;
     word width, height=200;
 
+    memset(&c64, 0, sizeof(c64));
     file = Open_file_read(context);
 
     if (file)
@@ -3167,11 +3183,40 @@ void Load_C64(T_IO_Context * context)
             fclose(file);
             return;
         }
-        fclose(file);
 
         // get load address (valid only if hasLoadAddr = 1)
         load_addr = file_buffer[0] | (file_buffer[1] << 8);
 
+        if (load_addr == 0x801)
+        {
+          word start_addr = C64_isBinaryProgram(file);
+          if (start_addr != 0)
+          {
+            prg_loaded = C64_LoadPrg(&c64, file_buffer, file_size, start_addr);
+            if (prg_loaded)
+            {
+              background = c64.ram + 0xd021;
+              if (c64.vicmode & C64_VICMODE_FLI)
+              {
+                loadFormat = F_fli;
+                background = c64.backgrounds;
+              }
+              else if (c64.vicmode & C64_VICMODE_MULTI)
+                loadFormat = F_multi;
+              else
+                loadFormat = F_hires;
+
+              hasLoadAddr = 1;
+              bitmap = c64.ram + c64.bitmap;
+              screen_ram = c64.ram + c64.screen;
+              color_ram = c64.ram + 0xd800;
+            }
+          }
+        }
+        fclose(file);
+
+        if (!prg_loaded)
+        {
           // Unpack if needed
           if (memcmp(file_buffer + 2, "DRAZPAINT", 9) == 0)
             file_size = C64_unpack_draz(&file_buffer, file_size);
@@ -3432,6 +3477,7 @@ void Load_C64(T_IO_Context * context)
                 free(file_buffer);
                 return;
           }
+        }
 
         if (loadFormat == F_invalid)
         {
@@ -3484,6 +3530,8 @@ void Load_C64(T_IO_Context * context)
         free(file_buffer);
         if (temp_buffer)
           free(temp_buffer);
+        if (c64.ram)
+          free(c64.ram);
     }
     else
         File_error = 1;