ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/Frodo4/Src/1541d64.h
(Generate patch)

Comparing Frodo4/Src/1541d64.h (file contents):
Revision 1.2 by cebix, 2003-07-01T17:51:17Z vs.
Revision 1.8 by cebix, 2005-06-27T19:55:48Z

# Line 1 | Line 1
1   /*
2 < *  1541d64.h - 1541 emulation in .d64 file
2 > *  1541d64.h - 1541 emulation in disk image files (.d64/.x64/zipcode)
3   *
4 < *  Frodo (C) 1994-1997,2002-2003 Christian Bauer
4 > *  Frodo (C) 1994-1997,2002-2005 Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 24 | Line 24
24   #include "IEC.h"
25  
26  
27 < // BAM structure
28 < typedef struct {
29 <        uint8   dir_track;              // Track...
30 <        uint8   dir_sector;             // ...and sector of first directory block
31 <        int8    fmt_type;               // Format type
32 <        int8    pad0;
33 <        uint8   bitmap[4*35];   // Sector allocation
34 <        uint8   disk_name[18];  // Disk name
35 <        uint8   id[2];                  // Disk ID
36 <        int8    pad1;
37 <        uint8   fmt_char[2];    // Format characters
38 <        int8    pad2[4];
39 <        int8    pad3[85];
40 < } BAM;
41 <
42 < // Directory entry structure
43 < typedef struct {
44 <        uint8   type;                   // File type
45 <        uint8   track;                  // Track...
46 <        uint8   sector;                 // ...and sector of first data block
47 <        uint8   name[16];               // File name
48 <        uint8   side_track;             // Track...
49 <        uint8   side_sector;    // ...and sector of first side sector
50 <        uint8   rec_len;                // Record length
51 <        int8    pad0[4];
52 <        uint8   ovr_track;              // Track...
53 <        uint8   ovr_sector;             // ...and sector on overwrite
54 <        uint8   num_blocks_l;   // Number of blocks, LSB
55 <        uint8   num_blocks_h;   // Number of blocks, MSB
56 <        int8    pad1[2];
57 < } DirEntry;
58 <
59 < // Directory block structure
60 < typedef struct {
61 <        uint8           padding[2];             // Keep DirEntry word-aligned
62 <        uint8           next_track;
63 <        uint8           next_sector;
64 <        DirEntry        entry[8];
65 < } Directory;
27 > /*
28 > *  Definitions
29 > */
30  
31 + // Constants
32 + const int NUM_SECTORS_35 = 683; // Number of sectors in a 35-track image
33 + const int NUM_SECTORS_40 = 768; // Number of sectors in a 40-track image
34 +
35 + // Disk image types
36 + enum {
37 +        TYPE_D64,                       // D64 file
38 +        TYPE_ED64,                      // Converted zipcode file (D64 with header ID)
39 +        TYPE_X64                        // x64 file
40 + };
41 +
42 + // Channel descriptor
43 + struct channel_desc {
44 +        int mode;                       // Channel mode
45 +        bool writing;           // Flag: writing to file (for file channels)
46 +        int buf_num;            // Buffer number for direct access and file channels
47 +        uint8 *buf;                     // Pointer to start of buffer
48 +        uint8 *buf_ptr;         // Pointer to current position in buffer
49 +        int buf_len;            // Remaining bytes in buffer
50 +        int track, sector;      // Track and sector the buffer will be written to (for writing to file channels)
51 +        int num_blocks;         // Number of blocks in file (for writing to file channels)
52 +        int dir_track;          // Track...
53 +        int dir_sector;         // ...and sector of directory block containing file entry
54 +        int entry;                      // Number of entry in directory block
55 + };
56  
57 < class D64Drive : public Drive {
57 > // Disk image file descriptor
58 > struct image_file_desc {
59 >        int type;                               // See definitions above
60 >        int header_size;                // Size of file header
61 >        int num_tracks;                 // Number of tracks
62 >        uint8 id1, id2;                 // Block header ID (as opposed to BAM ID)
63 >        uint8 error_info[NUM_SECTORS_40]; // Sector error information (1 byte/sector)
64 >        bool has_error_info;    // Flag: error info present in file
65 > };
66 >
67 > // Disk image drive class
68 > class ImageDrive : public Drive {
69   public:
70 <        D64Drive(IEC *iec, char *filepath);
71 <        virtual ~D64Drive();
72 <        virtual uint8 Open(int channel, char *filename);
70 >        ImageDrive(IEC *iec, const char *filepath);
71 >        virtual ~ImageDrive();
72 >
73 >        virtual uint8 Open(int channel, const uint8 *name, int name_len);
74          virtual uint8 Close(int channel);
75 <        virtual uint8 Read(int channel, uint8 *byte);
75 >        virtual uint8 Read(int channel, uint8 &byte);
76          virtual uint8 Write(int channel, uint8 byte, bool eoi);
77          virtual void Reset(void);
78  
79   private:
80 <        void open_close_d64_file(char *d64name);
81 <        uint8 open_file(int channel, char *filename);
82 <        void convert_filename(char *srcname, char *destname, int *filemode, int *filetype);
83 <        bool find_file(char *filename, int *track, int *sector);
80 >        void close_image(void);
81 >        bool change_image(const char *path);
82 >
83 >        uint8 open_file(int channel, const uint8 *name, int name_len);
84          uint8 open_file_ts(int channel, int track, int sector);
85 <        uint8 open_directory(char *pattern);
86 <        uint8 open_direct(int channel, char *filename);
87 <        void close_all_channels();
88 <        void execute_command(char *command);
89 <        void block_read_cmd(char *command);
89 <        void buffer_ptr_cmd(char *command);
90 <        bool parse_bcmd(char *cmd, int *arg1, int *arg2, int *arg3, int *arg4);
91 <        void chd64_cmd(char *d64name);
85 >        uint8 create_file(int channel, const uint8 *name, int name_len, int type, bool overwrite = false);
86 >        uint8 open_directory(const uint8 *pattern, int pattern_len);
87 >        uint8 open_direct(int channel, const uint8 *filename);
88 >        void close_all_channels(void);
89 >
90          int alloc_buffer(int want);
91          void free_buffer(int buf);
94        bool read_sector(int track, int sector, uint8 *buffer);
95        int offset_from_ts(int track, int sector);
96        uint8 conv_from_64(uint8 c, bool map_slash);
92  
93 <        char orig_d64_name[256]; // Original path of .d64 file
93 >        bool find_file(const uint8 *pattern, int pattern_len, int &dir_track, int &dir_sector, int &entry, bool cont);
94 >        bool find_first_file(const uint8 *pattern, int pattern_len, int &dir_track, int &dir_sector, int &entry);
95 >        bool find_next_file(const uint8 *pattern, int pattern_len, int &dir_track, int &dir_sector, int &entry);
96 >        bool alloc_dir_entry(int &track, int &sector, int &entry);
97 >
98 >        bool is_block_free(int track, int sector);
99 >        int num_free_blocks(int track);
100 >        int alloc_block(int track, int sector);
101 >        int free_block(int track, int sector);
102 >        bool alloc_block_chain(int track, int sector);
103 >        bool free_block_chain(int track, int sector);
104 >        bool alloc_next_block(int &track, int &sector, int interleave);
105 >
106 >        bool read_sector(int track, int sector, uint8 *buffer);
107 >        bool write_sector(int track, int sector, uint8 *buffer);
108 >        void write_error_info(void);
109  
110 <        FILE *the_file;                 // File pointer for .d64 file
110 >        virtual void block_read_cmd(int channel, int track, int sector, bool user_cmd = false);
111 >        virtual void block_write_cmd(int channel, int track, int sector, bool user_cmd = false);
112 >        virtual void block_allocate_cmd(int track, int sector);
113 >        virtual void block_free_cmd(int track, int sector);
114 >        virtual void buffer_pointer_cmd(int channel, int pos);
115 >        virtual void mem_read_cmd(uint16 adr, uint8 len);
116 >        virtual void mem_write_cmd(uint16 adr, uint8 len, uint8 *p);
117 >        virtual void copy_cmd(const uint8 *new_file, int new_file_len, const uint8 *old_files, int old_files_len);
118 >        virtual void rename_cmd(const uint8 *new_file, int new_file_len, const uint8 *old_file, int old_file_len);
119 >        virtual void scratch_cmd(const uint8 *files, int files_len);
120 >        virtual void initialize_cmd(void);
121 >        virtual void new_cmd(const uint8 *name, int name_len, const uint8 *comma);
122 >        virtual void validate_cmd(void);
123 >
124 >        FILE *the_file;                 // File pointer for image file
125 >        image_file_desc desc;   // Image file descriptor
126 >        bool write_protected;   // Flag: image file write-protected
127 >
128 >        uint8 ram[0x800];               // 2k 1541 RAM
129 >        uint8 dir[258];                 // Buffer for directory blocks
130 >        uint8 *bam;                             // Pointer to BAM in 1541 RAM (buffer 4, upper 256 bytes)
131 >        bool bam_dirty;                 // Flag: BAM modified, needs to be written back
132  
133 <        uint8 *ram;                             // 2KB 1541 RAM
134 <        BAM *bam;                               // Pointer to BAM
135 <        Directory dir;                  // Buffer for directory blocks
133 >        channel_desc ch[18];    // Descriptors for channels 0..17 (16 = internal read, 17 = internal write)
134 >        bool buf_free[4];               // Flags: buffer 0..3 free?
135 > };
136  
106        int chan_mode[16];              // Channel mode
107        int chan_buf_num[16];   // Buffer number of channel (for direct access channels)
108        uint8 *chan_buf[16];    // Pointer to buffer
109        uint8 *buf_ptr[16];             // Pointer in buffer
110        int buf_len[16];                // Remaining bytes in buffer
137  
138 <        bool buf_free[4];               // Buffer 0..3 free?
138 > /*
139 > *  Functions
140 > */
141  
142 <        char cmd_buffer[44];    // Buffer for incoming command strings
143 <        int cmd_len;                    // Length of received command
142 > // Check whether file with given header (64 bytes) and size looks like one
143 > // of the file types supported by this module
144 > extern bool IsImageFile(const char *path, const uint8 *header, long size);
145  
146 <        int image_header;               // Length of .d64 file header
146 > // Read directory of disk image file into (empty) c64_dir_entry vector
147 > extern bool ReadImageDirectory(const char *path, vector<c64_dir_entry> &vec);
148  
149 <        uint8 error_info[683];  // Sector error information (1 byte/sector)
150 < };
149 > // Create new blank disk image file
150 > extern bool CreateImageFile(const char *path);
151  
152   #endif

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines