src/mess/formats/flopimg.h
| r5798 | r5799 | |
| 78 | 78 | const char *param_guidelines; |
| 79 | 79 | }; |
| 80 | 80 | |
| 81 | #define FLOPPY_IDENTIFY(name) floperr_t name(floppy_image *floppy, const struct FloppyFormat *format, int *vote) |
| 82 | #define FLOPPY_CONSTRUCT(name) floperr_t name(floppy_image *floppy, const struct FloppyFormat *format, option_resolution *params) |
| 81 | 83 | |
| 84 | FLOPPY_IDENTIFY(td0_dsk_identify); |
| 85 | FLOPPY_CONSTRUCT(td0_dsk_construct); |
| 86 | |
| 82 | 87 | #define FLOPPY_OPTIONS_NAME(name) floppyoptions_##name |
| 83 | 88 | |
| 84 | 89 | #define FLOPPY_OPTIONS_START(name) \ |
| 85 | 90 | const struct FloppyFormat floppyoptions_##name[] = \ |
| 86 | 91 | { \ |
| 87 | 92 | |
| 88 | | #define FLOPPY_OPTIONS_END \ |
| 89 | | { NULL } \ |
| 90 | | }; |
| 91 | 93 | |
| 92 | 94 | #define FLOPPY_OPTIONS_EXTERN(name) \ |
| 93 | 95 | extern const struct FloppyFormat floppyoptions_##name[] \ |
| r5798 | r5799 | |
| 95 | 97 | #define FLOPPY_OPTION(name, extensions_, description_, identify_, construct_, ranges_)\ |
| 96 | 98 | { #name, extensions_, description_, identify_, construct_, ranges_ }, \ |
| 97 | 99 | |
| 100 | #define FLOPPY_OPTIONS_END \ |
| 101 | FLOPPY_OPTION( td0, "td0", "TD0 floppy disk image", td0_dsk_identify, td0_dsk_construct, NULL) \ |
| 102 | { NULL } \ |
| 103 | }; |
| 98 | 104 | |
| 105 | |
| 99 | 106 | #define PARAM_END '\0' |
| 100 | 107 | #define PARAM_HEADS 'H' |
| 101 | 108 | #define PARAM_TRACKS 'T' |
| r5798 | r5799 | |
| 111 | 118 | #define INTERLEAVE(range) "I" #range |
| 112 | 119 | #define FIRST_SECTOR_ID(range) "F" #range |
| 113 | 120 | |
| 114 | | #define FLOPPY_IDENTIFY(name) floperr_t name(floppy_image *floppy, const struct FloppyFormat *format, int *vote) |
| 115 | | #define FLOPPY_CONSTRUCT(name) floperr_t name(floppy_image *floppy, const struct FloppyFormat *format, option_resolution *params) |
| 116 | 121 | |
| 117 | 122 | /*************************************************************************** |
| 118 | 123 | |
src/mess/formats/td0_dsk.c
| r0 | r5799 | |
| 1 | /********************************************************************* |
| 2 | |
| 3 | formats/td0_dsk.c |
| 4 | |
| 5 | TD0 disk images |
| 6 | |
| 7 | *********************************************************************/ |
| 8 | |
| 9 | #include <string.h> |
| 10 | #include "driver.h" |
| 11 | #include "formats/dsk_dsk.h" |
| 12 | #include "devices/flopdrv.h" |
| 13 | |
| 14 | #define TD0_DSK_TAG "td0tag" |
| 15 | |
| 16 | struct td0dsk_tag |
| 17 | { |
| 18 | int heads; |
| 19 | int tracks; |
| 20 | int sector_size; |
| 21 | UINT64 track_offsets[84*2]; /* offset within data for each track */ |
| 22 | }; |
| 23 | |
| 24 | |
| 25 | static struct td0dsk_tag *get_tag(floppy_image *floppy) |
| 26 | { |
| 27 | struct td0dsk_tag *tag; |
| 28 | tag = floppy_tag(floppy, TD0_DSK_TAG); |
| 29 | return tag; |
| 30 | } |
| 31 | |
| 32 | |
| 33 | |
| 34 | FLOPPY_IDENTIFY( td0_dsk_identify ) |
| 35 | { |
| 36 | UINT8 header[2]; |
| 37 | |
| 38 | floppy_image_read(floppy, header, 0, 2); |
| 39 | if (header[0]=='T' && header[1]=='D') { |
| 40 | *vote = 100; |
| 41 | } else { |
| 42 | *vote = 0; |
| 43 | } |
| 44 | return FLOPPY_ERROR_SUCCESS; |
| 45 | } |
| 46 | |
| 47 | static int td0_get_heads_per_disk(floppy_image *floppy) |
| 48 | { |
| 49 | return get_tag(floppy)->heads; |
| 50 | } |
| 51 | |
| 52 | static int td0_get_tracks_per_disk(floppy_image *floppy) |
| 53 | { |
| 54 | return get_tag(floppy)->tracks; |
| 55 | } |
| 56 | |
| 57 | static UINT64 td0_get_track_offset(floppy_image *floppy, int head, int track) |
| 58 | { |
| 59 | return get_tag(floppy)->track_offsets[(track<<1) + head]; |
| 60 | } |
| 61 | |
| 62 | static floperr_t get_offset(floppy_image *floppy, int head, int track, int sector, int sector_is_index, UINT64 *offset) |
| 63 | { |
| 64 | UINT64 offs; |
| 65 | UINT8 header[8]; |
| 66 | UINT8 sectors_per_track; |
| 67 | int i; |
| 68 | |
| 69 | if ((head < 0) || (head >= get_tag(floppy)->heads) || (track < 0) || (track >= get_tag(floppy)->tracks) |
| 70 | || (sector < 0) ) |
| 71 | return FLOPPY_ERROR_SEEKERROR; |
| 72 | |
| 73 | // position on begining of track data |
| 74 | offs = td0_get_track_offset(floppy, head, track); |
| 75 | |
| 76 | // read track header |
| 77 | floppy_image_read(floppy, header, offs - 4, 4); |
| 78 | |
| 79 | // take number of sectors per track |
| 80 | sectors_per_track = header[0]; |
| 81 | |
| 82 | if (!sector_is_index) { |
| 83 | // when taking ID's return seek error if number is over counter |
| 84 | if (sector > sectors_per_track) { |
| 85 | return FLOPPY_ERROR_SEEKERROR; |
| 86 | } |
| 87 | } |
| 88 | |
| 89 | // move trought sectors |
| 90 | for(i=0;i < sector-1;i++) { |
| 91 | floppy_image_read(floppy, header, offs, 6); |
| 92 | offs+= 6; |
| 93 | floppy_image_read(floppy, header+6, offs, 2); |
| 94 | offs+= 2; |
| 95 | offs+= header[6] + (header[7]<<8); |
| 96 | } |
| 97 | // read size of sector |
| 98 | floppy_image_read(floppy, header, offs, 6); |
| 99 | get_tag(floppy)->sector_size = 1 << (header[3] + 7); |
| 100 | |
| 101 | if (offset) |
| 102 | *offset = offs; |
| 103 | return FLOPPY_ERROR_SUCCESS; |
| 104 | } |
| 105 | |
| 106 | |
| 107 | |
| 108 | static floperr_t internal_td0_read_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, void *buffer, size_t buflen) |
| 109 | { |
| 110 | UINT64 offset; |
| 111 | floperr_t err; |
| 112 | UINT8 header[9]; |
| 113 | int size,realsize,i; |
| 114 | int buff_pos; |
| 115 | int data_pos; |
| 116 | UINT8 *data; |
| 117 | UINT8 *buf; |
| 118 | |
| 119 | buf = (UINT8*)buffer; |
| 120 | // take sector offset |
| 121 | err = get_offset(floppy, head, track, sector, sector_is_index, &offset); |
| 122 | if (err) |
| 123 | return err; |
| 124 | |
| 125 | // read sector header |
| 126 | floppy_image_read(floppy, header, offset, 6); |
| 127 | offset+=6; |
| 128 | floppy_image_read(floppy, header+6, offset, 3); |
| 129 | offset+=3; |
| 130 | // take data size |
| 131 | size = header[6] + (header[7]<<8)-1; |
| 132 | // take real sector size |
| 133 | realsize = 1 << (header[3] + 7); |
| 134 | |
| 135 | data = malloc(size); |
| 136 | // read sector data |
| 137 | floppy_image_read(floppy, data, offset, size); |
| 138 | |
| 139 | buff_pos = 0; |
| 140 | data_pos = 0; |
| 141 | |
| 142 | switch(header[8]) { |
| 143 | case 0: |
| 144 | // encoding type 0 |
| 145 | // - plain data |
| 146 | memcpy(buffer,data,size); |
| 147 | break; |
| 148 | case 1: |
| 149 | // encoding type 1 |
| 150 | // - 2 bytes size |
| 151 | // - 2 bytes of data |
| 152 | // data is reapeted specified number of times |
| 153 | while(buff_pos<realsize) { |
| 154 | for (i=0;i<data[data_pos]+(data[data_pos+1] << 8);i++) { |
| 155 | buf[buff_pos] = data[data_pos+2];buff_pos++; |
| 156 | buf[buff_pos] = data[data_pos+3];buff_pos++; |
| 157 | } |
| 158 | data_pos+=4; |
| 159 | } |
| 160 | break; |
| 161 | case 2: |
| 162 | // encoding type 2 |
| 163 | // - if first byte is zero next byte represent size of |
| 164 | // plain data after it |
| 165 | // - if different then zero when multiply by 2 represent |
| 166 | // size of data that should be reapeted next byte times |
| 167 | while(buff_pos<realsize) { |
| 168 | if (data[data_pos]==0x00) { |
| 169 | int size = data[data_pos+1]; |
| 170 | memcpy(buf+buff_pos,data + data_pos + 2,size); |
| 171 | data_pos += 2 + size; |
| 172 | buff_pos += size; |
| 173 | } else { |
| 174 | int size = 2*data[data_pos]; |
| 175 | int repeat = data[data_pos+1]; |
| 176 | data_pos+=2; |
| 177 | |
| 178 | for (i=0;i<repeat;i++) { |
| 179 | memcpy(buf + buff_pos,data + data_pos,size); |
| 180 | buff_pos += size; |
| 181 | } |
| 182 | data_pos += size; |
| 183 | } |
| 184 | } |
| 185 | break; |
| 186 | default: |
| 187 | free(data); |
| 188 | return FLOPPY_ERROR_INTERNAL; |
| 189 | break; |
| 190 | } |
| 191 | free(data); |
| 192 | return FLOPPY_ERROR_SUCCESS; |
| 193 | } |
| 194 | |
| 195 | |
| 196 | static floperr_t td0_read_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen) |
| 197 | { |
| 198 | return internal_td0_read_sector(floppy, head, track, sector, FALSE, buffer, buflen); |
| 199 | } |
| 200 | |
| 201 | static floperr_t td0_read_indexed_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen) |
| 202 | { |
| 203 | return internal_td0_read_sector(floppy, head, track, sector, TRUE, buffer, buflen); |
| 204 | } |
| 205 | |
| 206 | static floperr_t td0_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length) |
| 207 | { |
| 208 | floperr_t err; |
| 209 | err = get_offset(floppy, head, track, sector, FALSE, NULL); |
| 210 | if (err) |
| 211 | return err; |
| 212 | |
| 213 | if (sector_length) { |
| 214 | *sector_length = get_tag(floppy)->sector_size; |
| 215 | } |
| 216 | return FLOPPY_ERROR_SUCCESS; |
| 217 | } |
| 218 | |
| 219 | static floperr_t td0_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length, unsigned long *flags) |
| 220 | { |
| 221 | floperr_t retVal; |
| 222 | UINT64 offset; |
| 223 | UINT8 sector_info[9]; |
| 224 | |
| 225 | retVal = get_offset(floppy, head, track, sector_index, FALSE, &offset); |
| 226 | |
| 227 | floppy_image_read(floppy, sector_info, offset, 9); |
| 228 | if (cylinder) |
| 229 | *cylinder = sector_info[0]; |
| 230 | if (side) |
| 231 | *side = sector_info[1]; |
| 232 | if (sector) |
| 233 | *sector = sector_info[2]; |
| 234 | if (sector_length) { |
| 235 | *sector_length = 1 << (sector_info[3] + 7); |
| 236 | } |
| 237 | if (flags) |
| 238 | *flags = 0; |
| 239 | return retVal; |
| 240 | } |
| 241 | |
| 242 | |
| 243 | FLOPPY_CONSTRUCT( td0_dsk_construct ) |
| 244 | { |
| 245 | struct FloppyCallbacks *callbacks; |
| 246 | struct td0dsk_tag *tag; |
| 247 | UINT8 header[16]; |
| 248 | int number_of_sectors; |
| 249 | int position; |
| 250 | int i; |
| 251 | int track; |
| 252 | |
| 253 | floppy_image_read(floppy, header, 0, 16); |
| 254 | |
| 255 | tag = (struct td0dsk_tag *) floppy_create_tag(floppy, TD0_DSK_TAG, sizeof(struct td0dsk_tag)); |
| 256 | if (!tag) |
| 257 | return FLOPPY_ERROR_OUTOFMEMORY; |
| 258 | |
| 259 | tag->heads = header[9]; |
| 260 | if (tag->heads > 1) { |
| 261 | tag->heads = 2; |
| 262 | } |
| 263 | |
| 264 | // header len + comment header + comment len |
| 265 | position = 12 + 10 + header[14] + (header[15]<<8); |
| 266 | tag->tracks = 0; |
| 267 | |
| 268 | do { |
| 269 | // read track header |
| 270 | floppy_image_read(floppy, header, position, 4); |
| 271 | track = header[1]; |
| 272 | number_of_sectors = header[0]; |
| 273 | if (number_of_sectors!=0xff){ |
| 274 | position+=4; |
| 275 | tag->track_offsets[(track<<1) + header[2]] = position; |
| 276 | for(i=0;i<number_of_sectors;i++) { |
| 277 | // read sector header |
| 278 | floppy_image_read(floppy, header, position, 6); |
| 279 | position+=6; |
| 280 | // read sector size |
| 281 | floppy_image_read(floppy, header, position, 2); |
| 282 | position+=2; |
| 283 | // skip sector data |
| 284 | position+= header[0] + (header[1]<<8); |
| 285 | } |
| 286 | tag->tracks++; |
| 287 | } |
| 288 | } while(number_of_sectors!=0xff); |
| 289 | tag->tracks++; |
| 290 | |
| 291 | callbacks = floppy_callbacks(floppy); |
| 292 | callbacks->read_sector = td0_read_sector; |
| 293 | callbacks->read_indexed_sector = td0_read_indexed_sector; |
| 294 | callbacks->get_sector_length = td0_get_sector_length; |
| 295 | callbacks->get_heads_per_disk = td0_get_heads_per_disk; |
| 296 | callbacks->get_tracks_per_disk = td0_get_tracks_per_disk; |
| 297 | callbacks->get_indexed_sector_info = td0_get_indexed_sector_info; |
| 298 | return FLOPPY_ERROR_SUCCESS; |
| 299 | } |
| 300 | |