home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / programs / emulaton / at2600 / !v2600 / c / files < prev    next >
Text File  |  1998-08-05  |  6KB  |  250 lines
  1. /****************************************************************************
  2.  
  3.    This file is part of x2600, the Atari 2600 Emulator
  4.    ===================================================
  5.  
  6.    Copyright 1996 Alex Hornby. For contributions see the file CREDITS.
  7.  
  8.    This software is distributed under the terms of the GNU General Public
  9.    License. This is free software with ABSOLUTELY NO WARRANTY.
  10.  
  11.    See the file COPYING for details.
  12.  
  13.    $Id: files.c,v 1.18 1997/02/23 20:39:29 ahornby Exp $
  14. ****************************************************************************/
  15.  
  16. /*
  17.    Used to load cartridge images into memory.
  18.  */
  19.  
  20. #include "config.h"
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include "options.h"
  25. #include "types.h"
  26. #include "vmachine.h"
  27. #include "c26def.h"
  28. #include "okie.h"
  29. #include "hawklib.h"
  30.  
  31. extern Window *gameinfo_window;
  32.  
  33. /* Return the size of the file pointed to by fp */
  34. /* Avoids need for UNIX type stat, leaves file */
  35. /* pointer untouched. */
  36. long filesize (FILE * fp){
  37.   long curpos, length;
  38.   curpos = ftell (fp);
  39.   fseek (fp, 0L, SEEK_END);
  40.   length = ftell (fp);
  41.   fseek (fp, curpos, SEEK_SET);
  42.   return length;
  43. }
  44.  
  45. /* Load from the common 2600 format */
  46. /* Uses the tag structure from c26def.h */
  47. int
  48. loadc26 (FILE * fp, long flen)
  49. {
  50.   char databuf[65535];
  51.   struct c26_tag tag;
  52.  
  53.   while (fread (&tag, sizeof (struct c26_tag), 1, fp))
  54.     {
  55.       /* If positive then it has a data block */
  56.       if (tag.type >= 0)
  57.     {
  58.       if (!fread (databuf, sizeof (BYTE), tag.len, fp))
  59.         {
  60.           hl_error("v2600 loadc26: Error reading data.");
  61.         }
  62.     }
  63.  
  64.       switch (tag.type)
  65.     {
  66.  
  67.     case CARTNAME:
  68.       hl_set_icon_text(gameinfo_window, 0, databuf, 0);
  69.           break;
  70.  
  71.     case CARTMAN:
  72.       hl_set_icon_text(gameinfo_window, 2, databuf, 0);
  73.           break;
  74.  
  75.         case CARTAUTHOR:
  76.       hl_set_icon_text(gameinfo_window, 4, databuf, 0);
  77.           break;
  78.  
  79.         case CARTSERIAL:
  80.       hl_set_icon_text(gameinfo_window, 6, databuf, 0);
  81.           break;
  82.  
  83.     case TVTYPE:
  84.       base_opts.tvtype = tag.len;
  85.       switch (base_opts.tvtype){
  86.             case NTSC:
  87.               hl_set_icon_text(gameinfo_window, 8, "NTSC", 0);
  88.               break;
  89.             case PAL:
  90.             case SECAM:
  91.             default:
  92.               hl_set_icon_text(gameinfo_window, 8, "PAL/SECAM", 0);
  93.               break;
  94.           }
  95.       break;
  96.  
  97.     case CONTROLLERS:
  98.       /* Higher byte */
  99.       base_opts.lcon = (tag.len & 0xff00)>>8;
  100.       /* Low byte */
  101.       base_opts.rcon = (tag.len) & 0xff;
  102.  
  103.     case BANKING:
  104.       base_opts.bank = tag.len;
  105.       break;
  106.  
  107.     case DATA:
  108.       if (tag.len <= 16384)
  109.         memcpy (&theCart[0], databuf, tag.len);
  110.       else
  111.         {
  112.           hl_error("Data larger that 16k!");
  113.           exit (-1);
  114.         }
  115.       rom_size = tag.len;
  116.       if (tag.len == 2048)
  117.         {
  118.           memcpy (&theCart[0], databuf, tag.len);
  119.           memcpy (&theCart[2048], databuf, tag.len);
  120.         }
  121.       break;
  122.  
  123.     default:
  124.       hl_error("Unknown tag. Ignoring.");
  125.       break;
  126.     }
  127.     }
  128.   return 0;
  129. }
  130.  
  131. /* Load a raw binary image  */
  132. /* fp: file stream to load */
  133. /* stat_data: unix stat structure for file pointed to by fp */
  134. /* returns: size of file loaded */
  135. int
  136. loadRaw (FILE * fp, long flen)
  137. {
  138.   int size = (int)flen;
  139.  
  140.   if (size > 16384)
  141.     size = 16384;
  142.   fread (theCart, sizeof (BYTE), size, fp);
  143.  
  144.   rom_size = size;
  145.   if (size == 2048)
  146.     {
  147.       memcpy (&theCart[2048], &theCart[0], 2048);
  148.       rom_size = 4096;
  149.     }
  150.   else if (size < 2048)
  151.     {
  152.       theCart[0x0ffc] = 0x00;
  153.       theCart[0x0ffd] = 0xf0;
  154.       rom_size = 4096;
  155.     }
  156.  
  157.   return size;
  158. }
  159.  
  160. /* Load a default game */
  161. void
  162. load_okie_dokie(void)
  163. {
  164.   memcpy (&theCart[0], &okie_dokie_data[0], 2048);
  165.   rom_size = 2048;
  166.   memcpy (&theCart[2048], &theCart[0], 2048);
  167.   rom_size = 4096;
  168. }
  169.  
  170. /* Load a commodore format .prg file  */
  171. /* fp: file stream to load */
  172. /* stat_data: unix stat structure for file pointed to by fp */
  173. /* returns: size of file loaded */
  174. int
  175. loadPrg (FILE * fp, long flen)
  176. {
  177.   int start;
  178.   int rompos;
  179.   int size;
  180.   unsigned char buf1, buf2;
  181.  
  182.   /* Get the load address */
  183.   fread (&buf1, sizeof (BYTE), 1, fp);
  184.   fread (&buf2, sizeof (BYTE), 1, fp);
  185.   start = buf2 * 256 + buf1;
  186.  
  187.   /* Translate the load address to a ROM address */
  188.   rompos = start & 0xfff;
  189.  
  190.   /* Get length of data part */
  191.   size = (int)flen - 2;
  192.  
  193.   /* Load the data */
  194.   fread (&theCart[rompos], sizeof (BYTE), size, fp);
  195.  
  196.   /* Put the load address into the reset vector */
  197.   theCart[0x0ffc] = buf1;
  198.   theCart[0x0ffd] = buf2;
  199.   return size;
  200. }
  201.  
  202. /* Load a cartridge image */
  203. /* name: filename to load */
  204. /* returns: -1 on error 0 otherwise  */
  205. int
  206. loadCart (void)
  207. {
  208.   FILE *fp;
  209.   char *ext;
  210.   int flen;
  211.   char *name = base_opts.filename;
  212.  
  213.   hl_set_icon_text(gameinfo_window, 0, "--", 0);
  214.   hl_set_icon_text(gameinfo_window, 2, "--", 0);
  215.   hl_set_icon_text(gameinfo_window, 4, "--", 0);
  216.   hl_set_icon_text(gameinfo_window, 6, "--", 0);
  217.   hl_set_icon_text(gameinfo_window, 8, "--", 0);
  218.  
  219.   if (name == NULL || strcmp("",name)==0)
  220.     {
  221.       hl_error("You should double click on a game ROM image to run !V2600.");
  222.       quit = 1; //load_okie_dokie();
  223.       return 0;
  224.     }
  225.  
  226.   fp = fopen (name, "rb");
  227.   if (!fp)
  228.     {
  229.       hl_error("Can't find file.");
  230.       return -1;
  231.     }
  232.  
  233.   flen = (int)filesize (fp);
  234.  
  235.   ext = strrchr (name, '/');
  236.   if (strcmp ("/pal", ext) == 0 || strcmp ("/vcs", ext) == 0 ||
  237.       strcmp ("/raw", ext) == 0 || strcmp ("/bin", ext) == 0 ||
  238.       strcmp ("/BIN", ext) == 0){
  239.     loadRaw (fp, flen);
  240.   }
  241.   else if (strcmp ("/prg", ext) == 0){
  242.     loadPrg (fp, flen);
  243.   }
  244.   else{
  245.     loadc26 (fp, flen);
  246.   }
  247.   fclose (fp);
  248.   return 0;
  249. }
  250.